scbi_fqbin 0.2.2 → 0.2.3

data/test/old/c/libreria_gz.h

@@ -0,0 +1,127 @@
+#include <zlib.h>
+
+#define VERSION 1
+#define SUBVERSION 0
+
+struct file_data {
+	char name[10000];
+	char index_name[10000];
+	gzFile gzf_bin;
+	// int file_bin;
+	gzFile gzf_index;
+	// int file_index;
+	// char file_outname[10000];
+	long long pos_chunk_gz;
+	// Contains the version and subversion of this file
+	int version;
+	int subversion;
+	// bin_search is true when a binary search can be used.
+	int bin_search;
+	// Counts the number of sequences written to the bin file, so it can
+	// decide where to create a new gz chunk
+	long long counter;
+	// If there is an error it is stored here so it can be retrieved.
+	int error;
+};
+
+// two modes:
+// 1 .- new files
+// 2 .- add data to files, if they don't exist they are created
+int initialize_writes(struct file_data ** file, char *output_name, int mode);
+
+/* write_seq writes a sequence to the files f_bin and its index to f_index 
+   pos_chunk_gz is the offset of the beggining of the current gz chunk inside the file 
+   seq_name is a pointer to the name of the sequence
+   fasta, quanta and extras are pointers to strings, must be zero terminated.
+   Returns 0 if all goes fine.
+ */
+
+void inspect_file_data_struct(struct file_data *file);
+
+// int write_seq(gzFile *f_bin, FILE *f_index, long pos_chunk_gz, char *seq_name, char *fasta, char *quanta, char *extras);
+int write_seq(struct file_data *file, char *seq_name, char *fasta, char *qual, char *extras);
+
+int close_writes(struct file_data *file);
+
+/*
+   read_seq reads from filename the sequence named seq_name and returns its
+   fasta, quanta and extras in those variables.
+   It returns 0 if there are no errors, otherwise it returns:
+   -2 : error opening index file (it doesn't exists)
+   -3 : error reading index file
+   -4 : error sequence not found in index file
+   -5 : error opening file (it doesn't exists)
+   -6 : error reading file
+   -7 : error sequence not found
+   -8 : error uncompressing sequence
+   -9 : EOF
+ */
+int read_seq(char *filename, char *seq_name, char **fasta, char **quanta, char **extras);
+
+// For doing sequential reads of the whole file:
+// int initialize_sequential_reads(struct file_data *filed, char *filename);
+int initialize_sequential_reads(struct file_data ** filed, char *filename);
+
+// return -9 on EOF
+int read_data_sequential(struct file_data *filed, char **seq_name, char **fasta, char **qual, char **extras);
+int close_sequential_reads(struct file_data *filed);
+
+
+/* process_biofile reads from fname (and fname.quanta) and writes to outname
+   (and outname.index) with the binary format 
+   Returns 0 if all goes fine */
+int process_biofile(char *fname,char *qfname, char *efname, char *outname);
+
+/*
+Format definition
+
+Main file that contains chunks compressed in gz
+For each sequence the information of that sequence is written with the format:
+  28F143CJN01EBIJN 105 312 0
+
+That is:
+4 chars for the size of this header, excluding itself, that is, it is the size of
+	the rest of the header
+sequence name
+fasta size
+qual size
+extras size
+
+The First sequence can be a special sequence with metainfo for this file:
+  30UMACOMPRESSEDFORMAT_version 0 0 0 
+  27UMACOMPRESSEDFORMAT_1 0 0 0
+
+
+
+Index file
+
+Compressed using chunks
+
+At the beggining a special sequence can be used to store metadata
+like the number of fields, if a binary search can be used, etc.
+
+That sequence will be:
+UMACOMPRESSEDFORMAT version binary_search begin_of_sequential_index  0 0
+
+If binary_search is yes then a metaindex follows to do a fast access to the
+index data.
+That will be the first sequence of each chunk and its offset inside the file.
+(Or perphaps it can be put in another file....)
+
+
+The rest of the index file will be indexes to the stored sequences, with
+the following fields separated by spaces:
+
+F143CJN01ETK00 0 471 
+
+Sequence name
+begin of the compressed chunk
+offset inside the chunk of the header of that sequence.
+
+*/
+
+
+
+
+
+

data/test/old/c/main.c

