%%	options

copyright owner	=	Dirk Krause
copyright year	=	2015-xxxx
SPDX-License-Identifier:	BSD-3-Clause



%%	header

#ifndef	DK4CONF_H_INCLUDED
#if DK4_BUILDING_DKTOOLS4
#include "dk4conf.h"
#else
#include <dktools-4/dk4conf.h>
#endif
#endif

#ifndef DK4DBI_H_INCLUDED
#if DK4_BUILDING_DKTOOLS4
#include "dk4dbi.h"
#else
#include <dktools-4/dk4dbi.h>
#endif
#endif

#ifndef DK4APP_H_INCLUDED
#if DK4_BUILDING_DKTOOLS4
#include "dk4app.h"
#else
#include <dktools-4/dk4app.h>
#endif
#endif


#ifdef	__cplusplus
extern "C" {
#endif


/**	Open database.
	@param	fn	Database type and file name.
			The database type is one from "mem", "bdb" or "ndbm".
			Database type and file name are separated by two
			colons "::".
	@param	wa	Flag: Write access required.
	@param	tr	Flag: Truncate existing database (only in conjunction
			with wa).
	@param	erp	Error report, may be NULL.
	@param	app	Application structure for diagnostics, may be NULL.
	@return	Pointer to new database structure on success, NULL on error.

	Error codes:
	- DK4_E_INVALID_ARGUMENTS<br>
	  if fn is NULL or tp contains an invalid type number,
	- DK4_E_NOT_SUPPORTED<br>
	  if the database type is not supported,
	- DK4_E_MATH_OVERFLOW<br>
	  on numeric overflow when calculating size,
	- DK4_E_MEMORY_ALLOCATION_FAILED<br>
	  with mem.elsize and mem.nelem
	  set if there is not enough memory available,
	- DK4_E_SYNTAX<br>
	  if
	  - the specification contains an invalid backend type
	  - the database file name does not refer to a regular file
	  - or the file contents is not an in-memory database
	  - or key/value sizes in the file are in conflict with
	    size restrictions
	  - or an invalid database type was specified,
	- DK4_E_SEC_CHECK<br>
	  with failed check id in iDetails1 if access is denied by additional
	  security checks,
	- DK4_E_MEMORY_ALLOCATION_FAILED<br>
	  with mem.elsize and mem.nelem
	  set if there is not enough memory available,
	- DK4_E_OPEN_READ_FAILED<br>
	  if fopen() or fread() failed,
	- DK4_E_OPEN_WRITE_FAILED<br>
	  if fopen() or fwrite() failed,
	- DK4_E_CLOSE_FAILED<br>
	  with errno value in iDetails1 if fclose() failed.
*/
dk4_dbi_t *
dk4dbi_open_app(
  const dkChar	*fn,
  int		 wa,
  int		 tr,
  dk4_er_t	*erp,
  dk4_app_t	*app
);

/**	Open database.
	@param	fn	Database type and file name.
			The database type is one from "mem", "bdb" or "ndbm".
			Database type and file name are separated by two
			colons "::".
	@param	wa	Flag: Write access required.
	@param	tr	Flag: Truncate existing database (only in conjunction
			with wa).
	@param	km	Maximum key size.
	@param	vm	Maximum value size.
	@param	erp	Error report, may be NULL.
	@param	app	Application structure for diagnostics, may be NULL.
	@return	Pointer to new database structure on success, NULL on error.

	Error codes:
	- DK4_E_INVALID_ARGUMENTS<br>
	  if fn is NULL or tp contains an invalid type number,
	- DK4_E_NOT_SUPPORTED<br>
	  if the database type is not supported,
	- DK4_E_MATH_OVERFLOW<br>
	  on numeric overflow when calculating size,
	- DK4_E_MEMORY_ALLOCATION_FAILED<br>
	  with mem.elsize and mem.nelem
	  set if there is not enough memory available,
	- DK4_E_SYNTAX<br>
	  if
	  - the specification contains an invalid backend type
	  - the database file name does not refer to a regular file
	  - or the file contents is not an in-memory database
	  - or key/value sizes in the file are in conflict with
	    size restrictions
	  - or an invalid database type was specified,
	- DK4_E_SEC_CHECK<br>
	  with failed check id in iDetails1 if access is denied by additional
	  security checks,
	- DK4_E_MEMORY_ALLOCATION_FAILED<br>
	  with mem.elsize and mem.nelem
	  set if there is not enough memory available,
	- DK4_E_OPEN_READ_FAILED<br>
	  if fopen() or fread() failed,
	- DK4_E_OPEN_WRITE_FAILED<br>
	  if fopen() or fwrite() failed,
	- DK4_E_CLOSE_FAILED<br>
	  with errno value in iDetails1 if fclose() failed.
*/
dk4_dbi_t *
dk4dbi_open_sizes_app(
  const dkChar	*fn,
  int		 wa,
  int		 tr,
  size_t	 km,
  size_t	 vm,
  dk4_er_t	*erp,
  dk4_app_t	*app
);

#ifdef	__cplusplus
}
#endif


