imports

package
v0.0.0-...-48c8420 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 6, 2017 License: LGPL-3.0 Imports: 140 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var Packages = make(map[string]Package)

Functions

This section is empty.

Types

type AEAD_crypto_cipher 

type AEAD_crypto_cipher struct {
	Object     interface{}
	NonceSize_ func(interface{}) int
	Open_      func(_proxy_obj_ interface{}, dst []byte, nonce []byte, ciphertext []byte, additionalData []byte) ([]byte, error)
	Overhead_  func(interface{}) int
	Seal_      func(_proxy_obj_ interface{}, dst []byte, nonce []byte, plaintext []byte, additionalData []byte) []byte
}

--------------- proxy for crypto/cipher.AEAD ---------------

func (*AEAD_crypto_cipher) NonceSize 

func (Proxy *AEAD_crypto_cipher) NonceSize() int

func (*AEAD_crypto_cipher) Open 

func (Proxy *AEAD_crypto_cipher) Open(dst []byte, nonce []byte, ciphertext []byte, additionalData []byte) ([]byte, error)

func (*AEAD_crypto_cipher) Overhead 

func (Proxy *AEAD_crypto_cipher) Overhead() int

func (*AEAD_crypto_cipher) Seal 

func (Proxy *AEAD_crypto_cipher) Seal(dst []byte, nonce []byte, plaintext []byte, additionalData []byte) []byte

type Addr_net 

type Addr_net struct {
	Object   interface{}
	Network_ func(interface{}) string
	String_  func(interface{}) string
}

--------------- proxy for net.Addr ---------------

func (*Addr_net) Network 

func (Proxy *Addr_net) Network() string

func (*Addr_net) String 

func (Proxy *Addr_net) String() string

type Auth_net_smtp 

type Auth_net_smtp struct {
	Object interface{}
	Next_  func(_proxy_obj_ interface{}, fromServer []byte, more bool) (toServer []byte, err error)
	Start_ func(_proxy_obj_ interface{}, server *smtp.ServerInfo) (proto string, toServer []byte, err error)
}

--------------- proxy for net/smtp.Auth ---------------

func (*Auth_net_smtp) Next 

func (Proxy *Auth_net_smtp) Next(fromServer []byte, more bool) (toServer []byte, err error)

func (*Auth_net_smtp) Start 

func (Proxy *Auth_net_smtp) Start(server *smtp.ServerInfo) (proto string, toServer []byte, err error)

type BinaryMarshaler_encoding 

type BinaryMarshaler_encoding struct {
	Object         interface{}
	MarshalBinary_ func(interface{}) (data []byte, err error)
}

--------------- proxy for encoding.BinaryMarshaler ---------------

func (*BinaryMarshaler_encoding) MarshalBinary 

func (Proxy *BinaryMarshaler_encoding) MarshalBinary() (data []byte, err error)

type BinaryUnmarshaler_encoding 

type BinaryUnmarshaler_encoding struct {
	Object           interface{}
	UnmarshalBinary_ func(_proxy_obj_ interface{}, data []byte) error
}

--------------- proxy for encoding.BinaryUnmarshaler ---------------

func (*BinaryUnmarshaler_encoding) UnmarshalBinary 

func (Proxy *BinaryUnmarshaler_encoding) UnmarshalBinary(data []byte) error

type BlockMode_crypto_cipher 

type BlockMode_crypto_cipher struct {
	Object       interface{}
	BlockSize_   func(interface{}) int
	CryptBlocks_ func(_proxy_obj_ interface{}, dst []byte, src []byte)
}

--------------- proxy for crypto/cipher.BlockMode ---------------

func (*BlockMode_crypto_cipher) BlockSize 

func (Proxy *BlockMode_crypto_cipher) BlockSize() int

func (*BlockMode_crypto_cipher) CryptBlocks 

func (Proxy *BlockMode_crypto_cipher) CryptBlocks(dst []byte, src []byte)

type Block_crypto_cipher 

type Block_crypto_cipher struct {
	Object     interface{}
	BlockSize_ func(interface{}) int
	Decrypt_   func(_proxy_obj_ interface{}, dst []byte, src []byte)
	Encrypt_   func(_proxy_obj_ interface{}, dst []byte, src []byte)
}

--------------- proxy for crypto/cipher.Block ---------------

func (*Block_crypto_cipher) BlockSize 

func (Proxy *Block_crypto_cipher) BlockSize() int

func (*Block_crypto_cipher) Decrypt 

func (Proxy *Block_crypto_cipher) Decrypt(dst []byte, src []byte)

func (*Block_crypto_cipher) Encrypt 

func (Proxy *Block_crypto_cipher) Encrypt(dst []byte, src []byte)

type BufferPool_net_http_httputil 

type BufferPool_net_http_httputil struct {
	Object interface{}
	Get_   func(interface{}) []byte
	Put_   func(interface{}, []byte)
}

--------------- proxy for net/http/httputil.BufferPool ---------------

func (*BufferPool_net_http_httputil) Get 

func (Proxy *BufferPool_net_http_httputil) Get() []byte

func (*BufferPool_net_http_httputil) Put 

func (Proxy *BufferPool_net_http_httputil) Put(unnamed0 []byte)

type ByteOrder_encoding_binary 

type ByteOrder_encoding_binary struct {
	Object     interface{}
	PutUint16_ func(interface{}, []byte, uint16)
	PutUint32_ func(interface{}, []byte, uint32)
	PutUint64_ func(interface{}, []byte, uint64)
	String_    func(interface{}) string
	Uint16_    func(interface{}, []byte) uint16
	Uint32_    func(interface{}, []byte) uint32
	Uint64_    func(interface{}, []byte) uint64
}

--------------- proxy for encoding/binary.ByteOrder ---------------

func (*ByteOrder_encoding_binary) PutUint16 

func (Proxy *ByteOrder_encoding_binary) PutUint16(unnamed0 []byte, unnamed1 uint16)

func (*ByteOrder_encoding_binary) PutUint32 

func (Proxy *ByteOrder_encoding_binary) PutUint32(unnamed0 []byte, unnamed1 uint32)

func (*ByteOrder_encoding_binary) PutUint64 

func (Proxy *ByteOrder_encoding_binary) PutUint64(unnamed0 []byte, unnamed1 uint64)

func (*ByteOrder_encoding_binary) String 

func (Proxy *ByteOrder_encoding_binary) String() string

func (*ByteOrder_encoding_binary) Uint16 

func (Proxy *ByteOrder_encoding_binary) Uint16(unnamed0 []byte) uint16

func (*ByteOrder_encoding_binary) Uint32 

func (Proxy *ByteOrder_encoding_binary) Uint32(unnamed0 []byte) uint32

func (*ByteOrder_encoding_binary) Uint64 

func (Proxy *ByteOrder_encoding_binary) Uint64(unnamed0 []byte) uint64

type ByteReader_io 

type ByteReader_io struct {
	Object    interface{}
	ReadByte_ func(interface{}) (byte, error)
}

--------------- proxy for io.ByteReader ---------------

func (*ByteReader_io) ReadByte 

func (Proxy *ByteReader_io) ReadByte() (byte, error)

type ByteScanner_io 

type ByteScanner_io struct {
	Object      interface{}
	ReadByte_   func(interface{}) (byte, error)
	UnreadByte_ func(interface{}) error
}

--------------- proxy for io.ByteScanner ---------------

func (*ByteScanner_io) ReadByte 

func (Proxy *ByteScanner_io) ReadByte() (byte, error)

func (*ByteScanner_io) UnreadByte 

func (Proxy *ByteScanner_io) UnreadByte() error

type ByteWriter_io 

type ByteWriter_io struct {
	Object     interface{}
	WriteByte_ func(_proxy_obj_ interface{}, c byte) error
}

--------------- proxy for io.ByteWriter ---------------

func (*ByteWriter_io) WriteByte 

func (Proxy *ByteWriter_io) WriteByte(c byte) error

type ClientCodec_net_rpc 

type ClientCodec_net_rpc struct {
	Object              interface{}
	Close_              func(interface{}) error
	ReadResponseBody_   func(interface{}, interface{}) error
	ReadResponseHeader_ func(interface{}, *rpc.Response) error
	WriteRequest_       func(interface{}, *rpc.Request, interface{}) error
}

--------------- proxy for net/rpc.ClientCodec ---------------

func (*ClientCodec_net_rpc) Close 

func (Proxy *ClientCodec_net_rpc) Close() error

func (*ClientCodec_net_rpc) ReadResponseBody 

func (Proxy *ClientCodec_net_rpc) ReadResponseBody(unnamed0 interface{}) error

func (*ClientCodec_net_rpc) ReadResponseHeader 

func (Proxy *ClientCodec_net_rpc) ReadResponseHeader(unnamed0 *rpc.Response) error

func (*ClientCodec_net_rpc) WriteRequest 

func (Proxy *ClientCodec_net_rpc) WriteRequest(unnamed0 *rpc.Request, unnamed1 interface{}) error

type ClientSessionCache_crypto_tls 

type ClientSessionCache_crypto_tls struct {
	Object interface{}
	Get_   func(_proxy_obj_ interface{}, sessionKey string) (session *tls.ClientSessionState, ok bool)
	Put_   func(_proxy_obj_ interface{}, sessionKey string, cs *tls.ClientSessionState)
}

--------------- proxy for crypto/tls.ClientSessionCache ---------------

func (*ClientSessionCache_crypto_tls) Get 

func (Proxy *ClientSessionCache_crypto_tls) Get(sessionKey string) (session *tls.ClientSessionState, ok bool)

func (*ClientSessionCache_crypto_tls) Put 

func (Proxy *ClientSessionCache_crypto_tls) Put(sessionKey string, cs *tls.ClientSessionState)