@@ -0,0 +1,86 @@
+#include "libreria_gz.h"
+#include <stdio.h>
+#include <ctype.h>
+
+
+/*******************************************************/
+/* main                                                */
+/*******************************************************/
+int main(int argc, char *argv[])
+{
+
+char *fasta=NULL;
+char *qual=NULL;
+char *extras=NULL;
+int size=5000;
+            
+if (argc!=4)
+{
+  printf("Usage %s fasta_file qual_file output_file\n\n",argv[0]);
+  exit(-1);
+}
+ 
+
+
+// prueba de lectura
+printf ("Comienzo\n");
+
+//int res=read_seq("data/F143CJN01.fbin","F143CJN01D96I9", &fasta, &qual, &extras);
+//int res=read_seq("fasta_filt_w_dict.fbin","F143CJN01D96I9", &fasta, &qual, &extras);
+
+// prueba de escritura
+/*int res=write_seq("borrar","S143CJN01D96I9", "primero","QUANTAQUANTAQUANTAQUANTAQUANTA","");
+    res=write_seq("borrar","3CJN01D96I9", "el de enmedio","QUANTAQUANTAQUANTAQUANTAQUANTA","");
+    res=write_seq("borrar","3CJsdasdaN01D96I9", "ultimo","QUANTAQUANTAQUANTAQUANTAQUANTA","");
+*/
+//init_dicts(dict_fasta,dict_qual,32767);
+//int res=process_biofile("data/F143CJN01.fasta","/tmp/prueba2gz.fbin");
+int res=process_biofile(argv[1],argv[3]);
+
+//res=read_seq("fasta_filt_w_dict.fbin","F143CJN01D96I9", &fasta, &qual, &extras);
+/*
+int res=read_seq("prueba2.fbin","F143CJN01DI5MZ", &fasta, &qual, &extras);
+printf ("-------------------------------------------------------------\n");
+printf ("RES of read_seq1 call is :%d\n",res);
+if ( res==0 ) printf ("fasta:%s\n size:%d\n",fasta,sizeof(fasta));
+if ( res==0 ) printf ("qual:%s\n",qual);
+if (( res==0 )&& (extras!=NULL)) printf ("extras:%s\n",extras);
+if ( fasta!=NULL ) {free(fasta);fasta=NULL;}
+if ( qual!=NULL ) {free(qual);qual=NULL;}
+if ( extras!=NULL ) {free(extras);extras=NULL;}
+*/
+//int res=read_seq("/tmp/prueba2gz.fbin","F143CJN01BO14N", &fasta, &qual, &extras);
+//int res=read_seq("/tmp/prueba2gz.fbin","F143CJN01D2X26", &fasta, &qual, &extras);
+//res=read_seq("prueba2gz.fbin","F143CJN01EBIJN", &fasta, &qual, &extras);
+res=read_seq(argv[3],"F143CJN01DZW7L", &fasta, &qual, &extras);
+//res=read_seq("prueba2gz.fbin","F143CJN01EN6AH", &fasta, &qual, &extras);
+printf ("-------------------------------------------------------------\n");
+printf ("RES of read_seq2 call is :%d\n",res);
+if ( res==0 ) printf ("fasta:%s\n fasta size:%d\n",fasta,strlen(fasta));
+if ( res==0 ) printf ("qual:%s\n",qual);
+if (( res==0 )&& (extras!=NULL)) printf ("extras:%s\n",extras);
+if ( fasta!=NULL ) {free(fasta);fasta=NULL;}
+if ( qual!=NULL ) {free(qual);qual=NULL;}
+if ( extras!=NULL ) {free(extras);extras=NULL;}
+
+printf ("***************************\n");
+printf ("Sequential reads\n");
+
+initialize_sequential_reads(argv[3]);
+char *sname=NULL;
+while (read_data_sequential(&sname, &fasta, &qual, &extras)==0)
+{
+	printf ("***************************\n");
+	printf ("RES of read_seq2 call is :%d, sname:%s\n",res,sname);
+	if ( res==0 ) printf ("fasta:%s fasta size:%d\n",fasta,strlen(fasta));
+	if ( res==0 ) printf ("qual:%s",qual);
+	if (( res==0 )&& (extras!=NULL)) printf ("extras:%s\n",extras);
+	if ( fasta!=NULL ) {free(fasta);fasta=NULL;}
+	if ( qual!=NULL ) {free(qual);qual=NULL;}
+	if ( extras!=NULL ) {free(extras);extras=NULL;}
+}
+close_sequential_reads();
+
+return res;
+}
+

data/test/old/c/mk_fbin.c

@@ -0,0 +1,24 @@
+#include "libreria_gz.h"
+#include <stdio.h>
+#include <ctype.h>
+
+
+/*******************************************************/
+/* main                                                */
+/*******************************************************/
+int main(int argc, char *argv[])
+{
+  // check params
+  if (argc!=5)
+  {
+    printf("Usage %s fasta_file qual_file extras_file output_file\n\n",argv[0]);
+    return -1;
+  }
+ 
+  // process file
+//  int res=process_biofile(argv[1],argv[2],argv[3],argv[4]);
+  int res=process_biofile(argv[1],argv[2],argv[3] ,argv[4]);
+
+  return res;
+}
+

data/test/old/c/rd_seq_fbin.c

@@ -0,0 +1,44 @@
+#include "libreria_gz.h"
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+
+
+/*******************************************************/
+/* main                                                */
+/*******************************************************/
+int main(int argc, char *argv[])
+{
+
+char *fasta=NULL;
+char *qual=NULL;
+char *extras=NULL;
+int size=5000;
+int res=0;
+
+if (argc!=3)
+{
+  printf("Usage %s fbin_file seq_name\n\n",argv[0]);
+  return -1;
+}
+ 
+
+
+res=read_seq(argv[1],argv[2], &fasta, &qual, &extras);
+
+if (res==0){
+	
+	printf(">%s\n%s\n", argv[2], fasta);
+	printf("%s\n",qual);
+	if (extras!=NULL) printf ("extras:%s\n",extras);
+}
+
+//res=read_seq("prueba2gz.fbin","F143CJN01EN6AH", &fasta, &qual, &extras);
+if ( fasta!=NULL ) {free(fasta);fasta=NULL;}
+if ( qual!=NULL ) {free(qual);qual=NULL;}
+if ( extras!=NULL ) {free(extras);extras=NULL;}
+
+return res;
+}
+

