alert

README

GoCryptoTrader package Alert

This alert package is part of the GoCryptoTrader codebase.

This is still in active development

You can track ideas, planned features and what's in progress on this Trello board: https://trello.com/b/ZAhMhpOy/gocryptotrader.

Join our slack to discuss all things related to GoCryptoTrader! GoCryptoTrader Slack

Alert

• This package allows for multiple routines to wait for a state change on any required data.

Examples:

• Implementation:

// SomeChangingType defines an example struct with an embedded alert.Notice
// type for easy access to the notice methods.
type SomeChangingType struct {
	ValueThatChanges int64
	alert.Notice
	mu sync.Mutex // Protection for routine shenanigans
}

// Update will update in a separate routine
func (s *SomeChangingType) Update(newValue int64) {
	// This simulates a changing variable or state
	s.mu.Lock()
	s.ValueThatChanges = newValue
	// This will alert any routines that are currently waiting for a change
	s.Alert()
	s.mu.Unlock()
}

// WhatsTheValue will retrieve the value that was changed and should be
// different from the past value. Efficiency++
func (s *SomeChangingType) WhatsTheValue() int64 {
	s.mu.Lock()
	value := s.ValueThatChanges
	s.mu.Unlock()
	return value
}

• Routine waiting for change:

// ExampleRoutineThatWaits defines an exchange potential routine that will wait
// for an impending change.
func ExampleRoutineThatWaits(potentialChange *SomeChangingType) {
	// Every iteration requires a Wait() call.
	for range potentialChange.Wait(nil) {
		val := potentialChange.WhatsTheValue()
		fmt.Println("Value:", val)
	}
}

// AnotherExampleRoutineThatWaits defines an exchange potential routine that 
// will wait for an impending change.
func AnotherExampleRoutineThatWaits(potentialChange *SomeChangingType) {
	// Every iteration requires a Wait() call.
	for {
		select {
			case <-potentialChange.Wait(nil):
				val := potentialChange.WhatsTheValue()
				fmt.Println("Value:", val)
			case <-shutdownChannel:
				fmt.Println("Good-Bye!")
			return 
		}
	}
}


// WARNING: PLEASE DON'T DO THIS.
// This will stop alerting for this specific data type due to the shared nature 
// of the underlying channels using a sync.Pool.
func ABadExampleRoutineThatWaits(potentialChange *SomeChangingType) {
	capturedChannel := potentialChange.Wait(nil)
	for {
		select {
			case <-capturedChannel:
				// This will produce incorrect results or no change. 
				val := potentialChange.WhatsTheValue()
				fmt.Println("Value:", val)
			case <-shutdownChannel:
				fmt.Println("Good-Bye!")
			return 
		}
	}
}

Please click GoDocs chevron above to view current GoDoc information for this package

Contribution

Please feel free to submit any pull requests or suggest any desired features to be added.

When submitting a PR, please abide by our coding guidelines:

• Code must adhere to the official Go formatting guidelines (i.e. uses gofmt).
• Code must be documented adhering to the official Go commentary guidelines.
• Code must adhere to our coding style.
• Pull requests need to be based on and opened against the master branch.

Donations

If this framework helped you in any way, or you would like to support the developers working on it, please donate Bitcoin to:

bc1qk0jareu4jytc0cfrhr5wgshsq8282awpavfahc

Documentation

Index

• Constants
• func SetDefaultPreAllocationCommsBuffer()
• func SetPreAllocationCommsBuffer(size int) error
• type Notice
  • func (n *Notice) Alert()
  • func (n *Notice) Wait(kick <-chan struct{}) chan bool

Constants

const (

	// PreAllocCommsDefaultBuffer is the default buffer size for comms
	PreAllocCommsDefaultBuffer = 5
)

Functions

func SetDefaultPreAllocationCommsBuffer

func SetDefaultPreAllocationCommsBuffer()

SetDefaultPreAllocationCommsBuffer sets default buffer size of the pre-allocated comms.

func SetPreAllocationCommsBuffer

func SetPreAllocationCommsBuffer(size int) error

SetPreAllocationCommsBuffer sets buffer size of the pre-allocated comms.

Types

type Notice

type Notice struct {
	// contains filtered or unexported fields
}

Notice defines fields required to alert sub-systems of a change of state so a routine can re-check in memory data

func (*Notice) Alert

func (n *Notice) Alert()

Alert establishes a state change on the required struct.

func (*Notice) Wait

func (n *Notice) Wait(kick <-chan struct{}) chan bool

Wait pauses calling routine until change of state has been established via notice method Alert. Kick allows for cancellation of waiting or when the caller has been shut down, if this is not needed it can be set to nil. This returns a channel so strategies can cleanly wait on a select statement case. NOTE: Please see README.md for implementation example.