Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

stalecucumber

package

Go to main page

Versions in this module

v0

v0.3.7

Oct 27, 2016

v0.3.7-pre3

Sep 24, 2016

v0.3.7-pre2

Sep 24, 2016

v0.3.7-pre1

Sep 23, 2016

v0.3.6

Aug 24, 2016

v0.3.6-pre2

Aug 23, 2016

v0.3.6-pre1

Aug 22, 2016

v0.3.5

Apr 10, 2016

v0.3.4

Apr 10, 2016

v0.3.3

Apr 9, 2016

v0.3.2

Mar 27, 2016

v0.3.1

Mar 24, 2016

Changes in this version

+ const BININT_MAX

+ const BININT_MIN

+ const OPCODE_APPEND

+ const OPCODE_APPENDS

+ const OPCODE_BINFLOAT

+ const OPCODE_BINGET

+ const OPCODE_BININT

+ const OPCODE_BININT1

+ const OPCODE_BININT2

+ const OPCODE_BINPERSID

+ const OPCODE_BINPUT

+ const OPCODE_BINSTRING

+ const OPCODE_BINUNICODE

+ const OPCODE_BUILD

+ const OPCODE_DICT

+ const OPCODE_DUP

+ const OPCODE_EMPTY_DICT

+ const OPCODE_EMPTY_LIST

+ const OPCODE_EMPTY_TUPLE

+ const OPCODE_EXT1

+ const OPCODE_EXT2

+ const OPCODE_EXT4

+ const OPCODE_FLOAT

+ const OPCODE_GET

+ const OPCODE_GLOBAL

+ const OPCODE_INST

+ const OPCODE_INT

+ const OPCODE_LIST

+ const OPCODE_LONG

+ const OPCODE_LONG1

+ const OPCODE_LONG4

+ const OPCODE_LONG_BINGET

+ const OPCODE_LONG_BINPUT

+ const OPCODE_MARK

+ const OPCODE_NEWFALSE

+ const OPCODE_NEWOBJ

+ const OPCODE_NEWTRUE

+ const OPCODE_NONE

+ const OPCODE_OBJ

+ const OPCODE_PERSID

+ const OPCODE_POP

+ const OPCODE_POP_MARK

+ const OPCODE_PROTO

+ const OPCODE_PUT

+ const OPCODE_REDUCE

+ const OPCODE_SETITEM

+ const OPCODE_SETITEMS

+ const OPCODE_SHORT_BINSTRING

+ const OPCODE_STOP

+ const OPCODE_STRING

+ const OPCODE_TUPLE

+ const OPCODE_TUPLE1

+ const OPCODE_TUPLE2

+ const OPCODE_TUPLE3

+ const OPCODE_UNICODE

+ const PICKLE_TAG

+ var ErrEmptyInterfaceNotPickleable = errors.New("The empty interface is not pickleable")

+ var ErrInputTruncated = errors.New("Input to the pickle machine was truncated")

+ var ErrMarkNotFound = errors.New("Mark could not be found on the stack")

+ var ErrNilPointer = errors.New("Destination cannot be a nil pointer")

+ var ErrNoResult = errors.New("Input did not place a value onto the stack")

+ var ErrNotPointer = errors.New("Destination must be a pointer type")

+ var ErrOpcodeInvalid = errors.New("Opcode is invalid")

+ var ErrOpcodeNotImplemented = errors.New("Input encountered opcode that is not implemented")

+ var ErrOpcodeStopped = errors.New("STOP opcode found")

+ var ErrStackTooSmall = errors.New("Stack is too small to perform requested operation")

+ var ErrTargetTypeMismatch = errors.New("Target type does not match source type")

+ var ErrTargetTypeNotPointer = errors.New("Target type must be a pointer to unpack this value")

+ var ErrTargetTypeOverflow = errors.New("Value overflows target type")

+ var ErrTypeNotPickleable = errors.New("Can't pickle this type")

+ func Big(v interface{}, err error) (*big.Int, error)

+ func Bool(v interface{}, err error) (bool, error)

+ func Dict(v interface{}, err error) (map[interface{}]interface{}, error)

+ func DictString(v interface{}, err error) (map[string]interface{}, error)

+ func Float(v interface{}, err error) (float64, error)

+ func Int(v interface{}, err error) (int64, error)

+ func ListOrTuple(v interface{}, err error) ([]interface{}, error)

+ func String(v interface{}, err error) (string, error)

+ func UnpackInto(dest interface{}) unpacker

+ func Unpickle(reader io.Reader) (interface{}, error)

+ type PickleMachine struct

+ Memo []interface{}

+ Reader io.Reader

+ Stack []interface{}

+ func (pm *PickleMachine) Opcode_Invalid() error

+ type PickleMachineError struct

+ Err error

+ MemoSize int

+ Opcode uint8

+ StackSize int

+ func (pme PickleMachineError) Error() string

+ type PickleMark struct

+ func (_ PickleMark) String() string

+ type PickleNone struct

+ func (_ PickleNone) String() string

+ type PickleTuple []interface

+ func NewTuple(v ...interface{}) PickleTuple

+ type Pickler struct

+ W io.Writer

+ func NewPickler(writer io.Writer) *Pickler

+ func (p *Pickler) Pickle(v interface{}) (int, error)

+ type PicklingError struct

+ Err error

+ V interface{}

+ func (pe PicklingError) Error() string

+ type UnpackingError struct

+ Destination reflect.Value

+ Err error

+ Source interface{}

+ func (ue UnpackingError) Error() string

+ type WrongTypeError struct

+ Request string

+ Result interface{}

+ func (wte WrongTypeError) Error() string