gfsmArcIndex.h

Go to the documentation of this file.

/*=============================================================================*\
 * File: gfsmArcIndex.h
 * Author: Bryan Jurish <moocow.bovine@gmail.com>
 * Description: finite state machine library: arc indices
 *
 * Copyright (c) 2006-2011 Bryan Jurish.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *=============================================================================*/

#ifndef _GFSM_ARCINDEX_H
#define _GFSM_ARCINDEX_H

#include <gfsmArcIter.h>

/*======================================================================
 * ReverseArcIndex
 */



typedef GPtrArray gfsmReverseArcIndex;

GFSM_INLINE
gfsmReverseArcIndex *gfsm_reverse_arc_index_new(void);

GFSM_INLINE
gfsmReverseArcIndex *gfsm_reverse_arc_index_sized_new(gfsmStateId n_states);

gfsmReverseArcIndex *gfsm_automaton_to_reverse_arc_index(gfsmAutomaton *fsm, gfsmReverseArcIndex *rarcs);

#define gfsm_automaton_reverse_arc_index gfsm_automaton_to_reverse_arc_index

void gfsm_reverse_arc_index_free(gfsmReverseArcIndex *rarcs, gboolean free_lists);



/*======================================================================
 * gfsmFinalWeightIndex
 */


typedef GArray gfsmWeightVector;

GFSM_INLINE
gfsmWeightVector *gfsm_weight_vector_new(void);

GFSM_INLINE
gfsmWeightVector *gfsm_weight_vector_sized_new(guint size);

GFSM_INLINE
gfsmWeightVector *gfsm_weight_vector_copy(gfsmWeightVector *dst, gfsmWeightVector *src);

GFSM_INLINE
gfsmWeightVector *gfsm_weight_vector_clone(gfsmWeightVector *src);


GFSM_INLINE
void gfsm_weight_vector_resize(gfsmWeightVector *wv, guint size);

gfsmWeightVector *gfsm_automaton_to_final_weight_vector(gfsmAutomaton *fsm, gfsmWeightVector *wv);

GFSM_INLINE
void gfsm_weight_vector_free(gfsmWeightVector *wv);

gboolean gfsm_weight_vector_write_bin_handle(gfsmWeightVector *wv, gfsmIOHandle *ioh, gfsmError **errp);

gboolean gfsm_weight_vector_read_bin_handle(gfsmWeightVector *wv, gfsmIOHandle *ioh, gfsmError **errp);


/*======================================================================
 * gfsmArcTable
 */


typedef GArray gfsmArcTable;

GFSM_INLINE
gfsmArcTable *gfsm_arc_table_new(void);

GFSM_INLINE
gfsmArcTable *gfsm_arc_table_sized_new(guint n_arcs);

GFSM_INLINE
void gfsm_arc_table_resize(gfsmArcTable *tab, guint n_arcs);

GFSM_INLINE
gfsmArcTable *gfsm_arc_table_copy(gfsmArcTable *dst, gfsmArcTable *src);

GFSM_INLINE
gfsmArcTable *gfsm_arc_table_clone(gfsmArcTable *src);

GFSM_INLINE
void gfsm_arc_table_free(gfsmArcTable *tab);

gfsmArcTable *gfsm_automaton_to_arc_table(gfsmAutomaton *fsm, gfsmArcTable *tab);

gfsmArcTable *gfsm_arc_table_append_arclist(gfsmArcTable *tab, gfsmArcList *arcs);

GFSM_INLINE
gfsmArcTable *gfsm_arc_table_append_arciter(gfsmArcTable *tab, gfsmArcIter *ai);

GFSM_INLINE
gfsmArcTable *gfsm_arc_table_append_state(gfsmArcTable *tab, gfsmAutomaton *fsm, gfsmStateId qid);


GFSM_INLINE
void gfsm_arc_table_sort_with_data(gfsmArcTable *tab, GCompareDataFunc compare_func, gpointer data);

GFSM_INLINE
void gfsm_arc_table_sort_bymask(gfsmArcTable *tab, gfsmArcCompMask m, gfsmSemiring *sr);

GFSM_INLINE
gfsmArc *gfsm_arc_table_seek(gfsmArcTable *tab, const gfsmArc *key, GCompareDataFunc compare_func, gpointer data);

GFSM_INLINE
gfsmArc *gfsm_arc_table_seek_bymask(gfsmArcTable *tab, const gfsmArc *key, gfsmArcCompMask m, gfsmSemiring *sr);

gboolean gfsm_arc_table_write_bin_handle(gfsmArcTable *tab, gfsmIOHandle *ioh, gfsmError **errp);

gboolean gfsm_arc_table_read_bin_handle(gfsmArcTable *tab, gfsmIOHandle *ioh, gfsmError **errp);


/*======================================================================
 * gfsmArcPTable
 */


typedef GPtrArray gfsmArcPtrTable;

GFSM_INLINE
gfsmArcPtrTable *gfsm_arc_ptr_table_new(void);

