source: trunk/CrypPlugins/StringToStreamConvertor/StringToStreamConverter.cs @ 2214

Last change on this file since 2214 was 1259, checked in by Matthäus Wander, 12 years ago

shortened license text to boilerplate notice in all source files

File size: 14.2 KB
Line 
1/*
2   Copyright 2008 Dr. Arno Wacker, University of 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 System.ComponentModel;
23using System.IO;
24using Cryptool.PluginBase.IO;
25using System.Windows.Controls;
26using System.Runtime.Remoting.Contexts;
27using Cryptool.PluginBase.Miscellaneous;
28using System.Runtime.CompilerServices;
29
30namespace Cryptool.Plugins.Convertor
31{
32    // Converts a given string into a stream by using different encodings.
33    [Author("Dr. Arno Wacker", "arno.wacker@cryptool.org", "Uni Duisburg", "http://www.uni-duisburg-essen.de")]
34    [PluginInfo(false, "String to Stream Converter", "Converts a given string into a stream.", "", "StringToStreamConverter/t2s-icon.png")]
35    public class StringToStreamConverter : IThroughput
36    {
37        #region Public interface
38
39        /// <summary>
40        /// Constructor
41        /// </summary>
42        public StringToStreamConverter()
43        {
44            this.settings = new StringToStreamConverterSettings();
45        }
46
47
48        /// <summary>
49        /// Returns the settings object, or sets it
50        /// </summary>
51        public ISettings Settings
52        {
53            get { return (ISettings)this.settings; }
54            set { this.settings = (StringToStreamConverterSettings)value; }
55        }
56
57        public object OutputStreamQuickWatchConverter(string PropertyNameToConvert)
58        {
59          return inputString;
60        }
61
62        [PropertyInfo(Direction.OutputData, "Stream output", "The stream after encoding the text from the input.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, "OutputStreamQuickWatchConverter")]
63        public CryptoolStream OutputStream
64        {
65            [MethodImpl(MethodImplOptions.Synchronized)]
66            get 
67            {
68              if (outputStream != null)
69              {
70                CryptoolStream cs = new CryptoolStream();
71                cs.OpenRead(outputStream.FileName);
72                listCryptoolStreamsOut.Add(cs);
73                return cs;
74              }
75              return null;
76            }
77            set
78            {
79            }
80        }
81
82        [PropertyInfo(Direction.OutputData, "byte[] output", "The stream after encoding the text from the input.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
83        public byte[] OutputBytes
84        {
85            [MethodImpl(MethodImplOptions.Synchronized)]
86            get
87            {
88                if (outputBytes != null)
89                {
90                    return outputBytes;
91                }
92                return null;
93            }
94            set
95            {
96            }
97        }
98
99        [PropertyInfo(Direction.InputData, "Text input", "The input text will be converted to a byte stream by using the encoding given in the settings.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
100        public string InputText
101        {
102            get { return this.inputString;  }
103            set 
104            {
105              inputString = value;
106              // processInput(value); This should be done in execute method, because PlayMode causes
107              // errors state (yellow/red markers) to be flushed on execute. So if input is processed
108              // here before execute method the plugin element will not be colored correctly if
109              // errors/warnings occur.
110              OnPropertyChanged("InputText");
111            }
112        }
113
114        #endregion
115
116        #region IPlugin Members
117
118        /// <summary>
119        /// Feuern, wenn ein neuer Text im Statusbar angezeigt werden soll.
120        /// </summary>
121        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
122
123        /// <summary>
124        /// Feuern, wenn sich sich eine Änderung des Fortschrittsbalkens ergibt
125        /// </summary>
126        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
127
128        public UserControl Presentation
129        {
130            get { return null; }
131        }
132
133        public UserControl QuickWatchPresentation
134        {
135          get { return null; }
136        }
137
138        public void Initialize() { }
139
140        public void Dispose()
141        {
142            if (outputStream != null)
143            {
144                outputStream.Flush();
145                outputStream.Close();
146                outputStream = null;
147            }
148            foreach (CryptoolStream stream in listCryptoolStreamsOut)
149            {
150              stream.Close();
151            }
152            listCryptoolStreamsOut.Clear();
153        }
154
155
156        public void Stop() { }
157
158        public bool HasChanges
159        {
160            get { return settings.HasChanges; }
161            set { settings.HasChanges = value;  }
162        }
163
164        public void PostExecution()
165        {
166            Dispose();
167        }
168
169        public void PreExecution()
170        {
171            outputStream = null;
172        }
173
174        #endregion
175
176        #region INotifyPropertyChanged Members
177
178        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
179
180        public void OnPropertyChanged(string name)
181        {
182          EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
183        }
184
185        #endregion
186
187        #region Private variables
188        private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
189        private StringToStreamConverterSettings settings;
190        private CryptoolStream outputStream = null;
191        private byte[] outputBytes = null;
192        private string inputString;
193        #endregion
194
195        #region Private methods
196
197        private void processInput(string value)
198        {
199            ShowStatusBarMessage("Got string input..", NotificationLevel.Debug);
200       
201            if ((value != null) && (value.Length != 0))
202            {               
203                ShowProgress(50, 100);
204                ShowStatusBarMessage("Converting input ...", NotificationLevel.Debug);
205                outputStream = new CryptoolStream();
206                listCryptoolStreamsOut.Add(outputStream);
207               
208                // here conversion happens
209                switch (settings.Encoding)
210                {
211                    case StringToStreamConverterSettings.EncodingTypes.Default:
212                        outputBytes = Encoding.Default.GetBytes(value);
213                        outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
214                        break;
215                    case StringToStreamConverterSettings.EncodingTypes.Base64Binary:
216                        try
217                        {
218                            outputBytes = Convert.FromBase64String(value);
219                            outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
220                        }
221                        catch (Exception ex)
222                        {
223                            ShowStatusBarMessage("Error converting input! Not a valid base64 string (" + ex.Message + ")", NotificationLevel.Error);
224                            // outputStream = null;
225                            return;
226                        }
227                        break;
228                    case StringToStreamConverterSettings.EncodingTypes.HexStringBinary:
229                        try
230                        {
231                            outputBytes = convertHexStringToByteArray(value);
232                            outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
233                        }
234                        catch (Exception ex)
235                        {
236                            ShowStatusBarMessage("Error converting input! Not a valid hex-string (" + ex.Message + ")", NotificationLevel.Error);
237                            return;
238                        }
239                        break;
240                    case StringToStreamConverterSettings.EncodingTypes.OctalStringBinary:
241                        try
242                        {
243                            outputBytes = convertOctalStringToByteArray(value);
244                            outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
245                        }
246                        catch (Exception ex)
247                        {
248                            ShowStatusBarMessage("Error converting input! Not a valid octal-string (" + ex.Message + ")", NotificationLevel.Error);
249                            return;
250                        }
251                        break;
252                    case StringToStreamConverterSettings.EncodingTypes.Unicode:
253                        outputBytes = Encoding.Unicode.GetBytes(value);
254                        outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
255                        break;
256                    case StringToStreamConverterSettings.EncodingTypes.UTF7:
257                        outputBytes = Encoding.UTF7.GetBytes(value);
258                        outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
259                        break;
260                    case StringToStreamConverterSettings.EncodingTypes.UTF8:
261                        outputBytes = Encoding.UTF8.GetBytes(value);
262                        outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
263                        break;
264                    case StringToStreamConverterSettings.EncodingTypes.UTF32:
265                        outputBytes = Encoding.UTF32.GetBytes(value);
266                        outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
267                        break;
268                    case StringToStreamConverterSettings.EncodingTypes.ASCII:
269                        outputBytes = Encoding.ASCII.GetBytes(value);
270                        outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
271                        break;
272                    case StringToStreamConverterSettings.EncodingTypes.BigEndianUnicode:
273                        outputBytes = Encoding.BigEndianUnicode.GetBytes(value);
274                        outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
275                        break;
276                    default:
277                        outputBytes = Encoding.Default.GetBytes(value);
278                        outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
279                        break;
280                }
281                               
282                ShowStatusBarMessage("Input converted.", NotificationLevel.Info);
283                ShowProgress(100, 100);
284                OnPropertyChanged("InputString");
285                OnPropertyChanged("OutputBytes");
286                OnPropertyChanged("OutputStream");
287            }
288            else
289            {
290                inputString = null;
291                outputStream = null;
292                outputBytes = null;
293                ShowStatusBarMessage("String input is empty. Nothing to convert.", NotificationLevel.Warning);
294            }
295       
296        }
297
298
299        private byte[] convertHexStringToByteArray(String hexString)
300        {
301            if (null == hexString)
302                return new byte[0];
303           
304            StringBuilder cleanHexString = new StringBuilder();
305
306            //cleanup the input
307            foreach (char c in hexString)
308            {
309                if (Uri.IsHexDigit(c))
310                    cleanHexString.Append(c);
311            }
312
313            int numberChars = cleanHexString.Length;
314
315            if (numberChars < 2) // Need at least 2 chars to make one byte
316                return new byte[0];
317
318            byte[] bytes = new byte[numberChars / 2];
319
320            for (int i = 0; i < numberChars; i += 2)
321            {
322                bytes[i / 2] = Convert.ToByte(cleanHexString.ToString().Substring(i, 2), 16);
323            }
324            return bytes;
325        }
326
327
328        private byte[] convertOctalStringToByteArray(String octalString)
329        {
330            if (null == octalString)
331                return new byte[0];
332
333            StringBuilder cleanOctalString = new StringBuilder();
334
335            //cleanup the input
336            foreach (char c in octalString)
337            {
338                if (char.IsDigit(c) && c!='8' && c!='9')
339                    cleanOctalString.Append(c);
340            }
341
342            int numberChars = cleanOctalString.Length;
343
344            if (numberChars < 3) // Need at least 3 chars to make one byte
345                return new byte[0];
346
347            byte[] bytes = new byte[numberChars / 3];
348
349            for (int i = 0; i < numberChars; i += 3)
350            {
351                bytes[i / 3] = Convert.ToByte(cleanOctalString.ToString().Substring(i, 3), 8);
352            }
353            return bytes;
354        }
355
356        private void ShowStatusBarMessage(string message, NotificationLevel logLevel)
357        {
358          EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(message, this, logLevel));
359        }
360
361        private void ShowProgress(double value, double max)
362        {
363          EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
364        }
365
366        #endregion
367
368
369        #region IPlugin Members
370
371        public event StatusChangedEventHandler OnPluginStatusChanged;
372
373        public void Execute()
374        {
375          processInput(InputText);
376        }
377
378        public void Pause()
379        {
380        }
381        #endregion
382    }
383}
Note: See TracBrowser for help on using the repository browser.