source: trunk/CrypPlugins/Multiplexer/Mux.cs @ 1941

Last change on this file since 1941 was 1259, checked in by Matthäus Wander, 12 years ago

shortened license text to boilerplate notice in all source files

File size: 11.6 KB
Line 
1/*
2   Copyright 2008 Thomas Schmid, University of Siegen
3
4   Licensed under the Apache License, Version 2.0 (the "License");
5   you may not use this file except in compliance with the License.
6   You may obtain a copy of the License at
7
8       http://www.apache.org/licenses/LICENSE-2.0
9
10   Unless required by applicable law or agreed to in writing, software
11   distributed under the License is distributed on an "AS IS" BASIS,
12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   See the License for the specific language governing permissions and
14   limitations under the License.
15*/
16
17using System;
18using System.Collections.Generic;
19using System.Linq;
20using System.Text;
21using System.Runtime.Remoting.Contexts;
22using Cryptool.PluginBase.IO;
23using Cryptool.PluginBase;
24using System.Windows.Controls;
25using System.ComponentModel;
26using Cryptool.PluginBase.Miscellaneous;
27using System.Runtime.CompilerServices;
28
29namespace Multiplexer
30{
31  [Author("Thomas Schmid", "thomas.schmid@cryptool.org", "Uni Siegen", "http://www.uni-siegen.de")]
32  [PluginInfo(false, "Multiplexer", "Choose one of the given inputs using the boolean-switch", "", "Multiplexer/icon.png")]
33  public class Mux : IThroughput
34  {
35    #region Private variables
36    private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
37
38    private readonly string inputOne = "InputOne";
39    private readonly string inputTwo = "InputTwo";
40    private readonly string outputOne = "OutputOne";
41
42    private int inputs;
43    private int outputs;
44    private bool gotSwitchValue;
45    private bool canSendPropertiesChangedEvent = true;
46    #endregion Private variables
47
48    public event DynamicPropertiesChanged OnDynamicPropertiesChanged;
49
50    public Mux()
51    {
52      settings = new MuxSettings(this);     
53      settings.OnGuiLogNotificationOccured += settings_OnGuiLogNotificationOccured;
54      CanChangeDynamicProperty = true;
55     
56      // No dynProp event in constructor - editor will read the property initial without the event.
57      // event can cause problems when using save files and is processed after
58      // connections have been restored.
59      CreateInputOutput(false); 
60    }
61
62    public void CreateInputOutput(bool announcePropertyChange)
63    {
64      DicDynamicProperties.Clear();
65      dicInputBuffer.Clear();
66      dicSwitchBuffer.Clear();
67      AddInput(inputOne, "This value will be forwarded if switch is true(default).");
68      AddInput(inputTwo, "This value will be forwarded if switch is false.");
69      AddOutput(outputOne);
70      if (announcePropertyChange) DynamicPropertiesChanged();
71    }
72
73    private void DynamicPropertiesChanged()
74    {
75      if (OnDynamicPropertiesChanged != null) OnDynamicPropertiesChanged(this);
76    }
77
78    private void settings_OnGuiLogNotificationOccured(IPlugin sender, GuiLogEventArgs args)
79    {     
80      EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(args.Message, this, args.NotificationLevel));
81    }
82   
83    public Dictionary<string, DynamicProperty> dicDynamicProperties = new Dictionary<string, DynamicProperty>();
84
85    [DynamicPropertyInfo("methodGetValue", "methodSetValue", "CanChangeDynamicProperty", "OnDynamicPropertiesChanged", "CanSendPropertiesChangedEvent")]
86    public Dictionary<string, DynamicProperty> DicDynamicProperties
87    {
88      get { return dicDynamicProperties; }
89      set { dicDynamicProperties = value; }
90    }
91   
92    public bool CanChangeDynamicProperty
93    {
94      get { return settings.CanChangeProperty; }
95      set { settings.CanChangeProperty = value; }
96    }
97
98    public bool CanSendPropertiesChangedEvent
99    {
100      get { return canSendPropertiesChangedEvent; }
101      set { canSendPropertiesChangedEvent = value; }
102    }
103
104
105    private Type getCurrentType()
106    {
107      switch (settings.CurrentDataType)
108      {
109        case MuxSettings.DataTypes.CryptoolStream:
110          return typeof(CryptoolStream);         
111        case MuxSettings.DataTypes.String:
112          return typeof(string);
113        case MuxSettings.DataTypes.ByteArray:
114          return typeof(byte[]);
115        case MuxSettings.DataTypes.Boolean:
116          return typeof(bool);
117        case MuxSettings.DataTypes.Integer:
118          return typeof(int);
119        default:
120          return null;         
121      }
122    }
123
124    private QuickWatchFormat getQuickWatchFormat()
125    {
126      Type type = getCurrentType();
127      if (type == typeof(CryptoolStream))
128        return QuickWatchFormat.Hex;
129      else if (type == typeof(string))
130        return QuickWatchFormat.Text;
131      else if (type == typeof(byte[]))
132        return QuickWatchFormat.Hex;
133      else if (type == typeof(bool))
134        return QuickWatchFormat.Text;
135      else if (type == typeof(int))
136        return QuickWatchFormat.Text;
137      else
138        return QuickWatchFormat.None;
139    }
140
141    private object getCurrentValue(string name)
142    {
143      if (DicDynamicProperties.ContainsKey(name))
144      {
145        switch (settings.CurrentDataType)
146        {
147          case MuxSettings.DataTypes.CryptoolStream:
148            CryptoolStream cryptoolStream = new CryptoolStream();
149            listCryptoolStreamsOut.Add(cryptoolStream);
150            cryptoolStream.OpenRead(((CryptoolStream)DicDynamicProperties[name].Value).FileName);
151            return cryptoolStream;
152          case MuxSettings.DataTypes.String:
153            return DicDynamicProperties[name].Value;
154          case MuxSettings.DataTypes.ByteArray:
155            return DicDynamicProperties[name].Value;
156          case MuxSettings.DataTypes.Boolean:
157            return DicDynamicProperties[name].Value;
158          case MuxSettings.DataTypes.Integer:
159            return DicDynamicProperties[name].Value;
160          default:
161            return null;
162        }
163      }
164      return null;
165    }
166
167    private void AddInput(string name, string toolTip)
168    {
169      inputs++;     
170      if (name == null || name == string.Empty) name = "Input " + inputs;     
171      DicDynamicProperties.Add(name, 
172        new DynamicProperty(name, getCurrentType(),
173          new PropertyInfoAttribute(Direction.InputData, name, toolTip, "", false, true, DisplayLevel.Beginner, getQuickWatchFormat(), null)));
174      dicInputBuffer.Add(name, 0);
175    }
176
177    private void AddOutput(string name)
178    {
179      outputs++;     
180      if (name == null || name == string.Empty) name = "Output " + outputs;
181     
182      DicDynamicProperties.Add(name,
183        new DynamicProperty(name, getCurrentType(),
184          new PropertyInfoAttribute(Direction.OutputData, name, "", "", false, false, DisplayLevel.Beginner, getQuickWatchFormat(), null)));
185    }
186
187    [MethodImpl(MethodImplOptions.Synchronized)]
188    public void methodSetValue(string propertyKey, object value)
189    {
190      if (DicDynamicProperties.ContainsKey(propertyKey)) DicDynamicProperties[propertyKey].Value = value;
191      if (value is CryptoolStream) listCryptoolStreamsOut.Add((CryptoolStream)value);
192      OnPropertyChanged(propertyKey);
193      dicInputBuffer[propertyKey]++;
194    }
195
196    private Dictionary<string, int> dicInputBuffer = new Dictionary<string, int>();
197    private Dictionary<bool, int> dicSwitchBuffer = new Dictionary<bool, int>();
198
199    private List<string> listBuffer = new List<string>();
200
201    [MethodImpl(MethodImplOptions.Synchronized)]
202    public object methodGetValue(string propertyKey)
203    {
204      if (propertyKey == outputOne)
205      {
206        if (DicDynamicProperties[inputOne].Value != null && InputSwitch)
207          return getCurrentValue(inputOne);
208
209        else if (DicDynamicProperties[inputTwo].Value != null && !InputSwitch)
210          return getCurrentValue(inputTwo);
211      }
212      else
213        return getCurrentValue(propertyKey); // QuickWatchDataCall to Input values
214
215      return null;
216    }
217
218    private bool inputSwitch;
219    [PropertyInfo(Direction.InputData, "Input switch", "Selects the input.", "", false, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
220    public bool InputSwitch   
221    {
222      [MethodImpl(MethodImplOptions.Synchronized)]
223      get { return inputSwitch; }
224      [MethodImpl(MethodImplOptions.Synchronized)]
225      set 
226      {       
227        inputSwitch = value;       
228        OnPropertyChanged("InputSwitch");
229
230        // only when buffer has been initialized correctly
231        if (dicSwitchBuffer.Count == 2)
232            dicSwitchBuffer[value]++;
233      }
234    }
235
236
237    #region IPlugin Members
238
239#pragma warning disable 67
240                public event StatusChangedEventHandler OnPluginStatusChanged;
241                public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
242                public event PluginProgressChangedEventHandler OnPluginProgressChanged;
243#pragma warning restore
244
245    private MuxSettings settings;
246    public ISettings Settings
247    {
248      get { return settings; }
249    }
250
251    public UserControl Presentation
252    {
253      get { return null; }
254    }
255
256    public UserControl QuickWatchPresentation
257    {
258      get { return null; }
259    }
260   
261    public void PreExecution()
262    {           
263      // clear Switch Buffer
264      dicSwitchBuffer.Clear();
265      dicSwitchBuffer.Add(false, 0);
266      dicSwitchBuffer.Add(true, 0);
267
268      // clear InputBuffer
269      //for (int i = 0; i < dicInputBuffer.Count; i++)
270      //{
271      //  dicInputBuffer.Values.ToList()[i] = 0;
272      //}
273      foreach (string item in dicInputBuffer.Keys.ToList())
274      {
275        dicInputBuffer[item] = 0;
276      }
277
278      Dispose();
279
280      // Set InputSwitch with default value => dicSwitchBuffer[default] will be increased, so
281      // the first input on default input will be forwared directly without waiting for a first
282      // boolean input swtich.
283      inputSwitch = false;
284
285      if (settings.DefaultValue == 0)
286        InputSwitch = true;
287      else if (settings.DefaultValue == 1)
288        InputSwitch = false;
289      // else nothing to do -> no default value
290    }
291
292    [MethodImpl(MethodImplOptions.Synchronized)]
293    public void Execute()
294    {
295      if (InputSwitch && dicSwitchBuffer[true] > 0 && dicInputBuffer[inputOne] > 0)
296      {       
297        dicSwitchBuffer[true]--;
298        dicInputBuffer[inputOne]--;       
299        OnPropertyChanged(outputOne);
300      }
301      else if (!InputSwitch && dicSwitchBuffer[false] > 0 && dicInputBuffer[inputTwo] > 0)
302      {
303        dicSwitchBuffer[false]--;
304        dicInputBuffer[inputTwo]--;
305        OnPropertyChanged(outputOne);
306      }
307    }
308
309    public void PostExecution()
310    {
311      Dispose();
312    }
313
314    public void Pause()
315    {
316     
317    }
318
319    public void Stop()
320    {
321     
322    }
323
324    public void Initialize()
325    {
326     
327    }
328
329    public void Dispose()
330    {
331      foreach (CryptoolStream cryptoolStream in listCryptoolStreamsOut)
332      {
333        cryptoolStream.Close();
334      }
335      listCryptoolStreamsOut.Clear();
336      foreach (DynamicProperty item in DicDynamicProperties.Values)
337      {
338        item.Value = null;       
339      }
340    }
341
342    #endregion
343
344    #region INotifyPropertyChanged Members
345
346    public event PropertyChangedEventHandler PropertyChanged;
347
348    public void OnPropertyChanged(string name)
349    {
350      EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
351    }
352
353    #endregion
354
355    private CryptoolStream getNewCryptoolStream(string Filename)
356    {
357      CryptoolStream cryptoolStream = new CryptoolStream();
358      cryptoolStream.OpenRead(Filename);
359      listCryptoolStreamsOut.Add(cryptoolStream);
360      return cryptoolStream;
361    }
362  }
363}
Note: See TracBrowser for help on using the repository browser.