github.com/tursom/GoCollections@v0.3.10/concurrent/collections/LockedMutableList.go (about)

     1  /*
     2   * Copyright (c) 2022 tursom. All rights reserved.
     3   * Use of this source code is governed by a GPL-3
     4   * license that can be found in the LICENSE file.
     5   */
     6  
     7  package collections
     8  
     9  import (
    10  	"sync"
    11  
    12  	"github.com/tursom/GoCollections/collections"
    13  	"github.com/tursom/GoCollections/concurrent"
    14  	"github.com/tursom/GoCollections/exceptions"
    15  	"github.com/tursom/GoCollections/lang"
    16  )
    17  
    18  type (
    19  	LockedMutableList[T lang.Object] struct {
    20  		list collections.MutableList[T]
    21  		lock concurrent.RWLock
    22  	}
    23  	lockedMutableListIterator[T lang.Object] struct {
    24  		iterator collections.MutableIterator[T]
    25  		lock     concurrent.RWLock
    26  	}
    27  )
    28  
    29  func MutableListWithLock[T lang.Object](list collections.MutableList[T]) collections.MutableList[T] {
    30  	return &LockedMutableList[T]{
    31  		list: list,
    32  		lock: &sync.RWMutex{},
    33  	}
    34  }
    35  
    36  func (l *LockedMutableList[T]) String() string {
    37  	return collections.String[T](l)
    38  }
    39  
    40  func (l *LockedMutableList[T]) Iterator() collections.Iterator[T] {
    41  	return l.MutableIterator()
    42  }
    43  
    44  func (l *LockedMutableList[T]) Size() int {
    45  	l.lock.RLock()
    46  	defer l.lock.RUnlock()
    47  
    48  	return l.list.Size()
    49  }
    50  
    51  func (l *LockedMutableList[T]) IsEmpty() bool {
    52  	return l.Size() == 0
    53  }
    54  
    55  func (l *LockedMutableList[T]) Contains(element T) bool {
    56  	l.lock.RLock()
    57  	defer l.lock.RUnlock()
    58  
    59  	return l.list.Contains(element)
    60  }
    61  
    62  func (l *LockedMutableList[T]) ContainsAll(c collections.Collection[T]) bool {
    63  	l.lock.RLock()
    64  	defer l.lock.RUnlock()
    65  
    66  	return l.list.ContainsAll(c)
    67  }
    68  
    69  func (l *LockedMutableList[T]) MutableIterator() collections.MutableIterator[T] {
    70  	return &lockedMutableListIterator[T]{l.list.MutableIterator(), l.lock}
    71  }
    72  
    73  func (l *LockedMutableList[T]) Add(element T) bool {
    74  	l.lock.Lock()
    75  	defer l.lock.Unlock()
    76  
    77  	return l.list.Add(element)
    78  }
    79  
    80  func (l *LockedMutableList[T]) Remove(element T) exceptions.Exception {
    81  	l.lock.Lock()
    82  	defer l.lock.Unlock()
    83  
    84  	return l.list.Remove(element)
    85  }
    86  
    87  func (l *LockedMutableList[T]) AddAll(c collections.Collection[T]) bool {
    88  	l.lock.Lock()
    89  	defer l.lock.Unlock()
    90  
    91  	return l.list.AddAll(c)
    92  }
    93  
    94  func (l *LockedMutableList[T]) RemoveAll(c collections.Collection[T]) bool {
    95  	l.lock.Lock()
    96  	defer l.lock.Unlock()
    97  
    98  	return l.list.RemoveAll(c)
    99  }
   100  
   101  func (l *LockedMutableList[T]) RetainAll(c collections.Collection[T]) bool {
   102  	l.lock.Lock()
   103  	defer l.lock.Unlock()
   104  
   105  	return l.list.RetainAll(c)
   106  }
   107  
   108  func (l *LockedMutableList[T]) Clear() {
   109  	l.lock.Lock()
   110  	defer l.lock.Unlock()
   111  
   112  	l.list.Clear()
   113  }
   114  
   115  func (l *LockedMutableList[T]) Get(index int) (T, exceptions.Exception) {
   116  	l.lock.RLock()
   117  	defer l.lock.RUnlock()
   118  
   119  	return l.list.Get(index)
   120  }
   121  
   122  func (l *LockedMutableList[T]) SubList(from, to int) collections.List[T] {
   123  	return l.SubMutableList(from, to)
   124  }
   125  
   126  func (l *LockedMutableList[T]) Set(index int, element T) exceptions.Exception {
   127  	l.lock.Lock()
   128  	defer l.lock.Unlock()
   129  
   130  	return l.list.Set(index, element)
   131  }
   132  
   133  func (l *LockedMutableList[T]) AddAtIndex(index int, element T) bool {
   134  	l.lock.Lock()
   135  	defer l.lock.Unlock()
   136  
   137  	return l.list.AddAtIndex(index, element)
   138  }
   139  
   140  func (l *LockedMutableList[T]) RemoveAt(index int) exceptions.Exception {
   141  	l.lock.Lock()
   142  	defer l.lock.Unlock()
   143  
   144  	return l.list.RemoveAt(index)
   145  }
   146  
   147  func (l *LockedMutableList[T]) SubMutableList(from, to int) collections.MutableList[T] {
   148  	return &LockedMutableList[T]{l.list.SubMutableList(from, to), l.lock}
   149  }
   150  
   151  func (l *lockedMutableListIterator[T]) HasNext() bool {
   152  	l.lock.RLock()
   153  	defer l.lock.RUnlock()
   154  
   155  	return l.iterator.HasNext()
   156  }
   157  
   158  func (l *lockedMutableListIterator[T]) Next() (T, exceptions.Exception) {
   159  	l.lock.RLock()
   160  	defer l.lock.RUnlock()
   161  
   162  	return l.iterator.Next()
   163  }
   164  
   165  func (l *lockedMutableListIterator[T]) Remove() exceptions.Exception {
   166  	l.lock.Lock()
   167  	defer l.lock.Unlock()
   168  
   169  	return l.iterator.Remove()
   170  }
   171  
   172  func (l *LockedMutableList[T]) ListIterator() collections.ListIterator[T] {
   173  	//TODO implement me
   174  	panic("implement me")
   175  }
   176  
   177  func (l *LockedMutableList[T]) MutableListIterator() collections.MutableListIterator[T] {
   178  	//TODO implement me
   179  	panic("implement me")
   180  }