#pragma interface
#ifndef TLMPLIB_H
#define TLMPLIB_H

#include <stdio.h>

#define _TLMP_tlmpprogram ___v1

struct _F_tlmpprogram{
	#define _F_tlmpprogram_usage(x) void x usage()
	virtual _F_tlmpprogram_usage( )=0;
	#define _F_tlmpprogram_onearg(x) int x onearg(const char *opt, const char *val)
	virtual _F_tlmpprogram_onearg( );
	#define _F_tlmpprogram_main(x) int x main(int argc, char *argv[])
	virtual _F_tlmpprogram_main( );
	#define _F_tlmpprogram_showerror(x) void x showerror(const char *msg)
	virtual _F_tlmpprogram_showerror( );
	#define _F_tlmpprogram_main_noarg(x) int x main_noarg()
	virtual _F_tlmpprogram_main_noarg( );
};
class SSTRING;
class SSTRINGS;

struct _F_tlmpprogram___v0{
	class _F_tlmpprogram___v0_private *priv;
	void setarg (const char letter, const char *name, const char *desc, const char *&val, bool mandatory);
	void setarg (const char letter, const char *name, const char *desc, SSTRING &val, bool mandatory);
	void setarg (const char letter, const char *name, const char *desc, SSTRINGS &vals, bool mandatory);
	void setarg (const char letter, const char *name, const char *desc, int &val, bool mandatory);
	void setarg (const char letter, const char *name, const char *desc, bool &val, bool mandatory);
	void setproginfo (const char *name, const char *version, const char *desc);
	void setproginfo (const char *name, int version, int release, const char *desc);
	void setdbconfname (const char *dbname);
	void setgrouparg (const char *descrip);
};


struct _F_tlmpprogram___v1: public _F_tlmpprogram___v0{
	bool opt_was_set (const char *optname);
	#define _F_tlmpprogram___v1_init(x) void x init()
	virtual _F_tlmpprogram___v1_init( );
	#define _F_tlmpprogram___v1_usage(x) void x usage()
	virtual _F_tlmpprogram___v1_usage( );
	#define _F_tlmpprogram___v1_onearg(x) int x onearg(const char *opt, const char *val)
	virtual _F_tlmpprogram___v1_onearg( );
	#define _F_tlmpprogram___v1_main(x) int x main(int argc, char *argv[])
	virtual _F_tlmpprogram___v1_main( );
	#define _F_tlmpprogram___v1_showerror(x) void x showerror(const char *msg)
	virtual _F_tlmpprogram___v1_showerror( );
	#define _F_tlmpprogram___v1_main_noarg(x) int x main_noarg()
	virtual _F_tlmpprogram___v1_main_noarg( );
};

#include <sys/types.h>

#define _TLMP_loadfile	__v1

struct _F_loadfile{
	class _F_loadfile_private *priv;
	#define _F_loadfile_oneline(x) int x oneline(const char *line, off_t filepos, int noline)
	virtual _F_loadfile_oneline( )=0;
	#define _F_loadfile_start(x) void x start()
	virtual _F_loadfile_start( );
	#define _F_loadfile_end(x) void x end(off_t filepos)
	virtual _F_loadfile_end( );
	#define _F_loadfile_empty(x) void x empty()
	virtual _F_loadfile_empty( );
	#define _F_loadfile_missing(x) void x missing(const char *fname)
	virtual _F_loadfile_missing( );
};

struct LOADFILE_INFO {
	const char *filename;
};

struct _F_loadfile__v1{
	class _F_loadfile_private *priv;
	#define _F_loadfile__v1_oneline(x) int x oneline(const char *line, off_t filepos, int noline, const LOADFILE_INFO &info)
	virtual _F_loadfile__v1_oneline( )=0;
	#define _F_loadfile__v1_start(x) void x start(const LOADFILE_INFO &info)
	virtual _F_loadfile__v1_start( );
	#define _F_loadfile__v1_end(x) void x end(off_t filepos, const LOADFILE_INFO &info)
	virtual _F_loadfile__v1_end( );
	#define _F_loadfile__v1_empty(x) void x empty(const LOADFILE_INFO &info)
	virtual _F_loadfile__v1_empty( );
	#define _F_loadfile__v1_missing(x) void x missing(const char *fname)
	virtual _F_loadfile__v1_missing( );
};

