コード例 #1
0
ファイル: writeenc.c プロジェクト: luigiScarso/mflua
void write_enc(char **glyph_names, struct avl_table *tx_tree, integer fe_objnum)
{
    int i_old, *p;
    struct avl_traverser t;
    assert(glyph_names != NULL);
    assert(tx_tree != NULL);
    assert(fe_objnum != 0);
    pdf_begin_dict(fe_objnum, 1);
    pdf_puts("/Type /Encoding\n");
    pdf_printf("/Differences [");
    avl_t_init(&t, tx_tree);
    for (i_old = -2, p = (int *) avl_t_first(&t, tx_tree); p != NULL;
         p = (int *) avl_t_next(&t)) {
        if (*p == i_old + 1)    /* no gap */
            pdf_printf("/%s", glyph_names[*p]);
        else {
            if (i_old == -2)
                pdf_printf("%i/%s", *p, glyph_names[*p]);
            else
                pdf_printf(" %i/%s", *p, glyph_names[*p]);
        }
        i_old = *p;
    }
    pdf_puts("]\n");
    pdf_end_dict();
}
コード例 #2
0
/*
 * Dado um código de cliente e um mês, determinar a lista de códigos de
 * produtos que mais comprou por quantidade e não por facturação), por ordem
 * descendente.
 */