%%	module


#include "dk4conf.h"

#if	DK4_HAVE_ASSERT_H
#ifndef	ASSERT_H_INCLUDED
#include <assert.h>
#define	ASSERT_H_INCLUDED 1
#endif
#endif

#include "dk4dbia.h"
#include "dk4const.h"


$!trace-include



/**	Preference names we are using here.
*/
static const dkChar * const	dk4dbi_pref_names[] = {
$!string-table	macro=dkT
db.key.max-size
db.value.max-size
$!end
};



/**	Constant texts used by the module, not localized.
*/
static const dkChar * const	dk4dbia_kwnl[] = {
$!string-table	macro=dkT
#
#	0	String table file name.
#
dk4dbia.str
$!end
};



/**	Constant texts used by the module, localized
	texts are used if available.
*/
static const dkChar * const	dk4dbia_kw_def[] = {
$!string-table	macro=dkT
#
#	0	Error: Failed to open database
#
Failed to open database!
#
#	1
#
\nInvalid arguments were provided to the DB opening function.
#
#	2
#
\nThe database type is not supported.
#
#	3
#
\nMathematical overflow in size calculation.
#
#	4
#
\nInsufficient memory available.
#
#	5
#
\nSyntax error (database name, file type or file contents).
#
#	6
#
\nInsufficient permissions.
#
#	7
#
\nFailed to open the file for read access.
#
#	8
#
\nFailed to open the file for write access.
#
#	9
#
\nFailed to close the file.
$!end
};



dk4_dbi_t *
dk4dbi_open_sizes_app(
  const dkChar	*fn,
  int		 wa,
  int		 tr,
  size_t	 km,
  size_t	 vm,
  dk4_er_t	*erp,
  dk4_app_t	*app
)
{
  dk4_er_t		 er;		/* Error report from dk4dbi_open */
  const dkChar *      	 parts[4];	/* Message parts array */
  const dkChar * const	*msg	= NULL;	/* Localized messages */
  dk4_dbi_t		*back	= NULL;	/* Result */
  size_t		 szpts	= 0;	/* Number of elements in parts */
#if	DK4_USE_ASSERT
  assert(NULL != fn);
#endif
  dk4error_init(&er);
  back = dk4dbi_open(fn, wa, tr, km, vm, &er);
  if (NULL == back) {
    dk4error_copy(erp, &er);
    if (NULL != app) {
      msg   = dk4app_string_table(app, dk4dbia_kwnl[0], dk4dbia_kw_def);
      parts[0] = msg[0];
      parts[1] = NULL;
      szpts = 1;
      switch (er.ec) {
        case DK4_E_INVALID_ARGUMENTS : {
	  parts[1] = msg[1];
	  parts[2] = NULL;
	  szpts = 2;
        } break;
        case DK4_E_NOT_SUPPORTED : {
	  parts[1] = msg[2];
	  parts[2] = NULL;
	  szpts = 2;
        } break;
        case DK4_E_MATH_OVERFLOW : {
	  parts[1] = msg[3];
	  parts[2] = NULL;
	  szpts = 2;
        } break;
        case DK4_E_MEMORY_ALLOCATION_FAILED : {
	  parts[1] = msg[4];
	  parts[2] = NULL;
	  szpts = 2;
        } break;
        case DK4_E_SYNTAX : {
	  parts[1] = msg[5];
	  parts[2] = NULL;
	  szpts = 2;
        } break;
        case DK4_E_SEC_CHECK : {
	  parts[1] = msg[6];
	  parts[2] = NULL;
	  szpts = 2;
        } break;
        case DK4_E_OPEN_READ_FAILED : {
	  parts[1] = msg[7];
	  parts[2] = NULL;
	  szpts = 2;
        } break;
        case DK4_E_OPEN_WRITE_FAILED : {
	  parts[1] = msg[8];
	  parts[2] = NULL;
	  szpts = 2;
        } break;
        case DK4_E_CLOSE_FAILED : {
	  parts[1] = msg[9];
	  parts[2] = NULL;
	  szpts = 2;
        } break;
      }
      if (0 < szpts) {
        dk4app_log_msg(app, DK4_LL_ERROR, parts, szpts);
      }
    }
  }
  return back;
}



dk4_dbi_t *
dk4dbi_open_app(
  const dkChar	*fn,
  int		 wa,
  int		 tr,
  dk4_er_t	*erp,
  dk4_app_t	*app
)
{
  size_t	 km	= 0;
  size_t	 vm	= 0;

#if	DK4_USE_ASSERT
  assert(NULL != fn);
#endif
  if (0 == dk4app_pref_get_size(&km, app, dk4dbi_pref_names[0], 0)) {
    km = 0;
  }
  if (0 == dk4app_pref_get_size(&vm, app, dk4dbi_pref_names[1], 0)) {
    vm = 0;
  }
  return (dk4dbi_open_sizes_app(fn, wa, tr, km, vm, erp, app));
}