imports

package
v0.0.0-...-d96f53a Latest Latest
Warning

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

 Go to latest Published: May 26, 2021 License: MPL-2.0 Imports: 143 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var Packages = make(PackageMap)

Functions

This section is empty.

Types

type P_compress_flate_Reader 

type P_compress_flate_Reader 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 (*P_compress_flate_Reader) Read 

func (P *P_compress_flate_Reader) Read(p []byte) (n int, err error)

func (*P_compress_flate_Reader) ReadByte 

func (P *P_compress_flate_Reader) ReadByte() (byte, error)

type P_compress_flate_Resetter 

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

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

func (*P_compress_flate_Resetter) Reset 

func (P *P_compress_flate_Resetter) Reset(r io.Reader, dict []byte) error

type P_compress_zlib_Resetter 

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

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

func (*P_compress_zlib_Resetter) Reset 

func (P *P_compress_zlib_Resetter) Reset(r io.Reader, dict []byte) error

type P_container_heap_Interface 

type P_container_heap_Interface 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 (*P_container_heap_Interface) Len 

func (P *P_container_heap_Interface) Len() int

func (*P_container_heap_Interface) Less 

func (P *P_container_heap_Interface) Less(i int, j int) bool

func (*P_container_heap_Interface) Pop 

func (P *P_container_heap_Interface) Pop() interface{}

func (*P_container_heap_Interface) Push 

func (P *P_container_heap_Interface) Push(x interface{})

func (*P_container_heap_Interface) Swap 

func (P *P_container_heap_Interface) Swap(i int, j int)

type P_context_Context 

type P_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 (*P_context_Context) Deadline 

func (P *P_context_Context) Deadline() (deadline time.Time, ok bool)

func (*P_context_Context) Done 

func (P *P_context_Context) Done() <-chan struct{}

func (*P_context_Context) Err 

func (P *P_context_Context) Err() error

func (*P_context_Context) Value 

func (P *P_context_Context) Value(key interface{}) interface{}

type P_crypto_Decrypter 

type P_crypto_Decrypter 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 (*P_crypto_Decrypter) Decrypt 

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

func (*P_crypto_Decrypter) Public 

func (P *P_crypto_Decrypter) Public() crypto.PublicKey

type P_crypto_Signer 

type P_crypto_Signer 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 (*P_crypto_Signer) Public 

func (P *P_crypto_Signer) Public() crypto.PublicKey

func (*P_crypto_Signer) Sign 

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

type P_crypto_SignerOpts 

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

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

func (*P_crypto_SignerOpts) HashFunc 

func (P *P_crypto_SignerOpts) HashFunc() crypto.Hash

type P_crypto_cipher_AEAD 

type P_crypto_cipher_AEAD 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 (*P_crypto_cipher_AEAD) NonceSize 

func (P *P_crypto_cipher_AEAD) NonceSize() int

func (*P_crypto_cipher_AEAD) Open 

func (P *P_crypto_cipher_AEAD) Open(dst []byte, nonce []byte, ciphertext []byte, additionalData []byte) ([]byte, error)

func (*P_crypto_cipher_AEAD) Overhead 

func (P *P_crypto_cipher_AEAD) Overhead() int

func (*P_crypto_cipher_AEAD) Seal 

func (P *P_crypto_cipher_AEAD) Seal(dst []byte, nonce []byte, plaintext []byte, additionalData []byte) []byte

type P_crypto_cipher_Block 

type P_crypto_cipher_Block 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 (*P_crypto_cipher_Block) BlockSize 

func (P *P_crypto_cipher_Block) BlockSize() int

func (*P_crypto_cipher_Block) Decrypt 

func (P *P_crypto_cipher_Block) Decrypt(dst []byte, src []byte)

func (*P_crypto_cipher_Block) Encrypt 

func (P *P_crypto_cipher_Block) Encrypt(dst []byte, src []byte)

type P_crypto_cipher_BlockMode 

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

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

func (*P_crypto_cipher_BlockMode) BlockSize 

func (P *P_crypto_cipher_BlockMode) BlockSize() int

func (*P_crypto_cipher_BlockMode) CryptBlocks 

func (P *P_crypto_cipher_BlockMode) CryptBlocks(dst []byte, src []byte)

type P_crypto_cipher_Stream 

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

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

func (*P_crypto_cipher_Stream) XORKeyStream 

func (P *P_crypto_cipher_Stream) XORKeyStream(dst []byte, src []byte)

type P_crypto_elliptic_Curve 

type P_crypto_elliptic_Curve 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 (*P_crypto_elliptic_Curve) Add 

func (P *P_crypto_elliptic_Curve) Add(x1 *big.Int, y1 *big.Int, x2 *big.Int, y2 *big.Int) (x *big.Int, y *big.Int)

func (*P_crypto_elliptic_Curve) Double 

func (P *P_crypto_elliptic_Curve) Double(x1 *big.Int, y1 *big.Int) (x *big.Int, y *big.Int)

func (*P_crypto_elliptic_Curve) IsOnCurve 

func (P *P_crypto_elliptic_Curve) IsOnCurve(x *big.Int, y *big.Int) bool

func (*P_crypto_elliptic_Curve) Params 

func (P *P_crypto_elliptic_Curve) Params() *elliptic.CurveParams

func (*P_crypto_elliptic_Curve) ScalarBaseMult 

func (P *P_crypto_elliptic_Curve) ScalarBaseMult(k []byte) (x *big.Int, y *big.Int)

func (*P_crypto_elliptic_Curve) ScalarMult 

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

type P_crypto_tls_ClientSessionCache 

type P_crypto_tls_ClientSessionCache 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 (*P_crypto_tls_ClientSessionCache) Get 

func (P *P_crypto_tls_ClientSessionCache) Get(sessionKey string) (session *tls.ClientSessionState, ok bool)

func (*P_crypto_tls_ClientSessionCache) Put 

func (P *P_crypto_tls_ClientSessionCache) Put(sessionKey string, cs *tls.ClientSessionState)

type P_database_sql_Result 

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

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