Apresentacao top_mes_descendente(Gestao g, char* cod, int mes){
	int i;
	Apresentacao a   = NULL;
	Cliente  cl      = NULL;
	Cliente  procura = NULL;
	Travessia t = (Travessia) malloc(sizeof(struct avl_traverser));
	
	procura      = (Cliente) malloc(sizeof(struct cliente));
	procura->cli = (char*)   malloc((sizeof(char))*(strlen(cod)+1));
	strcpy(procura->cli, cod);

	cl = (Cliente) avl_find((g->clientes)[*cod-'A'], procura);	
	free(procura->cli);
	free(procura);

	if (!cl) return NULL; /*Cliente não comprou*/

	a = init_apresentacao(cl->produtos_diferentes_comprados_mes[mes-1],2);

	for(i=0;i<26;i++){
		avl_t_init (t, cl->produtos[i]);
		a = preenche_apresentacao_descendente (t, a, mes,cl->produtos_diferentes_comprados_mes[mes-1]);
	}
	
	free(t);
	return a;
}
コード例 #3
0
Apresentacao clientes_produto(Gestao g, char* cod){
	int i;
	Apresentacao   a       = NULL;
	ProdutoGestao  pg      = NULL;
	ProdutoGestao  procura = NULL;
	Travessia t            = NULL;

	t = (Travessia) malloc(sizeof(struct avl_traverser));
	
	procura       = (ProdutoGestao) malloc(sizeof(struct produtogestao));
	procura->prod = (char*)   malloc((sizeof(char))*(strlen(cod)+1));
	strcpy(procura->prod, cod);

	pg = (ProdutoGestao) avl_find(g->produtos[*cod-'A'], procura);	
	free(procura->prod);
	free(procura);

	if (!pg) return NULL; /*Produto não existe*/

	a = init_apresentacao(pg->num_clientes,0);

	for(i=0;i<26;i++){
		avl_t_init (t, pg->clientes[i]);
		a = preenche_apresentacao_clientes_produto (t, a);
	}	
	
	free(t);
	return a;

}
extern "C" void fc_solve_dbm_store_offload_pre_cache(
    fcs_dbm_store_t store,
    fcs_pre_cache_t * pre_cache
)
{
    leveldb::DB * db;
#ifdef FCS_DBM_USE_LIBAVL
    struct avl_traverser trav;
    dict_key_t item;
#else
    dnode_t * node;
#endif
    dict_t * kaz_tree;
    int num_left_in_transaction = MAX_ITEMS_IN_TRANSACTION;
    leveldb::WriteBatch batch;
    fcs_pre_cache_key_val_pair_t * kv;

    db = (leveldb::DB *)store;
    kaz_tree = pre_cache->kaz_tree;

#ifdef FCS_DBM_USE_LIBAVL
    avl_t_init(&trav, kaz_tree);
#endif

#ifdef FCS_DBM_USE_LIBAVL
    for (
        item = avl_t_first(&trav, kaz_tree)
            ;
        item
            ;
        item = avl_t_next(&trav)
        )
#else
    for (node = fc_solve_kaz_tree_first(kaz_tree);
            node ;
            node = fc_solve_kaz_tree_next(kaz_tree, node)
            )
#define item (node->dict_key)
#endif
    {
        kv = (fcs_pre_cache_key_val_pair_t *)(item);

    leveldb::Slice key((const char *)(kv->key.s+1),kv->key.s[0]);
    /* We add 1 to the parent and move's length because it includes the
     * trailing one-char move.
     * */
    leveldb::Slice parent_and_move((const char *)(kv->parent_and_move.s+1),kv->parent_and_move.s[0]+1);
        batch.Put(key, parent_and_move);

        if ((--num_left_in_transaction) <= 0)
        {
#define WRITE() assert(db->Write(leveldb::WriteOptions(), &batch).ok())
            WRITE();
            batch.Clear();
            num_left_in_transaction = MAX_ITEMS_IN_TRANSACTION;
        }
    }
    WRITE();
#undef WRITE
}
コード例 #5
0
ファイル: sonLibSortedSet.c プロジェクト: adamnovak/sonLib
stSortedSetIterator *stSortedSet_getIterator(stSortedSet *items) {
    stSortedSetIterator *iterator;
    iterator = st_malloc(sizeof(stSortedSetIterator));
    iterator->sortedSet = items;
    avl_t_init(&iterator->traverser, items->sortedSet);
    items->numberOfLiveIterators++;
    return iterator;
}
コード例 #6
0
ファイル: idmap.c プロジェクト: kasei/hexastore
int hx_idmap_debug ( hx_idmap* map ) {
	struct avl_traverser iter;
	avl_t_init( &iter, map->id2string );
	hx_idmap_item* item;
	fprintf( stderr, "Nodemap:\n" );
	while ((item = (hx_idmap_item*) avl_t_next( &iter )) != NULL) {
		char* string	= item->string;
		fprintf( stderr, "\t%"PRIu64" -> %s\n", item->id, string );
	}
	return 0;
}
コード例 #7
0
ファイル: writeenc.c プロジェクト: luigiScarso/mflua
void write_fontencodings()
{
    fe_entry *fe;
    struct avl_traverser t;
    if (fe_tree == NULL)
        return;
    avl_t_init(&t, fe_tree);
    for (fe = (fe_entry *) avl_t_first(&t, fe_tree); fe != NULL;
         fe = (fe_entry *) avl_t_next(&t))
        if (fe->fe_objnum != 0)
            write_fontencoding(fe);
}
コード例 #8
0
void pour_toute_cle_valeur_table(
    const Table* table,
    void (* action)( const intptr_t cle, intptr_t valeur, void* data  ),
    void* data
) {
    struct avl_traverser traverser;
    void * item;
    avl_t_init( &traverser, table->root );
    while( (item = avl_t_next( &traverser )) ) {
        Table_association* asso = (Table_association *) item;
        action( asso->cle, asso->valeur, data );
    }
}
コード例 #9
0
ファイル: pagetable.c プロジェクト: Adjective-Object/369-2015
void print_pagetable() {
	if(avl_tree == NULL) {
		printf("Empty table\n");
		return;
	}

	avl_t_init(&trav, avl_tree);

	void *item;
	while((item = avl_t_next(&trav)) != NULL) {
		page_print(item);
	}

}
コード例 #10
0
ファイル: idmap.c プロジェクト: kasei/hexastore
hx_container_t* hx_idmap_strings ( hx_idmap* map ) {
	size_t size	= avl_count( map->id2string );
	hx_container_t* c	= hx_new_container( 'S', size );
	
	struct avl_traverser iter;
	avl_t_init( &iter, map->id2string );
	hx_idmap_item* item;
	while ((item = (hx_idmap_item*) avl_t_next( &iter )) != NULL) {
		int len			= strlen( item->string ) + 1;
		char* string	= calloc( len, sizeof(char) );
		strcpy(string, item->string );
		hx_container_push_item( c, string );
	}
	
	return c;
}
コード例 #11
0
ファイル: BlockManager.c プロジェクト: transdb/transdb
void blman_get_all_record_keys(blman *self, bbuff *recordKeys)
{
    if(self->blockIndex->avl_count != 0)
    {
        //prealloc
        bbuff_reserve(recordKeys, self->blockIndex->avl_count * sizeof(uint64));
        //add to buffer
        RDF *pRDF;
        struct avl_traverser rTraverser;
        avl_t_init(&rTraverser, self->blockIndex);
        //
        while((pRDF = avl_t_next(&rTraverser)) != NULL)
        {
            bbuff_append(recordKeys, &pRDF->m_key, sizeof(pRDF->m_key));
        }
    }
}
コード例 #12
0
/*
 * Determinar a lista ordenada de códigos de clientes que realizaram compras em
 * todas as filiais.
 */ 
