Changeset 817


Ignore:
Timestamp:
Nov 3, 2009, 1:59:56 PM (12 years ago)
Author:
falk
Message:

Added comments on Converter.cs

File:
1 edited

Legend:

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

    r803 r817  
    117117        {
    118118
    119             if (!(InputOne is int[] || InputOne is byte[] || InputOne is CryptoolStream))
     119            if (!(InputOne is int[] || InputOne is byte[] || InputOne is CryptoolStream)) 
    120120            {
    121121                if (inputOne is bool)
     
    153153                    return;
    154154                }
    155 
     155                // the string representation is used for all upcoming operations
    156156                string inpString = Convert.ToString(InputOne);
    157157
    158158
    159159
    160                 switch (this.settings.Converter)
     160                switch (this.settings.Converter) // convert to what?
    161161                {
    162162                    case 0: //String
     
    169169                        {
    170170
    171                             try // string -> int Läuft
     171                            try // can be read as int?
    172172                            {
    173173                                int temp = Convert.ToInt32(inpString);
    174                                 //int temp2 = (int)temp;
    175                                // GuiLogMessage("int erkannt", NotificationLevel.Info);
     174                               
    176175                                Output = temp;
    177176                                ProgressChanged(100, 100);
     
    186185                        {
    187186
    188                             try // string -> short Läuft
     187                            try // can be read as short?
    189188                            {
    190189                                short temp = Convert.ToInt16(inpString);
    191                                 // short temp2 = (short)temp;
    192                                // GuiLogMessage("short erkannt ", NotificationLevel.Info);
     190                             
    193191                                Output = temp;
    194192                                ProgressChanged(100, 100);
     
    202200                    case 3: //byte
    203201                        {
    204                             try // string -> byte Läuft
     202                            try // can be read as byte?
    205203                            {
    206204                                byte temp = Convert.ToByte(inpString);
    207                                // GuiLogMessage("byte erkannt ", NotificationLevel.Info);
     205                               
    208206                                Output = temp;
    209207                                ProgressChanged(100, 100);
     
    217215                    case 4: //double
    218216                        {
    219                             try // string -> double Läuft
    220                             {
    221                                 String cleanInputString = DoubleCleanup(inpString);
     217                            try // can be read as double?
     218                            {
     219                                String cleanInputString = DoubleCleanup(inpString); // apply user settings concerning input format
    222220
    223221                                double temp = Convert.ToDouble(cleanInputString);
     
    236234                    case 5: //bigint
    237235                        {
    238                             try // string -> bigint Läuft
     236                            try // can be read as biginteger?
    239237                            {
    240238
    241239                                BigInteger temp = BigInteger.parseExpression(inpString);
    242                                // GuiLogMessage("big int erkannt ", NotificationLevel.Info);
     240                               
    243241                                Output = temp;
    244242                                ProgressChanged(100, 100);
     
    252250                    case 6: // int[]
    253251                        {
    254                             GuiLogMessage("Conversion from String to int[] not defined: ", NotificationLevel.Error);
     252                            GuiLogMessage("Conversion to int[] not yet defined: ", NotificationLevel.Error);
    255253                            break;
    256254                        }
     
    258256                        {
    259257                            inpString = setText(inpString);
    260                             if (settings.Numeric)
    261                             {
    262                                 try // lässt sich als int verstehen?
     258                            if (settings.Numeric) // apply user setting concerning numeric interpretation of input (else input is read as string)
     259                            {
     260                                try // can be read as int?
    263261                                {
    264262                                    int tempint = Convert.ToInt32(inpString);
     
    267265
    268266                                    int test = BitConverter.ToInt32(temp, 0);
    269                                   //  GuiLogMessage("int erkannt " + test.ToString(), NotificationLevel.Info);
     267                                 
    270268
    271269                                    Output = temp;
     
    279277                                }
    280278
    281                                 try // lässt sich als bigint verstehen?
     279                                try // can be read as biginteger?
    282280                                {
    283281                                    BigInteger tempbigint = new BigInteger(inpString, 10);
     
    292290
    293291                                    BigInteger test = new BigInteger(temp);
    294                                    // GuiLogMessage("bigint erkannt " + test.ToString(), NotificationLevel.Info);
     292                                 
    295293                                    Output = temp;
    296294
     
    302300
    303301                                }
    304                                 try // lässt sich als double verstehen?
     302                                try // can be read as double
    305303                                {   
    306304                                   
     
    329327
    330328
    331                                 //GuiLogMessage("byte[] wiederherstellung " + Output.ToString(), NotificationLevel.Info);
     329                           
    332330                                ProgressChanged(100, 100);
    333331                                break;
    334332                               
     333                               
    335334                               
    336                                
    337                             }
    338                             else
    339                             {
    340                                 switch (settings.Encoding)
     335                            }
     336                            else // numeric interpretation NOT selected:
     337                            {
     338                                switch (settings.Encoding) //apply user settings concerning encoding
    341339                                {
    342340                                    case ConverterSettings.EncodingTypes.Default:
     
    368366
    369367
    370                                 //GuiLogMessage("byte[] wiederherstellung " + Output.ToString(), NotificationLevel.Info);
     368                             
    371369                                ProgressChanged(100, 100);
    372370                                break;
     
    376374                    case 8: //cryptoolstream
    377375                        {
    378                             GuiLogMessage("redundant", NotificationLevel.Error);
     376                            GuiLogMessage("Conversion to Cryptoolstream not yet implemented", NotificationLevel.Error);
    379377                            break;
    380378                        }
    381379                    default:
    382380                        {
    383                          //   GuiLogMessage("kein fall getriggert ", NotificationLevel.Error);
     381                         
    384382                            break;
    385383                        }
     
    394392
    395393        }
    396         private String setText(string temp)
     394        private String setText(string temp) //apply user selected presentation format
    397395        {
    398396            if (temp != null)
    399397            {
    400                 // Presentation format conversion
     398               
    401399                switch (settings.Presentation)
    402400                {
     
    418416            return temp;
    419417        }
    420         public String DoubleCleanup(String inpString)
     418        public String DoubleCleanup(String inpString) //apply user selected input format
    421419        {
    422420            if (this.settings.FormatAmer)
Note: See TracChangeset for help on using the changeset viewer.