source: trunk/CrypPlugins/Transposition/Transposition.cs @ 846

Last change on this file since 846 was 846, checked in by kohnen, 12 years ago

Transposition now works on Byte-Arrays instead of Strings

File size: 32.5 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using System.ComponentModel;
6
7using Cryptool;
8using Cryptool.PluginBase.IO;
9using Cryptool.PluginBase;
10using Cryptool.PluginBase.Cryptography;
11using Cryptool.PluginBase.Miscellaneous;
12
13namespace Transposition
14{
15    [Author("Daniel Kohnen, Julian Weyers, Simon Malischewski, Armin Wiefels", "kohnen@cryptool.org, weyers@cryptool.org, malischewski@cryptool.org, wiefels@cryptool.org", "Universität Duisburg-Essen", "http://www.uni-due.de")]
16    [PluginInfo(false, "Transposition", "Transposition cipher", "Transposition/Description/TranspositionDescript.xaml", "Transposition/Images/icon.png", "Transposition/Images/encrypt.png", "Transposition/Images/decrypt.png")]
17    [EncryptionType(EncryptionType.Classic)]
18    public class Transposition : IEncryption
19    {
20        # region Private variables
21
22        private String keyword = "";
23        private byte[] input;
24        private byte[] output;
25        private TranspositionSettings settings;
26        private TranspositionPresentation myPresentation;
27
28        private byte[,] read_in_matrix;
29        private byte[,] permuted_matrix;
30        private int[] key;
31        # endregion       
32
33        /// <summary>
34        /// Constructor
35        /// </summary>
36        public Transposition()
37        {
38            this.settings = new TranspositionSettings();
39            myPresentation = new TranspositionPresentation();
40            Presentation = myPresentation;
41        }
42
43        /// <summary>
44        /// Get or set all settings for this algorithm.
45        /// </summary>
46        public ISettings Settings
47        {
48            get { return this.settings; }
49            set { this.settings = (TranspositionSettings)value; }
50        }
51
52        # region getter methods
53
54        /// <summary>
55        /// Get read in matrix.
56        /// </summary>
57        public byte[,] Read_in_matrix
58        {
59            get
60            {
61                return read_in_matrix;
62            }
63        }
64
65        /// <summary>
66        /// Get permuted matrix.
67        /// </summary>
68        public byte[,] Permuted_matrix
69        {
70            get
71            {
72                return permuted_matrix;
73            }
74        }
75
76        /// <summary>
77        /// Get numerical key order.
78        /// </summary>
79        public int[] Key
80        {
81            get
82            {
83                return key;
84            }
85        }
86        # endregion
87
88        # region Properties
89
90        [PropertyInfo(Direction.InputData, "Input", "input", "Text to be encrypted.", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
91        public Byte[] Input
92        {
93            get
94            {
95                return this.input;
96            }
97
98            set
99            {
100                this.input = value;
101                OnPropertyChange("Input");
102            }
103        }
104
105        [PropertyInfo(Direction.InputData, "Keyword", "keyword", "Keyword used for encryption", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
106        public string Keyword
107        {
108            get
109            {
110                return this.keyword;
111            }
112
113            set
114            {
115                this.keyword = value;
116                OnPropertyChange("Keyword");
117            }
118        }
119
120        [PropertyInfo(Direction.OutputData, "Output", "output", "", DisplayLevel.Beginner)]
121        public byte[] Output
122        {
123            get
124            {
125                return this.output;
126            }
127            set
128            {
129                this.output = value;
130                OnPropertyChange("Output");
131            }
132        }
133
134        private void OnPropertyChange(String propertyname)
135        {
136            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(propertyname));
137        }
138
139        private void ProgressChanged(double value, double max)
140        {
141            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
142        }
143
144        # endregion
145
146        #region IPlugin Member
147
148        public void Dispose()
149        {
150
151        }
152
153        public void Execute()
154        {
155            ProcessTransposition();
156            //myPresentation.main(Read_in_matrix,Permuted_matrix,key,Keyword,Input,Output,this.settings.Permutation,this.settings.ReadIn,this.settings.ReadOut);
157           
158        }
159
160        public void Initialize()
161        {
162
163        }
164
165        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
166
167        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
168
169        public event StatusChangedEventHandler OnPluginStatusChanged;
170
171        public void Pause()
172        {
173           
174        }
175
176        public void PostExecution()
177        {
178
179        }
180
181        public void PreExecution()
182        {
183
184        }
185
186        public System.Windows.Controls.UserControl Presentation
187        {
188            get;
189            private set; 
190        }
191
192        public System.Windows.Controls.UserControl QuickWatchPresentation
193        {
194            get { return Presentation; }
195        }
196
197        public void Stop()
198        {
199            myPresentation.my_Stop(this, EventArgs.Empty);
200        }
201
202        #endregion
203
204        #region INotifyPropertyChanged Member
205
206        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
207
208        #endregion
209
210        # region Private Methods
211
212        private void ProcessTransposition()
213        {
214            try
215            {
216                if (keyword.Contains(','))
217                {
218                    key = get_Keyword_Array(keyword);
219                }
220
221                else
222                {
223                    key = sortKey(keyword);
224                }
225
226                switch (settings.Action)
227                {
228                    case 0:
229                        Output = encrypt(input, key);
230                        break;
231                    case 1:
232                        Output = decrypt(input, key);
233                        break;
234                    default:
235                        break;
236                }
237                ProgressChanged(1, 1);
238            }
239
240            catch (Exception)
241            {
242                Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
243                Output = null;
244            }
245        }
246
247        private byte[] encrypt(byte[] input, int[] key)
248        {
249            if (key != null && input != null && key.Length > 0)
250            {
251                if (is_Valid_Keyword(key))
252                {
253                    byte[] encrypted = null;
254
255                    if (((TranspositionSettings.PermutationMode)settings.Permutation).Equals(TranspositionSettings.PermutationMode.byRow))
256                    {
257                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
258                        {
259                            case TranspositionSettings.ReadInMode.byRow:
260                                read_in_matrix = enc_read_in_by_row_if_row_perm(input, key.Length); break;
261                            case TranspositionSettings.ReadInMode.byColumn:
262                                read_in_matrix = enc_read_in_by_column_if_row_perm(input, key.Length); break;
263                            default:
264                                break;
265                        }
266
267                        permuted_matrix = enc_permute_by_row(read_in_matrix, key);
268
269                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
270                        {
271                            case TranspositionSettings.ReadOutMode.byRow:
272                                encrypted = read_out_by_row_if_row_perm(permuted_matrix, key.Length); break;
273                            case TranspositionSettings.ReadOutMode.byColumn:
274                                encrypted = read_out_by_column_if_row_perm(permuted_matrix, key.Length); break;
275                            default:
276                                break;
277                        }
278                    }
279
280                    // permute by column:
281                    else
282                    {
283                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
284                        {
285                            case TranspositionSettings.ReadInMode.byRow:
286                                read_in_matrix = enc_read_in_by_row(input, key.Length); break;
287                            case TranspositionSettings.ReadInMode.byColumn:
288                                read_in_matrix = enc_read_in_by_column(input, key.Length); break;
289                            default:
290                                break;
291                        }
292
293                        permuted_matrix = enc_permut_by_column(read_in_matrix, key);
294
295                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
296                        {
297                            case TranspositionSettings.ReadOutMode.byRow:
298                                encrypted = read_out_by_row(permuted_matrix, key.Length); break;
299                            case TranspositionSettings.ReadOutMode.byColumn:
300                                encrypted = read_out_by_column(permuted_matrix, key.Length); break;
301                            default:
302                                break;
303                        }
304                    }
305                    return encrypted;
306                }
307                else
308                {
309                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
310                    return null;
311                }
312            }
313            else
314            {
315                // 2do: Anzeige "Kein gültiges Keyword
316                return null;
317            }
318        }
319
320        private byte[] decrypt(byte[] input, int[] key)
321        {
322            if (key != null && input != null && key.Length > 0)
323            {
324                if (is_Valid_Keyword(key))
325                {
326                    byte[] decrypted= null ;
327                    if (((TranspositionSettings.PermutationMode)settings.Permutation).Equals(TranspositionSettings.PermutationMode.byRow))
328                    {
329                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
330                        {
331                            case TranspositionSettings.ReadOutMode.byRow:
332                                read_in_matrix = dec_read_in_by_row_if_row_perm(input, key); break;
333                            case TranspositionSettings.ReadOutMode.byColumn:
334                                read_in_matrix = dec_read_in_by_column_if_row_perm(input, key); break;
335                            default:
336                                break;
337                        }
338
339                        permuted_matrix = dec_permut_by_row(read_in_matrix, key);
340
341                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
342                        {
343                            case TranspositionSettings.ReadInMode.byRow:
344                                decrypted = read_out_by_row_if_row_perm(permuted_matrix, key.Length); break;
345                            case TranspositionSettings.ReadInMode.byColumn:
346                                decrypted = read_out_by_column_if_row_perm(permuted_matrix, key.Length); break;
347                            default:
348                                break;
349                        }
350                    }
351
352                    // permute by column:
353                    else
354                    {
355                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
356                        {
357                            case TranspositionSettings.ReadOutMode.byRow:
358                                read_in_matrix = dec_read_in_by_row(input, key); break;
359                            case TranspositionSettings.ReadOutMode.byColumn:
360                                read_in_matrix = dec_read_in_by_column(input, key); break;
361                            default:
362                                break;
363                        }
364
365                        permuted_matrix = dec_permut_by_column(read_in_matrix, key);
366
367                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
368                        {
369                            case TranspositionSettings.ReadInMode.byRow:
370                                decrypted = read_out_by_row(permuted_matrix, key.Length); break;
371                            case TranspositionSettings.ReadInMode.byColumn:
372                                decrypted = read_out_by_column(permuted_matrix, key.Length); break;
373                            default:
374                                break;
375                        }
376                    }
377                    return decrypted;
378                }
379                else
380                {
381                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
382                    return null;
383                }
384            }
385            else
386            {
387                // 2do: Anzeige "Kein gültiges Keyword
388                return null;
389            }
390        }
391
392        private byte[,] enc_read_in_by_row(byte[] input, int keyword_length)
393        {
394            int size = input.Length / keyword_length;
395
396            if (input.Length % keyword_length != 0)
397            {
398                size++;
399            }
400
401            int pos = 0;
402            byte[,] matrix = new byte[keyword_length, size];
403
404            for (int i = 0; i < size; i++)
405            {
406                for (int j = 0; j < keyword_length; j++)
407                {
408                    if (pos < input.Length)
409                    {
410                        matrix[j, i] = input[pos];
411                        pos++;
412                    }
413                }
414            }
415            return matrix;
416        }
417
418        private byte[,] enc_read_in_by_column(byte[] input, int keyword_length)
419        {
420            int size = input.Length / keyword_length;
421            int offs = input.Length % keyword_length;
422            if (offs != 0)
423            {
424                size++;
425            }
426
427            int pos = 0;
428
429            byte[,] matrix = new byte[keyword_length, size];
430            for (int i = 0; i < keyword_length; i++)
431            {
432                for (int j = 0; j < size; j++)
433                {
434                    if (pos < input.Length)
435                    {
436                        if (offs > 0 && j == size - 1 && i >= offs) { }
437                        else
438                        {
439                            matrix[i, j] = input[pos];
440                            pos++;
441                        }
442                    }
443                }
444            }
445            return matrix;
446        }
447
448        private byte[,] enc_read_in_by_row_if_row_perm(byte[] input, int keyword_length)
449        {
450            int height = keyword_length;
451            int length = input.Length / keyword_length;
452            int offs = input.Length % keyword_length;
453            if (offs != 0)
454            {
455                length++;
456            }
457
458            byte[,] matrix = new byte[length, height];
459            int pos = 0;
460
461            for (int i = 0; i < height; i++)
462            {
463                for (int j = 0; j < length; j++)
464                {
465                    if (pos < input.Length)
466                    {
467                        if (j.Equals(length - 1) && offs != 0)
468                        {
469                            if (i < offs)
470                            {
471                                matrix[j, i] = input[pos];
472                                pos++;
473                            }
474                        }
475
476                        else
477                        {
478                            matrix[j, i] = input[pos];
479                            pos++;
480                        }
481                    }
482                }
483            }
484            return matrix;
485        }
486
487        private byte[,] enc_read_in_by_column_if_row_perm(byte[] input, int keyword_length)
488        {
489            int height = keyword_length;
490            int length = input.Length / keyword_length;
491            int offs = input.Length % keyword_length;
492            if (offs != 0)
493            {
494                length++;
495            }
496
497            byte[,] matrix = new byte[length, height];
498            int pos = 0;
499
500            for (int i = 0; i < length; i++)
501            {
502                for (int j = 0; j < height; j++)
503                {
504                    if (pos < input.Length)
505                    {
506                        matrix[i, j] = input[pos];
507                        pos++;
508                    }
509                }
510            }
511            return matrix;
512        }
513
514        private byte[,] dec_read_in_by_column(byte[] input, int[] keyword)
515        {
516            int size = input.Length / keyword.Length;
517            int offs = input.Length % keyword.Length;
518            if (offs != 0)
519            {
520                size++;
521            }
522
523            byte[,] matrix = new byte[keyword.Length, size];
524            int pos = 0;
525
526            for (int i = 0; i < keyword.Length; i++)
527            {
528                for (int j = 0; j < size; j++)
529                {
530                    if (pos < input.Length)
531                    {
532                        if ((!offs.Equals(0)) && j.Equals(size - 1))
533                        {
534                            bool ok = false;
535
536                            for (int k = 0; k < offs; k++)
537                            {
538                                if ((keyword[k] - 1).Equals(i))
539                                {
540                                    ok = true;
541                                }
542                            }
543
544                            if (ok)
545                            {
546                                matrix[i, j] = input[pos];
547                                pos++;
548                            }
549
550                        }
551                        else
552                        {
553                            matrix[i, j] = input[pos];
554                            pos++;
555                        }
556                    }
557                }
558            }
559            return matrix;
560        }
561
562        private byte[,] dec_read_in_by_column_if_row_perm(byte[] input, int[] keyword)
563        {
564            int size = input.Length / keyword.Length;
565            int offs = input.Length % keyword.Length;
566            if (offs != 0)
567            {
568                size++;
569            }
570
571            byte[,] matrix = new byte[size, keyword.Length];
572            int pos = 0;
573
574            for (int i = 0; i < size; i++)
575            {
576                for (int j = 0; j < keyword.Length; j++)
577                {
578                    if (pos < input.Length)
579                    {
580                        if ((!offs.Equals(0)) && i.Equals(size - 1))
581                        {
582                            bool ok = false;
583
584                            for (int k = 0; k < offs; k++)
585                            {
586                                if ((keyword[k] - 1).Equals(j))
587                                {
588                                    ok = true;
589                                }
590                            }
591
592                            if (ok)
593                            {
594                                matrix[i, j] = input[pos];
595                                pos++;
596                            }
597
598                        }
599                        else
600                        {
601                            matrix[i, j] = input[pos];
602                            pos++;
603                        }
604                    }
605                }
606            }
607            return matrix;
608        }
609
610        private byte[,] dec_read_in_by_row(byte[] input, int[] keyword)
611        {
612            int size = input.Length / keyword.Length;
613            int offs = input.Length % keyword.Length;
614            if (offs != 0)
615            {
616                size++;
617            }
618
619            byte[,] matrix = new byte[keyword.Length, size];
620            int pos = 0;
621
622            for (int i = 0; i < size; i++)
623            {
624                for (int j = 0; j < keyword.Length; j++)
625                {
626                    if (pos < input.Length)
627                    {
628                        if ((!offs.Equals(0)) && i.Equals(size - 1))
629                        {
630                            bool ok = false;
631
632                            for (int k = 0; k < offs; k++)
633                            {
634                                if ((keyword[k] - 1).Equals(j))
635                                {
636                                    ok = true;
637                                }
638                            }
639
640                            if (ok)
641                            {
642                                matrix[j, i] = input[pos];
643                                pos++;
644                            }
645
646                        }
647                        else
648                        {
649                            matrix[j, i] = input[pos];
650                            pos++;
651                        }
652                    }
653                }
654            }
655            return matrix;
656        }
657
658        private byte[,] dec_read_in_by_row_if_row_perm(byte[] input, int[] keyword)
659        {
660            int size = input.Length / keyword.Length;
661            int offs = input.Length % keyword.Length;
662            if (offs != 0)
663            {
664                size++;
665            }
666
667            byte[,] matrix = new byte[size, keyword.Length];
668            int pos = 0;
669
670            for (int i = 0; i < keyword.Length; i++)
671            {
672                for (int j = 0; j < size; j++)
673                {
674                    if (pos < input.Length)
675                    {
676                        if ((!offs.Equals(0)) && j.Equals(size - 1))
677                        {
678                            bool ok = false;
679
680                            for (int k = 0; k < offs; k++)
681                            {
682                                if ((keyword[k] - 1).Equals(i))
683                                {
684                                    ok = true;
685                                }
686                            }
687
688                            if (ok)
689                            {
690                                matrix[j, i] = input[pos];
691                                pos++;
692                            }
693
694                        }
695                        else
696                        {
697                            matrix[j, i] = input[pos];
698                            pos++;
699                        }
700                    }
701                }
702            }
703            return matrix;
704        }
705
706        private byte[,] enc_permut_by_column(byte[,] readin_matrix, int[] keyword)
707        {
708            int x = keyword.Length;
709            int y = readin_matrix.Length / keyword.Length;
710            byte[,] matrix = new byte[x, y];
711            int pos = 0;
712
713            for (int i = 1; i <= keyword.Length; i++)
714            {
715                for (int j = 0; j < keyword.Length; j++)
716                {
717                    if (i.Equals(keyword[j]))
718                    {
719                        pos = j;
720                    }
721                }
722
723                for (int j = 0; j < y; j++)
724                {
725                    matrix[i - 1, j] = readin_matrix[pos, j];
726                }
727            }
728            return matrix;
729        }
730
731        private byte[,] enc_permute_by_row(byte[,] readin_matrix, int[] keyword)
732        {
733            int y = keyword.Length;
734            int x = readin_matrix.Length / keyword.Length;
735            byte[,] matrix = new byte[x, y];
736            int pos = 0;
737
738            for (int i = 1; i <= y; i++)
739            {
740                for (int j = 0; j < keyword.Length; j++)
741                {
742                    if (keyword[j].Equals(i))
743                    {
744                        pos = j;
745                    }
746                }
747
748                for (int j = 0; j < x; j++)
749                {
750                    matrix[j, i - 1] = readin_matrix[j, pos];
751                }
752            }
753            return matrix;
754        }
755
756        private byte[,] dec_permut_by_column(byte[,] readin_matrix, int[] keyword)
757        {
758            int x = keyword.Length;
759            int y = readin_matrix.Length / keyword.Length;
760            byte[,] matrix = new byte[x, y];
761
762            for (int i = 0; i < x; i++)
763            {
764                for (int j = 0; j < y; j++)
765                {
766                    matrix[i, j] = readin_matrix[keyword[i] - 1, j];
767                }
768            }
769            return matrix;
770        }
771
772        private byte[,] dec_permut_by_row(byte[,] readin_matrix, int[] keyword)
773        {
774            int x = keyword.Length;
775            int y = readin_matrix.Length / keyword.Length;
776            byte[,] matrix = new byte[y, x];
777
778            for (int i = 0; i < x; i++)
779            {
780                for (int j = 0; j < y; j++)
781                {
782                    matrix[j, i] = readin_matrix[j, keyword[i] - 1];
783                }
784            }
785            return matrix;
786        }
787
788        private byte[] read_out_by_row(byte[,] matrix, int keyword_length)
789        {
790            int x = keyword_length;
791            int y = matrix.Length / keyword_length;
792            byte empty_byte = new byte();
793            int count_empty = 0;
794                       
795            for(int i=0; i<y; i++)
796            {
797                for(int j=0; j<x; j++)
798                {
799                    byte tmp = matrix[j, i];
800                    if (tmp.Equals(empty_byte))
801                    {
802                        count_empty++;
803                    }
804                }
805            }
806            byte[] enc = new byte[matrix.Length-count_empty];
807
808            int pos = 0;
809            for (int i = 0; i < y; i++)
810            {
811                for (int j = 0; j < x; j++)
812                {
813                    byte tmp = matrix[j, i];
814                    if (!tmp.Equals(empty_byte))
815                    {
816                        enc[pos] = tmp;
817                        pos++;
818                    }
819                }
820            }
821            return enc;
822        }
823
824        private byte[] read_out_by_row_if_row_perm(byte[,] matrix, int keyword_length)
825        {
826            int y = keyword_length;
827            int x = matrix.Length / keyword_length;
828           
829            byte empty_byte = new byte();
830            int empty_count = 0;
831            for (int i = 0; i < y; i++)
832            {
833                for (int j = 0; j < x; j++)
834                {
835                    byte tmp = matrix[j, i];
836                    if (tmp.Equals(empty_byte))
837                    {
838                        empty_count++;
839                    }
840                }
841            }
842
843            byte[] enc = new byte[matrix.Length - empty_count];
844            int pos = 0;
845
846            for (int i = 0; i < y; i++)
847            {
848                for (int j = 0; j < x; j++)
849                {
850                    byte tmp = matrix[j, i];
851                    if (!tmp.Equals(empty_byte))
852                    {
853                        enc[pos] = tmp;
854                        pos++;
855                    }
856                }
857            }
858            return enc;
859        }
860
861        private byte[] read_out_by_column(byte[,] matrix, int keyword_length)
862        {
863            int x = keyword_length;
864            int y = matrix.Length / keyword_length;
865           
866            byte empty_byte = new byte();
867            int empty_count = 0;
868
869            for (int i = 0; i < x; i++)
870            {
871                for (int j = 0; j < y; j++)
872                {
873                    byte tmp = matrix[i, j];
874                    if (tmp.Equals(empty_byte))
875                    {
876                        empty_count++;
877                    }
878                }
879            }
880
881            byte[] enc = new byte[matrix.Length - empty_count];
882            int pos =0;
883            for (int i = 0; i < x; i++)
884            {
885                for (int j = 0; j < y; j++)
886                {
887                    byte tmp = matrix[i, j];
888                    if (!tmp.Equals(empty_byte) || tmp.Equals(null))
889                    {
890                        enc[pos] = tmp;
891                        pos++; 
892                    }
893                }
894            }
895            return enc;
896        }
897
898        private byte[] read_out_by_column_if_row_perm(byte[,] matrix, int keyword_length)
899        {
900            int y = keyword_length;
901            int x = matrix.Length / keyword_length;
902           
903            byte empty_byte = new byte();
904            int empty_count = 0;
905            for (int i = 0; i < x; i++)
906            {
907                for (int j = 0; j < y; j++)
908                {
909                    byte tmp = matrix[i, j];
910                    if (tmp.Equals(empty_byte))
911                    {
912                        empty_count++;
913                    }
914                }
915            }
916
917            byte[] enc = new byte[matrix.Length - empty_count];
918            int pos = 0;
919            for (int i = 0; i < x; i++)
920            {
921                for (int j = 0; j < y; j++)
922                {
923                    byte tmp = matrix[i, j];
924                    if (!tmp.Equals(empty_byte))
925                    {
926                        enc[pos] = tmp;
927                        pos++;
928                    }
929                }
930            }
931            return enc;
932        }
933
934        private int[] get_Keyword_Array(String keyword)
935        {
936            try
937            {
938                int length = 1;
939                char komma = ',';
940
941                for (int i = 0; i < keyword.Length; i++)
942                {
943                    if (keyword[i].Equals(komma))
944                    {
945                        length++;
946                    }
947                }
948
949                int[] keys = new int[length];
950                String tmp = "";
951                int pos = 0;
952                for (int i = 0; i < keyword.Length; i++)
953                {
954                    if (i.Equals(keyword.Length - 1))
955                    {
956                        tmp += keyword[i];
957                        keys[pos] = Convert.ToInt32(tmp);
958                    }
959
960                    else
961                    {
962                        if (keyword[i].Equals(komma))
963                        {
964                            keys[pos] = Convert.ToInt32(tmp);
965                            tmp = "";
966                            pos++;
967                        }
968                        else
969                        {
970                            tmp += keyword[i];
971                        }
972                    }
973                }
974                return keys;
975            }
976            catch (FormatException)
977            {
978                return null;
979            }
980        }
981
982        private bool is_Valid_Keyword(int[] keyword)
983        {
984            for (int i = 1; i <= keyword.Length; i++)
985            {
986                bool exists = false;
987
988                for (int j = 0; j < keyword.Length; j++)
989                {
990                    if (i.Equals(keyword[j]))
991                    {
992                        exists = true;
993                    }
994                }
995
996                if (!exists)
997                {
998                    return false;
999                }
1000            }
1001            return true;
1002        }
1003
1004        public int[] sortKey(String input)
1005        {
1006            if (input != null && !input.Equals(""))
1007            {
1008                String key = input;
1009                Char[] keyChars = key.ToCharArray();
1010                Char[] orgChars = key.ToCharArray();
1011                int[] rank = new int[keyChars.Length];
1012                Array.Sort(keyChars);
1013
1014                for (int i = 0; i < orgChars.Length; i++)
1015                {
1016                    rank[i] = (Array.IndexOf(keyChars, orgChars[i])) + 1;
1017                    keyChars[Array.IndexOf(keyChars, orgChars[i])] = (char)0;
1018                }
1019                return rank;
1020            }
1021            return null;
1022        }
1023
1024        private void Transposition_LogMessage(string msg, NotificationLevel loglevel)
1025        {
1026            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(msg, this, loglevel));
1027        }
1028
1029        # endregion
1030    }
1031}
Note: See TracBrowser for help on using the repository browser.