Apresentacao compradores_todas_filiais(Gestao g){
	Apresentacao a = NULL;
	int i, ctf;
	Travessia t = (Travessia) malloc(sizeof(struct avl_traverser));

	ctf = g->num_compradores_todas_filiais;
	if (ctf==0) return NULL;

	a = init_apresentacao(ctf,0);

	for (i=0;i<=25;i++){
		avl_t_init (t, g->clientes[i]);
		preenche_apresentacao_gestao_compradores_todas_filiais (t, a);
	}

	free(t);
	return a;
}
コード例 #13
0
/*
 * Criar uma lista dos N produtos mais vendidos em todo o ano, indicando o
 * número total de clientes diferentes que os compraram e o número de unidades 
 * vendidas, filial a filial. 
 */
Apresentacao top_produtos(Gestao g, int N){
	int i;
	Apresentacao a = NULL;
	Travessia    t = (Travessia) malloc(sizeof(struct avl_traverser));

	if (N>g->prods) N = g->prods;

	a = init_apresentacao(g->prods,2);

	for(i=0;i<26;i++){
		avl_t_init (t, g->produtos[i]);
		a = preenche_apresentacao_top_produtos (t, a, N);
	}


	free(t);
	return a;
}
コード例 #14
0
/* 
 * Determinar a lista ordenada dos códigos dos produtos (e o seu número total),
 * que ninguém comprou, podendo o utilizador decidir igualmente se pretende
 * valores totais ou divididos pelas filiais. 
 */
