/**********************************************************************************************//** * Replace value. * * \author Ilan Hindy * \date 29/09/2016 * * \return An IndexCreatingOperation. * . **************************************************************************************************/ private IndexCreatingOperation replaceValue() { bool converted; object value = TypesUtility.Parse(list.GetType().GenericTypeArguments[0], TextBox_Replace_AddValue.Text, out converted); if (converted) { if (ListBox_Elements.SelectedIndex >= 0) { TypesUtility.InvokeMethodOfList(list, "RemoveAt", new object[] { ListBox_Elements.SelectedIndex }, false); TypesUtility.InvokeMethodOfList(list, "Insert", new object[] { ListBox_Elements.SelectedIndex, value }, false); return(IndexCreatingOperation.Current); } else { TypesUtility.InvokeMethodOfList(list, "Add", new object[] { value }, false); return(IndexCreatingOperation.Start); } } else { CustomizedMessageBox.Show("Cannot convert value " + TextBox_AddValue.Text + " to type " + list.GetType().GenericTypeArguments[0].ToString(), "List Input Message", Icons.Error); return(IndexCreatingOperation.Start); } }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn private Attribute GetExistingChildAttribute(dynamic key, Attribute newAttribute) /// /// \brief Gets existing child attribute. /// /// \par Description. /// There can be the following cases /// -# The attribute is found in both lists/dictionaries (So the attribute will be found) /// -# The attribute is found only in the exists list /// In this case There was a merge between the lists\dictionaries that puts the attributes /// of the existing in the new so the attribute will be found /// -# The attribute exists in the new and the exists - In this case the method returns null /// that will cause the algorithm to skip on all the attribute tree /// /// /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 28/12/2017 /// /// \param key (dynamic) - The key. /// \param newAttribute (Attribute) - The new attribute. /// /// \return The existing child attribute. //////////////////////////////////////////////////////////////////////////////////////////////////// private Attribute GetExistingChildAttribute(dynamic key, Attribute newAttribute) { Attribute existingComplexAttribute = complexAttributes.Peek(); string s = ""; Attribute result = null; if (Attribute.GetValueCategory(existingComplexAttribute) == Attribute.AttributeCategory.ListOfAttributes) { s = "Tring to find IdInList : " + newAttribute.IdInList.ToString(); result = ((AttributeList)existingComplexAttribute.Value).GetAttribute(newAttribute.IdInList.ToString()); } if (Attribute.GetValueCategory(existingComplexAttribute) == Attribute.AttributeCategory.AttributeDictionary) { s = "Tring to find attribute with key " + TypesUtility.GetKeyToString(key); result = ((AttributeDictionary)existingComplexAttribute.Value).GetAttribute(key); } if (Attribute.GetValueCategory(existingComplexAttribute) == Attribute.AttributeCategory.NetworkElementAttribute) { result = ((NetworkElement)existingComplexAttribute.Value).GetDictionaryAttribute(key); } if (result == null) { s += " failed : "; MessageRouter.ReportMessage("NetworkUpdate - retrieve existing child", "", s); } return(result); }
public Breakpoint(HostingElementTypes hostingElementType) : base(true) { Init(0); or[brp.ork.HostingElementType] = hostingElementType; or[brp.ork.Name] = TypesUtility.GetKeyToString(hostingElementType) + " Breakpoint"; }
/**********************************************************************************************//** * Writes to edit log file. * * \author Ilan Hindy * \date 16/01/2017 * * \param sender The sender. * \param messageLines The message lines. * \param result The result. * \param icon The icon. **************************************************************************************************/ public static string WriteOperationToEditLogFile(string sender, string [] messageLines, Icons icon, bool newLineAtTheEnd = true) { string timeString = DateTime.Now.ToString("dd/MM/yyyy hh:mm:ss.fff"); string iconString = TypesUtility.GetKeyToString(icon); string header = timeString + " " + sender + iconString + " : "; string emptySpaces = new string(' ', header.Length); header += messageLines[0] + "\r\n"; string log = header; for (int idx = 1; idx < messageLines.Length; idx++) { log += emptySpaces + messageLines[idx]; } if (!newLineAtTheEnd) { log = log.Remove(log.Length - 3); } // The config is loaded before the edit log file is opened so we save the // logs untill the the file is opened and then dump them at the beginning of the log if (editTraceListener == null) { logsBeforeConfigLoad.Add(log); } else { editTraceListener.WriteLine(log); editTraceListener.Flush(); } return(emptySpaces); }
/**********************************************************************************************//** * Init combo boxes. * * \author Ilan Hindy * \date 29/09/2016 * **************************************************************************************************/ private void InitComboBoxes() { FillComboBox(ComboBox_SelectCategory, TypesUtility.GetTypesCategories()); ComboBox_SelectCategory.SelectedIndex = 0; FillComboBox(ComboBox_SelectType, TypesUtility.GetTypesOfCategory((string)ComboBox_SelectCategory.SelectedItem)); ComboBox_SelectType.SelectedIndex = 0; }
/**********************************************************************************************//** * Constructor. * * \author Ilan Hindy * \date 29/09/2016 * * \param list The list. * \param network The network. * \param Editable (Optional) True if editable. * **************************************************************************************************/ public ListInput(object list, BaseNetwork network, bool Editable = true) { this.network = network; listOfAttributes = list.GetType().GenericTypeArguments[0].Equals(typeof(Attribute)); this.list = list; listForResetToInit = TypesUtility.CreateListFromString(list.GetType().ToString()); TypesUtility.CopyList(list, listForResetToInit); listForResetToSaved = TypesUtility.CreateListFromString(list.GetType().ToString()); TypesUtility.CopyList(list, listForResetToSaved); InitializeComponent(); if (!listOfAttributes) { Button_Edit.Visibility = System.Windows.Visibility.Collapsed; ComboBox_Replace_SelectValue.Visibility = System.Windows.Visibility.Collapsed; ComboBox_SelectValue.Visibility = System.Windows.Visibility.Collapsed; ComboBox_SelectCategory.Visibility = System.Windows.Visibility.Collapsed; ComboBox_SelectType.Visibility = System.Windows.Visibility.Collapsed; } else { InitComboBoxes(); } this.Title = "Editting list of type " + list.GetType().GenericTypeArguments[0].ToString(); FillListBox(list, IndexCreatingOperation.Start); editable = Editable; }
internal static void UpdateMockCounters() { foreach (KeyValuePair <MockCounterGroup, ConfigModel> kvp in MockCounter.loadedMockCounters) { Destroy(kvp.Key.CounterName); Destroy(kvp.Key.CounterData); } if (TextHelper.CounterCanvas != null) { Destroy(TextHelper.CounterCanvas.gameObject); } TextHelper.CounterCanvas = null; List <ConfigModel> loadedModels = TypesUtility.GetListOfType <ConfigModel>(); loadedModels = loadedModels.Where(x => !(x is CustomConfigModel)).ToList(); loadedModels.ForEach(x => x = ConfigLoader.DeserializeFromConfig(x, x.DisplayName) as ConfigModel); foreach (CustomCounter potential in CustomCounterCreator.LoadedCustomCounters) { loadedModels.Add(potential.ConfigModel); } loadedModels.RemoveAll(x => x is null); foreach (ConfigModel counter in loadedModels) { MockCounter.Update(counter); } }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn private bool IsTrue(EventTriggerType trigger, BaseMessage message) /// /// \brief Query if 'trigger' is true. /// /// \par Description. /// - Check other triggers type (not the Initialize trigger) /// /// \par Algorithm. /// - Get the MessageType of the message and the round of the message /// - Calculate the other end of the message according to the trigger /// - For Send events the other end is the target of the message /// - For Receive events the other end is the source of the message /// - Check if all the parameters retrieved from the message are equal to the /// EventTrigger members /// /// \par Usage Notes. /// /// \author Ilanh /// \date 09/05/2018 /// /// \param trigger (EventTriggerType) - The trigger. /// \param message (BaseMessage) - The message. /// /// \return True if true, false if not. //////////////////////////////////////////////////////////////////////////////////////////////////// private bool IsTrue(EventTriggerType trigger, BaseMessage message) { // Get the data of the message that caused the event int messageRound = message.GetHeaderField(bm.pak.Round); dynamic messageType = message.GetHeaderField(bm.pak.MessageType); // Get the other end of the message that caused the event: // For a sending event this is the destination of the message // For a receive event this is the source of the message int messageOtherEnd; if (trigger == EventTriggerType.AfterSendMessage || trigger == EventTriggerType.BeforeSendMessage) { messageOtherEnd = message.GetHeaderField(bm.pak.DestProcess); } else { messageOtherEnd = message.GetHeaderField(bm.pak.SourceProcess); } if (this[Comps.Trigger] == trigger && this[Comps.Round] == messageRound && TypesUtility.CompareDynamics(this[Comps.MessageType], messageType) && this[Comps.OtherEnd] == messageOtherEnd) { return(true); } return(false); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static NetworkElement BaseNetworkElement(string classType) /// /// \brief Base network element. /// /// \par Description. /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 19/11/2017 /// /// \param classType (string) - Type of the class. /// /// \return A NetworkElement. //////////////////////////////////////////////////////////////////////////////////////////////////// public static NetworkElement BaseNetworkElement(string classType) { NetworkElement result = (NetworkElement)TypesUtility.CreateObjectFromTypeString( GenerateNamespace("Base", "Base") + "." + "Base" + classType); return(result); }
/**********************************************************************************************//** * Creates an attribute. * * \author Ilan Hindy * \date 29/09/2016 * * \param [out] newValue The new value. * * \return true if it succeeds, false if it fails. * . **************************************************************************************************/ private bool CreateAttribute(out object newValue) { string valueString; Attribute attribute; if (!ComboBox_SelectValue.IsVisible) { valueString = TextBox_AddValue.Text; } else { valueString = (string)ComboBox_SelectValue.SelectedItem; } if (TypesUtility.CreateAttribute((string)ComboBox_SelectCategory.SelectedItem, (string)ComboBox_SelectType.SelectedItem, valueString, out attribute)) { newValue = attribute; return(true); } else { CustomizedMessageBox.Show("Cannot convert value " + valueString + " to type " + (string)ComboBox_SelectType.SelectedItem, "List Input Message", Icons.Error); newValue = null; return(false); } }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn private MethodsLists() /// /// \brief Constructor that prevents a default instance of this class from being created. /// /// \par Description. /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 17/01/2018 //////////////////////////////////////////////////////////////////////////////////////////////////// private MethodsLists() { Mouse.OverrideCursor = Cursors.Wait; endInputOperationMethods = TypesUtility.GetAllEndInputOperations(); elementWindowPrmsMethod = TypesUtility.GetAllElementWindowPrmsMethods(); Mouse.OverrideCursor = null; }
/**********************************************************************************************//** * Event handler. Called by Button_Add for click events. * * \author Ilan Hindy * \date 29/09/2016 * * \param sender Source of the event. * \param e Routed event information. * **************************************************************************************************/ private void Button_Add_Click(object sender, RoutedEventArgs e) { if (!EditableCheck()) { return; } bool additionalSuccess; object newValue; if (listOfAttributes) { additionalSuccess = CreateAttribute(out newValue); } else { additionalSuccess = CreateValue(out newValue); } if (additionalSuccess) { TypesUtility.InvokeMethodOfList(list, "Add", new object[] { newValue }, false); FillListBox(list, IndexCreatingOperation.End); ListBox_Elements.SelectedIndex = ListBox_Elements.Items.Count - 1; if (Updated == false) { Updated = true; } } }
public static void GetFormatters(IMessagePackProvider provider, IMessagePackContext context, IDictionary <Type, IMessagePackFormatter> formatters, int formatterType, Assembly assembly = null) { if (provider == null) { throw new ArgumentNullException(nameof(provider)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } if (formatters == null) { throw new ArgumentNullException(nameof(formatters)); } foreach (Type type in AssemblyUtility.GetBrowsableTypes <MessagePackFormatterAttribute>(assembly)) { var attribute = type.GetCustomAttribute <MessagePackFormatterAttribute>(false); if (attribute.Type == formatterType && TypesUtility.TryCreateType(type, new object[] { provider, context }, out IMessagePackFormatter formatter)) { formatters.Add(formatter.TargetType, formatter); } } }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static AttributeDictionary MessageDictionary(dynamic messageKey, NetworkElement messageDemo, BaseProcess process) /// /// \brief Message dictionary. /// Create a message dictionary according to the message type key /// /// \par Description. /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 24/12/2017 /// /// \param messageKey (dynamic) - The message key. /// \param messageDemo (NetworkElement) - The message demo. /// \param process (BaseProcess) - The process. /// /// \return An AttributeDictionary. //////////////////////////////////////////////////////////////////////////////////////////////////// public static AttributeDictionary MessageDictionary(dynamic messageKey, NetworkElement messageDemo, BaseProcess process) { // Add an empty dictionary to the OperationResults messageDemo.or.Add(messageKey, new Attribute { Value = new AttributeDictionary() }); // Generate the method name string methodName = ((AttributeDictionary)messageDemo.or[messageKey]).MessageMethodName(); // Generate the enum name of the message. Note that Enum names begin with small letter and // Enum values begin with big letter so there is a need to set the first letter to lower // In order to get the enum name string keyString = TypesUtility.GetKeyToString(messageKey); keyString = char.ToLower(keyString[0]) + keyString.Substring(1); // The method for getting the data is invoked by it's name. When invoking a method in this // way the exact number of parameters has to be given. Each method has a different number of parameters // (according to the number of entries in the message enum so this number has to be retrieved // from the enum int optionalPrmsCount = Enum.GetValues(GenerateMessageEnum(keyString)).Length; // Activating the method return((AttributeDictionary)TypesUtility.InvokeMethod(process, methodName, new List <object> { bm.PrmSource.Default, null }, optionalPrmsCount, true)); }
/**********************************************************************************************//** * Event handler. Called by ComboBox_SelectType for selection changed events. * * \author Ilan Hindy * \date 29/09/2016 * * \param sender Source of the event. * \param e Selection changed event information. * **************************************************************************************************/ private void ComboBox_SelectType_SelectionChanged(object sender, SelectionChangedEventArgs e) { FillComboBox(ComboBox_SelectValue, TypesUtility.GetPossibleValues((string)ComboBox_SelectType.SelectedItem)); if (ComboBox_SelectValue.Items.Count != 0) { ComboBox_SelectValue.SelectedIndex = 0; } }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static BaseNetwork GenerateNetwork(string subject = null, string algorithm = null) /// /// \brief Generates a network. /// /// \par Description. /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 19/11/2017 /// /// \param subject (Optional) (string) - The subject. /// \param algorithm (Optional) (string) - The algorithm. /// /// \return The network. //////////////////////////////////////////////////////////////////////////////////////////////////// public static BaseNetwork GenerateNetwork(string subject = null, string algorithm = null) { if (algorithm is null) { algorithm = Config.Instance[Config.Keys.SelectedAlgorithm]; } return((BaseNetwork)TypesUtility.CreateObjectFromTypeString(GenerateNamespace(subject, algorithm) + "." + algorithm + "Network")); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public void Activate() /// /// \brief Performs this object. /// /// \par Description. /// Activate all the methods in the list (By the processor) /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 09/05/2018 //////////////////////////////////////////////////////////////////////////////////////////////////// public void Activate() { List <string> methods = (List <string>)AsList(); for (int idx = 0; idx < methods.Count; idx++) { TypesUtility.InvokeMethod(Element, methods[idx], new List <object>(), 1, false); } }
/* * The possible parameters are: * key - in this case find the attribute * if the attribute found is a list * if only one value from the list is requested * return the value according to an index * else return the list * else (the value is not a list) return the value */ /**********************************************************************************************//** * Evaluate parameter. * * \author Ilan Hindy * \date 29/09/2016 * * \exception EvaluationException Thrown when an Evaluation error condition occurs. * * \param evaluationMode The evaluation mode. * \param network The network. * \param process The process. * \param channel The channel. * \param message The message. * \param parameter The parameter. * * \return An Attribute. * . **************************************************************************************************/ private Attribute EvaluateParameter(EvaluationMode evaluationMode, BaseNetwork network, BaseProcess process, BaseChannel channel, BaseMessage message, Attribute parameter) { if (parameter.Value.GetType().IsEnum) { if (!NetworkElementExist(network, process, channel, message)) { return(new Attribute() { Value = false }); } Attribute attribute = FindAttribute(network, process, channel, message, parameter.Value); if (attribute == null) { string typeOfHostingElementStr = TypesUtility.GetKeyToString(or[brp.ork.HostingElementType]); throw new EvaluationException("Could not find attribute " + TypesUtility.GetKeyToString(parameter.Value) + " In element of type " + typeOfHostingElementStr); } else { if (Attribute.GetValueCategory(attribute) == Attribute.AttributeCategory.ListOfAttributes) { if (or[brp.ork.ListParameterOneOrAll] == ListParameterOneOrAll.One) { object[] elements = TypesUtility.InvokeMethodOfList(attribute.Value, "ToArray", new object[0], true); int requestedIndex = or[brp.ork.IndexInList]; if (elements.Count() <= requestedIndex) { throw new EvaluationException("The index requested : " + requestedIndex.ToString() + " is larger or equal to the number of elements in the list : " + elements.Count()); } else { if (Attribute.GetValueCategory(attribute) == Attribute.AttributeCategory.ListOfAttributes) { return((Attribute)elements[requestedIndex]); } else { return(new Attribute() { Value = elements[requestedIndex] }); } } } } return(attribute); } } if (parameter.Value.GetType().Equals(typeof(Breakpoint))) { return(new Attribute() { Value = parameter.Value.Evaluate(evaluationMode, network, process, channel, message) }); } return(parameter); }
/**********************************************************************************************//** * Event handler. Called by Button_Save for click events. * * \author Ilan Hindy * \date 29/09/2016 * * \param sender Source of the event. * \param e Routed event information. * **************************************************************************************************/ private void Button_Save_Click(object sender, RoutedEventArgs e) { if (!EditableCheck()) { return; } TypesUtility.CopyList(list, listForResetToSaved); ListBox_Elements.UpdateLayout(); CustomizedMessageBox.Show("Finished Saving", "List Input Message", Icons.Success); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn private List<TextFragment> CreatePrimitiveTypes(string text) /// /// \brief Creates primitive types. /// /// \par Description. /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 18/10/2017 /// /// \param text (string) - The text. /// /// \return The new primitive types. //////////////////////////////////////////////////////////////////////////////////////////////////// private List <TextFragment> CreatePrimitiveTypes(string text) { List <Type> types = TypesUtility.GetPrimitiveTypes(); HashSet <string> typesStrings = new HashSet <string>(); types.ForEach(t => typesStrings.Add(t.ToString())); string tokensString = CreateTokensString(typesStrings); return(CreateMatchList(text, tokensString, Brushes.Red)); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public BaseMessage GenerateMessage(BaseNetwork network, string messageString, string subject = null, string algorithm = null) /// /// \brief Generates a message. /// /// \par Description. /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 19/11/2017 /// /// \param network (BaseNetwork) - The network. /// \param messageString (string) - The message string. /// \param subject (Optional) (string) - The subject. /// \param algorithm (Optional) (string) - The algorithm. /// /// \return The message. //////////////////////////////////////////////////////////////////////////////////////////////////// public BaseMessage GenerateMessage(BaseNetwork network, string messageString, string subject = null, string algorithm = null) { if (algorithm is null) { algorithm = Config.Instance[Config.Keys.SelectedAlgorithm]; } return((BaseMessage)TypesUtility.CreateObjectFromTypeString( GenerateNamespace(subject, algorithm) + "." + algorithm + "Message", new object[] { network, messageString })); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn protected void Selection_SourceSubject_SelectionChanged(object sender, EventArgs e) /// /// \brief Event handler. Called by Selection_SourceSubject for selection changed events. /// /// \par Description. /// - The Source algorithms control change (To present the algorithms of the subject) /// - The Target subject control change (To set the Target subject is set to the source subject /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 29/08/2017 /// /// \param sender (object) - Source of the event. /// \param e (EventArgs) - Event information. //////////////////////////////////////////////////////////////////////////////////////////////////// protected void Selection_SourceSubject_SelectionChanged(object sender, EventArgs e) { data[1].options = TypesUtility.GetAlgorithmsOfSubject(Selection_SourceSubject.TextBox_Selected.Text); data[1].enableItems = null; Selection_SourceAlgorithm.Init(data[1]); if (((ListBoxItem)Selection_TargetSubject.ListBox_Options.Items[Selection_SourceSubject.ListBox_Options.SelectedIndex]).IsEnabled) { Selection_TargetSubject.ListBox_Options.SelectedIndex = Selection_SourceSubject.ListBox_Options.SelectedIndex; } }
/**********************************************************************************************//** * Event handler. Called by ListBox_Elements for selection changed events. * * \author Ilan Hindy * \date 29/09/2016 * * \param sender Source of the event. * \param e Selection changed event information. * **************************************************************************************************/ private void ListBox_Elements_SelectionChanged(object sender, SelectionChangedEventArgs e) { if (listOfAttributes) { Type type; string valueString; Attribute attribute; if (ListBox_Elements.SelectedItem == null) { type = typeof(string); valueString = ""; } else { attribute = ((List <Attribute>)list)[ListBox_Elements.SelectedIndex]; type = attribute.Value.GetType(); valueString = attribute.GetValueToString(); } if (type.IsEnum || type.Equals(typeof(bool))) { FillComboBox(ComboBox_Replace_SelectValue, TypesUtility.GetPossibleValues(type.ToString())); ComboBox_Replace_SelectValue.SelectedItem = valueString; ComboBox_Replace_SelectValue.Visibility = System.Windows.Visibility.Visible; TextBox_Replace_AddValue.Visibility = System.Windows.Visibility.Collapsed; Button_Edit.Visibility = System.Windows.Visibility.Collapsed; Button_ReplaceValue.Visibility = System.Windows.Visibility.Visible; return; } if (type.IsPrimitive || type.Equals(typeof(string))) { TextBox_Replace_AddValue.Text = valueString; ComboBox_Replace_SelectValue.Visibility = System.Windows.Visibility.Collapsed; TextBox_Replace_AddValue.Visibility = System.Windows.Visibility.Visible; Button_Edit.Visibility = System.Windows.Visibility.Collapsed; Button_ReplaceValue.Visibility = System.Windows.Visibility.Visible; return; } ComboBox_Replace_SelectValue.Visibility = System.Windows.Visibility.Collapsed; TextBox_Replace_AddValue.Visibility = System.Windows.Visibility.Collapsed; Button_Edit.Visibility = System.Windows.Visibility.Visible; Button_ReplaceValue.Visibility = System.Windows.Visibility.Collapsed; } else { if (ListBox_Elements.SelectedItem != null) { TextBox_Replace_AddValue.Text = ((ListBoxItem)(ListBox_Elements.SelectedValue)).Content.ToString(); } else { TextBox_Replace_AddValue.Text = TypesUtility.GetDefault(list.GetType().GenericTypeArguments[0]).ToString(); TextBox_AddValue.Text = TypesUtility.GetDefault(list.GetType().GenericTypeArguments[0]).ToString(); } } }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public void Set(bool defaultValue) /// /// \brief Sets to default. /// /// \par Description. /// Set all entries. /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 25/07/2017 /// /// \param defaultValue (bool) - true to default value. //////////////////////////////////////////////////////////////////////////////////////////////////// public void Set(bool defaultValue) { foreach (var phase in TypesUtility.GetAllEnumValues(typeof(MainWindow.ActivationPhases))) { foreach (var permition in TypesUtility.GetAllEnumValues(typeof(PermitionTypes))) { permissions[(int)phase, (int)permition] = defaultValue; } } Set(MainWindow.ActivationPhases.Temp, true); }
/**********************************************************************************************//** * Convert this object into a string representation. * * \author Ilan Hindy * \date 29/09/2016 * * Returns a string that represents the current object. * * \return A string that represents the current object. * . **************************************************************************************************/ public override string ToString() { if (or.Count > 0) { return(TypesUtility.GetKeyToString(or[brp.ork.HostingElementType]) + ":" + or[brp.ork.Name]); } else { return("Brakepoint"); } }
/**********************************************************************************************//** * Event handler. Called by Button_ResetToSaved for click events. * * \author Ilan Hindy * \date 29/09/2016 * * \param sender Source of the event. * \param e Routed event information. * **************************************************************************************************/ private void Button_ResetToSaved_Click(object sender, RoutedEventArgs e) { if (!EditableCheck()) { return; } TypesUtility.CopyList(listForResetToSaved, list); FillListBox(list, IndexCreatingOperation.Start); ListBox_Elements.UpdateLayout(); CustomizedMessageBox.Show("Finished Reset to Saved", "List Input Message", Icons.Success); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static BaseChannel GenerateChannel(bool permissionsValue, string subject = null, string algorithm = null) /// /// \brief Generates a channel. /// /// \par Description. /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 19/11/2017 /// /// \param permissionsValue (bool) - true to permissions value. /// \param subject (Optional) (string) - The subject. /// \param algorithm (Optional) (string) - The algorithm. /// /// \return The channel. //////////////////////////////////////////////////////////////////////////////////////////////////// public static BaseChannel GenerateChannel(bool permissionsValue, string subject = null, string algorithm = null) { if (algorithm is null) { algorithm = Config.Instance[Config.Keys.SelectedAlgorithm]; } BaseChannel channel = (BaseChannel)TypesUtility.CreateObjectFromTypeString( GenerateNamespace(subject, algorithm) + "." + algorithm + "Channel", new object[] { permissionsValue }); return(channel); }
/**********************************************************************************************//** * Evaluate pair. * * \author Ilan Hindy * \date 29/09/2016 * * \exception EvaluationException Thrown when an Evaluation error condition occurs. * * \param prm1 The first prm. * \param prm2 The second prm. * \param evaluateExpressionFunc The evaluate expression function. * * \return true if it succeeds, false if it fails. * . **************************************************************************************************/ private bool EvaluatePair(dynamic prm1, dynamic prm2, EvaluateExpression evaluateExpressionFunc) { try { return(evaluateExpressionFunc(prm1, prm2)); } catch (Exception e) { string operatorName = TypesUtility.GetKeyToString(or[brp.ork.Operator]); throw new EvaluationException("Error while evaluating " + operatorName + "(" + prm1.ToString() + "," + prm2.ToString() + ")" + "\n" + e.Message); } }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static BaseProcess GenerateProcess(bool permissionsValue, string subject = null, string algorithm = null) /// /// \brief Generates the process. /// /// \par Description. /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 19/11/2017 /// /// \param permissionsValue (bool) - true to permissions value. /// \param subject (Optional) (string) - The subject. /// \param algorithm (Optional) (string) - The algorithm. /// /// \return The process. //////////////////////////////////////////////////////////////////////////////////////////////////// public static BaseProcess GenerateProcess(bool permissionsValue, string subject = null, string algorithm = null) { if (algorithm is null) { algorithm = Config.Instance[Config.Keys.SelectedAlgorithm]; } BaseProcess process = (BaseProcess)TypesUtility.CreateObjectFromTypeString( GenerateNamespace() + "." + Config.Instance[Config.Keys.SelectedAlgorithm] + "Process", new object[] { permissionsValue }); return(process); }
/* * ReceiveHandling * This method is responssible to devide the data received to packets and call * the ReceiveHandling method of the process * Note that there no connection from the way the data is sent to the way it is * Received. That meens that a several packets can be received in one Receive and * There is no garentee that the last packet in the data will end. * The packets (messages) are send with '#' termination flag * The received data is collected in state.buffer * Then it is copied to state.sb . The role of this variable is to hold all the * data that was not processed * Then it converted to string * Then it is devided to packets * Then each packet except the last packet is handled * Then the last packet is checked : * If the data received ends with '#' - do nothing because that meens that the last * packet is empty * else clear the state.data and fill it with the unterminated last packet to be joined * by the next receive data * The following is the handling of a complete packet * 1. Generate a message object from the message data * 2. If the MessageType attribute of the message is "Terminate" set the termnateFlag and return * 3. wait untill the ReceiveHandling method of the process is not locked by another * AsynchronousReader object * 4. Activate the ReceiveHandling method of the process with the data. */ /**********************************************************************************************//** * Receive handling. * * \author Ilan Hindy * \date 29/09/2016 * * \param bytesReceived The bytes received. * **************************************************************************************************/ public void ReceiveHandling(int bytesReceived) { String content = String.Empty; // There might be more data, so store the data received so far. state.sb.Append(Encoding.ASCII.GetString( state.buffer, 0, bytesReceived)); //Convert the data to string content = state.sb.ToString(); // Get the process BaseProcess process = state.process; //If any end of packets was received if (content.IndexOf("#") > -1) { //Devide the data to packets string[] packets = Regex.Split(content, "#"); //Packet handling for (int idx = 0; idx < packets.Length - 1; idx++) { //Create message from the packet //BaseMessage message = new BaseMessage(packets[idx]); string processName = "Process_" + process.ea[ne.eak.Id].ToString(); Logger.Log(Logger.LogMode.MainLogAndProcessLog, processName, "Receive", "Received message - packets[idx]", packets[idx], "ProcessReceive"); BaseMessage message = BaseMessage.CreateMessage(process.Network, packets[idx]); if (TypesUtility.CompareDynamics(message.GetHeaderField(bm.pak.MessageType), bm.MessageTypes.Terminate)) { terminateFlag = true; } process.MessageQHandling(ref message, MessageQOperation.AddMessage); MessageRouter.ReportMessageReceive(process, new object[] { message }); //Logger.Log(Logger.LogMode.MainLogAndProcessLog, process.ToString(), "Receive", "Received message", message); } //If there is a unfinished packet if (content[content.Length - 1] != '#') { //This is the last packet received and it is fregmented with the next package state.sb.Clear(); state.sb.Append(packets[packets.Length - 1]); } else { state.sb.Clear(); } } }