source: trunk/CrypPlugins/PeerToPeerJobs/JobResult.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: 12.8 KB
Line 
1/* Copyright 2010 Team CrypTool (Christian Arnold), Uni Duisburg-Essen
2
3   Licensed under the Apache License, Version 2.0 (the "License");
4   you may not use this file except in compliance with the License.
5   You may obtain a copy of the License at
6
7       http://www.apache.org/licenses/LICENSE-2.0
8
9   Unless required by applicable law or agreed to in writing, software
10   distributed under the License is distributed on an "AS IS" BASIS,
11   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12   See the License for the specific language governing permissions and
13   limitations under the License.
14*/
15
16using System;
17using System.Collections.Generic;
18using System.Linq;
19using System.Text;
20using System.IO;
21using System.Reflection;
22using Cryptool.PluginBase.Miscellaneous;
23using System.Numerics;
24
25namespace Cryptool.Plugins.PeerToPeer.Jobs
26{
27    public abstract class JobResult<JobResultType> : IJobResult<JobResultType>
28    {
29        #region Variables
30
31        private BigInteger jobId;
32        public BigInteger JobId
33        {
34            get {  return this.jobId; }
35            set { this.jobId = value; }
36        }
37        private bool isIntermediateJobResult = false;
38        public bool IsIntermediateResult
39        {
40            get { return this.isIntermediateJobResult;}
41            set { this.isIntermediateJobResult = value; }
42        }
43        private TimeSpan processingTime;
44        public TimeSpan ProcessingTime
45        {
46            get { return this.processingTime;}
47            set { this.processingTime = value; } 
48        }
49        private JobResultType result;
50        public JobResultType Result
51        { 
52            get{return this.result;}
53            set { this.result = value; }
54        }
55
56        #endregion
57
58        /// <summary>
59        /// Creates a new JobResult (this is an endresul!)
60        /// </summary>
61        /// <param name="jobId">jobId for which you have a result</param>
62        /// <param name="result">result of the job (e.g. simple conclusion, list, complex data structure)</param>
63        /// <param name="processingTime">Timespan between begin and end of processing the job</param>
64        public JobResult(BigInteger jobId, JobResultType result, TimeSpan processingTime)
65            :this(jobId,result,processingTime,false)
66        { } 
67
68        /// <summary>
69        /// Creates a new JobResult (you can choose if this is only an intermediate result or the endresult)
70        /// </summary>
71        /// <param name="jobId">jobId for which you have a result</param>
72        /// <param name="result">result of the job (e.g. simple conclusion, list, complex data structure)</param>
73        /// <param name="processingTime">Timespan between begin and end of processing the job</param>
74        /// <param name="isIntermediateResult">Is this is only an intermediate result, set this parameter to true, otherwise choose false</param>
75        public JobResult(BigInteger jobId, JobResultType result, TimeSpan processingTime, bool isIntermediateResult)
76        {
77            this.JobId = jobId;
78            this.Result = result;
79            this.ProcessingTime = processingTime;
80            this.IsIntermediateResult = isIntermediateResult;
81        }
82
83        // TODO: Test this constructor, if it works fine, delete Deserialize Method
84        /// <summary>
85        /// If you have a serialized JobResult class, you can deserialize it by using this constructor!
86        /// </summary>
87        /// <param name="serializedJobResult">serialized JobResult class as a byte[]</param>
88        public JobResult(byte[] serializedJobResult)
89        {
90            BigInteger temp_jobId;
91            JobResultType temp_result;
92            bool temp_isIntermediateResult;
93            TimeSpan temp_processingTime;
94
95            MemoryStream memStream = new MemoryStream(serializedJobResult, false);
96            try
97            {
98                Int32 testValue = 3000;
99                byte[] readInt = BitConverter.GetBytes(testValue);
100
101                /* Deserialize JobId */
102                memStream.Read(readInt, 0, readInt.Length);
103                int jobIdLen = BitConverter.ToInt32(readInt, 0);
104                byte[] jobIdByte = new byte[jobIdLen];
105                memStream.Read(jobIdByte, 0, jobIdByte.Length);
106                temp_jobId = new BigInteger(jobIdByte);
107
108                /* Deserialize Job result data */
109                //memStream.Read(readInt, 0, readInt.Length);
110                //int serializedDataLen = BitConverter.ToInt32(readInt, 0);
111                //byte[] serializedJobResultByte = new byte[serializedDataLen];
112                //memStream.Read(serializedJobResultByte, 0, serializedJobResultByte.Length);
113                //temp_result = (JobResultType)GetDeserializationViaReflection(serializedJobResultByte, this.Result);
114
115                // right for bool???
116                temp_isIntermediateResult = Convert.ToBoolean(memStream.ReadByte());
117
118                memStream.Read(readInt, 0, readInt.Length);
119                int days = BitConverter.ToInt32(readInt, 0);
120                memStream.Read(readInt, 0, readInt.Length);
121                int hours = BitConverter.ToInt32(readInt, 0);
122                memStream.Read(readInt, 0, readInt.Length);
123                int minutes = BitConverter.ToInt32(readInt, 0);
124                memStream.Read(readInt, 0, readInt.Length);
125                int seconds = BitConverter.ToInt32(readInt, 0);
126                memStream.Read(readInt, 0, readInt.Length);
127                int millisec = BitConverter.ToInt32(readInt, 0);
128                temp_processingTime = new TimeSpan(days, hours, minutes, seconds, millisec);
129
130                // read the rest of the byte[]-stream, this is the specialized JobResulType
131                byte[] serializedJobResultByte = new byte[memStream.Length - memStream.Position];
132                memStream.Read(serializedJobResultByte, 0, serializedJobResultByte.Length);
133                temp_result = DeserializeResultType(serializedJobResultByte);
134
135                this.JobId = temp_jobId;
136                this.IsIntermediateResult = temp_isIntermediateResult;
137                this.ProcessingTime = temp_processingTime;
138                this.Result = temp_result;
139            }
140            catch (Exception ex)
141            {
142                throw ex;
143            }
144            finally
145            {
146                memStream.Flush();
147                memStream.Close();
148                memStream.Dispose();
149            }
150        }
151
152        #region comparing methods
153
154        public override bool Equals(object obj)
155        {
156            if(obj == null)
157                return false;
158
159            if (ReferenceEquals(this, obj))
160                return true;
161
162            if (this.GetType() != obj.GetType())
163                return false;
164
165            return this == (JobResult<JobResultType>)obj;
166        }
167
168        public static bool operator ==(JobResult<JobResultType> left, JobResult<JobResultType> right)
169        {
170            if ((object)left == (object)right)
171                return true;
172
173            if ((object)left == null || (object)right == null)
174                return false;
175
176            if (left.jobId == right.JobId)
177                return true;
178
179            return false;
180        }
181
182        public static bool operator !=(JobResult<JobResultType> left, JobResult<JobResultType> right)
183        {
184            return !(left == right);
185        }
186
187        public override int GetHashCode()
188        {
189            return this.JobId.GetHashCode();
190        }
191
192        #endregion
193
194        #region Serialization methods
195
196        protected abstract byte[] SerializeResultType();
197
198        protected abstract JobResultType DeserializeResultType(byte[] serializedResultType);
199
200        /* 4 Bytes: serialized JobId
201         * 4 Bytes: serialized Job Result length
202         * y Bytes: serialized Job Result data
203         * 4 Bytes: isIntermedResult
204         * 4 Bytes: procTime.Days
205         * 4 Bytes: procTime.Hours
206         * 4 Bytes: procTime.Minutes
207         * 4 Bytes: procTime.Seconds
208         * 4 Bytes: procTime.Milliseconds */
209        /// <summary>
210        /// Serializes the whole class, so you can recreate this instance elsewhere by dint of this byte[].
211        /// HINT: You can Deserialize a byte[] representation of this class by using the constructor with
212        /// the byte[] parameter!
213        /// </summary>
214        /// <returns>serialized class as an byte[]</returns>
215        public byte[] Serialize()
216        {
217            byte[] ret = null;
218            MemoryStream memStream = new MemoryStream();
219            try
220            {
221                /* Serialize jobId */
222                byte[] jobIdByte = this.JobId.ToByteArray();
223                byte[] jobIdLen = BitConverter.GetBytes(jobIdByte.Length);
224                memStream.Write(jobIdLen, 0, jobIdLen.Length);
225                memStream.Write(jobIdByte, 0, jobIdByte.Length);
226
227                /* Serialize job result via Reflection */
228                //byte[] serializedJobResult = GetSerializationViaReflection(this.Result);
229                //byte[] byJobResultLen = BitConverter.GetBytes(serializedJobResult.Length);
230                //memStream.Write(byJobResultLen, 0, byJobResultLen.Length);
231                //memStream.Write(serializedJobResult, 0, serializedJobResult.Length);
232
233                byte[] intResultBytes = BitConverter.GetBytes(this.isIntermediateJobResult);
234                memStream.Write(intResultBytes,0,intResultBytes.Length);
235                /* Storing processingTimeSpan */
236                byte[] daysBytes = BitConverter.GetBytes(this.processingTime.Days);
237                memStream.Write(daysBytes,0,daysBytes.Length);
238                byte[] hoursBytes = (BitConverter.GetBytes(this.processingTime.Hours));
239                memStream.Write(hoursBytes,0,hoursBytes.Length);
240                byte[] minutesBytes = BitConverter.GetBytes(this.processingTime.Minutes);
241                memStream.Write(minutesBytes,0,minutesBytes.Length);
242                byte[] secondsBytes = BitConverter.GetBytes(this.processingTime.Seconds);
243                memStream.Write(secondsBytes,0,secondsBytes.Length);
244                byte[] msecondsBytes = BitConverter.GetBytes(this.processingTime.Milliseconds);
245                memStream.Write(msecondsBytes,0,msecondsBytes.Length);
246
247
248                byte[] serializedJobResult = SerializeResultType();
249                memStream.Write(serializedJobResult, 0, serializedJobResult.Length);
250
251
252                ret = memStream.ToArray();
253            }
254            catch (Exception ex)
255            {
256                throw ex;
257            }
258            finally
259            {
260                memStream.Flush();
261                memStream.Close();
262                memStream.Dispose();
263            }
264            return ret;
265        }
266
267        #endregion
268
269        //#region Reflection methods
270
271        //private byte[] GetSerializationViaReflection(object objectToSerialize)
272        //{
273        //    byte[] serializedBytes = null;
274        //    try
275        //    {
276        //        MethodInfo methInfo = objectToSerialize.GetType().GetMethod("Serialize");
277        //        ParameterInfo[] paramInfo = methInfo.GetParameters();
278        //        ParameterInfo returnParam = methInfo.ReturnParameter;
279        //        Type returnType = methInfo.ReturnType;
280
281        //        serializedBytes = methInfo.Invoke(objectToSerialize, null) as byte[];
282        //        if (serializedBytes == null)
283        //            throw (new Exception("Serializing " + objectToSerialize.GetType().ToString() + " canceled!"));
284        //    }
285        //    catch (Exception ex)
286        //    {
287        //        throw (new Exception("Invocing method 'Serialize' of '"
288        //            + objectToSerialize.GetType().ToString() + "' wasn't possible. " + ex.ToString()));
289        //    }
290        //    return serializedBytes;
291        //}
292
293        //private object GetDeserializationViaReflection(object serializedData, object returnType)
294        //{
295        //    try
296        //    {
297        //        MethodInfo methInfo = returnType.GetType().GetMethod("Deserialize", new[] { serializedData.GetType() });
298        //        object deserializedData = methInfo.Invoke(returnType, new object[] { serializedData });
299        //        if (deserializedData == null)
300        //            throw (new Exception("Deserializing " + returnType.ToString() + " canceled!"));
301        //        return deserializedData;
302        //    }
303        //    catch (Exception ex)
304        //    {
305        //        throw (new Exception("Invocing method 'Deserialize' of '"
306        //            + returnType.ToString() + "' wasn't possible. " + ex.ToString()));
307        //    }
308        //}
309
310        //#endregion
311    }
312}
Note: See TracBrowser for help on using the repository browser.