anchor.diff:  
   -export ([start_supervised/0, start_supervised/1, start_link/2]).
   -export ([init/1, terminate/2, code_change/3, handle_call/3, handle_cast/2, handle_info/2]).
  +
  +
  +-import (mosaic_enforcements, [enforce_ok/1, enforce_ok_1/1, enforce_ok_2/1]).
   
   
   start_supervised () ->
  
positive.code: handle_call ({mosaic_process_configurator, configure, Type, Disposition, Identifier, ConfigurationEncoding, ConfigurationContent}, _Sender, State = #state{})
  		when is_atom (Type), is_binary (Identifier), (bit_size (Identifier) =:= 160), is_atom (ConfigurationEncoding),
  				((Disposition =:= create) orelse (is_record (Disposition, migrate, 2) andalso ((element (2, Disposition) =:= source) orelse (element (2, Disposition) =:= target)))) ->
  	{ok, FunctionKey} = mosaic_cluster_tools:key ({mosaic_cluster_processes, configurator, Type, ConfigurationEncoding}),
  	case mosaic_cluster_storage:select (FunctionKey) of
  		{ok, undefined, {mosaic_cluster_processes, configurator, Type, ConfigurationEncoding, Function, _Annotation}} when is_function (Function, 5) ->
  			try erlang:apply (Function, [Type, Disposition, Identifier, ConfigurationEncoding, ConfigurationContent]) of
  				Outcome = {ok, Module, _Configuration} when is_atom (Module) ->
  					{reply, Outcome, State};
  				Error = {error, _Reason} ->
  					{reply, Error, State};
  				Return ->
  					{reply, {error, {configurator_failed, {invalid_return, Return}}}, State}
  			catch
  				throw : CatchedTerm ->
  					{reply, {error, {configurator_failed, {throw, CatchedTerm, erlang:get_stacktrace ()}}}, State};
  				error : CatchedTerm ->
  					{reply, {error, {configurator_failed, {error, CatchedTerm, erlang:get_stacktrace ()}}}, State};
  				exit : CatchedTerm ->
  					{reply, {error, {configurator_failed, {exit, CatchedTerm, erlang:get_stacktrace ()}}}, State}
  			end;
  		{ok, _, _} ->
  			ok = mosaic_transcript:trace_error ("selected invalid configurator; ignoring!", [{type, Type}, {configuration_encoding, ConfigurationEncoding}]),
  			{reply, {error, configurator_not_registered}, State};
  		{error, does_not_exist} ->
  			{reply, {error, configurator_not_registered}, State}
  	end;
  	
  handle_call ({mosaic_process_configurator, register, Type, ConfigurationEncoding, {Module, Function, FunctionExtraArgument}, Annotation}, Sender, State = #state{})
  		when is_atom (Type), is_atom (ConfigurationEncoding), is_atom (Module), is_atom (Function) ->
  	_ = code:ensure_loaded (Module),
  	ModuleLoaded = erlang:module_loaded (Module),
  	FunctionExported = erlang:function_exported (Module, Function, 6),
  	if
  		ModuleLoaded, FunctionExported ->
  			Function_ = fun (Type_, Disposition_, Identifier_, ConfigurationEncoding_, ConfigurationContent_) ->
  				erlang:apply (Module, Function, [Type_, Disposition_, Identifier_, ConfigurationEncoding_, ConfigurationContent_, FunctionExtraArgument])
  			end,
  			handle_call ({mosaic_process_configurator, register, Type, ConfigurationEncoding, Function_, Annotation}, Sender, State);
  		not ModuleLoaded ->
  			{reply, {error, {invalid_module, Module}}, State};
  		not FunctionExported ->
  			{reply, {error, {invalid_function, {Module, Function}}}, State}
  	end;
  	
  handle_call ({mosaic_process_configurator, register, Type, ConfigurationEncoding, {Module, Function}, Annotation}, Sender, State = #state{})
  		when is_atom (Type), is_atom (ConfigurationEncoding), is_atom (Module), is_atom (Function) ->
  	_ = code:ensure_loaded (Module),
  	ModuleLoaded = erlang:module_loaded (Module),
  	FunctionExported = erlang:function_exported (Module, Function, 5),
  	if
  		ModuleLoaded, FunctionExported ->
  			Function_ = fun (Type_, Disposition_, Identifier_, ConfigurationEncoding_, ConfigurationContent_) ->
  				erlang:apply (Module, Function, [Type_, Disposition_, Identifier_, ConfigurationEncoding_, ConfigurationContent_])
  			end,
  			handle_call ({mosaic_process_configurator, register, Type, ConfigurationEncoding, Function_, Annotation}, Sender, State);
  		not ModuleLoaded ->
  			{reply, {error, {invalid_module, Module}}, State};
  		not FunctionExported ->
  			{reply, {error, {invalid_function, {Module, Function}}}, State}
  	end;
  	
  handle_call ({mosaic_process_configurator, register, Type, ConfigurationEncoding, Function, Annotation}, _Sender, State = #state{})
  		when is_atom (Type), is_atom (ConfigurationEncoding), is_function (Function) ->
  	FunctionValid = erlang:is_function (Function, 5),
  	if
  		FunctionValid ->
  			{ok, FunctionKey} = mosaic_cluster_tools:key ({mosaic_cluster_processes, configurator, Type, ConfigurationEncoding}),
  			case mosaic_cluster_storage:include (FunctionKey, undefined, {mosaic_cluster_processes, configurator, Type, ConfigurationEncoding, Function, Annotation}) of
  				ok ->
  					{reply, ok, State};
  				Error = {error, _Reason} ->
  					{reply, Error, State}
  			end;
  		true ->
  			{reply, {error, {invalid_function, Function}}, State}
  	end;
  	
  handle_call ({mosaic_process_configurator, unregister, Type, ConfigurationEncoding}, _Sender, State = #state{})
  		when is_atom (Type), is_atom (ConfigurationEncoding) ->
  	{ok, FunctionKey} = mosaic_cluster_tools:key ({mosaic_cluster_processes, configurator, Type, ConfigurationEncoding}),
  	case mosaic_cluster_storage:exculde (FunctionKey, undefined) of
  		ok ->
  			{reply, ok, State};
  		Error = {error, _Reason} ->
  			{reply, Error, State}
  	end;
  	
  handle_call ({mosaic_process_configurator, select}, _Sender, State = #state{}) ->
  	case mosaic_cluster_storage:map (
  			fun
  				(Key, {undefined, {mosaic_cluster_processes, configurator, Type, ConfigurationEncoding, Function, Annotation}})
  
negative.code: 				{orddict:fetch (type, Information_1), orddict:fetch (configuration_encoding, Information_1)}
  						=< {orddict:fetch (type, Information_2), orddict:fetch (configuration_encoding, Information_2)}
  			end,
  			{ok, lists:usort (Comparator, Informations)};
  		{ok, _, Reasons} ->
  			{error, {storage_failure, Reasons}}
  	end.
  
  
  coerce_configurator_function ({Module, Function, FunctionExtraArgument})
  		when is_atom (Module), is_atom (Function) ->
  	_ = code:ensure_loaded (Module),
  	ModuleLoaded = erlang:module_loaded (Module),
  	FunctionExported = erlang:function_exported (Module, Function, 6),
  	if
  		ModuleLoaded, FunctionExported ->
  			Function_ = fun (Type_, Disposition_, Identifier_, ConfigurationEncoding_, ConfigurationContent_) ->
  				erlang:apply (Module, Function, [Type_, Disposition_, Identifier_, ConfigurationEncoding_, ConfigurationContent_, FunctionExtraArgument])
  			end,
  			{ok, Function_};
  		not ModuleLoaded ->
  			{error, {invalid_module, Module}};
  		not FunctionExported ->
  			{error, {invalid_function, {Module, Function}}}
  	end;
  	
  coerce_configurator_function ({Module, Function})
  		when is_atom (Module), is_atom (Function) ->
  	_ = code:ensure_loaded (Module),
  	ModuleLoaded = erlang:module_loaded (Module),
  	FunctionExported = erlang:function_exported (Module, Function, 5),
  	if
  		ModuleLoaded, FunctionExported ->
  			Function_ = fun (Type_, Disposition_, Identifier_, ConfigurationEncoding_, ConfigurationContent_) ->
  				erlang:apply (Module, Function, [Type_, Disposition_, Identifier_, ConfigurationEncoding_, ConfigurationContent_])
  			end,
  			{ok, Function_};
  		not ModuleLoaded ->
  			{error, {invalid_module, Module}};
  		not FunctionExported ->
  			{error, {invalid_function, {Module, Function}}}
  	end;
  	
  coerce_configurator_function (Function)
  		when is_function (Function, 5) ->
  	{ok, Function};
  	
  coerce_configurator_function (Function) ->
  	{error, {invalid_function, Function}}.
  