package t_tsenum;

use strict;

use vars qw(@ISA);

require t_template;

require t_enum;

@ISA=qw(t_template);

my @parms = qw(NAME TYPE COMPARE COPY PRINT);

my %defaults = ( "COPY", "0", "PRINT", "0" );

my @templatelines = <DATA>;

sub new { # no args

    my $self = {};

    bless $self;

    $self->init(\@parms, \%defaults, \@templatelines);

    return $self;

}

sub output {

    my ($self, $fh) = @_;

    my $a = new t_enum;

    $a->setparm("NAME", $self->{values}{"NAME"} . "__unsafe_enumerator");

    $a->setparm("TYPE", $self->{values}{"TYPE"});

    $a->setparm("COMPARE", $self->{values}{"COMPARE"});

    $a->output($fh);

    $self->SUPER::output($fh);

}

1;

__DATA__

/*

 */

#include "k5-thread.h"

struct <NAME>__ts_enumerator {

    <NAME>__unsafe_enumerator e;

    k5_mutex_t m;

};

typedef struct <NAME>__ts_enumerator <NAME>;

static inline int

<NAME>_init(<NAME> *en)

{

    int err = k5_mutex_init(&en->m);

    if (err)

	return err;

    err = <NAME>__unsafe_enumerator_init(&en->e);

    if (err) {

	k5_mutex_destroy(&en->m);

	return err;

    }

    return 0;

}

static inline int

<NAME>_size(<NAME> *en, long *size)

{

    int err = k5_mutex_lock(&en->m);

    if (err) {

	*size = -48;

	return err;

    }

    *size = <NAME>__unsafe_enumerator_size(&en->e);

    k5_mutex_unlock(&en->m);

    return 0;

}

static inline int

<NAME>__do_copy (<TYPE> *dest, <TYPE> src)

{

    int (*copyfn)(<TYPE>*, <TYPE>) = <COPY>;

    if (copyfn)

	return copyfn(dest, src);

    *dest = src;

    return 0;

}

static inline int

<NAME>_find_or_append(<NAME> *en, <TYPE> value, long *idxp, int *added)

{

    int err;

    long idx;

    err = k5_mutex_lock(&en->m);

    if (err)

	return err;

    idx = <NAME>__unsafe_enumerator_find(&en->e, value);

    if (idx < 0) {

	<TYPE> newvalue;

	err = <NAME>__do_copy(&newvalue, value);

	if (err == 0)

	    idx = <NAME>__unsafe_enumerator_append(&en->e, newvalue);

	k5_mutex_unlock(&en->m);

	if (err != 0)

	    return err;

	if (idx < 0)

	    return ENOMEM;

	*idxp = idx;

	*added = 1;

	return 0;

    }

    k5_mutex_unlock(&en->m);

    *idxp = idx;

    *added = 0;

    return 0;

}

static inline int

<NAME>_get(<NAME> *en, size_t idx, <TYPE> *value)

{

    int err;

    err = k5_mutex_lock(&en->m);

    if (err)

	return err;

    *value = <NAME>__unsafe_enumerator_get(&en->e, idx);

    k5_mutex_unlock(&en->m);

    return 0;

}

static inline void

<NAME>_destroy(<NAME> *en)

{

    k5_mutex_destroy(&en->m);

    <NAME>__unsafe_enumerator_destroy(&en->e);

}

static inline int

<NAME>_foreach(<NAME> *en, int (*fn)(size_t i, <TYPE> t, void *p), void *p)

{

    int err = k5_mutex_lock(&en->m);

    if (err)

	return err;

    <NAME>__unsafe_enumerator_foreach(&en->e, fn, p);

    k5_mutex_unlock(&en->m);

    return 0;

}

static inline int

<NAME>__print_map_elt(size_t idx, <TYPE> val, void *p)

{

    void (*printfn)(<TYPE>, FILE *) = <PRINT>;

    FILE *f = (FILE *) p;

    if (printfn) {

	fprintf(f, " %lu=", (unsigned long) idx);

	printfn(val, f);

    }

    return 0;

}

static inline void

<NAME>_print(<NAME> *en, FILE *f)

{

    void (*printfn)(<TYPE>, FILE *) = <PRINT>;

    if (printfn) {

	fprintf(f, "{");

	<NAME>_foreach (en, <NAME>__print_map_elt, f);

	fprintf(f, " }");

    }

}