public void True_Valid() { WrapErr.ToErrReport(out ErrReport err, 1111, "Validate arg", () => { WrapErr.ChkTrue(true, 8888, "zork error"); }); Assert.AreEqual(0, err.Code, "Should not have been an error"); }
public void True_Fail() { WrapErr.ToErrReport(out ErrReport err, 1111, "Validate arg", () => { WrapErr.ChkTrue(false, 8888, "zork error"); }); this.Validate(err, 8888, "True_Fail", "zork error"); }
/// <summary> /// The derived super state will override if it has some code to execute on the /// Defered transition type /// </summary> /// <param name="msg"></param> /// <returns></returns> protected virtual ISpEventMessage OnRuntimeTransitionRequest(ISpEventMessage msg) { WrapErr.ChkTrue(false, 9999, () => { return(String.Format("Not Overriden to Define Runtime Handling of Defered Transition for {0} State", this.FullName)); }); return(msg); }
/// <summary> /// Add an event to the proper priority queue /// </summary> /// <param name="msg">The msg to add</param> protected override void AddEvent(ISpEventMessage msg) { switch (msg.Priority) { case SpEventPriority.Low: this.lowPriorityQueue.Enqueue(msg); break; case SpEventPriority.Normal: this.NormalPriorityQueue.Enqueue(msg); break; case SpEventPriority.High: this.HighPriorityQueue.Enqueue(msg); break; case SpEventPriority.Urgent: this.UrgentPriorityQueue.Enqueue(msg); break; default: WrapErr.ChkTrue(false, 50150, String.Format("The Priority Type '{0}' is not Handled", msg.Priority)); break; } }
//// TODO - remove this - do not want to copy the event id automatically ?? //public SpBaseEventResponse(TMsgType _type, ISpEventMessage msg, TReturn _return, string returnStatus) // : base(_type, new SpIntToInt(msg.EventId)) { // // Transfer the message guid to the response for correlation // this.Uid = msg.Uid; // this.ReturnCode = this.GetReturnId(_return); // this.ReturnStatus = ReturnStatus; //} //public SpBaseEventResponse(TMsgType _type, TMsgId id, SpEventPriority priority, ISpEventMessage msg, ISpToInt returnCode, string returnStatus) // : base(_type, id, priority) { // // Transfer the message guid to the response for correlation // this.Uid = msg.Uid; // this.ReturnCode = returnCode.ToInt(); // this.ReturnStatus = ReturnStatus; //} private int GetReturnId(TReturn _return) { WrapErr.ChkTrue(typeof(TReturn).IsEnum, 9999, () => string.Format("Return id {0} must be Enum", _return.GetType().Name)); WrapErr.ChkTrue(typeof(TReturn).GetEnumUnderlyingType() == typeof(int), 9999, () => string.Format("Event id enum {0} must be derived from int", _return.GetType().Name)); return(Convert.ToInt32(_return)); }
/// <summary> /// Set the interval in for wakeup for the next Start /// </summary> /// <param name="interval">The interval in </param> public void SetInterval(TimeSpan interval) { WrapErr.ChkDisposed(this.disposed, 50002); WrapErr.ChkTrue(interval.TotalMilliseconds > 0, 50000, "The interval cannot be 0 milliseconds total"); WrapErr.ToErrorReportException(50001, () => { this.timespan = interval; }); }
//private readonly static ClassLog log = new ("FileHelpers"); #endregion /// <summary>Flip all slashes back or forth for cross-platform compatibility</summary> /// <param name="pathString">The path string to convert</param> /// <returns>The converted string</returns> public static string ConvertSlashes(string pathString) { WrapErr.ChkTrue(pathString.Length > 0, 9999, "Empty path string not allowed"); return(WrapErr.ToErrorReportException(9999, "Failed to flip slashes", () => { // Cover all bases by converting forward or back slashes to OS specific string tmp = pathString.Replace('\\', Path.DirectorySeparatorChar); return tmp.Replace('/', Path.DirectorySeparatorChar); })); }
/// <summary>Constructor for Normal Priority messages</summary> /// <param name="_type">The type id to cast to derived for payload retrieval</param> /// <param name="id">The event identifier</param> public SpBaseEventMsg(TMsgType _type, int id) { WrapErr.ChkTrue(typeof(TMsgType).IsEnum, 9999, () => string.Format("Event type {0} must be Enum", _type.GetType().Name)); WrapErr.ChkTrue(typeof(TMsgType).GetEnumUnderlyingType() == typeof(int), 9999, () => string.Format("Event type enum {0} must be derived from int", id.GetType().Name)); this.typeId = Convert.ToInt32(_type); this.eventId = id; this.priority = SpEventPriority.Normal; }
/// <summary> /// Called on every other period after the first /// </summary> /// <param name="msg">The incoming message</param> /// <returns>A state transition object</returns> public virtual ISpStateTransition OnTick(ISpEventMessage msg) { //Log.Info(this.className, "OnTick", String.Format("'{0}' State - {1}", this.FullName, this.ConvertEventIdToString(msg.EventId))); WrapErr.ChkTrue(this.IsEntryExcecuted, 50205, () => { return(String.Format("OnTick for '{0}' State Cannot be Executed Before OnEntry", this.FullName)); }); return(WrapErr.ToErrorReportException(9999, () => { return this.GetTransition(false, this.ExecOnTick, msg); })); }
public IStorageManager <T> GetManager <T>() where T : class { // TODO if (typeof(T).Name == typeof(SettingsDataModel).Name) { return(this.set.Settings as IStorageManager <T>); } ////else if(typeof(T).Name == typeof(TerminatorData).Name) { ////} WrapErr.ChkTrue(false, 9999, () => string.Format("No storage manager for type {0}", typeof(T).Name)); return(null); }
//private readonly static ClassLog log = new ("DirectoryHelpers"); #endregion public static bool CreateStorageDir(string dir) { WrapErr.ToErrReport(out ErrReport report, 9999, () => string.Format("Failed to create directory '{0}'", dir), () => { WrapErr.ChkTrue(dir.Length > 0, 9999, "0 length directory path"); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } }); return(report.Code == 0); }
/// <summary> /// Override and seal the ExecOnExit to automate common super state /// entry functionality. After execution the SuperStateOnExit() /// is called. /// </summary> /// <param name="msg">The incoming message</param> /// <returns>The appropriate return message</returns> protected sealed override void ExecOnExit() { Log.Info(this.className, "ExecOnExit", this.FullName); WrapErr.ChkTrue(this.IsEntryExcecuted, 9999, () => { return(String.Format("ExecOnExit called Before OnEntry {0} State", this.FullName)); }); if (this.currentState != null) { this.currentState.OnExit(); } this.currentState = this.entryState; }
/// <summary> /// Handle the NextState Transition type by setting the next state as /// </summary> /// <param name="tr"></param> /// <param name="msg"></param> /// <returns></returns> private ISpStateTransition HandleNextStateTransitionType(ISpStateTransition tr, ISpEventMessage msg) { Log.Info(this.className, "HandleNextStateTransitionType", String.Format("'{0}' State", this.FullName)); WrapErr.ChkTrue(tr.TransitionType == SpStateTransitionType.NextState, 9999, () => { return(String.Format("{0} is not NextState", tr.TransitionType)); }); WrapErr.ChkVar(tr.NextState, 9999, () => { return (String.Format( "State {0} Specified Next State on Event {1} but Next State Null", this.currentState.FullName, this.GetCachedEventId(msg.EventId))); }); this.currentState.OnExit(); this.currentState = tr.NextState; return(this.currentState.OnEntry(this.MsgFactory.GetDefaultResponse(msg))); }
/// <summary> /// Execute on each tick period /// </summary> /// <param name="msg">The incoming message with event</param> /// <returns>The return transition object with result information</returns> public sealed override ISpStateTransition OnTick(ISpEventMessage msg) { //Log.Info(this.className, "OnTick", String.Format("'{0}' State", this.FullName)); WrapErr.ChkVar(this.entryState, 9999, "The 'SetEntryState() Must be Called in the Constructor"); WrapErr.ChkVar(this.currentState, 9999, "Current state is not set"); WrapErr.ChkTrue(this.IsEntryExcecuted, 9999, "Tick Being Called before OnEntry"); // If there are OnEvent transitions registered at the superstate level return immediately ISpStateTransition tr = GetSuperStateOnEventTransition(msg); if (tr != null) { return(tr); } return(this.GetTransition(this.currentState.OnTick, msg)); }
/// <summary>Remove any leading or trailing '/' or '\' from path string</summary> /// <remarks>Path.Combine needs these off before combining</remarks> /// <param name="pathString">The path string to clean</param> /// <returns>The cleaned path string</returns> public static string CleanLeadAndTrailingSlashes(string pathString) { string tmp = pathString; if (tmp.StartsWith(Path.PathSeparator.ToString())) { tmp = tmp.Remove(0, 1); WrapErr.ChkTrue(tmp.Length > 0, 9999, () => string.Format("Empty path '{0}'", pathString)); } if (tmp.EndsWith(Path.PathSeparator.ToString())) { tmp = tmp.Remove(tmp.Length - 1, 1); WrapErr.ChkTrue(tmp.Length > 0, 9999, () => string.Format("Empty path '{0}'", pathString)); } return(tmp); }
public void True_Fail_WithNullable() { //ErrReport err = new ErrReport(); // To show that it will not flag a nullable error to compiler // because of attribute it knows ChkTrue will throw and so // the operation on null string never happens string?n = null; try { WrapErr.ChkTrue(false, 8889, "zork error"); string x = n; Assert.True(false, "Should not get here"); } catch { Assert.True(true, "Should get here"); } }
/// <summary>Register a transition for a state</summary> /// <param name="type">string of transition type</param> /// <typeparam name="TMsgId">Event id</typeparam> /// <param name="msgId">The event message id</param> /// <param name="transition">Transition object</param> /// <param name="store">Transition store</param> public static void RegisterTransition <TMsgId>(string type, TMsgId msgId, ISpStateTransition <TMsgId>?transition, Dictionary <int, ISpStateTransition <TMsgId> >?store) where TMsgId : struct { //WrapErr.ChkParam(eventId, "msgId", 51004); WrapErr.ChkParam(transition, "transition", 51005); WrapErr.ChkParam(store, "store", 51006); WrapErr.ChkTrue(typeof(TMsgId).IsEnum, 9999, () => string.Format("Transition type {0} must be Enum", msgId.GetType().Name)); WrapErr.ChkTrue(typeof(TMsgId).GetEnumUnderlyingType() == typeof(Int32), 9999, () => string.Format("Transition type enum {0} must be derived from int", msgId.GetType().Name)); int tmp = Convert.ToInt32(msgId); // 51007 - failure of conversion number // Duplicate transitions on same Event is a no no. WrapErr.ChkFalse(store.Keys.Contains(tmp), 51008, () => { return(String.Format("Already Contain a '{0}' Transition for Id:{1}", type, tmp)); }); store.Add(tmp, transition); }
public string IconSource(UIIcon code) { ErrReport report; string source = WrapErr.ToErrReport(out report, 9999, () => string.Format(""), () => { string tmp = ""; this.IconInfo(code, (info) => { tmp = info.IconSource as string; WrapErr.ChkVar(tmp, 9999, () => string.Format("No source string for {0}", code)); WrapErr.ChkTrue(tmp.Length > 0, 9999, () => string.Format("0 length source string for {0}", code)); }, (msg) => { tmp = ""; }); return(tmp); }); return(report.Code == 0 ? source : ""); }
/// <summary> /// Convert an integer to a generic enum /// </summary> /// <typeparam name="T">The enum type</typeparam> /// <param name="value">The integer value to convert from</param> /// <returns>The Enum or an exception on failure to convert</returns> public static T ToEnum <T>(this int value) where T : struct { T enumType = default(T); T ret = WrapErr.ToErrorReportException(9999, () => { return(String.Format( "Enum Conversion Failed Attempting to Convert to Type '{0}' with Value '{1}'", enumType.GetType().Name, value)); }, () => { // This will throw on non enum but not out of range return((T)Enum.Parse(typeof(T), value.ToString())); }); // Do the enum range check WrapErr.ChkTrue(Enum.IsDefined(typeof(T), ret), 9999, () => { return(String.Format( "Enum Conversion Out of Range Attempting to Convert to Type '{0}' with Value '{1}'", enumType.GetType().Name, value)); }); return(ret); }
/// <summary> /// Read the transition object to determine behavior /// </summary> /// <param name="tr">The transition object</param> /// <param name="msg">the current event message</param> /// <param name="superStateLevelEvent"> /// true if the transition object is from the current substate, false if the transition was generated /// by the superstate based on a previous Defered Transition type generated from the substate. This /// prevents infinite recursion. /// </param> /// <returns>A Transtion object with the results of the state processing</returns> ISpStateTransition ReadTransitionType(ISpStateTransition tr, ISpEventMessage msg, bool superStateLevelEvent) { WrapErr.ChkVar(tr, 9999, "The transition is null"); switch (tr.TransitionType) { case SpStateTransitionType.SameState: return(tr); case SpStateTransitionType.NextState: return(this.HandleNextStateTransitionType(tr, msg)); case SpStateTransitionType.ExitState: return(this.HandleExitStateTransitionType(msg)); case SpStateTransitionType.Defered: return(this.HandleDeferedStateTransitionType(tr, msg, superStateLevelEvent)); default: WrapErr.ChkTrue(false, 9999, String.Format("Transition Type {0} not Handled", tr.TransitionType)); return(tr); } }
public void ExceptionType_Regular_False() { CheckExceptionType(() => { WrapErr.ChkTrue(true, 8888, "true"); }); }
public void ExceptionType_Regular_True() { CheckExceptionType(() => { WrapErr.ChkTrue(false, 8888, "false"); }); }