#ifndef __DAPIC_H_
#define __DAPIC_H_

/**
 *@file
 * Hlavni include soubor pro DapiC.
 */

#include "types.h"

/* defines */

#ifdef WIN32
	#include <winsock2.h>
	#include <windows.h>

	#ifdef DAPIC_LIBRARY_EXPORTS
		#define DLLEXPORT extern __declspec(dllexport)
	#else 
		#define DLLEXPORT extern __declspec(dllimport)
	#endif
#else
	#define DLLEXPORT extern
#endif

/* special timeout specifications */
#define	TIMEOUT_INFINITE	-1
#define TIMEOUT_DEFAULT		-2

/* error code specification */
#define ERROR_DAPIC			-1
#define ERROR_BACKEND		-2


#ifdef __cplusplus
extern "C" {
#endif


/* forwards */
struct _DAPIC_HCLIENT_STR;
struct _DAPIC_HDAPI_STR;
struct _DAPIC_HPRMSET_STR;
struct _DAPIC_HRSROW_STR;

/** typedefs and structures **/

/**
 * Handle object na clienta.
 * Poskytuje type-safety pro handly.
 */
typedef struct _DAPIC_HCLIENT_STR *DAPIC_HCLIENT;

/**
 * Handle object na dapi.
 * Poskytuje type-safety pro handly.
 */
typedef struct _DAPIC_HDAPI_STR *DAPIC_HDAPI;

/**
 * Handle object na parameter set.
 * Poskytuje type-safety pro handly.
 */
typedef struct _DAPIC_HPRMSET_STR *DAPIC_HPRMSET;

/**
 * Handle object na rs row.
 * Poskytuje type-safety pro handly.
 */
typedef struct _DAPIC_HRSROW_STR *DAPIC_HRSROW;

/**
 * Zavaznost chyby 
 */
typedef enum _DAPIC_SEVERITY {
	DAPIC_SEV_FATAL,
	DAPIC_SEV_ERROR,
	DAPIC_SEV_WARNING,
	DAPIC_SEV_INFO
} DAPIC_SEVERITY;

/**
 * Struktura pro predani popisu chyby klientovi knihovny
 */
typedef struct _DAPIC_ERRORINFO {

	/* jednoznacne ID chyby */
	char msgID[11];

	/* zavaznost chyby */
	DAPIC_SEVERITY severity;

	/* popis s konkretnimi parametry situace */
	char *detailMsg;

	/* odkaz na dalsi errorInfo, ktere bylo pricinou teto chyby */
	struct _DAPIC_ERRORINFO *cause;

} DAPIC_ERRORINFO;

/**
 * Typ definujici prototyp funkce, kterou je mozne pouzit 
 * jako handler pro unexpected-message eventy. Jako parametry dostava 
 * identifikator MQ zpravy, ktera udalost vyvolala, a ukazatel na context, 
 * ktery byl predan pri nastaveni listenera.
 */
typedef int (*DAPIC_EVENTLISTENER)(const char *, void *);

/**
 * Typ definujici prototyp funkce, kterou je mozne pouzit 
 * jako handler pro enhanced unexpected-message eventy. Jako parametry dostava 
 * nazev spravce front, nazev fronty, identifikator MQ zpravy, ktera udalost vyvolala, 
 * vybrane udaje ze zahlavi zpravy a ukazatel na context, 
 * ktery byl predan pri nastaveni listenera.
 */
typedef int (*DAPIC_ENHANCED_EVENTLISTENER)(const char* queueManagerName,
			const char* queueName, const char* correlationId, const char* systemId,
			const char* applicationId, const char* functionId, const char* functionVersion, void* ctx);

/**
 * Smer parametru (in/out).
 */
typedef enum DAPIC_PARAMDIR {
	DAPIC_DIRIN,
	DAPIC_DIROUT
} DAPIC_PARAMDIR;

/**
 * Popis parametru.
 * Default value je ukazatel na typ, ktery odpovida typu parametru,
 * tedy napr. na DapiInteger, nebo DapiChar. V pripade bytes a stringu
 * je defaultValueLength rovna delce pole, ktere urcuje defaultValue. 
 * U ostatnich typu je nastavena na 0.
 * 
 * Tvori spojovy seznam pomoci 'next'.
 */
typedef struct DAPIC_PARAMDEF {
	const char *name;
	DAPIC_PARAMTYPE type;
	DAPIC_PARAMDIR direction;
	int required;
	const void *defaultValue;
	size_t defaultValueLenght;
	const char *description;

	struct DAPIC_PARAMDEF *next;
} DAPIC_PARAMDEF;

/**
 * Popis parametru paramsetu.
 * 
 * Tvori spojovy seznam pomoci 'next'.
 */
typedef struct DAPIC_PARAMSETDEF {
	char *name;
    DAPIC_PARAMDEF *paramdef;
	struct DAPIC_PARAMSETDEF *next;
} DAPIC_PARAMSETDEF;


/** functions **/

/**
 * Call-once funkce, ktera inicializuje knihovnu.
 * Musi byt zavolana jako prvni funkce z DapiC knihovny.
 */
DLLEXPORT
int dapic_init(void);

/**
 * Inicializace Dapi clienta podle konfigurace.
 * Nacte konfiguraci a podle ni zinicializizuje klienta.
 *@param	configFile	nazev souboru s konfiguraci
 *@return	Platny handle pri uspechu, NULL pri chybe. 
 *			Pri chybe v teto funkci je mozne pouzit funkce dapic_getLastError
 *			pro zjisteni podrobnosti o chybe s argumentem NULL.
 */
DLLEXPORT
DAPIC_HCLIENT dapic_initClient(const char *configFile);


/**
 * Inicializace Dapi clienta podle konfigurace.
 * Nacte konfiguraci a podle ni zinicializizuje klienta.
 *@param	configFile	nazev souboru s konfiguraci
 *@param    systemType  pouzity pri registraci do TIF topologie
 *@return	Platny handle pri uspechu, NULL pri chybe. 
 *			Pri chybe v teto funkci je mozne pouzit funkce dapic_getLastError
 *			pro zjisteni podrobnosti o chybe s argumentem NULL.
 */
DLLEXPORT
DAPIC_HCLIENT dapic_initClientSystemType(const char *configFile, const char* systemType);

/**
 * Nastavi jmeno uzivatele, v jehoz kontextu se ma backendova akce provest. 
 * Jedna se o uzivatelske jmeno, pod kterym se uzivatel loguje do klientske 
 * aplikace. Nemusi se nastavovat, muze se pouzit default z konfigurace.
 */
DLLEXPORT
int dapic_setClientClientUserName(DAPIC_HCLIENT hClient, const char *clientUserName);

/**
 * Vrati jmeno uzivatele, v jehoz kontextu se ma backendova akce provest. 
 * Jedna se o uzivatelske jmeno, pod kterym se uzivatel loguje do klientske 
 * aplikace.
 */
DLLEXPORT
int dapic_getClientClientUserName(DAPIC_HCLIENT hClient, const char **clientUserName);

/**
 * Nastavi jmeno uzivatele, v jehoz kontextu se ma backendova akce provest. 
 * Jedna se o uzivatelske jmeno, pod kterym se uzivatel loguje do serverove 
 * aplikace. Nemusi se nastavovat, muze se pouzit default z konfigurace.
 */
DLLEXPORT
int dapic_setClientServerUserName(DAPIC_HCLIENT hClient, const char *serverUserName);

/**
 * Vrati jmeno uzivatele, v jehoz kontextu se ma backendova akce provest. 
 * Jedna se o uzivatelske jmeno, pod kterym se uzivatel loguje do serverove 
 * aplikace.
 */
DLLEXPORT
int dapic_getClientServerUserName(DAPIC_HCLIENT hClient, const char **serverUserName);

/**
 * Nastavi appID front-end aplikace, ktera odesila pozadavek. Zapisuje se do headeru FE_APP_ID.
 */
DLLEXPORT
int dapic_setOriginatingAppID(DAPIC_HCLIENT hClient, const char *appID);

/**
 * Vraci appID front-end aplikace, ktera odesila pozadavek. Pokud neni
 * nastaveno, vraci normalni appID.
 */
DLLEXPORT
int dapic_getOriginatingAppID(DAPIC_HCLIENT hClient, const char **appID);

/**
 * Nastavi sysID front-end systemu, ktery odesila pozadavek. Zapisuje se
 * do headeru FE_SYS_ID.
 */
DLLEXPORT
int dapic_setOriginatingSysID(DAPIC_HCLIENT hClient, const char *sysID);

/**
 * Vraci sysID front-end systemu, ktery odesila pozadavek. Pokud neni
 * nastaveno, vraci normalni sysID.
 */
DLLEXPORT
int dapic_getOriginatingSysID(DAPIC_HCLIENT hClient, const char **sysID);

/**
 * Nastavi suffix generovaneho operation ID.
 */
DLLEXPORT
int dapic_setOriginatingOperationID(DAPIC_HCLIENT hClient, const char *operationID);

/**
 * Vraci suffix generovaneho operation ID.
 */
DLLEXPORT
int dapic_getOriginatingOperationID(DAPIC_HCLIENT hClient, const char **operationID);

/**
 * Vytvori strukturu pro sestaveni pozadavku pro danou funkci.
 *@return	platny handle	pri uspechu, nebo
 *			NULL			pokud pro dane jmeno nelze nalezt nebo 
 *							nacist definici API.
 */
DLLEXPORT
DAPIC_HDAPI dapic_createDapi(DAPIC_HCLIENT hClient,
							 const char *system,
							 const char *name, const char *version);


/* Nasleduje blok funkci, ktere umoznuji zjistit a nastavit vlastnosti daneho Dapi. */

/**
 * Vraci pointer na buffer obsahujici ID pozadavku, ktere se pouzije 
 * jako ID MQ zpravy s pozadavkem. Vraceny buffer nesmi volajici dealokovat,
 * pamet patri knihovne.
 */
DLLEXPORT
int dapic_getDapiMessageID(DAPIC_HDAPI hDapi, const char **msgID);

/**
 * Vraci jmeno Dapi. Vraceny buffer nesmi volajici dealokovat,
 * pamet patri knihovne.
 */
DLLEXPORT
int dapic_getDapiName(DAPIC_HDAPI hDapi, const char **dapiName);

/**
 * Vraci do promenne flag hodnotu 1, pokud je vyzadovana odpoved na pozadavek,
 * 0 pokud neni.
 */
DLLEXPORT
int dapic_isDapiReplyRequired(DAPIC_HDAPI hDapi, int *flag);

/**
 * Vraci do promenne timeout delku timeoutu pro odpoved v sekundach.
 */
DLLEXPORT
int dapic_getDapiTimeout(DAPIC_HDAPI hDapi, long *timeout);

/**
 * Do promenne flag vrati 1, pokud pri zpracovani pozadavku na backendu
 * byl vydan warning.
 */
DLLEXPORT
int dapic_isDapiWarningIssued(DAPIC_HDAPI hDapi, int *flag);

/**
 * Do promenne code vrati pointer na WarningCode, pokud pri zpracovani pozadavku 
 * na backendu byl vydan warning, jinak nastavi code na NULL.
 */
DLLEXPORT
int dapic_getDapiWarningCode(DAPIC_HDAPI hDapi, const char **code);

/**
 * Do promenne message vrati pointer na WarningMessage, pokud pri zpracovani pozadavku 
 * na backendu byl vydan warning, jinak nastavi message na NULL.
 */
DLLEXPORT
int dapic_getDapiWarningMessage(DAPIC_HDAPI hDapi, const char **message);

/**
 * Do promenne flag vrati 1, pokud pri zpracovani pozadavku na backendu
 * byla vydana chyba (return code 8).
 */
DLLEXPORT
int dapic_isDapiErrorIssued(DAPIC_HDAPI hDapi, int *flag);

/**
 * Do promenne flag vrati 1, pokud pri zpracovani pozadavku na backendu
 * byla vydana fatalni chyba (return code C).
 */
DLLEXPORT
int dapic_isDapiFatalErrorIssued(DAPIC_HDAPI hDapi, int *flag);

/**
 * Do promenne code vrati pointer na ErrorCode, pokud pri zpracovani pozadavku 
 * na backendu nastala chyba, jinak nastavi code na NULL.
 */
DLLEXPORT
int dapic_getDapiErrorCode(DAPIC_HDAPI hDapi, const char **code);

/**
 * Do promenne message vrati pointer na ErrorMessage, pokud pri zpracovani pozadavku 
 * na backendu nastala chyba, jinak nastavi message na NULL.
 */
DLLEXPORT
int dapic_getDapiErrorMessage(DAPIC_HDAPI hDapi, const char **message);

/**
 * Nastavi jmeno uzivatele, v jehoz kontextu se ma backendova akce provest. 
 * Jedna se o uzivatelske jmeno, pod kterym se uzivatel loguje do klientske
 * aplikace. Nastaveni pro Dapi request ma prednost pred nastavenim v klientovi.
 */
DLLEXPORT
int dapic_setDapiClientUserName(DAPIC_HDAPI hDapi, const char *clientUserName);

/**
 * Vrati jmeno uzivatele, v jehoz kontextu se ma backendova akce provest. 
 * Jedna se o uzivatelske jmeno, pod kterym se uzivatel loguje do klientske
 * aplikace. Nastaveni pro Dapi request ma prednost pred nastavenim v klientovi.
 */
DLLEXPORT
int dapic_getDapiClientUserName(DAPIC_HDAPI hDapi, const char **clientUserName);

/**
 * Nastavi jmeno uzivatele, v jehoz kontextu se ma backendova akce provest. 
 * Jedna se o uzivatelske jmeno, pod kterym se uzivatel loguje do serverove
 * aplikace. Nastaveni pro Dapi request ma prednost pred nastavenim v klientovi.
 */
DLLEXPORT
int dapic_setDapiServerUserName(DAPIC_HDAPI hDapi, const char *serverUserName);

/**
 * Vrati jmeno uzivatele, v jehoz kontextu se ma backendova akce provest.
 * Jedna se o uzivatelske jmeno, pod kterym se uzivatel loguje do serverove
 * aplikace. Nastaveni pro Dapi request ma prednost pred nastavenim v klientovi.
 */
DLLEXPORT
int dapic_getDapiServerUserName(DAPIC_HDAPI hDapi, const char **serverUserName);

/**
 * Zjistuje persistenci zpravy s pozadavkem v MQ.
 */
DLLEXPORT
int dapic_getDapiRequestPersistence(DAPIC_HDAPI hDapi, int *persistence);

/**
 * Zjistuje persistenci zpravy s odpovedi v MQ.
 */
DLLEXPORT
int dapic_getDapiResponsePersistence(DAPIC_HDAPI hDapi, int *persistence);

/**
 * Umoznuje ziskat metadata jednotlivych input parametru Dapi.
 * Do defs vraci pointer na seznam definic input parametru. 
 * Vracena pamet patri knihovne, volajici nesmi dealokovat.
 */
DLLEXPORT
int dapic_getDapiInParamDefs(DAPIC_HDAPI hDapi, DAPIC_PARAMDEF **defs);

/**
 * Umoznuje ziskat metadata jednotlivych output parametru Dapi.
 * Do defs vraci pointer na seznam definic output parametru. 
 * Vracena pamet patri knihovne, volajici nesmi dealokovat.
 */
DLLEXPORT
int dapic_getDapiOutParamDefs(DAPIC_HDAPI hDapi, DAPIC_PARAMDEF **defs);

/**
 * Vraci metadata konkretniho parametru (muze byt vstupni i vystupni).
 * Vstupni parametry jsou prohledavany drive, proto v pripade kolize 
 * jmen bude vracen vstupni parametr.
 * Do def ulozi ukazatel na strukturu parametru. 
 * Volajici nesmi vracenou pamet dealokovat.
 */
DLLEXPORT
int dapic_getDapiParamDef(DAPIC_HDAPI hDapi, const char *name, DAPIC_PARAMDEF **def);

#ifdef MSG_VER_2_ENABLED
/**
 * Umoznuje ziskat jmeno inputsetu.
 * Vracena pamet patri knihovne, volajici nesmi dealokovat.
 */
DLLEXPORT
int dapic_getDapiInputsetName(DAPIC_HDAPI hDapi, char **name);

/**
 * Umoznuje ziskat jmeno resultsetu.
 * Vracena pamet patri knihovne, volajici nesmi dealokovat.
 */
DLLEXPORT
int dapic_getDapiResultsetName(DAPIC_HDAPI hDapi, char **name);
#endif

/**
 * Umoznuje ziskat metadata jednotlivych inputset parametru Dapi.
 * Do defs vraci pointer na seznam definic inputset parametru. 
 * Vracena pamet patri knihovne, volajici nesmi dealokovat.
 */
DLLEXPORT
int dapic_getDapiInputsetParamDefs(DAPIC_HDAPI hDapi, DAPIC_PARAMDEF **defs);

/**
 * Umoznuje ziskat metadata jednotlivych resultset parametru Dapi.
 * Do defs vraci pointer na seznam definic resultset parametru. 
 * Vracena pamet patri knihovne, volajici nesmi dealokovat.
 */
DLLEXPORT
int dapic_getDapiResultsetParamDefs(DAPIC_HDAPI hDapi, DAPIC_PARAMDEF **defs);

/**
 * Funkce pro nastavovani vstupnich parametru DApi volani 
 * specifikaci konkretnich typu.
 *@param	hDapi		handle na Dapi, ve kterem se ma parametr nastavit
 *@param	name		jmeno parametru
 *@param	value		hodnota, pokud je to pointer, lze parametr nastavit na NULL, 
 *						jinak je nutne pouzit setParamNull
 *@return	0			on success, nebo
 *			-1			on error.
 */
DLLEXPORT
int dapic_setParamBool(DAPIC_HDAPI hDapi,
					   const char *name, DapiBool value);
DLLEXPORT
int dapic_setParamInteger(DAPIC_HDAPI hDapi, 
						  const char *name, DapiInteger value);
DLLEXPORT
int dapic_setParamDouble(DAPIC_HDAPI hDapi, 
						 const char *name, DapiDouble value);
DLLEXPORT
int dapic_setParamString(DAPIC_HDAPI hDapi, 
						 const char *name, const DapiChar *value);
DLLEXPORT
int dapic_setParamStringN(DAPIC_HDAPI hDapi,
						  const char *name, const DapiChar *value, 
						  size_t length);
DLLEXPORT
int dapic_setParamBytes(DAPIC_HDAPI hDapi,
						const char *name, const DapiByte *value,
						size_t length);
DLLEXPORT
int dapic_setParamDate(DAPIC_HDAPI hDapi,
					   const char *name, const DapiDate *value);
DLLEXPORT
int dapic_setParamTime(DAPIC_HDAPI hDapi,
					   const char *name, const DapiTime *value);
DLLEXPORT
int dapic_setParamDateTime(DAPIC_HDAPI hDapi,
						   const char *name, const DapiDateTime *value);
DLLEXPORT
int dapic_setParamTimestamp(DAPIC_HDAPI hDapi,
							const char *name, const DapiTimestamp *value);

/**
 * Nastavi hodnotu daneho parametru na NULL. 
 * Pokud je tento parametr 'required', pak je jeho hodnota nastavena na default.
 */
DLLEXPORT
int dapic_setParamNull(DAPIC_HDAPI hDapi, const char *name);

/**
 * Funkce pro nastavovani parametru vstupniho inputsetu.
 *@param	dapi		handle na Dapi, ve kterem se ma parametr nastavit
 *@param	row			index radky, ve ktere se ma nastavit dany parametr 
 *						(do XML se zapise primo hodnota row, ve FL zalezi pouze na poradi)
 *@param	name		jmeno parametru
 *@param	value		hodnota, pokud je to pointer, lze parametr nastavit na NULL, 
 *						jinak je nutne pouzit setRowNull
 *@return	0			on success, nebo
 *			-1			on error
 */
DLLEXPORT
int dapic_setRowBool(DAPIC_HDAPI hDapi, unsigned row, 
					 const char *name, DapiBool value);
DLLEXPORT
int dapic_setRowInteger(DAPIC_HDAPI hDapi, unsigned row, 
						const char *name, DapiInteger value);
DLLEXPORT
int dapic_setRowDouble(DAPIC_HDAPI hDapi, unsigned row, 
					   const char *name, DapiDouble value);
DLLEXPORT
int dapic_setRowString(DAPIC_HDAPI hDapi, unsigned row, 
					   const char *name, const DapiChar *value);
DLLEXPORT
int dapic_setRowStringN(DAPIC_HDAPI hDapi, unsigned row, 
						const char *name, const DapiChar *value, 
						size_t length);
DLLEXPORT
int dapic_setRowBytes(DAPIC_HDAPI hDapi, unsigned row, 
					  const char *name, const DapiByte *value, 
					  size_t length);
DLLEXPORT
int dapic_setRowDate(DAPIC_HDAPI hDapi, unsigned row, 
					 const char *name, const DapiDate *value);
DLLEXPORT
int dapic_setRowTime(DAPIC_HDAPI hDapi, unsigned row, 
					 const char *name, const DapiTime *value);
DLLEXPORT
int dapic_setRowDateTime(DAPIC_HDAPI hDapi, unsigned row, 
						 const char *name, const DapiDateTime *value);
DLLEXPORT
int dapic_setRowTimestamp(DAPIC_HDAPI hDapi, unsigned row, 
						  const char *name, const DapiTimestamp *value);

/**
 * Nastavi hodnotu daneho parametru v radce na NULL. 
 * Pokud je tento parametr 'required', pak je jeho hodnota nastavena na default.
 */
DLLEXPORT
int dapic_setRowNull(DAPIC_HDAPI hDapi, unsigned row, const char *name);

/**
 * Synchronni volani, time-out cekani na odpoved je stanoven podle 
 * konfigurace bindingu.
 *@return	0	on success (response received successfully), or
 *			>0	timed-out, or
 *			ERROR_DAPIC		on error in DapiC, or
 *			ERROR_BACKEND	on error in backend.
 */
DLLEXPORT
int dapic_callDapi(DAPIC_HDAPI hDapi);

/**
 * Asynchronni volani, neceka se na odpoved.
 *@return	0	on success (pozadavek odeslan uspesne), or
 *			-1	on error.
 */
DLLEXPORT
int dapic_putDapiRequest(DAPIC_HDAPI hDapi);

/**
 * Vyzvednuti odpovedi na odeslany pozadavek.
 *@param	timeout	max.doba cekani na odpoved v sekundach
 *			pokud je TIMEOUT_INFINITE, je nekonecny, 
 *			pokud je TIMEOUT_DEFAULT, pouzije se roundtrip_timeout definovany v Bindingu
 *@return	0	odpoved uspesne prijata, or
 *			>0	timed-out, or
 *			ERROR_DAPIC		on error in DapiC, or
 *			ERROR_BACKEND	on error in backend.
 */
DLLEXPORT
int dapic_getDapiResponse(DAPIC_HDAPI hDapi, long timeout);

/**
 * Funkce pro dotaz na hodnotu jednoduchych (non-ResultSet) vystupnich parametru 
 * DApi volani specifikaci konkretnich typu.
 *@param	hDapi				handle na Dapi, ve kterem se ma hodnota vystupniho 
 *								parametru vyhledat
 *@param	name				jmeno parametru
 *@param	value				vystupni parametr, po skonceni uspesneho volani 
 *								obsahuje hodnotu parametru, v pripade typu s fixni 
 *								velikosti (tedy krome stringu a bytu) se hodnota 
 *								zapise na misto v pameti, na ktere ukazuje parametr 
 *								value, v pripade, kdy value je dvojity pointer,
 *								se do parametru zapise adresa na misto v pameti, 
 *								kde zacina retezec znaku nebo bytu. 
 *								V zadnem pripade nesmi volajici dealokovat pamet, 
 *								na kterou dostane ukazatel. Ovsem 
 *								referencovana pamet prestane byt platne po zavolani 
 *								destroyDapi pro hDapi. Proto je doporuceno odkazovanou 
 *								pamet zkopirovat do pameti vlastnene volajicim.
 *								Pokud je hodnota parametru NULL a value neni dvojity pointer,
 *								pak do nej neni nic zapsano a navratovy kod je 1.
 *								Pokud je hodnota parametru NULL a value je dvojity pointer,
 *								pak je predana hodnota NULL a navratovy kod je 1.
 *@return	0	on success, nebo
 *			1	pokud je hodnota pozadovaneho parametru NULL, or
 *			-1	on error
 */
DLLEXPORT
int dapic_getParamBool(DAPIC_HDAPI hDapi, 
					   const char *name, DapiBool *value);
DLLEXPORT
int dapic_getParamInteger(DAPIC_HDAPI hDapi, 
						  const char *name, DapiInteger *value);
DLLEXPORT
int dapic_getParamDouble(DAPIC_HDAPI hDapi, 
						 const char *name, DapiDouble *value);
DLLEXPORT
int dapic_getParamString(DAPIC_HDAPI hDapi, 
						 const char *name, DapiChar **value);
DLLEXPORT
int dapic_getParamBytes(DAPIC_HDAPI hDapi, 
						const char *name, DapiByte **value, size_t *length);
DLLEXPORT
int dapic_getParamDate(DAPIC_HDAPI hDapi, 
					   const char *name, DapiDate *value);
DLLEXPORT
int dapic_getParamTime(DAPIC_HDAPI hDapi, 
					   const char *name, DapiTime *value);
DLLEXPORT
int dapic_getParamDateTime(DAPIC_HDAPI hDapi, 
						   const char *name, DapiDateTime *value);
DLLEXPORT
int dapic_getParamTimestamp(DAPIC_HDAPI hDapi, 
							const char *name, DapiTimestamp *value);

/**
 * Zjistuje, zda je dany vystupni parametr nastaven na NULL.
 *@return	0	parametr je nastaven, neni NULL,
 *			1	parametr ma hodnotu NULL,
 *			-1	chyba.
 */
DLLEXPORT
int dapic_isParamNull(DAPIC_HDAPI hDapi, const char *name);

/**
 * Vraci pocet radek vystupniho resultsetu
 *@return	-1		on error, nebo
 *			>=0		on success.
 */
DLLEXPORT
int dapic_getRsRowCount(DAPIC_HDAPI hDapi);

/**
 * Vytazeni radky resultsetu z odpovedi Dapi volani. Hodnoty jednotlivych 
 * parametru lze potom ziskat pomoci dalsich funkci pres vraceny 
 * handle na radku. Vraceny handle je nutne po skonceni pouzivani uvolnit 
 * pomoci releaseRsRow, jinak vznika memory leak.
 *@param	hDapi	handle na Dapi
 *@param	index	1-based index radky, o kterou ma volajici zajem
 *					u FL jsou tedy radky indexovane od 1, v XML ma cislo radky index num
 *					(num je atribut tagu row v XML)
 *@return	platny handle (non-NULL)	v pripade uspesneho vytazeni radky, nebo
 *			NULL						jinak (error, neexistujici radka...)
 */
DLLEXPORT
DAPIC_HRSROW dapic_getRsRow(DAPIC_HDAPI hDapi, unsigned index);

/**
 * Funkce pro dotaz na hodnotu jednoduchych (non-RS) vystupnich parametru 
 * z radky resultsetu specifikaci konkretnich typu.
 *@param	hRow	handle na radku resultsetu, ve ktere se ma parametr vyhledat
 *@param	name	jmeno parametru
 *@param	value	vystupni parametr, po skonceni uspesneho volani obsahuje
 *					hodnotu parametru; v pripade typu s fixni velikosti (tedy krome
 *					stringu a bytu) se hodnota zapise na misto v pameti, na ktere
 *					ukazuje parametr value; v pripade, kdy value je dvojity pointer,
 *					se do parametru zapise adresa na misto v pameti, kde zacina retezec
 *					znaku nebo bytu. 
 *					V zadnem pripade nesmi volajici dealokovat pamet, na kterou dostane
 *					ukazatel. Ovsem referencovana pamet prestane byt platne po zavolani 
 *					dapic_destroyDapi() pro hDapi. Proto je doporuceno odkazovanou pamet
 *					zkopirovat do pameti vlastnene volajicim.
 *					Pokud je hodnota parametru NULL a value neni dvojity pointer,
 *					pak do nej neni nic zapsano a navratovy kod je 1.
 *					Pokud je hodnota parametru NULL a value je dvojity pointer,
 *					pak je predana hodnota NULL a navratovy kod je 1.
 *@return	0		on success, or
 *			1		pokud je hodnota pozadovaneho parametru NULL, or
 *			-1		on error
 */
DLLEXPORT
int dapic_getRowBool(DAPIC_HRSROW hRow, 
					 const char *name, DapiBool *value);
DLLEXPORT
int dapic_getRowInteger(DAPIC_HRSROW hRow,
						const char *name, DapiInteger *value);
DLLEXPORT
int dapic_getRowDouble(DAPIC_HRSROW hRow, 
					   const char *name, DapiDouble *value);
DLLEXPORT
int dapic_getRowString(DAPIC_HRSROW hRow, 
					   const char *name, DapiChar **value);
DLLEXPORT
int dapic_getRowBytes(DAPIC_HRSROW hRow, 
					  const char *name, DapiByte **value, size_t *length);
DLLEXPORT
int dapic_getRowDate(DAPIC_HRSROW hRow, 
					 const char *name, DapiDate *value);
DLLEXPORT
int dapic_getRowTime(DAPIC_HRSROW hRow, 
					 const char *name, DapiTime *value);
DLLEXPORT
int dapic_getRowDateTime(DAPIC_HRSROW hRow, 
						 const char *name, DapiDateTime *value);
DLLEXPORT
int dapic_getRowTimestamp(DAPIC_HRSROW hRow, 
						  const char *name, DapiTimestamp *value);

/**
 * Zjistuje, zda je dany vystupni parametr radky resultsetu nastaven na NULL.
 *@param	name				jmeno parametru
 *@return	0	parametr je nastaven, neni NULL,
 *			1	parametr ma hodnotu NULL,
 *			-1	chyba.
 */
DLLEXPORT
int dapic_isRowNull(DAPIC_HRSROW hRow, const char *name);

/**
 * Uvolni pamet spojenou s handlem na radku resultsetu.
 */
DLLEXPORT
int dapic_releaseRsRow(DAPIC_HRSROW *hRow);

#ifdef MSG_VER_2_ENABLED
/**
 * Umoznuje ziskat metadata jednotlivych parametru Dapi pro vstupni rowset.
 * Do defs vraci pointer na seznam definic parametru vstupniho rowsetu. 
 * Vracena pamet patri knihovne, volajici nesmi dealokovat.
 */
DLLEXPORT
int dapic_getDapiInRowsetParamDefs(DAPIC_HDAPI hDapi, 
								   const char *rowsetName, 
								   DAPIC_PARAMDEF **defs);

/**
 * Umoznuje ziskat metadata jednotlivych parametru Dapi pro vystupni rowset.
 * Do defs vraci pointer na seznam definic parametru vystupniho rowsetu. 
 * Vracena pamet patri knihovne, volajici nesmi dealokovat.
 */
DLLEXPORT
int dapic_getDapiOutRowsetParamDefs(DAPIC_HDAPI hDapi, 
									const char *rowsetName, 
									DAPIC_PARAMDEF **defs);
#endif /* MSG_VER_2_ENABLED */

/**
 * Vraci vstupni parametry jako parameter set.
 *@return	-1		on error, nebo
 *			>=0		on success.
 */
DLLEXPORT
DAPIC_HPRMSET dapic_getInParams(DAPIC_HDAPI hDapi);

/**
 * Vraci vystupni parametry jako parameter set.
 *@return	-1		on error, nebo
 *			>=0		on success.
 */
DLLEXPORT
DAPIC_HPRMSET dapic_getOutParams(DAPIC_HDAPI hDapi);

/**
 * Vraci pocet radek inputsetu.
 *@return	-1		on error, nebo
 *			>=0		on success.
 */
DLLEXPORT
int dapic_getInputsetRowCount(DAPIC_HDAPI hDapi);

/**
 * Vytazeni radky inputsetu. Hodnoty jednotlivych 
 * parametru lze potom nastavit pomoci dalsich funkci pres vraceny handle
 * na parameter set. Vraceny handle je nutne po skonceni pouzivani uvolnit 
 * pomoci dapic_releaseParamset(), jinak vznika memory leak.
 *@param	hDapi	handle na Dapi
 *@param	index	1-based index radky, o kterou ma volajici zajem
 *					u FL jsou tedy radky indexovane od 1, v XML ma cislo radky index num
 *					(num je atribut tagu row v XML)
 *@return	platny handle (non-NULL)	v pripade uspesneho vytazeni radky, nebo
 *			NULL						error
 */
DLLEXPORT
DAPIC_HPRMSET dapic_getInputsetRow(DAPIC_HDAPI hDapi, unsigned index);

/**
 * Vraci pocet radek vystupniho resultsetu.
 *@return	-1		on error, nebo
 *			>=0		on success.
 */
DLLEXPORT
int dapic_getResultsetRowCount(DAPIC_HDAPI hDapi);

/**
 * Vytazeni radky resultsetu z odpovedi Dapi volani. Hodnoty jednotlivych 
 * parametru lze potom ziskat pomoci dalsich funkci pres vraceny handle
 * na parameter set. Vraceny handle je nutne po skonceni pouzivani uvolnit 
 * pomoci dapic_releaseParamset(), jinak vznika memory leak.
 *@param	hDapi	handle na Dapi
 *@param	index	1-based index radky, o kterou ma volajici zajem
 *					u FL jsou tedy radky indexovane od 1, v XML ma cislo radky index num
 *					(num je atribut tagu row v XML)
 *@return	platny handle (non-NULL)	v pripade uspesneho vytazeni radky, nebo
 *			NULL						(error, neexistujici radka...)
 */
DLLEXPORT
DAPIC_HPRMSET dapic_getResultsetRow(DAPIC_HDAPI hDapi, unsigned index);

#ifdef MSG_VER_2_ENABLED
/**
 * Vraci pocet radek vstupniho rowsetu.
 *@return	-1		on error, nebo
 *			>=0		on success.
 */
DLLEXPORT
int dapic_getInRowsetRowCount(DAPIC_HDAPI hDapi, const char *rowsetName);

/**
 * Vytazeni radky vstupniho rowsetu z odpovedi Dapi volani. Hodnoty jednotlivych 
 * parametru lze potom ziskat pomoci dalsich funkci pres vraceny handle
 * na parameter set. Vraceny handle je nutne po skonceni pouzivani uvolnit 
 * pomoci dapic_releaseParamset(), jinak vznika memory leak.
 *@param	hDapi		handle na Dapi
 *@param	rowsetName	jmeno parametru obsahujiciho rowset
 *@param	index		1-based index radky, o kterou ma volajici zajem
 *						v XML ma cislo radky index num (num je atribut tagu row v XML)
 *@return	platny handle (non-NULL)	v pripade uspesneho vytazeni radky, nebo
 *			NULL						(error, neexistujici radka...)
 */
DLLEXPORT
DAPIC_HPRMSET dapic_getInRowsetRow(DAPIC_HDAPI hDapi,
								   const char *rowsetName,
								   unsigned index);
/**
 * Vraci pocet radek vystupniho rowsetu.
 *@return	-1		on error, nebo
 *			>=0		on success.
 */
DLLEXPORT
int dapic_getOutRowsetRowCount(DAPIC_HDAPI hDapi, const char *rowsetName);

/**
 * Vytazeni radky vystupniho rowsetu z odpovedi Dapi volani. Hodnoty jednotlivych 
 * parametru lze potom ziskat pomoci dalsich funkci pres vraceny handle
 * na parameter set. Vraceny handle je nutne po skonceni pouzivani uvolnit 
 * pomoci dapic_releaseParamset(), jinak vznika memory leak.
 *@param	hDapi		handle na Dapi
 *@param	rowsetName	jmeno parametru obsahujiciho rowset
 *@param	index		1-based index radky, o kterou ma volajici zajem
 *						v XML ma cislo radky index num (num je atribut tagu row v XML)
 *@return	platny handle (non-NULL)	v pripade uspesneho vytazeni radky, nebo
 *			NULL						(error, neexistujici radka...)
 */
DLLEXPORT
DAPIC_HPRMSET dapic_getOutRowsetRow(DAPIC_HDAPI hDapi,
									const char *rowsetName,
									unsigned index);
#endif /* MSG_VER_2_ENABLED */

/**
 * Funkce pro nastavovani jednoduchych parametru vstupniho parameter setu
 * specifikaci konkretnich typu pro dany parameter set.
 *@param	hParamset	handle parameter setu, ve kterem se ma parametr nastavit
 *@param	name		jmeno parametru
 *@param	value		hodnota parametru; pokud je to pointer, lze parametr nastavit
 *                      na NULL, jinak je nutne pouzit dapic_setParamsetParamNull
 *@return	0			on success, nebo
 *			-1			on error.
 */
DLLEXPORT
int dapic_setParamsetBool(DAPIC_HPRMSET hPrmset,
						  const char *name, DapiBool value);
DLLEXPORT
int dapic_setParamsetInteger(DAPIC_HPRMSET hPrmset, 
							 const char *name, DapiInteger value);
DLLEXPORT
int dapic_setParamsetDouble(DAPIC_HPRMSET hPrmset, 
							const char *name, DapiDouble value);
DLLEXPORT
int dapic_setParamsetString(DAPIC_HPRMSET hPrmset, 
							const char *name, const DapiChar *value);
DLLEXPORT
int dapic_setParamsetStringN(DAPIC_HPRMSET hPrmset, 
							 const char *name, const DapiChar *value, 
							 size_t length);
DLLEXPORT
int dapic_setParamsetBytes(DAPIC_HPRMSET hPrmset,
						   const char *name, const DapiByte *value,
						   size_t length);
DLLEXPORT
int dapic_setParamsetDate(DAPIC_HPRMSET hPrmset,
						  const char *name, const DapiDate *value);
DLLEXPORT
int dapic_setParamsetTime(DAPIC_HPRMSET hPrmset,
						  const char *name, const DapiTime *value);
DLLEXPORT
int dapic_setParamsetDateTime(DAPIC_HPRMSET hPrmset,
							  const char *name, const DapiDateTime *value);
DLLEXPORT
int dapic_setParamsetTimestamp(DAPIC_HPRMSET hPrmset,
							   const char *name, const DapiTimestamp *value);

/**
 * Nastavi hodnotu daneho parametru parameter setu na NULL. 
 * Pokud je tento parametr 'required', pak je jeho hodnota nastavena na default.
 */
DLLEXPORT
int dapic_setParamsetParamNull(DAPIC_HPRMSET hPrmset, const char *name);

/**
 * Funkce pro dotaz na hodnotu jednoduchych parametru vystupniho parameter setu
 * specifikaci konkretnich typu.
 *@param	hPrmset	handle parameter setu, ve kterem se ma parametr vyhledat
 *@param	name	jmeno parametru
 *@param	value	parametr; po skonceni uspesneho volani obsahuje
 *					hodnotu parametru; v pripade typu s fixni velikosti (tedy krome
 *					stringu a bytu) se hodnota zapise na misto v pameti, na ktere
 *					ukazuje parametr value; v pripade, kdy value je dvojity pointer,
 *					se do parametru zapise adresa na misto v pameti, kde zacina retezec
 *					znaku nebo bytu. 
 *					V zadnem pripade nesmi volajici dealokovat pamet, na kterou dostane
 *					ukazatel. Ovsem referencovana pamet prestane byt platne po zavolani 
 *					dapic_destroyDapi() pro hDapi. Proto je doporuceno odkazovanou pamet
 *					zkopirovat do pameti vlastnene volajicim.
 *					Pokud je hodnota parametru NULL a value neni dvojity pointer,
 *					pak do nej neni nic zapsano a navratovy kod je 1.
 *					Pokud je hodnota parametru NULL a value je dvojity pointer,
 *					pak je predana hodnota NULL a navratovy kod je 1.
 *@return	0		on success, or
 *			1		pokud je hodnota pozadovaneho parametru NULL, or
 *			-1		on error
 */
DLLEXPORT
int dapic_getParamsetBool(DAPIC_HPRMSET hPrmset, 
						  const char *name, DapiBool *value);
DLLEXPORT
int dapic_getParamsetInteger(DAPIC_HPRMSET hPrmset,
							 const char *name, DapiInteger *value);
DLLEXPORT
int dapic_getParamsetDouble(DAPIC_HPRMSET hPrmset, 
							const char *name, DapiDouble *value);
DLLEXPORT
int dapic_getParamsetString(DAPIC_HPRMSET hPrmset, 
							const char *name, DapiChar **value);
DLLEXPORT
int dapic_getParamsetBytes(DAPIC_HPRMSET hPrmset, 
						   const char *name, DapiByte **value, size_t *length);
DLLEXPORT
int dapic_getParamsetDate(DAPIC_HPRMSET hPrmset, 
						  const char *name, DapiDate *value);
DLLEXPORT
int dapic_getParamsetTime(DAPIC_HPRMSET hPrmset, 
						  const char *name, DapiTime *value);
DLLEXPORT
int dapic_getParamsetDateTime(DAPIC_HPRMSET hPrmset, 
							  const char *name, DapiDateTime *value);
DLLEXPORT
int dapic_getParamsetTimestamp(DAPIC_HPRMSET hPrmset, 
							   const char *name, DapiTimestamp *value);

/**
 * Zjistuje, zda je dany parametr parameter setu nastaven na NULL.
 *@return	0	parametr je nastaven, neni NULL,
 *			1	parametr ma hodnotu NULL,
 *			-1	chyba.
 */
DLLEXPORT
int dapic_isParamsetParamNull(DAPIC_HPRMSET hPrmset, const char *name);

/**
 * Uvolni pamet spojenou s handlem na parameter set.
 */
DLLEXPORT
int dapic_releaseParamset(DAPIC_HPRMSET *hPrmset);

/**
 * Uvolni pamet spojenou s pozadavkem. 
 *
 * Handle bude nastaven na NULL, nebude uz mozne ho dale pouzivat.
 * Pokud dany handle hDapi odkazuje na odeslany pozadavek, na ktery byla 
 * pozadovana odpoved, ktera jeste nebyla prijata, pak po jejim doruceni 
 * dojde k vyvolani unexpectedMessageHandleru.
 */
DLLEXPORT
int dapic_destroyDapi(DAPIC_HDAPI *hDapi);

/**
 * Nastavuje funkci, ktera bude dostavat oznameni o prijatych neocekavanych zpravach.
 * Listener pomoci navratove hodnoty signalizuje, zda zpravu zpracoval (navratova 
 * hodnota nenulova), nebo nezpracoval (vraci nulu).
 *@return	0	listener set successfully, or
 *			!0	setting of listener failed.
 */
DLLEXPORT
int dapic_setEventListener(DAPIC_HCLIENT hClient, DAPIC_EVENTLISTENER listener, void *listenerContext);

/**
 * Nastavuje funkci, ktera bude dostavat rozsirena oznameni o prijatych neocekavanych zpravach.
 * Listener pomoci navratove hodnoty signalizuje, zda zpravu zpracoval (navratova 
 * hodnota nenulova), nebo nezpracoval (vraci nulu).
 *@return	0	listener set successfully, or
 *			!0	setting of listener failed.
 */
DLLEXPORT
int dapic_setEnhancedEventListener(DAPIC_HCLIENT hClient, DAPIC_ENHANCED_EVENTLISTENER listener, void *listenerContext);

/**
 * Uvolni pamet spojenou s handlem.
 *
 * Handle bude nastaven na NULL, nebude uz mozne ho dale pouzivat.
 */
DLLEXPORT
int dapic_uninitClient(DAPIC_HCLIENT *hClient);

/**
 * Destruktor knihovny dapi clienta - uvolni systemove prostredky. Muze byt volan
 * libovolny pocetkrat v rade.
 *@return	0	success, jinak failure
 */
DLLEXPORT
int dapic_uninit(void);

/**
 * Funkce vraci posledni chybu, ktera byla zaznamena pri praci s handlem hClient 
 * ve volajicim vlakne. Pokud je hClient NULL, potom se vraci posledni chyba, 
 * ktera vznikla pri operaci inicializace (dapic_initClient), nebo uninicializace 
 * (dapic_uninitClient) klienta. Tuto funkci lze volat pouze po uspesne inicializaci 
 * knihovny pomoci dapic_init a pred deinicializaci pomoci dapic_uninit.
 *
 *@return	NULL	informace o chybe nenalezena nebo hClient je neplatny handle 
 *					(ruzny od NULL), nebo
 *			ukazatel na instanci DAPIC_ERRORINFO	
 *					v pripade uspechu. Volajici nesmi dealokovat vraceny pointer, 
 *					ten zustava ve sprave knihovny. Vraceny pointer ani pointery 
 *					z vracene struktury neni doporuceno uchovavat pro pozdejsi pouziti, 
 *					protoze se stane neplatnym pri dalsi chybe, ktera nastane pri praci 
 *					se stejnym handlem ve stejnem vlakne. Je ovsem zaruceno, ze pointer 
 *					nemuze byt zneplatnen jinym vlaknem krome pripadu, kdy jine vlakno 
 *					zrusi handle hClient pomoci volani dapic_uninitClient, pripadne 
 *					uvolni celou knihovnu pomoci dapic_uninit.
 */
DLLEXPORT
DAPIC_ERRORINFO *dapic_getLastError(DAPIC_HCLIENT hClient);

/**
 * Funkce vrati pointer na staticky buffer obsahujici retezec popisujici 
 * verzi DAPI klienta. Volajici nesmi dealokovat pamet, na kterou ukazuje 
 * vraceny pointer (proto je const).
 */
DLLEXPORT
const char *dapic_getVersion(void);

#ifdef __cplusplus
}
#endif

#endif /* __DAPIC_H_ */