Apresentacao nunca_comprados(Faturacao f, int *filial){
	Apresentacao a = NULL;
	int i, nc, fil;
	Travessia t = (Travessia) malloc(sizeof(struct avl_traverser));

	if (!filial){
		nc = f->nao_comprados_global; 
	}
	else {
		fil = (*filial)-1;
		nc  = f->nao_comprados[fil];
	}

	a = init_apresentacao(nc,0);
	for (i=0;i<=25;i++){
		avl_t_init (t, f->produtos[i]);
		a = preenche_apresentacao_faturacao_nao_comprados (t, a, filial);
	}

	free(t);

	return a;
}
コード例 #15
0
PAGINA_RESULTADOS travessiaClientesPorLetra(CATALOGO_CLIENTES catalogo, char letra){
	int n;
	CodigoCliente_st cliente;
	PAGINA_RESULTADOS pagina;
	int i = calculaIndiceCliente(toupper(letra));
	int totalResultados = getTotalClientes(catalogo,i);

	TravessiaModulo trav = avl_trav_alloc();
	avl_t_init(trav, getCatalogoClientesPorLetra(catalogo,letra));

	cliente = (CodigoCliente_st) avl_t_next(trav);
	pagina = (PAGINA_RESULTADOS) paginaResultadosInit(totalResultados,1);
	inserirResultadoLista(pagina, cliente); /* a inserir enderecos dos codigos (sem malloc) */

	n = 0;
	while((cliente = avl_t_next(trav)) && n < totalResultados){
		inserirResultadoLista(pagina, cliente);
		n++;
	}

	freeTravessiaCatalogoClientes(trav);

	return pagina;
}
コード例 #16
0
PAGINA_RESULTADOS travessiaProdutosPorLetra(CATALOGO_PRODUTOS catalogo, char letra){
	int n;
	CodigoProduto_st produto;
	PAGINA_RESULTADOS pagina;
	int i = calculaIndiceProduto(toupper(letra));
	int totalResultados = getTotalProdutos(catalogo,i);

	TravessiaModulo trav = avl_trav_alloc();
	avl_t_init(trav, getCatalogoProdutosPorLetra(catalogo,letra));

	produto = (CodigoProduto_st) avl_t_next(trav);
	pagina = (PAGINA_RESULTADOS) paginaResultadosInit(totalResultados,1);
	inserirResultadoLista(pagina, produto); /* a inserir enderecos dos codigos (sem malloc) */

	n = 0;
	while((produto = avl_t_next(trav)) && n < totalResultados){
		inserirResultadoLista(pagina, produto);
		n++;
	}

	freeTravessiaCatalogoProdutos(trav);

	return pagina;
}
コード例 #17
0
ファイル: visibility.c プロジェクト: GRASS-GIS/grass-ci
/** for all points initiate their vis line to the one directly below
*/
void init_vis(struct Point *points, int num_points, struct Line *lines,
	      int num_lines)
{
    int i;
    double d;
    struct avl_table *tree = avl_create(cmp_points, NULL, NULL);
    struct avl_traverser it;
    struct Point *p;

    double y1, y2;

    struct Point *s1, *s2;

    for (i = 0; i < num_points; i++) {

	points[i].vis = NULL;
	d = PORT_DOUBLE_MAX;

	avl_t_init(&it, tree);

	/* loop through the tree */
	while ((p = avl_t_next(&it)) != NULL) {
	    if (segment1(p) == NULL && segment2(p) == NULL)
		continue;

	    /* test for intersection and get the intersecting point */
	    if (segment1(p) != NULL &&
		segment_intersect(segment1(p), &points[i], &y1) > -1) {
		/* find the closest one below */
		if (y1 < points[i].y && (points[i].y - y1) < d) {
		    d = points[i].y - y1;
		    points[i].vis = segment1(p);

		}
	    }


	    if (segment2(p) != NULL &&
		segment_intersect(segment2(p), &points[i], &y2) > -1) {
		if (y2 < points[i].y && (points[i].y - y2) < d) {
		    d = points[i].y - y2;
		    points[i].vis = segment2(p);
		}
	    }

	}			/* end loop */

	s1 = s2 = NULL;

	/* now if the other point is on the right, we can delete it */
	if (segment1(&points[i]) != NULL &&
	    cmp_points(&points[i], other1(&points[i]), NULL) > 0) {
	    p = other1(&points[i]);

	    /* unless the other point of it is on the left */
	    if (segment1(p) != NULL && other1(p) != &points[i] &&
		cmp_points(&points[i], other1(p), NULL) > 0)
		s1 = avl_delete(tree, p);
	    else if (segment2(p) != NULL && other2(p) != &points[i] &&
		     cmp_points(&points[i], other2(p), NULL) > 0)
		s1 = avl_delete(tree, p);
	}

	/* now if the other point is on the right, we can delete it */
	if (segment2(&points[i]) != NULL &&
	    cmp_points(&points[i], other2(&points[i]), NULL) > 0) {
	    p = other2(&points[i]);

	    /* unless the other point of it is on the left */
	    if (segment1(p) != NULL && other1(p) != &points[i] &&
		cmp_points(&points[i], other1(p), NULL) > 0)
		s2 = avl_delete(tree, p);
	    else if (segment2(p) != NULL && other2(p) != &points[i] &&
		     cmp_points(&points[i], other2(p), NULL) > 0)
		s2 = avl_delete(tree, p);
	}

	/* if both weren't deleted, it means there is at least one other
	   point on the left, so add the current */
	/* also there is no point adding the point if there is no segment attached to it */
	if ((s1 == NULL || s2 == NULL)) {
	    avl_insert(tree, &points[i]);
	}
    }


    avl_destroy(tree, NULL);
}
コード例 #18
0
ファイル: sonLibSortedSet.c プロジェクト: adamnovak/sonLib
void *stSortedSet_getLast(stSortedSet *items) {
    struct avl_traverser traverser;
    avl_t_init(&traverser, items->sortedSet);
    return avl_t_last(&traverser, items->sortedSet);
}
コード例 #19
0
ファイル: avl-test.c プロジェクト: Lichtavat/TCAX
/* Checks that |tree| is well-formed
   and verifies that the values in |array[]| are actually in |tree|.
   There must be |n| elements in |array[]| and |tree|.
   Returns nonzero only if no errors detected. */
