modules

type FullModuleMap map[string]ModuleMap

type GenericModule struct {
	// contains filtered or unexported fields
}

type Module interface {
	// Name returns the human-readable name for the module.
	Name() string

	// Version returns the human-readable version for the module.
	Version() string

	// GenericId returns a short generic identifier for this module. Usually
	// it identifies the "class" of this Module (for example,
	// "directory-reader" and, together with SpecificId() below, must
	// uniquely identify an instance of this Module.
	GenericId() string

	// SpecificId returns a short identifier for this module. It serves to
	// identify a specific Module instance in a given "class" (see
	// GenericId()). For example, assuming a GenericId() of
	// "directory-reader", this could return something that represents a
	// specific directory. For example, it could return "home" to indicate
	// that it is a "directory-reader" that operates in the "home"
	// directory.
	SpecificId() string

	// Type returns the specific module type. This is used do group modules
	// in specific domains so one can query about all modules on them. A
	// type could, for example, be a refrence to the program that uses
	// those modules (in other words, it could be the program name).
	Type() string

	// Register does any initialization required during module
	// registration. It is implicitly called by RegisterModule.
	Register() error

	// Unregister does any cleanup required during module removal. It is
	// implicitly called by UnregisterModule.
	Unregister() error

	// Parameters returns a ParameterMap with the configurable settings for
	// this module as keys and empty strings as values (except for entries
	// with default values). One could, then, fill/change the values in this
	// ParameterMap and pass it to Configure.
	Parameters() *ParameterMap

	// Configure configures the module usin the given ParameterMap. Usually
	// this needs to be called before actually trying to use the module.
	// Parameters above can be used to check what are the possible
	// configuration options.
	Configure(params *ParameterMap) error

	// New creates and registers a new instance of this module with
	// the given specific id. Returns a reference to the new Module and a
	// nil error on success and a non-nil error on failure. Note that
	// this must be implemented by each Module that cares about multiple
	// instances of it existing at the same time and it is the
	// responsibility of each implementation to register (calling
	// RegisterModule()) the new instance.
	New(specificId string) (Module, error)

	// Ready returns true if the module is ready to be used. False
	// otherwise. If the module requires configuration, this will return
	// false until Configure is called succesfully.
	Ready() bool
}

type ModuleMap map[string]Module

type ParameterMap map[string]string