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

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

converter new version (added user selected encoding types)

File size: 19.0 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/DetailedDescription/Description.xaml", "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                                switch (settings.Encoding)
340                                {
341                                    case ConverterSettings.EncodingTypes.Default:
342                                        Output = Encoding.Default.GetBytes(inpString.ToCharArray());
343                                        break;
344                                    case ConverterSettings.EncodingTypes.Unicode:
345                                        Output = Encoding.Unicode.GetBytes(inpString.ToCharArray());
346                                        break;
347                                    case ConverterSettings.EncodingTypes.UTF7:
348                                        Output = Encoding.UTF7.GetBytes(inpString.ToCharArray());
349                                        break;
350                                    case ConverterSettings.EncodingTypes.UTF8:
351                                        Output = Encoding.UTF8.GetBytes(inpString.ToCharArray());
352                                        break;
353                                    case ConverterSettings.EncodingTypes.UTF32:
354                                        Output = Encoding.UTF32.GetBytes(inpString.ToCharArray());
355                                        break;
356                                    case ConverterSettings.EncodingTypes.ASCII:
357                                        Output = Encoding.ASCII.GetBytes(inpString.ToCharArray());
358                                        break;
359                                    case ConverterSettings.EncodingTypes.BigEndianUnicode:
360                                        Output = Encoding.BigEndianUnicode.GetBytes(inpString.ToCharArray());
361                                        break;
362                                    default:
363                                        Output = Encoding.Default.GetBytes(inpString.ToCharArray());
364                                        break;
365                                }
366                               
367
368
369                                //GuiLogMessage("byte[] wiederherstellung " + Output.ToString(), NotificationLevel.Info);
370                                ProgressChanged(100, 100);
371                                break;
372                            }
373                           
374                        }
375                    case 8: //cryptoolstream
376                        {
377                            GuiLogMessage("redundant", NotificationLevel.Error);
378                            break;
379                        }
380                    default:
381                        {
382                            GuiLogMessage("kein fall getriggert ", NotificationLevel.Error);
383                            break;
384                        }
385                }
386
387            }
388            else
389            {
390                GuiLogMessage("not yet implemented", NotificationLevel.Error);
391            }
392
393
394        }
395
396        public String DoubleCleanup(String inpString)
397        {
398            if (this.settings.FormatAmer)
399            {
400                String temp1 = inpString.Replace(",", "");
401                if (!(temp1.IndexOf(".") == temp1.LastIndexOf(".")))
402                {
403                    String tempXY = temp1.Insert(0, "X");
404                    return tempXY;
405                }
406                if (temp1.Contains(".") && temp1.IndexOf(".") == temp1.LastIndexOf("."))
407                {
408                    String temp2 = temp1.Replace(".", ",");
409                    return temp2;
410                }
411                else
412                {
413                    String temp3 = inpString.Replace(".", "");
414                    return temp3;
415                }
416            }
417            else
418            {
419                return inpString;
420            }
421
422        }
423
424        public void Initialize()
425        {
426
427        }
428
429        public void Pause()
430        {
431
432        }
433
434        public void PostExecution()
435        {
436
437        }
438
439        public void PreExecution()
440        {
441
442        }
443
444        public void Stop()
445        {
446
447        }
448
449        #endregion
450
451        #region INotifyPropertyChanged Member
452
453        public event PropertyChangedEventHandler PropertyChanged;
454
455        protected void OnPropertyChanged(string name)
456        {
457            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
458        }
459        #endregion
460
461        #region event handling
462
463        private void Progress(double value, double max)
464        {
465            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
466        }
467
468        public event StatusChangedEventHandler OnPluginStatusChanged;
469
470        void settings_OnPluginStatusChanged(IPlugin sender, StatusEventArgs args)
471        {
472            if (OnPluginStatusChanged != null) OnPluginStatusChanged(this, args);
473        }
474
475        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
476
477        private void ProgressChanged(double value, double max)
478        {
479            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
480        }
481
482        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
483
484        private void GuiLogMessage(string p, NotificationLevel notificationLevel)
485        {
486            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(p, this, notificationLevel));
487        }
488
489        #endregion
490    }
491}
Note: See TracBrowser for help on using the repository browser.