func (*P_database_sql_Result) LastInsertId 

func (P *P_database_sql_Result) LastInsertId() (int64, error)

func (*P_database_sql_Result) RowsAffected 

func (P *P_database_sql_Result) RowsAffected() (int64, error)

type P_database_sql_Scanner 

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

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

func (*P_database_sql_Scanner) Scan 

func (P *P_database_sql_Scanner) Scan(src interface{}) error

type P_database_sql_driver_ColumnConverter 

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

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

func (*P_database_sql_driver_ColumnConverter) ColumnConverter 

func (P *P_database_sql_driver_ColumnConverter) ColumnConverter(idx int) driver.ValueConverter

type P_database_sql_driver_Conn 

type P_database_sql_driver_Conn 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 (*P_database_sql_driver_Conn) Begin 

func (P *P_database_sql_driver_Conn) Begin() (driver.Tx, error)

func (*P_database_sql_driver_Conn) Close 

func (P *P_database_sql_driver_Conn) Close() error

func (*P_database_sql_driver_Conn) Prepare 

func (P *P_database_sql_driver_Conn) Prepare(query string) (driver.Stmt, error)

type P_database_sql_driver_ConnBeginTx 

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

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

func (*P_database_sql_driver_ConnBeginTx) BeginTx 

func (P *P_database_sql_driver_ConnBeginTx) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error)

type P_database_sql_driver_ConnPrepareContext 

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

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

func (*P_database_sql_driver_ConnPrepareContext) PrepareContext 

func (P *P_database_sql_driver_ConnPrepareContext) PrepareContext(ctx context.Context, query string) (driver.Stmt, error)

type P_database_sql_driver_Connector 

type P_database_sql_driver_Connector struct {
	Object   interface{}
	Connect_ func(interface{}, context.Context) (driver.Conn, error)
	Driver_  func(interface{}) driver.Driver
}

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

func (*P_database_sql_driver_Connector) Connect 

func (P *P_database_sql_driver_Connector) Connect(unnamed0 context.Context) (driver.Conn, error)

func (*P_database_sql_driver_Connector) Driver 

func (P *P_database_sql_driver_Connector) Driver() driver.Driver

type P_database_sql_driver_Driver 

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

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

func (*P_database_sql_driver_Driver) Open 

func (P *P_database_sql_driver_Driver) Open(name string) (driver.Conn, error)

type P_database_sql_driver_DriverContext 

type P_database_sql_driver_DriverContext struct {
	Object         interface{}
	OpenConnector_ func(_proxy_obj_ interface{}, name string) (driver.Connector, error)
}

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

func (*P_database_sql_driver_DriverContext) OpenConnector 

func (P *P_database_sql_driver_DriverContext) OpenConnector(name string) (driver.Connector, error)

type P_database_sql_driver_Execer 

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

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

func (*P_database_sql_driver_Execer) Exec 

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

type P_database_sql_driver_ExecerContext 

type P_database_sql_driver_ExecerContext 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 (*P_database_sql_driver_ExecerContext) ExecContext 

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

type P_database_sql_driver_NamedValueChecker 

type P_database_sql_driver_NamedValueChecker struct {
	Object           interface{}
	CheckNamedValue_ func(interface{}, *driver.NamedValue) error
}

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

func (*P_database_sql_driver_NamedValueChecker) CheckNamedValue 

func (P *P_database_sql_driver_NamedValueChecker) CheckNamedValue(unnamed0 *driver.NamedValue) error

type P_database_sql_driver_Pinger 

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

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

func (*P_database_sql_driver_Pinger) Ping 

func (P *P_database_sql_driver_Pinger) Ping(ctx context.Context) error

type P_database_sql_driver_Queryer 

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

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

func (*P_database_sql_driver_Queryer) Query 

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

type P_database_sql_driver_QueryerContext 

type P_database_sql_driver_QueryerContext 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 (*P_database_sql_driver_QueryerContext) QueryContext 

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

type P_database_sql_driver_Result 

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

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

func (*P_database_sql_driver_Result) LastInsertId 

func (P *P_database_sql_driver_Result) LastInsertId() (int64, error)

func (*P_database_sql_driver_Result) RowsAffected 

func (P *P_database_sql_driver_Result) RowsAffected() (int64, error)

type P_database_sql_driver_Rows 

type P_database_sql_driver_Rows 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 (*P_database_sql_driver_Rows) Close 

func (P *P_database_sql_driver_Rows) Close() error

func (*P_database_sql_driver_Rows) Columns 

func (P *P_database_sql_driver_Rows) Columns() []string

func (*P_database_sql_driver_Rows) Next 

func (P *P_database_sql_driver_Rows) Next(dest []driver.Value) error

type P_database_sql_driver_RowsColumnTypeDatabaseTypeName 

type P_database_sql_driver_RowsColumnTypeDatabaseTypeName 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 (*P_database_sql_driver_RowsColumnTypeDatabaseTypeName) Close 

func (P *P_database_sql_driver_RowsColumnTypeDatabaseTypeName) Close() error

func (*P_database_sql_driver_RowsColumnTypeDatabaseTypeName) ColumnTypeDatabaseTypeName 

func (P *P_database_sql_driver_RowsColumnTypeDatabaseTypeName) ColumnTypeDatabaseTypeName(index int) string

func (*P_database_sql_driver_RowsColumnTypeDatabaseTypeName) Columns 

func (P *P_database_sql_driver_RowsColumnTypeDatabaseTypeName) Columns() []string

func (*P_database_sql_driver_RowsColumnTypeDatabaseTypeName) Next 

func (P *P_database_sql_driver_RowsColumnTypeDatabaseTypeName) Next(dest []driver.Value) error

type P_database_sql_driver_RowsColumnTypeLength 

type P_database_sql_driver_RowsColumnTypeLength 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 (*P_database_sql_driver_RowsColumnTypeLength) Close 

func (P *P_database_sql_driver_RowsColumnTypeLength) Close() error

func (*P_database_sql_driver_RowsColumnTypeLength) ColumnTypeLength 

