1 /*******************************************************************************
2 * Copyright (c) 2016 Ericsson
4 * All rights reserved. This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License v1.0
6 * which accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
8 *******************************************************************************/
10 package org
.eclipse
.tracecompass
.internal
.analysis
.timing
.core
.store
;
12 import static org
.eclipse
.tracecompass
.common
.core
.NonNullUtils
.checkNotNull
;
14 import java
.util
.ArrayList
;
15 import java
.util
.Collection
;
16 import java
.util
.Collections
;
17 import java
.util
.Comparator
;
18 import java
.util
.Iterator
;
19 import java
.util
.List
;
20 import java
.util
.concurrent
.locks
.ReadWriteLock
;
21 import java
.util
.concurrent
.locks
.ReentrantReadWriteLock
;
22 import java
.util
.stream
.Collectors
;
24 import org
.eclipse
.jdt
.annotation
.NonNull
;
25 import org
.eclipse
.jdt
.annotation
.Nullable
;
26 import org
.eclipse
.tracecompass
.segmentstore
.core
.ISegment
;
27 import org
.eclipse
.tracecompass
.segmentstore
.core
.ISegmentStore
;
29 import com
.google
.common
.collect
.ImmutableList
;
32 * Implementation of an {@link ISegmentStore} using one in-memory
33 * {@link ArrayList}. This relatively simple implementation holds everything in
34 * memory, and as such cannot contain too much data.
36 * The ArrayListStore itself is {@link Iterable}, and its iteration order will
37 * be by ascending order of start times. For segments with identical start
38 * times, the secondary comparator will be the end time. If even those are
39 * equal, it will defer to the segments' natural ordering (
40 * {@link ISegment#compareTo}).
42 * The store's tree maps will not accept duplicate key-value pairs, which means
43 * that if you want several segments with the same start and end times, make
44 * sure their compareTo() differentiates them.
46 * Removal operations are not supported.
49 * The type of segment held in this store
51 * @author Matthew Khouzam
53 public class ArrayListStore
<@NonNull E
extends ISegment
> implements ISegmentStore
<E
> {
55 private final Comparator
<E
> COMPARATOR
= (o1
, o2
) -> {
56 int ret
= Long
.compare(o1
.getStart(), o2
.getStart());
58 return Long
.compare(o1
.getEnd(), o2
.getEnd());
63 private final ReadWriteLock fLock
= new ReentrantReadWriteLock(false);
65 private final List
<E
> fStore
= new ArrayList
<>();
67 private @Nullable transient Iterable
<E
> fLastSnapshot
= null;
72 public ArrayListStore() {
74 * For the start times index, the "key comparator" will compare the
75 * start times as longs directly. This is the primary comparator for its
78 * The secondary "value" comparator will check the end times first.
80 * The same is done for the end times index, but swapping the first two
81 * comparators instead.
85 // ------------------------------------------------------------------------
86 // Methods from Collection
87 // ------------------------------------------------------------------------
90 public Iterator
<E
> iterator() {
91 fLock
.readLock().lock();
93 Iterable
<E
> lastSnapshot
= fLastSnapshot
;
94 if (lastSnapshot
== null) {
95 lastSnapshot
= ImmutableList
.copyOf(fStore
);
96 fLastSnapshot
= lastSnapshot
;
98 return checkNotNull(lastSnapshot
.iterator());
100 fLock
.readLock().unlock();
105 public boolean add(@Nullable E val
) {
107 throw new IllegalArgumentException("Cannot add null value"); //$NON-NLS-1$
110 fLock
.writeLock().lock();
113 // Go backwards to "sift up" like a priority queue
114 for (int i
= size() - 1; i
> 0 && COMPARATOR
.compare(val
, fStore
.get(i
- 1)) < 0; i
--) {
115 Collections
.swap(fStore
, i
, i
- 1);
119 fLock
.writeLock().unlock();
125 return fStore
.size();
129 public boolean isEmpty() {
130 return fStore
.isEmpty();
134 public boolean contains(@Nullable Object o
) {
135 fLock
.readLock().lock();
137 return fStore
.contains(o
);
139 fLock
.readLock().unlock();
144 public boolean containsAll(@Nullable Collection
<?
> c
) {
145 fLock
.readLock().lock();
147 return fStore
.containsAll(c
);
149 fLock
.readLock().unlock();
154 public Object
[] toArray() {
155 fLock
.readLock().lock();
157 return fStore
.toArray();
159 fLock
.readLock().unlock();
164 public <T
> T
[] toArray(T
[] a
) {
165 fLock
.readLock().lock();
167 return fStore
.toArray(a
);
169 fLock
.readLock().unlock();
174 public boolean remove(@Nullable Object o
) {
175 throw new UnsupportedOperationException();
179 public boolean addAll(@Nullable Collection
<?
extends E
> c
) {
181 throw new IllegalArgumentException();
184 fLock
.writeLock().lock();
186 boolean changed
= false;
188 if (this.add(elem
)) {
194 fLock
.writeLock().unlock();
199 public boolean removeAll(@Nullable Collection
<?
> c
) {
200 throw new UnsupportedOperationException();
204 public boolean retainAll(@Nullable Collection
<?
> c
) {
205 throw new UnsupportedOperationException();
209 public void clear() {
210 fLock
.writeLock().lock();
214 fLock
.writeLock().unlock();
218 // ------------------------------------------------------------------------
219 // Methods added by ISegmentStore
220 // ------------------------------------------------------------------------
223 public Iterable
<E
> getIntersectingElements(long position
) {
225 * The intervals intersecting 't' are those whose 1) start time is
226 * *lower* than 't' AND 2) end time is *higher* than 't'.
228 fLock
.readLock().lock();
230 return fStore
.stream().filter(element
-> position
>= element
.getStart() && position
<= element
.getEnd()).collect(Collectors
.toList());
232 fLock
.readLock().unlock();
237 public Iterable
<E
> getIntersectingElements(long start
, long end
) {
238 fLock
.readLock().lock();
240 return fStore
.stream().filter(element
-> !(start
> element
.getEnd() || end
< element
.getStart())).collect(Collectors
.toList());
242 fLock
.readLock().unlock();
247 public void dispose() {
248 fLock
.writeLock().lock();
252 fLock
.writeLock().unlock();
This page took 0.037645 seconds and 6 git commands to generate.