Updated enum usage to follow Ray Wenderlich Swift Style Guide

Packages/QuickProto/Sources/Field.swift

@@ -53,7 +53,7 @@ public class Field {
     var line = indent
     line += String(describing:self.descriptor.label) + " "
     line += String(describing:type)
-    if ((type == FieldType.MESSAGE) || (type == FieldType.ENUM)) {
+    if ((type == .message) || (type == .enumeration)) {
       line += ":" + self.descriptor.type_name
     }
     line += " "

Packages/QuickProto/Sources/FieldDescriptor.swift

@@ -60,24 +60,24 @@ class FieldDescriptor {
 
   func wireType() -> WireType {
     switch type {
-    case FieldType.DOUBLE   : return WireType.FIXED64
-    case FieldType.FLOAT    : return WireType.FIXED32
-    case FieldType.INT64    : return WireType.VARINT
-    case FieldType.UINT64   : return WireType.VARINT
-    case FieldType.INT32    : return WireType.VARINT
-    case FieldType.FIXED64  : return WireType.FIXED64
-    case FieldType.FIXED32  : return WireType.FIXED32
-    case FieldType.BOOL     : return WireType.VARINT
-    case FieldType.STRING   : return WireType.LENGTH_DELIMITED
-    case FieldType.GROUP    : return WireType.START_GROUP
-    case FieldType.MESSAGE  : return WireType.LENGTH_DELIMITED
-    case FieldType.BYTES    : return WireType.LENGTH_DELIMITED
-    case FieldType.UINT32   : return WireType.VARINT
-    case FieldType.ENUM     : return WireType.VARINT
-    case FieldType.SFIXED32 : return WireType.FIXED32
-    case FieldType.SFIXED64 : return WireType.FIXED64
-    case FieldType.SINT32   : return WireType.VARINT
-    case FieldType.SINT64   : return WireType.VARINT
+    case .double:      return .fixed64
+    case .float:       return .fixed32
+    case .int64:       return .varint
+    case .uint64:      return .varint
+    case .int32:       return .varint
+    case .fixed64:     return .fixed64
+    case .fixed32:     return .fixed32
+    case .bool:        return .varint
+    case .string:      return .lengthDelimited
+    case .group:       return .startGroup
+    case .message:     return .lengthDelimited
+    case .bytes:       return .lengthDelimited
+    case .uint32:      return .varint
+    case .enumeration: return .varint
+    case .sfixed32:    return .fixed32
+    case .sfixed64:    return .fixed64
+    case .sint32:      return .varint
+    case .sint64:      return .varint
     }
   }
 }

Packages/QuickProto/Sources/FieldType.swift

@@ -34,27 +34,27 @@ import Foundation
 
 /// The "type" of a protocol buffer field
 public enum FieldType: Int {
-  case DOUBLE         = 1
-  case FLOAT          = 2
+  case double         = 1
+  case float          = 2
   // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use SINT64 if
   // negative values are likely.
-  case INT64          = 3
-  case UINT64         = 4
+  case int64          = 3
+  case uint64         = 4
   // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use SINT32 if
   // negative values are likely.
-  case INT32          = 5
-  case FIXED64        = 6
-  case FIXED32        = 7
-  case BOOL           = 8
-  case STRING         = 9
-  case GROUP          = 10  // Tag-delimited aggregate.
-  case MESSAGE        = 11  // Length-delimited aggregate.
+  case int32          = 5
+  case fixed64        = 6
+  case fixed32        = 7
+  case bool           = 8
+  case string         = 9
+  case group          = 10  // Tag-delimited aggregate.
+  case message        = 11  // Length-delimited aggregate.
   // New in version 2.
-  case BYTES          = 12
-  case UINT32         = 13
-  case ENUM           = 14
-  case SFIXED32       = 15
-  case SFIXED64       = 16
-  case SINT32         = 17  // Uses ZigZag encoding.
-  case SINT64         = 18
+  case bytes          = 12
+  case uint32         = 13
+  case enumeration    = 14
+  case sfixed32       = 15
+  case sfixed64       = 16
+  case sint32         = 17  // Uses ZigZag encoding.
+  case sint64         = 18
 }

Packages/QuickProto/Sources/Message.swift

@@ -143,51 +143,51 @@ public class Message {
       data.appendVarint(field.tag() << 3 + field.wireType().rawValue)
 
       switch field.type() {
-      case FieldType.DOUBLE:
+      case .double:
         data.appendDouble(field.double())
-      case FieldType.FLOAT:
+      case .float:
         data.appendFloat(field.float())
-      case FieldType.INT64:
+      case .int64:
         data.appendVarint(field.integer())
-      case FieldType.UINT64:
+      case .uint64:
         data.appendVarint(field.integer())
-      case FieldType.INT32:
+      case .int32:
         data.appendVarint(field.integer())
-      case FieldType.FIXED64:
+      case .fixed64:
         data.appendInt64(field.integer())
-      case FieldType.FIXED32:
+      case .fixed32:
         data.appendInt32(field.integer())
-      case FieldType.BOOL:
+      case .bool:
         data.appendVarint(field.bool() ? 1 : 0)
-      case FieldType.STRING:
+      case .string:
         var buf = [UInt8](field.string().utf8)
         data.appendVarint(buf.count)
         data.append(&buf, length: buf.count)
-      case FieldType.GROUP:
+      case .group:
         assert(false)
-      case FieldType.MESSAGE:
+      case .message:
         let messageData = field.message().data()
         data.appendVarint(messageData.count)
         messageData.withUnsafeBytes({ (bytes) in
           data.append(bytes, length: messageData.count)
         })
-      case FieldType.BYTES:
+      case .bytes:
         let messageData = field.data()
         data.appendVarint(messageData.count)
         messageData.withUnsafeBytes({ (bytes) in
           data.append(bytes, length: messageData.count)
         })
-      case FieldType.UINT32:
+      case .uint32:
         data.appendVarint(field.integer())
-      case FieldType.ENUM:
+      case .enumeration:
         data.appendVarint(field.integer())
-      case FieldType.SFIXED32:
+      case .sfixed32:
         data.appendInt32(field.integer())
-      case FieldType.SFIXED64:
+      case .sfixed64:
         data.appendInt64(field.integer())
-      case FieldType.SINT32:
+      case .sint32:
         data.appendVarint(Int(zigzag(Int32(field.integer()))))
-      case FieldType.SINT64:
+      case .sint64:
         data.appendVarint(Int(zigzag(Int64(field.integer()))))
       }
     }

Packages/QuickProto/Sources/MessageReader.swift

@@ -136,14 +136,14 @@ class MessageReader {
     while (cursor < range.location + range.length) {
       let s = self.nextVarint()
       let tag = s >> 3
-      let wiretype = s & 0x07
+      let wiretype = WireType(rawValue:s & 0x07)!
       let field = descriptor.fieldDescriptor(tag:tag)
 
       switch (wiretype) {
-      case 0: // varint
+      case .varint:
         var value = self.nextVarint()
         if let field = field {
-          if ((field.type == FieldType.SINT32) || (field.type == FieldType.SINT64)) {
+          if ((field.type == .sint32) || (field.type == .sint64)) {
             // zigzag decoding
             let sign = value & 0x01
             value = value >> 1
@@ -158,10 +158,10 @@ class MessageReader {
           ))
         }
 
-      case 1: // 64-bit
+      case .fixed64:
 
         if let field = field {
-          if field.type == FieldType.DOUBLE {
+          if field.type == .double {
             let value = self.nextDouble()
             fields.append(
               Field(
@@ -176,18 +176,18 @@ class MessageReader {
           }
         }
 
-      case 2: // length-delimited
+      case .lengthDelimited: // length-delimited
         let length = self.nextVarint()
         if let field = field {
           switch (field.type) {
-          case FieldType.STRING:
+          case .string:
             let value = self.nextString(length: length)
             fields.append(
               Field(
                 descriptor: field,
                 value: value))
 
-          case FieldType.BYTES:
+          case .bytes:
             let value = self.nextData(length: length)
             fields.append(
               Field(
@@ -212,15 +212,15 @@ class MessageReader {
           cursor += length
         }
 
-      case 3: // start group
+      case .startGroup:
         break
 
-      case 4: // end group
+      case .endGroup:
         break
 
-      case 5: // 32-bit
+      case .fixed32:
         if let field = field {
-          if field.type == FieldType.FLOAT {
+          if field.type == .float {
             let value = self.nextFloat()
             fields.append(
               Field(
@@ -234,8 +234,6 @@ class MessageReader {
                 value: value))
           }
         }
-
-      default: continue
       }
     }
     return Message(descriptor:descriptor, fields:fields)

Packages/QuickProto/Sources/WireType.swift

@@ -34,10 +34,10 @@ import Foundation
 
 /// The "wire type" of a protocol buffer field
 public enum WireType: Int {
-  case VARINT = 0
-  case FIXED64 = 1
-  case LENGTH_DELIMITED = 2
-  case START_GROUP = 3
-  case END_GROUP = 4
-  case FIXED32 = 5
+  case varint = 0
+  case fixed64 = 1
+  case lengthDelimited = 2
+  case startGroup = 3
+  case endGroup = 4
+  case fixed32 = 5
 }