#define _TLMP_loadfile_csv

struct _F_loadfile_csv {
	class _F_loadfile_csv_private *priv;
	#define _F_loadfile_csv_oneline(x) int x oneline(const char *line, const char *fields[], int nbfields, off_t filepos, int noline, const LOADFILE_INFO &info, bool &end)
	virtual _F_loadfile_csv_oneline( )=0;
	#define _F_loadfile_csv_start(x) void x start(const LOADFILE_INFO &info)
	virtual _F_loadfile_csv_start( );
	#define _F_loadfile_csv_end(x) void x end(off_t filepos, const LOADFILE_INFO &info)
	virtual _F_loadfile_csv_end( );
	#define _F_loadfile_csv_empty(x) void x empty(const LOADFILE_INFO &info)
	virtual _F_loadfile_csv_empty( );
	#define _F_loadfile_csv_missing(x) void x missing(const char *fname)
	virtual _F_loadfile_csv_missing( );
};

#define _TLMP_savefile

struct _F_savefile{
	class _F_savefile_private *priv;
	#define _F_savefile_dowrite(x) int x dowrite(FILE *fout, const char *fname)
	virtual _F_savefile_dowrite( )=0;
	#define _F_savefile_openfail(x) void x openfail(const char *fname)
	virtual _F_savefile_openfail( );
	#define _F_savefile_end(x) void x end(FILE *fout, const char *fname)
	virtual _F_savefile_end( );
	#define _F_savefile_start(x) void x start(FILE *fout, const char *fname)
	virtual _F_savefile_start( );
};

#define _TLMP_walkpopen __v1

class POPEN;

struct _F_walkpopen__v1{
	class _F_walkpopen__v1_private *priv;
	void close_input();
	#define _F_walkpopen__v1_oneline(nom) int nom oneline (const char *line, int noline, FILE *fout)
	virtual _F_walkpopen__v1_oneline( ) = 0;
	#define _F_walkpopen__v1_oneerr(nom) int nom oneerr (const char *line, const char *command, FILE *fout)
	virtual _F_walkpopen__v1_oneerr( );
	#define _F_walkpopen__v1_empty(nom) void nom empty (const char *command)
	virtual _F_walkpopen__v1_empty( );
	#define _F_walkpopen__v1_start(nom) void nom start (FILE *fout, bool &end)
	virtual _F_walkpopen__v1_start( );
	#define _F_walkpopen__v1_end(nom) void nom end ()
	virtual _F_walkpopen__v1_end( );
	#define _F_walkpopen__v1_fail(nom) void nom fail (const char *command)
	virtual _F_walkpopen__v1_fail( );
	#define _F_walkpopen__v1_init(nom) void nom init (FILE *fout, bool &end)
	virtual _F_walkpopen__v1_init( );
	#define _F_walkpopen__v1_wait(nom) int nom wait (POPEN &pop, int timeout, bool &end)
	virtual _F_walkpopen__v1_wait( );
};

struct _F_walkpopen{
	class _F_walkpopen_private *priv;
	void close_input();
	#define _F_walkpopen_oneline(nom) int nom oneline (const char *line, int noline, FILE *fout)
	virtual _F_walkpopen_oneline( ) = 0;
	#define _F_walkpopen_oneerr(nom) int nom oneerr (const char *line, const char *command, FILE *fout)
	virtual _F_walkpopen_oneerr( );
	#define _F_walkpopen_empty(nom) void nom empty (const char *command)
	virtual _F_walkpopen_empty( );
	#define _F_walkpopen_start(nom) void nom start (FILE *fout, bool &end)
	virtual _F_walkpopen_start( );
	#define _F_walkpopen_end(nom) void nom end ()
	virtual _F_walkpopen_end( );
	#define _F_walkpopen_fail(nom) void nom fail (const char *command)
	virtual _F_walkpopen_fail( );
	#define _F_walkpopen_init(nom) void nom init (FILE *fout, bool &end)
	virtual _F_walkpopen_init( );
};

