265 lines
10 KiB
C++
265 lines
10 KiB
C++
/*************************************************************************/
|
|
/* */
|
|
/* Centre for Speech Technology Research */
|
|
/* University of Edinburgh, UK */
|
|
/* Copyright (c) 1995,1996 */
|
|
/* 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. */
|
|
/* */
|
|
/* THE UNIVERSITY OF EDINBURGH 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 THE UNIVERSITY OF EDINBURGH 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 */
|
|
/* Date : May 1996 */
|
|
/*-----------------------------------------------------------------------*/
|
|
/* */
|
|
/* A generic container class, originally for ints floats and string now */
|
|
/* extended for some others, eventually allow run addition of new types */
|
|
/* "built-in" types (i.e. ones explicitly mentioned in this file) may */
|
|
/* be accessed by member functions, objects added at run time may only */
|
|
/* be accessed by functions */
|
|
/* */
|
|
/* This is so similar to the LISP class in SIOD it could be viewed as a */
|
|
/* little embarrassing, but this is done without a cons cell heap or gc */
|
|
/* which may or may not be a good thing. */
|
|
/* */
|
|
/*=======================================================================*/
|
|
#ifndef __EST_VAL_H__
|
|
#define __EST_VAL_H__
|
|
|
|
#include "EST_String.h"
|
|
#include "EST_error.h"
|
|
#include "EST_Contents.h"
|
|
#include "EST_Val_defs.h"
|
|
|
|
typedef const char *val_type;
|
|
|
|
extern val_type val_unset;
|
|
extern val_type val_int;
|
|
extern val_type val_float;
|
|
extern val_type val_string;
|
|
|
|
/** The EST_Val class is a container class, used to store a single
|
|
item which can be an int, float, string or other user-defined
|
|
class. It is often used as the base item in the <link
|
|
linkend="est-features">EST_Features</link> class, to enable features
|
|
to take on values of different types.
|
|
*/
|
|
|
|
class EST_Val {
|
|
private:
|
|
val_type t;
|
|
union
|
|
{ int ival;
|
|
float fval;
|
|
EST_Contents *pval;} v;
|
|
// * may have a string name as well as a value
|
|
EST_String sval;
|
|
const int to_int() const;
|
|
const float to_flt() const;
|
|
const EST_String &to_str() const;
|
|
public:
|
|
/**@name Constructor and Destructor functions
|
|
*/
|
|
|
|
//@{
|
|
/** Default constructor */
|
|
EST_Val()
|
|
{t=val_unset;}
|
|
|
|
/** Copy constructor for another EST_Val*/
|
|
EST_Val(const EST_Val &val);
|
|
|
|
/** Copy constructor for an int*/
|
|
EST_Val(const int i)
|
|
{t=val_int; v.ival=i;}
|
|
|
|
/** Copy constructor for a float*/
|
|
EST_Val(const float f)
|
|
{t=val_float; v.fval=f;}
|
|
|
|
/** Copy constructor for a double*/
|
|
EST_Val(const double d) {t=val_float; v.fval=d;}
|
|
|
|
/** Copy constructor for a string*/
|
|
// EST_Val(const EST_String &s) {t=val_string; sval = s;}
|
|
EST_Val(const EST_String &s) : t(val_string), sval(s) {};
|
|
|
|
/** Copy constructor for a string literal*/
|
|
// EST_Val(const char *s) {t=val_string; sval = s;}
|
|
EST_Val(const char *s) : t(val_string), sval(s) {};
|
|
|
|
EST_Val(val_type type,void *p, void (*f)(void *));
|
|
|
|
/** Destructor */
|
|
~EST_Val(void);
|
|
|
|
//@}
|
|
|
|
/**@name Getting cast values
|
|
*/
|
|
|
|
//@{
|
|
|
|
/** returns the type that the val is currently holding */
|
|
const val_type type(void) const
|
|
{return t;}
|
|
|
|
/** returns the value, cast as an int */
|
|
const int Int(void) const
|
|
{if (t==val_int) return v.ival; return to_int();}
|
|
|
|
/** returns the value, cast as an int */
|
|
const int I(void) const
|
|
{ return Int(); }
|
|
|
|
/** returns the value, cast as a float */
|
|
const float Float(void) const
|
|
{if (t==val_float) return v.fval; return to_flt();}
|
|
|
|
/** returns the value, cast as a float */
|
|
const float F(void) const
|
|
{ return Float(); }
|
|
|
|
/** returns the value, cast as a string */
|
|
const EST_String &String(void) const
|
|
{if (t!=val_string) to_str(); return sval;}
|
|
|
|
/** returns the value, cast as a string */
|
|
const EST_String &string(void) const
|
|
{return String();}
|
|
|
|
/** returns the value, cast as a string */
|
|
const EST_String &S(void) const
|
|
{return String();}
|
|
|
|
/** returns the value, cast as a string */
|
|
const EST_String &string_only(void) const {return sval;}
|
|
|
|
//@}
|
|
|
|
// Humans should never call this only automatic functions
|
|
const void *internal_ptr(void) const
|
|
{ return v.pval->get_contents(); }
|
|
|
|
/**@name Setting values
|
|
*/
|
|
|
|
//@{
|
|
|
|
/** Assignment of val to an int */
|
|
EST_Val &operator=(const int i) { t=val_int; v.ival=i; return *this;}
|
|
|
|
/** Assignment of val to a float */
|
|
EST_Val &operator=(const float f) { t=val_float; v.fval=f; return *this;}
|
|
|
|
/** Assignment of val to a double */
|
|
EST_Val &operator=(const double d) { t=val_float; v.fval=d; return *this;}
|
|
|
|
/** Assignment of val to a string */
|
|
EST_Val &operator=(const EST_String &s) { t=val_string; sval = s; return *this;}
|
|
|
|
/** Assignment of val to a string literal*/
|
|
EST_Val &operator=(const char *s) { t=val_string; sval = s; return *this;}
|
|
|
|
/** Assignment of val to another val*/
|
|
EST_Val &operator=(const EST_Val &c);
|
|
|
|
//@}
|
|
|
|
/**@name Equivalence test
|
|
*/
|
|
|
|
//@{
|
|
|
|
|
|
/** Test whether val is equal to a*/
|
|
int operator ==(const EST_Val &a) const
|
|
{ if (t != a.t) return (1==0);
|
|
else if (t == val_string) return (sval == a.sval);
|
|
else if (t == val_int) return (v.ival == a.v.ival);
|
|
else if (t == val_float) return (v.fval == a.v.fval);
|
|
else return (internal_ptr() == a.internal_ptr()); }
|
|
|
|
/** Test whether val is equal to the string a*/
|
|
int operator ==(const EST_String &a) const { return (string() == a); }
|
|
/** Test whether val is equal to the char * a*/
|
|
int operator ==(const char *a) const { return (string() == a); }
|
|
/** Test whether val is equal to the int a*/
|
|
int operator ==(const int &i) const { return (Int() == i); }
|
|
/** Test whether val is equal to the float a*/
|
|
int operator ==(const float &f) const { return (Float() == f); }
|
|
/** Test whether val is equal to the double a*/
|
|
int operator ==(const double &d) const { return (Float() == d); }
|
|
|
|
|
|
/** Test whether val is not equal to the val a*/
|
|
int operator !=(const EST_Val &a) const { return (!(*this == a)); }
|
|
/** Test whether val is not equal to the string a*/
|
|
int operator !=(const EST_String &a) const { return (string() != a); }
|
|
/** Test whether val is not equal to the char * a*/
|
|
int operator !=(const char *a) const { return (string() != a); }
|
|
/** Test whether val is not equal to the int a*/
|
|
int operator !=(const int &i) const { return (Int() != i);}
|
|
/** Test whether val is not equal to the float a*/
|
|
int operator !=(const float &f) const { return (Float() != f); }
|
|
/** Test whether val is not equal to the double float a*/
|
|
int operator !=(const double &d) const { return (Float() != d); }
|
|
|
|
//@{
|
|
|
|
/**@name Automatic casting
|
|
*/
|
|
//@{
|
|
|
|
/** Automatically cast val as an int*/
|
|
operator int() const { return Int(); }
|
|
/** Automatically cast val as an float*/
|
|
operator float() const { return Float(); }
|
|
/** Automatically cast val as an string*/
|
|
operator EST_String() const { return string(); }
|
|
//@}
|
|
/** print val*/
|
|
friend ostream& operator << (ostream &s, const EST_Val &a)
|
|
{ if (a.type() == val_unset) s << "[VAL unset]" ;
|
|
else if (a.type() == val_int) s << a.v.ival;
|
|
else if (a.type() == val_float) s << a.v.fval;
|
|
else if (a.type() == val_string) s << a.sval;
|
|
else s << "[PVAL " << a.type() << "]";
|
|
return s;
|
|
}
|
|
};
|
|
|
|
inline const char *error_name(const EST_Val val) { return (EST_String)val;}
|
|
|
|
// For consistency with other (user-defined) types in val
|
|
inline EST_Val est_val(const EST_String s) { return EST_Val(s); }
|
|
inline EST_Val est_val(const char *s) { return EST_Val(s); }
|
|
inline int Int(const EST_Val &v) { return v.Int(); }
|
|
inline EST_Val est_val(const int i) { return EST_Val(i); }
|
|
inline float Float(const EST_Val &v) { return v.Float(); }
|
|
inline EST_Val est_val(const float f) { return EST_Val(f); }
|
|
|
|
#endif
|