source: trunk/CrypPlugins/KeyPatternJob/KeyPatternJobResult.cs @ 1448

Last change on this file since 1448 was 1448, checked in by Sven Rech, 11 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: 8.1 KB
RevLine 
[1137]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 Cryptool.PluginBase.Miscellaneous;
21using System.IO;
[1448]22using System.Numerics;
[1137]23
24namespace Cryptool.Plugins.PeerToPeer.Jobs
25{
26    public class KeyPatternJobResult : JobResult<LinkedList<KeySearcher.KeySearcher.ValueKey>>
27    {
28        private Encoding enc = Encoding.UTF8;
29
30        public KeyPatternJobResult(byte[] serializedKeyPatternJobResult) : base(serializedKeyPatternJobResult)
31        { }
32
33        public KeyPatternJobResult(BigInteger jobId, LinkedList<KeySearcher.KeySearcher.ValueKey> resultList, 
34            TimeSpan processingTime) 
35            : this(jobId, resultList, processingTime, false) { }
36
37        public KeyPatternJobResult(BigInteger jobId, LinkedList<KeySearcher.KeySearcher.ValueKey> resultList, 
38            TimeSpan processingTime, bool isIntermediateResult)
39            : base(jobId,resultList,processingTime, isIntermediateResult)
40        {
41            this.ResultList = resultList;
42        }
43
44        #region access methods on result elements
45
46        LinkedList<KeySearcher.KeySearcher.ValueKey> resultList;
47        public LinkedList<KeySearcher.KeySearcher.ValueKey> ResultList
48        {
49            get { return this.resultList; }
50            set { this.resultList = value; }
51        }
52
53        public KeySearcher.KeySearcher.ValueKey GetElement(int position)
54        {
55            if (this.ResultList != null)
56            {
57                return this.resultList.ElementAt<KeySearcher.KeySearcher.ValueKey>(position);
58            }
59            throw (new Exception("ResultList is empty or the choosen position doesn't exists in this context"));
60        }
61        public KeySearcher.KeySearcher.ValueKey GetFirstElement()
62        {
63            if (this.ResultList != null)
64            {
65                return this.resultList.First.Value;
66            }
67            throw (new Exception("ResultList is empty or the first position doesn't exists in this context"));
68        }
69
70
71        #endregion
72
73        #region Serialization methods -
74
75        /* serialization information: 3 fields per data set in the following order:
76         *  -------------------------------------------------------------------------------------------------------------------------------
77         * | Dataset count | double-value (8 byte) | string len (1 byte) | string-data (n bytes) | byte len (1 byte) | byte-data (n bytes) |
78         *  ------------------------------------------------------------------------------------------------------------------------------- */
79        protected override byte[] SerializeResultType()
80        {
81            MemoryStream memStream = new MemoryStream();
82            byte[] resultCountByte = BitConverter.GetBytes(resultList.Count);
83            memStream.Write(resultCountByte, 0, resultCountByte.Length);
84
85            foreach (KeySearcher.KeySearcher.ValueKey  valKey in resultList)
86            {
87                // serialize value (double)
88                byte[] valueByte = BitConverter.GetBytes(valKey.value);
89                byte[] valueByteLen = BitConverter.GetBytes(valueByte.Length);
90                memStream.Write(valueByteLen, 0, valueByteLen.Length);
91                memStream.Write(valueByte, 0, valueByte.Length);
92
93                // serialize key (string)
94                byte[] keyByte = enc.GetBytes(valKey.key);
95                byte[] keyByteLen = BitConverter.GetBytes(keyByte.Length);
96                memStream.Write(keyByteLen, 0, keyByteLen.Length);
97                memStream.Write(keyByte, 0, keyByte.Length);
98
99                byte[] decryptionByteLen;
100                // serialize decryption (byte[]) - not more than 256 byte
101                if (valKey.decryption.Length >= 255)
102                {
103                    decryptionByteLen = BitConverter.GetBytes(255);
104                    memStream.Write(decryptionByteLen, 0, decryptionByteLen.Length);
105                    memStream.Write(valKey.decryption, 0, 254);
106                }
107                else if (valKey.decryption.Length > 0 && valKey.decryption.Length < 255)
108                {
109                    decryptionByteLen = BitConverter.GetBytes(valKey.decryption.Length);
110                    memStream.Write(decryptionByteLen, 0, decryptionByteLen.Length);
111                    memStream.Write(valKey.decryption, 0, valKey.decryption.Length);
112                }
113                else // if no decryption result exists
114                {
115                    decryptionByteLen = BitConverter.GetBytes((int)0);
116                    memStream.Write(decryptionByteLen, 0, decryptionByteLen.Length);
117                }
118            } // end foreach
119
120            return memStream.ToArray();
121        }
122
123        protected override LinkedList<KeySearcher.KeySearcher.ValueKey> DeserializeResultType(byte[] serializedResultType)
124        {
125            LinkedList<KeySearcher.KeySearcher.ValueKey> lstRet = new LinkedList<KeySearcher.KeySearcher.ValueKey>();
126            MemoryStream memStream = new MemoryStream(serializedResultType);
127
128            // byte[] length of Int32
129            int iInt32 = 4;
130
131            int valueLen = 0;
132            int keyLen = 0;
133            int decryptionLen = 0;
134
135            byte[] byteDatasetCount = new byte[iInt32];
136            memStream.Read(byteDatasetCount, 0, byteDatasetCount.Length);
137            int iDatasetCount = BitConverter.ToInt32(byteDatasetCount, 0);
138
139            KeySearcher.KeySearcher.ValueKey valKey = new KeySearcher.KeySearcher.ValueKey();
140            for (int i = 0; i < iDatasetCount; i++)
141            {
142                // deserialize value (double)
143                byte[] valueByteLen = new byte[iInt32];
144                memStream.Read(valueByteLen, 0, valueByteLen.Length);
145                valueLen = BitConverter.ToInt32(valueByteLen, 0);
146                byte[] valueByte = new byte[valueLen];
147                memStream.Read(valueByte, 0, valueByte.Length);
148               
149                valKey.value = BitConverter.ToDouble(valueByte, 0);
150
151                // deserialize key (string)
152                byte[] keyByteLen = new byte[iInt32];
153                memStream.Read(keyByteLen, 0, keyByteLen.Length);
154                keyLen = BitConverter.ToInt32(keyByteLen, 0);
155                byte[] keyByte = new byte[keyLen];
156                memStream.Read(keyByte, 0, keyByte.Length);
157
158                valKey.key = enc.GetString(keyByte, 0, keyByte.Length);
159
160                // deserialize decryption (byte[])
161                byte[] decryptByteLen = new byte[iInt32];
162                memStream.Read(decryptByteLen, 0, decryptByteLen.Length);
163                decryptionLen = BitConverter.ToInt32(decryptByteLen, 0);
164                byte[] decryptionByte = new byte[decryptionLen];
165                memStream.Read(decryptionByte, 0, decryptionByte.Length);
166
167                valKey.decryption = decryptionByte;
168
169                // add new, deserialize ValueKey to LinkedList
170                lstRet.AddLast(valKey);
171            }
172            if ((memStream.Length - memStream.Position) > 0)
173            {
174                throw(new Exception("The serializedResultType wasn't deserialized correctly, because " 
175                    + "after deserializing there are already some bytes (remaining Length of byte[]: " 
176                    + memStream.Length + ")"));
177            }
178            this.ResultList = lstRet;
179
180            return lstRet;
181        }
182
183        #endregion
184    }
185}
Note: See TracBrowser for help on using the repository browser.