GFSM_INLINE
gfsmArcPtrTable *gfsm_arc_ptr_table_sized_new(guint n_arcs);

GFSM_INLINE
void gfsm_arc_ptr_table_resize(gfsmArcPtrTable *ptab, guint n_arcs);

GFSM_INLINE
gfsmArcPtrTable *gfsm_arc_ptr_table_copy(gfsmArcPtrTable *dst, gfsmArcPtrTable *src);

GFSM_INLINE
gfsmArcPtrTable *gfsm_arc_ptr_table_clone(gfsmArcPtrTable *src);

GFSM_INLINE
void gfsm_arc_ptr_table_free(gfsmArcPtrTable *ptab);

gfsmArcPtrTable *gfsm_arc_ptr_table_append_arclist(gfsmArcPtrTable *ptab, gfsmArcList *arcs);

GFSM_INLINE
gfsmArcPtrTable *gfsm_arc_ptr_table_append_arciter(gfsmArcPtrTable *ptab, gfsmArcIter *ai);

GFSM_INLINE
gfsmArcPtrTable *gfsm_arc_ptr_table_append_state(gfsmArcPtrTable *ptab, gfsmAutomaton *fsm, gfsmStateId qid);


GFSM_INLINE
void gfsm_arc_ptr_table_sort_with_data(gfsmArcPtrTable *ptab, GCompareDataFunc compare_func, gpointer data);

GFSM_INLINE
void gfsm_arc_ptr_table_sort_bymask(gfsmArcPtrTable *ptab, gfsmArcCompMask m, gfsmSemiring *sr);

GFSM_INLINE
gfsmArc *gfsm_arc_ptr_table_seek(gfsmArcPtrTable *ptab, const gfsmArc *key, GCompareDataFunc compare_func, gpointer data);

GFSM_INLINE
gfsmArc *gfsm_arc_ptr_table_seek_bymask(gfsmArcPtrTable *ptab, const gfsmArc *key, gfsmArcCompMask m, gfsmSemiring *sr);

/*======================================================================
 * gfsmArcTableIndex
 */


typedef struct {
  gfsmArcTable *tab;              
  GPtrArray    *first;            
} gfsmArcTableIndex;

GFSM_INLINE
gfsmArcTableIndex *gfsm_arc_table_index_new(void);

GFSM_INLINE
gfsmArcTableIndex *gfsm_arc_table_index_sized_new(gfsmStateId n_states, guint n_arcs);

GFSM_INLINE
void gfsm_arc_table_index_resize(gfsmArcTableIndex *tab, gfsmStateId n_states, guint n_arcs);

GFSM_INLINE
gfsmStateId gfsm_arc_table_index_n_states(gfsmArcTableIndex *tabx);

GFSM_INLINE
guint gfsm_arc_table_index_n_arcs(gfsmArcTableIndex *tabx);

gfsmArcTableIndex *gfsm_arc_table_index_copy(gfsmArcTableIndex *dst, gfsmArcTableIndex *src);

GFSM_INLINE
gfsmArcTableIndex *gfsm_arc_table_index_clone(gfsmArcTableIndex *src);

GFSM_INLINE
void gfsm_arc_table_index_free(gfsmArcTableIndex *tabx);

gfsmArcTableIndex *gfsm_automaton_to_arc_table_index(gfsmAutomaton *fsm, gfsmArcTableIndex *tabx);

void gfsm_arc_table_index_sort_with_data(gfsmArcTableIndex *tabx, GCompareDataFunc compare_func, gpointer data);

GFSM_INLINE
void gfsm_arc_table_index_sort_bymask(gfsmArcTableIndex *tabx, gfsmArcCompMask m, gfsmSemiring *sr);

GFSM_INLINE
guint gfsm_arc_table_index_out_degree(gfsmArcTableIndex *tabx, gfsmStateId qid);

gboolean gfsm_arc_table_index_write_bin_handle(gfsmArcTableIndex *tabx, gfsmIOHandle *ioh, gfsmError **errp);

gboolean gfsm_arc_table_index_read_bin_handle(gfsmArcTableIndex *tabx, gfsmIOHandle *ioh, gfsmError **errp);


/*======================================================================
 * gfsmArcRange
 */


typedef struct {
  gfsmArc *min; 
  gfsmArc *max; 
} gfsmArcRange;

GFSM_INLINE
void gfsm_arcrange_open_table_index(gfsmArcRange *range, gfsmArcTableIndex *tabx, gfsmStateId qid);

GFSM_INLINE
void gfsm_arcrange_close(gfsmArcRange *range);

GFSM_INLINE
gboolean gfsm_arcrange_ok(gfsmArcRange *range);

GFSM_INLINE
gfsmArc *gfsm_arcrange_arc(gfsmArcRange *range);

GFSM_INLINE
void gfsm_arcrange_next(gfsmArcRange *range);


/*======================================================================
 * inline definitions
 */
#ifdef GFSM_INLINE_ENABLED
# include <gfsmArcIndex.hi>
#endif

/*======================================================================
 * END
 */
#endif /* _GFSM_ARCINDEX_H */