source: trunk/CrypPlugins/Converter/Converter.cs @ 746

Last change on this file since 746 was 746, checked in by falk, 12 years ago

Converter

File size: 17.2 KB
Line 
1/*                             
2   Copyright 2009 Team CrypTool (Sven Rech,Dennis Nolte,Raoul Falk,Nils Kopal), Uni Duisburg-Essen
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 Cryptool.PluginBase;
22using Cryptool.PluginBase.IO;
23using System.ComponentModel;
24using Cryptool.PluginBase.Miscellaneous;
25using System.Runtime.CompilerServices;
26using Cryptool.Plugins.Converter;
27
28namespace Cryptool.Plugins.Converter
29{
30    [Author("Raoul Falk, Dennis Nolte", "falk@cryptool.org", "Uni Duisburg-Essen", "http://www.uni-due.de")]
31    [PluginInfo(false, "Converter", "Converts input to another type", "", "Converter/icons/icon.png", "Converter/icons/tostring.png", "Converter/icons/toint.png", "Converter/icons/toshort.png", "Converter/icons/tobyte.png", "Converter/icons/todouble.png", "Converter/icons/tobig.png", "Converter/icons/tointarray.png", "Converter/icons/tobytearray.png", "Converter/icons/tocryptoolstream.png")]
32
33    class Converter : IThroughput
34    {
35        #region private variables
36
37        private ConverterSettings settings = new ConverterSettings();
38        private object inputOne;
39        private object output;
40
41        #endregion
42
43        #region public interfaces
44
45        public Converter()
46        {
47            // this.settings = new ConverterSettings();
48            this.settings.OnPluginStatusChanged += settings_OnPluginStatusChanged;
49        }
50
51        public ISettings Settings
52        {
53            get { return this.settings; }
54            set { this.settings = (ConverterSettings)value; }
55        }
56
57        private void Converter_LogMessage(string msg, NotificationLevel loglevel)
58        {
59            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(msg, this, loglevel));
60        }
61
62        public System.Windows.Controls.UserControl Presentation
63        {
64            get { return null; }
65        }
66
67        public System.Windows.Controls.UserControl QuickWatchPresentation
68        {
69            get { return null; }
70        }
71
72        [PropertyInfo(Direction.InputData, "Input one", "Input one.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
73        public object InputOne
74        {
75            [MethodImpl(MethodImplOptions.Synchronized)]
76            get { return inputOne; }
77            [MethodImpl(MethodImplOptions.Synchronized)]
78            set
79            {
80                if (value != inputOne)
81                {
82                    inputOne = value;
83                    OnPropertyChanged("InputOne");
84                }
85            }
86        }
87
88
89
90        [PropertyInfo(Direction.OutputData, "Output", "Output.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
91        public object Output
92        {
93            [MethodImpl(MethodImplOptions.Synchronized)]
94            get
95            {
96                return output;
97            }
98
99            [MethodImpl(MethodImplOptions.Synchronized)]
100            set
101            {
102                this.output = value;
103                OnPropertyChanged("Output");
104            }
105        }
106
107        #endregion
108
109        #region IPlugin members
110
111        public void Dispose()
112        {
113
114        }
115
116        public void Execute()
117        {
118
119            if (!(InputOne is int[] || InputOne is byte[] || InputOne is CryptoolStream))
120            {
121                if (inputOne is bool)
122                {
123                    switch (this.settings.Converter)
124                    {
125                        case 0:
126                            {
127                                Output = inputOne.ToString();
128                                ProgressChanged(100, 100);
129                                break;
130                            }
131                        case 1:
132                            {
133                                if ((bool)inputOne)
134                                {
135                                    Output = 1;
136                                    ProgressChanged(100, 100);
137                                    break;
138                                }
139                                else
140                                {
141                                    Output = 0;
142                                    ProgressChanged(100, 100);
143                                    break;
144                                }
145                            }
146                        default:
147                            {
148                                GuiLogMessage("Could not convert from bool to chosen type: ", NotificationLevel.Error);
149                                break;
150
151                            }
152                    }
153                    return;
154                }
155
156                string inpString = Convert.ToString(InputOne);
157
158
159
160                switch (this.settings.Converter)
161                {
162                    case 0: //String
163                        {
164                            Output = inpString;
165                            ProgressChanged(100, 100);
166                            break;
167                        }
168                    case 1: //int
169                        {
170
171                            try // string -> int Läuft
172                            {
173                                int temp = Convert.ToInt32(inpString);
174                                //int temp2 = (int)temp;
175                                GuiLogMessage("int erkannt", NotificationLevel.Info);
176                                Output = temp;
177                                ProgressChanged(100, 100);
178                            }
179                            catch (Exception e)
180                            {
181                                GuiLogMessage("Could not convert input to integer: " + e.Message, NotificationLevel.Error);
182                            }
183                            break;
184                        }
185                    case 2: //short
186                        {
187
188                            try // string -> short Läuft
189                            {
190                                short temp = Convert.ToInt16(inpString);
191                                // short temp2 = (short)temp;
192                                GuiLogMessage("short erkannt ", NotificationLevel.Info);
193                                Output = temp;
194                                ProgressChanged(100, 100);
195                            }
196                            catch (Exception e)
197                            {
198                                GuiLogMessage("Could not convert input to short: " + e.Message, NotificationLevel.Error);
199                            }
200                            break;
201                        }
202                    case 3: //byte
203                        {
204                            try // string -> byte Läuft
205                            {
206                                byte temp = Convert.ToByte(inpString);
207                                GuiLogMessage("byte erkannt ", NotificationLevel.Info);
208                                Output = temp;
209                                ProgressChanged(100, 100);
210                            }
211                            catch (Exception e)
212                            {
213                                GuiLogMessage("Could not convert input to byte: " + e.Message, NotificationLevel.Error);
214                            }
215                            break;
216                        }
217                    case 4: //double
218                        {
219                            try // string -> double Läuft
220                            {
221                                String cleanInputString = DoubleCleanup(inpString);
222
223                                double temp = Convert.ToDouble(cleanInputString);
224                                GuiLogMessage("Converting String to double is not safe. Digits may have been cut off  ", NotificationLevel.Warning);
225                                Output = temp;
226                                ProgressChanged(100, 100);
227                            }
228
229                            catch (Exception e)
230                            {
231                                GuiLogMessage("Could not convert input to double: " + e.Message, NotificationLevel.Error);
232                            }
233                            break;
234
235                        }
236                    case 5: //bigint
237                        {
238                            try // string -> bigint Läuft
239                            {
240
241                                BigInteger temp = BigInteger.parseExpression(inpString);
242                                GuiLogMessage("big int erkannt ", NotificationLevel.Info);
243                                Output = temp;
244                                ProgressChanged(100, 100);
245                            }
246                            catch (Exception e)
247                            {
248                                GuiLogMessage("Could not convert input to biginteger: " + e.Message, NotificationLevel.Error);
249                            }
250                            break;
251                        }
252                    case 6: // int[]
253                        {
254                            GuiLogMessage("Conversion from String to int[] not defined: ", NotificationLevel.Error);
255                            break;
256                        }
257                    case 7: // byte[]
258                        {
259                            if (settings.Numeric)
260                            {
261                                try // lässt sich als int verstehen?
262                                {
263                                    int tempint = Convert.ToInt32(inpString);
264                                    byte[] temp = new byte[4];
265                                    temp = BitConverter.GetBytes(tempint);
266
267                                    int test = BitConverter.ToInt32(temp, 0);
268                                    GuiLogMessage("int erkannt " + test.ToString(), NotificationLevel.Info);
269
270                                    Output = temp;
271
272                                    ProgressChanged(100, 100);
273                                    break;
274                                }
275                                catch (Exception e)
276                                {
277
278                                }
279
280                                try // lässt sich als bigint verstehen?
281                                {
282                                    BigInteger tempbigint = new BigInteger(inpString, 10);
283
284                                    int numBits = tempbigint.bitCount();
285
286                                    int numBytes = numBits >> 3;
287                                    if ((numBits & 0x7) != 0)
288                                        numBytes++;
289                                    byte[] temp = new byte[numBytes];
290                                    temp = tempbigint.getBytes();
291
292                                    BigInteger test = new BigInteger(temp);
293                                    GuiLogMessage("bigint erkannt " + test.ToString(), NotificationLevel.Info);
294                                    Output = temp;
295
296                                    ProgressChanged(100, 100);
297                                    break;
298                                }
299                                catch (Exception e)
300                                {
301
302                                }
303                                try // lässt sich als double verstehen?
304                                {   
305                                   
306                                   
307                                   
308                                        double tempDouble = Convert.ToDouble(DoubleCleanup(inpString));
309                                        byte[] temp = BitConverter.GetBytes(tempDouble);
310
311                                        double test = BitConverter.ToDouble(temp, 0);
312                                        GuiLogMessage("Converting String to double is not safe. Digits may have been cut off " + test.ToString(), NotificationLevel.Warning);
313
314                                        Output = temp;
315
316                                        ProgressChanged(100, 100);
317                                        break;
318                                   
319                                 
320                                 
321                                }
322                                catch (Exception e)
323                                {
324
325                                }
326                                System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
327                                Output = enc.GetBytes(inpString);
328
329
330                                GuiLogMessage("byte[] wiederherstellung " + Output.ToString(), NotificationLevel.Info);
331                                ProgressChanged(100, 100);
332                                break;
333                               
334                               
335                               
336                            }
337                            else
338                            {
339                                System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
340                                Output = enc.GetBytes(inpString);
341
342
343                                GuiLogMessage("byte[] wiederherstellung " + Output.ToString(), NotificationLevel.Info);
344                                ProgressChanged(100, 100);
345                                break;
346                            }
347                           
348                        }
349                    case 8: //cryptoolstream
350                        {
351                            GuiLogMessage("redundant", NotificationLevel.Error);
352                            break;
353                        }
354                    default:
355                        {
356                            GuiLogMessage("kein fall getriggert ", NotificationLevel.Error);
357                            break;
358                        }
359                }
360
361            }
362            else
363            {
364                GuiLogMessage("not yet implemented", NotificationLevel.Error);
365            }
366
367
368        }
369
370        public String DoubleCleanup(String inpString)
371        {
372            if (this.settings.FormatAmer)
373            {
374                String temp1 = inpString.Replace(",", "");
375                if (!(temp1.IndexOf(".") == temp1.LastIndexOf(".")))
376                {
377                    String tempXY = temp1.Insert(0, "X");
378                    return tempXY;
379                }
380                if (temp1.Contains(".") && temp1.IndexOf(".") == temp1.LastIndexOf("."))
381                {
382                    String temp2 = temp1.Replace(".", ",");
383                    return temp2;
384                }
385                else
386                {
387                    String temp3 = inpString.Replace(".", "");
388                    return temp3;
389                }
390            }
391            else
392            {
393                return inpString;
394            }
395
396        }
397
398        public void Initialize()
399        {
400
401        }
402
403        public void Pause()
404        {
405
406        }
407
408        public void PostExecution()
409        {
410
411        }
412
413        public void PreExecution()
414        {
415
416        }
417
418        public void Stop()
419        {
420
421        }
422
423        #endregion
424
425        #region INotifyPropertyChanged Member
426
427        public event PropertyChangedEventHandler PropertyChanged;
428
429        protected void OnPropertyChanged(string name)
430        {
431            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
432        }
433        #endregion
434
435        #region event handling
436
437        private void Progress(double value, double max)
438        {
439            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
440        }
441
442        public event StatusChangedEventHandler OnPluginStatusChanged;
443
444        void settings_OnPluginStatusChanged(IPlugin sender, StatusEventArgs args)
445        {
446            if (OnPluginStatusChanged != null) OnPluginStatusChanged(this, args);
447        }
448
449        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
450
451        private void ProgressChanged(double value, double max)
452        {
453            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
454        }
455
456        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
457
458        private void GuiLogMessage(string p, NotificationLevel notificationLevel)
459        {
460            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(p, this, notificationLevel));
461        }
462
463        #endregion
464    }
465}
Note: See TracBrowser for help on using the repository browser.