From ef66ca49724f3aab1c13efda89a16763f9ae1cc2 Mon Sep 17 00:00:00 2001 From: Eric Coissac Date: Fri, 14 Jan 2022 17:32:12 +0100 Subject: [PATCH] Code refactoring --- pkg/obiformats/ecopcr_read.go | 16 ++--- pkg/obiformats/embl_read.go | 82 +++++++++++------------ pkg/obiformats/fastseq_read.go | 28 ++++---- pkg/obiformats/fastseq_write_fasta.go | 6 +- pkg/obiformats/fastseq_write_fastq.go | 16 ++--- pkg/obiseq/batchiterator.go | 80 +++++++++++------------ pkg/obiseq/iterator.go | 94 +++++++++++++-------------- pkg/obiseq/pairedbatchiterator.go | 20 +++--- pkg/obiseq/workers.go | 46 ++++++------- pkg/obitax/filter_on_name.go | 12 ++-- pkg/obitax/filter_on_rank.go | 8 +-- pkg/obitax/filter_on_subclade_of.go | 16 ++--- pkg/obitax/iterator.go | 4 +- pkg/obitools/obipairing/options.go | 36 +++++----- pkg/obitools/obipairing/pairing.go | 16 ++--- pkg/obitools/obipcr/options.go | 40 ++++++------ 16 files changed, 260 insertions(+), 260 deletions(-) diff --git a/pkg/obiformats/ecopcr_read.go b/pkg/obiformats/ecopcr_read.go index 10017e6..f24374f 100644 --- a/pkg/obiformats/ecopcr_read.go +++ b/pkg/obiformats/ecopcr_read.go @@ -163,12 +163,12 @@ func ReadEcoPCRBatch(reader io.Reader, options ...WithOption) obiseq.IBioSequenc opt := MakeOptions(options) - new_iter := obiseq.MakeIBioSequenceBatch(opt.BufferSize()) - new_iter.Add(1) + newIter := obiseq.MakeIBioSequenceBatch(opt.BufferSize()) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.Channel()) + newIter.Wait() + close(newIter.Channel()) }() go func() { @@ -181,7 +181,7 @@ func ReadEcoPCRBatch(reader io.Reader, options ...WithOption) obiseq.IBioSequenc slice = append(slice, seq) ii++ if ii >= opt.BatchSize() { - new_iter.Channel() <- obiseq.MakeBioSequenceBatch(i, slice...) + newIter.Channel() <- obiseq.MakeBioSequenceBatch(i, slice...) slice = make(obiseq.BioSequenceSlice, 0, opt.BatchSize()) i++ @@ -192,10 +192,10 @@ func ReadEcoPCRBatch(reader io.Reader, options ...WithOption) obiseq.IBioSequenc } if len(slice) > 0 { - new_iter.Channel() <- obiseq.MakeBioSequenceBatch(i, slice...) + newIter.Channel() <- obiseq.MakeBioSequenceBatch(i, slice...) } - new_iter.Done() + newIter.Done() if err != nil && err != io.EOF { log.Panicf("%+v", err) @@ -203,7 +203,7 @@ func ReadEcoPCRBatch(reader io.Reader, options ...WithOption) obiseq.IBioSequenc }() - return new_iter + return newIter } func ReadEcoPCR(reader io.Reader, options ...WithOption) obiseq.IBioSequence { diff --git a/pkg/obiformats/embl_read.go b/pkg/obiformats/embl_read.go index eee11fd..bf3eaac 100644 --- a/pkg/obiformats/embl_read.go +++ b/pkg/obiformats/embl_read.go @@ -14,14 +14,14 @@ import ( "git.metabarcoding.org/lecasofts/go/obitools/pkg/obiseq" ) -var __FILE_CHUNK_SIZE__ = 1 << 20 +var _FileChunkSize = 1 << 20 -type __file_chunk__ struct { +type _FileChunk struct { raw io.Reader order int } -func __end_of_last_entry__(buff []byte) int { +func _EndOfLastEntry(buff []byte) int { // 6 5 43 2 1 // ?//? var i int @@ -76,22 +76,22 @@ func __end_of_last_entry__(buff []byte) int { if i > 0 { return start - } else { - return -1 } + + return -1 } -func __parse_embl_file__(input <-chan __file_chunk__, out obiseq.IBioSequenceBatch) { +func _ParseEmblFile(input <-chan _FileChunk, out obiseq.IBioSequenceBatch) { for chunks := range input { scanner := bufio.NewScanner(chunks.raw) order := chunks.order sequences := make(obiseq.BioSequenceSlice, 0, 100) id := "" - scientific_name := "" - def_bytes := new(bytes.Buffer) - feat_bytes := new(bytes.Buffer) - seq_bytes := new(bytes.Buffer) + scientificName := "" + defBytes := new(bytes.Buffer) + featBytes := new(bytes.Buffer) + seqBytes := new(bytes.Buffer) taxid := 1 for scanner.Scan() { @@ -101,43 +101,43 @@ func __parse_embl_file__(input <-chan __file_chunk__, out obiseq.IBioSequenceBat case strings.HasPrefix(line, "ID "): id = strings.SplitN(line[5:], ";", 2)[0] case strings.HasPrefix(line, "OS "): - scientific_name = strings.TrimSpace(line[5:]) + scientificName = strings.TrimSpace(line[5:]) case strings.HasPrefix(line, "DE "): - if def_bytes.Len() > 0 { - def_bytes.WriteByte(' ') + if defBytes.Len() > 0 { + defBytes.WriteByte(' ') } - def_bytes.WriteString(strings.TrimSpace(line[5:])) + defBytes.WriteString(strings.TrimSpace(line[5:])) case strings.HasPrefix(line, "FH "): - feat_bytes.WriteString(line) + featBytes.WriteString(line) case line == "FH": - feat_bytes.WriteByte('\n') - feat_bytes.WriteString(line) + featBytes.WriteByte('\n') + featBytes.WriteString(line) case strings.HasPrefix(line, "FT "): - feat_bytes.WriteByte('\n') - feat_bytes.WriteString(line) + featBytes.WriteByte('\n') + featBytes.WriteString(line) if strings.HasPrefix(line, `FT /db_xref="taxon:`) { taxid, _ = strconv.Atoi(strings.SplitN(line[37:], `"`, 2)[0]) } case strings.HasPrefix(line, " "): parts := strings.SplitN(line[5:], " ", 7) for i := 0; i < 6; i++ { - seq_bytes.WriteString(parts[i]) + seqBytes.WriteString(parts[i]) } case line == "//": sequence := obiseq.MakeBioSequence(id, - seq_bytes.Bytes(), - def_bytes.String()) + seqBytes.Bytes(), + defBytes.String()) - sequence.SetFeatures(feat_bytes.String()) + sequence.SetFeatures(featBytes.String()) annot := sequence.Annotations() - annot["scientific_name"] = scientific_name + annot["scientific_name"] = scientificName annot["taxid"] = taxid // log.Println(FormatFasta(sequence, FormatFastSeqJsonHeader)) sequences = append(sequences, sequence) - def_bytes = new(bytes.Buffer) - feat_bytes = new(bytes.Buffer) - seq_bytes = new(bytes.Buffer) + defBytes = new(bytes.Buffer) + featBytes = new(bytes.Buffer) + seqBytes = new(bytes.Buffer) } } out.Channel() <- obiseq.MakeBioSequenceBatch(order, sequences...) @@ -148,7 +148,7 @@ func __parse_embl_file__(input <-chan __file_chunk__, out obiseq.IBioSequenceBat } -func __read_flat_file_chunk__(reader io.Reader, readers chan __file_chunk__) { +func _ReadFlatFileChunk(reader io.Reader, readers chan _FileChunk) { var err error var buff []byte @@ -162,13 +162,13 @@ func __read_flat_file_chunk__(reader io.Reader, readers chan __file_chunk__) { size, err = reader.Read(buff[l:]) } buff = buff[:l] - end := __end_of_last_entry__(buff) + end := _EndOfLastEntry(buff) remains := buff[end:] buff = buff[:end] io := bytes.NewBuffer(buff) - readers <- __file_chunk__{io, i} + readers <- _FileChunk{io, i} i++ - buff = make([]byte, __FILE_CHUNK_SIZE__) + buff = make([]byte, _FileChunkSize) copy(buff, remains) l = len(remains) } @@ -180,29 +180,29 @@ func __read_flat_file_chunk__(reader io.Reader, readers chan __file_chunk__) { // ?//? func ReadEMBLBatch(reader io.Reader, options ...WithOption) obiseq.IBioSequenceBatch { opt := MakeOptions(options) - entry_channel := make(chan __file_chunk__, opt.BufferSize()) + entry_channel := make(chan _FileChunk, opt.BufferSize()) - new_iter := obiseq.MakeIBioSequenceBatch(opt.BufferSize()) + newIter := obiseq.MakeIBioSequenceBatch(opt.BufferSize()) - // new_iter.Add(opt.ParallelWorkers()) - new_iter.Add(2) + // newIter.Add(opt.ParallelWorkers()) + newIter.Add(2) go func() { - new_iter.Wait() - for len(new_iter.Channel()) > 0 { + newIter.Wait() + for len(newIter.Channel()) > 0 { time.Sleep(time.Millisecond) } - close(new_iter.Channel()) + close(newIter.Channel()) }() // for j := 0; j < opt.ParallelWorkers(); j++ { for j := 0; j < 2; j++ { - go __parse_embl_file__(entry_channel, new_iter) + go _ParseEmblFile(entry_channel, newIter) } - go __read_flat_file_chunk__(reader, entry_channel) + go _ReadFlatFileChunk(reader, entry_channel) - return new_iter + return newIter } func ReadEMBL(reader io.Reader, options ...WithOption) obiseq.IBioSequence { diff --git a/pkg/obiformats/fastseq_read.go b/pkg/obiformats/fastseq_read.go index cb2078e..605b88e 100644 --- a/pkg/obiformats/fastseq_read.go +++ b/pkg/obiformats/fastseq_read.go @@ -101,28 +101,28 @@ func ReadFastSeqBatchFromFile(filename string, options ...WithOption) (obiseq.IB size = -1 } - new_iter := obiseq.MakeIBioSequenceBatch(opt.BufferSize()) - new_iter.Add(1) + newIter := obiseq.MakeIBioSequenceBatch(opt.BufferSize()) + newIter.Add(1) go func() { - new_iter.Wait() - for len(new_iter.Channel()) > 0 { + newIter.Wait() + for len(newIter.Channel()) > 0 { time.Sleep(time.Millisecond) } - close(new_iter.Channel()) + close(newIter.Channel()) log.Println("End of the fastq file reading") }() log.Println("Start of the fastq file reading") - go __fastseq_reader__(pointer, new_iter, opt.BatchSize()) + go __fastseq_reader__(pointer, newIter, opt.BatchSize()) parser := opt.ParseFastSeqHeader() if parser != nil { - return IParseFastSeqHeaderBatch(new_iter, options...), err + return IParseFastSeqHeaderBatch(newIter, options...), err } - return new_iter, err + return newIter, err } func ReadFastSeqFromFile(filename string, options ...WithOption) (obiseq.IBioSequence, error) { @@ -132,18 +132,18 @@ func ReadFastSeqFromFile(filename string, options ...WithOption) (obiseq.IBioSeq func ReadFastSeqBatchFromStdin(options ...WithOption) obiseq.IBioSequenceBatch { opt := MakeOptions(options) - new_iter := obiseq.MakeIBioSequenceBatch(opt.BufferSize()) + newIter := obiseq.MakeIBioSequenceBatch(opt.BufferSize()) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.Channel()) + newIter.Wait() + close(newIter.Channel()) }() - go __fastseq_reader__(C.open_fast_sek_stdin(C.int32_t(opt.QualityShift())), new_iter, opt.BatchSize()) + go __fastseq_reader__(C.open_fast_sek_stdin(C.int32_t(opt.QualityShift())), newIter, opt.BatchSize()) - return new_iter + return newIter } func ReadFastSeqFromStdin(options ...WithOption) obiseq.IBioSequence { diff --git a/pkg/obiformats/fastseq_write_fasta.go b/pkg/obiformats/fastseq_write_fasta.go index 2563af2..b8183bc 100644 --- a/pkg/obiformats/fastseq_write_fasta.go +++ b/pkg/obiformats/fastseq_write_fasta.go @@ -84,7 +84,7 @@ func WriteFastaToStdout(iterator obiseq.IBioSequence, options ...WithOption) err func WriteFastaBatch(iterator obiseq.IBioSequenceBatch, file io.Writer, options ...WithOption) error { buffsize := iterator.BufferSize() - new_iter := obiseq.MakeIBioSequenceBatch(buffsize) + newIter := obiseq.MakeIBioSequenceBatch(buffsize) opt := MakeOptions(options) nwriters := 4 @@ -111,9 +111,9 @@ func WriteFastaBatch(iterator obiseq.IBioSequenceBatch, file io.Writer, options FormatFastaBatch(batch, header_format), batch.Order(), } - new_iter.Channel() <- batch + newIter.Channel() <- batch } - new_iter.Done() + newIter.Done() } for i := 0; i < nwriters; i++ { diff --git a/pkg/obiformats/fastseq_write_fastq.go b/pkg/obiformats/fastseq_write_fastq.go index db76eb4..52afee2 100644 --- a/pkg/obiformats/fastseq_write_fastq.go +++ b/pkg/obiformats/fastseq_write_fastq.go @@ -83,7 +83,7 @@ type FileChunck struct { func WriteFastqBatch(iterator obiseq.IBioSequenceBatch, file io.Writer, options ...WithOption) (obiseq.IBioSequenceBatch, error) { buffsize := iterator.BufferSize() - new_iter := obiseq.MakeIBioSequenceBatch(buffsize) + newIter := obiseq.MakeIBioSequenceBatch(buffsize) opt := MakeOptions(options) nwriters := 4 @@ -93,18 +93,18 @@ func WriteFastqBatch(iterator obiseq.IBioSequenceBatch, file io.Writer, options header_format := opt.FormatFastSeqHeader() quality := opt.QualityShift() - new_iter.Add(nwriters) + newIter.Add(nwriters) go func() { - new_iter.Wait() + newIter.Wait() for len(chunkchan) > 0 { time.Sleep(time.Millisecond) } close(chunkchan) - for len(new_iter.Channel()) > 0 { + for len(newIter.Channel()) > 0 { time.Sleep(time.Millisecond) } - close(new_iter.Channel()) + close(newIter.Channel()) }() ff := func(iterator obiseq.IBioSequenceBatch) { @@ -114,9 +114,9 @@ func WriteFastqBatch(iterator obiseq.IBioSequenceBatch, file io.Writer, options FormatFastqBatch(batch, quality, header_format), batch.Order(), } - new_iter.Channel() <- batch + newIter.Channel() <- batch } - new_iter.Done() + newIter.Done() } log.Println("Start of the fastq file reading") @@ -146,7 +146,7 @@ func WriteFastqBatch(iterator obiseq.IBioSequenceBatch, file io.Writer, options } }() - return new_iter, nil + return newIter, nil } func WriteFastqBatchToStdout(iterator obiseq.IBioSequenceBatch, options ...WithOption) (obiseq.IBioSequenceBatch, error) { diff --git a/pkg/obiseq/batchiterator.go b/pkg/obiseq/batchiterator.go index 3461555..99bd524 100644 --- a/pkg/obiseq/batchiterator.go +++ b/pkg/obiseq/batchiterator.go @@ -103,8 +103,8 @@ func (iterator IBioSequenceBatch) Split() IBioSequenceBatch { buffer_size: iterator.pointer.buffer_size, finished: false, p_finished: iterator.pointer.p_finished} - new_iter := IBioSequenceBatch{&i} - return new_iter + newIter := IBioSequenceBatch{&i} + return newIter } func (iterator IBioSequenceBatch) Next() bool { @@ -144,13 +144,13 @@ func (iterator IBioSequenceBatch) IBioSequence(sizes ...int) IBioSequence { buffsize = sizes[0] } - new_iter := MakeIBioSequence(buffsize) + newIter := MakeIBioSequence(buffsize) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.pointer.channel) + newIter.Wait() + close(newIter.pointer.channel) }() go func() { @@ -158,13 +158,13 @@ func (iterator IBioSequenceBatch) IBioSequence(sizes ...int) IBioSequence { batch := iterator.Get() for _, s := range batch.slice { - new_iter.pointer.channel <- s + newIter.pointer.channel <- s } } - new_iter.Done() + newIter.Done() }() - return new_iter + return newIter } func (iterator IBioSequenceBatch) SortBatches(sizes ...int) IBioSequenceBatch { @@ -174,13 +174,13 @@ func (iterator IBioSequenceBatch) SortBatches(sizes ...int) IBioSequenceBatch { buffsize = sizes[0] } - new_iter := MakeIBioSequenceBatch(buffsize) + newIter := MakeIBioSequenceBatch(buffsize) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.pointer.channel) + newIter.Wait() + close(newIter.pointer.channel) }() next_to_send := 0 @@ -189,11 +189,11 @@ func (iterator IBioSequenceBatch) SortBatches(sizes ...int) IBioSequenceBatch { for iterator.Next() { batch := iterator.Get() if batch.order == next_to_send { - new_iter.pointer.channel <- batch + newIter.pointer.channel <- batch next_to_send++ batch, ok := received[next_to_send] for ok { - new_iter.pointer.channel <- batch + newIter.pointer.channel <- batch delete(received, next_to_send) next_to_send++ batch, ok = received[next_to_send] @@ -202,10 +202,10 @@ func (iterator IBioSequenceBatch) SortBatches(sizes ...int) IBioSequenceBatch { received[batch.order] = batch } } - new_iter.Done() + newIter.Done() }() - return new_iter + return newIter } @@ -216,13 +216,13 @@ func (iterator IBioSequenceBatch) Concat(iterators ...IBioSequenceBatch) IBioSeq } buffsize := iterator.BufferSize() - new_iter := MakeIBioSequenceBatch(buffsize) + newIter := MakeIBioSequenceBatch(buffsize) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.Channel()) + newIter.Wait() + close(newIter.Channel()) }() go func() { @@ -234,7 +234,7 @@ func (iterator IBioSequenceBatch) Concat(iterators ...IBioSequenceBatch) IBioSeq if s.order > max_order { max_order = s.order } - new_iter.Channel() <- MakeBioSequenceBatch(s.order+previous_max, s.slice...) + newIter.Channel() <- MakeBioSequenceBatch(s.order+previous_max, s.slice...) } previous_max = max_order + 1 @@ -245,14 +245,14 @@ func (iterator IBioSequenceBatch) Concat(iterators ...IBioSequenceBatch) IBioSeq max_order = s.order + previous_max } - new_iter.Channel() <- MakeBioSequenceBatch(s.order+previous_max, s.slice...) + newIter.Channel() <- MakeBioSequenceBatch(s.order+previous_max, s.slice...) } previous_max = max_order + 1 } - new_iter.Done() + newIter.Done() }() - return new_iter + return newIter } // Redistributes sequences from a IBioSequenceBatch into a new @@ -266,13 +266,13 @@ func (iterator IBioSequenceBatch) Rebatch(size int, sizes ...int) IBioSequenceBa buffsize = sizes[0] } - new_iter := MakeIBioSequenceBatch(buffsize) + newIter := MakeIBioSequenceBatch(buffsize) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.pointer.channel) + newIter.Wait() + close(newIter.pointer.channel) }() go func() { @@ -285,7 +285,7 @@ func (iterator IBioSequenceBatch) Rebatch(size int, sizes ...int) IBioSequenceBa for _, s := range seqs.slice { buffer = append(buffer, s) if len(buffer) == size { - new_iter.Channel() <- MakeBioSequenceBatch(order, buffer...) + newIter.Channel() <- MakeBioSequenceBatch(order, buffer...) order++ buffer = make(BioSequenceSlice, 0, size) } @@ -293,14 +293,14 @@ func (iterator IBioSequenceBatch) Rebatch(size int, sizes ...int) IBioSequenceBa } if len(buffer) > 0 { - new_iter.Channel() <- MakeBioSequenceBatch(order, buffer...) + newIter.Channel() <- MakeBioSequenceBatch(order, buffer...) } - new_iter.Done() + newIter.Done() }() - return new_iter + return newIter } func (iterator IBioSequenceBatch) Destroy() { @@ -331,13 +331,13 @@ func (iterator IBioSequenceBatch) PairWith(reverse IBioSequenceBatch, sizes ...i iterator = iterator.Rebatch(batchsize) reverse = reverse.Rebatch(batchsize) - new_iter := MakeIPairedBioSequenceBatch(buffsize) + newIter := MakeIPairedBioSequenceBatch(buffsize) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.pointer.channel) + newIter.Wait() + close(newIter.pointer.channel) log.Println("End of association of paired reads") }() @@ -347,12 +347,12 @@ func (iterator IBioSequenceBatch) PairWith(reverse IBioSequenceBatch, sizes ...i if !reverse.Next() { log.Panicln("Etrange reverse pas prêt") } - new_iter.Channel() <- MakePairedBioSequenceBatch(iterator.Get(), + newIter.Channel() <- MakePairedBioSequenceBatch(iterator.Get(), reverse.Get()) } - new_iter.Done() + newIter.Done() }() - return new_iter + return newIter } diff --git a/pkg/obiseq/iterator.go b/pkg/obiseq/iterator.go index 26cd9ef..a7ffb92 100644 --- a/pkg/obiseq/iterator.go +++ b/pkg/obiseq/iterator.go @@ -73,8 +73,8 @@ func (iterator IBioSequence) Split() IBioSequence { all_done: iterator.pointer.all_done, buffer_size: iterator.pointer.buffer_size, p_finished: iterator.pointer.p_finished} - new_iter := IBioSequence{&i} - return new_iter + newIter := IBioSequence{&i} + return newIter } func (iterator IBioSequence) Next() bool { @@ -132,16 +132,16 @@ func (iterator IBioSequence) IBioSequenceBatch(sizes ...int) IBioSequenceBatch { buffsize = sizes[1] } - new_iter := MakeIBioSequenceBatch(buffsize) + newIter := MakeIBioSequenceBatch(buffsize) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - for len(new_iter.Channel()) > 0 { + newIter.Wait() + for len(newIter.Channel()) > 0 { time.Sleep(time.Millisecond) } - close(new_iter.pointer.channel) + close(newIter.pointer.channel) }() go func() { @@ -153,12 +153,12 @@ func (iterator IBioSequence) IBioSequenceBatch(sizes ...int) IBioSequenceBatch { seq := iterator.Get() batch.slice = append(batch.slice, seq) } - new_iter.pointer.channel <- batch + newIter.pointer.channel <- batch } - new_iter.Done() + newIter.Done() }() - return new_iter + return newIter } func (iterator IBioSequence) IBioSequence(sizes ...int) IBioSequence { @@ -168,24 +168,24 @@ func (iterator IBioSequence) IBioSequence(sizes ...int) IBioSequence { buffsize = sizes[0] } - new_iter := MakeIBioSequence(buffsize) + newIter := MakeIBioSequence(buffsize) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.pointer.channel) + newIter.Wait() + close(newIter.pointer.channel) }() go func() { for iterator.Next() { s := iterator.Get() - new_iter.pointer.channel <- s + newIter.pointer.channel <- s } - new_iter.Done() + newIter.Done() }() - return new_iter + return newIter } func (iterator IBioSequence) Skip(n int, sizes ...int) IBioSequence { @@ -195,26 +195,26 @@ func (iterator IBioSequence) Skip(n int, sizes ...int) IBioSequence { buffsize = sizes[0] } - new_iter := MakeIBioSequence(buffsize) + newIter := MakeIBioSequence(buffsize) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.pointer.channel) + newIter.Wait() + close(newIter.pointer.channel) }() go func() { for i := 0; iterator.Next(); i++ { if i >= n { s := iterator.Get() - new_iter.pointer.channel <- s + newIter.pointer.channel <- s } } - new_iter.Done() + newIter.Done() }() - return new_iter + return newIter } func (iterator IBioSequence) Head(n int, sizes ...int) IBioSequence { @@ -224,13 +224,13 @@ func (iterator IBioSequence) Head(n int, sizes ...int) IBioSequence { buffsize = sizes[0] } - new_iter := MakeIBioSequence(buffsize) + newIter := MakeIBioSequence(buffsize) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.pointer.channel) + newIter.Wait() + close(newIter.pointer.channel) }() go func() { @@ -238,17 +238,17 @@ func (iterator IBioSequence) Head(n int, sizes ...int) IBioSequence { for i := 0; iterator.Next(); i++ { if i < n { s := iterator.Get() - new_iter.pointer.channel <- s + newIter.pointer.channel <- s } else { if not_done { - new_iter.Done() + newIter.Done() not_done = false } } } }() - return new_iter + return newIter } // The 'Tail' method discard every data from the source iterator @@ -260,14 +260,14 @@ func (iterator IBioSequence) Tail(n int, sizes ...int) IBioSequence { buffsize = sizes[0] } - new_iter := MakeIBioSequence(buffsize) + newIter := MakeIBioSequence(buffsize) buffseq := make(BioSequenceSlice, n) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.pointer.channel) + newIter.Wait() + close(newIter.pointer.channel) }() go func() { @@ -277,18 +277,18 @@ func (iterator IBioSequence) Tail(n int, sizes ...int) IBioSequence { } if i > n { for j := 0; j < n; j++ { - new_iter.Channel() <- buffseq[(i+j)%n] + newIter.Channel() <- buffseq[(i+j)%n] } } else { for j := 0; j < i; j++ { - new_iter.Channel() <- buffseq[j] + newIter.Channel() <- buffseq[j] } } - new_iter.Done() + newIter.Done() }() - return new_iter + return newIter } func (iterator IBioSequence) Concat(iterators ...IBioSequence) IBioSequence { @@ -298,29 +298,29 @@ func (iterator IBioSequence) Concat(iterators ...IBioSequence) IBioSequence { } buffsize := iterator.BufferSize() - new_iter := MakeIBioSequence(buffsize) + newIter := MakeIBioSequence(buffsize) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.pointer.channel) + newIter.Wait() + close(newIter.pointer.channel) }() go func() { for iterator.Next() { s := iterator.Get() - new_iter.pointer.channel <- s + newIter.pointer.channel <- s } for _, iter := range iterators { for iter.Next() { s := iter.Get() - new_iter.pointer.channel <- s + newIter.pointer.channel <- s } } - new_iter.Done() + newIter.Done() }() - return new_iter + return newIter } diff --git a/pkg/obiseq/pairedbatchiterator.go b/pkg/obiseq/pairedbatchiterator.go index c5293a6..a03205a 100644 --- a/pkg/obiseq/pairedbatchiterator.go +++ b/pkg/obiseq/pairedbatchiterator.go @@ -119,8 +119,8 @@ func (iterator IPairedBioSequenceBatch) Split() IPairedBioSequenceBatch { buffer_size: iterator.pointer.buffer_size, finished: false, p_finished: iterator.pointer.p_finished} - new_iter := IPairedBioSequenceBatch{&i} - return new_iter + newIter := IPairedBioSequenceBatch{&i} + return newIter } func (iterator IPairedBioSequenceBatch) Next() bool { @@ -160,13 +160,13 @@ func (iterator IPairedBioSequenceBatch) SortBatches(sizes ...int) IPairedBioSequ buffsize = sizes[0] } - new_iter := MakeIPairedBioSequenceBatch(buffsize) + newIter := MakeIPairedBioSequenceBatch(buffsize) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.pointer.channel) + newIter.Wait() + close(newIter.pointer.channel) }() next_to_send := 0 @@ -175,11 +175,11 @@ func (iterator IPairedBioSequenceBatch) SortBatches(sizes ...int) IPairedBioSequ for iterator.Next() { batch := iterator.Get() if batch.order == next_to_send { - new_iter.pointer.channel <- batch + newIter.pointer.channel <- batch next_to_send++ batch, ok := received[next_to_send] for ok { - new_iter.pointer.channel <- batch + newIter.pointer.channel <- batch delete(received, next_to_send) next_to_send++ batch, ok = received[next_to_send] @@ -188,9 +188,9 @@ func (iterator IPairedBioSequenceBatch) SortBatches(sizes ...int) IPairedBioSequ received[batch.order] = batch } } - new_iter.Done() + newIter.Done() }() - return new_iter + return newIter } diff --git a/pkg/obiseq/workers.go b/pkg/obiseq/workers.go index 6118b2b..3b17df5 100644 --- a/pkg/obiseq/workers.go +++ b/pkg/obiseq/workers.go @@ -25,25 +25,25 @@ func (iterator IBioSequence) MakeIWorker(worker SeqWorker, sizes ...int) IBioSeq buffsize = sizes[0] } - new_iter := MakeIBioSequence(buffsize) + newIter := MakeIBioSequence(buffsize) - new_iter.Add(1) + newIter.Add(1) go func() { - new_iter.Wait() - close(new_iter.pointer.channel) + newIter.Wait() + close(newIter.pointer.channel) }() go func() { for iterator.Next() { seq := iterator.Get() seq = worker(seq) - new_iter.pointer.channel <- seq + newIter.pointer.channel <- seq } - new_iter.Done() + newIter.Done() }() - return new_iter + return newIter } func (iterator IBioSequenceBatch) MakeIWorker(worker SeqWorker, sizes ...int) IBioSequenceBatch { @@ -58,16 +58,16 @@ func (iterator IBioSequenceBatch) MakeIWorker(worker SeqWorker, sizes ...int) IB buffsize = sizes[1] } - new_iter := MakeIBioSequenceBatch(buffsize) + newIter := MakeIBioSequenceBatch(buffsize) - new_iter.Add(nworkers) + newIter.Add(nworkers) go func() { - new_iter.Wait() - for len(new_iter.Channel()) > 0 { + newIter.Wait() + for len(newIter.Channel()) > 0 { time.Sleep(time.Millisecond) } - close(new_iter.pointer.channel) + close(newIter.pointer.channel) log.Println("End of the batch workers") }() @@ -78,9 +78,9 @@ func (iterator IBioSequenceBatch) MakeIWorker(worker SeqWorker, sizes ...int) IB for i, seq := range batch.slice { batch.slice[i] = worker(seq) } - new_iter.pointer.channel <- batch + newIter.pointer.channel <- batch } - new_iter.Done() + newIter.Done() } log.Println("Start of the batch workers") @@ -88,7 +88,7 @@ func (iterator IBioSequenceBatch) MakeIWorker(worker SeqWorker, sizes ...int) IB go f(iterator.Split()) } - return new_iter + return newIter } func (iterator IBioSequenceBatch) MakeISliceWorker(worker SeqSliceWorker, sizes ...int) IBioSequenceBatch { @@ -103,16 +103,16 @@ func (iterator IBioSequenceBatch) MakeISliceWorker(worker SeqSliceWorker, sizes buffsize = sizes[1] } - new_iter := MakeIBioSequenceBatch(buffsize) + newIter := MakeIBioSequenceBatch(buffsize) - new_iter.Add(nworkers) + newIter.Add(nworkers) go func() { - new_iter.Wait() - for len(new_iter.Channel()) > 0 { + newIter.Wait() + for len(newIter.Channel()) > 0 { time.Sleep(time.Millisecond) } - close(new_iter.pointer.channel) + close(newIter.pointer.channel) log.Println("End of the batch slice workers") }() @@ -120,9 +120,9 @@ func (iterator IBioSequenceBatch) MakeISliceWorker(worker SeqSliceWorker, sizes for iterator.Next() { batch := iterator.Get() batch.slice = worker(batch.slice) - new_iter.pointer.channel <- batch + newIter.pointer.channel <- batch } - new_iter.Done() + newIter.Done() } log.Println("Start of the batch slice workers") @@ -130,5 +130,5 @@ func (iterator IBioSequenceBatch) MakeISliceWorker(worker SeqSliceWorker, sizes go f(iterator.Split()) } - return new_iter + return newIter } diff --git a/pkg/obitax/filter_on_name.go b/pkg/obitax/filter_on_name.go index 7dc093e..d8f689b 100644 --- a/pkg/obitax/filter_on_name.go +++ b/pkg/obitax/filter_on_name.go @@ -19,7 +19,7 @@ func (taxonomy *Taxonomy) IFilterOnName(name string, strict bool) *ITaxonSet { } func (iterator *ITaxonSet) IFilterOnName(name string, strict bool) *ITaxonSet { - new_iterator := NewITaxonSet() + newIterator := NewITaxonSet() sentTaxa := make(map[int]bool) if strict { @@ -29,11 +29,11 @@ func (iterator *ITaxonSet) IFilterOnName(name string, strict bool) *ITaxonSet { if _, ok := sentTaxa[taxon.taxid]; !ok { if taxon.IsNameEqual(name) { sentTaxa[taxon.taxid] = true - new_iterator.source <- taxon + newIterator.source <- taxon } } } - close(new_iterator.source) + close(newIterator.source) }() } else { pattern := regexp.MustCompile(name) @@ -44,13 +44,13 @@ func (iterator *ITaxonSet) IFilterOnName(name string, strict bool) *ITaxonSet { if _, ok := sentTaxa[taxon.taxid]; !ok { if taxon.IsNameMatching(pattern) { sentTaxa[taxon.taxid] = true - new_iterator.source <- taxon + newIterator.source <- taxon } } } - close(new_iterator.source) + close(newIterator.source) }() } - return new_iterator + return newIterator } diff --git a/pkg/obitax/filter_on_rank.go b/pkg/obitax/filter_on_rank.go index 25b573d..8a1809f 100644 --- a/pkg/obitax/filter_on_rank.go +++ b/pkg/obitax/filter_on_rank.go @@ -1,19 +1,19 @@ package obitax func (iterator *ITaxonSet) IFilterOnTaxRank(rank string) *ITaxonSet { - new_iter := NewITaxonSet() + newIter := NewITaxonSet() go func() { for iterator.Next() { taxon := iterator.Get() if taxon.rank == rank { - new_iter.source <- taxon + newIter.source <- taxon } } - close(new_iter.source) + close(newIter.source) }() - return new_iter + return newIter } func (set *TaxonSet) IFilterOnTaxRank(rank string) *ITaxonSet { diff --git a/pkg/obitax/filter_on_subclade_of.go b/pkg/obitax/filter_on_subclade_of.go index c960e9c..85268a1 100644 --- a/pkg/obitax/filter_on_subclade_of.go +++ b/pkg/obitax/filter_on_subclade_of.go @@ -3,19 +3,19 @@ package obitax import "reflect" func (iterator *ITaxonSet) IFilterOnSubcladeOf(taxon *TaxNode) *ITaxonSet { - new_iter := NewITaxonSet() + newIter := NewITaxonSet() go func() { for iterator.Next() { tx := iterator.Get() if tx.IsSubCladeOf(taxon) { - new_iter.source <- tx + newIter.source <- tx } } - close(new_iter.source) + close(newIter.source) }() - return new_iter + return newIter } func (set *TaxonSet) IFilterOnSubcladeOf(taxon *TaxNode) *ITaxonSet { @@ -43,17 +43,17 @@ func (iterator *ITaxonSet) IFilterBelongingSubclades(clades *TaxonSet) *ITaxonSe return iterator.IFilterOnSubcladeOf((*clades)[int(keys[0].Int())]) } - new_iter := NewITaxonSet() + newIter := NewITaxonSet() go func() { for iterator.Next() { tx := iterator.Get() if tx.IsBelongingSubclades(clades) { - new_iter.source <- tx + newIter.source <- tx } } - close(new_iter.source) + close(newIter.source) }() - return new_iter + return newIter } diff --git a/pkg/obitax/iterator.go b/pkg/obitax/iterator.go index e610bcb..b1f4fbf 100644 --- a/pkg/obitax/iterator.go +++ b/pkg/obitax/iterator.go @@ -74,8 +74,8 @@ func (iterator *ITaxonSet) Finished() bool { } func (iterator *ITaxonSet) Split() *ITaxonSet { - new_iter := ITaxonSet{iterator.source, nil, false, iterator.p_finished} - return &new_iter + newIter := ITaxonSet{iterator.source, nil, false, iterator.p_finished} + return &newIter } func (iterator *ITaxonSet) TaxonSet() *TaxonSet { diff --git a/pkg/obitools/obipairing/options.go b/pkg/obitools/obipairing/options.go index 687e3ab..74229e5 100644 --- a/pkg/obitools/obipairing/options.go +++ b/pkg/obitools/obipairing/options.go @@ -6,32 +6,32 @@ import ( "github.com/DavidGamba/go-getoptions" ) -var __forward_files__ = make([]string, 0, 10) -var __reverse_files__ = make([]string, 0, 10) -var __delta__ = 5 -var __min_overlap__ = 20 -var __gap_penality__ = 2 -var __without_stats__ = false +var _ForwardFiles = make([]string, 0, 10) +var _ReverseFiles = make([]string, 0, 10) +var _Delta = 5 +var _MinOverlap = 20 +var _GapPenality = 2 +var _WithoutStats = false func PairingOptionSet(options *getoptions.GetOpt) { - options.StringSliceVar(&__forward_files__, "forward-reads", + options.StringSliceVar(&_ForwardFiles, "forward-reads", 1, 1000, options.Alias("F"), options.Description("The file names containing the forward reads")) - options.StringSliceVar(&__reverse_files__, "reverse-reads", + options.StringSliceVar(&_ReverseFiles, "reverse-reads", 1, 1000, options.Alias("R"), options.Description("The file names containing the reverse reads")) - options.IntVar(&__delta__, "delta", 5, + options.IntVar(&_Delta, "delta", 5, options.Alias("D"), options.Description("Length added to the fast detected overlap for the precise alignement (default 5).")) - options.IntVar(&__min_overlap__, "min-overlap", 20, + options.IntVar(&_MinOverlap, "min-overlap", 20, options.Alias("O"), options.Description("Minimum ovelap between both the reads to consider the aligment (default 20).")) - options.IntVar(&__gap_penality__, "gap-penality", 2, + options.IntVar(&_GapPenality, "gap-penality", 2, options.Alias("G"), options.Description("Gap penality expressed as the multiply factor applied to the mismatch score between two nucleotides with a quality of 40 (default 2).")) - options.BoolVar(&__without_stats__, "without-stat", false, + options.BoolVar(&_WithoutStats, "without-stat", false, options.Alias("S"), options.Description("Remove alignment statistics from the produced consensus sequences.")) } @@ -42,12 +42,12 @@ func OptionSet(options *getoptions.GetOpt) { } func IBatchPairedSequence() (obiseq.IPairedBioSequenceBatch, error) { - forward, err := obiconvert.ReadBioSequencesBatch(__forward_files__...) + forward, err := obiconvert.ReadBioSequencesBatch(_ForwardFiles...) if err != nil { return obiseq.NilIPairedBioSequenceBatch, err } - reverse, err := obiconvert.ReadBioSequencesBatch(__reverse_files__...) + reverse, err := obiconvert.ReadBioSequencesBatch(_ReverseFiles...) if err != nil { return obiseq.NilIPairedBioSequenceBatch, err } @@ -58,17 +58,17 @@ func IBatchPairedSequence() (obiseq.IPairedBioSequenceBatch, error) { } func Delta() int { - return __delta__ + return _Delta } func MinOverlap() int { - return __min_overlap__ + return _MinOverlap } func GapPenality() int { - return __gap_penality__ + return _GapPenality } func WithStats() bool { - return !__without_stats__ + return !_WithoutStats } diff --git a/pkg/obitools/obipairing/pairing.go b/pkg/obitools/obipairing/pairing.go index 4dc73f3..0cca250 100644 --- a/pkg/obitools/obipairing/pairing.go +++ b/pkg/obitools/obipairing/pairing.go @@ -112,16 +112,16 @@ func IAssemblePESequencesBatch(iterator obiseq.IPairedBioSequenceBatch, buffsize = sizes[1] } - new_iter := obiseq.MakeIBioSequenceBatch(buffsize) + newIter := obiseq.MakeIBioSequenceBatch(buffsize) - new_iter.Add(nworkers) + newIter.Add(nworkers) go func() { - new_iter.Wait() - for len(new_iter.Channel()) > 0 { + newIter.Wait() + for len(newIter.Channel()) > 0 { time.Sleep(time.Millisecond) } - close(new_iter.Channel()) + close(newIter.Channel()) log.Printf("End of the sequence Pairing") }() @@ -157,14 +157,14 @@ func IAssemblePESequencesBatch(iterator obiseq.IPairedBioSequenceBatch, B.Destroy() } bar.Add(batch.Length() - processed) - new_iter.Channel() <- obiseq.MakeBioSequenceBatch( + newIter.Channel() <- obiseq.MakeBioSequenceBatch( batch.Order(), cons..., ) // log.Printf("\n==> %d Wait data to align\n", wid) // start = time.Now() } - new_iter.Done() + newIter.Done() } log.Printf("Start of the sequence Pairing") @@ -173,6 +173,6 @@ func IAssemblePESequencesBatch(iterator obiseq.IPairedBioSequenceBatch, go f(iterator.Split(), i) } - return new_iter + return newIter } diff --git a/pkg/obitools/obipcr/options.go b/pkg/obitools/obipcr/options.go index fe41711..367def0 100644 --- a/pkg/obitools/obipcr/options.go +++ b/pkg/obitools/obipcr/options.go @@ -8,34 +8,34 @@ import ( "github.com/DavidGamba/go-getoptions" ) -var __circular__ = false -var __forward_primer__ string -var __reverse_primer__ string -var __allowed_mismatch__ = 0 -var __minimum_length__ = 0 -var __maximum_length__ = -1 +var _Circular = false +var _ForwardPrimer string +var _ReversePrimer string +var _AllowedMismatch = 0 +var _MinimumLength = 0 +var _MaximumLength = -1 func PCROptionSet(options *getoptions.GetOpt) { - options.BoolVar(&__circular__, "circular", false, + options.BoolVar(&_Circular, "circular", false, options.Alias("c"), options.Description("Considers that sequences are [c]ircular.")) - options.StringVar(&__forward_primer__, "forward", "", + options.StringVar(&_ForwardPrimer, "forward", "", options.Required("You must provide a forward primer"), options.Description("The forward primer used for the electronic PCR.")) - options.StringVar(&__reverse_primer__, "reverse", "", + options.StringVar(&_ReversePrimer, "reverse", "", options.Required("You must provide a reverse primer"), options.Description("The reverse primer used for the electronic PCR.")) - options.IntVar(&__allowed_mismatch__, "allowed-mismatches", 0, + options.IntVar(&_AllowedMismatch, "allowed-mismatches", 0, options.Alias("e"), options.Description("Maximum number of mismatches allowed for each primer.")) - options.IntVar(&__minimum_length__, "min-length", 0, + options.IntVar(&_MinimumLength, "min-length", 0, options.Alias("l"), options.Description("Minimum length of the barcode (primers excluded).")) - options.IntVar(&__maximum_length__, "max-length", -1, + options.IntVar(&_MaximumLength, "max-length", -1, options.Alias("L"), options.Description("Maximum length of the barcode (primers excluded).")) } @@ -46,7 +46,7 @@ func OptionSet(options *getoptions.GetOpt) { } func ForwardPrimer() string { - pattern, err := obiapat.MakeApatPattern(__forward_primer__, __allowed_mismatch__) + pattern, err := obiapat.MakeApatPattern(_ForwardPrimer, _AllowedMismatch) if err != nil { log.Fatalf("%+v", err) @@ -54,11 +54,11 @@ func ForwardPrimer() string { pattern.Free() - return __forward_primer__ + return _ForwardPrimer } func ReversePrimer() string { - pattern, err := obiapat.MakeApatPattern(__reverse_primer__, __allowed_mismatch__) + pattern, err := obiapat.MakeApatPattern(_ReversePrimer, _AllowedMismatch) if err != nil { log.Fatalf("%+v", err) @@ -66,21 +66,21 @@ func ReversePrimer() string { pattern.Free() - return __reverse_primer__ + return _ReversePrimer } func AllowedMismatch() int { - return __allowed_mismatch__ + return _AllowedMismatch } func Circular() bool { - return __circular__ + return _Circular } func MinLength() int { - return __minimum_length__ + return _MinimumLength } func MaxLength() int { - return __maximum_length__ + return _MaximumLength }