type CloseNotifier_net_http 

type CloseNotifier_net_http struct {
	Object       interface{}
	CloseNotify_ func(interface{}) <-chan bool
}

--------------- proxy for net/http.CloseNotifier ---------------

func (*CloseNotifier_net_http) CloseNotify 

func (Proxy *CloseNotifier_net_http) CloseNotify() <-chan bool

type Closer_io 

type Closer_io struct {
	Object interface{}
	Close_ func(interface{}) error
}

--------------- proxy for io.Closer ---------------

func (*Closer_io) Close 

func (Proxy *Closer_io) Close() error

type Color_image_color 

type Color_image_color struct {
	Object interface{}
	RGBA_  func(interface{}) (r uint32, g uint32, b uint32, a uint32)
}

--------------- proxy for image/color.Color ---------------

func (*Color_image_color) RGBA 

func (Proxy *Color_image_color) RGBA() (r uint32, g uint32, b uint32, a uint32)

type ColumnConverter_database_sql_driver 

type ColumnConverter_database_sql_driver struct {
	Object           interface{}
	ColumnConverter_ func(_proxy_obj_ interface{}, idx int) driver.ValueConverter
}

--------------- proxy for database/sql/driver.ColumnConverter ---------------

func (*ColumnConverter_database_sql_driver) ColumnConverter 

func (Proxy *ColumnConverter_database_sql_driver) ColumnConverter(idx int) driver.ValueConverter

type ConnBeginTx_database_sql_driver 

type ConnBeginTx_database_sql_driver struct {
	Object   interface{}
	BeginTx_ func(_proxy_obj_ interface{}, ctx context.Context, opts driver.TxOptions) (driver.Tx, error)
}

--------------- proxy for database/sql/driver.ConnBeginTx ---------------

func (*ConnBeginTx_database_sql_driver) BeginTx 

func (Proxy *ConnBeginTx_database_sql_driver) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error)

type ConnPrepareContext_database_sql_driver 

type ConnPrepareContext_database_sql_driver struct {
	Object          interface{}
	PrepareContext_ func(_proxy_obj_ interface{}, ctx context.Context, query string) (driver.Stmt, error)
}

--------------- proxy for database/sql/driver.ConnPrepareContext ---------------

func (*ConnPrepareContext_database_sql_driver) PrepareContext 

func (Proxy *ConnPrepareContext_database_sql_driver) PrepareContext(ctx context.Context, query string) (driver.Stmt, error)

type Conn_database_sql_driver 

type Conn_database_sql_driver struct {
	Object   interface{}
	Begin_   func(interface{}) (driver.Tx, error)
	Close_   func(interface{}) error
	Prepare_ func(_proxy_obj_ interface{}, query string) (driver.Stmt, error)
}

--------------- proxy for database/sql/driver.Conn ---------------

func (*Conn_database_sql_driver) Begin 

func (Proxy *Conn_database_sql_driver) Begin() (driver.Tx, error)

func (*Conn_database_sql_driver) Close 

func (Proxy *Conn_database_sql_driver) Close() error

func (*Conn_database_sql_driver) Prepare 

func (Proxy *Conn_database_sql_driver) Prepare(query string) (driver.Stmt, error)

type Conn_net 

type Conn_net struct {
	Object            interface{}
	Close_            func(interface{}) error
	LocalAddr_        func(interface{}) net.Addr
	Read_             func(_proxy_obj_ interface{}, b []byte) (n int, err error)
	RemoteAddr_       func(interface{}) net.Addr
	SetDeadline_      func(_proxy_obj_ interface{}, t time.Time) error
	SetReadDeadline_  func(_proxy_obj_ interface{}, t time.Time) error
	SetWriteDeadline_ func(_proxy_obj_ interface{}, t time.Time) error
	Write_            func(_proxy_obj_ interface{}, b []byte) (n int, err error)
}

--------------- proxy for net.Conn ---------------

func (*Conn_net) Close 

func (Proxy *Conn_net) Close() error

func (*Conn_net) LocalAddr 

func (Proxy *Conn_net) LocalAddr() net.Addr

func (*Conn_net) Read 

func (Proxy *Conn_net) Read(b []byte) (n int, err error)

func (*Conn_net) RemoteAddr 

func (Proxy *Conn_net) RemoteAddr() net.Addr

func (*Conn_net) SetDeadline 

func (Proxy *Conn_net) SetDeadline(t time.Time) error

func (*Conn_net) SetReadDeadline 

func (Proxy *Conn_net) SetReadDeadline(t time.Time) error

func (*Conn_net) SetWriteDeadline 

func (Proxy *Conn_net) SetWriteDeadline(t time.Time) error

func (*Conn_net) Write 

func (Proxy *Conn_net) Write(b []byte) (n int, err error)

type Context_context 

type Context_context struct {
	Object    interface{}
	Deadline_ func(interface{}) (deadline time.Time, ok bool)
	Done_     func(interface{}) <-chan struct{}
	Err_      func(interface{}) error
	Value_    func(_proxy_obj_ interface{}, key interface{}) interface{}
}

--------------- proxy for context.Context ---------------

func (*Context_context) Deadline 

func (Proxy *Context_context) Deadline() (deadline time.Time, ok bool)

func (*Context_context) Done 

func (Proxy *Context_context) Done() <-chan struct{}

func (*Context_context) Err 

func (Proxy *Context_context) Err() error

func (*Context_context) Value 

func (Proxy *Context_context) Value(key interface{}) interface{}

type CookieJar_net_http 

type CookieJar_net_http struct {
	Object      interface{}
	Cookies_    func(_proxy_obj_ interface{}, u *url.URL) []*http.Cookie
	SetCookies_ func(_proxy_obj_ interface{}, u *url.URL, cookies []*http.Cookie)
}

--------------- proxy for net/http.CookieJar ---------------

func (*CookieJar_net_http) Cookies 

func (Proxy *CookieJar_net_http) Cookies(u *url.URL) []*http.Cookie

func (*CookieJar_net_http) SetCookies 

func (Proxy *CookieJar_net_http) SetCookies(u *url.URL, cookies []*http.Cookie)

type Curve_crypto_elliptic 

type Curve_crypto_elliptic struct {
	Object          interface{}
	Add_            func(_proxy_obj_ interface{}, x1 *big.Int, y1 *big.Int, x2 *big.Int, y2 *big.Int) (x *big.Int, y *big.Int)
	Double_         func(_proxy_obj_ interface{}, x1 *big.Int, y1 *big.Int) (x *big.Int, y *big.Int)
	IsOnCurve_      func(_proxy_obj_ interface{}, x *big.Int, y *big.Int) bool
	Params_         func(interface{}) *elliptic.CurveParams
	ScalarBaseMult_ func(_proxy_obj_ interface{}, k []byte) (x *big.Int, y *big.Int)
	ScalarMult_     func(_proxy_obj_ interface{}, x1 *big.Int, y1 *big.Int, k []byte) (x *big.Int, y *big.Int)
}

--------------- proxy for crypto/elliptic.Curve ---------------

func (*Curve_crypto_elliptic) Add 

func (Proxy *Curve_crypto_elliptic) Add(x1 *big.Int, y1 *big.Int, x2 *big.Int, y2 *big.Int) (x *big.Int, y *big.Int)

func (*Curve_crypto_elliptic) Double 

func (Proxy *Curve_crypto_elliptic) Double(x1 *big.Int, y1 *big.Int) (x *big.Int, y *big.Int)

func (*Curve_crypto_elliptic) IsOnCurve 

func (Proxy *Curve_crypto_elliptic) IsOnCurve(x *big.Int, y *big.Int) bool

func (*Curve_crypto_elliptic) Params 

func (Proxy *Curve_crypto_elliptic) Params() *elliptic.CurveParams

func (*Curve_crypto_elliptic) ScalarBaseMult 

func (Proxy *Curve_crypto_elliptic) ScalarBaseMult(k []byte) (x *big.Int, y *big.Int)

func (*Curve_crypto_elliptic) ScalarMult 

func (Proxy *Curve_crypto_elliptic) ScalarMult(x1 *big.Int, y1 *big.Int, k []byte) (x *big.Int, y *big.Int)

type DecrypterOpts_crypto 

type DecrypterOpts_crypto struct {
	Object interface{}
}

--------------- proxy for crypto.DecrypterOpts ---------------

type Decrypter_crypto 

type Decrypter_crypto struct {
	Object   interface{}
	Decrypt_ func(_proxy_obj_ interface{}, rand io.Reader, msg []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error)
	Public_  func(interface{}) crypto.PublicKey
}

--------------- proxy for crypto.Decrypter ---------------

func (*Decrypter_crypto) Decrypt 

func (Proxy *Decrypter_crypto) Decrypt(rand io.Reader, msg []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error)

func (*Decrypter_crypto) Public 

func (Proxy *Decrypter_crypto) Public() crypto.PublicKey

type Drawer_image_draw 

type Drawer_image_draw struct {
	Object interface{}
	Draw_  func(_proxy_obj_ interface{}, dst draw.Image, r image.Rectangle, src image.Image, sp image.Point)
}

--------------- proxy for image/draw.Drawer ---------------

func (*Drawer_image_draw) Draw 

func (Proxy *Drawer_image_draw) Draw(dst draw.Image, r image.Rectangle, src image.Image, sp image.Point)

type Driver_database_sql_driver 

type Driver_database_sql_driver struct {
	Object interface{}
	Open_  func(_proxy_obj_ interface{}, name string) (driver.Conn, error)
}

--------------- proxy for database/sql/driver.Driver ---------------

func (*Driver_database_sql_driver) Open 