data/test/old/c/test_ffi/app.c

@@ -0,0 +1,26 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "mylibrary.h"
+
+int main()
+{
+  double c, d ;
+  int errcode ;
+  struct SomeObject *objptr ;
+
+  c = calculate_something(42, 98.6);
+
+  if ((errcode = error_code()) != 0) {
+    fprintf(stderr, "error calculating something: %d\n", errcode);
+    exit(1);
+  }
+
+  objptr = create_object("my object") ;
+  d = calculate_something_else(c, objptr) ;
+  free_object(objptr) ;  
+
+  fprintf(stdout, "calculated %f\n", d);
+  exit(0) ;
+}

data/test/old/c/test_ffi/app.rb

@@ -0,0 +1,19 @@
+require 'my_library'
+
+o = MyLibrary.new
+
+r=o.calculate_something(42,98.6)
+puts r
+
+# c = MyLibrary.calculate_something(42, 98.6) # note FFI handles literals just fine
+# 
+# if ( (errcode = MyLibrary.error_code()) != 0)
+#   puts "error calculating something: #{errcode}"
+#   exit 1
+# end
+# 
+# objptr = MyLibrary.create_object("my object") # note FFI handles string literals as well
+# d = MyLibrary.calculate_something_else(c, objptr)
+# MyLibrary.free_object(objptr)
+# 
+# puts "calculated #{d}"

data/test/old/c/test_ffi/my_library.rb

@@ -0,0 +1,23 @@
+require 'ffi'
+
+module MyModule
+  extend FFI::Library
+  ffi_lib "mylibrary"
+  
+  attach_function :calculate_something, [:int, :float], :double
+  attach_function :error_code, [], :int # note empty array for functions taking zero arguments
+  attach_function :create_object, [:string], :pointer
+  attach_function :calculate_something_else, [:double, :pointer], :double
+  attach_function :free_object, [:pointer], :void
+  
+end
+
+class MyLibrary
+  
+  include MyModule
+  
+  def initialize
+    puts calculate_something(1,2.3)
+  end
+
+end

data/test/old/c/test_ffi/mylibrary.c

@@ -0,0 +1,22 @@
+#include "mylibrary.h"
+
+double               calculate_something(int a, float b){
+	return a+b;
+} 
+
+int                  error_code(void){
+	return 0;
+}
+
+struct SomeObject*   create_object(char* name){
+	// SomeObject e;
+	return 0;
+}
+
+double               calculate_something_else(double c, struct SomeObject* obj){
+	return 1.1;
+}
+
+void                 free_object(void* pointer_to_memory){
+	
+}

data/test/old/c/test_ffi/mylibrary.h

@@ -0,0 +1,6 @@
+/* mylibrary.h */
+double               calculate_something(int a, float b);
+int                  error_code(void);
+struct SomeObject*   create_object(char* name);
+double               calculate_something_else(double c, struct SomeObject* obj);
+void                 free_object(void* pointer_to_memory);

data/test/old/c/usage_instructions.txt

@@ -0,0 +1,62 @@
+
+Manual of the YAGFF (Yet Another Genetic File Format)
+OGF (Optimized Genetic Format)
+
+
+First a call to :
+        error=initialize_writes(outname,1);
+
+Is needed to initialize the files.
+
+Its arguments are:
+
+- the name of the main output file and to this the suffix .index will be
+  appended for the index file.
+
+- The mode of the write:
+	1 : create a new file
+	2 : append data to already existing files
+
+It returns 
+	 0 if everything goes fine, 
+	-1 if there is a problem with already existing files, like an incorrect
+		version number 
+	-2 if there is a problem creating or opening files
+
+In case of error it writes it on stderr
+
+
+Then request to write can be done:
+
+int error_wr=write_seq(sname, fasta,qual,extras);
+
+Where sname is a char* with the name of the sequence, and fasta, qual and
+extras are char* with the fasta, qual and extras data.
+
+At the end a call to : closes_writes();
+is needed to close the opened files
+
+
+
+The reads are even easier:
+
+int read_seq(char *filename, char *seq_name, char **fasta, char **qual, char **extras)
+The arguments are:
+filename: is a char* used as input the name of the main file, .index is appended for the index file
+seq_name :  char* that contains the name of the searched sequence
+
+And the result are returned in :
+fasta, qual and extras, if they point to NULL they are malloced to bufsize=150000 bytes (defined inside the function)
+else they are used without checking its size
+
+
+
+For doing sequential reads an untested procedure is implemented:
+
+int initialize_sequential_reads(char *filename);
+
+// return -9 on EOF
+int read_data_sequential(char **seq_name, char **fasta, char **qual, char **extras)
+int close_sequential_reads();
+
+