source: trunk/CrypPlugins/PeerToPeerJobs/JobResult.cs @ 1130

Last change on this file since 1130 was 1130, checked in by arnold, 12 years ago

Added references to some P2PProjects, so the global SLN compiles correctly again

File size: 9.5 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using System.IO;
6using System.Reflection;
7
8namespace Cryptool.Plugins.PeerToPeer.Jobs
9{
10    public class JobResult<JobResultType> : IJobResult<JobResultType>
11    {
12        #region Variables
13
14        private int jobId;
15        public int JobId
16        {
17            get {  return this.jobId; }
18            set { this.jobId = value; }
19        }
20        private bool isIntermediateJobResult;
21        public bool IsIntermediateResult
22        {
23            get { return this.isIntermediateJobResult;}
24            set { this.isIntermediateJobResult = value; }
25        }
26        private TimeSpan processingTime;
27        public TimeSpan ProcessingTime
28        {
29            get { return this.processingTime;}
30            set { this.processingTime = value; } 
31        }
32        private JobResultType result;
33        public JobResultType Result
34        { 
35            get{return this.result;}
36            set { this.result = value; }
37        }
38
39        #endregion
40
41        /// <summary>
42        /// Creates a new JobResult (this is an endresul!)
43        /// </summary>
44        /// <param name="jobId">jobId for which you have a result</param>
45        /// <param name="result">result of the job (e.g. simple conclusion, list, complex data structure)</param>
46        /// <param name="processingTime">Timespan between begin and end of processing the job</param>
47        public JobResult(int jobId, JobResultType result, TimeSpan processingTime)
48            :this(jobId,result,processingTime,false)
49        { } 
50
51        /// <summary>
52        /// Creates a new JobResult (you can choose if this is only an intermediate result or the endresult)
53        /// </summary>
54        /// <param name="jobId">jobId for which you have a result</param>
55        /// <param name="result">result of the job (e.g. simple conclusion, list, complex data structure)</param>
56        /// <param name="processingTime">Timespan between begin and end of processing the job</param>
57        /// <param name="isIntermediateResult">Is this is only an intermediate result, set this parameter to true, otherwise choose false</param>
58        public JobResult(int jobId, JobResultType result, TimeSpan processingTime, bool isIntermediateResult)
59        {
60            this.JobId = jobId;
61            this.Result = result;
62            this.ProcessingTime = processingTime;
63            this.IsIntermediateResult = isIntermediateResult;
64        }
65
66        #region Serialization methods
67
68        /* 4 Bytes: serialized JobId
69         * 4 Bytes: serialized Job Result length
70         * y Bytes: serialized Job Result data
71         * 4 Bytes: isIntermedResult
72         * 4 Bytes: procTime.Days
73         * 4 Bytes: procTime.Hours
74         * 4 Bytes: procTime.Minutes
75         * 4 Bytes: procTime.Seconds
76         * 4 Bytes: procTime.Milliseconds */
77        /// <summary>
78        /// Serializes the whole class, so you can recreate this instance elsewhere by dint of this byte[]
79        /// </summary>
80        /// <returns>serialized class as an byte[]</returns>
81        public byte[] Serialize()
82        {
83            byte[] ret = null;
84            MemoryStream memStream = new MemoryStream();
85            try
86            {
87                /* Serialize jobId */
88                byte[] intJobId = BitConverter.GetBytes(this.JobId);
89                memStream.Write(intJobId, 0, intJobId.Length);
90
91                /* Serialize job result via Reflection */
92                byte[] serializedJobResult = GetSerializationViaReflection(this.Result);
93                byte[] byJobResultLen = BitConverter.GetBytes(serializedJobResult.Length);
94                memStream.Write(byJobResultLen, 0, byJobResultLen.Length);
95                memStream.Write(serializedJobResult, 0, serializedJobResult.Length);
96
97                byte[] intResultBytes = BitConverter.GetBytes(this.isIntermediateJobResult);
98                memStream.Write(intResultBytes,0,intResultBytes.Length);
99                /* Storing processingTimeSpan */
100                byte[] daysBytes = BitConverter.GetBytes(this.processingTime.Days);
101                memStream.Write(daysBytes,0,daysBytes.Length);
102                byte[] hoursBytes = (BitConverter.GetBytes(this.processingTime.Hours));
103                memStream.Write(hoursBytes,0,hoursBytes.Length);
104                byte[] minutesBytes = BitConverter.GetBytes(this.processingTime.Minutes);
105                memStream.Write(minutesBytes,0,minutesBytes.Length);
106                byte[] secondsBytes = BitConverter.GetBytes(this.processingTime.Seconds);
107                memStream.Write(secondsBytes,0,secondsBytes.Length);
108                byte[] msecondsBytes = BitConverter.GetBytes(this.processingTime.Milliseconds);
109                memStream.Write(msecondsBytes,0,msecondsBytes.Length);
110                               
111                ret = memStream.ToArray();
112            }
113            catch (Exception ex)
114            {
115                throw ex;
116            }
117            finally
118            {
119                memStream.Flush();
120                memStream.Close();
121                memStream.Dispose();
122            }
123            return ret;
124        }
125
126        /// <summary>
127        /// ATTENTION: Not only deserializes the DistributableJobResult, but additionally recreates the whole class
128        /// by dint of the byte[]. So all this class information will be overwritten.
129        /// </summary>
130        /// <param name="serializedJobResult">a valid DistributableJobResult serialization</param>
131        public bool Deserialize(byte[] serializedJobResult)
132        {
133            bool ret = false;
134            MemoryStream memStream = new MemoryStream(serializedJobResult,false);
135            try
136            {
137                /* Deserialize JobId */
138                byte[] readInt = new byte[4];
139                memStream.Read(readInt, 0, readInt.Length);
140                this.JobId = BitConverter.ToInt32(readInt,0);
141
142                /* Deserialize Job result data */
143                memStream.Read(readInt,0,readInt.Length);
144                int serializedDataLen = BitConverter.ToInt32(readInt,0);
145                byte[] serializedJobResultByte = new byte[serializedDataLen];
146                memStream.Read(serializedJobResultByte, 0, serializedJobResultByte.Length);
147                this.Result = (JobResultType)GetDeserializationViaReflection(serializedJobResultByte, this.Result);
148
149                // right for bool???
150                memStream.Read(readInt, 0, readInt.Length);
151                this.isIntermediateJobResult = BitConverter.ToBoolean(readInt,0);
152
153                memStream.Read(readInt, 0, readInt.Length);
154                int days = BitConverter.ToInt32(readInt,0);
155                memStream.Read(readInt, 0, readInt.Length);
156                int hours = BitConverter.ToInt32(readInt, 0);
157                memStream.Read(readInt, 0, readInt.Length);
158                int minutes = BitConverter.ToInt32(readInt, 0);
159                memStream.Read(readInt, 0, readInt.Length);
160                int seconds = BitConverter.ToInt32(readInt, 0);
161                memStream.Read(readInt, 0, readInt.Length);
162                int millisec = BitConverter.ToInt32(readInt, 0);
163                this.processingTime = new TimeSpan(days, hours, minutes, seconds, millisec);
164
165                ret = true;
166            }
167            catch (Exception ex)
168            {
169                throw ex;
170            }
171            finally
172            {
173                memStream.Flush();
174                memStream.Close();
175                memStream.Dispose();
176            }
177            return ret;
178        }
179
180        #endregion
181
182        #region Reflection methods
183
184        private byte[] GetSerializationViaReflection(object objectToSerialize)
185        {
186            byte[] serializedBytes = null;
187            try
188            {
189                MethodInfo methInfo = objectToSerialize.GetType().GetMethod("Serialize");
190                ParameterInfo[] paramInfo = methInfo.GetParameters();
191                ParameterInfo returnParam = methInfo.ReturnParameter;
192                Type returnType = methInfo.ReturnType;
193
194                serializedBytes = methInfo.Invoke(objectToSerialize, null) as byte[];
195                if (serializedBytes == null)
196                    throw (new Exception("Serializing " + objectToSerialize.GetType().ToString() + " canceled!"));
197            }
198            catch (Exception ex)
199            {
200                throw (new Exception("Invocing method 'Serialize' of '"
201                    + objectToSerialize.GetType().ToString() + "' wasn't possible. " + ex.ToString()));
202            }
203            return serializedBytes;
204        }
205
206        private object GetDeserializationViaReflection(object serializedData, object returnType)
207        {
208            try
209            {
210                MethodInfo methInfo = returnType.GetType().GetMethod("Deserialize", new[] { serializedData.GetType() });
211                object deserializedData = methInfo.Invoke(returnType, new object[] { serializedData });
212                if (deserializedData == null)
213                    throw (new Exception("Deserializing " + returnType.ToString() + " canceled!"));
214                return deserializedData;
215            }
216            catch (Exception ex)
217            {
218                throw (new Exception("Invocing method 'Deserialize' of '"
219                    + returnType.ToString() + "' wasn't possible. " + ex.ToString()));
220            }
221        }
222
223        #endregion
224    }
225}
Note: See TracBrowser for help on using the repository browser.