source: trunk/CrypPlugins/StreamToStringConverter/StreamToStringConverter.cs @ 2263

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

shortened license text to boilerplate notice in all source files

File size: 11.0 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    [Author("Dr. Arno Wacker", "arno.wacker@cryptool.org", "Uni Duisburg", "http://www.uni-duisburg-essen.de")]
33    [PluginInfo(false, "Stream to String Converter", "Converts a given stream into a string.", "", "StreamToStringConverter/s2t-icon.png")]   
34    public class StreamToStringConverter : IThroughput
35    {       
36        #region Public interface
37
38        /// <summary>
39        /// Constructor
40        /// </summary>
41        public StreamToStringConverter()
42        {
43            this.settings = new StreamToStringConverterSettings();
44        }
45
46
47        /// <summary>
48        /// Returns the settings object, or sets it
49        /// </summary>
50        public ISettings Settings
51        {
52            get { return (ISettings)this.settings; }
53            set { this.settings = (StreamToStringConverterSettings)value; }
54        }
55
56        [PropertyInfo(Direction.OutputData, "Text output", "The string after decoding the bytes from the input stream.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
57        public string OutputString
58        {
59            get { return this.outputString; }
60            set
61            {
62                outputString = value;
63                OnPropertyChanged("OutputString");
64            }
65        }
66
67        public object InputStreamQuickWatchConverter(string PropertyNameToConvert)
68        {
69          return outputString;
70        }
71
72        [PropertyInfo(Direction.InputData, "Stream input", "Input stream will be converted to ASCII text. The encoding given in the settings will be used.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, "InputStreamQuickWatchConverter")]
73        public CryptoolStream InputStream
74        {           
75            get 
76            {
77              CryptoolStream cryptoolStream = null;
78              if (inputStream != null)
79              {
80                cryptoolStream = new CryptoolStream();
81                cryptoolStream.OpenRead(inputStream.FileName);
82                listCryptoolStreams.Add(cryptoolStream);               
83              }
84              return cryptoolStream;
85            }
86            set 
87            {
88              inputStream = value;
89              if (value != null) listCryptoolStreams.Add(value);
90              // processInput(value); This should be done in execute method, because PlayMode causes
91              // errors state (yellow/red markers) to be flushed on execute. So if input is processed
92              // here before execute method the plugin element will not be colored correctly if
93              // errors/warnings occur.
94              OnPropertyChanged("InputStream");
95            }
96        }
97
98        #endregion
99
100        #region IPlugin Members
101
102        /// <summary>
103        /// Feuern, wenn ein neuer Text im Statusbar angezeigt werden soll.
104        /// </summary>
105        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
106
107        /// <summary>
108        /// Feuern, wenn sich sich eine Änderung des Fortschrittsbalkens ergibt
109        /// </summary>
110        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
111
112        public UserControl Presentation
113        {
114            get { return null; }
115        }
116
117        public UserControl QuickWatchPresentation
118        {
119          get { return null; }
120        }
121
122        public void Initialize() { }
123
124        public void Dispose() 
125        {         
126          if (inputStream != null)
127          {
128              inputStream.Flush();
129              inputStream.Close();
130              inputStream = null;
131          }
132          foreach (CryptoolStream cryptoolStream in listCryptoolStreams)
133          {
134            cryptoolStream.Close();
135          }
136          listCryptoolStreams.Clear();
137        }
138
139
140        public void Stop() { }
141
142        public bool HasChanges
143        {
144            get { return settings.HasChanges; }
145            set { settings.HasChanges = value;  }
146        }
147
148        public void PostExecution()
149        {
150            Dispose();
151        }
152
153        public void PreExecution()
154        {
155            outputString = null;
156        }
157
158        #endregion
159
160        #region INotifyPropertyChanged Members
161
162        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
163
164        public void OnPropertyChanged(string name)
165        {
166            if (PropertyChanged != null)
167            {
168                PropertyChanged(this, new PropertyChangedEventArgs(name));
169            }
170        }
171
172        #endregion
173
174        #region Private variables
175        private List<CryptoolStream> listCryptoolStreams = new List<CryptoolStream>();
176        private StreamToStringConverterSettings settings;
177        private CryptoolStream inputStream = null;
178        private string outputString;       
179        #endregion
180
181        #region Private methods
182
183        private void processInput(CryptoolStream value)
184        {
185            ShowStatusBarMessage("Got stream input.", NotificationLevel.Debug);       
186       
187            if (value != null)
188            {               
189                ShowProgress(50, 100);
190                ShowStatusBarMessage("Converting input ...", NotificationLevel.Debug);
191                if (value.Length > settings.MaxLength)
192                  ShowStatusBarMessage("WARNING - Input stream is too large (" + (value.Length / 1024).ToString("0.00") + " kB), output will be truncated to " + (settings.MaxLength / 1024).ToString("0.00") + "kB", NotificationLevel.Warning);
193
194                byte[] byteValues = new byte[settings.MaxLength];
195                int bytesRead;
196                value.Seek(0, SeekOrigin.Begin);
197                bytesRead = value.Read(byteValues, 0, byteValues.Length);
198               
199                // here conversion happens
200                switch (settings.Encoding)
201                {
202                    case StreamToStringConverterSettings.EncodingTypes.Default:
203                        outputString = Encoding.Default.GetString(byteValues, 0, bytesRead);
204                        break;
205                    case StreamToStringConverterSettings.EncodingTypes.Base64Binary:
206                        outputString = Convert.ToBase64String(byteValues, 0, bytesRead);
207                        break;
208                    case StreamToStringConverterSettings.EncodingTypes.HexStringBinary:
209                        outputString = convertBytesToHexString(byteValues, 0, bytesRead);
210                        break;
211                    case StreamToStringConverterSettings.EncodingTypes.OctalStringBinary:
212                        outputString = convertBytesToOctalString(byteValues, 0, bytesRead);
213                        break;
214                    case StreamToStringConverterSettings.EncodingTypes.Unicode:
215                        outputString = Encoding.Unicode.GetString(byteValues, 0, bytesRead);
216                        break;
217                    case StreamToStringConverterSettings.EncodingTypes.UTF7:
218                        outputString = Encoding.UTF7.GetString(byteValues, 0, bytesRead);
219                        break;
220                    case StreamToStringConverterSettings.EncodingTypes.UTF8:
221                        outputString = Encoding.UTF8.GetString(byteValues, 0, bytesRead);
222                        break;
223                    case StreamToStringConverterSettings.EncodingTypes.UTF32:
224                        outputString = Encoding.UTF32.GetString(byteValues, 0, bytesRead);
225                        break;
226                    case StreamToStringConverterSettings.EncodingTypes.ASCII:
227                        outputString = Encoding.ASCII.GetString(byteValues, 0, bytesRead);
228                        break;
229                    case StreamToStringConverterSettings.EncodingTypes.BigEndianUnicode:
230                        outputString = Encoding.BigEndianUnicode.GetString(byteValues, 0, bytesRead);
231                        break;
232                    default:
233                        outputString = Encoding.Default.GetString(byteValues, 0, bytesRead);
234                        break;
235                }
236
237                ShowStatusBarMessage("Input converted.", NotificationLevel.Debug);
238                ShowProgress(100, 100);
239                OnPropertyChanged("InputStream");
240                OnPropertyChanged("OutputString");
241            }
242            else
243            {
244                inputStream = null;
245                ShowStatusBarMessage("Stream input is null. Nothing to convert.", NotificationLevel.Warning);
246            }       
247        }
248
249        private string convertBytesToHexString(byte[] array, int start, int count)
250        {
251            StringBuilder sb = new StringBuilder();
252            for (int i = start; i < (start+count); i++)
253            {
254               sb.Append(array[i].ToString("X2"));
255               sb.Append(" ");
256            }
257            return sb.ToString();
258        }
259
260        private string convertBytesToOctalString(byte[] array, int start, int count)
261        {
262            StringBuilder sb = new StringBuilder();
263            for (int i = start; i < (start + count); i++)
264            {
265                string val = String.Format("{0,3}",Convert.ToString(array[i], 8));
266                sb.Append(val.Replace(' ','0'));
267                sb.Append(" ");
268            }
269            return sb.ToString();
270        }
271
272        private void ShowStatusBarMessage(string message, NotificationLevel logLevel)
273        {
274          EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(message, this, logLevel));
275        }
276
277        private void ShowProgress(double value, double max)
278        {
279          EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
280        }
281
282        #endregion
283
284        #region IPlugin Members
285
286        public event StatusChangedEventHandler OnPluginStatusChanged;
287
288        public void Execute()
289        {
290          processInput(InputStream);
291        }
292
293        public void Pause()
294        {
295         
296        }
297
298        #endregion
299    }
300}
Note: See TracBrowser for help on using the repository browser.