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

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

Added Hex / Base64 Representation on Converter

File size: 20.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/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                            inpString = setText(inpString);
260                            if (settings.Numeric)
261                            {
262                                try // lässt sich als int verstehen?
263                                {
264                                    int tempint = Convert.ToInt32(inpString);
265                                    byte[] temp = new byte[4];
266                                    temp = BitConverter.GetBytes(tempint);
267
268                                    int test = BitConverter.ToInt32(temp, 0);
269                                  //  GuiLogMessage("int erkannt " + test.ToString(), NotificationLevel.Info);
270
271                                    Output = temp;
272
273                                    ProgressChanged(100, 100);
274                                    break;
275                                }
276                                catch (Exception e)
277                                {
278
279                                }
280
281                                try // lässt sich als bigint verstehen?
282                                {
283                                    BigInteger tempbigint = new BigInteger(inpString, 10);
284
285                                    int numBits = tempbigint.bitCount();
286
287                                    int numBytes = numBits >> 3;
288                                    if ((numBits & 0x7) != 0)
289                                        numBytes++;
290                                    byte[] temp = new byte[numBytes];
291                                    temp = tempbigint.getBytes();
292
293                                    BigInteger test = new BigInteger(temp);
294                                   // GuiLogMessage("bigint erkannt " + test.ToString(), NotificationLevel.Info);
295                                    Output = temp;
296
297                                    ProgressChanged(100, 100);
298                                    break;
299                                }
300                                catch (Exception e)
301                                {
302
303                                }
304                                try // lässt sich als double verstehen?
305                                {   
306                                   
307                                   
308                                   
309                                        double tempDouble = Convert.ToDouble(DoubleCleanup(inpString));
310                                        byte[] temp = BitConverter.GetBytes(tempDouble);
311
312                                        double test = BitConverter.ToDouble(temp, 0);
313                                        GuiLogMessage("Converting String to double is not safe. Digits may have been cut off " + test.ToString(), NotificationLevel.Warning);
314
315                                        Output = temp;
316
317                                        ProgressChanged(100, 100);
318                                        break;
319                                   
320                                 
321                                 
322                                }
323                                catch (Exception e)
324                                {
325
326                                }
327                                System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
328                                Output = enc.GetBytes(inpString);
329
330
331                                //GuiLogMessage("byte[] wiederherstellung " + Output.ToString(), NotificationLevel.Info);
332                                ProgressChanged(100, 100);
333                                break;
334                               
335                               
336                               
337                            }
338                            else
339                            {
340                                switch (settings.Encoding)
341                                {
342                                    case ConverterSettings.EncodingTypes.Default:
343                                        Output = Encoding.Default.GetBytes(inpString.ToCharArray());
344                                        break;
345                                    case ConverterSettings.EncodingTypes.Unicode:
346                                        Output = Encoding.Unicode.GetBytes(inpString.ToCharArray());
347                                        break;
348                                    case ConverterSettings.EncodingTypes.UTF7:
349                                        Output = Encoding.UTF7.GetBytes(inpString.ToCharArray());
350                                        break;
351                                    case ConverterSettings.EncodingTypes.UTF8:
352                                        Output = Encoding.UTF8.GetBytes(inpString.ToCharArray());
353                                        break;
354                                    case ConverterSettings.EncodingTypes.UTF32:
355                                        Output = Encoding.UTF32.GetBytes(inpString.ToCharArray());
356                                        break;
357                                    case ConverterSettings.EncodingTypes.ASCII:
358                                        Output = Encoding.ASCII.GetBytes(inpString.ToCharArray());
359                                        break;
360                                    case ConverterSettings.EncodingTypes.BigEndianUnicode:                             
361                                        Output = Encoding.BigEndianUnicode.GetBytes(inpString.ToCharArray());
362                                        break;
363                                    default:
364                                        Output = Encoding.Default.GetBytes(inpString.ToCharArray());
365                                        break;
366                                }
367                               
368
369
370                                //GuiLogMessage("byte[] wiederherstellung " + Output.ToString(), NotificationLevel.Info);
371                                ProgressChanged(100, 100);
372                                break;
373                            }
374                           
375                        }
376                    case 8: //cryptoolstream
377                        {
378                            GuiLogMessage("redundant", NotificationLevel.Error);
379                            break;
380                        }
381                    default:
382                        {
383                         //   GuiLogMessage("kein fall getriggert ", NotificationLevel.Error);
384                            break;
385                        }
386                }
387
388            }
389            else
390            {
391                GuiLogMessage("not yet implemented", NotificationLevel.Error);
392            }
393
394
395        }
396        private String setText(string temp)
397        {
398            if (temp != null)
399            {
400                // Presentation format conversion
401                switch (settings.Presentation)
402                {
403                    case ConverterSettings.PresentationFormat.Text:
404                        // nothin to do here
405                        break;
406                    case ConverterSettings.PresentationFormat.Hex:
407                        byte[] byteValues = Encoding.Default.GetBytes(temp.ToCharArray());
408                        temp = BitConverter.ToString(byteValues, 0, byteValues.Length).Replace("-", "");
409                        break;
410                    case ConverterSettings.PresentationFormat.Base64:
411                        temp = Convert.ToBase64String(Encoding.Default.GetBytes(temp.ToCharArray()));
412                        break;
413                    default:
414                        break;
415                }
416                return temp;
417            }
418            return temp;
419        }
420        public String DoubleCleanup(String inpString)
421        {
422            if (this.settings.FormatAmer)
423            {
424                String temp1 = inpString.Replace(",", "");
425                if (!(temp1.IndexOf(".") == temp1.LastIndexOf(".")))
426                {
427                    String tempXY = temp1.Insert(0, "X");
428                    return tempXY;
429                }
430                if (temp1.Contains(".") && temp1.IndexOf(".") == temp1.LastIndexOf("."))
431                {
432                    String temp2 = temp1.Replace(".", ",");
433                    return temp2;
434                }
435                else
436                {
437                    String temp3 = inpString.Replace(".", "");
438                    return temp3;
439                }
440            }
441            else
442            {
443                return inpString;
444            }
445
446        }
447
448        public void Initialize()
449        {
450
451        }
452
453        public void Pause()
454        {
455
456        }
457
458        public void PostExecution()
459        {
460
461        }
462
463        public void PreExecution()
464        {
465
466        }
467
468        public void Stop()
469        {
470
471        }
472
473        #endregion
474
475        #region INotifyPropertyChanged Member
476
477        public event PropertyChangedEventHandler PropertyChanged;
478
479        protected void OnPropertyChanged(string name)
480        {
481            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
482        }
483        #endregion
484
485        #region event handling
486
487        private void Progress(double value, double max)
488        {
489            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
490        }
491
492        public event StatusChangedEventHandler OnPluginStatusChanged;
493
494        void settings_OnPluginStatusChanged(IPlugin sender, StatusEventArgs args)
495        {
496            if (OnPluginStatusChanged != null) OnPluginStatusChanged(this, args);
497        }
498
499        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
500
501        private void ProgressChanged(double value, double max)
502        {
503            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
504        }
505
506        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
507
508        private void GuiLogMessage(string p, NotificationLevel notificationLevel)
509        {
510            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(p, this, notificationLevel));
511        }
512
513        #endregion
514    }
515}
Note: See TracBrowser for help on using the repository browser.