 
     /// check data type of the value / element of value array
     public var `type`: DataType? {
-      get {
-        return DataType(rawValue: Int(TFLib.TensorType(tensor)))
-      }
+      return DataType(rawValue: Int(TFLib.TensorType(tensor)))
     }
 
     /// check dimension count
     public var dimensionCount: Int {
-      get {
-        return Int(TFLib.NumDims(tensor))
-      }
+      return Int(TFLib.NumDims(tensor))
     }
 
     /// get a dimension data giving a proper index


    /// retrieve all operations into an array
    public var operations: [Operation] {
      get {
        var cursor = 0
        var ops = [Operation]()
        while let pointer = TF_NextGraphOperation(graph, &cursor) {
          ops.append(Operation(pointer))
        }//next
        return ops
      }//end get
    }//end var

    /// get the definition proto buffer
    public var definition: GraphDef? {
      get {
        guard let data = self.buffer?.data else {
          return nil
        }//end guard

        do {
          let def = try GraphDef(serializedData: data)
          return def
        } catch {
          return nil
        }//end try
      }//end get
    }//end var

    /// get the definition as a buffer
    public var buffer: Buffer? {
      get {
        do {
          let buffer = try Buffer()
          let status = try Status()
          TFLib.GraphToGraphDef(graph, buffer.buffer, status.status)
          guard status.code == .OK else { return nil }
          return buffer
        } catch {
          return nil
        }//end try
      }//end get
    }//end buffer

    /// import a proto buffer with options

    return result
  }//end encode

  // decode strings from a buffer
  public static func Decode(strings: [Int8], count: Int) throws -> [Data] {
    let szHeader = count * MemoryLayout<UInt64>.size
    guard count > 0, strings.count > 0, strings.count > szHeader else {
