memory_iter.go 2.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181
  1. package ezdb
  2. import "sort"
  3. type MemoryIterator[T any] struct {
  4. k []string
  5. m map[string]T
  6. pos int
  7. released bool
  8. prev Iterator[T]
  9. }
  10. func (i *MemoryIterator[T]) Count() int {
  11. return len(i.k)
  12. }
  13. func (i *MemoryIterator[T]) Filter(f FilterFunc[T]) Iterator[T] {
  14. if i.released {
  15. return i
  16. }
  17. m := map[string]T{}
  18. i.reset()
  19. for i.Next() {
  20. key, value, _ := i.Get()
  21. if f(key, value) {
  22. m[key] = value
  23. }
  24. }
  25. return newMemoryIterator(m, i)
  26. }
  27. func (i *MemoryIterator[T]) First() bool {
  28. if i.released {
  29. return false
  30. }
  31. i.pos = 0
  32. return true
  33. }
  34. func (i *MemoryIterator[T]) Get() (string, T, error) {
  35. if i.released {
  36. return "", i.m[""], ErrReleased
  37. }
  38. key := i.Key()
  39. return key, i.m[key], nil
  40. }
  41. func (i *MemoryIterator[T]) GetAll() (map[string]T, error) {
  42. m := map[string]T{}
  43. if i.released {
  44. return m, ErrReleased
  45. }
  46. i.reset()
  47. for i.Next() {
  48. key, value, _ := i.Get()
  49. m[key] = value
  50. }
  51. return m, nil
  52. }
  53. func (i *MemoryIterator[T]) GetAllKeys() []string {
  54. keys := []string{}
  55. if i.released {
  56. return keys
  57. }
  58. i.reset()
  59. for i.Next() {
  60. keys = append(keys, i.Key())
  61. }
  62. return keys
  63. }
  64. func (i *MemoryIterator[T]) Key() string {
  65. if i.pos < 0 || i.pos > i.Count() || i.released {
  66. return ""
  67. }
  68. return i.k[i.pos]
  69. }
  70. func (i *MemoryIterator[T]) Last() bool {
  71. if i.released {
  72. return false
  73. }
  74. i.pos = len(i.k) - 1
  75. return true
  76. }
  77. func (i *MemoryIterator[T]) Next() bool {
  78. if i.released {
  79. return false
  80. }
  81. hasNext := i.pos+1 <= i.Count()
  82. if hasNext {
  83. i.pos++
  84. }
  85. return hasNext
  86. }
  87. func (i *MemoryIterator[T]) Prev() bool {
  88. if i.released {
  89. return false
  90. }
  91. end := i.pos > 0
  92. if !end {
  93. i.pos--
  94. }
  95. return end
  96. }
  97. func (i *MemoryIterator[T]) Release() {
  98. i.k = []string{}
  99. i.m = map[string]T{}
  100. i.released = true
  101. if i.prev != nil {
  102. i.prev.Release()
  103. }
  104. }
  105. func (i *MemoryIterator[T]) Sort(f SortFunc[T]) Iterator[T] {
  106. if i.released {
  107. return i
  108. }
  109. s := &valueSort[T]{
  110. a: makeSortable(i.m),
  111. f: f,
  112. }
  113. sort.Stable(s)
  114. m := s.Result()
  115. return newMemoryIterator(m, i)
  116. }
  117. func (i *MemoryIterator[T]) SortKeys(f SortFunc[string]) Iterator[T] {
  118. if i.released {
  119. return i
  120. }
  121. s := &keySort[T]{
  122. a: makeSortable(i.m),
  123. f: f,
  124. }
  125. sort.Stable(s)
  126. m := s.Result()
  127. return newMemoryIterator(m, i)
  128. }
  129. func (i *MemoryIterator[T]) Value() (T, error) {
  130. key := i.Key()
  131. return i.m[key], nil
  132. }
  133. func (i *MemoryIterator[T]) reset() {
  134. i.pos = -1
  135. }
  136. func newMemoryIterator[T any](m map[string]T, prev Iterator[T]) *MemoryIterator[T] {
  137. i := &MemoryIterator[T]{
  138. k: []string{},
  139. m: m,
  140. pos: -1,
  141. prev: prev,
  142. }
  143. for k := range i.m {
  144. i.k = append(i.k, k)
  145. }
  146. return i
  147. }