#define _TLMP_walkfs

struct _F_walkfs{
	class _F_walkfs_private *priv;
	void end();
	#define _F_walkfs_onefile(nom) void nom onefile(const char *path, const char *basename, const char *relpath, int depth)
	virtual _F_walkfs_onefile( )=0;
	#define _F_walkfs_recurse(nom) bool nom recurse(const char *dir, const char *basename, const char *relpath, int depth)
	virtual _F_walkfs_recurse( );
};

#define _TLMP_copyfile

struct _F_copyfile{
	class _F_copyfile_private *priv;
	#define _F_copyfile_progress(x) void x progress(const char *src, const char *dst, size_t size, size_t sofar, bool &end)
	virtual _F_copyfile_progress( );
	#define _F_copyfile_fail(x) void x fail(const char *src, const char *dst, const char *details)
	virtual _F_copyfile_fail( );
};

#define _TLMP_sort
class ARRAY_OBJ;

struct _F_sort {
	#define _F_sort_cmp(x) int x cmp (const ARRAY_OBJ *o1, const ARRAY_OBJ *o2)
	virtual _F_sort_cmp( )=0;
};

#define _TLMP_OBJECTSUB


struct _F_OBJECTSUB{
	#define _F_OBJECTSUB_exec(nom) void nom exec()
	virtual _F_OBJECTSUB_exec( )=0;
};

class OBJECTSUB{
	_F_OBJECTSUB *c;
	/*~PROTOBEG~ OBJECTSUB */
public:
	OBJECTSUB (_F_OBJECTSUB&_c);
	void exec (void);
	/*~PROTOEND~ OBJECTSUB */
};

// Buffer holding bytes later processed by the process functag
class STREAMP_BUF{
	friend class STREAMP;
	char *buf;
	int bufsize;	// Size of buf, how much was malloced
	int offset;		// Offset of the first available byte in buf
	int last;		// Last byte available in buf
	int bufincr;	// How to enlarge the buffer
	/*~PROTOBEG~ STREAMP_BUF */
public:
	STREAMP_BUF (int _bufsize, int incr);
	STREAMP_BUF (void);
	void checkalloc (int len);
	const char *getbytes (void);
	char *getinputbuf (void);
	int getnbbytes (void);
	int getspace (void)const;
private:
	void init (int size, int incr);
public:
	bool isempty (void)const;
	void pack (bool force);
	void pack (void);
	void reset (void);
	void setadded (int len);
	void setused (int len);
	~STREAMP_BUF (void);
	/*~PROTOEND~ STREAMP_BUF */
};

#define _TLMP_STREAMP

struct _F_STREAMP {
	class STREAMP_PRIVATE *priv;
	void reset();
	#define _F_STREAMP_fill(nom) int nom fill(void *buf, int size, bool &end)
	virtual _F_STREAMP_fill( );
	#define _F_STREAMP_process(nom) int nom process(const void *buf, int len, bool &end, bool nomore)
	virtual _F_STREAMP_process( );
	#define _F_STREAMP_validrecord(nom) int nom validrecord(const void *buf, int len, bool &end, bool nomore)
	virtual _F_STREAMP_validrecord( );
};

class STREAMP{
	class STREAMP_PRIVATE *priv;
	/*~PROTOBEG~ STREAMP */
public:
	STREAMP (_F_STREAMP&c);
	void eof (void);
	int fill (void *buf, int len);
	int getrecord (void *buf, int size);
	void loop (void);
private:
	void pack (void);
public:
	~STREAMP (void);
	/*~PROTOEND~ STREAMP */
};