func (P *P_database_sql_driver_RowsColumnTypeLength) ColumnTypeLength(index int) (length int64, ok bool)

func (*P_database_sql_driver_RowsColumnTypeLength) Columns 

func (P *P_database_sql_driver_RowsColumnTypeLength) Columns() []string

func (*P_database_sql_driver_RowsColumnTypeLength) Next 

func (P *P_database_sql_driver_RowsColumnTypeLength) Next(dest []driver.Value) error

type P_database_sql_driver_RowsColumnTypeNullable 

type P_database_sql_driver_RowsColumnTypeNullable 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 (*P_database_sql_driver_RowsColumnTypeNullable) Close 

func (P *P_database_sql_driver_RowsColumnTypeNullable) Close() error

func (*P_database_sql_driver_RowsColumnTypeNullable) ColumnTypeNullable 

func (P *P_database_sql_driver_RowsColumnTypeNullable) ColumnTypeNullable(index int) (nullable bool, ok bool)

func (*P_database_sql_driver_RowsColumnTypeNullable) Columns 

func (P *P_database_sql_driver_RowsColumnTypeNullable) Columns() []string

func (*P_database_sql_driver_RowsColumnTypeNullable) Next 

func (P *P_database_sql_driver_RowsColumnTypeNullable) Next(dest []driver.Value) error

type P_database_sql_driver_RowsColumnTypePrecisionScale 

type P_database_sql_driver_RowsColumnTypePrecisionScale 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 (*P_database_sql_driver_RowsColumnTypePrecisionScale) Close 

func (P *P_database_sql_driver_RowsColumnTypePrecisionScale) Close() error

func (*P_database_sql_driver_RowsColumnTypePrecisionScale) ColumnTypePrecisionScale 

func (P *P_database_sql_driver_RowsColumnTypePrecisionScale) ColumnTypePrecisionScale(index int) (precision int64, scale int64, ok bool)

func (*P_database_sql_driver_RowsColumnTypePrecisionScale) Columns 

func (P *P_database_sql_driver_RowsColumnTypePrecisionScale) Columns() []string

func (*P_database_sql_driver_RowsColumnTypePrecisionScale) Next 

func (P *P_database_sql_driver_RowsColumnTypePrecisionScale) Next(dest []driver.Value) error

type P_database_sql_driver_RowsColumnTypeScanType 

type P_database_sql_driver_RowsColumnTypeScanType 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 (*P_database_sql_driver_RowsColumnTypeScanType) Close 

func (P *P_database_sql_driver_RowsColumnTypeScanType) Close() error

func (*P_database_sql_driver_RowsColumnTypeScanType) ColumnTypeScanType 

func (P *P_database_sql_driver_RowsColumnTypeScanType) ColumnTypeScanType(index int) reflect.Type

func (*P_database_sql_driver_RowsColumnTypeScanType) Columns 

func (P *P_database_sql_driver_RowsColumnTypeScanType) Columns() []string

func (*P_database_sql_driver_RowsColumnTypeScanType) Next 

func (P *P_database_sql_driver_RowsColumnTypeScanType) Next(dest []driver.Value) error

type P_database_sql_driver_RowsNextResultSet 

type P_database_sql_driver_RowsNextResultSet 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 (*P_database_sql_driver_RowsNextResultSet) Close 

func (P *P_database_sql_driver_RowsNextResultSet) Close() error

func (*P_database_sql_driver_RowsNextResultSet) Columns 

func (P *P_database_sql_driver_RowsNextResultSet) Columns() []string

func (*P_database_sql_driver_RowsNextResultSet) HasNextResultSet 

func (P *P_database_sql_driver_RowsNextResultSet) HasNextResultSet() bool

func (*P_database_sql_driver_RowsNextResultSet) Next 

func (P *P_database_sql_driver_RowsNextResultSet) Next(dest []driver.Value) error

func (*P_database_sql_driver_RowsNextResultSet) NextResultSet 

func (P *P_database_sql_driver_RowsNextResultSet) NextResultSet() error

type P_database_sql_driver_SessionResetter 

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

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

func (*P_database_sql_driver_SessionResetter) ResetSession 

func (P *P_database_sql_driver_SessionResetter) ResetSession(ctx context.Context) error

type P_database_sql_driver_Stmt 

type P_database_sql_driver_Stmt 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 (*P_database_sql_driver_Stmt) Close 

func (P *P_database_sql_driver_Stmt) Close() error

func (*P_database_sql_driver_Stmt) Exec 

func (P *P_database_sql_driver_Stmt) Exec(args []driver.Value) (driver.Result, error)

func (*P_database_sql_driver_Stmt) NumInput 

func (P *P_database_sql_driver_Stmt) NumInput() int

func (*P_database_sql_driver_Stmt) Query 

func (P *P_database_sql_driver_Stmt) Query(args []driver.Value) (driver.Rows, error)

type P_database_sql_driver_StmtExecContext 

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

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

func (*P_database_sql_driver_StmtExecContext) ExecContext 

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

type P_database_sql_driver_StmtQueryContext 

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

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

func (*P_database_sql_driver_StmtQueryContext) QueryContext 

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

type P_database_sql_driver_Tx 

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

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

func (*P_database_sql_driver_Tx) Commit 

func (P *P_database_sql_driver_Tx) Commit() error

func (*P_database_sql_driver_Tx) Rollback 

func (P *P_database_sql_driver_Tx) Rollback() error

type P_database_sql_driver_ValueConverter 

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

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

func (*P_database_sql_driver_ValueConverter) ConvertValue 

func (P *P_database_sql_driver_ValueConverter) ConvertValue(v interface{}) (driver.Value, error)

type P_database_sql_driver_Valuer 

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

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

func (*P_database_sql_driver_Valuer) Value 

func (P *P_database_sql_driver_Valuer) Value() (driver.Value, error)

type P_debug_dwarf_Type 

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

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

func (*P_debug_dwarf_Type) Common 

func (P *P_debug_dwarf_Type) Common() *dwarf.CommonType

