// license-header java merge-point
   //
   // Attention: Generated code! Do not modify by hand!
   // Generated by: hibernate/HibernateEntity.vsl in andromda-hibernate-cartridge.
   //
   package fr.ifremer.quadrige3.core.dao.system.rule;
   
   /*-
    * #%L
   * Quadrige3 Core :: Client API
   * %%
   * Copyright (C) 2017 - 2024 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   * 
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   * 
   * You should have received a copy of the GNU Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  import java.io.Serializable;
  import java.sql.Timestamp;
  import java.util.Collection;
  import java.util.HashSet;
  
  /**
   * Cette table permet de conserver les règles de contrôle
   */
  // HibernateEntity.vsl annotations merge-point
  public abstract class Rule
      implements Serializable, Comparable<Rule>
  {
      /**
       * The serial version UID of this class. Needed for serialization.
       */
      private static final long serialVersionUID = 4559848545964014818L;
  
      // Generate 7 attributes
      private String ruleCd;
  
      /**
       * Code de la règle de contrôle
       * @return this.ruleCd String
       */
      public String getRuleCd()
      {
          return this.ruleCd;
      }
  
      /**
       * Code de la règle de contrôle
       * @param ruleCdIn String
       */
      public void setRuleCd(String ruleCdIn)
      {
          this.ruleCd = ruleCdIn;
      }
  
      private String ruleControledAttribut;
  
      /**
       * Attribut de l'élément contrôlé
       * @return this.ruleControledAttribut String
       */
      public String getRuleControledAttribut()
      {
          return this.ruleControledAttribut;
      }
  
      /**
       * Attribut de l'élément contrôlé
       * @param ruleControledAttributIn String
       */
      public void setRuleControledAttribut(String ruleControledAttributIn)
      {
          this.ruleControledAttribut = ruleControledAttributIn;
      }
  
      private String ruleDc;
  
      /**
       * Description de la règle
       * @return this.ruleDc String
       */
      public String getRuleDc()
      {
          return this.ruleDc;
      }
  
      /**
       * Description de la règle
       * @param ruleDcIn String
      */
     public void setRuleDc(String ruleDcIn)
     {
         this.ruleDc = ruleDcIn;
     }
 
     private String ruleIsActive;
 
     /**
      * Indique si la règle est active ou non
      * @return this.ruleIsActive String
      */
     public String getRuleIsActive()
     {
         return this.ruleIsActive;
     }
 
     /**
      * Indique si la règle est active ou non
      * @param ruleIsActiveIn String
      */
     public void setRuleIsActive(String ruleIsActiveIn)
     {
         this.ruleIsActive = ruleIsActiveIn;
     }
 
     private String ruleIsBlocking;
 
     /**
      * Indique si le non respect de la règle est bloquant ou non
      * @return this.ruleIsBlocking String
      */
     public String getRuleIsBlocking()
     {
         return this.ruleIsBlocking;
     }
 
     /**
      * Indique si le non respect de la règle est bloquant ou non
      * @param ruleIsBlockingIn String
      */
     public void setRuleIsBlocking(String ruleIsBlockingIn)
     {
         this.ruleIsBlocking = ruleIsBlockingIn;
     }
 
     private String ruleErrorMsg;
 
     /**
      * Message d'erreur renvoyé si la règle n'est pas respectée
      * @return this.ruleErrorMsg String
      */
     public String getRuleErrorMsg()
     {
         return this.ruleErrorMsg;
     }
 
     /**
      * Message d'erreur renvoyé si la règle n'est pas respectée
      * @param ruleErrorMsgIn String
      */
     public void setRuleErrorMsg(String ruleErrorMsgIn)
     {
         this.ruleErrorMsg = ruleErrorMsgIn;
     }
 
     private Timestamp updateDt;
 
     /**
      * Date de modification de l'objet, mise à jour par le système
      * @return this.updateDt Timestamp
      */
     public Timestamp getUpdateDt()
     {
         return this.updateDt;
     }
 
     /**
      * Date de modification de l'objet, mise à jour par le système
      * @param updateDtIn Timestamp
      */
     public void setUpdateDt(Timestamp updateDtIn)
     {
         this.updateDt = updateDtIn;
     }
 
     // Generate 7 associations
     private RuleList ruleList;
 
     /**
      * Cette table permet de conserver les listes de règles de contrôle
      * @return this.ruleList RuleList
      */
     public RuleList getRuleList()
     {
         return this.ruleList;
     }
 
     /**
      * Cette table permet de conserver les listes de règles de contrôle
      * @param ruleListIn RuleList
      */
     public void setRuleList(RuleList ruleListIn)
     {
         this.ruleList = ruleListIn;
     }
 
     private Collection<RuleParameter> ruleParameters = new HashSet<RuleParameter>();
 
     /**
      * Cette table permet de conserver les paramètres des règles de contrôle
      * @return this.ruleParameters Collection<RuleParameter>
      */
     public Collection<RuleParameter> getRuleParameters()
     {
         return this.ruleParameters;
     }
 
     /**
      * Cette table permet de conserver les paramètres des règles de contrôle
      * @param ruleParametersIn Collection<RuleParameter>
      */
     public void setRuleParameters(Collection<RuleParameter> ruleParametersIn)
     {
         this.ruleParameters = ruleParametersIn;
     }
 
     /**
      * Cette table permet de conserver les paramètres des règles de contrôle
      * @param elementToAdd RuleParameter
      * @return <tt>true</tt> if this collection changed as a result of the
      *         call
      */
     public boolean addRuleParameters(RuleParameter elementToAdd)
     {
         return this.ruleParameters.add(elementToAdd);
     }
 
     /**
      * Cette table permet de conserver les paramètres des règles de contrôle
      * @param elementToRemove RuleParameter
      * @return <tt>true</tt> if this collection changed as a result of the
      *         call
      */
     public boolean removeRuleParameters(RuleParameter elementToRemove)
     {
         return this.ruleParameters.remove(elementToRemove);
     }
 
     private Function function;
 
     /**
      * Cette table permet de conserver les fonctions de contrôle
      * @return this.function Function
      */
     public Function getFunction()
     {
         return this.function;
     }
 
     /**
      * Cette table permet de conserver les fonctions de contrôle
      * @param functionIn Function
      */
     public void setFunction(Function functionIn)
     {
         this.function = functionIn;
     }
 
     private Collection<RulePmfm> rulePmfms = new HashSet<RulePmfm>();
 
     /**
      * Cette table permet de conserver les PMFM concernés par une règle de contrôle
      * @return this.rulePmfms Collection<RulePmfm>
      */
     public Collection<RulePmfm> getRulePmfms()
     {
         return this.rulePmfms;
     }
 
     /**
      * Cette table permet de conserver les PMFM concernés par une règle de contrôle
      * @param rulePmfmsIn Collection<RulePmfm>
      */
     public void setRulePmfms(Collection<RulePmfm> rulePmfmsIn)
     {
         this.rulePmfms = rulePmfmsIn;
     }
 
     /**
      * Cette table permet de conserver les PMFM concernés par une règle de contrôle
      * @param elementToAdd RulePmfm
      * @return <tt>true</tt> if this collection changed as a result of the
      *         call
      */
     public boolean addRulePmfms(RulePmfm elementToAdd)
     {
         return this.rulePmfms.add(elementToAdd);
     }
 
     /**
      * Cette table permet de conserver les PMFM concernés par une règle de contrôle
      * @param elementToRemove RulePmfm
      * @return <tt>true</tt> if this collection changed as a result of the
      *         call
      */
     public boolean removeRulePmfms(RulePmfm elementToRemove)
     {
         return this.rulePmfms.remove(elementToRemove);
     }
 
     private Collection<RulePrecondition> rulePreconditions = new HashSet<RulePrecondition>();
 
     /**
      * 
      * @return this.rulePreconditions Collection<RulePrecondition>
      */
     public Collection<RulePrecondition> getRulePreconditions()
     {
         return this.rulePreconditions;
     }
 
     /**
      * 
      * @param rulePreconditionsIn Collection<RulePrecondition>
      */
     public void setRulePreconditions(Collection<RulePrecondition> rulePreconditionsIn)
     {
         this.rulePreconditions = rulePreconditionsIn;
     }
 
     /**
      * 
      * @param elementToAdd RulePrecondition
      * @return <tt>true</tt> if this collection changed as a result of the
      *         call
      */
     public boolean addRulePreconditions(RulePrecondition elementToAdd)
     {
         return this.rulePreconditions.add(elementToAdd);
     }
 
     /**
      * 
      * @param elementToRemove RulePrecondition
      * @return <tt>true</tt> if this collection changed as a result of the
      *         call
      */
     public boolean removeRulePreconditions(RulePrecondition elementToRemove)
     {
         return this.rulePreconditions.remove(elementToRemove);
     }
 
     private Collection<RuleGroup> ruleGroups = new HashSet<RuleGroup>();
 
     /**
      * 
      * @return this.ruleGroups Collection<RuleGroup>
      */
     public Collection<RuleGroup> getRuleGroups()
     {
         return this.ruleGroups;
     }
 
     /**
      * 
      * @param ruleGroupsIn Collection<RuleGroup>
      */
     public void setRuleGroups(Collection<RuleGroup> ruleGroupsIn)
     {
         this.ruleGroups = ruleGroupsIn;
     }
 
     /**
      * 
      * @param elementToAdd RuleGroup
      * @return <tt>true</tt> if this collection changed as a result of the
      *         call
      */
     public boolean addRuleGroups(RuleGroup elementToAdd)
     {
         return this.ruleGroups.add(elementToAdd);
     }
 
     /**
      * 
      * @param elementToRemove RuleGroup
      * @return <tt>true</tt> if this collection changed as a result of the
      *         call
      */
     public boolean removeRuleGroups(RuleGroup elementToRemove)
     {
         return this.ruleGroups.remove(elementToRemove);
     }
 
     /**
      * Returns <code>true</code> if the argument is an Rule instance and all identifiers for this entity
      * equal the identifiers of the argument entity. Returns <code>false</code> otherwise.
      */
     @Override
     public boolean equals(Object object)
     {
         if (this == object)
         {
             return true;
         }
         if (!(object instanceof Rule))
         {
             return false;
         }
         final Rule that = (Rule)object;
         if (this.ruleCd == null || that.getRuleCd() == null || !this.ruleCd.equals(that.getRuleCd()))
         {
             return false;
         }
         return true;
     }
 
     /**
      * Returns a hash code based on this entity's identifiers.
      */
     @Override
     public int hashCode()
     {
         int hashCode = 0;
         hashCode = 29 * hashCode + (this.ruleCd == null ? 0 : this.ruleCd.hashCode());
 
         return hashCode;
     }
 
     /**
      * Constructs new instances of {@link Rule}.
      */
     public static final class Factory
     {
         /**
          * Constructs a new instance of {@link Rule}.
          * @return new RuleImpl()
          */
         public static Rule newInstance()
         {
             return new RuleImpl();
         }
 
         /**
          * Constructs a new instance of {@link Rule}, taking all required and/or
          * read-only properties as arguments, except for identifiers.
          * @param ruleControledAttribut String
          * @param function Function
          * @return newInstance
          */
         public static Rule newInstance(String ruleControledAttribut, Function function)
         {
             final Rule entity = new RuleImpl();
             entity.setRuleControledAttribut(ruleControledAttribut);
             entity.setFunction(function);
             return entity;
         }
 
         /**
          * Constructs a new instance of {@link Rule}, taking all possible properties
          * (except the identifier(s))as arguments.
          * @param ruleControledAttribut String
          * @param ruleDc String
          * @param ruleIsActive String
          * @param ruleIsBlocking String
          * @param ruleErrorMsg String
          * @param updateDt Timestamp
          * @param ruleList RuleList
          * @param ruleParameters Collection<RuleParameter>
          * @param function Function
          * @param rulePmfms Collection<RulePmfm>
          * @param rulePreconditions Collection<RulePrecondition>
          * @param ruleGroups Collection<RuleGroup>
          * @return newInstance Rule
          */
         public static Rule newInstance(String ruleControledAttribut, String ruleDc, String ruleIsActive, String ruleIsBlocking, String ruleErrorMsg, Timestamp updateDt, RuleList ruleList, Collection<RuleParameter> ruleParameters, Function function, Collection<RulePmfm> rulePmfms, Collection<RulePrecondition> rulePreconditions, Collection<RuleGroup> ruleGroups)
         {
             final Rule entity = new RuleImpl();
             entity.setRuleControledAttribut(ruleControledAttribut);
             entity.setRuleDc(ruleDc);
             entity.setRuleIsActive(ruleIsActive);
             entity.setRuleIsBlocking(ruleIsBlocking);
             entity.setRuleErrorMsg(ruleErrorMsg);
             entity.setUpdateDt(updateDt);
             entity.setRuleList(ruleList);
             entity.setRuleParameters(ruleParameters);
             entity.setFunction(function);
             entity.setRulePmfms(rulePmfms);
             entity.setRulePreconditions(rulePreconditions);
             entity.setRuleGroups(ruleGroups);
             return entity;
         }
     }
 
     /**
      * @see Comparable#compareTo
      */
     public int compareTo(Rule o)
     {
         int cmp = 0;
         if (this.getRuleCd() != null)
         {
             cmp = this.getRuleCd().compareTo(o.getRuleCd());
         }
         else
         {
             if (this.getRuleControledAttribut() != null)
             {
                 cmp = (cmp != 0 ? cmp : this.getRuleControledAttribut().compareTo(o.getRuleControledAttribut()));
             }
             if (this.getRuleDc() != null)
             {
                 cmp = (cmp != 0 ? cmp : this.getRuleDc().compareTo(o.getRuleDc()));
             }
             if (this.getRuleIsActive() != null)
             {
                 cmp = (cmp != 0 ? cmp : this.getRuleIsActive().compareTo(o.getRuleIsActive()));
             }
             if (this.getRuleIsBlocking() != null)
             {
                 cmp = (cmp != 0 ? cmp : this.getRuleIsBlocking().compareTo(o.getRuleIsBlocking()));
             }
             if (this.getRuleErrorMsg() != null)
             {
                 cmp = (cmp != 0 ? cmp : this.getRuleErrorMsg().compareTo(o.getRuleErrorMsg()));
             }
             if (this.getUpdateDt() != null)
             {
                 cmp = (cmp != 0 ? cmp : this.getUpdateDt().compareTo(o.getUpdateDt()));
             }
         }
         return cmp;
     }
 // HibernateEntity.vsl merge-point
 // Rule.java merge-point
 }