func (Proxy *Driver_database_sql_driver) Open(name string) (driver.Conn, error)

type Error_net 

type Error_net struct {
	Object     interface{}
	Error_     func(interface{}) string
	Temporary_ func(interface{}) bool
	Timeout_   func(interface{}) bool
}

--------------- proxy for net.Error ---------------

func (*Error_net) Error 

func (Proxy *Error_net) Error() string

func (*Error_net) Temporary 

func (Proxy *Error_net) Temporary() bool

func (*Error_net) Timeout 

func (Proxy *Error_net) Timeout() bool

type Error_runtime 

type Error_runtime struct {
	Object        interface{}
	Error_        func(interface{}) string
	RuntimeError_ func(interface{})
}

--------------- proxy for runtime.Error ---------------

func (*Error_runtime) Error 

func (Proxy *Error_runtime) Error() string

func (*Error_runtime) RuntimeError 

func (Proxy *Error_runtime) RuntimeError()

type ExecerContext_database_sql_driver 

type ExecerContext_database_sql_driver struct {
	Object       interface{}
	ExecContext_ func(_proxy_obj_ interface{}, ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error)
}

--------------- proxy for database/sql/driver.ExecerContext ---------------

func (*ExecerContext_database_sql_driver) ExecContext 

func (Proxy *ExecerContext_database_sql_driver) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error)

type Execer_database_sql_driver 

type Execer_database_sql_driver struct {
	Object interface{}
	Exec_  func(_proxy_obj_ interface{}, query string, args []driver.Value) (driver.Result, error)
}

--------------- proxy for database/sql/driver.Execer ---------------

func (*Execer_database_sql_driver) Exec 

func (Proxy *Execer_database_sql_driver) Exec(query string, args []driver.Value) (driver.Result, error)

type FileInfo_os 

type FileInfo_os struct {
	Object   interface{}
	IsDir_   func(interface{}) bool
	ModTime_ func(interface{}) time.Time
	Mode_    func(interface{}) os.FileMode
	Name_    func(interface{}) string
	Size_    func(interface{}) int64
	Sys_     func(interface{}) interface{}
}

--------------- proxy for os.FileInfo ---------------

func (*FileInfo_os) IsDir 

func (Proxy *FileInfo_os) IsDir() bool

func (*FileInfo_os) ModTime 

func (Proxy *FileInfo_os) ModTime() time.Time

func (*FileInfo_os) Mode 

func (Proxy *FileInfo_os) Mode() os.FileMode

func (*FileInfo_os) Name 

func (Proxy *FileInfo_os) Name() string

func (*FileInfo_os) Size 

func (Proxy *FileInfo_os) Size() int64

func (*FileInfo_os) Sys 

func (Proxy *FileInfo_os) Sys() interface{}

type FileSystem_net_http 

type FileSystem_net_http struct {
	Object interface{}
	Open_  func(_proxy_obj_ interface{}, name string) (http.File, error)
}

--------------- proxy for net/http.FileSystem ---------------

func (*FileSystem_net_http) Open 

func (Proxy *FileSystem_net_http) Open(name string) (http.File, error)

type File_mime_multipart 

type File_mime_multipart struct {
	Object  interface{}
	Close_  func(interface{}) error
	Read_   func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	ReadAt_ func(_proxy_obj_ interface{}, p []byte, off int64) (n int, err error)
	Seek_   func(_proxy_obj_ interface{}, offset int64, whence int) (int64, error)
}

--------------- proxy for mime/multipart.File ---------------

func (*File_mime_multipart) Close 

func (Proxy *File_mime_multipart) Close() error

func (*File_mime_multipart) Read 

func (Proxy *File_mime_multipart) Read(p []byte) (n int, err error)

func (*File_mime_multipart) ReadAt 

func (Proxy *File_mime_multipart) ReadAt(p []byte, off int64) (n int, err error)

func (*File_mime_multipart) Seek 

func (Proxy *File_mime_multipart) Seek(offset int64, whence int) (int64, error)

type File_net_http 

type File_net_http struct {
	Object   interface{}
	Close_   func(interface{}) error
	Read_    func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	Readdir_ func(_proxy_obj_ interface{}, count int) ([]os.FileInfo, error)
	Seek_    func(_proxy_obj_ interface{}, offset int64, whence int) (int64, error)
	Stat_    func(interface{}) (os.FileInfo, error)
}

--------------- proxy for net/http.File ---------------

func (*File_net_http) Close 

func (Proxy *File_net_http) Close() error

func (*File_net_http) Read 

func (Proxy *File_net_http) Read(p []byte) (n int, err error)

func (*File_net_http) Readdir 

func (Proxy *File_net_http) Readdir(count int) ([]os.FileInfo, error)

func (*File_net_http) Seek 

func (Proxy *File_net_http) Seek(offset int64, whence int) (int64, error)

func (*File_net_http) Stat 

func (Proxy *File_net_http) Stat() (os.FileInfo, error)

type Flusher_net_http 

type Flusher_net_http struct {
	Object interface{}
	Flush_ func(interface{})
}

--------------- proxy for net/http.Flusher ---------------

func (*Flusher_net_http) Flush 

func (Proxy *Flusher_net_http) Flush()

type Formatter_fmt 

type Formatter_fmt struct {
	Object  interface{}
	Format_ func(_proxy_obj_ interface{}, f fmt.State, c rune)
}

--------------- proxy for fmt.Formatter ---------------

func (*Formatter_fmt) Format 

func (Proxy *Formatter_fmt) Format(f fmt.State, c rune)

type Generator_testing_quick 

type Generator_testing_quick struct {
	Object    interface{}
	Generate_ func(_proxy_obj_ interface{}, rand *rand.Rand, size int) reflect.Value
}

--------------- proxy for testing/quick.Generator ---------------

func (*Generator_testing_quick) Generate 

func (Proxy *Generator_testing_quick) Generate(rand *rand.Rand, size int) reflect.Value

type Getter_flag 

type Getter_flag struct {
	Object  interface{}
	Get_    func(interface{}) interface{}
	Set_    func(interface{}, string) error
	String_ func(interface{}) string
}

--------------- proxy for flag.Getter ---------------

func (*Getter_flag) Get 

func (Proxy *Getter_flag) Get() interface{}

func (*Getter_flag) Set 

func (Proxy *Getter_flag) Set(unnamed0 string) error

func (*Getter_flag) String 

func (Proxy *Getter_flag) String() string

type GoStringer_fmt 

type GoStringer_fmt struct {
	Object    interface{}
	GoString_ func(interface{}) string
}

--------------- proxy for fmt.GoStringer ---------------

func (*GoStringer_fmt) GoString 

func (Proxy *GoStringer_fmt) GoString() string

type GobDecoder_encoding_gob 

type GobDecoder_encoding_gob struct {
	Object     interface{}
	GobDecode_ func(interface{}, []byte) error
}

--------------- proxy for encoding/gob.GobDecoder ---------------

func (*GobDecoder_encoding_gob) GobDecode 

func (Proxy *GobDecoder_encoding_gob) GobDecode(unnamed0 []byte) error

type GobEncoder_encoding_gob 

type GobEncoder_encoding_gob struct {
	Object     interface{}
	GobEncode_ func(interface{}) ([]byte, error)
}

--------------- proxy for encoding/gob.GobEncoder ---------------

func (*GobEncoder_encoding_gob) GobEncode 

func (Proxy *GobEncoder_encoding_gob) GobEncode() ([]byte, error)

type Handler_net_http 

type Handler_net_http struct {
	Object     interface{}
	ServeHTTP_ func(interface{}, http.ResponseWriter, *http.Request)
}

--------------- proxy for net/http.Handler ---------------

func (*Handler_net_http) ServeHTTP 

func (Proxy *Handler_net_http) ServeHTTP(unnamed0 http.ResponseWriter, unnamed1 *http.Request)

type Hash32_hash 