func (*P_debug_dwarf_Type) Size 

func (P *P_debug_dwarf_Type) Size() int64

func (*P_debug_dwarf_Type) String 

func (P *P_debug_dwarf_Type) String() string

type P_debug_macho_Load 

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

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

func (*P_debug_macho_Load) Raw 

func (P *P_debug_macho_Load) Raw() []byte

type P_encoding_BinaryMarshaler 

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

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

func (*P_encoding_BinaryMarshaler) MarshalBinary 

func (P *P_encoding_BinaryMarshaler) MarshalBinary() (data []byte, err error)

type P_encoding_BinaryUnmarshaler 

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

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

func (*P_encoding_BinaryUnmarshaler) UnmarshalBinary 

func (P *P_encoding_BinaryUnmarshaler) UnmarshalBinary(data []byte) error

type P_encoding_TextMarshaler 

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

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

func (*P_encoding_TextMarshaler) MarshalText 

func (P *P_encoding_TextMarshaler) MarshalText() (text []byte, err error)

type P_encoding_TextUnmarshaler 

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

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

func (*P_encoding_TextUnmarshaler) UnmarshalText 

func (P *P_encoding_TextUnmarshaler) UnmarshalText(text []byte) error

type P_encoding_binary_ByteOrder 

type P_encoding_binary_ByteOrder 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 (*P_encoding_binary_ByteOrder) PutUint16 

func (P *P_encoding_binary_ByteOrder) PutUint16(unnamed0 []byte, unnamed1 uint16)

func (*P_encoding_binary_ByteOrder) PutUint32 

func (P *P_encoding_binary_ByteOrder) PutUint32(unnamed0 []byte, unnamed1 uint32)

func (*P_encoding_binary_ByteOrder) PutUint64 

func (P *P_encoding_binary_ByteOrder) PutUint64(unnamed0 []byte, unnamed1 uint64)

func (*P_encoding_binary_ByteOrder) String 

func (P *P_encoding_binary_ByteOrder) String() string

func (*P_encoding_binary_ByteOrder) Uint16 

func (P *P_encoding_binary_ByteOrder) Uint16(unnamed0 []byte) uint16

func (*P_encoding_binary_ByteOrder) Uint32 

func (P *P_encoding_binary_ByteOrder) Uint32(unnamed0 []byte) uint32

func (*P_encoding_binary_ByteOrder) Uint64 

func (P *P_encoding_binary_ByteOrder) Uint64(unnamed0 []byte) uint64

type P_encoding_gob_GobDecoder 

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

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

func (*P_encoding_gob_GobDecoder) GobDecode 

func (P *P_encoding_gob_GobDecoder) GobDecode(unnamed0 []byte) error

type P_encoding_gob_GobEncoder 

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

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

func (*P_encoding_gob_GobEncoder) GobEncode 

func (P *P_encoding_gob_GobEncoder) GobEncode() ([]byte, error)

type P_encoding_json_Marshaler 

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

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

func (*P_encoding_json_Marshaler) MarshalJSON 

func (P *P_encoding_json_Marshaler) MarshalJSON() ([]byte, error)

type P_encoding_json_Unmarshaler 

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

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

func (*P_encoding_json_Unmarshaler) UnmarshalJSON 

func (P *P_encoding_json_Unmarshaler) UnmarshalJSON(unnamed0 []byte) error

type P_encoding_xml_Marshaler 

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

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

func (*P_encoding_xml_Marshaler) MarshalXML 

func (P *P_encoding_xml_Marshaler) MarshalXML(e *xml.Encoder, start xml.StartElement) error

type P_encoding_xml_MarshalerAttr 

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

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

func (*P_encoding_xml_MarshalerAttr) MarshalXMLAttr 

func (P *P_encoding_xml_MarshalerAttr) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

type P_encoding_xml_TokenReader 

type P_encoding_xml_TokenReader struct {
	Object interface{}
	Token_ func(interface{}) (xml.Token, error)
}

--------------- proxy for encoding/xml.TokenReader ---------------

func (*P_encoding_xml_TokenReader) Token 

func (P *P_encoding_xml_TokenReader) Token() (xml.Token, error)

type P_encoding_xml_Unmarshaler 

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

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

func (*P_encoding_xml_Unmarshaler) UnmarshalXML 

func (P *P_encoding_xml_Unmarshaler) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type P_encoding_xml_UnmarshalerAttr 

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

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

func (*P_encoding_xml_UnmarshalerAttr) UnmarshalXMLAttr 

func (P *P_encoding_xml_UnmarshalerAttr) UnmarshalXMLAttr(attr xml.Attr) error

type P_expvar_Var 

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

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

func (*P_expvar_Var) String 

func (P *P_expvar_Var) String() string

type P_flag_Getter 

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

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

func (*P_flag_Getter) Get 

func (P *P_flag_Getter) Get() interface{}

func (*P_flag_Getter) Set 

func (P *P_flag_Getter) Set(unnamed0 string) error

func (*P_flag_Getter) String 

func (P *P_flag_Getter) String() string

type P_flag_Value 

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

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

func (*P_flag_Value) Set 

func (P *P_flag_Value) Set(unnamed0 string) error

func (*P_flag_Value) String 

func (P *P_flag_Value) String() string

type P_fmt_Formatter 

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

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

func (*P_fmt_Formatter) Format 

func (P *P_fmt_Formatter) Format(f fmt.State, c rune)

type P_fmt_GoStringer 

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

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

func (*P_fmt_GoStringer) GoString 

func (P *P_fmt_GoStringer) GoString() string

type P_fmt_ScanState 

type P_fmt_ScanState 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 (*P_fmt_ScanState) Read 

func (P *P_fmt_ScanState) Read(buf []byte) (n int, err error)

func (*P_fmt_ScanState) ReadRune 

func (P *P_fmt_ScanState) ReadRune() (r rune, size int, err error)

func (*P_fmt_ScanState) SkipSpace 

func (P *P_fmt_ScanState) SkipSpace()

