Ejemplos de ion_write_padding en C++ (Cpp)

Ejemplo n.º 1

Archivo: sff_read.c Proyecto: alecw/TS

uint32_t
sff_read_write(FILE *fp, sff_header_t *gh, sff_read_header_t *rh, sff_read_t *r)
{
  uint32_t i, n = 0;
  
  // convert flowgram to network order
  for(i=0;i<gh->flow_length;i++) {
      r->flowgram[i] = htons(r->flowgram[i]);
  }
  
  if(gh->flow_length != fwrite(r->flowgram, sizeof(uint16_t), gh->flow_length, fp)
     || rh->n_bases != fwrite(r->flow_index, sizeof(uint8_t), rh->n_bases, fp)
     || rh->n_bases != fwrite(r->bases->s, sizeof(char), rh->n_bases, fp)
     || rh->n_bases != fwrite(r->quality->s, sizeof(char), rh->n_bases, fp)) {
      ion_error(__func__, "fread", Exit, ReadFileError);
  }
  n += sizeof(uint16_t)*gh->flow_length + 3*sizeof(uint8_t)*rh->n_bases;
  
  // convert flowgram to host order
  for(i=0;i<gh->flow_length;i++) {
      r->flowgram[i] = ntohs(r->flowgram[i]);
  }

  n += ion_write_padding(fp, n);

  return n;
}

Ejemplo n.º 2

Archivo: sff_index.c Proyecto: Brainiarc7/TS

uint32_t
sff_index_length(sff_index_t *idx)
{
  uint32_t n = 0;
  uint64_t len = 0;

  // index header
  n += sizeof(uint32_t)*2 + sizeof(int32_t)*3;

  // offsets
  if(SFF_INDEX_ROW_ONLY == idx->type) {
      len = 1 + idx->num_rows;
  }
  else if(SFF_INDEX_ALL == idx->type) {
      len = 1 + (idx->num_rows * idx->num_cols);
  }
  else {
      ion_error(__func__, "could not understand index type", Exit, OutOfRange);
  }
  n += sizeof(uint64_t) * len;

  // padding
  n += ion_write_padding(NULL, n);

  return n;
}

Ejemplo n.º 3

Archivo: sff_read_header.c Proyecto: alecw/TS

uint32_t
sff_read_header_write(FILE *fp, sff_read_header_t *rh)
{
  uint32_t n = 0;

  sff_read_header_calc_bytes(rh);

  // convert values to big-endian
  sff_read_header_hton(rh);

  if(1 != fwrite(&rh->rheader_length, sizeof(uint16_t), 1, fp)
     || 1 != fwrite(&rh->name_length, sizeof(uint16_t), 1, fp)
     || 1 != fwrite(&rh->n_bases, sizeof(uint32_t), 1, fp)
     || 1 != fwrite(&rh->clip_qual_left, sizeof(uint16_t), 1, fp)
     || 1 != fwrite(&rh->clip_qual_right, sizeof(uint16_t), 1, fp)
     || 1 != fwrite(&rh->clip_adapter_left, sizeof(uint16_t), 1, fp)
     || 1 != fwrite(&rh->clip_adapter_right, sizeof(uint16_t), 1, fp)) {
      ion_error(__func__, "fwrite", Exit, WriteFileError);
  }
  n += sizeof(uint32_t) + 6*sizeof(uint16_t);
 
  // convert values from big-endian
  sff_read_header_ntoh(rh);

  if(rh->name_length != fwrite(rh->name->s, sizeof(char), rh->name_length, fp)) {
      ion_error(__func__, "fwrite", Exit, ReadFileError);
  }
  n += sizeof(char)*rh->name_length;

  n += ion_write_padding(fp, n);

  return n;
}

Ejemplo n.º 4

Archivo: sff_index.c Proyecto: Brainiarc7/TS

uint32_t
sff_index_write(FILE *fp, sff_index_t *idx)
{
  int32_t i;
  uint32_t n = 0;
  uint64_t len = 0;

  if(NULL == idx) {
      return 0;
  }

  // convert values to big-endian
  sff_index_hton(idx);

  // index header
  if(1 != fwrite(&idx->index_magic_number, sizeof(uint32_t), 1, fp)
     || 1 != fwrite(&idx->index_version, sizeof(uint32_t), 1, fp)
     || 1 != fwrite(&idx->num_rows, sizeof(int32_t), 1, fp)
     || 1 != fwrite(&idx->num_cols, sizeof(int32_t), 1, fp)
     || 1 != fwrite(&idx->type, sizeof(int32_t), 1, fp)) {
      ion_error(__func__, "fwrite", Exit, WriteFileError);
  }
  n += sizeof(uint32_t)*2 + sizeof(int32_t)*3;

  // convert values from big-endian
  sff_index_ntoh(idx);

  // offsets
  if(SFF_INDEX_ROW_ONLY == idx->type) {
      len = 1 + idx->num_rows;
  }
  else if(SFF_INDEX_ALL == idx->type) {
      len = 1 + (idx->num_rows * idx->num_cols);
  }
  else {
      ion_error(__func__, "could not understand index type", Exit, OutOfRange);
  }

  // convert values to big-endian
  for(i=0;i<len;i++) {
      idx->offset[i] = htonll(idx->offset[i]);
  }
  // write
  if(len != fwrite(idx->offset, sizeof(uint64_t), len, fp)) {
      ion_error(__func__, "fwrite", Exit, WriteFileError);
  }
  n += sizeof(uint64_t) * len;
  // convert values from big-endian
  for(i=0;i<len;i++) {
      idx->offset[i] = ntohll(idx->offset[i]);
  }

  // padding
  n += ion_write_padding(fp, n);

  return n;
}