type Hash32_hash struct {
	Object     interface{}
	BlockSize_ func(interface{}) int
	Reset_     func(interface{})
	Size_      func(interface{}) int
	Sum_       func(_proxy_obj_ interface{}, b []byte) []byte
	Sum32_     func(interface{}) uint32
	Write_     func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

--------------- proxy for hash.Hash32 ---------------

func (*Hash32_hash) BlockSize 

func (Proxy *Hash32_hash) BlockSize() int

func (*Hash32_hash) Reset 

func (Proxy *Hash32_hash) Reset()

func (*Hash32_hash) Size 

func (Proxy *Hash32_hash) Size() int

func (*Hash32_hash) Sum 

func (Proxy *Hash32_hash) Sum(b []byte) []byte

func (*Hash32_hash) Sum32 

func (Proxy *Hash32_hash) Sum32() uint32

func (*Hash32_hash) Write 

func (Proxy *Hash32_hash) Write(p []byte) (n int, err error)

type Hash64_hash 

type Hash64_hash struct {
	Object     interface{}
	BlockSize_ func(interface{}) int
	Reset_     func(interface{})
	Size_      func(interface{}) int
	Sum_       func(_proxy_obj_ interface{}, b []byte) []byte
	Sum64_     func(interface{}) uint64
	Write_     func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

--------------- proxy for hash.Hash64 ---------------

func (*Hash64_hash) BlockSize 

func (Proxy *Hash64_hash) BlockSize() int

func (*Hash64_hash) Reset 

func (Proxy *Hash64_hash) Reset()

func (*Hash64_hash) Size 

func (Proxy *Hash64_hash) Size() int

func (*Hash64_hash) Sum 

func (Proxy *Hash64_hash) Sum(b []byte) []byte

func (*Hash64_hash) Sum64 

func (Proxy *Hash64_hash) Sum64() uint64

func (*Hash64_hash) Write 

func (Proxy *Hash64_hash) Write(p []byte) (n int, err error)

type Hash_hash 

type Hash_hash struct {
	Object     interface{}
	BlockSize_ func(interface{}) int
	Reset_     func(interface{})
	Size_      func(interface{}) int
	Sum_       func(_proxy_obj_ interface{}, b []byte) []byte
	Write_     func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

--------------- proxy for hash.Hash ---------------

func (*Hash_hash) BlockSize 

func (Proxy *Hash_hash) BlockSize() int

func (*Hash_hash) Reset 

func (Proxy *Hash_hash) Reset()

func (*Hash_hash) Size 

func (Proxy *Hash_hash) Size() int

func (*Hash_hash) Sum 

func (Proxy *Hash_hash) Sum(b []byte) []byte

func (*Hash_hash) Write 

func (Proxy *Hash_hash) Write(p []byte) (n int, err error)

type Hijacker_net_http 

type Hijacker_net_http struct {
	Object  interface{}
	Hijack_ func(interface{}) (net.Conn, *bufio.ReadWriter, error)
}

--------------- proxy for net/http.Hijacker ---------------

func (*Hijacker_net_http) Hijack 

func (Proxy *Hijacker_net_http) Hijack() (net.Conn, *bufio.ReadWriter, error)

type Image_image 

type Image_image struct {
	Object      interface{}
	At_         func(_proxy_obj_ interface{}, x int, y int) color.Color
	Bounds_     func(interface{}) image.Rectangle
	ColorModel_ func(interface{}) color.Model
}

--------------- proxy for image.Image ---------------

func (*Image_image) At 

func (Proxy *Image_image) At(x int, y int) color.Color

func (*Image_image) Bounds 

func (Proxy *Image_image) Bounds() image.Rectangle

func (*Image_image) ColorModel 

func (Proxy *Image_image) ColorModel() color.Model

type Image_image_draw 

type Image_image_draw struct {
	Object      interface{}
	At_         func(_proxy_obj_ interface{}, x int, y int) color.Color
	Bounds_     func(interface{}) image.Rectangle
	ColorModel_ func(interface{}) color.Model
	Set_        func(_proxy_obj_ interface{}, x int, y int, c color.Color)
}

--------------- proxy for image/draw.Image ---------------

func (*Image_image_draw) At 

func (Proxy *Image_image_draw) At(x int, y int) color.Color

func (*Image_image_draw) Bounds 

func (Proxy *Image_image_draw) Bounds() image.Rectangle

func (*Image_image_draw) ColorModel 

func (Proxy *Image_image_draw) ColorModel() color.Model

func (*Image_image_draw) Set 

func (Proxy *Image_image_draw) Set(x int, y int, c color.Color)

type ImporterFrom_go_types 

type ImporterFrom_go_types struct {
	Object      interface{}
	Import_     func(_proxy_obj_ interface{}, path string) (*types.Package, error)
	ImportFrom_ func(_proxy_obj_ interface{}, path string, srcDir string, mode types.ImportMode) (*types.Package, error)
}

--------------- proxy for go/types.ImporterFrom ---------------

func (*ImporterFrom_go_types) Import 

func (Proxy *ImporterFrom_go_types) Import(path string) (*types.Package, error)

func (*ImporterFrom_go_types) ImportFrom 

func (Proxy *ImporterFrom_go_types) ImportFrom(path string, srcDir string, mode types.ImportMode) (*types.Package, error)

type Importer_go_types 

type Importer_go_types struct {
	Object  interface{}
	Import_ func(_proxy_obj_ interface{}, path string) (*types.Package, error)
}

--------------- proxy for go/types.Importer ---------------

func (*Importer_go_types) Import 

func (Proxy *Importer_go_types) Import(path string) (*types.Package, error)

type Interface_container_heap 

type Interface_container_heap struct {
	Object interface{}
	Len_   func(interface{}) int
	Less_  func(_proxy_obj_ interface{}, i int, j int) bool
	Pop_   func(interface{}) interface{}
	Push_  func(_proxy_obj_ interface{}, x interface{})
	Swap_  func(_proxy_obj_ interface{}, i int, j int)
}

--------------- proxy for container/heap.Interface ---------------

func (*Interface_container_heap) Len 

func (Proxy *Interface_container_heap) Len() int

func (*Interface_container_heap) Less 

func (Proxy *Interface_container_heap) Less(i int, j int) bool

func (*Interface_container_heap) Pop 

func (Proxy *Interface_container_heap) Pop() interface{}

func (*Interface_container_heap) Push 

func (Proxy *Interface_container_heap) Push(x interface{})

func (*Interface_container_heap) Swap 

func (Proxy *Interface_container_heap) Swap(i int, j int)

type Interface_sort 

type Interface_sort struct {
	Object interface{}
	Len_   func(interface{}) int
	Less_  func(_proxy_obj_ interface{}, i int, j int) bool
	Swap_  func(_proxy_obj_ interface{}, i int, j int)
}

--------------- proxy for sort.Interface ---------------

func (*Interface_sort) Len 

func (Proxy *Interface_sort) Len() int

func (*Interface_sort) Less 

func (Proxy *Interface_sort) Less(i int, j int) bool

func (*Interface_sort) Swap 

func (Proxy *Interface_sort) Swap(i int, j int)

type Listener_net 

type Listener_net struct {
	Object  interface{}
	Accept_ func(interface{}) (net.Conn, error)
	Addr_   func(interface{}) net.Addr
	Close_  func(interface{}) error
}

--------------- proxy for net.Listener ---------------

func (*Listener_net) Accept 

func (Proxy *Listener_net) Accept() (net.Conn, error)

func (*Listener_net) Addr 

func (Proxy *Listener_net) Addr() net.Addr

func (*Listener_net) Close 

func (Proxy *Listener_net) Close() error

type Load_debug_macho 

type Load_debug_macho struct {
	Object interface{}
	Raw_   func(interface{}) []byte
}

--------------- proxy for debug/macho.Load ---------------

func (*Load_debug_macho) Raw 

func (Proxy *Load_debug_macho) Raw() []byte

type Locker_sync 

type Locker_sync struct {
	Object  interface{}
	Lock_   func(interface{})
	Unlock_ func(interface{})
}

--------------- proxy for sync.Locker ---------------

func (*Locker_sync) Lock 

func (Proxy *Locker_sync) Lock()

func (*Locker_sync) Unlock 

func (Proxy *Locker_sync) Unlock()

type MarshalerAttr_encoding_xml 

type MarshalerAttr_encoding_xml struct {
	Object          interface{}
	MarshalXMLAttr_ func(_proxy_obj_ interface{}, name xml.Name) (xml.Attr, error)
}

--------------- proxy for encoding/xml.MarshalerAttr ---------------

func (*MarshalerAttr_encoding_xml) MarshalXMLAttr 

func (Proxy *MarshalerAttr_encoding_xml) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

type Marshaler_encoding_json 

type Marshaler_encoding_json struct {
	Object       interface{}
	MarshalJSON_ func(interface{}) ([]byte, error)
}

--------------- proxy for encoding/json.Marshaler ---------------

func (*Marshaler_encoding_json) MarshalJSON 

func (Proxy *Marshaler_encoding_json) MarshalJSON() ([]byte, error)

type Marshaler_encoding_xml 

type Marshaler_encoding_xml struct {
	Object      interface{}
	MarshalXML_ func(_proxy_obj_ interface{}, e *xml.Encoder, start xml.StartElement) error
}

--------------- proxy for encoding/xml.Marshaler ---------------

func (*Marshaler_encoding_xml) MarshalXML 

func (Proxy *Marshaler_encoding_xml) MarshalXML(e *xml.Encoder, start xml.StartElement) error

type Model_image_color 

type Model_image_color struct {
	Object   interface{}
	Convert_ func(_proxy_obj_ interface{}, c color.Color) color.Color
}

--------------- proxy for image/color.Model ---------------

func (*Model_image_color) Convert 

func (Proxy *Model_image_color) Convert(c color.Color) color.Color

type Node_go_ast 

type Node_go_ast struct {
	Object interface{}
	End_   func(interface{}) token.Pos
	Pos_   func(interface{}) token.Pos
}

--------------- proxy for go/ast.Node ---------------

func (*Node_go_ast) End 

func (Proxy *Node_go_ast) End() token.Pos

func (*Node_go_ast) Pos 

func (Proxy *Node_go_ast) Pos() token.Pos

type Package 

type Package struct {
	Binds   map[string]Value
	Types   map[string]Type
	Proxies map[string]Type
	// Untypeds contains a string representation of untyped constants,
	// stored without loss of precision
	Untypeds map[string]string
	// Wrappers is the list of wrapper methods for named types.
	// Stored explicitly because reflect package cannot distinguish
	// between explicit methods and wrapper methods for embedded fields
	Wrappers map[string][]string
}

func (*Package) Init 

func (pkg *Package) Init()

func (Package) Merge 

func (dst Package) Merge(src Package)

func (Package) SaveToPackages 

func (pkg Package) SaveToPackages(path string)

type PacketConn_net 

type PacketConn_net struct {
	Object            interface{}
	Close_            func(interface{}) error
	LocalAddr_        func(interface{}) net.Addr
	ReadFrom_         func(_proxy_obj_ interface{}, b []byte) (n int, addr net.Addr, err error)
	SetDeadline_      func(_proxy_obj_ interface{}, t time.Time) error
	SetReadDeadline_  func(_proxy_obj_ interface{}, t time.Time) error
	SetWriteDeadline_ func(_proxy_obj_ interface{}, t time.Time) error
	WriteTo_          func(_proxy_obj_ interface{}, b []byte, addr net.Addr) (n int, err error)
}

--------------- proxy for net.PacketConn ---------------

func (*PacketConn_net) Close 

func (Proxy *PacketConn_net) Close() error

func (*PacketConn_net) LocalAddr 

func (Proxy *PacketConn_net) LocalAddr() net.Addr

func (*PacketConn_net) ReadFrom 

func (Proxy *PacketConn_net) ReadFrom(b []byte) (n int, addr net.Addr, err error)

func (*PacketConn_net) SetDeadline 

func (Proxy *PacketConn_net) SetDeadline(t time.Time) error

func (*PacketConn_net) SetReadDeadline 

func (Proxy *PacketConn_net) SetReadDeadline(t time.Time) error

func (*PacketConn_net) SetWriteDeadline 

func (Proxy *PacketConn_net) SetWriteDeadline(t time.Time) error

func (*PacketConn_net) WriteTo 

func (Proxy *PacketConn_net) WriteTo(b []byte, addr net.Addr) (n int, err error)

type PalettedImage_image 

type PalettedImage_image struct {
	Object        interface{}
	At_           func(_proxy_obj_ interface{}, x int, y int) color.Color
	Bounds_       func(interface{}) image.Rectangle
	ColorIndexAt_ func(_proxy_obj_ interface{}, x int, y int) uint8
	ColorModel_   func(interface{}) color.Model
}

--------------- proxy for image.PalettedImage ---------------

func (*PalettedImage_image) At 

func (Proxy *PalettedImage_image) At(x int, y int) color.Color

func (*PalettedImage_image) Bounds 

func (Proxy *PalettedImage_image) Bounds() image.Rectangle

func (*PalettedImage_image) ColorIndexAt 

func (Proxy *PalettedImage_image) ColorIndexAt(x int, y int) uint8

func (*PalettedImage_image) ColorModel 

func (Proxy *PalettedImage_image) ColorModel() color.Model

type Pinger_database_sql_driver 

type Pinger_database_sql_driver struct {
	Object interface{}
	Ping_  func(_proxy_obj_ interface{}, ctx context.Context) error
}

--------------- proxy for database/sql/driver.Pinger ---------------

func (*Pinger_database_sql_driver) Ping 

func (Proxy *Pinger_database_sql_driver) Ping(ctx context.Context) error

type PrivateKey_crypto 

type PrivateKey_crypto struct {
	Object interface{}
}

--------------- proxy for crypto.PrivateKey ---------------

type PublicKey_crypto 

type PublicKey_crypto struct {
	Object interface{}
}

--------------- proxy for crypto.PublicKey ---------------

type PublicSuffixList_net_http_cookiejar 

type PublicSuffixList_net_http_cookiejar struct {
	Object        interface{}
	PublicSuffix_ func(_proxy_obj_ interface{}, domain string) string
	String_       func(interface{}) string
}

--------------- proxy for net/http/cookiejar.PublicSuffixList ---------------

func (*PublicSuffixList_net_http_cookiejar) PublicSuffix 

func (Proxy *PublicSuffixList_net_http_cookiejar) PublicSuffix(domain string) string

func (*PublicSuffixList_net_http_cookiejar) String 

func (Proxy *PublicSuffixList_net_http_cookiejar) String() string

type Pusher_net_http 

type Pusher_net_http struct {
	Object interface{}
	Push_  func(_proxy_obj_ interface{}, target string, opts *http.PushOptions) error
}

--------------- proxy for net/http.Pusher ---------------

func (*Pusher_net_http) Push 

func (Proxy *Pusher_net_http) Push(target string, opts *http.PushOptions) error

type Quantizer_image_draw 

type Quantizer_image_draw struct {
	Object    interface{}
	Quantize_ func(_proxy_obj_ interface{}, p color.Palette, m image.Image) color.Palette
}

--------------- proxy for image/draw.Quantizer ---------------

func (*Quantizer_image_draw) Quantize 

func (Proxy *Quantizer_image_draw) Quantize(p color.Palette, m image.Image) color.Palette

type QueryerContext_database_sql_driver 

type QueryerContext_database_sql_driver struct {
	Object        interface{}
	QueryContext_ func(_proxy_obj_ interface{}, ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error)
}

--------------- proxy for database/sql/driver.QueryerContext ---------------

func (*QueryerContext_database_sql_driver) QueryContext 

func (Proxy *QueryerContext_database_sql_driver) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error)

type Queryer_database_sql_driver 

type Queryer_database_sql_driver struct {
	Object interface{}
	Query_ func(_proxy_obj_ interface{}, query string, args []driver.Value) (driver.Rows, error)
}

--------------- proxy for database/sql/driver.Queryer ---------------

func (*Queryer_database_sql_driver) Query 

func (Proxy *Queryer_database_sql_driver) Query(query string, args []driver.Value) (driver.Rows, error)

type ReadCloser_io 

type ReadCloser_io struct {
	Object interface{}
	Close_ func(interface{}) error
	Read_  func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

--------------- proxy for io.ReadCloser ---------------

func (*ReadCloser_io) Close 

func (Proxy *ReadCloser_io) Close() error

func (*ReadCloser_io) Read 

func (Proxy *ReadCloser_io) Read(p []byte) (n int, err error)

type ReadSeeker_io 

type ReadSeeker_io struct {
	Object interface{}
	Read_  func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	Seek_  func(_proxy_obj_ interface{}, offset int64, whence int) (int64, error)
}

--------------- proxy for io.ReadSeeker ---------------

func (*ReadSeeker_io) Read 

func (Proxy *ReadSeeker_io) Read(p []byte) (n int, err error)

func (*ReadSeeker_io) Seek 

func (Proxy *ReadSeeker_io) Seek(offset int64, whence int) (int64, error)

type ReadWriteCloser_io 

type ReadWriteCloser_io struct {
	Object interface{}
	Close_ func(interface{}) error
	Read_  func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	Write_ func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

--------------- proxy for io.ReadWriteCloser ---------------

func (*ReadWriteCloser_io) Close 

func (Proxy *ReadWriteCloser_io) Close() error

func (*ReadWriteCloser_io) Read 

func (Proxy *ReadWriteCloser_io) Read(p []byte) (n int, err error)

func (*ReadWriteCloser_io) Write 

func (Proxy *ReadWriteCloser_io) Write(p []byte) (n int, err error)

type ReadWriteSeeker_io 

type ReadWriteSeeker_io struct {
	Object interface{}
	Read_  func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	Seek_  func(_proxy_obj_ interface{}, offset int64, whence int) (int64, error)
	Write_ func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

--------------- proxy for io.ReadWriteSeeker ---------------

func (*ReadWriteSeeker_io) Read 

func (Proxy *ReadWriteSeeker_io) Read(p []byte) (n int, err error)

func (*ReadWriteSeeker_io) Seek 

func (Proxy *ReadWriteSeeker_io) Seek(offset int64, whence int) (int64, error)

func (*ReadWriteSeeker_io) Write 

func (Proxy *ReadWriteSeeker_io) Write(p []byte) (n int, err error)

type ReadWriter_io 

type ReadWriter_io struct {
	Object interface{}
	Read_  func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	Write_ func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

--------------- proxy for io.ReadWriter ---------------

func (*ReadWriter_io) Read 

func (Proxy *ReadWriter_io) Read(p []byte) (n int, err error)

func (*ReadWriter_io) Write 

func (Proxy *ReadWriter_io) Write(p []byte) (n int, err error)

type ReaderAt_io 

type ReaderAt_io struct {
	Object  interface{}
	ReadAt_ func(_proxy_obj_ interface{}, p []byte, off int64) (n int, err error)
}

--------------- proxy for io.ReaderAt ---------------

func (*ReaderAt_io) ReadAt 

func (Proxy *ReaderAt_io) ReadAt(p []byte, off int64) (n int, err error)

type ReaderFrom_io 

type ReaderFrom_io struct {
	Object    interface{}
	ReadFrom_ func(_proxy_obj_ interface{}, r io.Reader) (n int64, err error)
}

--------------- proxy for io.ReaderFrom ---------------

func (*ReaderFrom_io) ReadFrom 

func (Proxy *ReaderFrom_io) ReadFrom(r io.Reader) (n int64, err error)

type Reader_compress_flate 

type Reader_compress_flate struct {
	Object    interface{}
	Read_     func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	ReadByte_ func(interface{}) (byte, error)
}

--------------- proxy for compress/flate.Reader ---------------

func (*Reader_compress_flate) Read 

func (Proxy *Reader_compress_flate) Read(p []byte) (n int, err error)

func (*Reader_compress_flate) ReadByte 

func (Proxy *Reader_compress_flate) ReadByte() (byte, error)

type Reader_image_jpeg 

type Reader_image_jpeg struct {
	Object    interface{}
	Read_     func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	ReadByte_ func(interface{}) (byte, error)
}

--------------- proxy for image/jpeg.Reader ---------------

func (*Reader_image_jpeg) Read 

func (Proxy *Reader_image_jpeg) Read(p []byte) (n int, err error)

func (*Reader_image_jpeg) ReadByte 

func (Proxy *Reader_image_jpeg) ReadByte() (byte, error)

type Reader_io 

type Reader_io struct {
	Object interface{}
	Read_  func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

--------------- proxy for io.Reader ---------------

func (*Reader_io) Read 

func (Proxy *Reader_io) Read(p []byte) (n int, err error)

type Resetter_compress_flate 

type Resetter_compress_flate struct {
	Object interface{}
	Reset_ func(_proxy_obj_ interface{}, r io.Reader, dict []byte) error
}

--------------- proxy for compress/flate.Resetter ---------------

func (*Resetter_compress_flate) Reset 

func (Proxy *Resetter_compress_flate) Reset(r io.Reader, dict []byte) error

type Resetter_compress_zlib 

type Resetter_compress_zlib struct {
	Object interface{}
	Reset_ func(_proxy_obj_ interface{}, r io.Reader, dict []byte) error
}

--------------- proxy for compress/zlib.Resetter ---------------

func (*Resetter_compress_zlib) Reset 

func (Proxy *Resetter_compress_zlib) Reset(r io.Reader, dict []byte) error

type ResponseWriter_net_http 

type ResponseWriter_net_http struct {
	Object       interface{}
	Header_      func(interface{}) http.Header
	Write_       func(interface{}, []byte) (int, error)
	WriteHeader_ func(interface{}, int)
}

--------------- proxy for net/http.ResponseWriter ---------------

func (*ResponseWriter_net_http) Header 

func (Proxy *ResponseWriter_net_http) Header() http.Header

func (*ResponseWriter_net_http) Write 

func (Proxy *ResponseWriter_net_http) Write(unnamed0 []byte) (int, error)

func (*ResponseWriter_net_http) WriteHeader 

func (Proxy *ResponseWriter_net_http) WriteHeader(unnamed0 int)

type Result_database_sql 

type Result_database_sql struct {
	Object        interface{}
	LastInsertId_ func(interface{}) (int64, error)
	RowsAffected_ func(interface{}) (int64, error)
}

--------------- proxy for database/sql.Result ---------------

func (*Result_database_sql) LastInsertId 

func (Proxy *Result_database_sql) LastInsertId() (int64, error)

func (*Result_database_sql) RowsAffected 

func (Proxy *Result_database_sql) RowsAffected() (int64, error)

type Result_database_sql_driver 

type Result_database_sql_driver struct {
	Object        interface{}
	LastInsertId_ func(interface{}) (int64, error)
	RowsAffected_ func(interface{}) (int64, error)
}

--------------- proxy for database/sql/driver.Result ---------------

func (*Result_database_sql_driver) LastInsertId 

func (Proxy *Result_database_sql_driver) LastInsertId() (int64, error)

func (*Result_database_sql_driver) RowsAffected 

func (Proxy *Result_database_sql_driver) RowsAffected() (int64, error)

type RoundTripper_net_http 

type RoundTripper_net_http struct {
	Object     interface{}
	RoundTrip_ func(interface{}, *http.Request) (*http.Response, error)
}

--------------- proxy for net/http.RoundTripper ---------------

func (*RoundTripper_net_http) RoundTrip 

func (Proxy *RoundTripper_net_http) RoundTrip(unnamed0 *http.Request) (*http.Response, error)

type RowsColumnTypeDatabaseTypeName_database_sql_driver 

type RowsColumnTypeDatabaseTypeName_database_sql_driver struct {
	Object                      interface{}
	Close_                      func(interface{}) error
	ColumnTypeDatabaseTypeName_ func(_proxy_obj_ interface{}, index int) string
	Columns_                    func(interface{}) []string
	Next_                       func(_proxy_obj_ interface{}, dest []driver.Value) error
}

--------------- proxy for database/sql/driver.RowsColumnTypeDatabaseTypeName ---------------

func (*RowsColumnTypeDatabaseTypeName_database_sql_driver) Close 

func (Proxy *RowsColumnTypeDatabaseTypeName_database_sql_driver) Close() error

func (*RowsColumnTypeDatabaseTypeName_database_sql_driver) ColumnTypeDatabaseTypeName 

func (Proxy *RowsColumnTypeDatabaseTypeName_database_sql_driver) ColumnTypeDatabaseTypeName(index int) string

func (*RowsColumnTypeDatabaseTypeName_database_sql_driver) Columns 

func (Proxy *RowsColumnTypeDatabaseTypeName_database_sql_driver) Columns() []string

func (*RowsColumnTypeDatabaseTypeName_database_sql_driver) Next 

func (Proxy *RowsColumnTypeDatabaseTypeName_database_sql_driver) Next(dest []driver.Value) error

type RowsColumnTypeLength_database_sql_driver 

type RowsColumnTypeLength_database_sql_driver struct {
	Object            interface{}
	Close_            func(interface{}) error
	ColumnTypeLength_ func(_proxy_obj_ interface{}, index int) (length int64, ok bool)
	Columns_          func(interface{}) []string
	Next_             func(_proxy_obj_ interface{}, dest []driver.Value) error
}

--------------- proxy for database/sql/driver.RowsColumnTypeLength ---------------

func (*RowsColumnTypeLength_database_sql_driver) Close 

func (Proxy *RowsColumnTypeLength_database_sql_driver) Close() error

func (*RowsColumnTypeLength_database_sql_driver) ColumnTypeLength 

func (Proxy *RowsColumnTypeLength_database_sql_driver) ColumnTypeLength(index int) (length int64, ok bool)

func (*RowsColumnTypeLength_database_sql_driver) Columns 

func (Proxy *RowsColumnTypeLength_database_sql_driver) Columns() []string

func (*RowsColumnTypeLength_database_sql_driver) Next 

func (Proxy *RowsColumnTypeLength_database_sql_driver) Next(dest []driver.Value) error

type RowsColumnTypeNullable_database_sql_driver 

type RowsColumnTypeNullable_database_sql_driver struct {
	Object              interface{}
	Close_              func(interface{}) error
	ColumnTypeNullable_ func(_proxy_obj_ interface{}, index int) (nullable bool, ok bool)
	Columns_            func(interface{}) []string
	Next_               func(_proxy_obj_ interface{}, dest []driver.Value) error
}

--------------- proxy for database/sql/driver.RowsColumnTypeNullable ---------------

func (*RowsColumnTypeNullable_database_sql_driver) Close 

func (Proxy *RowsColumnTypeNullable_database_sql_driver) Close() error

func (*RowsColumnTypeNullable_database_sql_driver) ColumnTypeNullable 

func (Proxy *RowsColumnTypeNullable_database_sql_driver) ColumnTypeNullable(index int) (nullable bool, ok bool)

func (*RowsColumnTypeNullable_database_sql_driver) Columns 

func (Proxy *RowsColumnTypeNullable_database_sql_driver) Columns() []string

func (*RowsColumnTypeNullable_database_sql_driver) Next 

func (Proxy *RowsColumnTypeNullable_database_sql_driver) Next(dest []driver.Value) error

type RowsColumnTypePrecisionScale_database_sql_driver 

type RowsColumnTypePrecisionScale_database_sql_driver struct {
	Object                    interface{}
	Close_                    func(interface{}) error
	ColumnTypePrecisionScale_ func(_proxy_obj_ interface{}, index int) (precision int64, scale int64, ok bool)
	Columns_                  func(interface{}) []string
	Next_                     func(_proxy_obj_ interface{}, dest []driver.Value) error
}

--------------- proxy for database/sql/driver.RowsColumnTypePrecisionScale ---------------

func (*RowsColumnTypePrecisionScale_database_sql_driver) Close 

func (Proxy *RowsColumnTypePrecisionScale_database_sql_driver) Close() error

func (*RowsColumnTypePrecisionScale_database_sql_driver) ColumnTypePrecisionScale 

func (Proxy *RowsColumnTypePrecisionScale_database_sql_driver) ColumnTypePrecisionScale(index int) (precision int64, scale int64, ok bool)

func (*RowsColumnTypePrecisionScale_database_sql_driver) Columns 

func (Proxy *RowsColumnTypePrecisionScale_database_sql_driver) Columns() []string

func (*RowsColumnTypePrecisionScale_database_sql_driver) Next 

func (Proxy *RowsColumnTypePrecisionScale_database_sql_driver) Next(dest []driver.Value) error

type RowsColumnTypeScanType_database_sql_driver 

type RowsColumnTypeScanType_database_sql_driver struct {
	Object              interface{}
	Close_              func(interface{}) error
	ColumnTypeScanType_ func(_proxy_obj_ interface{}, index int) reflect.Type
	Columns_            func(interface{}) []string
	Next_               func(_proxy_obj_ interface{}, dest []driver.Value) error
}

--------------- proxy for database/sql/driver.RowsColumnTypeScanType ---------------

func (*RowsColumnTypeScanType_database_sql_driver) Close 

func (Proxy *RowsColumnTypeScanType_database_sql_driver) Close() error

func (*RowsColumnTypeScanType_database_sql_driver) ColumnTypeScanType 

func (Proxy *RowsColumnTypeScanType_database_sql_driver) ColumnTypeScanType(index int) reflect.Type

func (*RowsColumnTypeScanType_database_sql_driver) Columns 

func (Proxy *RowsColumnTypeScanType_database_sql_driver) Columns() []string

func (*RowsColumnTypeScanType_database_sql_driver) Next 

func (Proxy *RowsColumnTypeScanType_database_sql_driver) Next(dest []driver.Value) error

type RowsNextResultSet_database_sql_driver 

type RowsNextResultSet_database_sql_driver struct {
	Object            interface{}
	Close_            func(interface{}) error
	Columns_          func(interface{}) []string
	HasNextResultSet_ func(interface{}) bool
	Next_             func(_proxy_obj_ interface{}, dest []driver.Value) error
	NextResultSet_    func(interface{}) error
}

--------------- proxy for database/sql/driver.RowsNextResultSet ---------------

func (*RowsNextResultSet_database_sql_driver) Close 

func (Proxy *RowsNextResultSet_database_sql_driver) Close() error

func (*RowsNextResultSet_database_sql_driver) Columns 

func (Proxy *RowsNextResultSet_database_sql_driver) Columns() []string

func (*RowsNextResultSet_database_sql_driver) HasNextResultSet 

func (Proxy *RowsNextResultSet_database_sql_driver) HasNextResultSet() bool

func (*RowsNextResultSet_database_sql_driver) Next 

func (Proxy *RowsNextResultSet_database_sql_driver) Next(dest []driver.Value) error

func (*RowsNextResultSet_database_sql_driver) NextResultSet 

func (Proxy *RowsNextResultSet_database_sql_driver) NextResultSet() error

type Rows_database_sql_driver 

type Rows_database_sql_driver struct {
	Object   interface{}
	Close_   func(interface{}) error
	Columns_ func(interface{}) []string
	Next_    func(_proxy_obj_ interface{}, dest []driver.Value) error
}

--------------- proxy for database/sql/driver.Rows ---------------

func (*Rows_database_sql_driver) Close 

func (Proxy *Rows_database_sql_driver) Close() error

func (*Rows_database_sql_driver) Columns 

func (Proxy *Rows_database_sql_driver) Columns() []string

func (*Rows_database_sql_driver) Next 

func (Proxy *Rows_database_sql_driver) Next(dest []driver.Value) error

type RuneReader_io 

type RuneReader_io struct {
	Object    interface{}
	ReadRune_ func(interface{}) (r rune, size int, err error)
}

--------------- proxy for io.RuneReader ---------------

func (*RuneReader_io) ReadRune 

func (Proxy *RuneReader_io) ReadRune() (r rune, size int, err error)

type RuneScanner_io 

type RuneScanner_io struct {
	Object      interface{}
	ReadRune_   func(interface{}) (r rune, size int, err error)
	UnreadRune_ func(interface{}) error
}

--------------- proxy for io.RuneScanner ---------------

func (*RuneScanner_io) ReadRune 

func (Proxy *RuneScanner_io) ReadRune() (r rune, size int, err error)

func (*RuneScanner_io) UnreadRune 

func (Proxy *RuneScanner_io) UnreadRune() error

type ScanState_fmt 

type ScanState_fmt struct {
	Object      interface{}
	Read_       func(_proxy_obj_ interface{}, buf []byte) (n int, err error)
	ReadRune_   func(interface{}) (r rune, size int, err error)
	SkipSpace_  func(interface{})
	Token_      func(_proxy_obj_ interface{}, skipSpace bool, f func(rune) bool) (token []byte, err error)
	UnreadRune_ func(interface{}) error
	Width_      func(interface{}) (wid int, ok bool)
}

--------------- proxy for fmt.ScanState ---------------

func (*ScanState_fmt) Read 

func (Proxy *ScanState_fmt) Read(buf []byte) (n int, err error)

func (*ScanState_fmt) ReadRune 

func (Proxy *ScanState_fmt) ReadRune() (r rune, size int, err error)

func (*ScanState_fmt) SkipSpace 

func (Proxy *ScanState_fmt) SkipSpace()

func (*ScanState_fmt) Token 

func (Proxy *ScanState_fmt) Token(skipSpace bool, f func(rune) bool) (token []byte, err error)

func (*ScanState_fmt) UnreadRune 

func (Proxy *ScanState_fmt) UnreadRune() error

func (*ScanState_fmt) Width 

func (Proxy *ScanState_fmt) Width() (wid int, ok bool)

type Scanner_database_sql 

type Scanner_database_sql struct {
	Object interface{}
	Scan_  func(_proxy_obj_ interface{}, src interface{}) error
}

--------------- proxy for database/sql.Scanner ---------------

func (*Scanner_database_sql) Scan 

func (Proxy *Scanner_database_sql) Scan(src interface{}) error

type Scanner_fmt 

type Scanner_fmt struct {
	Object interface{}
	Scan_  func(_proxy_obj_ interface{}, state fmt.ScanState, verb rune) error
}

--------------- proxy for fmt.Scanner ---------------

func (*Scanner_fmt) Scan 

func (Proxy *Scanner_fmt) Scan(state fmt.ScanState, verb rune) error

type Seeker_io 

type Seeker_io struct {
	Object interface{}
	Seek_  func(_proxy_obj_ interface{}, offset int64, whence int) (int64, error)
}

--------------- proxy for io.Seeker ---------------

func (*Seeker_io) Seek 

func (Proxy *Seeker_io) Seek(offset int64, whence int) (int64, error)

type ServerCodec_net_rpc 

type ServerCodec_net_rpc struct {
	Object             interface{}
	Close_             func(interface{}) error
	ReadRequestBody_   func(interface{}, interface{}) error
	ReadRequestHeader_ func(interface{}, *rpc.Request) error
	WriteResponse_     func(interface{}, *rpc.Response, interface{}) error
}

--------------- proxy for net/rpc.ServerCodec ---------------

func (*ServerCodec_net_rpc) Close 

func (Proxy *ServerCodec_net_rpc) Close() error

func (*ServerCodec_net_rpc) ReadRequestBody 

func (Proxy *ServerCodec_net_rpc) ReadRequestBody(unnamed0 interface{}) error

func (*ServerCodec_net_rpc) ReadRequestHeader 

func (Proxy *ServerCodec_net_rpc) ReadRequestHeader(unnamed0 *rpc.Request) error

func (*ServerCodec_net_rpc) WriteResponse 

func (Proxy *ServerCodec_net_rpc) WriteResponse(unnamed0 *rpc.Response, unnamed1 interface{}) error

type Signal_os 

type Signal_os struct {
	Object  interface{}
	Signal_ func(interface{})
	String_ func(interface{}) string
}

--------------- proxy for os.Signal ---------------

func (*Signal_os) Signal 

func (Proxy *Signal_os) Signal()

func (*Signal_os) String 

func (Proxy *Signal_os) String() string

type SignerOpts_crypto 

type SignerOpts_crypto struct {
	Object    interface{}
	HashFunc_ func(interface{}) crypto.Hash
}

--------------- proxy for crypto.SignerOpts ---------------

func (*SignerOpts_crypto) HashFunc 

func (Proxy *SignerOpts_crypto) HashFunc() crypto.Hash

type Signer_crypto 

type Signer_crypto struct {
	Object  interface{}
	Public_ func(interface{}) crypto.PublicKey
	Sign_   func(_proxy_obj_ interface{}, rand io.Reader, digest []byte, opts crypto.SignerOpts) (signature []byte, err error)
}

--------------- proxy for crypto.Signer ---------------

func (*Signer_crypto) Public 

func (Proxy *Signer_crypto) Public() crypto.PublicKey

func (*Signer_crypto) Sign 

func (Proxy *Signer_crypto) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) (signature []byte, err error)

type Sizes_go_types 

type Sizes_go_types struct {
	Object     interface{}
	Alignof_   func(_proxy_obj_ interface{}, T types.Type) int64
	Offsetsof_ func(_proxy_obj_ interface{}, fields []*types.Var) []int64
	Sizeof_    func(_proxy_obj_ interface{}, T types.Type) int64
}

--------------- proxy for go/types.Sizes ---------------

func (*Sizes_go_types) Alignof 

func (Proxy *Sizes_go_types) Alignof(T types.Type) int64

func (*Sizes_go_types) Offsetsof 

func (Proxy *Sizes_go_types) Offsetsof(fields []*types.Var) []int64

func (*Sizes_go_types) Sizeof 

func (Proxy *Sizes_go_types) Sizeof(T types.Type) int64

type Source64_math_rand 

type Source64_math_rand struct {
	Object  interface{}
	Int63_  func(interface{}) int64
	Seed_   func(_proxy_obj_ interface{}, seed int64)
	Uint64_ func(interface{}) uint64
}

--------------- proxy for math/rand.Source64 ---------------

func (*Source64_math_rand) Int63 

func (Proxy *Source64_math_rand) Int63() int64

func (*Source64_math_rand) Seed 

func (Proxy *Source64_math_rand) Seed(seed int64)

func (*Source64_math_rand) Uint64 

func (Proxy *Source64_math_rand) Uint64() uint64

type Source_math_rand 

type Source_math_rand struct {
	Object interface{}
	Int63_ func(interface{}) int64
	Seed_  func(_proxy_obj_ interface{}, seed int64)
}

--------------- proxy for math/rand.Source ---------------

func (*Source_math_rand) Int63 

func (Proxy *Source_math_rand) Int63() int64

func (*Source_math_rand) Seed 

func (Proxy *Source_math_rand) Seed(seed int64)

type State_fmt 

type State_fmt struct {
	Object     interface{}
	Flag_      func(_proxy_obj_ interface{}, c int) bool
	Precision_ func(interface{}) (prec int, ok bool)
	Width_     func(interface{}) (wid int, ok bool)
	Write_     func(_proxy_obj_ interface{}, b []byte) (n int, err error)
}

--------------- proxy for fmt.State ---------------

func (*State_fmt) Flag 

func (Proxy *State_fmt) Flag(c int) bool

func (*State_fmt) Precision 

func (Proxy *State_fmt) Precision() (prec int, ok bool)

func (*State_fmt) Width 

func (Proxy *State_fmt) Width() (wid int, ok bool)

func (*State_fmt) Write 

func (Proxy *State_fmt) Write(b []byte) (n int, err error)

type StmtExecContext_database_sql_driver 

type StmtExecContext_database_sql_driver struct {
	Object       interface{}
	ExecContext_ func(_proxy_obj_ interface{}, ctx context.Context, args []driver.NamedValue) (driver.Result, error)
}

--------------- proxy for database/sql/driver.StmtExecContext ---------------

func (*StmtExecContext_database_sql_driver) ExecContext 

func (Proxy *StmtExecContext_database_sql_driver) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error)

type StmtQueryContext_database_sql_driver 

type StmtQueryContext_database_sql_driver struct {
	Object        interface{}
	QueryContext_ func(_proxy_obj_ interface{}, ctx context.Context, args []driver.NamedValue) (driver.Rows, error)
}

--------------- proxy for database/sql/driver.StmtQueryContext ---------------

func (*StmtQueryContext_database_sql_driver) QueryContext 

func (Proxy *StmtQueryContext_database_sql_driver) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error)

type Stmt_database_sql_driver 

type Stmt_database_sql_driver struct {
	Object    interface{}
	Close_    func(interface{}) error
	Exec_     func(_proxy_obj_ interface{}, args []driver.Value) (driver.Result, error)
	NumInput_ func(interface{}) int
	Query_    func(_proxy_obj_ interface{}, args []driver.Value) (driver.Rows, error)
}

--------------- proxy for database/sql/driver.Stmt ---------------

func (*Stmt_database_sql_driver) Close 

func (Proxy *Stmt_database_sql_driver) Close() error

func (*Stmt_database_sql_driver) Exec 

func (Proxy *Stmt_database_sql_driver) Exec(args []driver.Value) (driver.Result, error)

func (*Stmt_database_sql_driver) NumInput 

func (Proxy *Stmt_database_sql_driver) NumInput() int

func (*Stmt_database_sql_driver) Query 

func (Proxy *Stmt_database_sql_driver) Query(args []driver.Value) (driver.Rows, error)

type Stream_crypto_cipher 

type Stream_crypto_cipher struct {
	Object        interface{}
	XORKeyStream_ func(_proxy_obj_ interface{}, dst []byte, src []byte)
}

--------------- proxy for crypto/cipher.Stream ---------------

func (*Stream_crypto_cipher) XORKeyStream 

func (Proxy *Stream_crypto_cipher) XORKeyStream(dst []byte, src []byte)

type Stringer_fmt 

type Stringer_fmt struct {
	Object  interface{}
	String_ func(interface{}) string
}

--------------- proxy for fmt.Stringer ---------------

func (*Stringer_fmt) String 

func (Proxy *Stringer_fmt) String() string

type Symbol_plugin 

type Symbol_plugin struct {
	Object interface{}
}

--------------- proxy for plugin.Symbol ---------------

type TextMarshaler_encoding 

type TextMarshaler_encoding struct {
	Object       interface{}
	MarshalText_ func(interface{}) (text []byte, err error)
}

--------------- proxy for encoding.TextMarshaler ---------------

func (*TextMarshaler_encoding) MarshalText 

func (Proxy *TextMarshaler_encoding) MarshalText() (text []byte, err error)

type TextUnmarshaler_encoding 

type TextUnmarshaler_encoding struct {
	Object         interface{}
	UnmarshalText_ func(_proxy_obj_ interface{}, text []byte) error
}

--------------- proxy for encoding.TextUnmarshaler ---------------

func (*TextUnmarshaler_encoding) UnmarshalText 

func (Proxy *TextUnmarshaler_encoding) UnmarshalText(text []byte) error

type Token_encoding_json 

type Token_encoding_json struct {
	Object interface{}
}

--------------- proxy for encoding/json.Token ---------------

type Token_encoding_xml 

type Token_encoding_xml struct {
	Object interface{}
}

--------------- proxy for encoding/xml.Token ---------------

type Tx_database_sql_driver 

type Tx_database_sql_driver struct {
	Object    interface{}
	Commit_   func(interface{}) error
	Rollback_ func(interface{}) error
}

--------------- proxy for database/sql/driver.Tx ---------------

func (*Tx_database_sql_driver) Commit 

func (Proxy *Tx_database_sql_driver) Commit() error

func (*Tx_database_sql_driver) Rollback 

func (Proxy *Tx_database_sql_driver) Rollback() error

type Type_debug_dwarf 

type Type_debug_dwarf struct {
	Object  interface{}
	Common_ func(interface{}) *dwarf.CommonType
	Size_   func(interface{}) int64
	String_ func(interface{}) string
}

--------------- proxy for debug/dwarf.Type ---------------

func (*Type_debug_dwarf) Common 

func (Proxy *Type_debug_dwarf) Common() *dwarf.CommonType

func (*Type_debug_dwarf) Size 

func (Proxy *Type_debug_dwarf) Size() int64

func (*Type_debug_dwarf) String 

func (Proxy *Type_debug_dwarf) String() string

type Type_go_types 

type Type_go_types struct {
	Object      interface{}
	String_     func(interface{}) string
	Underlying_ func(interface{}) types.Type
}

--------------- proxy for go/types.Type ---------------

func (*Type_go_types) String 

func (Proxy *Type_go_types) String() string

func (*Type_go_types) Underlying 

func (Proxy *Type_go_types) Underlying() types.Type

type UnmarshalerAttr_encoding_xml 

type UnmarshalerAttr_encoding_xml struct {
	Object            interface{}
	UnmarshalXMLAttr_ func(_proxy_obj_ interface{}, attr xml.Attr) error
}

--------------- proxy for encoding/xml.UnmarshalerAttr ---------------

func (*UnmarshalerAttr_encoding_xml) UnmarshalXMLAttr 

func (Proxy *UnmarshalerAttr_encoding_xml) UnmarshalXMLAttr(attr xml.Attr) error

type Unmarshaler_encoding_json 

type Unmarshaler_encoding_json struct {
	Object         interface{}
	UnmarshalJSON_ func(interface{}, []byte) error
}

--------------- proxy for encoding/json.Unmarshaler ---------------

func (*Unmarshaler_encoding_json) UnmarshalJSON 

func (Proxy *Unmarshaler_encoding_json) UnmarshalJSON(unnamed0 []byte) error

type Unmarshaler_encoding_xml 

type Unmarshaler_encoding_xml struct {
	Object        interface{}
	UnmarshalXML_ func(_proxy_obj_ interface{}, d *xml.Decoder, start xml.StartElement) error
}

--------------- proxy for encoding/xml.Unmarshaler ---------------

func (*Unmarshaler_encoding_xml) UnmarshalXML 

func (Proxy *Unmarshaler_encoding_xml) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type ValueConverter_database_sql_driver 

type ValueConverter_database_sql_driver struct {
	Object        interface{}
	ConvertValue_ func(_proxy_obj_ interface{}, v interface{}) (driver.Value, error)
}

--------------- proxy for database/sql/driver.ValueConverter ---------------

func (*ValueConverter_database_sql_driver) ConvertValue 

func (Proxy *ValueConverter_database_sql_driver) ConvertValue(v interface{}) (driver.Value, error)

type Value_database_sql_driver 

type Value_database_sql_driver struct {
	Object interface{}
}

--------------- proxy for database/sql/driver.Value ---------------

type Value_flag 

type Value_flag struct {
	Object  interface{}
	Set_    func(interface{}, string) error
	String_ func(interface{}) string
}

--------------- proxy for flag.Value ---------------

func (*Value_flag) Set 

func (Proxy *Value_flag) Set(unnamed0 string) error

func (*Value_flag) String 

func (Proxy *Value_flag) String() string

type Valuer_database_sql_driver 

type Valuer_database_sql_driver struct {
	Object interface{}
	Value_ func(interface{}) (driver.Value, error)
}

--------------- proxy for database/sql/driver.Valuer ---------------

func (*Valuer_database_sql_driver) Value 

func (Proxy *Valuer_database_sql_driver) Value() (driver.Value, error)

type Var_expvar 

type Var_expvar struct {
	Object  interface{}
	String_ func(interface{}) string
}

--------------- proxy for expvar.Var ---------------

func (*Var_expvar) String 

func (Proxy *Var_expvar) String() string

type Visitor_go_ast 

type Visitor_go_ast struct {
	Object interface{}
	Visit_ func(_proxy_obj_ interface{}, node ast.Node) (w ast.Visitor)
}

--------------- proxy for go/ast.Visitor ---------------

func (*Visitor_go_ast) Visit 

func (Proxy *Visitor_go_ast) Visit(node ast.Node) (w ast.Visitor)

type WriteCloser_io 

type WriteCloser_io struct {
	Object interface{}
	Close_ func(interface{}) error
	Write_ func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

--------------- proxy for io.WriteCloser ---------------

func (*WriteCloser_io) Close 

func (Proxy *WriteCloser_io) Close() error

func (*WriteCloser_io) Write 

func (Proxy *WriteCloser_io) Write(p []byte) (n int, err error)

type WriteSeeker_io 

type WriteSeeker_io struct {
	Object interface{}
	Seek_  func(_proxy_obj_ interface{}, offset int64, whence int) (int64, error)
	Write_ func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

--------------- proxy for io.WriteSeeker ---------------

func (*WriteSeeker_io) Seek 

func (Proxy *WriteSeeker_io) Seek(offset int64, whence int) (int64, error)

func (*WriteSeeker_io) Write 

func (Proxy *WriteSeeker_io) Write(p []byte) (n int, err error)

type WriterAt_io 

type WriterAt_io struct {
	Object   interface{}
	WriteAt_ func(_proxy_obj_ interface{}, p []byte, off int64) (n int, err error)
}

--------------- proxy for io.WriterAt ---------------

func (*WriterAt_io) WriteAt 

func (Proxy *WriterAt_io) WriteAt(p []byte, off int64) (n int, err error)

type WriterTo_io 

type WriterTo_io struct {
	Object   interface{}
	WriteTo_ func(_proxy_obj_ interface{}, w io.Writer) (n int64, err error)
}

--------------- proxy for io.WriterTo ---------------

func (*WriterTo_io) WriteTo 

func (Proxy *WriterTo_io) WriteTo(w io.Writer) (n int64, err error)

type Writer_io 

type Writer_io struct {
	Object interface{}
	Write_ func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

--------------- proxy for io.Writer ---------------

func (*Writer_io) Write 

func (Proxy *Writer_io) Write(p []byte) (n int, err error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.