func (*P_fmt_ScanState) Token 

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

func (*P_fmt_ScanState) UnreadRune 

func (P *P_fmt_ScanState) UnreadRune() error

func (*P_fmt_ScanState) Width 

func (P *P_fmt_ScanState) Width() (wid int, ok bool)

type P_fmt_Scanner 

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

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

func (*P_fmt_Scanner) Scan 

func (P *P_fmt_Scanner) Scan(state fmt.ScanState, verb rune) error

type P_fmt_State 

type P_fmt_State 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 (*P_fmt_State) Flag 

func (P *P_fmt_State) Flag(c int) bool

func (*P_fmt_State) Precision 

func (P *P_fmt_State) Precision() (prec int, ok bool)

func (*P_fmt_State) Width 

func (P *P_fmt_State) Width() (wid int, ok bool)

func (*P_fmt_State) Write 

func (P *P_fmt_State) Write(b []byte) (n int, err error)

type P_fmt_Stringer 

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

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

func (*P_fmt_Stringer) String 

func (P *P_fmt_Stringer) String() string

type P_go_ast_Node 

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

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

func (*P_go_ast_Node) End 

func (P *P_go_ast_Node) End() token.Pos

func (*P_go_ast_Node) Pos 

func (P *P_go_ast_Node) Pos() token.Pos

type P_go_ast_Visitor 

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

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

func (*P_go_ast_Visitor) Visit 

func (P *P_go_ast_Visitor) Visit(node ast.Node) (w ast.Visitor)

type P_go_types_Importer 

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

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

func (*P_go_types_Importer) Import 

func (P *P_go_types_Importer) Import(path string) (*types.Package, error)

type P_go_types_ImporterFrom 

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

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

func (*P_go_types_ImporterFrom) Import 

func (P *P_go_types_ImporterFrom) Import(path string) (*types.Package, error)

func (*P_go_types_ImporterFrom) ImportFrom 

func (P *P_go_types_ImporterFrom) ImportFrom(path string, dir string, mode types.ImportMode) (*types.Package, error)

type P_go_types_Sizes 

type P_go_types_Sizes 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 (*P_go_types_Sizes) Alignof 

func (P *P_go_types_Sizes) Alignof(T types.Type) int64

func (*P_go_types_Sizes) Offsetsof 

func (P *P_go_types_Sizes) Offsetsof(fields []*types.Var) []int64

func (*P_go_types_Sizes) Sizeof 

func (P *P_go_types_Sizes) Sizeof(T types.Type) int64

type P_go_types_Type 

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

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

func (*P_go_types_Type) String 

func (P *P_go_types_Type) String() string

func (*P_go_types_Type) Underlying 

func (P *P_go_types_Type) Underlying() types.Type

type P_hash_Hash 

type P_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 (*P_hash_Hash) BlockSize 

func (P *P_hash_Hash) BlockSize() int

func (*P_hash_Hash) Reset 

func (P *P_hash_Hash) Reset()

func (*P_hash_Hash) Size 

func (P *P_hash_Hash) Size() int

func (*P_hash_Hash) Sum 

func (P *P_hash_Hash) Sum(b []byte) []byte

func (*P_hash_Hash) Write 

func (P *P_hash_Hash) Write(p []byte) (n int, err error)

type P_hash_Hash32 

type P_hash_Hash32 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 (*P_hash_Hash32) BlockSize 

func (P *P_hash_Hash32) BlockSize() int

func (*P_hash_Hash32) Reset 

func (P *P_hash_Hash32) Reset()

func (*P_hash_Hash32) Size 

func (P *P_hash_Hash32) Size() int

func (*P_hash_Hash32) Sum 

func (P *P_hash_Hash32) Sum(b []byte) []byte

func (*P_hash_Hash32) Sum32 

func (P *P_hash_Hash32) Sum32() uint32

func (*P_hash_Hash32) Write 

func (P *P_hash_Hash32) Write(p []byte) (n int, err error)

type P_hash_Hash64 

type P_hash_Hash64 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 (*P_hash_Hash64) BlockSize 

func (P *P_hash_Hash64) BlockSize() int

func (*P_hash_Hash64) Reset 

func (P *P_hash_Hash64) Reset()

func (*P_hash_Hash64) Size 

func (P *P_hash_Hash64) Size() int

func (*P_hash_Hash64) Sum 

func (P *P_hash_Hash64) Sum(b []byte) []byte

func (*P_hash_Hash64) Sum64 

func (P *P_hash_Hash64) Sum64() uint64

func (*P_hash_Hash64) Write 

func (P *P_hash_Hash64) Write(p []byte) (n int, err error)

type P_image_Image 

type P_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 (*P_image_Image) At 

func (P *P_image_Image) At(x int, y int) color.Color

func (*P_image_Image) Bounds 

func (P *P_image_Image) Bounds() image.Rectangle

func (*P_image_Image) ColorModel 

func (P *P_image_Image) ColorModel() color.Model

type P_image_PalettedImage 

type P_image_PalettedImage 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 (*P_image_PalettedImage) At 

func (P *P_image_PalettedImage) At(x int, y int) color.Color

func (*P_image_PalettedImage) Bounds 

func (P *P_image_PalettedImage) Bounds() image.Rectangle

func (*P_image_PalettedImage) ColorIndexAt 

func (P *P_image_PalettedImage) ColorIndexAt(x int, y int) uint8

func (*P_image_PalettedImage) ColorModel 

func (P *P_image_PalettedImage) ColorModel() color.Model

type P_image_color_Color 

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

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

func (*P_image_color_Color) RGBA 

func (P *P_image_color_Color) RGBA() (r uint32, g uint32, b uint32, a uint32)

type P_image_color_Model 

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

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

func (*P_image_color_Model) Convert 

func (P *P_image_color_Model) Convert(c color.Color) color.Color

type P_image_draw_Drawer 

type P_image_draw_Drawer 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 (*P_image_draw_Drawer) Draw 

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

type P_image_draw_Image 

type P_image_draw_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
	Set_        func(_proxy_obj_ interface{}, x int, y int, c color.Color)
}

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

