src/hrg/cst_item.c

/*************************************************************************/
/*                                                                       */
/*                  Language Technologies Institute                      */
/*                     Carnegie Mellon University                        */
/*                        Copyright (c) 1999                             */
/*                        All Rights Reserved.                           */
/*                                                                       */
/*  Permission is hereby granted, free of charge, to use and distribute  */
/*  this software and its documentation without restriction, including   */
/*  without limitation the rights to use, copy, modify, merge, publish,  */
/*  distribute, sublicense, and/or sell copies of this work, and to      */
/*  permit persons to whom this work is furnished to do so, subject to   */
/*  the following conditions:                                            */
/*   1. The code must retain the above copyright notice, this list of    */
/*      conditions and the following disclaimer.                         */
/*   2. Any modifications must be clearly marked as such.                */
/*   3. Original authors' names are not deleted.                         */
/*   4. The authors' names are not used to endorse or promote products   */
/*      derived from this software without specific prior written        */
/*      permission.                                                      */
/*                                                                       */
/*  CARNEGIE MELLON UNIVERSITY AND THE CONTRIBUTORS TO THIS WORK         */
/*  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      */
/*  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   */
/*  SHALL CARNEGIE MELLON UNIVERSITY NOR THE CONTRIBUTORS BE LIABLE      */
/*  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    */
/*  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   */
/*  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          */
/*  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       */
/*  THIS SOFTWARE.                                                       */
/*                                                                       */
/*************************************************************************/
/*             Author:  Alan W Black (awb@cs.cmu.edu)                    */
/*               Date:  December 1999                                    */
/*************************************************************************/
/*                                                                       */
/*  Items (and Item Contents)                                            */
/*                                                                       */
/*************************************************************************/
#include "cst_alloc.h"
#include "cst_item.h"
#include "cst_relation.h"
#include "cst_utterance.h"

/* Define functions for using items, rels and utts as vals */
CST_VAL_REGISTER_TYPE_NODEL(relation,cst_relation)
CST_VAL_REGISTER_TYPE_NODEL(item,cst_item)
CST_VAL_REGISTER_TYPE(utterance,cst_utterance)
CST_VAL_REGISTER_FUNCPTR(itemfunc,cst_itemfunc)

cst_item *new_item_relation(cst_relation *r,cst_item *i)
{
    cst_item *ni;

    ni = cst_utt_alloc(r->utterance, cst_item, 1);
    ni->contents = 0;
    ni->n = ni->p = ni->u = ni->d = 0;
    ni->relation = r;
    item_contents_set(ni,i);
    return ni;
}

void item_contents_set(cst_item *current, cst_item *i)
{
    cst_item_contents *c = 0;
    cst_item *nn_item;
    if (i == 0)
	c = new_item_contents(current);
    else
	c = i->contents;
    if (c != current->contents)
    {
	item_unref_contents(current);
	current->contents = c;
	/* If this contents is already in this relation         */
	/* empty the other reference                            */
	if (feat_present(current->contents->relations,current->relation->name))
	{   /* oops this is already in this relation */
	    nn_item = val_item(feat_val(current->contents->relations,
					current->relation->name));
	    feat_set(nn_item->contents->relations,
		     current->relation->name,
		     item_val(nn_item));
	       
	}
	/* Add back reference */
	feat_set(current->contents->relations,
		 current->relation->name,
		 item_val(current));
    }
}

void delete_item(cst_item *item)
{
    cst_item *ds, *nds;

    if (item->n != NULL) 
    { 
	item->n->p = item->p;
	item->n->u = item->u;  /* in trees if this is first daughter */
    }
    if (item->p != NULL) item->p->n = item->n;
    if (item->u != NULL) item->u->d = item->n; /* when first daughter */
    
    if (item->relation)
    {
	if (item->relation->head == item)
	    item->relation->head = item->n;
	if (item->relation->tail == item)
	    item->relation->tail = item->p;
    }

    /* Delete all the daughters of item */
    for (ds = item->d; ds; ds=nds)
    {
	nds = ds->n;
	delete_item(ds);
    }
    
    item_unref_contents(item);
    cst_utt_free(item->relation->utterance, item);
}

void item_unref_contents(cst_item *item)
{
    /* unreference this item from contents, and delete contents */
    /* if no one else is referencing it                         */

    if (item && item->contents)
    {
	feat_remove(item->contents->relations,item->relation->name);
	if (feat_length(item->contents->relations) == 0)
	{
	    delete_features(item->contents->relations);
	    delete_features(item->contents->features);
	    cst_utt_free(item->relation->utterance,item->contents);
	}
	item->contents = NULL;
    }
}

cst_item_contents *new_item_contents(cst_item *i)
{
    cst_item_contents *ic;

    ic = cst_utt_alloc(i->relation->utterance,cst_item_contents,1);
    ic->features = new_features_local(i->relation->utterance->ctx);
    ic->relations = new_features_local(i->relation->utterance->ctx);

    return ic;
}

