3030import org .apache .baremaps .data .type .DataType ;
3131
3232/**
33- * A log of records backed by a {@link DataType} and a {@link Memory}. Elements are appended to the
34- * log and can be accessed by their position in the {@link Memory}. Appending elements to the log is
35- * thread-safe.
33+ * A log of elements that can only be appended to. Elements are stored in memory and can be accessed
34+ * by their position. Append operations are thread-safe.
3635 *
37- * @param <E> The type of the data.
36+ * @param <E> The type of elements in the log
3837 */
3938public class AppendOnlyLog <E > implements DataCollection <E > {
4039
@@ -47,21 +46,84 @@ public class AppendOnlyLog<E> implements DataCollection<E> {
4746 private final Lock lock = new ReentrantLock ();
4847
4948 /**
50- * Constructs an {@link AppendOnlyLog} .
49+ * Creates a new builder for an AppendOnlyLog.
5150 *
52- * @param dataType the data type
51+ * @param <E> the type of elements
52+ * @return a new builder
5353 */
54- public AppendOnlyLog ( DataType <E > dataType ) {
55- this ( dataType , new OffHeapMemory () );
54+ public static <E > Builder < E > builder ( ) {
55+ return new Builder <>( );
5656 }
5757
5858 /**
59- * Constructs an append only log.
59+ * Builder for AppendOnlyLog.
60+ *
61+ * @param <E> the type of elements
62+ */
63+ public static class Builder <E > {
64+ private DataType <E > dataType ;
65+ private Memory <?> memory ;
66+
67+ /**
68+ * Sets the data type for the log.
69+ *
70+ * @param dataType the data type
71+ * @return this builder
72+ */
73+ public Builder <E > dataType (DataType <?> dataType ) {
74+ @ SuppressWarnings ("unchecked" )
75+ DataType <E > castedDataType = (DataType <E >) dataType ;
76+ this .dataType = castedDataType ;
77+ return this ;
78+ }
79+
80+ /**
81+ * Sets the memory for the log.
82+ *
83+ * @param memory the memory
84+ * @return this builder
85+ */
86+ public Builder <E > memory (Memory <?> memory ) {
87+ this .memory = memory ;
88+ return this ;
89+ }
90+
91+ /**
92+ * Sets the memory for the log values.
93+ *
94+ * @param memory the memory
95+ * @return this builder
96+ */
97+ public Builder <E > values (Memory <?> memory ) {
98+ return memory (memory );
99+ }
100+
101+ /**
102+ * Builds a new AppendOnlyLog.
103+ *
104+ * @return a new AppendOnlyLog
105+ * @throws IllegalStateException if required parameters are missing
106+ */
107+ public AppendOnlyLog <E > build () {
108+ if (dataType == null ) {
109+ throw new IllegalStateException ("Data type must be specified" );
110+ }
111+
112+ if (memory == null ) {
113+ memory = new OffHeapMemory ();
114+ }
115+
116+ return new AppendOnlyLog <>(dataType , memory );
117+ }
118+ }
119+
120+ /**
121+ * Constructs an AppendOnlyLog.
60122 *
61123 * @param dataType the data type
62124 * @param memory the memory
63125 */
64- public AppendOnlyLog (DataType <E > dataType , Memory <?> memory ) {
126+ private AppendOnlyLog (DataType <E > dataType , Memory <?> memory ) {
65127 this .dataType = dataType ;
66128 this .memory = memory ;
67129 this .segmentSize = memory .segmentSize ();
@@ -70,10 +132,18 @@ public AppendOnlyLog(DataType<E> dataType, Memory<?> memory) {
70132 }
71133
72134 /**
73- * Appends the value to the log and returns its position in the memory.
135+ * Persists the current size to memory.
136+ */
137+ public void persistSize () {
138+ memory .segment (0 ).putLong (0 , size );
139+ }
140+
141+ /**
142+ * Appends an element to the log and returns its position in memory.
74143 *
75- * @param value the value
76- * @return the position of the value in the memory.
144+ * @param value the element to add
145+ * @return the position of the element in memory
146+ * @throws DataCollectionException if the element is too large for a segment
77147 */
78148 public long addPositioned (E value ) {
79149 int valueSize = dataType .size (value );
@@ -102,10 +172,10 @@ public long addPositioned(E value) {
102172 }
103173
104174 /**
105- * Returns a values at the specified position in the memory.
175+ * Returns the element at the specified position in memory.
106176 *
107- * @param position the position of the value
108- * @return the value
177+ * @param position the position of the element
178+ * @return the element
109179 */
110180 public E getPositioned (long position ) {
111181 long segmentIndex = position / segmentSize ;
@@ -130,32 +200,39 @@ public long size() {
130200 public void clear () {
131201 try {
132202 memory .clear ();
203+ this .size = 0 ;
204+ persistSize ();
133205 } catch (IOException e ) {
134206 throw new DataCollectionException (e );
135207 }
136208 }
137209
138210 /**
139- * Returns an iterator over the values of the log, starting at the beginning of the log. The
140- * iterator allows to get the current position in the memory.
211+ * Returns an iterator over the elements of this log.
141212 *
142- * @return an iterator over the values of the log
213+ * @return an iterator over the elements
143214 */
144215 @ Override
145216 public AppendOnlyLogIterator iterator () {
146217 return new AppendOnlyLogIterator (size );
147218 }
148219
220+ @ Override
221+ public void close () throws Exception {
222+ try {
223+ memory .close ();
224+ } catch (IOException e ) {
225+ throw new DataCollectionException (e );
226+ }
227+ }
228+
149229 /**
150- * An iterator over the values of the log that can be used to iterate over the values of the log
151- * and to get the current position in the memory.
230+ * An iterator over the elements in this log.
152231 */
153232 public class AppendOnlyLogIterator implements Iterator <E > {
154233
155234 private final long size ;
156-
157235 private long index ;
158-
159236 private long position ;
160237
161238 private AppendOnlyLogIterator (long size ) {
@@ -199,9 +276,13 @@ public E next() {
199276 return dataType .read (segment , (int ) segmentOffset );
200277 }
201278
279+ /**
280+ * Returns the current position in memory.
281+ *
282+ * @return the current position
283+ */
202284 public long getPosition () {
203285 return position ;
204286 }
205-
206287 }
207288}
0 commit comments