func (*P_image_draw_Image) At 

func (P *P_image_draw_Image) At(x int, y int) color.Color

func (*P_image_draw_Image) Bounds 

func (P *P_image_draw_Image) Bounds() image.Rectangle

func (*P_image_draw_Image) ColorModel 

func (P *P_image_draw_Image) ColorModel() color.Model

func (*P_image_draw_Image) Set 

func (P *P_image_draw_Image) Set(x int, y int, c color.Color)

type P_image_draw_Quantizer 

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

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

func (*P_image_draw_Quantizer) Quantize 

func (P *P_image_draw_Quantizer) Quantize(p color.Palette, m image.Image) color.Palette

type P_image_jpeg_Reader 

type P_image_jpeg_Reader 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 (*P_image_jpeg_Reader) Read 

func (P *P_image_jpeg_Reader) Read(p []byte) (n int, err error)

func (*P_image_jpeg_Reader) ReadByte 

func (P *P_image_jpeg_Reader) ReadByte() (byte, error)

type P_image_png_EncoderBufferPool 

type P_image_png_EncoderBufferPool struct {
	Object interface{}
	Get_   func(interface{}) *png.EncoderBuffer
	Put_   func(interface{}, *png.EncoderBuffer)
}

--------------- proxy for image/png.EncoderBufferPool ---------------

func (*P_image_png_EncoderBufferPool) Get 

func (P *P_image_png_EncoderBufferPool) Get() *png.EncoderBuffer

func (*P_image_png_EncoderBufferPool) Put 

func (P *P_image_png_EncoderBufferPool) Put(unnamed0 *png.EncoderBuffer)

type P_io_ByteReader 

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

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

func (*P_io_ByteReader) ReadByte 

func (P *P_io_ByteReader) ReadByte() (byte, error)

type P_io_ByteScanner 

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

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

func (*P_io_ByteScanner) ReadByte 

func (P *P_io_ByteScanner) ReadByte() (byte, error)

func (*P_io_ByteScanner) UnreadByte 

func (P *P_io_ByteScanner) UnreadByte() error

type P_io_ByteWriter 

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

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

func (*P_io_ByteWriter) WriteByte 

func (P *P_io_ByteWriter) WriteByte(c byte) error

type P_io_Closer 

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

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

func (*P_io_Closer) Close 

func (P *P_io_Closer) Close() error

type P_io_ReadCloser 

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

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

func (*P_io_ReadCloser) Close 

func (P *P_io_ReadCloser) Close() error

func (*P_io_ReadCloser) Read 

func (P *P_io_ReadCloser) Read(p []byte) (n int, err error)

type P_io_ReadSeeker 

type P_io_ReadSeeker 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 (*P_io_ReadSeeker) Read 

func (P *P_io_ReadSeeker) Read(p []byte) (n int, err error)

func (*P_io_ReadSeeker) Seek 

func (P *P_io_ReadSeeker) Seek(offset int64, whence int) (int64, error)

type P_io_ReadWriteCloser 

type P_io_ReadWriteCloser 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 (*P_io_ReadWriteCloser) Close 

func (P *P_io_ReadWriteCloser) Close() error

func (*P_io_ReadWriteCloser) Read 

func (P *P_io_ReadWriteCloser) Read(p []byte) (n int, err error)

func (*P_io_ReadWriteCloser) Write 

func (P *P_io_ReadWriteCloser) Write(p []byte) (n int, err error)

type P_io_ReadWriteSeeker 

type P_io_ReadWriteSeeker 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 (*P_io_ReadWriteSeeker) Read 

func (P *P_io_ReadWriteSeeker) Read(p []byte) (n int, err error)

func (*P_io_ReadWriteSeeker) Seek 

func (P *P_io_ReadWriteSeeker) Seek(offset int64, whence int) (int64, error)

func (*P_io_ReadWriteSeeker) Write 

func (P *P_io_ReadWriteSeeker) Write(p []byte) (n int, err error)

type P_io_ReadWriter 

type P_io_ReadWriter 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 (*P_io_ReadWriter) Read 

func (P *P_io_ReadWriter) Read(p []byte) (n int, err error)

func (*P_io_ReadWriter) Write 

func (P *P_io_ReadWriter) Write(p []byte) (n int, err error)

type P_io_Reader 

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

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

func (*P_io_Reader) Read 

func (P *P_io_Reader) Read(p []byte) (n int, err error)

type P_io_ReaderAt 

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

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

func (*P_io_ReaderAt) ReadAt 

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

type P_io_ReaderFrom 

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

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

func (*P_io_ReaderFrom) ReadFrom 

func (P *P_io_ReaderFrom) ReadFrom(r io.Reader) (n int64, err error)

type P_io_RuneReader 

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

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

func (*P_io_RuneReader) ReadRune 

func (P *P_io_RuneReader) ReadRune() (r rune, size int, err error)

type P_io_RuneScanner 

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

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

func (*P_io_RuneScanner) ReadRune 

func (P *P_io_RuneScanner) ReadRune() (r rune, size int, err error)

func (*P_io_RuneScanner) UnreadRune 

func (P *P_io_RuneScanner) UnreadRune() error

type P_io_Seeker 

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

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

func (*P_io_Seeker) Seek 

func (P *P_io_Seeker) Seek(offset int64, whence int) (int64, error)

type P_io_WriteCloser 

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

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

func (*P_io_WriteCloser) Close 

func (P *P_io_WriteCloser) Close() error

func (*P_io_WriteCloser) Write 

func (P *P_io_WriteCloser) Write(p []byte) (n int, err error)

type P_io_WriteSeeker 

type P_io_WriteSeeker 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 (*P_io_WriteSeeker) Seek 

func (P *P_io_WriteSeeker) Seek(offset int64, whence int) (int64, error)

func (*P_io_WriteSeeker) Write 

func (P *P_io_WriteSeeker) Write(p []byte) (n int, err error)

type P_io_Writer 

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

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

func (*P_io_Writer) Write 