static int
verify_tree (struct avl_table *tree, int array[], size_t n)
{
  int okay = 1;

  /* Check |tree|'s bst_count against that supplied. */
  if (avl_count (tree) != n)
    {
      printf (" Tree count is %lu, but should be %lu.\n",
              (unsigned long) avl_count (tree), (unsigned long) n);
      okay = 0;
    }

  if (okay)
    {
      /* Recursively verify tree structure. */
      size_t count;
      int height;

      recurse_verify_tree (tree->avl_root, &okay, &count,
                           0, INT_MAX, &height);
      if (count != n)
        {
          printf (" Tree has %lu nodes, but should have %lu.\n",
                  (unsigned long) count, (unsigned long) n);
          okay = 0;
        }
    }

  if (okay)
    {
      /* Check that all the values in |array[]| are in |tree|. */
      size_t i;

      for (i = 0; i < n; i++)
        if (avl_find (tree, &array[i]) == NULL)
          {
            printf (" Tree does not contain expected value %d.\n", array[i]);
            okay = 0;
          }
    }

  if (okay)
    {
      /* Check that |avl_t_first()| and |avl_t_next()| work properly. */
      struct avl_traverser trav;
      size_t i;
      int prev = -1;
      int *item;

      for (i = 0, item = avl_t_first (&trav, tree); i < 2 * n && item != NULL;
           i++, item = avl_t_next (&trav))
        {
          if (*item <= prev)
            {
              printf (" Tree out of order: %d follows %d in traversal\n",
                      *item, prev);
              okay = 0;
            }

          prev = *item;
        }

      if (i != n)
        {
          printf (" Tree should have %lu items, but has %lu in traversal\n",
                  (unsigned long) n, (unsigned long) i);
          okay = 0;
        }
    }

  if (okay)
    {
      /* Check that |avl_t_last()| and |avl_t_prev()| work properly. */
      struct avl_traverser trav;
      size_t i;
      int next = INT_MAX;
      int *item;

      for (i = 0, item = avl_t_last (&trav, tree); i < 2 * n && item != NULL;
           i++, item = avl_t_prev (&trav))
        {
          if (*item >= next)
            {
              printf (" Tree out of order: %d precedes %d in traversal\n",
                      *item, next);
              okay = 0;
            }

          next = *item;
        }

      if (i != n)
        {
          printf (" Tree should have %lu items, but has %lu in reverse\n",
                  (unsigned long) n, (unsigned long) i);
          okay = 0;
        }
    }

  if (okay)
    {
      /* Check that |avl_t_init()| works properly. */
      struct avl_traverser init, first, last;
      int *cur, *prev, *next;

      avl_t_init (&init, tree);
      avl_t_first (&first, tree);
      avl_t_last (&last, tree);

      cur = avl_t_cur (&init);
      if (cur != NULL)
        {
          printf (" Inited traverser should be null, but is actually %d.\n",
                  *cur);
          okay = 0;
        }

      next = avl_t_next (&init);
      if (next != avl_t_cur (&first))
        {
          printf (" Next after null should be %d, but is actually %d.\n",
                  *(int *) avl_t_cur (&first), *next);
          okay = 0;
        }
      avl_t_prev (&init);

      prev = avl_t_prev (&init);
      if (prev != avl_t_cur (&last))
        {
          printf (" Previous before null should be %d, but is actually %d.\n",
                  *(int *) avl_t_cur (&last), *prev);
          okay = 0;
        }
      avl_t_next (&init);
    }

  return okay;
}
コード例 #20
0
ファイル: BlockManager.c プロジェクト: transdb/transdb
uint32 blman_write_record(blman *self, uint64 recordkey, const uint8 *record, uint16 recordsize)
{
    //size check
    if(recordsize > MAX_RECORD_SIZE)
    {
        return eBMS_FailRecordTooBig;
    }

    //variables
    uint32 retStatus = eBMS_Ok;
    uint8 rCompressedRecord[BLOCK_SIZE];
    
    //PHASE 0 --> compression
    //try to compress
    if(recordsize > g_cfg.RecordSizeForCompression)
    {
        size_t outSize;
        int cStatus = CCommon_compressGzip_Buffer(g_cfg.GzipCompressionLevel, record, recordsize, rCompressedRecord, sizeof(rCompressedRecord), &outSize);
        if(cStatus == Z_OK && outSize < recordsize)
        {
            //replace record ptr and set new record size
            record = rCompressedRecord;
            recordsize = (uint16)outSize;
            g_stats.NumOfRecordCompressions++;
        }
        else
        {
            Log_Warning(__FUNCTION__, "Compression generated bigger size. Source size: %u, new size: " I64FMTD, recordsize, outSize);
        }
    }
    
    //PHASE 1 --> try to update
    //try to update record first
    blidxnode rNodeSearch = { recordkey, 0 };
    blidxnode *pNodeFind = avl_find(self->blockIndex, &rNodeSearch);
    if(pNodeFind != NULL)
    {
        uint8 *block = blman_get_block(self, pNodeFind->m_blockNumber);
        //update
        E_BLS updateStatus = Block_UpdateRecord(block, recordkey, record, recordsize);
        if(updateStatus == eBLS_OK)
        {
            return retStatus;
        }
        
        //delete key, record will be on another block
        avl_delete(self->blockIndex, pNodeFind);
        blidxnode_destroy(pNodeFind, self->blockIndex->avl_param);
    }
    
    //PHASE 2 --> check record limit
    //block limit - start to rewrite from begin (record key is timestamp)
    if(g_cfg.EnableRecordLimit && self->blockIndex->avl_count >= g_cfg.RecordLimit)
    {
        int removedRecords = 0;
        //limit can be lowed so delete all records
        while(self->blockIndex->avl_count >= g_cfg.RecordLimit)
        {
            struct avl_traverser rTraverser;
            avl_t_init(&rTraverser, self->blockIndex);
            //delete 1st one (the oldest)
            blidxnode *node = avl_t_first(&rTraverser, self->blockIndex);
            if(node != NULL)
            {
                //DO NOT ADD OLDER DATA
                //check if new data are not the older one
                if(recordkey < node->m_key)
                {
                    retStatus |= (eBMS_RecordCountLimit | eBMS_OldRecord);
                    return retStatus;
                }
                
                //update counter
                ++removedRecords;
                //remove record from block
                blman_delete_record_by_node(self, node);
                //set return status
                retStatus |= eBMS_RecordCountLimit;
            }
        }

        //request defragment
        if(removedRecords >= g_cfg.DefragAfterRecordDelete)
        {
            retStatus |= eBMS_NeedDefrag;
        }
    }

    //PHASE 3 --> try to write
    //find empty space in blocks
    //search from end to begin -> mostly there appends to the end
    uint16 blockNum = self->blockCount;
    for(;;)
    {
        --blockNum;
        //get block and try to write
        uint8 *block = blman_get_block(self, blockNum);
        //
        E_BLS writeStatus = Block_WriteRecord(block, recordkey, record, recordsize);
        if(writeStatus == eBLS_OK)
        {
            blidxnode *node = blidxnode_create(recordkey, blockNum);
            avl_insert(self->blockIndex, node);
            break;
        }
        else if(blockNum == 0 && writeStatus == eBLS_NO_SPACE_FOR_NEW_DATA)
        {
            //realloc blocks + 1 -> modify m_blockCount
            blman_realloc_blocks(self);
            //set status
            retStatus |= eBMS_ReallocatedBlocks;
            //reset control variable
            blockNum = self->blockCount;
        }
    }
    
    return retStatus;
}