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

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

Added comments on Converter.cs

File size: 19.8 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                // the string representation is used for all upcoming operations
156                string inpString = Convert.ToString(InputOne);
157
158
159
160                switch (this.settings.Converter) // convert to what?
161                {
162                    case 0: //String
163                        {
164                            Output = inpString;
165                            ProgressChanged(100, 100);
166                            break;
167                        }
168                    case 1: //int
169                        {
170
171                            try // can be read as int?
172                            {
173                                int temp = Convert.ToInt32(inpString);
174                               
175                                Output = temp;
176                                ProgressChanged(100, 100);
177                            }
178                            catch (Exception e)
179                            {
180                                GuiLogMessage("Could not convert input to integer: " + e.Message, NotificationLevel.Error);
181                            }
182                            break;
183                        }
184                    case 2: //short
185                        {
186
187                            try // can be read as short?
188                            {
189                                short temp = Convert.ToInt16(inpString);
190                             
191                                Output = temp;
192                                ProgressChanged(100, 100);
193                            }
194                            catch (Exception e)
195                            {
196                                GuiLogMessage("Could not convert input to short: " + e.Message, NotificationLevel.Error);
197                            }
198                            break;
199                        }
200                    case 3: //byte
201                        {
202                            try // can be read as byte?
203                            {
204                                byte temp = Convert.ToByte(inpString);
205                               
206                                Output = temp;
207                                ProgressChanged(100, 100);
208                            }
209                            catch (Exception e)
210                            {
211                                GuiLogMessage("Could not convert input to byte: " + e.Message, NotificationLevel.Error);
212                            }
213                            break;
214                        }
215                    case 4: //double
216                        {
217                            try // can be read as double?
218                            {
219                                String cleanInputString = DoubleCleanup(inpString); // apply user settings concerning input format
220
221                                double temp = Convert.ToDouble(cleanInputString);
222                                GuiLogMessage("Converting String to double is not safe. Digits may have been cut off  ", NotificationLevel.Warning);
223                                Output = temp;
224                                ProgressChanged(100, 100);
225                            }
226
227                            catch (Exception e)
228                            {
229                                GuiLogMessage("Could not convert input to double: " + e.Message, NotificationLevel.Error);
230                            }
231                            break;
232
233                        }
234                    case 5: //bigint
235                        {
236                            try // can be read as biginteger?
237                            {
238
239                                BigInteger temp = BigInteger.parseExpression(inpString);
240                               
241                                Output = temp;
242                                ProgressChanged(100, 100);
243                            }
244                            catch (Exception e)
245                            {
246                                GuiLogMessage("Could not convert input to biginteger: " + e.Message, NotificationLevel.Error);
247                            }
248                            break;
249                        }
250                    case 6: // int[]
251                        {
252                            GuiLogMessage("Conversion to int[] not yet defined: ", NotificationLevel.Error);
253                            break;
254                        }
255                    case 7: // byte[]
256                        {
257                            inpString = setText(inpString);
258                            if (settings.Numeric) // apply user setting concerning numeric interpretation of input (else input is read as string)
259                            {
260                                try // can be read as int?
261                                {
262                                    int tempint = Convert.ToInt32(inpString);
263                                    byte[] temp = new byte[4];
264                                    temp = BitConverter.GetBytes(tempint);
265
266                                    int test = BitConverter.ToInt32(temp, 0);
267                                 
268
269                                    Output = temp;
270
271                                    ProgressChanged(100, 100);
272                                    break;
273                                }
274                                catch (Exception e)
275                                {
276
277                                }
278
279                                try // can be read as biginteger?
280                                {
281                                    BigInteger tempbigint = new BigInteger(inpString, 10);
282
283                                    int numBits = tempbigint.bitCount();
284
285                                    int numBytes = numBits >> 3;
286                                    if ((numBits & 0x7) != 0)
287                                        numBytes++;
288                                    byte[] temp = new byte[numBytes];
289                                    temp = tempbigint.getBytes();
290
291                                    BigInteger test = new BigInteger(temp);
292                                 
293                                    Output = temp;
294
295                                    ProgressChanged(100, 100);
296                                    break;
297                                }
298                                catch (Exception e)
299                                {
300
301                                }
302                                try // can be read as double
303                                {   
304                                   
305                                   
306                                   
307                                        double tempDouble = Convert.ToDouble(DoubleCleanup(inpString));
308                                        byte[] temp = BitConverter.GetBytes(tempDouble);
309
310                                        double test = BitConverter.ToDouble(temp, 0);
311                                        GuiLogMessage("Converting String to double is not safe. Digits may have been cut off " + test.ToString(), NotificationLevel.Warning);
312
313                                        Output = temp;
314
315                                        ProgressChanged(100, 100);
316                                        break;
317                                   
318                                 
319                                 
320                                }
321                                catch (Exception e)
322                                {
323
324                                }
325                                System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
326                                Output = enc.GetBytes(inpString);
327
328
329                           
330                                ProgressChanged(100, 100);
331                                break;
332                               
333                               
334                               
335                            }
336                            else // numeric interpretation NOT selected:
337                            {
338                                switch (settings.Encoding) //apply user settings concerning encoding
339                                {
340                                    case ConverterSettings.EncodingTypes.Default:
341                                        Output = Encoding.Default.GetBytes(inpString.ToCharArray());
342                                        break;
343                                    case ConverterSettings.EncodingTypes.Unicode:
344                                        Output = Encoding.Unicode.GetBytes(inpString.ToCharArray());
345                                        break;
346                                    case ConverterSettings.EncodingTypes.UTF7:
347                                        Output = Encoding.UTF7.GetBytes(inpString.ToCharArray());
348                                        break;
349                                    case ConverterSettings.EncodingTypes.UTF8:
350                                        Output = Encoding.UTF8.GetBytes(inpString.ToCharArray());
351                                        break;
352                                    case ConverterSettings.EncodingTypes.UTF32:
353                                        Output = Encoding.UTF32.GetBytes(inpString.ToCharArray());
354                                        break;
355                                    case ConverterSettings.EncodingTypes.ASCII:
356                                        Output = Encoding.ASCII.GetBytes(inpString.ToCharArray());
357                                        break;
358                                    case ConverterSettings.EncodingTypes.BigEndianUnicode:                             
359                                        Output = Encoding.BigEndianUnicode.GetBytes(inpString.ToCharArray());
360                                        break;
361                                    default:
362                                        Output = Encoding.Default.GetBytes(inpString.ToCharArray());
363                                        break;
364                                }
365                               
366
367
368                             
369                                ProgressChanged(100, 100);
370                                break;
371                            }
372                           
373                        }
374                    case 8: //cryptoolstream
375                        {
376                            GuiLogMessage("Conversion to Cryptoolstream not yet implemented", NotificationLevel.Error);
377                            break;
378                        }
379                    default:
380                        {
381                         
382                            break;
383                        }
384                }
385
386            }
387            else
388            {
389                GuiLogMessage("not yet implemented", NotificationLevel.Error);
390            }
391
392
393        }
394        private String setText(string temp) //apply user selected presentation format
395        {
396            if (temp != null)
397            {
398               
399                switch (settings.Presentation)
400                {
401                    case ConverterSettings.PresentationFormat.Text:
402                        // nothin to do here
403                        break;
404                    case ConverterSettings.PresentationFormat.Hex:
405                        byte[] byteValues = Encoding.Default.GetBytes(temp.ToCharArray());
406                        temp = BitConverter.ToString(byteValues, 0, byteValues.Length).Replace("-", "");
407                        break;
408                    case ConverterSettings.PresentationFormat.Base64:
409                        temp = Convert.ToBase64String(Encoding.Default.GetBytes(temp.ToCharArray()));
410                        break;
411                    default:
412                        break;
413                }
414                return temp;
415            }
416            return temp;
417        }
418        public String DoubleCleanup(String inpString) //apply user selected input format
419        {
420            if (this.settings.FormatAmer)
421            {
422                String temp1 = inpString.Replace(",", "");
423                if (!(temp1.IndexOf(".") == temp1.LastIndexOf(".")))
424                {
425                    String tempXY = temp1.Insert(0, "X");
426                    return tempXY;
427                }
428                if (temp1.Contains(".") && temp1.IndexOf(".") == temp1.LastIndexOf("."))
429                {
430                    String temp2 = temp1.Replace(".", ",");
431                    return temp2;
432                }
433                else
434                {
435                    String temp3 = inpString.Replace(".", "");
436                    return temp3;
437                }
438            }
439            else
440            {
441                return inpString;
442            }
443
444        }
445
446        public void Initialize()
447        {
448
449        }
450
451        public void Pause()
452        {
453
454        }
455
456        public void PostExecution()
457        {
458
459        }
460
461        public void PreExecution()
462        {
463
464        }
465
466        public void Stop()
467        {
468
469        }
470
471        #endregion
472
473        #region INotifyPropertyChanged Member
474
475        public event PropertyChangedEventHandler PropertyChanged;
476
477        protected void OnPropertyChanged(string name)
478        {
479            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
480        }
481        #endregion
482
483        #region event handling
484
485        private void Progress(double value, double max)
486        {
487            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
488        }
489
490        public event StatusChangedEventHandler OnPluginStatusChanged;
491
492        void settings_OnPluginStatusChanged(IPlugin sender, StatusEventArgs args)
493        {
494            if (OnPluginStatusChanged != null) OnPluginStatusChanged(this, args);
495        }
496
497        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
498
499        private void ProgressChanged(double value, double max)
500        {
501            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
502        }
503
504        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
505
506        private void GuiLogMessage(string p, NotificationLevel notificationLevel)
507        {
508            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(p, this, notificationLevel));
509        }
510
511        #endregion
512    }
513}
Note: See TracBrowser for help on using the repository browser.