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

Last change on this file since 1237 was 1237, checked in by pretzsch, 12 years ago

+ Converter plugin: Added conversion from byte to CryptoolStream

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