src/Tizen.NUI/src/internal/XamlBinding/SynchronizedList.cs

   1 using System.Collections;
   2 using System.Collections.Generic;
   3 using System.Collections.ObjectModel;
   4 using System.Linq;
   5
   6 namespace Tizen.NUI.Binding
   7 {
   8         internal class SynchronizedList<T> : IList<T>, IReadOnlyList<T>
   9         {
  10                 readonly List<T> _list = new List<T>();
  11                 ReadOnlyCollection<T> _snapshot;
  12
  13                 public void Add(T item)
  14                 {
  15                         lock (_list)
  16                         {
  17                                 _list.Add(item);
  18                                 _snapshot = null;
  19                         }
  20                 }
  21
  22                 public void Clear()
  23                 {
  24                         lock (_list)
  25                         {
  26                                 _list.Clear();
  27                                 _snapshot = null;
  28                         }
  29                 }
  30
  31                 public bool Contains(T item)
  32                 {
  33                         lock (_list)
  34                                 return _list.Contains(item);
  35                 }
  36
  37                 public void CopyTo(T[] array, int arrayIndex)
  38                 {
  39                         lock (_list)
  40                                 _list.CopyTo(array, arrayIndex);
  41                 }
  42
  43                 public int Count
  44                 {
  45                         get { return _list.Count; }
  46                 }
  47
  48                 bool ICollection<T>.IsReadOnly
  49                 {
  50                         get { return false; }
  51                 }
  52
  53                 public bool Remove(T item)
  54                 {
  55                         lock (_list)
  56                         {
  57                                 if (_list.Remove(item))
  58                                 {
  59                                         _snapshot = null;
  60                                         return true;
  61                                 }
  62
  63                                 return false;
  64                         }
  65                 }
  66
  67                 IEnumerator IEnumerable.GetEnumerator()
  68                 {
  69                         return GetEnumerator();
  70                 }
  71
  72                 public IEnumerator<T> GetEnumerator()
  73                 {
  74                         ReadOnlyCollection<T> snap = _snapshot;
  75                         if (snap == null)
  76                         {
  77                                 lock (_list)
  78                                         _snapshot = snap = new ReadOnlyCollection<T>(_list.ToList());
  79                         }
  80
  81                         return snap?.GetEnumerator();
  82                 }
  83
  84                 public int IndexOf(T item)
  85                 {
  86                         lock (_list)
  87                                 return _list.IndexOf(item);
  88                 }
  89
  90                 public void Insert(int index, T item)
  91                 {
  92                         lock (_list)
  93                         {
  94                                 _list.Insert(index, item);
  95                                 _snapshot = null;
  96                         }
  97                 }
  98
  99                 public T this[int index]
 100                 {
 101                         get
 102                         {
 103                                 ReadOnlyCollection<T> snap = _snapshot;
 104                                 if (snap != null)
 105                                         return snap[index];
 106
 107                                 lock (_list)
 108                                         return _list[index];
 109                         }
 110
 111                         set
 112                         {
 113                                 lock (_list)
 114                                 {
 115                                         _list[index] = value;
 116                                         _snapshot = null;
 117                                 }
 118                         }
 119                 }
 120
 121                 public void RemoveAt(int index)
 122                 {
 123                         lock (_list)
 124                         {
 125                                 _list.RemoveAt(index);
 126                                 _snapshot = null;
 127                         }
 128                 }
 129         }
 130 }