org.neo4j.csv.reader

Class SectionedCharBuffer

java.lang.Object

org.neo4j.csv.reader.SectionedCharBuffer

public class SectionedCharBuffer
extends Object

Has a similar role to a CharBuffer, but is tailored to how BufferedCharSeeker works and to be able to take full advantage of ThreadAheadReadable. First of all this thing wraps a char[] where the array, while still being one array, is sectioned into two equally sized parts: the back and the front. The flow of things is as follows:

1. Characters are read from a Reader using readFrom(Reader) into the front section, i.e. starting from the middle of the array and forwards.
2. Consumer of the read characters access the array() and starts reading from the pivot() point, which is the middle, to finally reach the end, denoted by front() (exclusive). During the reading typically characters are read into some sort of fields/values, and so the last characters of the array might represent an incomplete value.
3. For this reason, before reading more values into the array, the characters making up the last incomplete value can be moved to the back section using compact(SectionedCharBuffer, int) where after that call back() will point to the index in the array() containing the first value in the array.
4. Now more characters can be read into the front section using readFrom(Reader).

This divide into back and front section enables a behaviour in ThreadAheadReadable where the thread that reads ahead reads into the front section of another buffer, a double buffer, and the current buffer that BufferedCharSeeker is working with can compact(SectionedCharBuffer, int) its last incomplete characters into that double buffer and flip so that the BufferedCharSeeker continues to read from the other buffer, i.e. flips buffer every call to ThreadAheadReadable.read(SectionedCharBuffer, int). Without these sections the entire double buffer would have to be copied into the char seekers buffer to get the same behavior.

Constructor Summary

Constructors

Constructor and Description
SectionedCharBuffer(int effectiveBuffserSize)

Method Summary

Modifier and Type	Method and Description
void	append(char ch) Puts a character into the front section of the buffer and increments the front index.
char[]	array()
int	available()
int	back()
void	compact(SectionedCharBuffer into, int from) Copies characters in the array() from (and including) the given from index of the array and all characters forwards to front() (excluding) index.
int	front()
boolean	hasAvailable()
int	pivot()
void	readFrom(Reader reader) Reads characters from reader into the front section of this buffer, setting front() accordingly afterwards.
void	readFrom(Reader reader, int max) Like readFrom(Reader) but with added max argument for limiting the number of characters read from the Reader.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SectionedCharBuffer

public SectionedCharBuffer(int effectiveBuffserSize)

Parameters:

effectiveBuffserSize - Size of each section, i.e. effective buffer size that can be read each time.

Method Detail

array

public char[] array()

Returns:

the underlying array which characters are read into. back(), pivot() and front() marks the noteworthy indexes into this array.

compact

public void compact(SectionedCharBuffer into,
                    int from)

Copies characters in the array() from (and including) the given from index of the array and all characters forwards to front() (excluding) index. These characters are copied into the array() of the given into buffer, where the character array[from] will be be copied to into.array[pivot-(front-from)], and so on. As an example:

 pivot (i.e. effective buffer size) = 16
 buffer A
 <------ back ------> <------ front ----->
 [    .    .    .    |abcd.efgh.ijkl.mnop]
                                 ^ = 25

 A.compactInto( B, 25 )

 buffer B
 <------ back ------> <------ front ----->
 [    .    . jkl.mnop|    .    .    .    ]
 

Parameters:

into - which buffer to compact into.

from - the array index to start compacting from.

readFrom

public void readFrom(Reader reader)
              throws IOException

Reads characters from reader into the front section of this buffer, setting front() accordingly afterwards. If no characters were read due to end reached then hasAvailable() will return false after this call, likewise available() will return 0.

Parameters:

reader - Reader to read from.

Throws:

IOException - any exception from the Reader.

readFrom

public void readFrom(Reader reader,
                     int max)
              throws IOException

Like readFrom(Reader) but with added max argument for limiting the number of characters read from the Reader.

Throws:

IOException

See Also:

readFrom(Reader)

append

public void append(char ch)

Puts a character into the front section of the buffer and increments the front index.

Parameters:

ch -

pivot

public int pivot()

Returns:

the pivot point of the array(). Before the pivot there are characters saved from a previous compaction and after (and including) this point are characters read from readFrom(Reader).

back

public int back()

Returns:

index of first available character, might be before pivot point if there have been characters moved over from a previous compaction.

front

public int front()

Returns:

index of the last available character plus one.

hasAvailable

public boolean hasAvailable()

Returns:

whether or not there are characters read into the front section of the buffer.

available

public int available()

Returns:

the number of characters available in the front section of the buffer.