gfsmArc.h

Go to the documentation of this file.

/*=============================================================================*\
 * File: gfsmArc.h
 * Author: Bryan Jurish <moocow.bovine@gmail.com>
 * Description: finite state machine library: arcs
 *
 * Copyright (c) 2004-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_ARC_H
#define _GFSM_ARC_H

#include <gfsmSemiring.h>
#include <stdarg.h>

typedef struct {
  gfsmStateId       source;  
  gfsmStateId       target;  
  gfsmLabelId       lower;   
  gfsmLabelId       upper;   
  gfsmWeight        weight;  
} gfsmArc;

typedef enum {
  gfsmLSBoth  = 0, 
  gfsmLSLower = 1, 
  gfsmLSUpper = 2  
} gfsmLabelSide;

//----------------------------------------------------------------------
// arc sorting (new)


typedef enum {
  gfsmACNone    = 0x0,  
  //
  //-- Forward (ascending)
  gfsmACLower   = 0x1,  
  gfsmACUpper   = 0x2,  
  gfsmACWeight  = 0x3,  
  gfsmACSource  = 0x4,  
  gfsmACTarget  = 0x5,  
  gfsmACUser    = 0x6,  
  gfsmACUnused1 = 0x7,  
  //
  //-- Reverse (descending)
  gfsmACReverse = 0x8,  
  gfsmACLowerR  = 0x9,  
  gfsmACUpperR  = 0xa,  
  gfsmACWeightR = 0xb,  
  gfsmACSourceR = 0xc,  
  gfsmACTargetR = 0xd,  
  gfsmACUserR   = 0xe,  
  //
  //-- Pseudo-comparisons
  gfsmACAll     = 0xf   
} gfsmArcComp;

typedef guint32 gfsmArcCompMask;

#define gfsmACShift 4

#define gfsmACMaxN 6

typedef enum {
  gfsmASMNone   = 0x0,                                                                       
  gfsmASMLower  = (gfsmACLower|(gfsmACUpper<<gfsmACShift)|(gfsmACTarget<<(2*gfsmACShift))),  
  gfsmASMUpper  = (gfsmACUpper|(gfsmACLower<<gfsmACShift)|(gfsmACTarget<<(2*gfsmACShift))),  
  gfsmASMWeight = gfsmACWeight,                                                              
  gfsmASMLowerWeight = (gfsmACLower|(gfsmACWeight<<gfsmACShift)),                            
  gfsmASMUpperWeight = (gfsmACUpper|(gfsmACWeight<<gfsmACShift)),                            
  gfsmASMUser        = gfsmACUser,                                                           
} gfsmArcSortModeE;

typedef gfsmArcCompMask gfsmArcSortMode;

typedef struct {
  gfsmArcCompMask       mask;               
  gfsmSemiring         *sr;                 
  GCompareDataFunc    user_compare_func;    
  gpointer            user_data;            
} gfsmArcCompData;

/*======================================================================
 * Methods: Arcs: Constructors etc.
 */



GFSM_INLINE
gfsmArc *gfsm_arc_new(void);

GFSM_INLINE
gfsmArc *gfsm_arc_init(gfsmArc *a,
                       gfsmStateId src,
                       gfsmStateId dst,
                       gfsmLabelId lo,
                       gfsmLabelId hi,
                       gfsmWeight wt);

GFSM_INLINE
gfsmArc *gfsm_arc_new_full(gfsmStateId src, gfsmStateId dst, gfsmLabelVal lo, gfsmLabelVal hi, gfsmWeight wt);

GFSM_INLINE
gfsmArc *gfsm_arc_clone(gfsmArc *src);

#define gfsm_arc_copy(src) gfsm_arc_clone(src)

GFSM_INLINE
void gfsm_arc_free(gfsmArc *a);

/*======================================================================
 * Methods: Arc: Accessors
 */


#define gfsm_arc_source(arcptr) ((arcptr)->source)

#define gfsm_arc_target(arcptr) ((arcptr)->target)

#define gfsm_arc_lower(arcptr) ((arcptr)->lower)

#define gfsm_arc_upper(arcptr) ((arcptr)->upper)

#define gfsm_arc_weight(arcptr) ((arcptr)->weight)



/*======================================================================
 * Arc Comparison Utilities
 */


GFSM_INLINE
gint gfsm_arc_compare_bymask_inline(gfsmArc *a1, gfsmArc *a2, gfsmArcCompData *acdata);

gint gfsm_arc_compare_bymask(gfsmArc *a1, gfsmArc *a2, gfsmArcCompData *acdata);

GFSM_INLINE
gint gfsm_arc_compare_bymask_1_(gfsmArc *a1, gfsmArc *a2, gfsmArcComp cmp, gfsmArcCompData *acdata);

gfsmArcCompMask gfsm_acmask_from_chars(const char *maskchars);

gfsmArcCompMask gfsm_acmask_from_args(gfsmArcComp cmp0, ...);

GFSM_INLINE
gfsmArcCompMask gfsm_acmask_new(gfsmArcComp cmp, gint nth);

GFSM_INLINE
gfsmArcComp gfsm_acmask_nth(gfsmArcCompMask m, gint nth);

GFSM_INLINE
gfsmArcComp gfsm_acmask_nth_comp(gfsmArcCompMask m, gint nth);

GFSM_INLINE
gboolean gfsm_acmask_nth_reverse(gfsmArcCompMask m, gint nth);

GFSM_INLINE
gchar gfsm_acmask_nth_char(gfsmArcCompMask m, gint nth);

const gchar *gfsm_acmask_nth_string(gfsmArcCompMask m, gint nth);

gchar *gfsm_acmask_to_chars(gfsmArcCompMask m, gchar *chars);

GString *gfsm_acmask_to_gstring(gfsmArcCompMask m, GString *gstr);

GFSM_INLINE
const gchar *gfsm_arc_sortmode_to_name(gfsmArcCompMask m);


//-- inline definitions
#ifdef GFSM_INLINE_ENABLED
# include <gfsmArc.hi>
#endif

#endif /* _GFSM_ARC_H */