123 lines
2.8 KiB
Go
123 lines
2.8 KiB
Go
package internal
|
|
|
|
import (
|
|
"container/list"
|
|
|
|
"github.com/shopspring/decimal"
|
|
)
|
|
|
|
type Filler struct {
|
|
Record
|
|
|
|
filled decimal.Decimal
|
|
quantity decimal.Decimal
|
|
price decimal.Decimal
|
|
}
|
|
|
|
func NewFiller(r Record) *Filler {
|
|
return &Filler{
|
|
Record: r,
|
|
quantity: r.Quantity(),
|
|
price: r.Price(),
|
|
}
|
|
}
|
|
|
|
func (f *Filler) Quantity() decimal.Decimal { return f.quantity }
|
|
|
|
func (f *Filler) Price() decimal.Decimal { return f.price }
|
|
|
|
// Fill accrues some quantity. Returns how mutch was accrued in the 1st return value and whether
|
|
// it was filled or not on the 2nd return value.
|
|
func (f *Filler) Fill(quantity decimal.Decimal) (decimal.Decimal, bool) {
|
|
unfilled := f.quantity.Sub(f.filled)
|
|
delta := decimal.Min(unfilled, quantity)
|
|
f.filled = f.filled.Add(delta)
|
|
return delta, f.IsFilled()
|
|
}
|
|
|
|
// IsFilled returns true if the fill is equal to the record quantity.
|
|
func (f *Filler) IsFilled() bool {
|
|
return f.filled.Equal(f.quantity)
|
|
}
|
|
|
|
// ApplySplit adjusts the lot for a stock split by the given ratio (newQty/oldQty).
|
|
// The total cost basis is preserved: quantity scales up, price scales down proportionally.
|
|
func (f *Filler) ApplySplit(ratio decimal.Decimal) {
|
|
f.quantity = f.quantity.Mul(ratio)
|
|
f.filled = f.filled.Mul(ratio)
|
|
f.price = f.price.Div(ratio)
|
|
}
|
|
|
|
type FillerQueue struct {
|
|
l *list.List
|
|
}
|
|
|
|
// Push inserts the Filler at the back of the queue.
|
|
func (fq *FillerQueue) Push(f *Filler) {
|
|
if f == nil {
|
|
return
|
|
}
|
|
|
|
if fq == nil {
|
|
// This would cause a panic anyway so, we panic with a more meaningful message
|
|
panic("Push to nil FillerQueue")
|
|
}
|
|
|
|
if fq.l == nil {
|
|
fq.l = list.New()
|
|
}
|
|
|
|
fq.l.PushBack(f)
|
|
}
|
|
|
|
// Pop removes and returns the first Filler of the queue in the 1st return value. If the list is
|
|
// empty returns false on the 2nd return value, true otherwise.
|
|
func (fq *FillerQueue) Pop() (*Filler, bool) {
|
|
el := fq.frontElement()
|
|
if el == nil {
|
|
return nil, false
|
|
}
|
|
|
|
val := fq.l.Remove(el)
|
|
|
|
return val.(*Filler), true
|
|
}
|
|
|
|
// Peek returns the front Filler of the queue in the 1st return value. If the list is empty returns
|
|
// false on the 2nd return value, true otherwise.
|
|
func (fq *FillerQueue) Peek() (*Filler, bool) {
|
|
el := fq.frontElement()
|
|
if el == nil {
|
|
return nil, false
|
|
}
|
|
|
|
return el.Value.(*Filler), true
|
|
}
|
|
|
|
func (fq *FillerQueue) frontElement() *list.Element {
|
|
if fq == nil || fq.l == nil {
|
|
return nil
|
|
}
|
|
|
|
return fq.l.Front()
|
|
}
|
|
|
|
// AdjustForSplit applies a stock split ratio to all lots in the queue.
|
|
func (fq *FillerQueue) AdjustForSplit(ratio decimal.Decimal) {
|
|
if fq == nil || fq.l == nil {
|
|
return
|
|
}
|
|
for e := fq.l.Front(); e != nil; e = e.Next() {
|
|
e.Value.(*Filler).ApplySplit(ratio)
|
|
}
|
|
}
|
|
|
|
// Len returns how many elements are currently on the queue
|
|
func (fq *FillerQueue) Len() int {
|
|
if fq == nil || fq.l == nil {
|
|
return 0
|
|
}
|
|
|
|
return fq.l.Len()
|
|
}
|