Changeset 608


Ignore:
Timestamp:
Sep 29, 2009, 4:24:48 PM (12 years ago)
Author:
falk
Message:

Comparators : added IComparable support. changed DetailedDescription.

Location:
trunk/CrypPlugins/Comparators
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/Comparators/Comparators.cs

    r588 r608  
    2828{
    2929    [Author("Raoul Falk", "falk@cryptool.org", "Uni Duisburg-Essen", "http://www.uni-due.de")]
    30     [PluginInfo(false, "Comparators", "Simple comparators (=,!=, <, >, <=, >=). Strings and streams are compared via length while using one of the last four comparators.", "Comparators/DetailedDescription/Description.xaml", "Comparators/icons/icon_is.png", "Comparators/icons/icon_isnot.png", "Comparators/icons/icon_smaller.png", "Comparators/icons/icon_bigger.png", "Comparators/icons/icon_smallerIs.png", "Comparators/icons/icon_biggerIs.png")]
     30    [PluginInfo(false, "Comparators", "Simple comparators (=,!=, <, >, <=, >=). See detailed description.", "Comparators/DetailedDescription/Description.xaml", "Comparators/icons/icon_is.png", "Comparators/icons/icon_isnot.png", "Comparators/icons/icon_smaller.png", "Comparators/icons/icon_bigger.png", "Comparators/icons/icon_smallerIs.png", "Comparators/icons/icon_biggerIs.png")]
    3131
    3232    class Comparators : IThroughput
     
    3535
    3636        private ComparatorsSettings settings = new ComparatorsSettings();
    37         private object inputOne;
    38         private object inputTwo;
     37        private IComparable inputOne;
     38        private IComparable inputTwo;
    3939        private bool output;
    4040
     
    7171
    7272        [PropertyInfo(Direction.InputData, "Input one", "Input one.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    73         public object InputOne
     73        public IComparable InputOne
    7474        {
    7575            [MethodImpl(MethodImplOptions.Synchronized)]
     
    8787
    8888        [PropertyInfo(Direction.InputData, "Input two", "Input two.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    89         public object InputTwo
     89        public IComparable InputTwo
    9090        {
    9191            [MethodImpl(MethodImplOptions.Synchronized)]
     
    132132            if (InputOne != null && InputTwo != null)
    133133            {
    134                 switch (this.settings.Comparator)
    135                 {
    136                     // if operator is =
    137                     case 0:
    138                         {
    139                             Output = InputOne.Equals(InputTwo);
    140                             ProgressChanged(100, 100);
    141                             break;
    142                         }
    143                     // if operator is !=
    144                     case 1:
    145                         {
    146                             Output = !InputOne.Equals(InputTwo);
    147                             ProgressChanged(100, 100);
    148                             break;
    149                         }
    150                     //if operator is <
    151                     case 2:
    152                         {
    153                             if (InputOne is BigInteger&& InputTwo is BigInteger)
    154                             {
    155                                 Output = (BigInteger)InputOne < (BigInteger)InputTwo;
    156                                 ProgressChanged(100, 100);
    157                                 break;
    158                             }
    159                             if (InputOne is int && InputTwo is int)
    160                             {
    161                                 Output = (int)InputOne < (int)InputTwo;
    162                                 ProgressChanged(100, 100);
    163                                 break;
    164                             }
    165                             if (InputOne is CryptoolStream && InputTwo is CryptoolStream)
    166                             {
    167                                 CryptoolStream temp1 = (CryptoolStream)InputOne;
    168                                 CryptoolStream temp2 = (CryptoolStream)InputTwo;
    169                                 Output = temp1.Length < temp2.Length;
    170                                 ProgressChanged(100, 100);
    171                                 break;
    172                             }
    173 
    174                             if (InputOne is byte && InputTwo is byte)
    175                             {
    176                                 Output = (byte)InputOne < (byte)InputTwo;
    177                                 ProgressChanged(100, 100);
    178                                 break;
    179                             }
    180 
    181                             if (InputOne is double && InputTwo is double)
    182                             {
    183                                 Output = (double)InputOne < (double)InputTwo;
    184                                 ProgressChanged(100, 100);
    185                                 break;
    186                             }
    187 
    188                             if (InputOne is string && InputTwo is string)
    189                             {
    190                                 string in1 = (string)InputOne;
    191                                 string in2 = (string)InputTwo;
    192                                 Output = (in1.Length < in2.Length);
    193                                 ProgressChanged(100, 100);
    194                                 break;
    195                             }
    196 
    197                             Comparators_LogMessage("The comparator \"<\" is not defined for the current inputs. Output is set to false automatically.", NotificationLevel.Error);
    198                             Output = false;
    199 
    200                             break;
    201 
    202                         }
    203                     //if operator is >
    204                     case 3:
    205                         {
    206                             if (InputOne is BigInteger && InputTwo is BigInteger)
    207                             {
    208                                 Output = (BigInteger)InputOne > (BigInteger)InputTwo;
    209                                 ProgressChanged(100, 100);
    210                                 break;
    211                             }
    212                             if (InputOne is int && InputTwo is int)
    213                             {
    214                                 Output = (int)InputOne > (int)InputTwo;
    215                                 ProgressChanged(100, 100);
    216                                 break;
    217                             }
    218                             if (InputOne is CryptoolStream && InputTwo is CryptoolStream)
    219                             {
    220                                 CryptoolStream temp1 = (CryptoolStream)InputOne;
    221                                 CryptoolStream temp2 = (CryptoolStream)InputTwo;
    222                                 Output = temp1.Length > temp2.Length;
    223                                 ProgressChanged(100, 100);
    224                                 break;
    225                             }
    226 
    227                             if (InputOne is byte && InputTwo is byte)
    228                             {
    229                                 Output = (byte)InputOne > (byte)InputTwo;
    230                                 ProgressChanged(100, 100);
    231                                 break;
    232                             }
    233 
    234                             if (InputOne is double && InputTwo is double)
    235                             {
    236                                 Output = (double)InputOne > (double)InputTwo;
    237                                 ProgressChanged(100, 100);
    238                                 break;
    239                             }
    240 
    241                             if (InputOne is string && InputTwo is string)
    242                             {
    243                                 string in1 = (string)InputOne;
    244                                 string in2 = (string)InputTwo;
    245                                 Output = (in1.Length > in2.Length);
    246                                 ProgressChanged(100, 100);
    247                                 break;
    248                             }
    249 
    250                             Comparators_LogMessage("The comparator \">\" is not defined for the current inputs. Output is set to false automatically.", NotificationLevel.Error);
    251                             Output = false;
    252 
    253                             break;
    254 
    255                         }
    256                     //if operator is <=
    257                     case 4:
    258                         {
    259                             if (InputOne is BigInteger && InputTwo is BigInteger)
    260                             {
    261                                 Output = (BigInteger)InputOne <= (BigInteger)InputTwo;
    262                                 ProgressChanged(100, 100);
    263                                 break;
    264                             }
    265                             if (InputOne is int && InputTwo is int)
    266                             {
    267                                 Output = (int)InputOne <= (int)InputTwo;
    268                                 ProgressChanged(100, 100);
    269                                 break;
    270                             }
    271 
    272                             if (InputOne is CryptoolStream && InputTwo is CryptoolStream)
    273                             {
    274                                 CryptoolStream temp1 = (CryptoolStream)InputOne;
    275                                 CryptoolStream temp2 = (CryptoolStream)InputTwo;
    276                                 Output = temp1.Length <= temp2.Length;
    277                                 ProgressChanged(100, 100);
    278                                 break;
    279                             }
    280 
    281                             if (InputOne is byte && InputTwo is byte)
    282                             {
    283                                 Output = (byte)InputOne <= (byte)InputTwo;
    284                                 ProgressChanged(100, 100);
    285                                 break;
    286                             }
    287 
    288                             if (InputOne is double && InputTwo is double)
    289                             {
    290                                 Output = (double)InputOne <= (double)InputTwo;
    291                                 ProgressChanged(100, 100);
    292                                 break;
    293                             }
    294 
    295                             if (InputOne is string && InputTwo is string)
    296                             {
    297                                 string in1 = (string)InputOne;
    298                                 string in2 = (string)InputTwo;
    299                                 Output = (in1.Length <= in2.Length);
    300                                 ProgressChanged(100, 100);
    301                                 break;
    302                             }
    303 
    304                             Comparators_LogMessage("The comparator \"<=\" is not defined for the current inputs. Output is set to false automatically.", NotificationLevel.Error);
    305                             Output = false;
    306 
    307                             break;
    308 
    309                         }
    310                     //if operator is >=
    311                     case 5:
    312                         {
    313                             if (InputOne is BigInteger && InputTwo is BigInteger)
    314                             {
    315                                 Output = (BigInteger)InputOne >= (BigInteger)InputTwo;
    316                                 ProgressChanged(100, 100);
    317                                 break;
    318                             }
    319                             if (InputOne is int && InputTwo is int)
    320                             {
    321                                 Output = (int)InputOne >= (int)InputTwo;
    322                                 ProgressChanged(100, 100);
    323                                 break;
    324                             }
    325 
    326                             if (InputOne is CryptoolStream && InputTwo is CryptoolStream)
    327                             {
    328                                 CryptoolStream temp1 = (CryptoolStream)InputOne;
    329                                 CryptoolStream temp2 = (CryptoolStream)InputTwo;
    330                                 Output = temp1.Length >= temp2.Length;
    331                                 ProgressChanged(100, 100);
    332                                 break;
    333                             }
    334 
    335                             if (InputOne is byte && InputTwo is byte)
    336                             {
    337                                 Output = (byte)InputOne >= (byte)InputTwo;
    338                                 ProgressChanged(100, 100);
    339                                 break;
    340                             }
    341 
    342                             if (InputOne is double && InputTwo is double)
    343                             {
    344                                 Output = (double)InputOne >= (double)InputTwo;
    345                                 ProgressChanged(100, 100);
    346                                 break;
    347                             }
    348 
    349                             if (InputOne is string && InputTwo is string)
    350                             {
    351                                 string in1 = (string)InputOne;
    352                                 string in2 = (string)InputTwo;
    353                                 Output = (in1.Length >= in2.Length);
    354                                 ProgressChanged(100, 100);
    355                                 break;
    356                             }
    357 
    358                             Comparators_LogMessage("The comparator \">=\" is not defined for the current inputs. Output is set to false automatically.", NotificationLevel.Error);
    359                             Output = false;
    360 
    361                             break;
    362 
    363                         }
    364 
     134                try
     135                {
     136                    switch (this.settings.Comparator)
     137                    {
     138                        // if operator is =
     139                        case 0:
     140                            {
     141                                Output = InputOne.Equals(InputTwo);
     142                                ProgressChanged(100, 100);
     143                                break;
     144                            }
     145                        // if operator is !=
     146                        case 1:
     147                            {
     148                                Output = !InputOne.Equals(InputTwo);
     149                                ProgressChanged(100, 100);
     150                                break;
     151                            }
     152                        //if operator is <
     153                        case 2:
     154                            {
     155                                Output = InputOne.CompareTo(InputTwo) < 0;
     156                                ProgressChanged(100, 100);
     157                                break;
     158
     159                            }
     160                        //if operator is >
     161                        case 3:
     162                            {
     163
     164                                Output = InputOne.CompareTo(InputTwo) > 0;
     165                                ProgressChanged(100, 100);
     166                                break;
     167                            }
     168                        //if operator is <=
     169                        case 4:
     170                            {
     171
     172                                Output = InputOne.CompareTo(InputTwo) <= 0;
     173                                ProgressChanged(100, 100);
     174                                break;
     175
     176                            }
     177                        //if operator is >=
     178                        case 5:
     179                            {
     180                                Output = InputOne.CompareTo(InputTwo) >= 0;
     181                                ProgressChanged(100, 100);
     182
     183                                break;
     184
     185                            }
     186
     187                    }
     188                }
     189                catch (ArgumentException e)
     190                {
     191                    GuiLogMessage("The given Inputs are not comparable : " + e.Message, NotificationLevel.Error);
    365192                }
    366193
  • trunk/CrypPlugins/Comparators/DetailedDescription/Description.xaml

    r591 r608  
    3131    <Paragraph TextAlignment="Justify">
    3232        <Run FontSize="16" xml:lang="en-us">
    33            This plugin provides different comparators for certain given inputs. Make sure that the current
    34            comparator is defined for the given inputs.
     33           This plugin provides different comparators for two inputs. The success of this operation depends on the comparability of the given inputs. If possible, the types will be internally casted and compared. Otherwise an error will show up.
    3534           
    3635           </Run>
     
    3837    <Paragraph TextAlignment="Justify">
    3938    <Run>
    40             Note that for all oparators except "=" and "!=" the given inputs must be of the same type. This is not checked
    41             before the chain starts, because the input types are "object".
    42             "String" and "CryptoolStream" inputs are compared via length and not via their binary representaion.
     39            Note that
     40            "String" and "CryptoolStream" inputs are compared via their binary representaion.
    4341        </Run>
    4442    </Paragraph>
     
    7573                </TableCell>
    7674                <TableCell>
    77                     <Paragraph>int, BigInteger, Byte, Double, String (via length), CryptoolStream (via length)</Paragraph>
     75                    <Paragraph>only comparable inputs, which can be internally casted to another type (int,String etc.)</Paragraph>
    7876                </TableCell>
    7977            </TableRow>
Note: See TracChangeset for help on using the changeset viewer.