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

Last change on this file since 1448 was 1448, checked in by Sven Rech, 12 years ago

replaced all BigInteger stuff with the new BigInteger class from .net 4.0

But there are still problems with some plugins (Keysearcher, BigInteger Operations...)

File size: 20.4 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;
27using System.Numerics;
28
29namespace Cryptool.Plugins.Converter
30{
31    [Author("Raoul Falk, Dennis Nolte", "falk@cryptool.org", "Uni Duisburg-Essen", "http://www.uni-due.de")]
32    [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")]
33
34    class Converter : IThroughput
35    {
36        #region private variables
37
38        private ConverterSettings settings = new ConverterSettings();
39        private object inputOne;
40        private object output;
41
42        #endregion
43
44        private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
45
46        #region public interfaces
47
48        public Converter()
49        {
50            // this.settings = new ConverterSettings();
51            this.settings.OnPluginStatusChanged += settings_OnPluginStatusChanged;
52        }
53
54        public ISettings Settings
55        {
56            get { return this.settings; }
57            set { this.settings = (ConverterSettings)value; }
58        }
59
60        private void Converter_LogMessage(string msg, NotificationLevel loglevel)
61        {
62            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(msg, this, loglevel));
63        }
64
65        public System.Windows.Controls.UserControl Presentation
66        {
67            get { return null; }
68        }
69
70        public System.Windows.Controls.UserControl QuickWatchPresentation
71        {
72            get { return null; }
73        }
74
75        [PropertyInfo(Direction.InputData, "Input one", "Input one.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
76        public object InputOne
77        {
78            [MethodImpl(MethodImplOptions.Synchronized)]
79            get { return inputOne; }
80            [MethodImpl(MethodImplOptions.Synchronized)]
81            set
82            {
83                if (value != inputOne)
84                {
85                    inputOne = value;
86                    OnPropertyChanged("InputOne");
87                }
88            }
89        }
90
91
92
93        [PropertyInfo(Direction.OutputData, "Output", "Output.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
94        public object Output
95        {
96            [MethodImpl(MethodImplOptions.Synchronized)]
97            get
98            {
99                if (inputOne == null)
100                    return null;
101
102                if (settings.Converter == 8)
103                {
104                    byte[] streamData = null;
105
106                    if (inputOne is byte[])
107                        streamData = (byte[])inputOne;
108                    else if (inputOne is byte)
109                        streamData = new byte[] { (byte)inputOne };
110
111                    if (streamData != null)
112                    {
113                        CryptoolStream stream = new CryptoolStream();
114                        listCryptoolStreamsOut.Add(stream);
115                        stream.OpenRead(streamData);
116                        return stream;
117                    }
118                    else
119                    {
120                        GuiLogMessage("Conversion from " + inputOne.GetType().Name + " to Cryptoolstream is not yet implemented", NotificationLevel.Error);
121                        return null;
122                    }
123                }
124                else
125                {
126                    return output;
127                }
128            }
129
130            [MethodImpl(MethodImplOptions.Synchronized)]
131            set
132            {
133                this.output = value;
134                OnPropertyChanged("Output");
135            }
136        }
137
138        #endregion
139
140        #region IPlugin members
141
142        public void Dispose()
143        {
144            foreach (CryptoolStream stream in listCryptoolStreamsOut)
145                stream.Close();
146        }
147
148        public void Execute()
149        {
150            if (InputOne != null)
151                GuiLogMessage("Laufe! " + InputOne.ToString(), NotificationLevel.Debug);
152
153            if (!(InputOne is int[] || InputOne is CryptoolStream))
154            {
155                if (inputOne is bool)
156                {
157                    switch (this.settings.Converter)
158                    {
159                        case 0:
160                            {
161                                Output = inputOne.ToString();
162                                ProgressChanged(100, 100);
163                                break;
164                            }
165                        case 1:
166                            {
167                                if ((bool)inputOne)
168                                {
169                                    Output = 1;
170                                    ProgressChanged(100, 100);
171                                    break;
172                                }
173                                else
174                                {
175                                    Output = 0;
176                                    ProgressChanged(100, 100);
177                                    break;
178                                }
179                            }
180                        default:
181                            {
182                                GuiLogMessage("Could not convert from bool to chosen type: ", NotificationLevel.Error);
183                                break;
184
185                            }
186                    }
187                    return;
188                }
189                // the string representation is used for all upcoming operations
190                string inpString = Convert.ToString(InputOne);
191
192
193
194                switch (this.settings.Converter) // convert to what?
195                {
196                    case 0: //String
197                        {
198                            Output = inpString;
199                            ProgressChanged(100, 100);
200                            break;
201                        }
202                    case 1: //int
203                        {
204
205                            try // can be read as int?
206                            {
207                                int temp = Convert.ToInt32(inpString);
208
209                                Output = temp;
210                                ProgressChanged(100, 100);
211                            }
212                            catch (Exception e)
213                            {
214                                GuiLogMessage("Could not convert input to integer: " + e.Message, NotificationLevel.Error);
215                            }
216                            break;
217                        }
218                    case 2: //short
219                        {
220
221                            try // can be read as short?
222                            {
223                                short temp = Convert.ToInt16(inpString);
224
225                                Output = temp;
226                                ProgressChanged(100, 100);
227                            }
228                            catch (Exception e)
229                            {
230                                GuiLogMessage("Could not convert input to short: " + e.Message, NotificationLevel.Error);
231                            }
232                            break;
233                        }
234                    case 3: //byte
235                        {
236                            try // can be read as byte?
237                            {
238                                byte temp = Convert.ToByte(inpString);
239
240                                Output = temp;
241                                ProgressChanged(100, 100);
242                            }
243                            catch (Exception e)
244                            {
245                                GuiLogMessage("Could not convert input to byte: " + e.Message, NotificationLevel.Error);
246                            }
247                            break;
248                        }
249                    case 4: //double
250                        {
251                            try // can be read as double?
252                            {
253                                String cleanInputString = DoubleCleanup(inpString); // apply user settings concerning input format
254
255                                double temp = Convert.ToDouble(cleanInputString);
256                                GuiLogMessage("Converting String to double is not safe. Digits may have been cut off  ", NotificationLevel.Warning);
257                                Output = temp;
258                                ProgressChanged(100, 100);
259                            }
260
261                            catch (Exception e)
262                            {
263                                GuiLogMessage("Could not convert input to double: " + e.Message, NotificationLevel.Error);
264                            }
265                            break;
266
267                        }
268                    case 5: //bigint
269                        {
270                            try // can be read as biginteger?
271                            {
272
273                                BigInteger temp = BigIntegerHelper.parseExpression(inpString);
274
275                                Output = temp;
276                                ProgressChanged(100, 100);
277                            }
278                            catch (Exception e)
279                            {
280                                GuiLogMessage("Could not convert input to biginteger: " + e.Message, NotificationLevel.Error);
281                            }
282                            break;
283                        }
284                    case 6: // int[]
285                        {
286                            GuiLogMessage("Conversion to int[] not yet defined: ", NotificationLevel.Error);
287                            break;
288                        }
289                    case 7: // byte[]
290                        {
291                            inpString = setText(inpString);
292                            if (settings.Numeric) // apply user setting concerning numeric interpretation of input (else input is read as string)
293                            {
294                                try // can be read as int?
295                                {
296                                    int tempint = Convert.ToInt32(inpString);
297                                    byte[] temp = new byte[4];
298                                    temp = BitConverter.GetBytes(tempint);
299
300                                    int test = BitConverter.ToInt32(temp, 0);
301
302
303                                    Output = temp;
304
305                                    ProgressChanged(100, 100);
306                                    break;
307                                }
308                                catch (Exception e)
309                                {
310
311                                }
312
313                                try // can be read as biginteger?
314                                {
315                                    BigInteger tempbigint = BigInteger.Parse(inpString);
316                                    Output = tempbigint;
317
318                                    ProgressChanged(100, 100);
319                                    break;
320                                }
321                                catch (Exception e)
322                                {
323
324                                }
325                                try // can be read as double
326                                {
327
328
329
330                                    double tempDouble = Convert.ToDouble(DoubleCleanup(inpString));
331                                    byte[] temp = BitConverter.GetBytes(tempDouble);
332
333                                    double test = BitConverter.ToDouble(temp, 0);
334                                    GuiLogMessage("Converting String to double is not safe. Digits may have been cut off " + test.ToString(), NotificationLevel.Warning);
335
336                                    Output = temp;
337
338                                    ProgressChanged(100, 100);
339                                    break;
340
341
342
343                                }
344                                catch (Exception e)
345                                {
346
347                                }
348                                System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
349                                Output = enc.GetBytes(inpString);
350
351
352
353                                ProgressChanged(100, 100);
354                                break;
355
356
357
358                            }
359                            else // numeric interpretation NOT selected:
360                            {
361                                switch (settings.Encoding) //apply user settings concerning encoding
362                                {
363                                    case ConverterSettings.EncodingTypes.Default:
364                                        Output = Encoding.Default.GetBytes(inpString.ToCharArray());
365                                        break;
366                                    case ConverterSettings.EncodingTypes.Unicode:
367                                        Output = Encoding.Unicode.GetBytes(inpString.ToCharArray());
368                                        break;
369                                    case ConverterSettings.EncodingTypes.UTF7:
370                                        Output = Encoding.UTF7.GetBytes(inpString.ToCharArray());
371                                        break;
372                                    case ConverterSettings.EncodingTypes.UTF8:
373                                        Output = Encoding.UTF8.GetBytes(inpString.ToCharArray());
374                                        break;
375                                    case ConverterSettings.EncodingTypes.UTF32:
376                                        Output = Encoding.UTF32.GetBytes(inpString.ToCharArray());
377                                        break;
378                                    case ConverterSettings.EncodingTypes.ASCII:
379                                        Output = Encoding.ASCII.GetBytes(inpString.ToCharArray());
380                                        break;
381                                    case ConverterSettings.EncodingTypes.BigEndianUnicode:
382                                        Output = Encoding.BigEndianUnicode.GetBytes(inpString.ToCharArray());
383                                        break;
384                                    default:
385                                        Output = Encoding.Default.GetBytes(inpString.ToCharArray());
386                                        break;
387                                }
388
389
390
391
392                                ProgressChanged(100, 100);
393                                break;
394                            }
395
396                        }
397                    case 8: //cryptoolstream
398                        {
399
400                            if (inputOne is byte[] || inputOne is byte)
401                            {
402                                OnPropertyChanged("Output");
403                            }
404                            else
405                            {
406                                GuiLogMessage("Conversion from " + inputOne.GetType().Name + " to Cryptoolstream is not yet implemented", NotificationLevel.Error);
407                            }
408                            break;
409                        }
410                    default:
411                        {
412
413                            break;
414                        }
415                }
416
417            }
418            else
419            {
420                GuiLogMessage("not yet implemented", NotificationLevel.Error);
421            }
422        }
423        private String setText(string temp) //apply user selected presentation format
424        {
425            if (temp != null)
426            {
427
428                switch (settings.Presentation)
429                {
430                    case ConverterSettings.PresentationFormat.Text:
431                        // nothin to do here
432                        break;
433                    case ConverterSettings.PresentationFormat.Hex:
434                        byte[] byteValues = Encoding.Default.GetBytes(temp.ToCharArray());
435                        temp = BitConverter.ToString(byteValues, 0, byteValues.Length).Replace("-", "");
436                        break;
437                    case ConverterSettings.PresentationFormat.Base64:
438                        temp = Convert.ToBase64String(Encoding.Default.GetBytes(temp.ToCharArray()));
439                        break;
440                    default:
441                        break;
442                }
443                return temp;
444            }
445            return temp;
446        }
447        public String DoubleCleanup(String inpString) //apply user selected input format
448        {
449            if (this.settings.FormatAmer)
450            {
451                String temp1 = inpString.Replace(",", "");
452                if (!(temp1.IndexOf(".") == temp1.LastIndexOf(".")))
453                {
454                    String tempXY = temp1.Insert(0, "X");
455                    return tempXY;
456                }
457                if (temp1.Contains(".") && temp1.IndexOf(".") == temp1.LastIndexOf("."))
458                {
459                    String temp2 = temp1.Replace(".", ",");
460                    return temp2;
461                }
462                else
463                {
464                    String temp3 = inpString.Replace(".", "");
465                    return temp3;
466                }
467            }
468            else
469            {
470                return inpString;
471            }
472
473        }
474
475        public void Initialize()
476        {
477            settings.UpdateTaskPaneVisibility();
478            settings.UpdateIcon();
479        }
480
481        public void Pause()
482        {
483
484        }
485
486        public void PostExecution()
487        {
488
489        }
490
491        public void PreExecution()
492        {
493
494        }
495
496        public void Stop()
497        {
498
499        }
500
501        #endregion
502
503        #region INotifyPropertyChanged Member
504
505        public event PropertyChangedEventHandler PropertyChanged;
506
507        protected void OnPropertyChanged(string name)
508        {
509            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
510        }
511        #endregion
512
513        #region event handling
514
515        private void Progress(double value, double max)
516        {
517            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
518        }
519
520        public event StatusChangedEventHandler OnPluginStatusChanged;
521
522        void settings_OnPluginStatusChanged(IPlugin sender, StatusEventArgs args)
523        {
524            if (OnPluginStatusChanged != null) OnPluginStatusChanged(this, args);
525        }
526
527        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
528
529        private void ProgressChanged(double value, double max)
530        {
531            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
532        }
533
534        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
535
536        private void GuiLogMessage(string p, NotificationLevel notificationLevel)
537        {
538            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(p, this, notificationLevel));
539        }
540
541        #endregion
542    }
543}
Note: See TracBrowser for help on using the repository browser.