application/mov/database/mov_iterator.go

   1 package database
   2
   3 import (
   4         log "github.com/sirupsen/logrus"
   5
   6         "github.com/bytom/vapor/application/mov/common"
   7         "github.com/bytom/vapor/protocol/bc"
   8 )
   9
  10 // TradePairIterator wrap read trade pair from DB action
  11 type TradePairIterator struct {
  12         movStore       MovStore
  13         tradePairs     []*common.TradePair
  14         tradePairIndex int
  15 }
  16
  17 // NewTradePairIterator create the new TradePairIterator object
  18 func NewTradePairIterator(movStore MovStore) *TradePairIterator {
  19         return &TradePairIterator{movStore: movStore}
  20 }
  21
  22 // HasNext check if there are more trade pairs in memory or DB
  23 func (t *TradePairIterator) HasNext() bool {
  24         tradePairSize := len(t.tradePairs)
  25         if t.tradePairIndex < tradePairSize {
  26                 return true
  27         }
  28
  29         var fromAssetID, toAssetID *bc.AssetID
  30         if len(t.tradePairs) > 0 {
  31                 lastTradePair := t.tradePairs[tradePairSize-1]
  32                 fromAssetID, toAssetID = lastTradePair.FromAssetID, lastTradePair.ToAssetID
  33         }
  34
  35         tradePairs, err := t.movStore.ListTradePairsWithStart(fromAssetID, toAssetID)
  36         if err != nil {
  37                 // If the error is returned, it's an error of program itself,
  38                 // and cannot be recovered, so panic directly.
  39                 log.WithField("err", err).Fatal("fail to list trade pairs")
  40         }
  41
  42         if len(tradePairs) == 0 {
  43                 return false
  44         }
  45
  46         t.tradePairs = tradePairs
  47         t.tradePairIndex = 0
  48         return true
  49 }
  50
  51 // Next return the next available trade pair in memory or DB
  52 func (t *TradePairIterator) Next() *common.TradePair {
  53         if !t.HasNext() {
  54                 return nil
  55         }
  56
  57         tradePair := t.tradePairs[t.tradePairIndex]
  58         t.tradePairIndex++
  59         return tradePair
  60 }
  61
  62 // OrderIterator wrap read order from DB action
  63 type OrderIterator struct {
  64         movStore  MovStore
  65         lastOrder *common.Order
  66         orders    []*common.Order
  67 }
  68
  69 // NewOrderIterator create the new OrderIterator object
  70 func NewOrderIterator(movStore MovStore, tradePair *common.TradePair) *OrderIterator {
  71         return &OrderIterator{
  72                 movStore:  movStore,
  73                 lastOrder: &common.Order{FromAssetID: tradePair.FromAssetID, ToAssetID: tradePair.ToAssetID},
  74         }
  75 }
  76
  77 // HasNext check if there are more orders in memory or DB
  78 func (o *OrderIterator) HasNext() bool {
  79         if len(o.orders) == 0 {
  80                 orders, err := o.movStore.ListOrders(o.lastOrder)
  81                 if err != nil {
  82                         log.WithField("err", err).Fatal("fail to list orders")
  83                 }
  84
  85                 if len(orders) == 0 {
  86                         return false
  87                 }
  88
  89                 o.orders = orders
  90                 o.lastOrder = o.orders[len(o.orders)-1]
  91         }
  92         return true
  93 }
  94
  95 // NextBatch return the next batch of orders in memory or DB
  96 func (o *OrderIterator) NextBatch() []*common.Order {
  97         if !o.HasNext() {
  98                 return nil
  99         }
 100
 101         orders := o.orders
 102         o.orders = nil
 103         return orders
 104 }