lib/eggdrop/variant.c File Reference

#include <stdio.h>
#include <string.h>
#include <eggdrop/memory.h>
#include <eggdrop/memutil.h>
#include <eggdrop/variant.h>

Go to the source code of this file.

Functions

void variant_set_str (variant_t *target, const char *value)

const char * variant_get_str (variant_t *target, const char *nil)

void variant_set_int (variant_t *target, int value)

int variant_get_int (variant_t *target, int nil)

void variant_set_bool (variant_t *target, int value)

int variant_get_bool (variant_t *target, int nil)

void variant_set_ts (variant_t *target, time_t value)

time_t variant_get_ts (variant_t *target, time_t nil)

Variables

static const char rcsid [] = "$Id: variant.c,v 1.2 2004-06-30 17:07:20 wingman Exp $"

Function Documentation

int variant_get_bool	(	variant_t *	target,
		int	nil
	)

Definition at line 142 of file variant.c.

References variant_t::b_val, variant_t::i_val, NULL, variant_t::s_val, variant_t::type, variant_t::value, VARIANT_BOOL, VARIANT_INT, VARIANT_STRING, and VARIANT_TIMESTAMP.

00143 {
00144   switch (target->type) {
00145   
00146     case (VARIANT_INT):
00147       return (target->value.i_val) ? 0 : 1;
00148 
00149     case (VARIANT_BOOL):
00150       return target->value.b_val;
00151     
00152     case (VARIANT_STRING):
00153       if (target->value.s_val == NULL)
00154         return nil;
00155       if (0 == strcmp(target->value.s_val, "yes")
00156         || 0 == strcmp(target->value.s_val, "1"))
00157         return 1;
00158       else if (0 == strcmp(target->value.s_val, "no")
00159         || 0 == strcmp(target->value.s_val, "0"))
00160         return 0;
00161       return nil;
00162   
00163     case (VARIANT_TIMESTAMP):
00164       return nil;
00165     
00166   }
00167   
00168   return nil;
00169 }

int variant_get_int	(	variant_t *	target,
		int	nil
	)

Definition at line 102 of file variant.c.

References variant_t::b_val, variant_t::i_val, NULL, variant_t::s_val, variant_t::ts_val, variant_t::type, variant_t::value, VARIANT_BOOL, VARIANT_INT, VARIANT_STRING, and VARIANT_TIMESTAMP.

00103 {
00104   switch (target->type) {
00105   
00106     case (VARIANT_INT):
00107       return target->value.i_val;
00108 
00109     case (VARIANT_BOOL):
00110       return target->value.b_val;
00111     
00112     case (VARIANT_STRING):
00113       if (target->value.s_val == NULL)
00114         return nil;
00115       return atoi(target->value.s_val);
00116   
00117     case (VARIANT_TIMESTAMP):
00118       return (int)target->value.ts_val;
00119     
00120   }
00121   
00122   return nil;
00123 }

const char* variant_get_str	(	variant_t *	target,
		const char *	nil
	)

Definition at line 42 of file variant.c.

References variant_t::b_val, variant_t::i_val, MAX_INT, MIN_INT, NULL, variant_t::s_val, variant_t::ts_val, variant_t::type, variant_t::value, VARIANT_BOOL, variant_get_str(), VARIANT_INT, variant_set_str(), VARIANT_STRING, and VARIANT_TIMESTAMP.

Referenced by variant_get_str().

00043 {
00044   switch (target->type) {
00045 
00046     case (VARIANT_STRING):
00047     {
00048       return target->value.s_val;
00049     }
00050 
00051     case (VARIANT_INT):
00052     {
00053       char buf[32];
00054       
00055       if (target->value.i_val == MIN_INT || target->value.i_val == MAX_INT)
00056         return NULL;
00057 
00058       snprintf(buf, sizeof(buf), "%d", target->value.i_val);
00059       variant_set_str(target, buf);
00060       return variant_get_str(target, buf);
00061     }
00062     
00063     case (VARIANT_BOOL):
00064     {
00065       variant_set_str(target, target->value.b_val ? "yes" : "no");
00066       return variant_get_str(target, NULL);
00067     }
00068 
00069     case (VARIANT_TIMESTAMP):
00070     {
00071       char buf[32];
00072   
00073       if (target->value.ts_val == (time_t)0)
00074         return NULL;
00075 
00076       snprintf(buf, sizeof(buf), "%li", target->value.ts_val);
00077       variant_set_str(target, buf);
00078       return variant_get_str(target, buf);
00079     }
00080 
00081   }
00082 
00083   return NULL;
00084 }

