]> git.ktnx.net Git - mobile-ledger.git/blob - app/src/main/java/net/ktnx/mobileledger/utils/ObservableList.java
Data: single central method for changing the current profile
[mobile-ledger.git] / app / src / main / java / net / ktnx / mobileledger / utils / ObservableList.java
1 /*
2  * Copyright © 2019 Damyan Ivanov.
3  * This file is part of Mobile-Ledger.
4  * Mobile-Ledger is free software: you can distribute it and/or modify it
5  * under the term of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your opinion), any later version.
8  *
9  * Mobile-Ledger is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License terms for details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with Mobile-Ledger. If not, see <https://www.gnu.org/licenses/>.
16  */
17
18 package net.ktnx.mobileledger.utils;
19
20 import android.os.Build;
21 import android.support.annotation.NonNull;
22 import android.support.annotation.Nullable;
23 import android.support.annotation.RequiresApi;
24
25 import java.util.Collection;
26 import java.util.Comparator;
27 import java.util.Iterator;
28 import java.util.List;
29 import java.util.ListIterator;
30 import java.util.Observable;
31 import java.util.Spliterator;
32 import java.util.function.Consumer;
33 import java.util.function.Predicate;
34 import java.util.function.UnaryOperator;
35 import java.util.stream.Stream;
36
37 public class ObservableList<T> extends Observable {
38     private List<T> list;
39     public ObservableList(List<T> list) {
40         this.list = list;
41     }
42     private void forceNotify() {
43         setChanged();
44         notifyObservers();
45     }
46     private void forceNotify(Object arg) {
47         setChanged();
48         notifyObservers(arg);
49     }
50     public int size() {
51         return list.size();
52     }
53     public boolean isEmpty() {
54         return list.isEmpty();
55     }
56     public boolean contains(@Nullable Object o) {
57         return list.contains(o);
58     }
59     public Iterator<T> iterator() {
60         return list.iterator();
61     }
62     public Object[] toArray() {
63         return list.toArray();
64     }
65     public <T1> T1[] toArray(@Nullable T1[] a) {
66         return list.toArray(a);
67     }
68     public boolean add(T t) {
69         boolean result = list.add(t);
70         if (result) forceNotify();
71         return result;
72     }
73     public boolean remove(@Nullable Object o) {
74         boolean result = list.remove(o);
75         if (result) forceNotify();
76         return result;
77     }
78     public boolean containsAll(@NonNull Collection<?> c) {
79         return list.containsAll(c);
80     }
81     public boolean addAll(@NonNull Collection<? extends T> c) {
82         boolean result = list.addAll(c);
83         if (result) forceNotify();
84         return result;
85     }
86     public boolean addAll(int index, @NonNull Collection<? extends T> c) {
87         boolean result = list.addAll(index, c);
88         if (result) forceNotify();
89         return result;
90     }
91     public boolean removeAll(@NonNull Collection<?> c) {
92         boolean result = list.removeAll(c);
93         if (result) forceNotify();
94         return result;
95     }
96     public boolean retainAll(@NonNull Collection<?> c) {
97         boolean result = list.retainAll(c);
98         if (result) forceNotify();
99         return result;
100     }
101     @RequiresApi(api = Build.VERSION_CODES.N)
102     public void replaceAll(@NonNull UnaryOperator<T> operator) {
103         list.replaceAll(operator);
104         forceNotify();
105     }
106     @RequiresApi(api = Build.VERSION_CODES.N)
107     public void sort(@Nullable Comparator<? super T> c) {
108         list.sort(c);
109         forceNotify();
110     }
111     public void clear() {
112         boolean wasEmpty = list.isEmpty();
113         list.clear();
114         if (!wasEmpty) forceNotify();
115     }
116     public T get(int index) {
117         return list.get(index);
118     }
119     public T set(int index, T element) {
120         T result = list.set(index, element);
121         forceNotify();
122         return result;
123     }
124     public void add(int index, T element) {
125         list.add(index, element);
126         forceNotify();
127     }
128     public T remove(int index) {
129         T result = list.remove(index);
130         forceNotify();
131         return result;
132     }
133     public int indexOf(@Nullable Object o) {
134         return list.indexOf(o);
135     }
136     public int lastIndexOf(@Nullable Object o) {
137         return list.lastIndexOf(o);
138     }
139     public ListIterator<T> listIterator() {
140         return list.listIterator();
141     }
142     public ListIterator<T> listIterator(int index) {
143         return list.listIterator(index);
144     }
145     public List<T> subList(int fromIndex, int toIndex) {
146         return list.subList(fromIndex, toIndex);
147     }
148     @RequiresApi(api = Build.VERSION_CODES.N)
149     public Spliterator<T> spliterator() {
150         return list.spliterator();
151     }
152     @RequiresApi(api = Build.VERSION_CODES.N)
153     public boolean removeIf(Predicate<? super T> filter) {
154         boolean result = list.removeIf(filter);
155         if (result) forceNotify();
156         return result;
157     }
158     @RequiresApi(api = Build.VERSION_CODES.N)
159     public Stream<T> stream() {
160         return list.stream();
161     }
162     @RequiresApi(api = Build.VERSION_CODES.N)
163     public Stream<T> parallelStream() {
164         return list.parallelStream();
165     }
166     @RequiresApi(api = Build.VERSION_CODES.N)
167     public void forEach(Consumer<? super T> action) {
168         list.forEach(action);
169     }
170     public void setList(List<T> aList) {
171         list = aList;
172         forceNotify();
173     }
174     public List<T> getList() {
175         return list;
176     }
177 }