func (P *P_io_Writer) Write(p []byte) (n int, err error)

type P_io_WriterAt 

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

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

func (*P_io_WriterAt) WriteAt 

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

type P_io_WriterTo 

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

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

func (*P_io_WriterTo) WriteTo 

func (P *P_io_WriterTo) WriteTo(w io.Writer) (n int64, err error)

type P_math_rand_Source 

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

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

func (*P_math_rand_Source) Int63 

func (P *P_math_rand_Source) Int63() int64

func (*P_math_rand_Source) Seed 

func (P *P_math_rand_Source) Seed(seed int64)

type P_math_rand_Source64 

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

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

func (*P_math_rand_Source64) Int63 

func (P *P_math_rand_Source64) Int63() int64

func (*P_math_rand_Source64) Seed 

func (P *P_math_rand_Source64) Seed(seed int64)

func (*P_math_rand_Source64) Uint64 

func (P *P_math_rand_Source64) Uint64() uint64

type P_mime_multipart_File 

type P_mime_multipart_File 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 (*P_mime_multipart_File) Close 

func (P *P_mime_multipart_File) Close() error

func (*P_mime_multipart_File) Read 

func (P *P_mime_multipart_File) Read(p []byte) (n int, err error)

func (*P_mime_multipart_File) ReadAt 

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

func (*P_mime_multipart_File) Seek 

func (P *P_mime_multipart_File) Seek(offset int64, whence int) (int64, error)

type P_net_Addr 

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

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

func (*P_net_Addr) Network 

func (P *P_net_Addr) Network() string

func (*P_net_Addr) String 

func (P *P_net_Addr) String() string

type P_net_Conn 

type P_net_Conn 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 (*P_net_Conn) Close 

func (P *P_net_Conn) Close() error

func (*P_net_Conn) LocalAddr 

func (P *P_net_Conn) LocalAddr() net.Addr

func (*P_net_Conn) Read 

func (P *P_net_Conn) Read(b []byte) (n int, err error)

func (*P_net_Conn) RemoteAddr 

func (P *P_net_Conn) RemoteAddr() net.Addr

func (*P_net_Conn) SetDeadline 

func (P *P_net_Conn) SetDeadline(t time.Time) error

func (*P_net_Conn) SetReadDeadline 

func (P *P_net_Conn) SetReadDeadline(t time.Time) error

func (*P_net_Conn) SetWriteDeadline 

func (P *P_net_Conn) SetWriteDeadline(t time.Time) error

func (*P_net_Conn) Write 

func (P *P_net_Conn) Write(b []byte) (n int, err error)

type P_net_Error 

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

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

func (*P_net_Error) Error 

func (P *P_net_Error) Error() string

func (*P_net_Error) Temporary 

func (P *P_net_Error) Temporary() bool

func (*P_net_Error) Timeout 

func (P *P_net_Error) Timeout() bool

type P_net_Listener 

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

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

func (*P_net_Listener) Accept 

func (P *P_net_Listener) Accept() (net.Conn, error)

func (*P_net_Listener) Addr 

func (P *P_net_Listener) Addr() net.Addr

func (*P_net_Listener) Close 

func (P *P_net_Listener) Close() error

type P_net_PacketConn 

type P_net_PacketConn 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 (*P_net_PacketConn) Close 

func (P *P_net_PacketConn) Close() error

func (*P_net_PacketConn) LocalAddr 

func (P *P_net_PacketConn) LocalAddr() net.Addr

func (*P_net_PacketConn) ReadFrom 

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

func (*P_net_PacketConn) SetDeadline 

func (P *P_net_PacketConn) SetDeadline(t time.Time) error

func (*P_net_PacketConn) SetReadDeadline 

func (P *P_net_PacketConn) SetReadDeadline(t time.Time) error

func (*P_net_PacketConn) SetWriteDeadline 

func (P *P_net_PacketConn) SetWriteDeadline(t time.Time) error

func (*P_net_PacketConn) WriteTo 

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

type P_net_http_CloseNotifier 

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

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

func (*P_net_http_CloseNotifier) CloseNotify 

func (P *P_net_http_CloseNotifier) CloseNotify() <-chan bool

type P_net_http_CookieJar 

type P_net_http_CookieJar 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 (*P_net_http_CookieJar) Cookies 

func (P *P_net_http_CookieJar) Cookies(u *url.URL) []*http.Cookie

func (*P_net_http_CookieJar) SetCookies 

func (P *P_net_http_CookieJar) SetCookies(u *url.URL, cookies []*http.Cookie)

type P_net_http_File 

type P_net_http_File 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 (*P_net_http_File) Close 

func (P *P_net_http_File) Close() error

func (*P_net_http_File) Read 

func (P *P_net_http_File) Read(p []byte) (n int, err error)

func (*P_net_http_File) Readdir 

func (P *P_net_http_File) Readdir(count int) ([]os.FileInfo, error)

func (*P_net_http_File) Seek 

func (P *P_net_http_File) Seek(offset int64, whence int) (int64, error)

func (*P_net_http_File) Stat 

func (P *P_net_http_File) Stat() (os.FileInfo, error)

type P_net_http_FileSystem 

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

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

func (*P_net_http_FileSystem) Open 

func (P *P_net_http_FileSystem) Open(name string) (http.File, error)

type P_net_http_Flusher 

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

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

func (*P_net_http_Flusher) Flush 

func (P *P_net_http_Flusher) Flush()

type P_net_http_Handler 

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

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

func (*P_net_http_Handler) ServeHTTP 

func (P *P_net_http_Handler) ServeHTTP(unnamed0 http.ResponseWriter, unnamed1 *http.Request)

type P_net_http_Hijacker 

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

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

func (*P_net_http_Hijacker) Hijack 

func (P *P_net_http_Hijacker) Hijack() (net.Conn, *bufio.ReadWriter, error)

type P_net_http_Pusher 

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

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

func (*P_net_http_Pusher) Push 

func (P *P_net_http_Pusher) Push(target string, opts *http.PushOptions) error

