imports

package
Version: v0.0.0-...-b4935e4 Latest Latest
Warning

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

Go to latest
Published: Jun 24, 2021 License: MPL-2.0 Imports: 144 Imported by: 4

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_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_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

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

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

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

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_database_sql_driver_Connector) 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

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

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

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

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

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

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_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_database_sql_driver_RowsColumnTypeDatabaseTypeName) Next

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_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_database_sql_driver_RowsColumnTypeLength) Next

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_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_database_sql_driver_RowsColumnTypeNullable) Next

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_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_database_sql_driver_RowsColumnTypePrecisionScale) Next

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_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_database_sql_driver_RowsColumnTypeScanType) Next

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_database_sql_driver_RowsNextResultSet) Columns

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_database_sql_driver_RowsNextResultSet) NextResultSet

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

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_database_sql_driver_Stmt) NumInput

func (P *P_database_sql_driver_Stmt) NumInput() int

func (*P_database_sql_driver_Stmt) Query

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

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

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

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_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

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_image_png_EncoderBufferPool) Put

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_StringWriter

type P_io_StringWriter struct {
	Object       interface{}
	WriteString_ func(_proxy_obj_ interface{}, s string) (n int, err error)
}

--------------- proxy for io.StringWriter ---------------

func (*P_io_StringWriter) WriteString

func (P *P_io_StringWriter) WriteString(s string) (n int, err 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{}, p []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{}, p []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(p []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(p []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_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

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_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

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
t or T : Toggle theme light dark auto
y or Y : Canonical URL