/// <summary>
 ///     Constructor
 /// </summary>
 /// <param name="id"></param>
 /// <param name="instance"></param>
 /// <param name="priority"></param>
 public ModelEvent(string id, INamable instance, acceptor.RulePriority? priority)
 {
     Id = id;
     Message = id;
     Instance = instance;
     Priority = priority;
 }

 /// <summary>
 ///     Constructor
 /// </summary>
 /// <param name="id"></param>
 public RuleFired(Runner.Activation activation, acceptor.RulePriority priority)
     : base(activation.RuleCondition.Name, activation.RuleCondition, priority)
 {
     Activation = activation;
     Explanation = Activation.Explanation;
     Updates = new List<VariableUpdate>();
 }

 public void setMessageType(acceptor.DBMessageType v)
 {
     aMessageType = v;
       __setDirty(true);
       NotifyControllers(null);
 }

        /// <summary>
        ///     Creates an range in the namespace provided
        /// </summary>
        /// <param name="enclosing"></param>
        /// <param name="name"></param>
        /// <param name="precision"></param>
        /// <param name="minValue"></param>
        /// <param name="maxValue"></param>
        /// <returns></returns>
        protected Range CreateRange(NameSpace enclosing, string name, acceptor.PrecisionEnum precision, string minValue,
            string maxValue)
        {
            Range retVal = (Range) Factory.createRange();

            enclosing.appendRanges(retVal);
            retVal.Name = name;
            retVal.setPrecision(precision);
            retVal.MinValue = minValue;
            retVal.MaxValue = maxValue;

            return retVal;
        }

 /// <summary>
 /// Indicates that a rule is applicable for this type at the provided priority
 /// </summary>
 /// <returns></returns>
 public virtual bool ApplicableRule(acceptor.RulePriority priority)
 {
     return false;
 }

 public void setVariableMode(acceptor.VariableModeEnumType v)
 {
     aVariableMode = v;
       __setDirty(true);
       NotifyControllers(null);
 }

 public void setTimeDelay(acceptor.TimeDelay v)
 {
     aTimeDelay = v;
       __setDirty(true);
       NotifyControllers(null);
 }

 public void setLevelOUT(acceptor.ST_LEVEL v)
 {
     aLevelOUT = v;
       __setDirty(true);
       NotifyControllers(null);
 }

 public void setImplementationStatus(acceptor.SPEC_IMPLEMENTED_ENUM v)
 {
     aImplementationStatus = v;
       __setDirty(true);
       NotifyControllers(null);
 }

 public static acceptor getUnique()
 {
     if (theOne == null) { theOne = new acceptor(); }
       return theOne;
 }

 public void setMedia(acceptor.Message_media v)
 {
     aMedia = v;
       __setDirty(true);
       NotifyControllers(null);
 }

 public void setType(acceptor.meaning_type v)
 {
     aType = v;
       __setDirty(true);
       NotifyControllers(null);
 }

 public void setMaximum(acceptor.maximum_Value v)
 {
     aMaximum = v;
       __setDirty(true);
       NotifyControllers(null);
 }

 public void setKind(acceptor.ExpectationKind v)
 {
     aKind = v;
       __setDirty(true);
       NotifyControllers(null);
 }

 public void setCyclePhase(acceptor.RulePriority v)
 {
     aCyclePhase = v;
       __setDirty(true);
       NotifyControllers(null);
 }

 public void setInterface(acceptor.ST_INTERFACE v)
 {
     aInterface = v;
       __setDirty(true);
       NotifyControllers(null);
 }

 public void setIO(acceptor.ST_IO v)
 {
     aIO = v;
       __setDirty(true);
       NotifyControllers(null);
 }

 public void setObsoleteScope(acceptor.Paragraph_scope v)
 {
     aObsoleteScope = v;
       __setDirty(true);
       NotifyControllers(null);
 }

 public void setModeOUT(acceptor.ST_MODE v)
 {
     aModeOUT = v;
       __setDirty(true);
       NotifyControllers(null);
 }

 public void setErtms_type(acceptor.TypeSpec_ertms_type v)
 {
     aErtms_type = v;
       __setDirty(true);
       NotifyControllers(null);
 }