type P_net_http_ResponseWriter 

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

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

func (*P_net_http_ResponseWriter) Header 

func (P *P_net_http_ResponseWriter) Header() http.Header

func (*P_net_http_ResponseWriter) Write 

func (P *P_net_http_ResponseWriter) Write(unnamed0 []byte) (int, error)

func (*P_net_http_ResponseWriter) WriteHeader 

func (P *P_net_http_ResponseWriter) WriteHeader(statusCode int)

type P_net_http_RoundTripper 

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

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

func (*P_net_http_RoundTripper) RoundTrip 

func (P *P_net_http_RoundTripper) RoundTrip(unnamed0 *http.Request) (*http.Response, error)

type P_net_http_cookiejar_PublicSuffixList 

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

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

func (*P_net_http_cookiejar_PublicSuffixList) PublicSuffix 

func (P *P_net_http_cookiejar_PublicSuffixList) PublicSuffix(domain string) string

func (*P_net_http_cookiejar_PublicSuffixList) String 

func (P *P_net_http_cookiejar_PublicSuffixList) String() string

type P_net_http_httputil_BufferPool 

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

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

func (*P_net_http_httputil_BufferPool) Get 

func (P *P_net_http_httputil_BufferPool) Get() []byte

func (*P_net_http_httputil_BufferPool) Put 

func (P *P_net_http_httputil_BufferPool) Put(unnamed0 []byte)

type P_net_rpc_ClientCodec 

type P_net_rpc_ClientCodec 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 (*P_net_rpc_ClientCodec) Close 

func (P *P_net_rpc_ClientCodec) Close() error

func (*P_net_rpc_ClientCodec) ReadResponseBody 

func (P *P_net_rpc_ClientCodec) ReadResponseBody(unnamed0 interface{}) error

func (*P_net_rpc_ClientCodec) ReadResponseHeader 

func (P *P_net_rpc_ClientCodec) ReadResponseHeader(unnamed0 *rpc.Response) error

func (*P_net_rpc_ClientCodec) WriteRequest 

func (P *P_net_rpc_ClientCodec) WriteRequest(unnamed0 *rpc.Request, unnamed1 interface{}) error

type P_net_rpc_ServerCodec 

type P_net_rpc_ServerCodec 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 (*P_net_rpc_ServerCodec) Close 

func (P *P_net_rpc_ServerCodec) Close() error

func (*P_net_rpc_ServerCodec) ReadRequestBody 

func (P *P_net_rpc_ServerCodec) ReadRequestBody(unnamed0 interface{}) error

func (*P_net_rpc_ServerCodec) ReadRequestHeader 

func (P *P_net_rpc_ServerCodec) ReadRequestHeader(unnamed0 *rpc.Request) error

func (*P_net_rpc_ServerCodec) WriteResponse 

func (P *P_net_rpc_ServerCodec) WriteResponse(unnamed0 *rpc.Response, unnamed1 interface{}) error

type P_net_smtp_Auth 

type P_net_smtp_Auth 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 (*P_net_smtp_Auth) Next 

func (P *P_net_smtp_Auth) Next(fromServer []byte, more bool) (toServer []byte, err error)

func (*P_net_smtp_Auth) Start 

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

type P_os_FileInfo 

type P_os_FileInfo 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 (*P_os_FileInfo) IsDir 

func (P *P_os_FileInfo) IsDir() bool

func (*P_os_FileInfo) ModTime 

func (P *P_os_FileInfo) ModTime() time.Time

func (*P_os_FileInfo) Mode 

func (P *P_os_FileInfo) Mode() os.FileMode

func (*P_os_FileInfo) Name 

func (P *P_os_FileInfo) Name() string

func (*P_os_FileInfo) Size 

func (P *P_os_FileInfo) Size() int64

func (*P_os_FileInfo) Sys 

func (P *P_os_FileInfo) Sys() interface{}

type P_os_Signal 

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

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

func (*P_os_Signal) Signal 

func (P *P_os_Signal) Signal()

func (*P_os_Signal) String 

func (P *P_os_Signal) String() string

type P_runtime_Error 

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

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

func (*P_runtime_Error) Error 

func (P *P_runtime_Error) Error() string

func (*P_runtime_Error) RuntimeError 

func (P *P_runtime_Error) RuntimeError()

type P_sort_Interface 

type P_sort_Interface 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 (*P_sort_Interface) Len 

func (P *P_sort_Interface) Len() int

func (*P_sort_Interface) Less 

func (P *P_sort_Interface) Less(i int, j int) bool

func (*P_sort_Interface) Swap 

func (P *P_sort_Interface) Swap(i int, j int)

type P_sync_Locker 

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

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

func (*P_sync_Locker) Lock 

func (P *P_sync_Locker) Lock()

func (*P_sync_Locker) Unlock 

func (P *P_sync_Locker) Unlock()

type P_testing_quick_Generator 

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

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

func (*P_testing_quick_Generator) Generate 

func (P *P_testing_quick_Generator) Generate(rand *rand.Rand, size int) reflect.Value

type Package 

type Package PackageUnderlying // named, can have methods

func (*Package) DefaultName 

func (pkg *Package) DefaultName(path string) string

*

  • return the default name to bind when importing Package *
  • https://golang.org/ref/spec#Package_clause states:
  • If the PackageName is omitted, it defaults to the identifier
  • specified in the package clause of the imported package *
  • So use that if known, otherwise extrapolate it from package path

func (*Package) LazyInit 

func (pkg *Package) LazyInit(path string)

func (*Package) Merge 

func (dst *Package) Merge(src PackageUnderlying)

type PackageMap 

type PackageMap map[string]Package // named, can have methods

func (PackageMap) Merge 

func (pkgs PackageMap) Merge(srcs map[string]PackageUnderlying)

func (PackageMap) MergePackage 

func (pkgs PackageMap) MergePackage(path string, src PackageUnderlying)

type PackageUnderlying 

type PackageUnderlying = struct {
	Name    string
	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
}

Source Files

View all Source files

Directories

Path Synopsis

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.