time_t variant_get_ts	(	variant_t *	target,
		time_t	nil
	)

Definition at line 189 of file variant.c.

References variant_t::s_val, variant_t::ts_val, variant_t::type, variant_t::value, VARIANT_BOOL, VARIANT_INT, VARIANT_STRING, and VARIANT_TIMESTAMP.

00190 {
00191   switch (target->type) {
00192   
00193     case (VARIANT_INT):
00194       return nil;
00195 
00196     case (VARIANT_BOOL):
00197       return nil;
00198     
00199     case (VARIANT_STRING):
00200       return (time_t)atof(target->value.s_val);
00201   
00202     case (VARIANT_TIMESTAMP):
00203       return target->value.ts_val;
00204     
00205   }
00206   
00207   return nil;
00208 }

void variant_set_bool	(	variant_t *	target,
		int	value
	)

Definition at line 125 of file variant.c.

References variant_t::b_val, variant_t::s_val, variant_t::type, variant_t::value, VARIANT_BOOL, and VARIANT_STRING.

00126 {
00127   if (target->type == VARIANT_BOOL) {
00128     target->value.b_val = value;
00129     return;
00130   }
00131 
00132   /* string is the only type which needs to be freed */
00133   if (target->type == VARIANT_STRING) {
00134     if (target->value.s_val) free(target->value.s_val);
00135   }
00136 
00137   /* normalize to 0 or 1 */
00138   target->value.b_val = (value) ? 0 : 1;
00139   target->type = VARIANT_BOOL;
00140 }

void variant_set_int	(	variant_t *	target,
		int	value
	)

Definition at line 86 of file variant.c.

References variant_t::i_val, variant_t::s_val, variant_t::type, variant_t::value, VARIANT_INT, and VARIANT_STRING.

00087 {
00088   if (target->type == VARIANT_INT) {
00089     target->value.i_val = value;
00090     return;
00091   }
00092 
00093   /* string is the only type which needs to be freed */
00094   if (target->type == VARIANT_STRING) {
00095     if (target->value.s_val) free(target->value.s_val);
00096   }
00097 
00098   target->value.i_val = value;
00099   target->type = VARIANT_INT; 
00100 }

void variant_set_str	(	variant_t *	target,
		const char *	value
	)

Definition at line 31 of file variant.c.

References NULL, variant_t::s_val, str_redup(), variant_t::type, variant_t::value, and VARIANT_STRING.

Referenced by variant_get_str().

00032 {
00033   if (target->type == VARIANT_STRING) {
00034     str_redup(&target->value.s_val, value);
00035     return;
00036   }
00037 
00038   target->value.s_val = (value) ? strdup(value) : NULL;
00039   target->type = VARIANT_STRING;
00040 }

void variant_set_ts	(	variant_t *	target,
		time_t	value
	)

Definition at line 171 of file variant.c.

References NULL, variant_t::s_val, variant_t::ts_val, variant_t::type, variant_t::value, VARIANT_STRING, and VARIANT_TIMESTAMP.

00172 {
00173   if (target->type == VARIANT_TIMESTAMP) {
00174     target->value.ts_val = value;
00175     return;
00176   }
00177 
00178   /* string is the only type which needs to be freed */
00179   if (target->type == VARIANT_STRING) {
00180     if (target->value.s_val)
00181        free(target->value.s_val);
00182     target->value.s_val = NULL;
00183   }
00184 
00185   target->value.ts_val = value;
00186   target->type = VARIANT_TIMESTAMP; 
00187 }

Variable Documentation

const char rcsid[] = "$Id: variant.c,v 1.2 2004-06-30 17:07:20 wingman Exp $" [static]

Definition at line 21 of file variant.c.


Functions
void	variant_set_str (variant_t target, const char value)
const char *	variant_get_str (variant_t target, const char nil)
void	variant_set_int (variant_t *target, int value)
int	variant_get_int (variant_t *target, int nil)
void	variant_set_bool (variant_t *target, int value)
int	variant_get_bool (variant_t *target, int nil)
void	variant_set_ts (variant_t *target, time_t value)
time_t	variant_get_ts (variant_t *target, time_t nil)
Variables
static const char	rcsid [] = "$Id: variant.c,v 1.2 2004-06-30 17:07:20 wingman Exp $"