cst_item *item_as(const cst_item *i,const char *rname)
{
    /* return i as relation rname or null */
    const cst_val *v;

    if (i == NULL)
	return NULL;
    else 
    {
        v = feat_val(i->contents->relations,rname);
        if (v != NULL)
            return val_item(v);
        else
            return NULL;
    }
}

/********************************************************************/
/*    List relation related functions                               */
/********************************************************************/

cst_item *item_next(const cst_item *i)
{
    if (i == NULL)
	return NULL;
    else
	return i->n;
}

cst_item *item_prev(const cst_item *i)
{
    if (i == NULL)
	return NULL;
    else
	return i->p;
}

cst_item *item_append(cst_item *current, cst_item *ni)
{
    cst_item *rni = 0;

    if (ni && (ni->relation == current->relation))
    {
	/* got to delete it first as an item can't be in a relation twice */
    }
    else
	rni = new_item_relation(current->relation,ni);

    rni->n = current->n;
    if (current->n != NULL)
	current->n->p = rni;
    rni->p = current;
    current->n = rni;

    if (current->relation->tail == current)
	current->relation->tail = rni;

    return rni;
}

cst_item *item_prepend(cst_item *current, cst_item *ni)
{
    cst_item *rni = 0;

    if (ni && (ni->relation == current->relation))
    {
	/* got to delete it first as an item can't be in a relation twice */
    }
    else
	rni = new_item_relation(current->relation,ni);

    rni->p = current->p;
    if (current->p != NULL)
	current->p->n = rni;
    rni->n = current;
    current->p = rni;

    if (current->u)  /* in a tree */
    {
	current->u->d = rni;
	rni->u = current->u;
	current->u = NULL;
    }

    if (current->relation->head == current)
	current->relation->head = rni;

    return rni;
}

/********************************************************************/
/*    Tree relation related functions                               */
/********************************************************************/
cst_item *item_parent(const cst_item *i)
{
    const cst_item *n;

    for (n=i; item_prev(n); n=item_prev(n));
    if (n == NULL)
	return NULL;
    else 
	return n->u;
}

cst_item *item_daughter(const cst_item *i)
{
    if (i == NULL)
	return NULL;
    else 
	return i->d;
}

cst_item *item_nth_daughter(const cst_item *i,int n)
{
    int d;
    cst_item *p;

    for (d=0,p=item_daughter(i); p && (d < n); p=item_next(p),d++);
    return p;
}


cst_item *item_last_daughter(const cst_item *i)
{
    cst_item *p;

    for (p=item_daughter(i); item_next(p); p=item_next(p));
    return p;
}

cst_item *item_add_daughter(cst_item *i,cst_item *nd)
{
    cst_item *p,*rnd;

    p = item_last_daughter(i);

    if (p)
	rnd=item_append(p,nd);
    else
    {   /* first new daughter */
	if (nd && (nd->relation == i->relation))
	{
	    /* got to delete it first as nd can't be in a relation twice */
	    cst_errmsg("item_add_daughter: already in relation\n");
	    return 0;
	}
	else
	    rnd = new_item_relation(i->relation,nd);

	rnd->u = i;
	i->d = rnd;
    }

    return rnd;
}

/********************************************************************/
/*    Feature functions                                             */
/********************************************************************/

int item_feat_present(const cst_item *i,const char *name)
{
    return feat_present(item_feats(i),name);
}

int item_feat_remove(const cst_item *i,const char *name)
{
    return feat_remove(item_feats(i),name);
}

cst_features *item_feats(const cst_item *i)
{
    return (i ? i->contents->features : NULL);
}

const cst_val *item_feat(const cst_item *i,const char *name)
{
    return feat_val(item_feats(i),name);
}

int item_feat_int(const cst_item *i,const char *name)
{
    return feat_int(item_feats(i),name);
}

float item_feat_float(const cst_item *i,const char *name)
{
    return feat_float(item_feats(i),name);
}

const char *item_feat_string(const cst_item *i,const char *name)
{
    return feat_string(item_feats(i),name);
}

void item_set(const cst_item *i,const char *name,const cst_val *val)
{
    feat_set(item_feats(i),name,val);
}

void item_set_int(const cst_item *i,const char *name,int val)
{
    feat_set_int(item_feats(i),name,val);
}

void item_set_float(const cst_item *i,const char *name,float val)
{
    feat_set_float(item_feats(i),name,val);
}

void item_set_string(const cst_item *i,const char *name,const char *val)
{
    feat_set_string(item_feats(i),name,val);
}

cst_utterance *item_utt(const cst_item *i)
{
    if (i && i->relation)
	return i->relation->utterance;
    else
	return NULL;
}

int item_equal(const cst_item *a, const cst_item *b)
{
    if ((a == b) ||
	(a && b && (a->contents == b->contents)))
	return TRUE;
    else
	return FALSE;
}