memory.go 2.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156
  1. package ezdb
  2. type MemoryCollection[T any] struct {
  3. c Collection[T]
  4. m map[string]T
  5. open bool
  6. }
  7. func (c *MemoryCollection[T]) Close() error {
  8. if c.c != nil {
  9. return c.c.Close()
  10. }
  11. c.m = map[string]T{}
  12. c.open = false
  13. return nil
  14. }
  15. func (c *MemoryCollection[T]) Count() int {
  16. iter := c.Iter()
  17. defer iter.Release()
  18. return iter.Count()
  19. }
  20. func (c *MemoryCollection[T]) Delete(key string) error {
  21. if !c.open {
  22. return ErrClosed
  23. }
  24. if c.c != nil {
  25. if err := c.c.Delete(key); err != nil {
  26. return err
  27. }
  28. }
  29. delete(c.m, key)
  30. return nil
  31. }
  32. func (c *MemoryCollection[T]) DeleteAll() error {
  33. iter := c.Iter()
  34. defer iter.Release()
  35. keys := iter.GetAllKeys()
  36. for _, key := range keys {
  37. if err := c.Delete(key); err != nil {
  38. return err
  39. }
  40. }
  41. return nil
  42. }
  43. func (c *MemoryCollection[T]) Get(key string) (T, error) {
  44. if !c.open {
  45. return c.m[""], ErrClosed
  46. }
  47. if value, ok := c.m[key]; ok {
  48. return value, nil
  49. }
  50. return c.m[""], ErrNotFound
  51. }
  52. func (c *MemoryCollection[T]) GetAll() (map[string]T, error) {
  53. iter := c.Iter()
  54. defer iter.Release()
  55. return iter.GetAll()
  56. }
  57. func (c *MemoryCollection[T]) GetAllKeys() []string {
  58. iter := c.Iter()
  59. defer iter.Release()
  60. return iter.GetAllKeys()
  61. }
  62. func (c *MemoryCollection[T]) Has(key string) (bool, error) {
  63. if !c.open {
  64. return false, ErrClosed
  65. }
  66. _, ok := c.m[key]
  67. return ok, nil
  68. }
  69. func (c *MemoryCollection[T]) Iter() Iterator[T] {
  70. m := MemoryIter[T](c.m, nil, nil)
  71. if !c.open {
  72. m.Release()
  73. }
  74. return m
  75. }
  76. func (c *MemoryCollection[T]) Open() error {
  77. if c.c != nil {
  78. if err := c.c.Open(); err != nil {
  79. return err
  80. }
  81. iter := c.c.Iter()
  82. defer iter.Release()
  83. all, err := iter.GetAll()
  84. if err != nil {
  85. return err
  86. }
  87. c.m = all
  88. } else {
  89. c.m = map[string]T{}
  90. }
  91. c.open = true
  92. return nil
  93. }
  94. func (c *MemoryCollection[T]) Put(key string, value T) error {
  95. if !c.open {
  96. return ErrClosed
  97. }
  98. if err := ValidateKey(key); err != nil {
  99. return err
  100. }
  101. if c.c != nil {
  102. if err := c.c.Put(key, value); err != nil {
  103. return err
  104. }
  105. }
  106. c.m[key] = value
  107. return nil
  108. }
  109. // Memory creates an in-memory collection, which offers fast access without a document marshaler.
  110. //
  111. // If the collection c is non-nil, it will be used as a persistence backend.
  112. //
  113. // If T is a pointer type, the same pointer will be used whenever a document is read from this collection.
  114. // Take care not to modify documents retrieved from a memory collection.
  115. func Memory[T any](c Collection[T]) *MemoryCollection[T] {
  116. return &MemoryCollection[T]{
  117. c: c,
  118. m: map[string]T{},
  119. }
  120. }