gitee.com/zhongguo168a/gocodes@v0.0.0-20230609140523-e1828349603f/datax/setx/setx.go (about)

     1  package setx
     2  
     3  import "sync"
     4  
     5  type SetObject[K comparable, V any] struct {
     6  	mutex sync.RWMutex
     7  	data  map[K]V
     8  }
     9  
    10  func New[K comparable, V any]() *SetObject[K, V] {
    11  	return &SetObject[K, V]{
    12  		data: map[K]V{},
    13  	}
    14  }
    15  func (set *SetObject[K, V]) Reset(data map[K]V) {
    16  	set.mutex.Lock()
    17  	set.data = data
    18  	set.mutex.Unlock()
    19  }
    20  func (set *SetObject[K, V]) Set(key K, value V) {
    21  	set.mutex.Lock()
    22  	set.data[key] = value
    23  	set.mutex.Unlock()
    24  }
    25  func (set *SetObject[K, V]) SetByMap(m map[K]V) {
    26  	data := set.data
    27  	set.mutex.Lock()
    28  	for key, value := range m {
    29  		data[key] = value
    30  	}
    31  	set.mutex.Unlock()
    32  }
    33  
    34  func (set *SetObject[K, V]) SetBySet(other *SetObject[K, V]) {
    35  	data := set.data
    36  	set.mutex.Lock()
    37  	for key, value := range other.data {
    38  		data[key] = value
    39  	}
    40  	set.mutex.Unlock()
    41  }
    42  
    43  func (set *SetObject[K, V]) Get(key K) (V, bool) {
    44  	set.mutex.RLock()
    45  	value, ok := set.data[key]
    46  	set.mutex.RUnlock()
    47  	return value, ok
    48  }
    49  
    50  // 与other集合组合成新集合，相同键值时，other覆盖set
    51  func (set *SetObject[K, V]) Combine(other *SetObject[K, V]) *SetObject[K, V] {
    52  	newSet := New[K, V]()
    53  	data := newSet.data
    54  	set.mutex.Lock()
    55  	for key, value := range set.data {
    56  		data[key] = value
    57  	}
    58  	for key, value := range other.data {
    59  		data[key] = value
    60  	}
    61  	set.mutex.Unlock()
    62  	return newSet
    63  }
    64  
    65  func (set *SetObject[K, V]) Delete(key K) {
    66  	set.mutex.Lock()
    67  	delete(set.data, key)
    68  	set.mutex.Unlock()
    69  }
    70  
    71  func (set *SetObject[K, V]) Exists(key K) bool {
    72  	set.mutex.RLock()
    73  	_, ok := set.data[key]
    74  	set.mutex.RUnlock()
    75  	return ok
    76  }
    77  
    78  func (set *SetObject[K, V]) Length() int {
    79  	set.mutex.RLock()
    80  	length := len(set.data)
    81  	set.mutex.RUnlock()
    82  	return length
    83  }
    84  func (set *SetObject[K, V]) Pop(key K) (v V, exists bool) {
    85  	set.mutex.Lock()
    86  	v, exists = set.data[key]
    87  	delete(set.data, key)
    88  	set.mutex.Unlock()
    89  	return v, exists
    90  }
    91  func (set *SetObject[K, V]) IsEmpty() bool {
    92  	return set.Length() == 0
    93  }
    94  
    95  func (set *SetObject[K, V]) Items() (items []V) {
    96  	l := len(set.data)
    97  	items = make([]V, l, l)
    98  	set.mutex.RLock()
    99  	i := 0
   100  	for _, item := range set.data {
   101  		items[i] = item
   102  		i++
   103  	}
   104  	set.mutex.RUnlock()
   105  	return
   106  }
   107  
   108  func (set *SetObject[K, V]) Keys() (keys []K) {
   109  	l := len(set.data)
   110  	keys = make([]K, l, l)
   111  	set.mutex.RLock()
   112  	i := 0
   113  	for key := range set.data {
   114  		keys[i] = key
   115  		i++
   116  	}
   117  	set.mutex.RUnlock()
   118  	return
   119  }
   120  
   121  // 如果返回错误，迭代终止
   122  func (set *SetObject[K, V]) ForRange(handler func(key K, val V) (err error)) error {
   123  	set.mutex.RLock()
   124  	defer set.mutex.RUnlock()
   125  	for key, val := range set.data {
   126  		err := handler(key, val)
   127  		if err != nil {
   128  			return err
   129  		}
   130  	}
   131  
   132  	return nil
   133  }
   134  
   135  // func(key string, val V) bool{}
   136  func (set *SetObject[K, V]) First(handler func(key K, val V) bool) (result V) {
   137  	set.mutex.RLock()
   138  	defer set.mutex.RUnlock()
   139  	for key, val := range set.data {
   140  		if handler(key, val) {
   141  			return val
   142  		}
   143  	}
   144  
   145  	return
   146  }
   147  
   148  // 返回符合条件的项形成的新集合
   149  func (set *SetObject[K, V]) Filter(cond func(key K, val V) bool) *SetObject[K, V] {
   150  	set.mutex.RLock()
   151  	var a = map[K]V{}
   152  	for key, val := range set.data {
   153  		if cond(key, val) {
   154  			a[key] = val
   155  		}
   156  	}
   157  	set.mutex.RUnlock()
   158  	return &SetObject[K, V]{
   159  		data: a,
   160  	}
   161  }