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

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

converter can do a lot more now.

File size: 17.3 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("double erkannt ", NotificationLevel.Info);
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                                    double number=0.0;
306                                   
307                                    if (Double.TryParse(DoubleCleanup(inpString), out number))
308                                    {
309                                       
310                                        double tempDouble = Convert.ToDouble(DoubleCleanup(inpString));
311                                        byte[] temp = BitConverter.GetBytes(tempDouble);
312
313                                        double test = BitConverter.ToDouble(temp, 0);
314                                        GuiLogMessage("double erkannt " + test.ToString(), NotificationLevel.Info);
315
316                                        Output = temp;
317
318                                        ProgressChanged(100, 100);
319                                        break;
320                                    }
321                                 
322                                 
323                                }
324                                catch (Exception e)
325                                {
326
327                                }
328                                System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
329                                Output = enc.GetBytes(inpString);
330
331
332                                GuiLogMessage("byte[] wiederherstellung " + Output.ToString(), NotificationLevel.Info);
333                                ProgressChanged(100, 100);
334                                break;
335                               
336                               
337                               
338                            }
339                            else
340                            {
341                                System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
342                                Output = enc.GetBytes(inpString);
343
344
345                                GuiLogMessage("byte[] wiederherstellung " + Output.ToString(), NotificationLevel.Info);
346                                ProgressChanged(100, 100);
347                                break;
348                            }
349                            break;
350                        }
351                    case 8: //cryptoolstream
352                        {
353                            GuiLogMessage("redundant", NotificationLevel.Error);
354                            break;
355                        }
356                    default:
357                        {
358                            GuiLogMessage("kein fall getriggert ", NotificationLevel.Error);
359                            break;
360                        }
361                }
362
363            }
364            else
365            {
366                GuiLogMessage("not yet implemented", NotificationLevel.Error);
367            }
368
369
370        }
371
372        public String DoubleCleanup(String inpString)
373        {
374            if (this.settings.FormatAmer)
375            {
376                String temp1 = inpString.Replace(",", "");
377                if (!(temp1.IndexOf(".") == temp1.LastIndexOf(".")))
378                {
379                    String tempXY = temp1.Insert(0, "X");
380                    return tempXY;
381                }
382                if (temp1.Contains(".") && temp1.IndexOf(".") == temp1.LastIndexOf("."))
383                {
384                    String temp2 = temp1.Replace(".", ",");
385                    return temp2;
386                }
387                else
388                {
389                    String temp3 = inpString.Replace(".", "");
390                    return temp3;
391                }
392            }
393            else
394            {
395                return inpString;
396            }
397
398        }
399
400        public void Initialize()
401        {
402
403        }
404
405        public void Pause()
406        {
407
408        }
409
410        public void PostExecution()
411        {
412
413        }
414
415        public void PreExecution()
416        {
417
418        }
419
420        public void Stop()
421        {
422
423        }
424
425        #endregion
426
427        #region INotifyPropertyChanged Member
428
429        public event PropertyChangedEventHandler PropertyChanged;
430
431        protected void OnPropertyChanged(string name)
432        {
433            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
434        }
435        #endregion
436
437        #region event handling
438
439        private void Progress(double value, double max)
440        {
441            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
442        }
443
444        public event StatusChangedEventHandler OnPluginStatusChanged;
445
446        void settings_OnPluginStatusChanged(IPlugin sender, StatusEventArgs args)
447        {
448            if (OnPluginStatusChanged != null) OnPluginStatusChanged(this, args);
449        }
450
451        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
452
453        private void ProgressChanged(double value, double max)
454        {
455            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
456        }
457
458        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
459
460        private void GuiLogMessage(string p, NotificationLevel notificationLevel)
461        {
462            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(p, this, notificationLevel));
463        }
464
465        #endregion
466    }
467}
Note: See TracBrowser for help on using the repository browser.