madkit.kernel

## Class Madkit

- java.lang.Object
- - madkit.kernel.Madkit

-     public final class Madkit
      extends Object

  MaDKit 5 booter class.

  ## MaDKit v.5 new features

  - One big change that comes with version 5 is how agents are identified and localized within the artificial society. An agent is no longer binded to a single agent address but has as many agent addresses as holden positions in the artificial society. see `AgentAddress` for more information.
  - With respect to the previous change, a `withRole` version of all the messaging methods has been added. See `AbstractAgent.sendMessageWithRole(AgentAddress, Message, String)` for an example of such a method.
  - A replying mechanism has been introduced through `SendReply` methods. It enables the agent with the possibility of replying directly to a given message. Also, it is now possible to get the reply to a message, or to wait for a reply ( for `Agent` subclasses only as they are threaded) See `AbstractAgent.sendReply(Message, Message)` for more details.
  - Agents now have a formal state during a MaDKit session. See the `AbstractAgent.getState()` method for detailed information.
  - One of the most convenient improvement of v.5 is the logging mechanism which is provided. See the `AbstractAgent.getLogger()` for more details.
  - Internationalization is being made (fr_fr and en_us for now).

  Since:
    MaDKit 4.0
  Version:
    5.2
  Author:
    Fabien Michel, Jacques Ferber

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `Madkit.BooleanOption` Option used to activate or disable features on startup.
    `static class` | `Madkit.LevelOption` MaDKit options valued with a string representing a `Level` value.
    `static class` | `Madkit.Option` MaDKit options which are valued with a string representing parameters.

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static String` | `BUILD_ID`
    `static String` | `VERSION`
    `static String` | `WEB`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Madkit(String... options)` Launch a new kernel with predefined options.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `doAction(KernelAction action, Object... parameters)` Makes the kernel do the corresponding action.
    `static void` | `main(String[] options)` This main could be used to launch a new kernel using predefined options.
    `String` | `toString()`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### VERSION

          public static final String VERSION

    - #### BUILD_ID

          public static final String BUILD_ID

    - #### WEB

          public static final String WEB

  - ### Constructor Detail

    - #### Madkit

          public Madkit(String... options)

      Launch a new kernel with predefined options. The call returns when the new kernel has finished to take care of all options. Moreover the kernel automatically ends when all the agents living on this kernel are done.

      Here is an example of use:

           public void somewhereInYourCode() {
               new Madkit(Option.launchAgents.toString(), // gets the --launchAgents string
                      Client.class.getName() + ",true,20;" + Broker.class.getName() + ",true,10;" + Provider.class.getName() + ",false,20");
           }

      Parameters:
        `options` - the options which should be used to launch Madkit. If `null`, the dektop mode is automatically used.
      See Also:
        `Madkit.Option`, `Madkit.BooleanOption`, `Madkit.LevelOption`

  - ### Method Detail

    - #### main

          public static void main(String[] options)

      This main could be used to launch a new kernel using predefined options. The new kernel automatically ends when all the agents living on this kernel are done. So the JVM automatically quits if there is no other remaining threads. Basically this call just instantiates a new kernel like this:

           public static void main(String[] options) {
               new Madkit(options);
           }

      So, this main can be used as a MAS application entry point in two ways :

      (1) From the command line:

      For instance, assuming that your classpath is already set correctly:

      `>java madkit.kernel.Madkit agentLogLevel INFO --launchAgents madkit.marketorg.Client,20,true;madkit.marketorg.Broker,10,true;madkit.marketorg.Provider,20,true;`

      (2) It can be used programmatically anywhere, especially within main method of agent classes to ease their launch within an IDE.

      Here is an example of how it can be used in this way:

           public static void main(String[] args) {
               String[] argss = { LevelOption.agentLogLevel.toString(), "FINE", Option.launchAgents.toString(), // gets the -- launchAgents string
                      Client.class.getName() + ",true,20;" + Broker.class.getName() + ",true,10;" + Provider.class.getName() + ",false,20" };
               Madkit.main(argss);// launching the application
           }

      Parameters:
        `options` - the options which should be used to launch Madkit: see `Madkit.LevelOption`, `Madkit.BooleanOption` and `Madkit.Option`

    - #### doAction

          public void doAction(KernelAction action,
                               Object... parameters)

      Makes the kernel do the corresponding action. This is done by sending a message directly to the kernel agent. This should not be used intensively since it is better to control the execution flow of the application using the agents running in the kernel. Still it provides a way to launch and manage a kernel from any java application as a third party service.

           public void somewhereInYourCode() {
                                          ...
                                          Madkit m = new Madkit(args);
                                          ...
                                          m.doAction(KernelAction.LAUNCH_NETWORK); //start the network
                                          ...
                                          m.doAction(KernelAction.LAUNCH_AGENT, new Agent(), true); //launch a new agent with a GUI
                                          ...
           }

      Parameters:
        `action` - the action to request
        `parameters` - the parameters of the request. To work properly, the actual class of the parameters should match the class of the parameters of the underlying targeted method. For instance, for launching an Agent, one must use `m.doAction(KernelAction.LAUNCH_AGENT, new Agent(),Boolean.TRUE);` That is, in this case, using "true" does not work since it is a String.

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

Fabien Michel, Olivier Gutknecht, Jacques Ferber - February 17 2020