[Fudaa-svn-commit] SF.net SVN: fudaa:[6511] trunk/framework/ctulu-common/src/main/java/org/ fudaa/ctulu

[<de...@us...>]

Revision: 6511
          http://fudaa.svn.sourceforge.net/fudaa/?rev=6511&view=rev
Author:   deniger
Date:     2011-10-10 19:28:38 +0000 (Mon, 10 Oct 2011)
Log Message:
-----------


Modified Paths:
--------------
    trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluAnalyzeGroup.java
    trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluDefaultLogFormatter.java

Added Paths:
-----------
    trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLog.java
    trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLogGroup.java
    trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLogLevel.java
    trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLogRecord.java

Modified: trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluAnalyzeGroup.java
===================================================================
--- trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluAnalyzeGroup.java	2011-10-10 16:03:53 UTC (rev 6510)
+++ trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluAnalyzeGroup.java	2011-10-10 19:28:38 UTC (rev 6511)
@@ -6,8 +6,7 @@
 import java.util.ResourceBundle;
 
 /**
- * Manager qui indique toutes les erreurs,messages qui se sont produites pendant le chargement. Le titre principal est
- * g\xE9r\xE9 par
+ * Manager qui indique toutes les erreurs,messages qui se sont produites pendant le chargement. 
  * 
  * @author Adrien Hadoux
  */