#define _TLMP_streamp

class _F_streamp {
public:
	class _F_streamp_private *priv;
	void reset();
	#define _F_streamp_fill(nom) int nom fill(void *buf, int size, bool &end)
	virtual _F_streamp_fill( )=0;
	#define _F_streamp_process(nom) int nom process(const void *buf, int len, bool &end, bool nomore)
	virtual _F_streamp_process( )=0;
};

#define _TLMP_streamp_do

class _F_streamp_do {
public:
	class _F_streamp_do_private *priv;
	void reset();
	#define _F_streamp_do_process(nom) int nom process(const void *buf, int len, bool &end)
	virtual _F_streamp_do_process( )=0;
};

class ERROR_PREFIX{
	class ERROR_PREFIX_PRIVATE *priv;
	/*~PROTOBEG~ ERROR_PREFIX */
public:
	ERROR_PREFIX (const char *ctl, ...);
	~ERROR_PREFIX (void);
	/*~PROTOEND~ ERROR_PREFIX */
};


#define _TLMP_COROUTINE

struct _F_COROUTINE{
	class _F_COROUTINE_private *priv;
	int yield();
	#define _F_COROUTINE_run(x) void x run()
	virtual _F_COROUTINE_run( )=0;
};

class COROUTINE{
	class _F_COROUTINE_private *priv;
	/*~PROTOBEG~ COROUTINE */
public:
	COROUTINE (_F_COROUTINE&c);
	bool is_done (void)const;
	bool is_idle (void)const;
	bool is_running (void)const;
	bool next (void);
	void restart (void);
	void stop (void);
	~COROUTINE (void);
	/*~PROTOEND~ COROUTINE */
};

class TRANS_NOTLOAD;

class DEBUG_KEY{
	class DEBUG_KEY_private *priv;
	/*~PROTOBEG~ DEBUG_KEY */
public:
	DEBUG_KEY (const char *key, const char *desc);
	const char *getdesc (void)const;
	const char *getkey (void)const;
	DEBUG_KEY *getnext (void)const;
	~DEBUG_KEY (void);
	/*~PROTOEND~ DEBUG_KEY */
};

class DEBUG_CONTEXT{
private:
	class DEBUG_CONTEXT_private *priv;
	/*~PROTOBEG~ DEBUG_CONTEXT */
public:
	DEBUG_CONTEXT (const DEBUG_KEY&key);
	DEBUG_CONTEXT (const char *ctl, ...);
	~DEBUG_CONTEXT (void);
	/*~PROTOEND~ DEBUG_CONTEXT */
};

// Command line option defined anywhere in a program, not
// via the tlmpprogram::setarg() function.
class TLMP_OPTION{
	class TLMP_OPTION_private *priv;
	/*~PROTOBEG~ TLMP_OPTION */
public:
	TLMP_OPTION (const char *optname,
		 TRANS_NOTLOAD *optdesc);
	TLMP_OPTION (const char *optname,
		 TRANS_NOTLOAD *optdesc,
		 SSTRING&s);
	TLMP_OPTION (const char *optname,
		 TRANS_NOTLOAD *optdesc,
		 SSTRINGS&s);
	TLMP_OPTION (const char *optname,
		 TRANS_NOTLOAD *optdesc,
		 int &s);
	TLMP_OPTION (const char *optname,
		 TRANS_NOTLOAD *optdesc,
		 int (*fct)());
	TLMP_OPTION (const char *optname,
		 TRANS_NOTLOAD *optdesc,
		 int (*fct)(const char *));
	const char *getdesc (void)const;
	const char *getname (void)const;
	TLMP_OPTION *getnext (void)const;
	bool ison (void)const;
	bool needval (void)const;
	int setval (const char *val);
	~TLMP_OPTION (void);
	/*~PROTOEND~ TLMP_OPTION */
};


class SSTREAM;
class ARRAY;
class CONFIG_FILE;

#include "tlmplib.p"

#endif