Changeset 952


Ignore:
Timestamp:
Dec 4, 2009, 11:06:27 PM (12 years ago)
Author:
Sven Rech
Message:

some big keypattern changes that are needed for christians work.

Location:
trunk/CrypPlugins/KeySearcher
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/KeySearcher/KeyPattern.cs

    r950 r952  
    4141                isSplit = false;
    4242                counter = 0;
    43                 length = 0;
    44                 int i = 1;
    45                 while (valuePattern[i] != ']')
    46                 {
    47                     if (valuePattern[i + 1] == '-')
    48                     {
    49                         for (char c = valuePattern[i]; c <= valuePattern[i + 2]; c++)
    50                             values[length++] = c;
    51                         i += 2;
    52                     }
    53                     else
    54                         values[length++] = valuePattern[i];
    55                     i++;
     43                if (valuePattern.Length == 1)
     44                {                   
     45                    length = 1;
     46                    values[0] = valuePattern[0];
     47                }
     48                else
     49                {                   
     50                    length = 0;
     51                    int i = 1;
     52                    while (valuePattern[i] != ']')
     53                    {
     54                        if (valuePattern[i + 1] == '-')
     55                        {
     56                            for (char c = valuePattern[i]; c <= valuePattern[i + 2]; c++)
     57                                values[length++] = c;
     58                            i += 2;
     59                        }
     60                        else
     61                            values[length++] = valuePattern[i];
     62                        i++;
     63                    }
    5664                }
    5765            }
     
    7280            public Wildcard[] split()
    7381            {
    74                 int length = this.length - this.counter;
     82                if (length <= 1)
     83                    return null;
     84                int length1 = this.length - this.counter;
    7585                Wildcard[] wcs = new Wildcard[2];
    7686                wcs[0] = new Wildcard();
    7787                wcs[0].counter = 0;
    78                 wcs[0].length = length / 2;
     88                wcs[0].length = length1 / 2;
    7989                wcs[1] = new Wildcard();
    8090                wcs[1].counter = 0;
    81                 wcs[1].length = length - wcs[0].length;
     91                wcs[1].length = length1 - wcs[0].length;
    8292                for (int i = 0; i < wcs[0].length; i++)
    8393                    wcs[0].values[i] = values[this.counter + i];
     
    125135                counter = 0;
    126136            }
     137
     138            public string getRepresentationString()
     139            {
     140                if (length == 1)
     141                    return "" + values[0];
     142                string res = "[";
     143                int begin = 0;
     144                for (int i = 1; i < length; i++)
     145                {
     146                    if (values[i - 1] != values[i] - 1)
     147                    {
     148                        if (begin == i - 1)
     149                            res += values[begin];
     150                        else
     151                        {
     152                            if (i - 1 - begin == 1)
     153                                res += values[begin] + values[i - 1];
     154                            else
     155                                res += values[begin] + "-" + values[i - 1];
     156                        }
     157                        begin = i;
     158                    }
     159                }
     160                if (begin == length - 1)
     161                    res += values[begin];
     162                else
     163                {
     164                    if (length - 1 - begin == 1)
     165                        res += values[begin] + "" + values[length - 1];
     166                    else
     167                        res += values[begin] + "-" + values[length - 1];
     168                }
     169
     170                res += "]";
     171                return res;
     172            }
     173
     174            public bool contains(Wildcard wc)
     175            {
     176                if (wc == null)
     177                    return false;
     178                for (int i = 0; i < wc.length; i++)
     179                {
     180                    bool contains = false;
     181                    for (int j = 0; j < this.length; j++)
     182                    {
     183                        if (this.values[j] == wc.values[i])
     184                        {
     185                            contains = true;
     186                            break;
     187                        }
     188                    }
     189                    if (!contains)
     190                        return false;
     191                }
     192                return true;
     193            }
    127194        }
    128195
    129196        private string pattern;
    130         private string key;
    131197        private ArrayList wildcardList;
    132198
     
    141207            for (int i = 0; i < 2; i++)
    142208            {
    143                 patterns[i] = new KeyPattern(pattern);
    144                 patterns[i].key = key;
     209                patterns[i] = new KeyPattern(pattern);               
    145210                patterns[i].wildcardList = new ArrayList();
    146211            }
     
    153218                    Wildcard[] wcs = wc.split();
    154219                    patterns[0].wildcardList.Add(wcs[0]);
    155                     patterns[1].wildcardList.Add(wcs[1]);
     220                    patterns[1].wildcardList.Add(wcs[1]);                   
    156221                    s = true;
    157222                }
     
    170235        }
    171236
    172         public string giveWildcardKey()
     237        public string giveInputPattern()
    173238        {
    174239            string res = "";
     
    189254        }
    190255
    191         public bool testKey(string key)
     256        public bool testWildcardKey(string wildcardKey)
    192257        {
    193258            int kcount = 0;
    194259            int pcount = 0;
    195             while (kcount < key.Length && pcount < pattern.Length)
     260            while (kcount < wildcardKey.Length && pcount < pattern.Length)
    196261            {
    197262                if (pattern[pcount] != '[')
    198263                {
    199                     if (key[kcount] != '*' && pattern[pcount] != key[kcount])
     264                    if (pattern[pcount] != wildcardKey[kcount])
    200265                        return false;
    201266                    kcount++;
     
    203268                }
    204269                else
    205                 {
    206                     bool contains = false;
    207                     pcount++;
    208                     while (pattern[pcount] != ']')
    209                     {
    210                         if (key[kcount] != '*')
    211                         {
    212                             if (pattern[pcount + 1] == '-')
    213                             {
    214                                 if (key[kcount] >= pattern[pcount] && key[kcount] <= pattern[pcount + 2])
    215                                     contains = true;
    216                                 pcount += 2;
    217                             }
    218                             else
    219                                 if (pattern[pcount] == key[kcount])
    220                                     contains = true;
    221                         }
    222                         pcount++;
    223                     }
    224                     if (!contains && !(key[kcount] == '*'))
     270                {                   
     271                    Wildcard wc1 = new Wildcard(pattern.Substring(pcount, pattern.IndexOf(']', pcount) + 1 - pcount));
     272                    while (pattern[pcount++] != ']') ;
     273                    Wildcard wc2 = null;
     274                    if (wildcardKey[kcount] == '[')
     275                    {
     276                        wc2 = new Wildcard(wildcardKey.Substring(kcount, wildcardKey.IndexOf(']', kcount) + 1 - kcount));
     277                        while (wildcardKey[++kcount] != ']') ;
     278                    }
     279                    else if (wildcardKey[kcount] != '*')
     280                        wc2 = new Wildcard("" + wildcardKey[kcount]);
     281
     282                    if (!wc1.contains(wc2) && !(wildcardKey[kcount] == '*'))
    225283                        return false;
    226284                    kcount++;
    227                     pcount++;
    228                 }
    229             }
    230             if (pcount != pattern.Length || kcount != key.Length)
     285                }
     286            }
     287            if (pcount != pattern.Length || kcount != wildcardKey.Length)
    231288                return false;
    232289            return true;
    233290        }
    234291
    235         public BigInteger initKeyIteration(string key)
    236         {
    237             BigInteger counter = 1;
    238             this.key = key;
     292        public BigInteger setWildcardKey(string wildcardKey)
     293        {
     294            BigInteger counter = 1;           
    239295            int pcount = 0;
    240296            wildcardList = new ArrayList();
    241             for (int i = 0; i < key.Length; i++)
    242             {
    243                 if (key[i] == '*')
    244                 {
    245                     Wildcard wc = new Wildcard(pattern.Substring(pcount, pattern.IndexOf(']', pcount) + 1 - pcount));
    246                     wildcardList.Add(wc);
    247                     counter *= wc.size();
    248                 }
    249 
     297            for (int i = 0; i < wildcardKey.Length; i++)
     298            {
    250299                if (pattern[pcount] == '[')
    251                     while (pattern[pcount] != ']')
    252                         pcount++;
     300                {
     301                    if (wildcardKey[i] == '*')
     302                    {
     303                        Wildcard wc = new Wildcard(pattern.Substring(pcount, pattern.IndexOf(']', pcount) + 1 - pcount));
     304                        wildcardList.Add(wc);
     305                        counter *= wc.size();
     306                    }
     307                    else
     308                    {
     309                        Wildcard wc = new Wildcard("" + wildcardKey[i]);
     310                        wildcardList.Add(wc);
     311                    }
     312                    while (pattern[++pcount] != ']') ;
     313                }
    253314                pcount++;
    254315            }
    255316            return counter;
     317        }
     318
     319        public string getWildcardKey()
     320        {
     321            string res = "";
     322            int pcount = 0;
     323            int wccount = 0;
     324            while (pcount < pattern.Length)
     325            {
     326                if (pattern[pcount] != '[')
     327                    res += pattern[pcount];
     328                else
     329                {
     330                    res += ((Wildcard)wildcardList[wccount++]).getRepresentationString();
     331                    while (pattern[++pcount] != ']') ;
     332                }
     333                pcount++;
     334            }
     335            return res;
    256336        }
    257337
     
    285365            else
    286366                wildcardCount = nextWildcard;
    287             bool overflow = ((Wildcard)wildcardList[wildcardCount]).succ();
    288             wildcardCount--;
     367            bool overflow = ((Wildcard)wildcardList[wildcardCount--]).succ();           
    289368            while (overflow && (wildcardCount >= 0))
    290369                overflow = ((Wildcard)wildcardList[wildcardCount--]).succ();
     
    296375            string res = "";
    297376            int wildcardCount = 0;
    298             for (int i = 0; i < key.Length; i++)
    299             {
    300                 if (key[i] != '*')
    301                     res += key[i];
     377            int i = 0;
     378            while (i < pattern.Length)           
     379            {
     380                if (pattern[i] != '[')
     381                    res += pattern[i++];
    302382                else
    303383                {
    304384                    Wildcard wc = (Wildcard)wildcardList[wildcardCount++];
    305385                    res += wc.getChar();
    306                 }
     386                    while (pattern[i++] != ']') ;
     387                }               
    307388            }
    308389            return res;
     
    314395            int div = 1;
    315396            int wildcardCount = wildcardList.Count - 1;
    316             for (int i = key.Length - 1; i >= 0; i--)
    317             {
    318                 if (key[i] != '*')
    319                     res += key[i];
     397            int i = pattern.Length - 1;
     398            while (i >= 0)           
     399            {
     400                if (pattern[i] != ']')
     401                    res += pattern[i--];
    320402                else
    321403                {
     
    328410                        div *= wc.size();
    329411                    }
     412                    while (pattern[i--] != '[') ;
    330413                }
    331414            }
     
    358441            string res = "";
    359442            int wildcardCount = 0;
    360             for (int i = 0; i < key.Length; i++)
    361             {
    362                 if (key[i] != '*')
    363                     res += key[i];
     443            int i = 0;
     444            while (i < pattern.Length)
     445            {
     446                if (pattern[i] != '[')
     447                    res += pattern[i++];
    364448                else
    365449                {
     
    371455                        res += wc.getChar();
    372456                    }
     457                    while (pattern[i++] != ']') ;
    373458                }
    374459            }
     
    383468        public List<KeyPattern> makeKeySearcherPool(BigInteger partsize)
    384469        {
     470            BigInteger sizeS = size();
    385471            if (size() > partsize)
    386472            {
     
    388474                KeyPattern[] patterns = split();
    389475                p1 = patterns[0].makeKeySearcherPool(partsize);
     476                BigInteger size1 = patterns[0].size();
    390477                p2 = patterns[1].makeKeySearcherPool(partsize);
     478                BigInteger size2 = patterns[1].size();
    391479                p1.AddRange(p2);
    392480                return p1;
     
    418506        public override string ToString()
    419507        {
    420             return "Type: KeySearcher.KeyPattern. Key: '" + this.key + "', Pattern: '" + this.pattern + "'";
     508            return "Type: KeySearcher.KeyPattern. WildcardKey: '" + this.getWildcardKey() + "', Pattern: '" + this.pattern + "'";
    421509        }
    422510
     
    465553        {
    466554            object objReturn = null;
    467             if (this.key != null && this.pattern != null)
     555            string wildcardKey = this.getWildcardKey();
     556            if (wildcardKey != null && this.pattern != null)
    468557            {
    469558                // TODO: implement testPattern-method
    470559                //if (testPattern(pattern) && testKey(key))
    471                 if (testKey(key))
     560                if (testWildcardKey(wildcardKey))
    472561                {
    473562                    if (returnByte)
    474                         objReturn = encoder.GetBytes(key + kpSeperator + pattern);
     563                        objReturn = encoder.GetBytes(wildcardKey + kpSeperator + pattern);
    475564                    else
    476                         objReturn = key + kpSeperator + pattern;
    477                 }
    478                 else
    479                 {
    480                     throw (new Exception("Serializing KeyPattern canceled, because Key and/or Pattern aren't valid. "
    481                         + "Key: '" + key + "', Pattern: '" + pattern + "'.\n"));
     565                        objReturn = wildcardKey + kpSeperator + pattern;
     566                }
     567                else
     568                {
     569                    throw (new Exception("Serializing KeyPattern canceled, because WildcardKey and/or Pattern aren't valid. "
     570                        + "WildcardKey: '" + wildcardKey + "', Pattern: '" + pattern + "'.\n"));
    482571                }
    483572            }
    484573            else
    485574            {
    486                 throw (new Exception("Serializing KeyPattern canceled, because Key and/or Pattern are NULL. Key: '" + key + "'. Pattern: '" + pattern + "'."));
     575                throw (new Exception("Serializing KeyPattern canceled, because Key and/or Pattern are NULL. WildcardKey: '" + wildcardKey + "'. Pattern: '" + pattern + "'."));
    487576            }
    488577            return objReturn;
     
    502591                throw (new Exception("Deserializing KeyPattern canceled, because parameter neither a byte array nor a string!"));
    503592
    504             // disaggregate string representatiojn
    505             string key_temp = sTemp.Substring(0, sTemp.IndexOf(kpSeperator));
     593            // disaggregate string representation
     594            string wildcardKey_temp = sTemp.Substring(0, sTemp.IndexOf(kpSeperator));
    506595            int beginOfPattern = sTemp.IndexOf(kpSeperator) + kpSeperator.Length;
    507596            string pattern_temp = sTemp.Substring(beginOfPattern, sTemp.Length - beginOfPattern);
    508597
    509             // test extracted pattern and key!
     598            // test extracted pattern and wildcardKey!
    510599            // TODO: implement testPattern-method
    511             //if (testPattern(pattern_temp) && testKey(key_temp))
    512             if (testKey(key_temp))
     600            //if (testPattern(pattern_temp) && testKey(wildcardKey_temp))
     601            if (testWildcardKey(wildcardKey_temp))
    513602            {
    514603                // TODO: use Pattern-property in future
    515604                keyPatternToReturn = new KeyPattern(pattern_temp);
    516                 // TODO: use Key-property in future
    517                 keyPatternToReturn.initKeyIteration(key_temp);
     605                // TODO: use WildcardKey-property in future
     606                keyPatternToReturn.setWildcardKey(wildcardKey_temp);
    518607                return keyPatternToReturn;
    519608            }
    520609            else
    521610            {
    522                 throw (new Exception("Deserializing KeyPattern canceled, because Key or Pattern aren't valid. "
    523                     + "Key: '" + key_temp + "', Pattern: '" + pattern_temp + "'.\n"));
     611                throw (new Exception("Deserializing KeyPattern canceled, because WildcardKey or Pattern aren't valid. "
     612                    + "WildcardKey: '" + wildcardKey_temp + "', Pattern: '" + pattern_temp + "'.\n"));
    524613            }
    525614        }
  • trunk/CrypPlugins/KeySearcher/KeySearcher.cs

    r951 r952  
    1212using System.Windows.Threading;
    1313using Cryptool.PluginBase.Miscellaneous;
     14using System.IO;
    1415
    1516namespace KeySearcher
     
    4142            {
    4243                pattern = value;
    43                 if ((settings.Key == null) || ((settings.Key != null) && !pattern.testKey(settings.Key)))
    44                     settings.Key = pattern.giveWildcardKey();
     44                if ((settings.Key == null) || ((settings.Key != null) && !pattern.testWildcardKey(settings.Key)))
     45                    settings.Key = pattern.giveInputPattern();
    4546            }
    4647        }
     
    403404
    404405            stop = false;
    405             if (!pattern.testKey(settings.Key))
     406            if (!pattern.testWildcardKey(settings.Key))
    406407            {
    407408                GuiLogMessage("Wrong key pattern!", NotificationLevel.Error);
     
    421422            }
    422423
    423             BigInteger size = pattern.initKeyIteration(settings.Key);
     424            BigInteger size = pattern.setWildcardKey(settings.Key);           
    424425            KeyPattern[] patterns = splitPatternForThreads(pattern);
    425426
  • trunk/CrypPlugins/KeySearcher/KeySearcherSettings.cs

    r754 r952  
    3535                key = value;
    3636                OnPropertyChanged("Key");
    37                 if (!(keysearcher.Pattern != null && keysearcher.Pattern.testKey(value)))
     37                if (!(keysearcher.Pattern != null && keysearcher.Pattern.testWildcardKey(value)))
    3838                    keysearcher.GuiLogMessage("Wrong key pattern!", NotificationLevel.Error);
    3939            }
     
    4343        public void Reset()
    4444        {
    45             Key = keysearcher.Pattern.giveWildcardKey();
     45            Key = keysearcher.Pattern.giveInputPattern();
    4646        }
    4747       
Note: See TracChangeset for help on using the changeset viewer.