@@ -134,7 +133,7 @@
   }
 
   /**
-   * @return la liste des anayliser utilis\xE9
+   * @return la liste des anayliser utilis�
    */
   public List<CtuluAnalyze> getAnalyser() {
     return analyser;

Modified: trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluDefaultLogFormatter.java
===================================================================
--- trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluDefaultLogFormatter.java	2011-10-10 16:03:53 UTC (rev 6510)
+++ trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluDefaultLogFormatter.java	2011-10-10 19:28:38 UTC (rev 6511)
@@ -11,7 +11,7 @@
   /**
    * Formateur par defaut pour les logs
    */
-  public final static Formatter DEFAULT = new CtuluDefaultLogFormatter();
+  public final static CtuluDefaultLogFormatter DEFAULT = new CtuluDefaultLogFormatter();
 
   private boolean printLevel = true;
 
@@ -23,6 +23,10 @@
   public CtuluDefaultLogFormatter() {
   // EMPTY
   }
+  
+  public String formatLogs(CtuluLogRecord log){
+    return "a faire";
+  }
 
   /**
    * @param logAnalyse l'analyse a formater
@@ -56,6 +60,18 @@
     }
     return res.toString();
   }
+  /**
+   * @param logs l'analyse a formater
+   * @return la string contenant le tout
+   */
+  public static String formatLogs(final Collection<CtuluLogRecord> logs) {
+    if (logs == null) { return CtuluLibString.EMPTY_STRING; }
+    final StringBuilder res = new StringBuilder(10 + logs.size() * 40);
+    for (final CtuluLogRecord logRecord : logs) {
+      res.append('\n').append(DEFAULT.formatLogs(logRecord));
+    }
+    return res.toString();
+  }
 
   @Override
   public synchronized String format(final LogRecord record) {

Added: trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLog.java
===================================================================
--- trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLog.java	                        (rev 0)
+++ trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLog.java	2011-10-10 19:28:38 UTC (rev 6511)
@@ -0,0 +1,484 @@
+/*
+ * @creation 20 fevr. 2003
+ * 
+ * @modification $Date: 2007-05-21 10:28:29 $
+ * 
+ * @license GNU General Public License 2
+ * 
+ * @copyright (c)1998-2001 CETMEF 2 bd Gambetta F-60231 Compiegne
+ * 
+ * @mail de...@fu...
+ */
+package org.fudaa.ctulu;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.LineNumberReader;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.ResourceBundle;
+import java.util.logging.LogRecord;
+
+/**
+ * Cette classe sert a transmettre les informations d'une operation de lecture ou d'ecriture. Les informations et les
+ * erreurs de l'operation sont stockees avec eventuellement leur numero de ligne.
+ * 
+ * @author deniger
+ * @version $Id: CtuluAnalyze.java,v 1.12 2007-05-21 10:28:29 deniger Exp $
+ */
+public class CtuluLog {
+
+
+  /**
+   * Constructeur par defaut
+   */
+  public CtuluLog() {
+    super();
+  }
+
+  /**
+   * Constructeur precisant le resourceBundle a utiliser
+   * 
+   * @param defaultResourceBundle
+   */
+  public CtuluLog(final ResourceBundle defaultResourceBundle) {
+    super();
+    this.defaultResourceBundle = defaultResourceBundle;
+  }
+
+  ResourceBundle defaultResourceBundle;
+
+  private String desc = "Analyzing";
+
+  protected final List<CtuluLogRecord> logs = new ArrayList<CtuluLogRecord>();
+
+  private String ressource;
+
+  /**
+   * @param msg le message
+   */
+  public void addError(final String msg) {
+    addRecord(CtuluLogLevel.ERROR, msg);
+  }
+
+  /**
+   * @param msg le message
+   * @param e l'erreur
+   */
+  public void addError(final String msg, final Throwable e) {
+    addRecord(CtuluLogLevel.ERROR, msg).setThrown(e);
+  }
+
+  /**
+   * @param msg le message
+   * @param data
+   */
+  public void addError(final String msg, Object... data) {
+    addRecord(CtuluLogLevel.ERROR, msg, data);
+  }
+
+  /**
+   * @param msg le message
+   * @param data
+   * @param e l'erreur
+   */
+  public void addErrorThrown(final String msg, final Throwable e, Object... data) {
+    addRecord(CtuluLogLevel.ERROR, msg, data).setThrown(e);
+  }
+
+  /**
+   * @param msg
+   * @param i
+   */
+  public void addErrorFromFile(final String msg, final int i) {
+    addRecord(CtuluLogLevel.ERROR, msg, Integer.valueOf(i));
+  }
+
+  /**
+   * @param msg le message
+   * @param reader le reader occasionnant l'erreur
+   */
+  public void addErrorFromFile(final String msg, final LineNumberReader reader) {
+    addRecord(CtuluLogLevel.ERROR, msg, reader.getLineNumber());
+  }
+
+  /**
+   * @param msg le message
+   * @param data les donnees complementaire
+   * @param i le numero de ligne de l'erreur
+   */
+  public void addErrorFromFile(final String msg, final int i, Object... data) {
+    if (data == null) {
+      addRecord(CtuluLogLevel.ERROR, msg, i);
+    } else {
+      Object[] all = new Object[data.length + 1];
+      System.arraycopy(data, 0, all, 1, data.length);
+      all[0] = i;
+      addRecord(CtuluLogLevel.ERROR, msg, all);
+    }
+  }
+
+  /**
+   * @param msg le message
+   * @param data les donnees complementaire
+   * @param reader le reader occasionnant l'erreur
+   */
+  public void addErrorFromFile(final String msg, final LineNumberReader reader, Object... data) {
+    addErrorFromFile(msg, reader.getLineNumber(), data);
+  }
+
+  /**
+   * @param _m le message
+   */
+  public void addFatalError(final String _m) {
+    addRecord(CtuluLogLevel.FATAL, _m);
+  }
+
+  /**
+   * Initialise le champ "erreur fatale". Si une erreur fatale a deja ete initialisee, ne fait rien.
+   * 
+   * @param _m le message
+   * @param _index le num de ligne
+   */
+  public void addFatalError(final String _m, final int _index) {
+    addRecord(CtuluLogLevel.FATAL, _m, Integer.valueOf(_index));
+  }
+
+  /**
+   * @param _m
+   * @param arg
+   */
+  public void addFatalError(final String _m, final Object... arg) {
+    addRecord(CtuluLogLevel.FATAL, _m, arg);
+  }
+
+  /**
+   * Initialise le champ "erreur fatale". Si une erreur fatale a deja ete initialisee, ne fait rien.
+   * 
+   * @param _m le message
+   * @param _in pour recuperer le num de ligne
+   */
+  public void addFatalError(final String _m, final LineNumberReader _in) {
+    addFatalError(_m, _in == null ? -1 : _in.getLineNumber());
+  }
+
+  /**
+   * @param msg le message d'info a ajouter
+   */
+  public void addInfo(final String msg) {
+    addRecord(CtuluLogLevel.INFO, msg);
+  }
+
+  /**
+   * @param msg
+   * @param args
+   */
+  public void addInfo(final String msg, final Object... args) {
+    addRecord(CtuluLogLevel.INFO, msg, args);
+  }
+
+  /**
+   * @param msg le message d'info a ajouter
+   * @param _index l'index identifiant le message (peut etre un numero de ligne)
+   */
+  public void addInfoFromFile(final String msg, final int _index) {
+    addRecord(CtuluLogLevel.INFO, msg, _index);
+  }
+
+  /**
+   * @param msg
+   * @param i
+   * @param data
+   */
+  public void addInfoFromFile(final String msg, final int i, Object... data) {
+    addRecord(CtuluLogLevel.INFO, msg, i, data);
+  }
+
+  /**
+   * @param msg le message d'info a ajouter
+   * @param _in le reader permettant de recuperer le numero de ligne
+   */
+  public void addInfoFromFile(final String msg, final LineNumberReader _in) {
+    addRecord(CtuluLogLevel.INFO, msg, _in.getLineNumber());
+  }
+
+  // /**
+  // * @param level le level
+  // * @param msg le message
+  // * @return le logRecord ajoute
+  // */
+  // public LogRecord addRecord(final Level level, final String msg) {
+  // return addRecord(level, msg, null);
+  // }
+
+  /**
+   * @param level le level
+   * @param msg le message
+   * @param data les donnees complementaire
+   * @return le logRecord ajoute
+   */
+  public CtuluLogRecord addRecord(final CtuluLogLevel level, final String msg, Object... data) {
+    final CtuluLogRecord o = new CtuluLogRecord(level, msg);
+    o.setArgs(data);
+    logs.add(o);
+    return o;
+  }
+
+  /**
+   * @param msg le message d'avertissement
+   */
+  public void addWarn(final String msg) {
+    addRecord(CtuluLogLevel.WARNING, msg);
+  }
+
+  /**
+   * @param msg le message d'avertissement
+   * @param in le reader permettant de recuperer le numero de ligne
+   */
+  public void addWarn(final String msg, final LineNumberReader in) {
+    addRecord(CtuluLogLevel.WARNING, msg, in.getLineNumber());
+  }
+
+  /**
+   * @param msg le message d'avertissement
+   * @param args les arguments supplementaires
+   */
+  // public void addWarn(final String msg, final Map<String, Object> args) {
+  public void addWarn(final String msg, final Object... args) {
+    addRecord(CtuluLogLevel.WARNING, msg, args);
+  }
+
+  /**
+   * @param msg le message d'avertissement
+   * @param index le numero identifiant le message
+   */
+  public void addWarnFromFile(final String msg, final int index) {
+    addRecord(CtuluLogLevel.WARNING, msg, index);
+  }
+
+  /**
+   * @param _m
+   */
+  @Deprecated
+  public void changeFatalError(final String _m) {
+    addError(_m);
+  }
+
+  /**
+   * Efface tous les canaux.
+   */
+  public void clear() {
+    logs.clear();
+  }
+
+  public boolean containsErrorOrFatalError() {
+    return containsErrors() || containsFatalError();
+  }
+
+  /**
+   * @return true si contient au moins une erreur
+   */
+  public boolean containsErrors() {
+    return containsLevel(CtuluLogLevel.ERROR);
+  }
+
+  /**
+   * @return true si contient une erreur fatale
+   */
+  public boolean containsFatalError() {
+    return containsLevel(CtuluLogLevel.FATAL);
+  }
+
+  /**
+   * @return true si contient au moins une info
+   */
+  public boolean containsInfos() {
+    return containsLevel(CtuluLogLevel.INFO);
+  }
+
+  /**
+   * @param l le level a tester
+   * @return true si au moins un message et de niveau l.
+   */
+  public boolean containsLevel(final CtuluLogLevel l) {
+    for (final CtuluLogRecord log : logs) {
+      if (l.equals(log.getLevel())) { return true; }
+    }
+    return false;
+  }
+
+  /**
+   * @return true si contient au moins un avertissement
+   */
+  public boolean containsWarnings() {
+    return containsLevel(CtuluLogLevel.WARNING);
+  }
+
+  /**
+   * @return the defaultResourceBundle
+   */
+  public ResourceBundle getDefaultResourceBundle() {
+    return defaultResourceBundle;
+  }
+
+  /**
+   * @return la description de l'analyse en cours
+   */
+  public String getDesc() {
+    return desc;
+  }
+
+  /**
+   * @return l'ensemble des enregistrements de log
+   */
+  public Collection<CtuluLogRecord> getRecords() {
+    return Collections.unmodifiableCollection(logs);
+  }
+
+  /**
+   * @return chaine decrivant la ressource ( fichier, url, ...)
+   */
+  public String getResource() {
+    return ressource;
+  }
+
+  /**
+   * @return le resume de l'analyse
+   */
+  public String getResume() {
+    return getDesc() + "\n" + CtuluDefaultLogFormatter.formatLogs(logs);
+  }
+  
+  public String getFatalError() {
+    CtuluLogRecord log = getFirstOfLevel(CtuluLogLevel.FATAL );
+    return log == null ? null : CtuluDefaultLogFormatter.DEFAULT.formatLogs(log);
+  }
+  
+  /**
+   * @param l le level a tester
+   * @return true si au moins un message et de niveau l.
+   */
+  private CtuluLogRecord getFirstOfLevel(final CtuluLogLevel l) {
+    for (final CtuluLogRecord log : logs) {
+      if (l.equals(log.getLevel())) { return log; }
+    }
+    return null;
+  }
+
+  /**
+   * @return true si vide
+   */
+  public boolean isEmpty() {
+    return logs.isEmpty();
+  }
+
+  public boolean isNotEmpty() {
+    return !isEmpty();
+  }
+
+  /**
+   * @param _e l'exception a ajouter a l'anayse
+   */
+  public void manageException(final Exception _e) {
+    manageException(_e, "exception.occured");
+  }
+
+  /**
+   * @param _e l'exception a ajouter a l'anayse
+   * @param msg le message
+   */
+  public void manageException(final Exception _e, final String msg) {
+    addRecord(CtuluLogLevel.ERROR, msg).setThrown(_e);
+    _e.printStackTrace();
+  }
+
+  /**
+   * Ajoute un message d'erreur.
+   * 
+   * @param _e l'exception a loguer
+   */
+  public void manageException(final FileNotFoundException _e) {
+    manageException(_e, "exception.FileNotFoundException");
+  }
+
+  /**
+   * @param _e l'exception a ajouter a l'anayse
+   */
+  public void manageException(final IllegalArgumentException _e) {
+    manageException(_e, "exception.IllegalArgumentException");
+  }
+
+  /**
+   * Ajoute un message d'erreur.
+   * 
+   * @param _e l'exception a loguer
+   */
+  public void manageException(final IOException _e) {
+    manageException(_e, "exception.IOException");
+  }
+
+  /**
+   * @param _e l'exception a ajouter a l'anayse
+   * @param _l le numero de ligne
+   */
+  public void manageException(final NumberFormatException _e, final int _l) {
+    manageException(_e, "exception.NumberFormatException");
+  }
+
+  /**
+   * @param _e l'exception a ajouter a l'anayse
+   * @param msg le message
+   * @param line la ligne
+   */
+  public void manageExceptionFromFile(final Exception _e, final String msg, final int line) {
+    addRecord(CtuluLogLevel.ERROR, msg, line).setThrown(_e);
+  }
+  
+
+  public String getDesci18n() {
+    if (defaultResourceBundle == null) return desc;
+    return defaultResourceBundle.getString(desc);
+  }
+
+  /**
+   * Ajoute tous les canaux de l'analyse passee en parametres. Les pointeurs sont copiees.
+   * 
+   * @param _analyze l'analyse a ajouter a celle-ci
+   */
+  public void merge(final CtuluLog _analyze) {
+    setDesc(_analyze.getDesc());
+    setDefaultResourceBundle(_analyze.getDefaultResourceBundle());
+    setResource(_analyze.getResource());
+    logs.addAll(_analyze.logs);
+  }
+
+  /**
+   * Permet d'ecrire sur la sortie standart le contenu de cette analyse.
+   */
+  public void printResume() {
+    System.err.println(getResume());// NOPMD
+  }
+
+  /**
+   * @param defaultResourceBundle the defaultResourceBundle to set
+   */
+  public void setDefaultResourceBundle(final ResourceBundle defaultResourceBundle) {
+    this.defaultResourceBundle = defaultResourceBundle;
+  }
+
+  /**
+   * @param _string la nouvelle description de l'analyse
+   */
+  public void setDesc(final String _string) {
+    desc = _string;
+  }
+
+  /**
+   * @param _string la nouvelle ressource de l'analyse
+   */
+  public void setResource(final String _string) {
+    ressource = _string;
+  }
+}
\ No newline at end of file

Added: trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLogGroup.java
===================================================================
--- trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLogGroup.java	                        (rev 0)
+++ trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLogGroup.java	2011-10-10 19:28:38 UTC (rev 6511)
@@ -0,0 +1,201 @@
+package org.fudaa.ctulu;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.ResourceBundle;
+
+/**
+ * Manager qui indique toutes les erreurs,messages qui se sont produites pendant le chargement. 
+ * 
+ * @author Adrien Hadoux
+ */
+public class CtuluLogGroup {
+
+  private List<CtuluAnalyze> analyser = new ArrayList<CtuluAnalyze>();
+  private CtuluAnalyze mainAnalyze = new CtuluAnalyze();
+
+  /**
+   * 
+   */
+  List<CtuluLogGroup> groups;
+
+  List<CtuluLogGroup> groupsExt;
+
+  ResourceBundle defaultResource;
+
+  public CtuluLogGroup(ResourceBundle defaultResource) {
+    super();
+    analyser.add(mainAnalyze);
+    this.defaultResource = defaultResource;
+  }
+
+  public void addAnalyzer(CtuluAnalyze analyze) {
+    analyser.add(analyze);
+  }
+
+  // /**
+  // * Ajoute un message d'erreur au tout dernier analyzer dispo.
+  // *
+  // * @param message
+  // */
+  // public void addMessageError(final String message) {
+  // analyser.get(analyser.size() - 1).addError(message);
+  // }
+
+  public void clear() {
+    analyser.clear();
+  }
+
+  public CtuluAnalyze getNewAnalyser(String desc) {
+    CtuluAnalyze analyzer = createAnalyzer();
+    analyzer.setDesc(desc);
+    analyser.add(analyzer);
+    return analyzer;
+  }
+
+  /**
+   * @return true si un analyseur contient des erreur
+   */
+  public boolean containsError() {
+    if (isContentEmpty()) { return false; }
+    for (CtuluAnalyze analyze : analyser) {
+      if (analyze.containsFatalError() || analyze.containsErrors()) { return true; }
+    }
+    if (groups != null) {
+      for (CtuluLogGroup mng : groups) {
+        if (mng.containsError()) { return true; }
+      }
+    }
+    return false;
+  }
+
+  public boolean containsFatalError() {
+    if (isContentEmpty()) { return false; }
+    for (CtuluAnalyze analyze : analyser) {
+      if (analyze.containsFatalError()) { return true; }
+    }
+    if (groups != null) {
+      for (CtuluLogGroup mng : groups) {
+        if (mng.containsFatalError()) { return true; }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * @return true si les analyseur ne sont pas vide
+   */
+  public boolean containsSomething() {
+    if (isContentEmpty()) { return false; }
+    for (CtuluAnalyze analyze : analyser) {
+      if (!analyze.isEmpty()) { return true; }
+    }
+    if (groups != null) {
+      for (CtuluLogGroup mng : groups) {
+        if (mng.containsSomething()) { return true; }
+      }
+    }
+    return false;
+  }
+
+  public boolean containsWarning() {
+    if (isContentEmpty()) { return false; }
+    for (CtuluAnalyze analyze : analyser) {
+      if (analyze.containsWarnings()) { return true; }
+    }
+    if (groups != null) {
+      for (CtuluLogGroup mng : groups) {
+        if (mng.containsWarning()) { return true; }
+      }
+    }
+    return false;
+  }
+
+  private CtuluAnalyze createAnalyzer() {
+    CtuluAnalyze analyzer = new CtuluAnalyze();
+    analyzer.setDefaultResourceBundle(defaultResource);
+    return analyzer;
+  }
+
+  /**
+   * @param name la nom du sous-groupe
+   * @return le sous-groupe ajoute.
+   */
+  public CtuluLogGroup createGroup(String name) {
+    CtuluLogGroup res = new CtuluLogGroup(defaultResource);
+    res.getMainAnalyze().setDesc(name);
+    if (groups == null) {
+      groups = new ArrayList<CtuluLogGroup>();
+    }
+    groups.add(res);
+    return res;
+  }
+
+  /**
+   * @return la liste des anayliser utilis�
+   */
+  public List<CtuluAnalyze> getAnalyser() {
+    return analyser;
+  }
+
+  /**
+   * @return the groups
+   */
+  public List<CtuluLogGroup> getGroups() {
+    if (groups == null) { return Collections.emptyList(); }
+    if (groupsExt == null) {
+      groupsExt = Collections.unmodifiableList(groups);
+    }
+    return groupsExt;
+  }
+
+  /**
+   * retourne le dernier ctuluanalyze cree.
+   * 
+   * @param message
+   * @return
+   */
+  public CtuluAnalyze getLastAnalyser() {
+    return analyser.get(analyser.size() - 1);
+  }
+
+  /**
+   * @return the mainAnalyze
+   */
+  public CtuluAnalyze getMainAnalyze() {
+    return mainAnalyze;
+  }
+
+  public String getMainDesc() {
+    return mainAnalyze.getDesc();
+  }
+
+  /**
+   * Ajoute un nouvel ctuluanalyze a la liste et le fournit.
+   * 
+   * @return
+   */
+  public CtuluAnalyze getNewAnalyser() {
+    CtuluAnalyze analyzer = createAnalyzer();
+    // ajout dans la liste des analyze
+    analyser.add(analyzer);
+    return analyzer;
+  }
+
+  private boolean isContentEmpty() {
+    return CtuluLibArray.isEmpty(analyser) && CtuluLibArray.isEmpty(groups);
+  }
+
+  public void setListeMessageError(final List<CtuluAnalyze> listeMessageError) {
+    this.analyser = listeMessageError;
+  }
+
+  /**
+   * @param mainAnalyze the mainAnalyze to set
+   */
+  public void setMainAnalyze(CtuluAnalyze mainAnalyze) {
+    this.mainAnalyze = mainAnalyze;
+  }
+
+}

Added: trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLogLevel.java
===================================================================
--- trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLogLevel.java	                        (rev 0)
+++ trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLogLevel.java	2011-10-10 19:28:38 UTC (rev 6511)
@@ -0,0 +1,16 @@
+package org.fudaa.ctulu;
+
+
+/**
+ * Level used in log
+ * 
+ * @author deniger
+ */
+public enum CtuluLogLevel {
+
+  INFO,
+  WARNING,
+  ERROR,
+  FATAL;
+
+}

Added: trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLogRecord.java
===================================================================
--- trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLogRecord.java	                        (rev 0)
+++ trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/CtuluLogRecord.java	2011-10-10 19:28:38 UTC (rev 6511)
@@ -0,0 +1,56 @@
+package org.fudaa.ctulu;
+
+
+public class CtuluLogRecord {
+  
+  private Object[] args;
+  private CtuluLogLevel level;
+  private String msg;
+  private Throwable thrown;
+  /**
+   * @param level
+   * @param msg
+   */
+  public CtuluLogRecord(CtuluLogLevel level, String msg) {
+    super();
+    this.level = level;
+    this.msg = msg;
+  }
+  /**
+   * @return the args
+   */
+  public Object[] getArgs() {
+    return args;
+  }
+  /**
+   * @return the level
+   */
+  public CtuluLogLevel getLevel() {
+    return level;
+  }
+  /**
+   * @return the msg
+   */
+  public String getMsg() {
+    return msg;
+  }
+  /**
+   * @param args the args to set
+   */
+  public void setArgs(Object[] args) {
+    this.args = args;
+  }
+  /**
+   * @return the thrown
+   */
+  public Throwable getThrown() {
+    return thrown;
+  }
+  /**
+   * @param thrown the thrown to set
+   */
+  public void setThrown(Throwable thrown) {
+    this.thrown = thrown;
+  }
+
+}

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.