Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
07/22/10 00:44:01 (14 years ago)
Author:
swagner
Message:

Sorted usings and removed unused usings in entire solution (#1094)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.ProtobufCS/0.9.1/ProtobufCS/src/ProtocolBuffers/TextFormat.cs

    r3857 r4068  
    3434
    3535using System;
     36using System.Collections;
    3637using System.Collections.Generic;
    3738using System.Globalization;
    … …  
    3940using System.Text;
    4041using Google.ProtocolBuffers.Descriptors;
    41 using System.Collections;
    4242
    4343namespace Google.ProtocolBuffers {
    … …  
    8787      if (field.IsRepeated) {
    8888        // Repeated field.  Print each element.
    89         foreach (object element in (IEnumerable) value) {
     89        foreach (object element in (IEnumerable)value) {
    9090          PrintSingleField(field, element, generator);
    9191        }
    … …  
    102102            && field.FieldType == FieldType.Message
    103103            && field.IsOptional
    104             // object equality (TODO(jonskeet): Work out what this comment means!)
     104          // object equality (TODO(jonskeet): Work out what this comment means!)
    105105            && field.ExtensionScope == field.MessageType) {
    106106          generator.Print(field.MessageType.FullName);
    … …  
    150150          // The simple Object.ToString converts using the current culture.
    151151          // We want to always use the invariant culture so it's predictable.
    152           generator.Print(((IConvertible) value).ToString(CultureInfo.InvariantCulture));
     152          generator.Print(((IConvertible)value).ToString(CultureInfo.InvariantCulture));
    153153          break;
    154154        case FieldType.Bool:
    155155          // Explicitly use the Java true/false
    156           generator.Print((bool) value ? "true" : "false");
     156          generator.Print((bool)value ? "true" : "false");
    157157          break;
    158158
    159159        case FieldType.String:
    160160          generator.Print("\"");
    161           generator.Print(EscapeText((string) value));
     161          generator.Print(EscapeText((string)value));
    162162          generator.Print("\"");
    163163          break;
    164164
    165165        case FieldType.Bytes: {
    166           generator.Print("\"");
    167           generator.Print(EscapeBytes((ByteString) value));
    168           generator.Print("\"");
    169           break;
    170         }
     166            generator.Print("\"");
     167            generator.Print(EscapeBytes((ByteString)value));
     168            generator.Print("\"");
     169            break;
     170          }
    171171
    172172        case FieldType.Enum: {
    173           generator.Print(((EnumValueDescriptor) value).Name);
    174           break;
    175         }
     173            generator.Print(((EnumValueDescriptor)value).Name);
     174            break;
     175          }
    176176
    177177        case FieldType.Message:
    178178        case FieldType.Group:
    179           Print((IMessage) value, generator);
     179          Print((IMessage)value, generator);
    180180          break;
    181181      }
    … …  
    220220
    221221    internal static ulong ParseUInt64(string text) {
    222       return (ulong) ParseInteger(text, false, true);
     222      return (ulong)ParseInteger(text, false, true);
    223223    }
    224224
    … …  
    228228
    229229    internal static uint ParseUInt32(string text) {
    230       return (uint) ParseInteger(text, false, false);
     230      return (uint)ParseInteger(text, false, false);
    231231    }
    232232
    233233    internal static int ParseInt32(string text) {
    234       return (int) ParseInteger(text, true, false);
     234      return (int)ParseInteger(text, true, false);
    235235    }
    236236
    … …  
    269269      }
    270270    }
    271    
     271
    272272    /// <summary>
    273273    /// Parses an integer in hex (leading 0x), decimal (no prefix) or octal (leading 0).
    … …  
    298298        // We should be able to use Convert.ToUInt64 for all cases.
    299299        result = radix == 10 ? ulong.Parse(text) : Convert.ToUInt64(text, radix);
    300       } catch (OverflowException) {
     300      }
     301      catch (OverflowException) {
    301302        // Convert OverflowException to FormatException so there's a single exception type this method can throw.
    302303        string numberDescription = string.Format("{0}-bit {1}signed integer", isLong ? 64 : 32, isSigned ? "" : "un");
    … …  
    310311          throw new FormatException("Number out of range for " + numberDescription + ": " + original);
    311312        }
    312         return -((long) result);
    313       } else {
    314         ulong max = isSigned 
    315             ? (isLong ? (ulong) long.MaxValue : int.MaxValue)
     313        return -((long)result);
     314      } else {
     315        ulong max = isSigned
     316            ? (isLong ? (ulong)long.MaxValue : int.MaxValue)
    316317            : (isLong ? ulong.MaxValue : uint.MaxValue);
    317318        if (result > max) {
    … …  
    319320          throw new FormatException("Number out of range for " + numberDescription + ": " + original);
    320321        }
    321         return (long) result;
     322        return (long)result;
    322323      }
    323324    }
    … …  
    384385        switch (b) {
    385386          // C# does not use \a or \v
    386           case 0x07: builder.Append("\\a" ); break;
    387           case (byte)'\b': builder.Append("\\b" ); break;
    388           case (byte)'\f': builder.Append("\\f" ); break;
    389           case (byte)'\n': builder.Append("\\n" ); break;
    390           case (byte)'\r': builder.Append("\\r" ); break;
    391           case (byte)'\t': builder.Append("\\t" ); break;
    392           case 0x0b: builder.Append("\\v" ); break;
     387          case 0x07: builder.Append("\\a"); break;
     388          case (byte)'\b': builder.Append("\\b"); break;
     389          case (byte)'\f': builder.Append("\\f"); break;
     390          case (byte)'\n': builder.Append("\\n"); break;
     391          case (byte)'\r': builder.Append("\\r"); break;
     392          case (byte)'\t': builder.Append("\\t"); break;
     393          case 0x0b: builder.Append("\\v"); break;
    393394          case (byte)'\\': builder.Append("\\\\"); break;
    394395          case (byte)'\'': builder.Append("\\\'"); break;
    395           case (byte)'"' : builder.Append("\\\""); break;
     396          case (byte)'"': builder.Append("\\\""); break;
    396397          default:
    397398            if (b >= 0x20 && b < 128) {
    398               builder.Append((char) b);
     399              builder.Append((char)b);
    399400            } else {
    400401              builder.Append('\\');
    401               builder.Append((char) ('0' + ((b >> 6) & 3)));
    402               builder.Append((char) ('0' + ((b >> 3) & 7)));
    403               builder.Append((char) ('0' + (b & 7)));
     402              builder.Append((char)('0' + ((b >> 6) & 3)));
     403              builder.Append((char)('0' + ((b >> 3) & 7)));
     404              builder.Append((char)('0' + (b & 7)));
    404405            }
    405406            break;
    … …  
    421422        }
    422423        if (c != '\\') {
    423           result[pos++] = (byte) c;
     424          result[pos++] = (byte)c;
    424425          continue;
    425426        }
    … …  
    433434          // Octal escape.
    434435          int code = ParseDigit(c);
    435           if (i + 1 < input.Length && IsOctal(input[i+1])) {
     436          if (i + 1 < input.Length && IsOctal(input[i + 1])) {
    436437            i++;
    437438            code = code * 8 + ParseDigit(input[i]);
    438439          }
    439           if (i + 1 < input.Length && IsOctal(input[i+1])) {
     440          if (i + 1 < input.Length && IsOctal(input[i + 1])) {
    440441            i++;
    441442            code = code * 8 + ParseDigit(input[i]);
    442443          }
    443           result[pos++] = (byte) code;
     444          result[pos++] = (byte)code;
    444445        } else {
    445446          switch (c) {
    446447            case 'a': result[pos++] = 0x07; break;
    447             case 'b': result[pos++] = (byte) '\b'; break;
    448             case 'f': result[pos++] = (byte) '\f'; break;
    449             case 'n': result[pos++] = (byte) '\n'; break;
    450             case 'r': result[pos++] = (byte) '\r'; break;
    451             case 't': result[pos++] = (byte) '\t'; break;
     448            case 'b': result[pos++] = (byte)'\b'; break;
     449            case 'f': result[pos++] = (byte)'\f'; break;
     450            case 'n': result[pos++] = (byte)'\n'; break;
     451            case 'r': result[pos++] = (byte)'\r'; break;
     452            case 't': result[pos++] = (byte)'\t'; break;
    452453            case 'v': result[pos++] = 0x0b; break;
    453             case '\\': result[pos++] = (byte) '\\'; break;
    454             case '\'': result[pos++] = (byte) '\''; break;
    455             case '"': result[pos++] = (byte) '\"'; break;
     454            case '\\': result[pos++] = (byte)'\\'; break;
     455            case '\'': result[pos++] = (byte)'\''; break;
     456            case '"': result[pos++] = (byte)'\"'; break;
    456457
    457458            case 'x':
    458459              // hex escape
    459460              int code;
    460               if (i + 1 < input.Length && IsHex(input[i+1])) {
     461              if (i + 1 < input.Length && IsHex(input[i + 1])) {
    461462                i++;
    462463                code = ParseDigit(input[i]);
    … …  
    464465                throw new FormatException("Invalid escape sequence: '\\x' with no digits");
    465466              }
    466               if (i + 1 < input.Length && IsHex(input[i+1])) {
     467              if (i + 1 < input.Length && IsHex(input[i + 1])) {
    467468                ++i;
    468469                code = code * 16 + ParseDigit(input[i]);
    … …  
    636637
    637638          case FieldType.Enum: {
    638             EnumDescriptor enumType = field.EnumType;
    639 
    640             if (tokenizer.LookingAtInteger()) {
    641               int number = tokenizer.ConsumeInt32();
    642               value = enumType.FindValueByNumber(number);
    643               if (value == null) {
    644                 throw tokenizer.CreateFormatExceptionPreviousToken(
    645                   "Enum type \"" + enumType.FullName +
    646                   "\" has no value with number " + number + ".");
     639              EnumDescriptor enumType = field.EnumType;
     640
     641              if (tokenizer.LookingAtInteger()) {
     642                int number = tokenizer.ConsumeInt32();
     643                value = enumType.FindValueByNumber(number);
     644                if (value == null) {
     645                  throw tokenizer.CreateFormatExceptionPreviousToken(
     646                    "Enum type \"" + enumType.FullName +
     647                    "\" has no value with number " + number + ".");
     648                }
     649              } else {
     650                String id = tokenizer.ConsumeIdentifier();
     651                value = enumType.FindValueByName(id);
     652                if (value == null) {
     653                  throw tokenizer.CreateFormatExceptionPreviousToken(
     654                    "Enum type \"" + enumType.FullName +
     655                    "\" has no value named \"" + id + "\".");
     656                }
    647657              }
    648             } else {
    649               String id = tokenizer.ConsumeIdentifier();
    650               value = enumType.FindValueByName(id);
    651               if (value == null) {
    652                 throw tokenizer.CreateFormatExceptionPreviousToken(
    653                   "Enum type \"" + enumType.FullName +
    654                   "\" has no value named \"" + id + "\".");
    655               }
     658
     659              break;
    656660            }
    657 
    658             break;
    659           }
    660661
    661662          case FieldType.Message:
Note: See TracChangeset for help on using the changeset viewer.