Some enhanced ideas which will not be part of 0.8.


== API Changes ==

keyset:
	ensure that every ks* has as @post a sorted keyset
	ksClear/keyClear weg (da mit *Copy(,0) ersetzbar)

Single Interface: only get pointers, no memcopy (only one keyGetString)

no "binary" metadata hack, just provide keyGetString and keyGetStringSize

remove old metadata get/set

remove null ptr checks? (speed? decision?)


=== Plugin API Changes ===

lazy kdbOpen, maybe kdbConstruct and kdbDestruct needed too?




== Error handling ==

translation of exceptions to different languages
(or by GUI only?)


== Elektra types ==

customized type checkers
	which can be integrated within Frontend generator
	(for checking default values and preloading)
	maybe even checking of values within frontend


== Schema ==

convert elektra schema to xsd, yaml or similar
base schema (user/system)
plugins like fstab, hosts should provide their schema
schema for config of plugins + generation of code for them

define vectors, maps, class hierarchy
upgrade by global schema files similar to ldconfig


== Vision ==

Configuration definitions:
	provide definitions of known configuration trees
	generate code
	generate other schemas
	generate docu of comments (see libcomment)
	do mounting+preloading (generate config for type checkers)
	provide definitions which metadata is available and how it is used ("columns" of Configuration definitions)

community:
	make place to share configuration
	make place to share plugins

Make Plugins 1st level citizen
	plugins should be able to do everything the core can do
	(mounting, exceptions, bootstrapping, user/system split)

InternalDatabase: (only for frontend!)
	for highlevel kdbGetString, kdbSetString

Lazy+Bind Mounting
	makes kdbOpen cheaper (with many plugins)
	plugins can have global information bind mounted into their conf
	(e.g. /etc/passwd into resolver)
	kdbDup to copy current state
	leaves architecture as is -> possibility for any frontend and caching strategy + plays nicely with recursive plugins

GlobalPlugins:
	for notification start/end
	for shared plugins with expensive startup (typechecker)
	for journaling
	for git-commit

non-file based storage plugins (backends):
	nvram
	sql
	mmap
	filesys

cryptography:
	sign modules and check them when kdbOpen
	encrypted keys backend
	sign+encrypt configurationn

distributed elektra
	automatical synchronisation of nodes

typed elektra
	typing system with subtyping
	dynamic type checking

notification: new notification api (only for frontend!)
	for highlevel API
	void kdbRegisterCallback(KeySet *interests, u_int32_t diffMask,
		KdbCallback *cb, void *userdata);
	void kdbUnregisterCallback(KeySet *interests, u_int32_t diffMask,
		KdbCallback *cb, void *userdata);
	void kdbDeliverEvents(long iterations, int sleep);


libcomment: -> define as metadata
	multilanguage comments
	type of key (list, int, bool,...)
	validator of key (what is valid?)
	important? (-20 for optional 20 for must have)
	regexpr for keysets
	version of key (full.major.minor)
	user comments
	without any field it will be taken as
		comment for every language,
		not especially specified
	readonly?
	dynamic?
	persistent?
	visibility (enum for groups)
	default
	type
	description




== Internals ==

BackendCtl:
	set and get options dynamically of backends
	readonly
	transactions
	locking (performance)
	filesys optimistic lock

support multiple owner at once for kdbGet()/kdbSet()? -> or just set USER env or uid?
allow mounting for users?


= FINISH for 1.0.0 =

symbole, only export
Version info
release
minimize API -> (split core and convienience?)


== OVERVIEW ==

draw a big picture

make list of all symbols
	exported symbols
	reduce it hard
	symbole, only export (otherwise static)
	Version info 4.0

