private ThreadAheadReadable(CharReadable actual, int bufferSize) : base(actual) { this._actual = actual; this._theOtherBuffer = new SectionedCharBuffer(bufferSize); this._sourceDescription = actual.SourceDescription(); start(); }
/// <summary> /// Extracts the first line, i.e characters until the first newline or end of stream. /// Reads one character at a time to be sure not to read too far ahead. The stream is left /// in a state of either exhausted or at the beginning of the next line of data. /// </summary> /// <param name="source"> <seealso cref="CharReadable"/> to read from. </param> /// <returns> char[] containing characters until the first newline character or end of stream. </returns> /// <exception cref="IOException"> on I/O reading error. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static char[] extractFirstLineFrom(CharReadable source) throws java.io.IOException public static char[] ExtractFirstLineFrom(CharReadable source) { char[] result = new char[100]; int cursor = 0; int read; bool foundEol = false; do { // Grow on demand if (cursor >= result.Length) { result = Arrays.copyOf(result, cursor * 2); } // Read one character read = source.Read(result, cursor, 1); if (read > 0) { foundEol = BufferedCharSeeker.IsEolChar(result[cursor]); if (!foundEol) { cursor++; } } } while (read > 0 && !foundEol); return(Arrays.copyOf(result, cursor)); }
private void WarnAboutDuplicateSourceFiles(ISet <string> seenSourceFiles, CharReadable source) { string sourceDescription = source.SourceDescription(); if (!seenSourceFiles.Add(sourceDescription)) { _monitor.duplicateSourceFile(sourceDescription); } }
/// <summary> /// Instantiates a <seealso cref="BufferedCharSeeker"/> with optional <seealso cref="ThreadAheadReadable read-ahead"/> capability. /// </summary> /// <param name="reader"> the <seealso cref="CharReadable"/> which is the source of data, f.ex. a <seealso cref="System.IO.StreamReader_FileReader"/>. </param> /// <param name="config"> <seealso cref="Configuration"/> for the resulting <seealso cref="CharSeeker"/>. </param> /// <param name="readAhead"> whether or not to start a <seealso cref="ThreadAheadReadable read-ahead thread"/> /// which strives towards always keeping one buffer worth of data read and available from I/O when it's /// time for the <seealso cref="BufferedCharSeeker"/> to read more data. </param> /// <returns> a <seealso cref="CharSeeker"/> with optional <seealso cref="ThreadAheadReadable read-ahead"/> capability. </returns> public static CharSeeker CharSeeker(CharReadable reader, Configuration config, bool readAhead) { if (readAhead) { // Thread that always has one buffer read ahead reader = threadAhead(reader, config.BufferSize()); } // Give the reader to the char seeker return(new BufferedCharSeeker(new AutoReadingSource(reader, config.BufferSize()), config)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private long[] sample(Iterable<DataFactory> dataFactories, Header.Factory headerFactory, System.Func<org.neo4j.values.storable.Value[], int> valueSizeCalculator, System.Func<org.neo4j.unsafe.impl.batchimport.input.InputEntity, int> additionalCalculator) throws java.io.IOException private long[] Sample(IEnumerable <DataFactory> dataFactories, Header.Factory headerFactory, System.Func <Value[], int> valueSizeCalculator, System.Func <InputEntity, int> additionalCalculator) { long[] estimates = new long[4]; // [entity count, property count, property size, labels (for nodes only)] using (CsvInputChunkProxy chunk = new CsvInputChunkProxy()) { // One group of input files int groupId = 0; foreach (DataFactory dataFactory in dataFactories) // one input group { groupId++; Header header = null; Data data = dataFactory.Create(_config); RawIterator <CharReadable, IOException> sources = data.Stream(); while (sources.HasNext()) { using (CharReadable source = sources.Next()) { if (header == null) { // Extract the header from the first file in this group header = extractHeader(source, headerFactory, _idType, _config, _groups); } using (CsvInputIterator iterator = new CsvInputIterator(source, data.Decorator(), header, _config, _idType, EMPTY, extractors(_config), groupId), InputEntity entity = new InputEntity()) { int entities = 0; int properties = 0; int propertySize = 0; int additional = 0; while (iterator.Position() < _estimateSampleSize && iterator.Next(chunk)) { for ( ; chunk.Next(entity); entities++) { properties += entity.PropertyCount(); propertySize += calculatePropertySize(entity, valueSizeCalculator); additional += additionalCalculator(entity); } } if (entities > 0) { long entityCountInSource = ( long )((( double )source.Length() / iterator.Position()) * entities); estimates[0] += entityCountInSource; estimates[1] += ( long )((( double )properties / entities) * entityCountInSource); estimates[2] += ( long )((( double )propertySize / entities) * entityCountInSource); estimates[3] += ( long )((( double )additional / entities) * entityCountInSource); } } } } } } return(estimates); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldExtractOnlyLine() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldExtractOnlyLine() { // given string firstLine = "characters of only line"; CharReadable reader = Readables.Wrap(firstLine); // when char[] firstLineCharacters = Readables.ExtractFirstLineFrom(reader); int readAfterwards = reader.Read(new char[1], 0, 1); // then assertArrayEquals(firstLine.ToCharArray(), firstLineCharacters); assertEquals(-1, readAfterwards); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void warnAboutDuplicateSourceFiles(java.util.Set<String> seenSourceFiles, Iterable<DataFactory> dataFactories) throws java.io.IOException private void WarnAboutDuplicateSourceFiles(ISet <string> seenSourceFiles, IEnumerable <DataFactory> dataFactories) { foreach (DataFactory dataFactory in dataFactories) { RawIterator <CharReadable, IOException> stream = dataFactory.Create(_config).stream(); while (stream.HasNext()) { using (CharReadable source = stream.Next()) { WarnAboutDuplicateSourceFiles(seenSourceFiles, source); } } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private boolean goToNextSource() throws java.io.IOException private bool GoToNextSource() { if (_actual.hasNext()) { if (_current != null) { _previousPosition += _current.position(); } CloseCurrent(); _current = _actual.next(); return(true); } return(false); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldFailIfNoNewlineInChunk() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldFailIfNoNewlineInChunk() { // GIVEN CharReadable reader = Readables.Wrap("1234567\n89012345678901234"); // (next chunks): ^ // (actual chunks): ^ using (ClosestNewLineChunker source = new ClosestNewLineChunker(reader, 12)) { // WHEN Source_Chunk chunk = source.NewChunk(); assertTrue(source.NextChunk(chunk)); assertArrayEquals("1234567\n".ToCharArray(), CharactersOf(chunk)); assertThrows(typeof(System.InvalidOperationException), () => assertFalse(source.NextChunk(chunk))); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldExtractFirstLine() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldExtractFirstLine() { // given string firstLine = "characters of first line"; string secondLine = "here on the second line"; CharReadable reader = Readables.Wrap(firstLine + "\n" + secondLine); // when char[] firstLineCharacters = Readables.ExtractFirstLineFrom(reader); char[] secondLineCharacters = new char[secondLine.Length]; reader.Read(secondLineCharacters, 0, secondLineCharacters.Length); // then assertArrayEquals(firstLine.ToCharArray(), firstLineCharacters); assertArrayEquals(secondLine.ToCharArray(), secondLineCharacters); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldHandleReadAheadEmptyData() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldHandleReadAheadEmptyData() { // GIVEN TrackingReader actual = new TrackingReader(0); int bufferSize = 10; CharReadable aheadReadable = ThreadAheadReadable.ThreadAhead(actual, bufferSize); // WHEN actual.AwaitCompletedReadAttempts(1); // THEN SectionedCharBuffer buffer = new SectionedCharBuffer(bufferSize); buffer = aheadReadable.Read(buffer, buffer.Front()); assertEquals(buffer.Pivot(), buffer.Back()); assertEquals(buffer.Pivot(), buffer.Front()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldReadAhead() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldReadAhead() { // GIVEN TrackingReader actual = new TrackingReader(23); int bufferSize = 5; CharReadable aheadReader = ThreadAheadReadable.ThreadAhead(actual, bufferSize); SectionedCharBuffer buffer = new SectionedCharBuffer(bufferSize); // WHEN starting it up it should read and fill the buffer to the brim assertEquals(bufferSize, actual.AwaitCompletedReadAttempts(1)); // WHEN we read one buffer int read = 0; buffer = aheadReader.Read(buffer, buffer.Front()); AssertBuffer(Chars(read, bufferSize), buffer, 0, bufferSize); read += buffer.Available(); // and simulate reading all characters, i.e. back section will be empty in the new buffer buffer = aheadReader.Read(buffer, buffer.Front()); AssertBuffer(Chars(read, bufferSize), buffer, 0, bufferSize); read += buffer.Available(); // then simulate reading some characters, i.e. back section will contain some characters int keep = 2; buffer = aheadReader.Read(buffer, buffer.Front() - keep); AssertBuffer(Chars(read - keep, bufferSize + keep), buffer, keep, bufferSize); read += buffer.Available(); keep = 3; buffer = aheadReader.Read(buffer, buffer.Front() - keep); AssertBuffer(Chars(read - keep, bufferSize + keep), buffer, keep, bufferSize); read += buffer.Available(); keep = 1; buffer = aheadReader.Read(buffer, buffer.Front() - keep); assertEquals(3, buffer.Available()); AssertBuffer(Chars(read - keep, buffer.Available() + keep), buffer, keep, 3); read += buffer.Available(); assertEquals(23, read); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void shouldComplyWithSpecifiedCharset(java.nio.charset.Charset charset) throws Exception private void ShouldComplyWithSpecifiedCharset(Charset charset) { // GIVEN string data = "abcåäö[]{}"; File file = WriteToFile(data, charset); // WHEN CharReadable reader = Readables.Files(charset, file); SectionedCharBuffer buffer = new SectionedCharBuffer(100); buffer = reader.Read(buffer, buffer.Front()); // THEN char[] expected = data.ToCharArray(); char[] array = buffer.Array(); assertEquals(expected.Length, buffer.Available()); for (int i = 0; i < expected.Length; i++) { assertEquals(expected[i], array[buffer.Pivot() + i]); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldBackUpChunkToClosestNewline() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldBackUpChunkToClosestNewline() { // GIVEN CharReadable reader = Readables.Wrap("1234567\n8901234\n5678901234"); // (next chunks): ^ ^ // (actual chunks): ^ ^ using (ClosestNewLineChunker source = new ClosestNewLineChunker(reader, 12)) { // WHEN Source_Chunk chunk = source.NewChunk(); assertTrue(source.NextChunk(chunk)); assertArrayEquals("1234567\n".ToCharArray(), CharactersOf(chunk)); assertTrue(source.NextChunk(chunk)); assertArrayEquals("8901234\n".ToCharArray(), CharactersOf(chunk)); assertTrue(source.NextChunk(chunk)); assertArrayEquals("5678901234".ToCharArray(), CharactersOf(chunk)); // THEN assertFalse(source.NextChunk(chunk)); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldTrackPosition() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldTrackPosition() { // GIVEN string data = "1234567890"; // ^ ^ CharReadable reader = Readables.Wrap(data); SectionedCharBuffer buffer = new SectionedCharBuffer(4); // WHEN int expected = 0; do { buffer = reader.Read(buffer, buffer.Front()); expected += buffer.Available(); // THEN assertEquals(expected, reader.Position()); } while (buffer.HasAvailable()); // and THEN assertEquals(data.ToCharArray().length, expected); }
public static CharReadable ThreadAhead(CharReadable actual, int bufferSize) { return(new ThreadAheadReadable(actual, bufferSize)); }
public ClosestNewLineChunker(CharReadable reader, int chunkSize) : base(reader, chunkSize) { }
internal TrackingReader(int length) { this.Bytes = length * 2; this.Actual = Readables.Wrap(new CharArrayReader(Chars(0, length)), length * 2); }
public CharReadableChunker(CharReadable reader, int chunkSize) { this.Reader = reader; this.ChunkSize = chunkSize; this._backBuffer = new char[chunkSize >> 4]; }
public AutoReadingSource(CharReadable reader, SectionedCharBuffer charBuffer) { this._reader = reader; this._charBuffer = charBuffer; }
public AutoReadingSource(CharReadable reader, int bufferSize) : this(reader, new SectionedCharBuffer(bufferSize)) { }
/// <summary> /// Instantiates a <seealso cref="BufferedCharSeeker"/> with optional <seealso cref="ThreadAheadReadable read-ahead"/> capability. /// </summary> /// <param name="reader"> the <seealso cref="CharReadable"/> which is the source of data, f.ex. a <seealso cref="System.IO.StreamReader_FileReader"/>. </param> /// <param name="bufferSize"> buffer size of the seeker and, if enabled, the read-ahead thread. </param> /// <param name="readAhead"> whether or not to start a <seealso cref="ThreadAheadReadable read-ahead thread"/> /// which strives towards always keeping one buffer worth of data read and available from I/O when it's /// time for the <seealso cref="BufferedCharSeeker"/> to read more data. </param> /// <param name="quotationCharacter"> character to interpret quotation character. </param> /// <returns> a <seealso cref="CharSeeker"/> with optional <seealso cref="ThreadAheadReadable read-ahead"/> capability. </returns> //JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected: //ORIGINAL LINE: public static CharSeeker charSeeker(CharReadable reader, final int bufferSize, boolean readAhead, final char quotationCharacter) public static CharSeeker CharSeeker(CharReadable reader, int bufferSize, bool readAhead, char quotationCharacter) { return(charSeeker(reader, new Configuration_OverriddenAnonymousInnerClass(DEFAULT, bufferSize, quotationCharacter) , readAhead)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void assertReadText(CharReadable readable, String text) throws java.io.IOException private void AssertReadText(CharReadable readable, string text) { char[] readText = ReadMethod.read(readable, text.ToCharArray().length); assertArrayEquals(readText, text.ToCharArray()); }