{- This file was auto-generated from tensorflow/core/protobuf/tensor_bundle.proto by the proto-lens-protoc program. -}
{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, UndecidableInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds, BangPatterns, TypeApplications, OverloadedStrings, DerivingStrategies#-}
{-# OPTIONS_GHC -Wno-unused-imports#-}
{-# OPTIONS_GHC -Wno-duplicate-exports#-}
{-# OPTIONS_GHC -Wno-dodgy-exports#-}
module Proto.Tensorflow.Core.Protobuf.TensorBundle (
        BundleEntryProto(), BundleHeaderProto(),
        BundleHeaderProto'Endianness(..), BundleHeaderProto'Endianness(),
        BundleHeaderProto'Endianness'UnrecognizedValue
    ) where
import qualified Data.ProtoLens.Runtime.Control.DeepSeq as Control.DeepSeq
import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Prism as Data.ProtoLens.Prism
import qualified Data.ProtoLens.Runtime.Prelude as Prelude
import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int
import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid
import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word
import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens
import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes
import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing
import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe
import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire
import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field
import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum
import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types
import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2
import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked
import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text
import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map
import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString
import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8
import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding
import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector
import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic
import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed
import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read
import qualified Proto.Tensorflow.Core.Framework.TensorShape
import qualified Proto.Tensorflow.Core.Framework.TensorSlice
import qualified Proto.Tensorflow.Core.Framework.Types
import qualified Proto.Tensorflow.Core.Framework.Versions
{- | Fields :
     
         * 'Proto.Tensorflow.Core.Protobuf.TensorBundle_Fields.dtype' @:: Lens' BundleEntryProto Proto.Tensorflow.Core.Framework.Types.DataType@
         * 'Proto.Tensorflow.Core.Protobuf.TensorBundle_Fields.shape' @:: Lens' BundleEntryProto Proto.Tensorflow.Core.Framework.TensorShape.TensorShapeProto@
         * 'Proto.Tensorflow.Core.Protobuf.TensorBundle_Fields.maybe'shape' @:: Lens' BundleEntryProto (Prelude.Maybe Proto.Tensorflow.Core.Framework.TensorShape.TensorShapeProto)@
         * 'Proto.Tensorflow.Core.Protobuf.TensorBundle_Fields.shardId' @:: Lens' BundleEntryProto Data.Int.Int32@
         * 'Proto.Tensorflow.Core.Protobuf.TensorBundle_Fields.offset' @:: Lens' BundleEntryProto Data.Int.Int64@
         * 'Proto.Tensorflow.Core.Protobuf.TensorBundle_Fields.size' @:: Lens' BundleEntryProto Data.Int.Int64@
         * 'Proto.Tensorflow.Core.Protobuf.TensorBundle_Fields.crc32c' @:: Lens' BundleEntryProto Data.Word.Word32@
         * 'Proto.Tensorflow.Core.Protobuf.TensorBundle_Fields.slices' @:: Lens' BundleEntryProto [Proto.Tensorflow.Core.Framework.TensorSlice.TensorSliceProto]@
         * 'Proto.Tensorflow.Core.Protobuf.TensorBundle_Fields.vec'slices' @:: Lens' BundleEntryProto (Data.Vector.Vector Proto.Tensorflow.Core.Framework.TensorSlice.TensorSliceProto)@ -}
data BundleEntryProto
  = BundleEntryProto'_constructor {BundleEntryProto -> DataType
_BundleEntryProto'dtype :: !Proto.Tensorflow.Core.Framework.Types.DataType,
                                   BundleEntryProto -> Maybe TensorShapeProto
_BundleEntryProto'shape :: !(Prelude.Maybe Proto.Tensorflow.Core.Framework.TensorShape.TensorShapeProto),
                                   BundleEntryProto -> Int32
_BundleEntryProto'shardId :: !Data.Int.Int32,
                                   BundleEntryProto -> Int64
_BundleEntryProto'offset :: !Data.Int.Int64,
                                   BundleEntryProto -> Int64
_BundleEntryProto'size :: !Data.Int.Int64,
                                   BundleEntryProto -> Word32
_BundleEntryProto'crc32c :: !Data.Word.Word32,
                                   BundleEntryProto -> Vector TensorSliceProto
_BundleEntryProto'slices :: !(Data.Vector.Vector Proto.Tensorflow.Core.Framework.TensorSlice.TensorSliceProto),
                                   BundleEntryProto -> FieldSet
_BundleEntryProto'_unknownFields :: !Data.ProtoLens.FieldSet}
  deriving stock (BundleEntryProto -> BundleEntryProto -> Bool
(BundleEntryProto -> BundleEntryProto -> Bool)
-> (BundleEntryProto -> BundleEntryProto -> Bool)
-> Eq BundleEntryProto
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BundleEntryProto -> BundleEntryProto -> Bool
$c/= :: BundleEntryProto -> BundleEntryProto -> Bool
== :: BundleEntryProto -> BundleEntryProto -> Bool
$c== :: BundleEntryProto -> BundleEntryProto -> Bool
Prelude.Eq, Eq BundleEntryProto
Eq BundleEntryProto =>
(BundleEntryProto -> BundleEntryProto -> Ordering)
-> (BundleEntryProto -> BundleEntryProto -> Bool)
-> (BundleEntryProto -> BundleEntryProto -> Bool)
-> (BundleEntryProto -> BundleEntryProto -> Bool)
-> (BundleEntryProto -> BundleEntryProto -> Bool)
-> (BundleEntryProto -> BundleEntryProto -> BundleEntryProto)
-> (BundleEntryProto -> BundleEntryProto -> BundleEntryProto)
-> Ord BundleEntryProto
BundleEntryProto -> BundleEntryProto -> Bool
BundleEntryProto -> BundleEntryProto -> Ordering
BundleEntryProto -> BundleEntryProto -> BundleEntryProto
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BundleEntryProto -> BundleEntryProto -> BundleEntryProto
$cmin :: BundleEntryProto -> BundleEntryProto -> BundleEntryProto
max :: BundleEntryProto -> BundleEntryProto -> BundleEntryProto
$cmax :: BundleEntryProto -> BundleEntryProto -> BundleEntryProto
>= :: BundleEntryProto -> BundleEntryProto -> Bool
$c>= :: BundleEntryProto -> BundleEntryProto -> Bool
> :: BundleEntryProto -> BundleEntryProto -> Bool
$c> :: BundleEntryProto -> BundleEntryProto -> Bool
<= :: BundleEntryProto -> BundleEntryProto -> Bool
$c<= :: BundleEntryProto -> BundleEntryProto -> Bool
< :: BundleEntryProto -> BundleEntryProto -> Bool
$c< :: BundleEntryProto -> BundleEntryProto -> Bool
compare :: BundleEntryProto -> BundleEntryProto -> Ordering
$ccompare :: BundleEntryProto -> BundleEntryProto -> Ordering
$cp1Ord :: Eq BundleEntryProto
Prelude.Ord)
instance Prelude.Show BundleEntryProto where
  showsPrec :: Int -> BundleEntryProto -> ShowS
showsPrec _ __x :: BundleEntryProto
__x __s :: String
__s
    = Char -> ShowS
Prelude.showChar
        '{'
        (String -> ShowS
Prelude.showString
           (BundleEntryProto -> String
forall msg. Message msg => msg -> String
Data.ProtoLens.showMessageShort BundleEntryProto
__x) (Char -> ShowS
Prelude.showChar '}' String
__s))
instance Data.ProtoLens.Field.HasField BundleEntryProto "dtype" Proto.Tensorflow.Core.Framework.Types.DataType where
  fieldOf :: Proxy# "dtype"
-> (DataType -> f DataType)
-> BundleEntryProto
-> f BundleEntryProto
fieldOf _
    = ((DataType -> f DataType)
 -> BundleEntryProto -> f BundleEntryProto)
-> ((DataType -> f DataType) -> DataType -> f DataType)
-> (DataType -> f DataType)
-> BundleEntryProto
-> f BundleEntryProto
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
        ((BundleEntryProto -> DataType)
-> (BundleEntryProto -> DataType -> BundleEntryProto)
-> Lens BundleEntryProto BundleEntryProto DataType DataType
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           BundleEntryProto -> DataType
_BundleEntryProto'dtype
           (\ x__ :: BundleEntryProto
x__ y__ :: DataType
y__ -> BundleEntryProto
x__ {_BundleEntryProto'dtype :: DataType
_BundleEntryProto'dtype = DataType
y__}))
        (DataType -> f DataType) -> DataType -> f DataType
forall a. a -> a
Prelude.id
instance Data.ProtoLens.Field.HasField BundleEntryProto "shape" Proto.Tensorflow.Core.Framework.TensorShape.TensorShapeProto where
  fieldOf :: Proxy# "shape"
-> (TensorShapeProto -> f TensorShapeProto)
-> BundleEntryProto
-> f BundleEntryProto
fieldOf _
    = ((Maybe TensorShapeProto -> f (Maybe TensorShapeProto))
 -> BundleEntryProto -> f BundleEntryProto)
-> ((TensorShapeProto -> f TensorShapeProto)
    -> Maybe TensorShapeProto -> f (Maybe TensorShapeProto))
-> (TensorShapeProto -> f TensorShapeProto)
-> BundleEntryProto
-> f BundleEntryProto
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
        ((BundleEntryProto -> Maybe TensorShapeProto)
-> (BundleEntryProto -> Maybe TensorShapeProto -> BundleEntryProto)
-> Lens
     BundleEntryProto
     BundleEntryProto
     (Maybe TensorShapeProto)
     (Maybe TensorShapeProto)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           BundleEntryProto -> Maybe TensorShapeProto
_BundleEntryProto'shape
           (\ x__ :: BundleEntryProto
x__ y__ :: Maybe TensorShapeProto
y__ -> BundleEntryProto
x__ {_BundleEntryProto'shape :: Maybe TensorShapeProto
_BundleEntryProto'shape = Maybe TensorShapeProto
y__}))
        (TensorShapeProto -> Lens' (Maybe TensorShapeProto) TensorShapeProto
forall b. b -> Lens' (Maybe b) b
Data.ProtoLens.maybeLens TensorShapeProto
forall msg. Message msg => msg
Data.ProtoLens.defMessage)
instance Data.ProtoLens.Field.HasField BundleEntryProto "maybe'shape" (Prelude.Maybe Proto.Tensorflow.Core.Framework.TensorShape.TensorShapeProto) where
  fieldOf :: Proxy# "maybe'shape"
-> (Maybe TensorShapeProto -> f (Maybe TensorShapeProto))
-> BundleEntryProto
-> f BundleEntryProto
fieldOf _
    = ((Maybe TensorShapeProto -> f (Maybe TensorShapeProto))
 -> BundleEntryProto -> f BundleEntryProto)
-> ((Maybe TensorShapeProto -> f (Maybe TensorShapeProto))
    -> Maybe TensorShapeProto -> f (Maybe TensorShapeProto))
-> (Maybe TensorShapeProto -> f (Maybe TensorShapeProto))
-> BundleEntryProto
-> f BundleEntryProto
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
        ((BundleEntryProto -> Maybe TensorShapeProto)
-> (BundleEntryProto -> Maybe TensorShapeProto -> BundleEntryProto)
-> Lens
     BundleEntryProto
     BundleEntryProto
     (Maybe TensorShapeProto)
     (Maybe TensorShapeProto)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           BundleEntryProto -> Maybe TensorShapeProto
_BundleEntryProto'shape
           (\ x__ :: BundleEntryProto
x__ y__ :: Maybe TensorShapeProto
y__ -> BundleEntryProto
x__ {_BundleEntryProto'shape :: Maybe TensorShapeProto
_BundleEntryProto'shape = Maybe TensorShapeProto
y__}))
        (Maybe TensorShapeProto -> f (Maybe TensorShapeProto))
-> Maybe TensorShapeProto -> f (Maybe TensorShapeProto)
forall a. a -> a
Prelude.id
instance Data.ProtoLens.Field.HasField BundleEntryProto "shardId" Data.Int.Int32 where
  fieldOf :: Proxy# "shardId"
-> (Int32 -> f Int32) -> BundleEntryProto -> f BundleEntryProto
fieldOf _
    = ((Int32 -> f Int32) -> BundleEntryProto -> f BundleEntryProto)
-> ((Int32 -> f Int32) -> Int32 -> f Int32)
-> (Int32 -> f Int32)
-> BundleEntryProto
-> f BundleEntryProto
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
        ((BundleEntryProto -> Int32)
-> (BundleEntryProto -> Int32 -> BundleEntryProto)
-> Lens BundleEntryProto BundleEntryProto Int32 Int32
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           BundleEntryProto -> Int32
_BundleEntryProto'shardId
           (\ x__ :: BundleEntryProto
x__ y__ :: Int32
y__ -> BundleEntryProto
x__ {_BundleEntryProto'shardId :: Int32
_BundleEntryProto'shardId = Int32
y__}))
        (Int32 -> f Int32) -> Int32 -> f Int32
forall a. a -> a
Prelude.id
instance Data.ProtoLens.Field.HasField BundleEntryProto "offset" Data.Int.Int64 where
  fieldOf :: Proxy# "offset"
-> (Int64 -> f Int64) -> BundleEntryProto -> f BundleEntryProto
fieldOf _
    = ((Int64 -> f Int64) -> BundleEntryProto -> f BundleEntryProto)
-> ((Int64 -> f Int64) -> Int64 -> f Int64)
-> (Int64 -> f Int64)
-> BundleEntryProto
-> f BundleEntryProto
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
        ((BundleEntryProto -> Int64)
-> (BundleEntryProto -> Int64 -> BundleEntryProto)
-> Lens BundleEntryProto BundleEntryProto Int64 Int64
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           BundleEntryProto -> Int64
_BundleEntryProto'offset
           (\ x__ :: BundleEntryProto
x__ y__ :: Int64
y__ -> BundleEntryProto
x__ {_BundleEntryProto'offset :: Int64
_BundleEntryProto'offset = Int64
y__}))
        (Int64 -> f Int64) -> Int64 -> f Int64
forall a. a -> a
Prelude.id
instance Data.ProtoLens.Field.HasField BundleEntryProto "size" Data.Int.Int64 where
  fieldOf :: Proxy# "size"
-> (Int64 -> f Int64) -> BundleEntryProto -> f BundleEntryProto
fieldOf _
    = ((Int64 -> f Int64) -> BundleEntryProto -> f BundleEntryProto)
-> ((Int64 -> f Int64) -> Int64 -> f Int64)
-> (Int64 -> f Int64)
-> BundleEntryProto
-> f BundleEntryProto
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
        ((BundleEntryProto -> Int64)
-> (BundleEntryProto -> Int64 -> BundleEntryProto)
-> Lens BundleEntryProto BundleEntryProto Int64 Int64
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           BundleEntryProto -> Int64
_BundleEntryProto'size
           (\ x__ :: BundleEntryProto
x__ y__ :: Int64
y__ -> BundleEntryProto
x__ {_BundleEntryProto'size :: Int64
_BundleEntryProto'size = Int64
y__}))
        (Int64 -> f Int64) -> Int64 -> f Int64
forall a. a -> a
Prelude.id
instance Data.ProtoLens.Field.HasField BundleEntryProto "crc32c" Data.Word.Word32 where
  fieldOf :: Proxy# "crc32c"
-> (Word32 -> f Word32) -> BundleEntryProto -> f BundleEntryProto
fieldOf _
    = ((Word32 -> f Word32) -> BundleEntryProto -> f BundleEntryProto)
-> ((Word32 -> f Word32) -> Word32 -> f Word32)
-> (Word32 -> f Word32)
-> BundleEntryProto
-> f BundleEntryProto
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
        ((BundleEntryProto -> Word32)
-> (BundleEntryProto -> Word32 -> BundleEntryProto)
-> Lens BundleEntryProto BundleEntryProto Word32 Word32
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           BundleEntryProto -> Word32
_BundleEntryProto'crc32c
           (\ x__ :: BundleEntryProto
x__ y__ :: Word32
y__ -> BundleEntryProto
x__ {_BundleEntryProto'crc32c :: Word32
_BundleEntryProto'crc32c = Word32
y__}))
        (Word32 -> f Word32) -> Word32 -> f Word32
forall a. a -> a
Prelude.id
instance Data.ProtoLens.Field.HasField BundleEntryProto "slices" [Proto.Tensorflow.Core.Framework.TensorSlice.TensorSliceProto] where
  fieldOf :: Proxy# "slices"
-> ([TensorSliceProto] -> f [TensorSliceProto])
-> BundleEntryProto
-> f BundleEntryProto
fieldOf _
    = ((Vector TensorSliceProto -> f (Vector TensorSliceProto))
 -> BundleEntryProto -> f BundleEntryProto)
-> (([TensorSliceProto] -> f [TensorSliceProto])
    -> Vector TensorSliceProto -> f (Vector TensorSliceProto))
-> ([TensorSliceProto] -> f [TensorSliceProto])
-> BundleEntryProto
-> f BundleEntryProto
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
        ((BundleEntryProto -> Vector TensorSliceProto)
-> (BundleEntryProto
    -> Vector TensorSliceProto -> BundleEntryProto)
-> Lens
     BundleEntryProto
     BundleEntryProto
     (Vector TensorSliceProto)
     (Vector TensorSliceProto)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           BundleEntryProto -> Vector TensorSliceProto
_BundleEntryProto'slices
           (\ x__ :: BundleEntryProto
x__ y__ :: Vector TensorSliceProto
y__ -> BundleEntryProto
x__ {_BundleEntryProto'slices :: Vector TensorSliceProto
_BundleEntryProto'slices = Vector TensorSliceProto
y__}))
        ((Vector TensorSliceProto -> [TensorSliceProto])
-> (Vector TensorSliceProto
    -> [TensorSliceProto] -> Vector TensorSliceProto)
-> Lens
     (Vector TensorSliceProto)
     (Vector TensorSliceProto)
     [TensorSliceProto]
     [TensorSliceProto]
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           Vector TensorSliceProto -> [TensorSliceProto]
forall (v :: * -> *) a. Vector v a => v a -> [a]
Data.Vector.Generic.toList
           (\ _ y__ :: [TensorSliceProto]
y__ -> [TensorSliceProto] -> Vector TensorSliceProto
forall (v :: * -> *) a. Vector v a => [a] -> v a
Data.Vector.Generic.fromList [TensorSliceProto]
y__))
instance Data.ProtoLens.Field.HasField BundleEntryProto "vec'slices" (Data.Vector.Vector Proto.Tensorflow.Core.Framework.TensorSlice.TensorSliceProto) where
  fieldOf :: Proxy# "vec'slices"
-> (Vector TensorSliceProto -> f (Vector TensorSliceProto))
-> BundleEntryProto
-> f BundleEntryProto
fieldOf _
    = ((Vector TensorSliceProto -> f (Vector TensorSliceProto))
 -> BundleEntryProto -> f BundleEntryProto)
-> ((Vector TensorSliceProto -> f (Vector TensorSliceProto))
    -> Vector TensorSliceProto -> f (Vector TensorSliceProto))
-> (Vector TensorSliceProto -> f (Vector TensorSliceProto))
-> BundleEntryProto
-> f BundleEntryProto
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
        ((BundleEntryProto -> Vector TensorSliceProto)
-> (BundleEntryProto
    -> Vector TensorSliceProto -> BundleEntryProto)
-> Lens
     BundleEntryProto
     BundleEntryProto
     (Vector TensorSliceProto)
     (Vector TensorSliceProto)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           BundleEntryProto -> Vector TensorSliceProto
_BundleEntryProto'slices
           (\ x__ :: BundleEntryProto
x__ y__ :: Vector TensorSliceProto
y__ -> BundleEntryProto
x__ {_BundleEntryProto'slices :: Vector TensorSliceProto
_BundleEntryProto'slices = Vector TensorSliceProto
y__}))
        (Vector TensorSliceProto -> f (Vector TensorSliceProto))
-> Vector TensorSliceProto -> f (Vector TensorSliceProto)
forall a. a -> a
Prelude.id
instance Data.ProtoLens.Message BundleEntryProto where
  messageName :: Proxy BundleEntryProto -> Text
messageName _ = String -> Text
Data.Text.pack "tensorflow.BundleEntryProto"
  packedMessageDescriptor :: Proxy BundleEntryProto -> ByteString
packedMessageDescriptor _
    = "\n\
      \\DLEBundleEntryProto\DC2*\n\
      \\ENQdtype\CAN\SOH \SOH(\SO2\DC4.tensorflow.DataTypeR\ENQdtype\DC22\n\
      \\ENQshape\CAN\STX \SOH(\v2\FS.tensorflow.TensorShapeProtoR\ENQshape\DC2\EM\n\
      \\bshard_id\CAN\ETX \SOH(\ENQR\ashardId\DC2\SYN\n\
      \\ACKoffset\CAN\EOT \SOH(\ETXR\ACKoffset\DC2\DC2\n\
      \\EOTsize\CAN\ENQ \SOH(\ETXR\EOTsize\DC2\SYN\n\
      \\ACKcrc32c\CAN\ACK \SOH(\aR\ACKcrc32c\DC24\n\
      \\ACKslices\CAN\a \ETX(\v2\FS.tensorflow.TensorSliceProtoR\ACKslices"
  packedFileDescriptor :: Proxy BundleEntryProto -> ByteString
packedFileDescriptor _ = ByteString
packedFileDescriptor
  fieldsByTag :: Map Tag (FieldDescriptor BundleEntryProto)
fieldsByTag
    = let
        dtype__field_descriptor :: FieldDescriptor BundleEntryProto
dtype__field_descriptor
          = String
-> FieldTypeDescriptor DataType
-> FieldAccessor BundleEntryProto DataType
-> FieldDescriptor BundleEntryProto
forall value msg.
String
-> FieldTypeDescriptor value
-> FieldAccessor msg value
-> FieldDescriptor msg
Data.ProtoLens.FieldDescriptor
              "dtype"
              (ScalarField DataType -> FieldTypeDescriptor DataType
forall value. ScalarField value -> FieldTypeDescriptor value
Data.ProtoLens.ScalarField ScalarField DataType
forall t. MessageEnum t => ScalarField t
Data.ProtoLens.EnumField ::
                 Data.ProtoLens.FieldTypeDescriptor Proto.Tensorflow.Core.Framework.Types.DataType)
              (WireDefault DataType
-> Lens BundleEntryProto BundleEntryProto DataType DataType
-> FieldAccessor BundleEntryProto DataType
forall value msg.
WireDefault value -> Lens' msg value -> FieldAccessor msg value
Data.ProtoLens.PlainField
                 WireDefault DataType
forall value. (FieldDefault value, Eq value) => WireDefault value
Data.ProtoLens.Optional (forall s a (f :: * -> *).
(HasField s "dtype" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"dtype")) ::
              Data.ProtoLens.FieldDescriptor BundleEntryProto
        shape__field_descriptor :: FieldDescriptor BundleEntryProto
shape__field_descriptor
          = String
-> FieldTypeDescriptor TensorShapeProto
-> FieldAccessor BundleEntryProto TensorShapeProto
-> FieldDescriptor BundleEntryProto
forall value msg.
String
-> FieldTypeDescriptor value
-> FieldAccessor msg value
-> FieldDescriptor msg
Data.ProtoLens.FieldDescriptor
              "shape"
              (MessageOrGroup -> FieldTypeDescriptor TensorShapeProto
forall value.
Message value =>
MessageOrGroup -> FieldTypeDescriptor value
Data.ProtoLens.MessageField MessageOrGroup
Data.ProtoLens.MessageType ::
                 Data.ProtoLens.FieldTypeDescriptor Proto.Tensorflow.Core.Framework.TensorShape.TensorShapeProto)
              (Lens
  BundleEntryProto
  BundleEntryProto
  (Maybe TensorShapeProto)
  (Maybe TensorShapeProto)
-> FieldAccessor BundleEntryProto TensorShapeProto
forall msg value.
Lens' msg (Maybe value) -> FieldAccessor msg value
Data.ProtoLens.OptionalField
                 (forall s a (f :: * -> *).
(HasField s "maybe'shape" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"maybe'shape")) ::
              Data.ProtoLens.FieldDescriptor BundleEntryProto
        shardId__field_descriptor :: FieldDescriptor BundleEntryProto
shardId__field_descriptor
          = String
-> FieldTypeDescriptor Int32
-> FieldAccessor BundleEntryProto Int32
-> FieldDescriptor BundleEntryProto
forall value msg.
String
-> FieldTypeDescriptor value
-> FieldAccessor msg value
-> FieldDescriptor msg
Data.ProtoLens.FieldDescriptor
              "shard_id"
              (ScalarField Int32 -> FieldTypeDescriptor Int32
forall value. ScalarField value -> FieldTypeDescriptor value
Data.ProtoLens.ScalarField ScalarField Int32
Data.ProtoLens.Int32Field ::
                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
              (WireDefault Int32
-> Lens BundleEntryProto BundleEntryProto Int32 Int32
-> FieldAccessor BundleEntryProto Int32
forall value msg.
WireDefault value -> Lens' msg value -> FieldAccessor msg value
Data.ProtoLens.PlainField
                 WireDefault Int32
forall value. (FieldDefault value, Eq value) => WireDefault value
Data.ProtoLens.Optional (forall s a (f :: * -> *).
(HasField s "shardId" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"shardId")) ::
              Data.ProtoLens.FieldDescriptor BundleEntryProto
        offset__field_descriptor :: FieldDescriptor BundleEntryProto
offset__field_descriptor
          = String
-> FieldTypeDescriptor Int64
-> FieldAccessor BundleEntryProto Int64
-> FieldDescriptor BundleEntryProto
forall value msg.
String
-> FieldTypeDescriptor value
-> FieldAccessor msg value
-> FieldDescriptor msg
Data.ProtoLens.FieldDescriptor
              "offset"
              (ScalarField Int64 -> FieldTypeDescriptor Int64
forall value. ScalarField value -> FieldTypeDescriptor value
Data.ProtoLens.ScalarField ScalarField Int64
Data.ProtoLens.Int64Field ::
                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
              (WireDefault Int64
-> Lens BundleEntryProto BundleEntryProto Int64 Int64
-> FieldAccessor BundleEntryProto Int64
forall value msg.
WireDefault value -> Lens' msg value -> FieldAccessor msg value
Data.ProtoLens.PlainField
                 WireDefault Int64
forall value. (FieldDefault value, Eq value) => WireDefault value
Data.ProtoLens.Optional (forall s a (f :: * -> *).
(HasField s "offset" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"offset")) ::
              Data.ProtoLens.FieldDescriptor BundleEntryProto
        size__field_descriptor :: FieldDescriptor BundleEntryProto
size__field_descriptor
          = String
-> FieldTypeDescriptor Int64
-> FieldAccessor BundleEntryProto Int64
-> FieldDescriptor BundleEntryProto
forall value msg.
String
-> FieldTypeDescriptor value
-> FieldAccessor msg value
-> FieldDescriptor msg
Data.ProtoLens.FieldDescriptor
              "size"
              (ScalarField Int64 -> FieldTypeDescriptor Int64
forall value. ScalarField value -> FieldTypeDescriptor value
Data.ProtoLens.ScalarField ScalarField Int64
Data.ProtoLens.Int64Field ::
                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
              (WireDefault Int64
-> Lens BundleEntryProto BundleEntryProto Int64 Int64
-> FieldAccessor BundleEntryProto Int64
forall value msg.
WireDefault value -> Lens' msg value -> FieldAccessor msg value
Data.ProtoLens.PlainField
                 WireDefault Int64
forall value. (FieldDefault value, Eq value) => WireDefault value
Data.ProtoLens.Optional (forall s a (f :: * -> *).
(HasField s "size" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"size")) ::
              Data.ProtoLens.FieldDescriptor BundleEntryProto
        crc32c__field_descriptor :: FieldDescriptor BundleEntryProto
crc32c__field_descriptor
          = String
-> FieldTypeDescriptor Word32
-> FieldAccessor BundleEntryProto Word32
-> FieldDescriptor BundleEntryProto
forall value msg.
String
-> FieldTypeDescriptor value
-> FieldAccessor msg value
-> FieldDescriptor msg
Data.ProtoLens.FieldDescriptor
              "crc32c"
              (ScalarField Word32 -> FieldTypeDescriptor Word32
forall value. ScalarField value -> FieldTypeDescriptor value
Data.ProtoLens.ScalarField ScalarField Word32
Data.ProtoLens.Fixed32Field ::
                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word32)
              (WireDefault Word32
-> Lens BundleEntryProto BundleEntryProto Word32 Word32
-> FieldAccessor BundleEntryProto Word32
forall value msg.
WireDefault value -> Lens' msg value -> FieldAccessor msg value
Data.ProtoLens.PlainField
                 WireDefault Word32
forall value. (FieldDefault value, Eq value) => WireDefault value
Data.ProtoLens.Optional (forall s a (f :: * -> *).
(HasField s "crc32c" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"crc32c")) ::
              Data.ProtoLens.FieldDescriptor BundleEntryProto
        slices__field_descriptor :: FieldDescriptor BundleEntryProto
slices__field_descriptor
          = String
-> FieldTypeDescriptor TensorSliceProto
-> FieldAccessor BundleEntryProto TensorSliceProto
-> FieldDescriptor BundleEntryProto
forall value msg.
String
-> FieldTypeDescriptor value
-> FieldAccessor msg value
-> FieldDescriptor msg
Data.ProtoLens.FieldDescriptor
              "slices"
              (MessageOrGroup -> FieldTypeDescriptor TensorSliceProto
forall value.
Message value =>
MessageOrGroup -> FieldTypeDescriptor value
Data.ProtoLens.MessageField MessageOrGroup
Data.ProtoLens.MessageType ::
                 Data.ProtoLens.FieldTypeDescriptor Proto.Tensorflow.Core.Framework.TensorSlice.TensorSliceProto)
              (Packing
-> Lens' BundleEntryProto [TensorSliceProto]
-> FieldAccessor BundleEntryProto TensorSliceProto
forall msg value.
Packing -> Lens' msg [value] -> FieldAccessor msg value
Data.ProtoLens.RepeatedField
                 Packing
Data.ProtoLens.Unpacked (forall s a (f :: * -> *).
(HasField s "slices" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"slices")) ::
              Data.ProtoLens.FieldDescriptor BundleEntryProto
      in
        [(Tag, FieldDescriptor BundleEntryProto)]
-> Map Tag (FieldDescriptor BundleEntryProto)
forall k a. Ord k => [(k, a)] -> Map k a
Data.Map.fromList
          [(Int -> Tag
Data.ProtoLens.Tag 1, FieldDescriptor BundleEntryProto
dtype__field_descriptor),
           (Int -> Tag
Data.ProtoLens.Tag 2, FieldDescriptor BundleEntryProto
shape__field_descriptor),
           (Int -> Tag
Data.ProtoLens.Tag 3, FieldDescriptor BundleEntryProto
shardId__field_descriptor),
           (Int -> Tag
Data.ProtoLens.Tag 4, FieldDescriptor BundleEntryProto
offset__field_descriptor),
           (Int -> Tag
Data.ProtoLens.Tag 5, FieldDescriptor BundleEntryProto
size__field_descriptor),
           (Int -> Tag
Data.ProtoLens.Tag 6, FieldDescriptor BundleEntryProto
crc32c__field_descriptor),
           (Int -> Tag
Data.ProtoLens.Tag 7, FieldDescriptor BundleEntryProto
slices__field_descriptor)]
  unknownFields :: LensLike' f BundleEntryProto FieldSet
unknownFields
    = (BundleEntryProto -> FieldSet)
-> (BundleEntryProto -> FieldSet -> BundleEntryProto)
-> Lens' BundleEntryProto FieldSet
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
        BundleEntryProto -> FieldSet
_BundleEntryProto'_unknownFields
        (\ x__ :: BundleEntryProto
x__ y__ :: FieldSet
y__ -> BundleEntryProto
x__ {_BundleEntryProto'_unknownFields :: FieldSet
_BundleEntryProto'_unknownFields = FieldSet
y__})
  defMessage :: BundleEntryProto
defMessage
    = $WBundleEntryProto'_constructor :: DataType
-> Maybe TensorShapeProto
-> Int32
-> Int64
-> Int64
-> Word32
-> Vector TensorSliceProto
-> FieldSet
-> BundleEntryProto
BundleEntryProto'_constructor
        {_BundleEntryProto'dtype :: DataType
_BundleEntryProto'dtype = DataType
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault,
         _BundleEntryProto'shape :: Maybe TensorShapeProto
_BundleEntryProto'shape = Maybe TensorShapeProto
forall a. Maybe a
Prelude.Nothing,
         _BundleEntryProto'shardId :: Int32
_BundleEntryProto'shardId = Int32
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault,
         _BundleEntryProto'offset :: Int64
_BundleEntryProto'offset = Int64
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault,
         _BundleEntryProto'size :: Int64
_BundleEntryProto'size = Int64
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault,
         _BundleEntryProto'crc32c :: Word32
_BundleEntryProto'crc32c = Word32
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault,
         _BundleEntryProto'slices :: Vector TensorSliceProto
_BundleEntryProto'slices = Vector TensorSliceProto
forall (v :: * -> *) a. Vector v a => v a
Data.Vector.Generic.empty,
         _BundleEntryProto'_unknownFields :: FieldSet
_BundleEntryProto'_unknownFields = []}
  parseMessage :: Parser BundleEntryProto
parseMessage
    = let
        loop ::
          BundleEntryProto
          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Proto.Tensorflow.Core.Framework.TensorSlice.TensorSliceProto
             -> Data.ProtoLens.Encoding.Bytes.Parser BundleEntryProto
        loop :: BundleEntryProto
-> Growing Vector RealWorld TensorSliceProto
-> Parser BundleEntryProto
loop x :: BundleEntryProto
x mutable'slices :: Growing Vector RealWorld TensorSliceProto
mutable'slices
          = do Bool
end <- Parser Bool
Data.ProtoLens.Encoding.Bytes.atEnd
               if Bool
end then
                   do Vector TensorSliceProto
frozen'slices <- IO (Vector TensorSliceProto) -> Parser (Vector TensorSliceProto)
forall a. IO a -> Parser a
Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                         (Growing Vector (PrimState IO) TensorSliceProto
-> IO (Vector TensorSliceProto)
forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Growing v (PrimState m) a -> m (v a)
Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                            Growing Vector RealWorld TensorSliceProto
Growing Vector (PrimState IO) TensorSliceProto
mutable'slices)
                      (let missing :: [a]
missing = []
                       in
                         if [Any] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
Prelude.null [Any]
forall a. [a]
missing then
                             () -> Parser ()
forall (m :: * -> *) a. Monad m => a -> m a
Prelude.return ()
                         else
                             String -> Parser ()
forall (m :: * -> *) a. MonadFail m => String -> m a
Prelude.fail
                               (String -> ShowS
forall a. [a] -> [a] -> [a]
(Prelude.++)
                                  "Missing required fields: "
                                  ([String] -> String
forall a. Show a => a -> String
Prelude.show ([String]
forall a. [a]
missing :: [Prelude.String]))))
                      BundleEntryProto -> Parser BundleEntryProto
forall (m :: * -> *) a. Monad m => a -> m a
Prelude.return
                        (Setter BundleEntryProto BundleEntryProto FieldSet FieldSet
-> (FieldSet -> FieldSet) -> BundleEntryProto -> BundleEntryProto
forall s t a b. Setter s t a b -> (a -> b) -> s -> t
Lens.Family2.over
                           forall msg. Message msg => Lens' msg FieldSet
Setter BundleEntryProto BundleEntryProto FieldSet FieldSet
Data.ProtoLens.unknownFields
                           (\ !FieldSet
t -> FieldSet -> FieldSet
forall a. [a] -> [a]
Prelude.reverse FieldSet
t)
                           (Setter
  BundleEntryProto
  BundleEntryProto
  (Vector TensorSliceProto)
  (Vector TensorSliceProto)
-> Vector TensorSliceProto -> BundleEntryProto -> BundleEntryProto
forall s t a b. Setter s t a b -> b -> s -> t
Lens.Family2.set
                              (forall s a (f :: * -> *).
(HasField s "vec'slices" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"vec'slices") Vector TensorSliceProto
frozen'slices BundleEntryProto
x))
               else
                   do Word64
tag <- Parser Word64
Data.ProtoLens.Encoding.Bytes.getVarInt
                      case Word64
tag of
                        8 -> do DataType
y <- Parser DataType -> String -> Parser DataType
forall a. Parser a -> String -> Parser a
(Data.ProtoLens.Encoding.Bytes.<?>)
                                       ((Int -> DataType) -> Parser Int -> Parser DataType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.fmap
                                          Int -> DataType
forall a. Enum a => Int -> a
Prelude.toEnum
                                          ((Word64 -> Int) -> Parser Word64 -> Parser Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.fmap
                                             Word64 -> Int
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral
                                             Parser Word64
Data.ProtoLens.Encoding.Bytes.getVarInt))
                                       "dtype"
                                BundleEntryProto
-> Growing Vector RealWorld TensorSliceProto
-> Parser BundleEntryProto
loop
                                  (Setter BundleEntryProto BundleEntryProto DataType DataType
-> DataType -> BundleEntryProto -> BundleEntryProto
forall s t a b. Setter s t a b -> b -> s -> t
Lens.Family2.set (forall s a (f :: * -> *).
(HasField s "dtype" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"dtype") DataType
y BundleEntryProto
x)
                                  Growing Vector RealWorld TensorSliceProto
mutable'slices
                        18
                          -> do TensorShapeProto
y <- Parser TensorShapeProto -> String -> Parser TensorShapeProto
forall a. Parser a -> String -> Parser a
(Data.ProtoLens.Encoding.Bytes.<?>)
                                       (do Word64
len <- Parser Word64
Data.ProtoLens.Encoding.Bytes.getVarInt
                                           Int -> Parser TensorShapeProto -> Parser TensorShapeProto
forall a. Int -> Parser a -> Parser a
Data.ProtoLens.Encoding.Bytes.isolate
                                             (Word64 -> Int
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral Word64
len) Parser TensorShapeProto
forall msg. Message msg => Parser msg
Data.ProtoLens.parseMessage)
                                       "shape"
                                BundleEntryProto
-> Growing Vector RealWorld TensorSliceProto
-> Parser BundleEntryProto
loop
                                  (Setter
  BundleEntryProto BundleEntryProto TensorShapeProto TensorShapeProto
-> TensorShapeProto -> BundleEntryProto -> BundleEntryProto
forall s t a b. Setter s t a b -> b -> s -> t
Lens.Family2.set (forall s a (f :: * -> *).
(HasField s "shape" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"shape") TensorShapeProto
y BundleEntryProto
x)
                                  Growing Vector RealWorld TensorSliceProto
mutable'slices
                        24
                          -> do Int32
y <- Parser Int32 -> String -> Parser Int32
forall a. Parser a -> String -> Parser a
(Data.ProtoLens.Encoding.Bytes.<?>)
                                       ((Word64 -> Int32) -> Parser Word64 -> Parser Int32
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.fmap
                                          Word64 -> Int32
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral
                                          Parser Word64
Data.ProtoLens.Encoding.Bytes.getVarInt)
                                       "shard_id"
                                BundleEntryProto
-> Growing Vector RealWorld TensorSliceProto
-> Parser BundleEntryProto
loop
                                  (Setter BundleEntryProto BundleEntryProto Int32 Int32
-> Int32 -> BundleEntryProto -> BundleEntryProto
forall s t a b. Setter s t a b -> b -> s -> t
Lens.Family2.set (forall s a (f :: * -> *).
(HasField s "shardId" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"shardId") Int32
y BundleEntryProto
x)
                                  Growing Vector RealWorld TensorSliceProto
mutable'slices
                        32
                          -> do Int64
y <- Parser Int64 -> String -> Parser Int64
forall a. Parser a -> String -> Parser a
(Data.ProtoLens.Encoding.Bytes.<?>)
                                       ((Word64 -> Int64) -> Parser Word64 -> Parser Int64
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.fmap
                                          Word64 -> Int64
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral
                                          Parser Word64
Data.ProtoLens.Encoding.Bytes.getVarInt)
                                       "offset"
                                BundleEntryProto
-> Growing Vector RealWorld TensorSliceProto
-> Parser BundleEntryProto
loop
                                  (Setter BundleEntryProto BundleEntryProto Int64 Int64
-> Int64 -> BundleEntryProto -> BundleEntryProto
forall s t a b. Setter s t a b -> b -> s -> t
Lens.Family2.set (forall s a (f :: * -> *).
(HasField s "offset" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"offset") Int64
y BundleEntryProto
x)
                                  Growing Vector RealWorld TensorSliceProto
mutable'slices
                        40
                          -> do Int64
y <- Parser Int64 -> String -> Parser Int64
forall a. Parser a -> String -> Parser a
(Data.ProtoLens.Encoding.Bytes.<?>)
                                       ((Word64 -> Int64) -> Parser Word64 -> Parser Int64
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.fmap
                                          Word64 -> Int64
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral
                                          Parser Word64
Data.ProtoLens.Encoding.Bytes.getVarInt)
                                       "size"
                                BundleEntryProto
-> Growing Vector RealWorld TensorSliceProto
-> Parser BundleEntryProto
loop
                                  (Setter BundleEntryProto BundleEntryProto Int64 Int64
-> Int64 -> BundleEntryProto -> BundleEntryProto
forall s t a b. Setter s t a b -> b -> s -> t
Lens.Family2.set (forall s a (f :: * -> *).
(HasField s "size" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"size") Int64
y BundleEntryProto
x)
                                  Growing Vector RealWorld TensorSliceProto
mutable'slices
                        53
                          -> do Word32
y <- Parser Word32 -> String -> Parser Word32
forall a. Parser a -> String -> Parser a
(Data.ProtoLens.Encoding.Bytes.<?>)
                                       Parser Word32
Data.ProtoLens.Encoding.Bytes.getFixed32 "crc32c"
                                BundleEntryProto
-> Growing Vector RealWorld TensorSliceProto
-> Parser BundleEntryProto
loop
                                  (Setter BundleEntryProto BundleEntryProto Word32 Word32
-> Word32 -> BundleEntryProto -> BundleEntryProto
forall s t a b. Setter s t a b -> b -> s -> t
Lens.Family2.set (forall s a (f :: * -> *).
(HasField s "crc32c" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"crc32c") Word32
y BundleEntryProto
x)
                                  Growing Vector RealWorld TensorSliceProto
mutable'slices
                        58
                          -> do !TensorSliceProto
y <- Parser TensorSliceProto -> String -> Parser TensorSliceProto
forall a. Parser a -> String -> Parser a
(Data.ProtoLens.Encoding.Bytes.<?>)
                                        (do Word64
len <- Parser Word64
Data.ProtoLens.Encoding.Bytes.getVarInt
                                            Int -> Parser TensorSliceProto -> Parser TensorSliceProto
forall a. Int -> Parser a -> Parser a
Data.ProtoLens.Encoding.Bytes.isolate
                                              (Word64 -> Int
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral Word64
len)
                                              Parser TensorSliceProto
forall msg. Message msg => Parser msg
Data.ProtoLens.parseMessage)
                                        "slices"
                                Growing Vector RealWorld TensorSliceProto
v <- IO (Growing Vector RealWorld TensorSliceProto)
-> Parser (Growing Vector RealWorld TensorSliceProto)
forall a. IO a -> Parser a
Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                       (Growing Vector (PrimState IO) TensorSliceProto
-> TensorSliceProto
-> IO (Growing Vector (PrimState IO) TensorSliceProto)
forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Growing v (PrimState m) a -> a -> m (Growing v (PrimState m) a)
Data.ProtoLens.Encoding.Growing.append Growing Vector RealWorld TensorSliceProto
Growing Vector (PrimState IO) TensorSliceProto
mutable'slices TensorSliceProto
y)
                                BundleEntryProto
-> Growing Vector RealWorld TensorSliceProto
-> Parser BundleEntryProto
loop BundleEntryProto
x Growing Vector RealWorld TensorSliceProto
v
                        wire :: Word64
wire
                          -> do !TaggedValue
y <- Word64 -> Parser TaggedValue
Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                        Word64
wire
                                BundleEntryProto
-> Growing Vector RealWorld TensorSliceProto
-> Parser BundleEntryProto
loop
                                  (Setter BundleEntryProto BundleEntryProto FieldSet FieldSet
-> (FieldSet -> FieldSet) -> BundleEntryProto -> BundleEntryProto
forall s t a b. Setter s t a b -> (a -> b) -> s -> t
Lens.Family2.over
                                     forall msg. Message msg => Lens' msg FieldSet
Setter BundleEntryProto BundleEntryProto FieldSet FieldSet
Data.ProtoLens.unknownFields (\ !FieldSet
t -> (:) TaggedValue
y FieldSet
t) BundleEntryProto
x)
                                  Growing Vector RealWorld TensorSliceProto
mutable'slices
      in
        Parser BundleEntryProto -> String -> Parser BundleEntryProto
forall a. Parser a -> String -> Parser a
(Data.ProtoLens.Encoding.Bytes.<?>)
          (do Growing Vector RealWorld TensorSliceProto
mutable'slices <- IO (Growing Vector RealWorld TensorSliceProto)
-> Parser (Growing Vector RealWorld TensorSliceProto)
forall a. IO a -> Parser a
Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                  IO (Growing Vector RealWorld TensorSliceProto)
forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
m (Growing v (PrimState m) a)
Data.ProtoLens.Encoding.Growing.new
              BundleEntryProto
-> Growing Vector RealWorld TensorSliceProto
-> Parser BundleEntryProto
loop BundleEntryProto
forall msg. Message msg => msg
Data.ProtoLens.defMessage Growing Vector RealWorld TensorSliceProto
mutable'slices)
          "BundleEntryProto"
  buildMessage :: BundleEntryProto -> Builder
buildMessage
    = \ _x :: BundleEntryProto
_x
        -> Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
             (let
                _v :: DataType
_v = FoldLike
  DataType BundleEntryProto BundleEntryProto DataType DataType
-> BundleEntryProto -> DataType
forall a s t b. FoldLike a s t a b -> s -> a
Lens.Family2.view (forall s a (f :: * -> *).
(HasField s "dtype" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"dtype") BundleEntryProto
_x
              in
                if DataType -> DataType -> Bool
forall a. Eq a => a -> a -> Bool
(Prelude.==) DataType
_v DataType
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault then
                    Builder
forall a. Monoid a => a
Data.Monoid.mempty
                else
                    Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                      (Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt 8)
                      ((Int -> Builder) -> (DataType -> Int) -> DataType -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
                         ((Word64 -> Builder) -> (Int -> Word64) -> Int -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
                            Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt Int -> Word64
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral)
                         DataType -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum
                         DataType
_v))
             (Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                (case
                     FoldLike
  (Maybe TensorShapeProto)
  BundleEntryProto
  BundleEntryProto
  (Maybe TensorShapeProto)
  (Maybe TensorShapeProto)
-> BundleEntryProto -> Maybe TensorShapeProto
forall a s t b. FoldLike a s t a b -> s -> a
Lens.Family2.view (forall s a (f :: * -> *).
(HasField s "maybe'shape" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"maybe'shape") BundleEntryProto
_x
                 of
                   Prelude.Nothing -> Builder
forall a. Monoid a => a
Data.Monoid.mempty
                   (Prelude.Just _v :: TensorShapeProto
_v)
                     -> Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                          (Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt 18)
                          ((ByteString -> Builder)
-> (TensorShapeProto -> ByteString) -> TensorShapeProto -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
                             (\ bs :: ByteString
bs
                                -> Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                                     (Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt
                                        (Int -> Word64
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral (ByteString -> Int
Data.ByteString.length ByteString
bs)))
                                     (ByteString -> Builder
Data.ProtoLens.Encoding.Bytes.putBytes ByteString
bs))
                             TensorShapeProto -> ByteString
forall msg. Message msg => msg -> ByteString
Data.ProtoLens.encodeMessage
                             TensorShapeProto
_v))
                (Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                   (let
                      _v :: Int32
_v = FoldLike Int32 BundleEntryProto BundleEntryProto Int32 Int32
-> BundleEntryProto -> Int32
forall a s t b. FoldLike a s t a b -> s -> a
Lens.Family2.view (forall s a (f :: * -> *).
(HasField s "shardId" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"shardId") BundleEntryProto
_x
                    in
                      if Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
(Prelude.==) Int32
_v Int32
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault then
                          Builder
forall a. Monoid a => a
Data.Monoid.mempty
                      else
                          Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                            (Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt 24)
                            ((Word64 -> Builder) -> (Int32 -> Word64) -> Int32 -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
                               Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt Int32 -> Word64
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral Int32
_v))
                   (Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                      (let
                         _v :: Int64
_v = FoldLike Int64 BundleEntryProto BundleEntryProto Int64 Int64
-> BundleEntryProto -> Int64
forall a s t b. FoldLike a s t a b -> s -> a
Lens.Family2.view (forall s a (f :: * -> *).
(HasField s "offset" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"offset") BundleEntryProto
_x
                       in
                         if Int64 -> Int64 -> Bool
forall a. Eq a => a -> a -> Bool
(Prelude.==) Int64
_v Int64
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault then
                             Builder
forall a. Monoid a => a
Data.Monoid.mempty
                         else
                             Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                               (Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt 32)
                               ((Word64 -> Builder) -> (Int64 -> Word64) -> Int64 -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
                                  Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt Int64 -> Word64
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral Int64
_v))
                      (Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                         (let _v :: Int64
_v = FoldLike Int64 BundleEntryProto BundleEntryProto Int64 Int64
-> BundleEntryProto -> Int64
forall a s t b. FoldLike a s t a b -> s -> a
Lens.Family2.view (forall s a (f :: * -> *).
(HasField s "size" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"size") BundleEntryProto
_x
                          in
                            if Int64 -> Int64 -> Bool
forall a. Eq a => a -> a -> Bool
(Prelude.==) Int64
_v Int64
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault then
                                Builder
forall a. Monoid a => a
Data.Monoid.mempty
                            else
                                Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                                  (Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt 40)
                                  ((Word64 -> Builder) -> (Int64 -> Word64) -> Int64 -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
                                     Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt
                                     Int64 -> Word64
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral
                                     Int64
_v))
                         (Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                            (let
                               _v :: Word32
_v = FoldLike Word32 BundleEntryProto BundleEntryProto Word32 Word32
-> BundleEntryProto -> Word32
forall a s t b. FoldLike a s t a b -> s -> a
Lens.Family2.view (forall s a (f :: * -> *).
(HasField s "crc32c" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"crc32c") BundleEntryProto
_x
                             in
                               if Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
(Prelude.==) Word32
_v Word32
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault then
                                   Builder
forall a. Monoid a => a
Data.Monoid.mempty
                               else
                                   Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                                     (Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt 53)
                                     (Word32 -> Builder
Data.ProtoLens.Encoding.Bytes.putFixed32 Word32
_v))
                            (Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                               ((TensorSliceProto -> Builder) -> Vector TensorSliceProto -> Builder
forall (v :: * -> *) a.
Vector v a =>
(a -> Builder) -> v a -> Builder
Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                                  (\ _v :: TensorSliceProto
_v
                                     -> Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                                          (Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt 58)
                                          ((ByteString -> Builder)
-> (TensorSliceProto -> ByteString) -> TensorSliceProto -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
                                             (\ bs :: ByteString
bs
                                                -> Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                                                     (Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt
                                                        (Int -> Word64
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral
                                                           (ByteString -> Int
Data.ByteString.length ByteString
bs)))
                                                     (ByteString -> Builder
Data.ProtoLens.Encoding.Bytes.putBytes ByteString
bs))
                                             TensorSliceProto -> ByteString
forall msg. Message msg => msg -> ByteString
Data.ProtoLens.encodeMessage
                                             TensorSliceProto
_v))
                                  (FoldLike
  (Vector TensorSliceProto)
  BundleEntryProto
  BundleEntryProto
  (Vector TensorSliceProto)
  (Vector TensorSliceProto)
-> BundleEntryProto -> Vector TensorSliceProto
forall a s t b. FoldLike a s t a b -> s -> a
Lens.Family2.view (forall s a (f :: * -> *).
(HasField s "vec'slices" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"vec'slices") BundleEntryProto
_x))
                               (FieldSet -> Builder
Data.ProtoLens.Encoding.Wire.buildFieldSet
                                  (FoldLike
  FieldSet BundleEntryProto BundleEntryProto FieldSet FieldSet
-> BundleEntryProto -> FieldSet
forall a s t b. FoldLike a s t a b -> s -> a
Lens.Family2.view FoldLike
  FieldSet BundleEntryProto BundleEntryProto FieldSet FieldSet
forall msg. Message msg => Lens' msg FieldSet
Data.ProtoLens.unknownFields BundleEntryProto
_x))))))))
instance Control.DeepSeq.NFData BundleEntryProto where
  rnf :: BundleEntryProto -> ()
rnf
    = \ x__ :: BundleEntryProto
x__
        -> FieldSet -> () -> ()
forall a b. NFData a => a -> b -> b
Control.DeepSeq.deepseq
             (BundleEntryProto -> FieldSet
_BundleEntryProto'_unknownFields BundleEntryProto
x__)
             (DataType -> () -> ()
forall a b. NFData a => a -> b -> b
Control.DeepSeq.deepseq
                (BundleEntryProto -> DataType
_BundleEntryProto'dtype BundleEntryProto
x__)
                (Maybe TensorShapeProto -> () -> ()
forall a b. NFData a => a -> b -> b
Control.DeepSeq.deepseq
                   (BundleEntryProto -> Maybe TensorShapeProto
_BundleEntryProto'shape BundleEntryProto
x__)
                   (Int32 -> () -> ()
forall a b. NFData a => a -> b -> b
Control.DeepSeq.deepseq
                      (BundleEntryProto -> Int32
_BundleEntryProto'shardId BundleEntryProto
x__)
                      (Int64 -> () -> ()
forall a b. NFData a => a -> b -> b
Control.DeepSeq.deepseq
                         (BundleEntryProto -> Int64
_BundleEntryProto'offset BundleEntryProto
x__)
                         (Int64 -> () -> ()
forall a b. NFData a => a -> b -> b
Control.DeepSeq.deepseq
                            (BundleEntryProto -> Int64
_BundleEntryProto'size BundleEntryProto
x__)
                            (Word32 -> () -> ()
forall a b. NFData a => a -> b -> b
Control.DeepSeq.deepseq
                               (BundleEntryProto -> Word32
_BundleEntryProto'crc32c BundleEntryProto
x__)
                               (Vector TensorSliceProto -> () -> ()
forall a b. NFData a => a -> b -> b
Control.DeepSeq.deepseq (BundleEntryProto -> Vector TensorSliceProto
_BundleEntryProto'slices BundleEntryProto
x__) ())))))))
{- | Fields :
     
         * 'Proto.Tensorflow.Core.Protobuf.TensorBundle_Fields.numShards' @:: Lens' BundleHeaderProto Data.Int.Int32@
         * 'Proto.Tensorflow.Core.Protobuf.TensorBundle_Fields.endianness' @:: Lens' BundleHeaderProto BundleHeaderProto'Endianness@
         * 'Proto.Tensorflow.Core.Protobuf.TensorBundle_Fields.version' @:: Lens' BundleHeaderProto Proto.Tensorflow.Core.Framework.Versions.VersionDef@
         * 'Proto.Tensorflow.Core.Protobuf.TensorBundle_Fields.maybe'version' @:: Lens' BundleHeaderProto (Prelude.Maybe Proto.Tensorflow.Core.Framework.Versions.VersionDef)@ -}
data BundleHeaderProto
  = BundleHeaderProto'_constructor {BundleHeaderProto -> Int32
_BundleHeaderProto'numShards :: !Data.Int.Int32,
                                    BundleHeaderProto -> BundleHeaderProto'Endianness
_BundleHeaderProto'endianness :: !BundleHeaderProto'Endianness,
                                    BundleHeaderProto -> Maybe VersionDef
_BundleHeaderProto'version :: !(Prelude.Maybe Proto.Tensorflow.Core.Framework.Versions.VersionDef),
                                    BundleHeaderProto -> FieldSet
_BundleHeaderProto'_unknownFields :: !Data.ProtoLens.FieldSet}
  deriving stock (BundleHeaderProto -> BundleHeaderProto -> Bool
(BundleHeaderProto -> BundleHeaderProto -> Bool)
-> (BundleHeaderProto -> BundleHeaderProto -> Bool)
-> Eq BundleHeaderProto
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BundleHeaderProto -> BundleHeaderProto -> Bool
$c/= :: BundleHeaderProto -> BundleHeaderProto -> Bool
== :: BundleHeaderProto -> BundleHeaderProto -> Bool
$c== :: BundleHeaderProto -> BundleHeaderProto -> Bool
Prelude.Eq, Eq BundleHeaderProto
Eq BundleHeaderProto =>
(BundleHeaderProto -> BundleHeaderProto -> Ordering)
-> (BundleHeaderProto -> BundleHeaderProto -> Bool)
-> (BundleHeaderProto -> BundleHeaderProto -> Bool)
-> (BundleHeaderProto -> BundleHeaderProto -> Bool)
-> (BundleHeaderProto -> BundleHeaderProto -> Bool)
-> (BundleHeaderProto -> BundleHeaderProto -> BundleHeaderProto)
-> (BundleHeaderProto -> BundleHeaderProto -> BundleHeaderProto)
-> Ord BundleHeaderProto
BundleHeaderProto -> BundleHeaderProto -> Bool
BundleHeaderProto -> BundleHeaderProto -> Ordering
BundleHeaderProto -> BundleHeaderProto -> BundleHeaderProto
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BundleHeaderProto -> BundleHeaderProto -> BundleHeaderProto
$cmin :: BundleHeaderProto -> BundleHeaderProto -> BundleHeaderProto
max :: BundleHeaderProto -> BundleHeaderProto -> BundleHeaderProto
$cmax :: BundleHeaderProto -> BundleHeaderProto -> BundleHeaderProto
>= :: BundleHeaderProto -> BundleHeaderProto -> Bool
$c>= :: BundleHeaderProto -> BundleHeaderProto -> Bool
> :: BundleHeaderProto -> BundleHeaderProto -> Bool
$c> :: BundleHeaderProto -> BundleHeaderProto -> Bool
<= :: BundleHeaderProto -> BundleHeaderProto -> Bool
$c<= :: BundleHeaderProto -> BundleHeaderProto -> Bool
< :: BundleHeaderProto -> BundleHeaderProto -> Bool
$c< :: BundleHeaderProto -> BundleHeaderProto -> Bool
compare :: BundleHeaderProto -> BundleHeaderProto -> Ordering
$ccompare :: BundleHeaderProto -> BundleHeaderProto -> Ordering
$cp1Ord :: Eq BundleHeaderProto
Prelude.Ord)
instance Prelude.Show BundleHeaderProto where
  showsPrec :: Int -> BundleHeaderProto -> ShowS
showsPrec _ __x :: BundleHeaderProto
__x __s :: String
__s
    = Char -> ShowS
Prelude.showChar
        '{'
        (String -> ShowS
Prelude.showString
           (BundleHeaderProto -> String
forall msg. Message msg => msg -> String
Data.ProtoLens.showMessageShort BundleHeaderProto
__x) (Char -> ShowS
Prelude.showChar '}' String
__s))
instance Data.ProtoLens.Field.HasField BundleHeaderProto "numShards" Data.Int.Int32 where
  fieldOf :: Proxy# "numShards"
-> (Int32 -> f Int32) -> BundleHeaderProto -> f BundleHeaderProto
fieldOf _
    = ((Int32 -> f Int32) -> BundleHeaderProto -> f BundleHeaderProto)
-> ((Int32 -> f Int32) -> Int32 -> f Int32)
-> (Int32 -> f Int32)
-> BundleHeaderProto
-> f BundleHeaderProto
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
        ((BundleHeaderProto -> Int32)
-> (BundleHeaderProto -> Int32 -> BundleHeaderProto)
-> Lens BundleHeaderProto BundleHeaderProto Int32 Int32
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           BundleHeaderProto -> Int32
_BundleHeaderProto'numShards
           (\ x__ :: BundleHeaderProto
x__ y__ :: Int32
y__ -> BundleHeaderProto
x__ {_BundleHeaderProto'numShards :: Int32
_BundleHeaderProto'numShards = Int32
y__}))
        (Int32 -> f Int32) -> Int32 -> f Int32
forall a. a -> a
Prelude.id
instance Data.ProtoLens.Field.HasField BundleHeaderProto "endianness" BundleHeaderProto'Endianness where
  fieldOf :: Proxy# "endianness"
-> (BundleHeaderProto'Endianness -> f BundleHeaderProto'Endianness)
-> BundleHeaderProto
-> f BundleHeaderProto
fieldOf _
    = ((BundleHeaderProto'Endianness -> f BundleHeaderProto'Endianness)
 -> BundleHeaderProto -> f BundleHeaderProto)
-> ((BundleHeaderProto'Endianness
     -> f BundleHeaderProto'Endianness)
    -> BundleHeaderProto'Endianness -> f BundleHeaderProto'Endianness)
-> (BundleHeaderProto'Endianness -> f BundleHeaderProto'Endianness)
-> BundleHeaderProto
-> f BundleHeaderProto
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
        ((BundleHeaderProto -> BundleHeaderProto'Endianness)
-> (BundleHeaderProto
    -> BundleHeaderProto'Endianness -> BundleHeaderProto)
-> Lens
     BundleHeaderProto
     BundleHeaderProto
     BundleHeaderProto'Endianness
     BundleHeaderProto'Endianness
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           BundleHeaderProto -> BundleHeaderProto'Endianness
_BundleHeaderProto'endianness
           (\ x__ :: BundleHeaderProto
x__ y__ :: BundleHeaderProto'Endianness
y__ -> BundleHeaderProto
x__ {_BundleHeaderProto'endianness :: BundleHeaderProto'Endianness
_BundleHeaderProto'endianness = BundleHeaderProto'Endianness
y__}))
        (BundleHeaderProto'Endianness -> f BundleHeaderProto'Endianness)
-> BundleHeaderProto'Endianness -> f BundleHeaderProto'Endianness
forall a. a -> a
Prelude.id
instance Data.ProtoLens.Field.HasField BundleHeaderProto "version" Proto.Tensorflow.Core.Framework.Versions.VersionDef where
  fieldOf :: Proxy# "version"
-> (VersionDef -> f VersionDef)
-> BundleHeaderProto
-> f BundleHeaderProto
fieldOf _
    = ((Maybe VersionDef -> f (Maybe VersionDef))
 -> BundleHeaderProto -> f BundleHeaderProto)
-> ((VersionDef -> f VersionDef)
    -> Maybe VersionDef -> f (Maybe VersionDef))
-> (VersionDef -> f VersionDef)
-> BundleHeaderProto
-> f BundleHeaderProto
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
        ((BundleHeaderProto -> Maybe VersionDef)
-> (BundleHeaderProto -> Maybe VersionDef -> BundleHeaderProto)
-> Lens
     BundleHeaderProto
     BundleHeaderProto
     (Maybe VersionDef)
     (Maybe VersionDef)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           BundleHeaderProto -> Maybe VersionDef
_BundleHeaderProto'version
           (\ x__ :: BundleHeaderProto
x__ y__ :: Maybe VersionDef
y__ -> BundleHeaderProto
x__ {_BundleHeaderProto'version :: Maybe VersionDef
_BundleHeaderProto'version = Maybe VersionDef
y__}))
        (VersionDef -> Lens' (Maybe VersionDef) VersionDef
forall b. b -> Lens' (Maybe b) b
Data.ProtoLens.maybeLens VersionDef
forall msg. Message msg => msg
Data.ProtoLens.defMessage)
instance Data.ProtoLens.Field.HasField BundleHeaderProto "maybe'version" (Prelude.Maybe Proto.Tensorflow.Core.Framework.Versions.VersionDef) where
  fieldOf :: Proxy# "maybe'version"
-> (Maybe VersionDef -> f (Maybe VersionDef))
-> BundleHeaderProto
-> f BundleHeaderProto
fieldOf _
    = ((Maybe VersionDef -> f (Maybe VersionDef))
 -> BundleHeaderProto -> f BundleHeaderProto)
-> ((Maybe VersionDef -> f (Maybe VersionDef))
    -> Maybe VersionDef -> f (Maybe VersionDef))
-> (Maybe VersionDef -> f (Maybe VersionDef))
-> BundleHeaderProto
-> f BundleHeaderProto
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
        ((BundleHeaderProto -> Maybe VersionDef)
-> (BundleHeaderProto -> Maybe VersionDef -> BundleHeaderProto)
-> Lens
     BundleHeaderProto
     BundleHeaderProto
     (Maybe VersionDef)
     (Maybe VersionDef)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
           BundleHeaderProto -> Maybe VersionDef
_BundleHeaderProto'version
           (\ x__ :: BundleHeaderProto
x__ y__ :: Maybe VersionDef
y__ -> BundleHeaderProto
x__ {_BundleHeaderProto'version :: Maybe VersionDef
_BundleHeaderProto'version = Maybe VersionDef
y__}))
        (Maybe VersionDef -> f (Maybe VersionDef))
-> Maybe VersionDef -> f (Maybe VersionDef)
forall a. a -> a
Prelude.id
instance Data.ProtoLens.Message BundleHeaderProto where
  messageName :: Proxy BundleHeaderProto -> Text
messageName _ = String -> Text
Data.Text.pack "tensorflow.BundleHeaderProto"
  packedMessageDescriptor :: Proxy BundleHeaderProto -> ByteString
packedMessageDescriptor _
    = "\n\
      \\DC1BundleHeaderProto\DC2\GS\n\
      \\n\
      \num_shards\CAN\SOH \SOH(\ENQR\tnumShards\DC2H\n\
      \\n\
      \endianness\CAN\STX \SOH(\SO2(.tensorflow.BundleHeaderProto.EndiannessR\n\
      \endianness\DC20\n\
      \\aversion\CAN\ETX \SOH(\v2\SYN.tensorflow.VersionDefR\aversion\"!\n\
      \\n\
      \Endianness\DC2\n\
      \\n\
      \\ACKLITTLE\DLE\NUL\DC2\a\n\
      \\ETXBIG\DLE\SOH"
  packedFileDescriptor :: Proxy BundleHeaderProto -> ByteString
packedFileDescriptor _ = ByteString
packedFileDescriptor
  fieldsByTag :: Map Tag (FieldDescriptor BundleHeaderProto)
fieldsByTag
    = let
        numShards__field_descriptor :: FieldDescriptor BundleHeaderProto
numShards__field_descriptor
          = String
-> FieldTypeDescriptor Int32
-> FieldAccessor BundleHeaderProto Int32
-> FieldDescriptor BundleHeaderProto
forall value msg.
String
-> FieldTypeDescriptor value
-> FieldAccessor msg value
-> FieldDescriptor msg
Data.ProtoLens.FieldDescriptor
              "num_shards"
              (ScalarField Int32 -> FieldTypeDescriptor Int32
forall value. ScalarField value -> FieldTypeDescriptor value
Data.ProtoLens.ScalarField ScalarField Int32
Data.ProtoLens.Int32Field ::
                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
              (WireDefault Int32
-> Lens BundleHeaderProto BundleHeaderProto Int32 Int32
-> FieldAccessor BundleHeaderProto Int32
forall value msg.
WireDefault value -> Lens' msg value -> FieldAccessor msg value
Data.ProtoLens.PlainField
                 WireDefault Int32
forall value. (FieldDefault value, Eq value) => WireDefault value
Data.ProtoLens.Optional
                 (forall s a (f :: * -> *).
(HasField s "numShards" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"numShards")) ::
              Data.ProtoLens.FieldDescriptor BundleHeaderProto
        endianness__field_descriptor :: FieldDescriptor BundleHeaderProto
endianness__field_descriptor
          = String
-> FieldTypeDescriptor BundleHeaderProto'Endianness
-> FieldAccessor BundleHeaderProto BundleHeaderProto'Endianness
-> FieldDescriptor BundleHeaderProto
forall value msg.
String
-> FieldTypeDescriptor value
-> FieldAccessor msg value
-> FieldDescriptor msg
Data.ProtoLens.FieldDescriptor
              "endianness"
              (ScalarField BundleHeaderProto'Endianness
-> FieldTypeDescriptor BundleHeaderProto'Endianness
forall value. ScalarField value -> FieldTypeDescriptor value
Data.ProtoLens.ScalarField ScalarField BundleHeaderProto'Endianness
forall t. MessageEnum t => ScalarField t
Data.ProtoLens.EnumField ::
                 Data.ProtoLens.FieldTypeDescriptor BundleHeaderProto'Endianness)
              (WireDefault BundleHeaderProto'Endianness
-> Lens
     BundleHeaderProto
     BundleHeaderProto
     BundleHeaderProto'Endianness
     BundleHeaderProto'Endianness
-> FieldAccessor BundleHeaderProto BundleHeaderProto'Endianness
forall value msg.
WireDefault value -> Lens' msg value -> FieldAccessor msg value
Data.ProtoLens.PlainField
                 WireDefault BundleHeaderProto'Endianness
forall value. (FieldDefault value, Eq value) => WireDefault value
Data.ProtoLens.Optional
                 (forall s a (f :: * -> *).
(HasField s "endianness" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"endianness")) ::
              Data.ProtoLens.FieldDescriptor BundleHeaderProto
        version__field_descriptor :: FieldDescriptor BundleHeaderProto
version__field_descriptor
          = String
-> FieldTypeDescriptor VersionDef
-> FieldAccessor BundleHeaderProto VersionDef
-> FieldDescriptor BundleHeaderProto
forall value msg.
String
-> FieldTypeDescriptor value
-> FieldAccessor msg value
-> FieldDescriptor msg
Data.ProtoLens.FieldDescriptor
              "version"
              (MessageOrGroup -> FieldTypeDescriptor VersionDef
forall value.
Message value =>
MessageOrGroup -> FieldTypeDescriptor value
Data.ProtoLens.MessageField MessageOrGroup
Data.ProtoLens.MessageType ::
                 Data.ProtoLens.FieldTypeDescriptor Proto.Tensorflow.Core.Framework.Versions.VersionDef)
              (Lens
  BundleHeaderProto
  BundleHeaderProto
  (Maybe VersionDef)
  (Maybe VersionDef)
-> FieldAccessor BundleHeaderProto VersionDef
forall msg value.
Lens' msg (Maybe value) -> FieldAccessor msg value
Data.ProtoLens.OptionalField
                 (forall s a (f :: * -> *).
(HasField s "maybe'version" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"maybe'version")) ::
              Data.ProtoLens.FieldDescriptor BundleHeaderProto
      in
        [(Tag, FieldDescriptor BundleHeaderProto)]
-> Map Tag (FieldDescriptor BundleHeaderProto)
forall k a. Ord k => [(k, a)] -> Map k a
Data.Map.fromList
          [(Int -> Tag
Data.ProtoLens.Tag 1, FieldDescriptor BundleHeaderProto
numShards__field_descriptor),
           (Int -> Tag
Data.ProtoLens.Tag 2, FieldDescriptor BundleHeaderProto
endianness__field_descriptor),
           (Int -> Tag
Data.ProtoLens.Tag 3, FieldDescriptor BundleHeaderProto
version__field_descriptor)]
  unknownFields :: LensLike' f BundleHeaderProto FieldSet
unknownFields
    = (BundleHeaderProto -> FieldSet)
-> (BundleHeaderProto -> FieldSet -> BundleHeaderProto)
-> Lens' BundleHeaderProto FieldSet
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.Family2.Unchecked.lens
        BundleHeaderProto -> FieldSet
_BundleHeaderProto'_unknownFields
        (\ x__ :: BundleHeaderProto
x__ y__ :: FieldSet
y__ -> BundleHeaderProto
x__ {_BundleHeaderProto'_unknownFields :: FieldSet
_BundleHeaderProto'_unknownFields = FieldSet
y__})
  defMessage :: BundleHeaderProto
defMessage
    = $WBundleHeaderProto'_constructor :: Int32
-> BundleHeaderProto'Endianness
-> Maybe VersionDef
-> FieldSet
-> BundleHeaderProto
BundleHeaderProto'_constructor
        {_BundleHeaderProto'numShards :: Int32
_BundleHeaderProto'numShards = Int32
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault,
         _BundleHeaderProto'endianness :: BundleHeaderProto'Endianness
_BundleHeaderProto'endianness = BundleHeaderProto'Endianness
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault,
         _BundleHeaderProto'version :: Maybe VersionDef
_BundleHeaderProto'version = Maybe VersionDef
forall a. Maybe a
Prelude.Nothing,
         _BundleHeaderProto'_unknownFields :: FieldSet
_BundleHeaderProto'_unknownFields = []}
  parseMessage :: Parser BundleHeaderProto
parseMessage
    = let
        loop ::
          BundleHeaderProto
          -> Data.ProtoLens.Encoding.Bytes.Parser BundleHeaderProto
        loop :: BundleHeaderProto -> Parser BundleHeaderProto
loop x :: BundleHeaderProto
x
          = do Bool
end <- Parser Bool
Data.ProtoLens.Encoding.Bytes.atEnd
               if Bool
end then
                   do (let missing :: [a]
missing = []
                       in
                         if [Any] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
Prelude.null [Any]
forall a. [a]
missing then
                             () -> Parser ()
forall (m :: * -> *) a. Monad m => a -> m a
Prelude.return ()
                         else
                             String -> Parser ()
forall (m :: * -> *) a. MonadFail m => String -> m a
Prelude.fail
                               (String -> ShowS
forall a. [a] -> [a] -> [a]
(Prelude.++)
                                  "Missing required fields: "
                                  ([String] -> String
forall a. Show a => a -> String
Prelude.show ([String]
forall a. [a]
missing :: [Prelude.String]))))
                      BundleHeaderProto -> Parser BundleHeaderProto
forall (m :: * -> *) a. Monad m => a -> m a
Prelude.return
                        (Setter BundleHeaderProto BundleHeaderProto FieldSet FieldSet
-> (FieldSet -> FieldSet) -> BundleHeaderProto -> BundleHeaderProto
forall s t a b. Setter s t a b -> (a -> b) -> s -> t
Lens.Family2.over
                           forall msg. Message msg => Lens' msg FieldSet
Setter BundleHeaderProto BundleHeaderProto FieldSet FieldSet
Data.ProtoLens.unknownFields (\ !FieldSet
t -> FieldSet -> FieldSet
forall a. [a] -> [a]
Prelude.reverse FieldSet
t) BundleHeaderProto
x)
               else
                   do Word64
tag <- Parser Word64
Data.ProtoLens.Encoding.Bytes.getVarInt
                      case Word64
tag of
                        8 -> do Int32
y <- Parser Int32 -> String -> Parser Int32
forall a. Parser a -> String -> Parser a
(Data.ProtoLens.Encoding.Bytes.<?>)
                                       ((Word64 -> Int32) -> Parser Word64 -> Parser Int32
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.fmap
                                          Word64 -> Int32
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral
                                          Parser Word64
Data.ProtoLens.Encoding.Bytes.getVarInt)
                                       "num_shards"
                                BundleHeaderProto -> Parser BundleHeaderProto
loop
                                  (Setter BundleHeaderProto BundleHeaderProto Int32 Int32
-> Int32 -> BundleHeaderProto -> BundleHeaderProto
forall s t a b. Setter s t a b -> b -> s -> t
Lens.Family2.set (forall s a (f :: * -> *).
(HasField s "numShards" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"numShards") Int32
y BundleHeaderProto
x)
                        16
                          -> do BundleHeaderProto'Endianness
y <- Parser BundleHeaderProto'Endianness
-> String -> Parser BundleHeaderProto'Endianness
forall a. Parser a -> String -> Parser a
(Data.ProtoLens.Encoding.Bytes.<?>)
                                       ((Int -> BundleHeaderProto'Endianness)
-> Parser Int -> Parser BundleHeaderProto'Endianness
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.fmap
                                          Int -> BundleHeaderProto'Endianness
forall a. Enum a => Int -> a
Prelude.toEnum
                                          ((Word64 -> Int) -> Parser Word64 -> Parser Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.fmap
                                             Word64 -> Int
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral
                                             Parser Word64
Data.ProtoLens.Encoding.Bytes.getVarInt))
                                       "endianness"
                                BundleHeaderProto -> Parser BundleHeaderProto
loop
                                  (Setter
  BundleHeaderProto
  BundleHeaderProto
  BundleHeaderProto'Endianness
  BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness
-> BundleHeaderProto
-> BundleHeaderProto
forall s t a b. Setter s t a b -> b -> s -> t
Lens.Family2.set (forall s a (f :: * -> *).
(HasField s "endianness" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"endianness") BundleHeaderProto'Endianness
y BundleHeaderProto
x)
                        26
                          -> do VersionDef
y <- Parser VersionDef -> String -> Parser VersionDef
forall a. Parser a -> String -> Parser a
(Data.ProtoLens.Encoding.Bytes.<?>)
                                       (do Word64
len <- Parser Word64
Data.ProtoLens.Encoding.Bytes.getVarInt
                                           Int -> Parser VersionDef -> Parser VersionDef
forall a. Int -> Parser a -> Parser a
Data.ProtoLens.Encoding.Bytes.isolate
                                             (Word64 -> Int
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral Word64
len) Parser VersionDef
forall msg. Message msg => Parser msg
Data.ProtoLens.parseMessage)
                                       "version"
                                BundleHeaderProto -> Parser BundleHeaderProto
loop (Setter BundleHeaderProto BundleHeaderProto VersionDef VersionDef
-> VersionDef -> BundleHeaderProto -> BundleHeaderProto
forall s t a b. Setter s t a b -> b -> s -> t
Lens.Family2.set (forall s a (f :: * -> *).
(HasField s "version" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"version") VersionDef
y BundleHeaderProto
x)
                        wire :: Word64
wire
                          -> do !TaggedValue
y <- Word64 -> Parser TaggedValue
Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                        Word64
wire
                                BundleHeaderProto -> Parser BundleHeaderProto
loop
                                  (Setter BundleHeaderProto BundleHeaderProto FieldSet FieldSet
-> (FieldSet -> FieldSet) -> BundleHeaderProto -> BundleHeaderProto
forall s t a b. Setter s t a b -> (a -> b) -> s -> t
Lens.Family2.over
                                     forall msg. Message msg => Lens' msg FieldSet
Setter BundleHeaderProto BundleHeaderProto FieldSet FieldSet
Data.ProtoLens.unknownFields (\ !FieldSet
t -> (:) TaggedValue
y FieldSet
t) BundleHeaderProto
x)
      in
        Parser BundleHeaderProto -> String -> Parser BundleHeaderProto
forall a. Parser a -> String -> Parser a
(Data.ProtoLens.Encoding.Bytes.<?>)
          (do BundleHeaderProto -> Parser BundleHeaderProto
loop BundleHeaderProto
forall msg. Message msg => msg
Data.ProtoLens.defMessage) "BundleHeaderProto"
  buildMessage :: BundleHeaderProto -> Builder
buildMessage
    = \ _x :: BundleHeaderProto
_x
        -> Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
             (let
                _v :: Int32
_v = FoldLike Int32 BundleHeaderProto BundleHeaderProto Int32 Int32
-> BundleHeaderProto -> Int32
forall a s t b. FoldLike a s t a b -> s -> a
Lens.Family2.view (forall s a (f :: * -> *).
(HasField s "numShards" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"numShards") BundleHeaderProto
_x
              in
                if Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
(Prelude.==) Int32
_v Int32
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault then
                    Builder
forall a. Monoid a => a
Data.Monoid.mempty
                else
                    Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                      (Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt 8)
                      ((Word64 -> Builder) -> (Int32 -> Word64) -> Int32 -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
                         Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt Int32 -> Word64
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral Int32
_v))
             (Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                (let
                   _v :: BundleHeaderProto'Endianness
_v
                     = FoldLike
  BundleHeaderProto'Endianness
  BundleHeaderProto
  BundleHeaderProto
  BundleHeaderProto'Endianness
  BundleHeaderProto'Endianness
-> BundleHeaderProto -> BundleHeaderProto'Endianness
forall a s t b. FoldLike a s t a b -> s -> a
Lens.Family2.view (forall s a (f :: * -> *).
(HasField s "endianness" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"endianness") BundleHeaderProto
_x
                 in
                   if BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
forall a. Eq a => a -> a -> Bool
(Prelude.==) BundleHeaderProto'Endianness
_v BundleHeaderProto'Endianness
forall value. FieldDefault value => value
Data.ProtoLens.fieldDefault then
                       Builder
forall a. Monoid a => a
Data.Monoid.mempty
                   else
                       Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                         (Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt 16)
                         ((Int -> Builder)
-> (BundleHeaderProto'Endianness -> Int)
-> BundleHeaderProto'Endianness
-> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
                            ((Word64 -> Builder) -> (Int -> Word64) -> Int -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
                               Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt Int -> Word64
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral)
                            BundleHeaderProto'Endianness -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum
                            BundleHeaderProto'Endianness
_v))
                (Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                   (case
                        FoldLike
  (Maybe VersionDef)
  BundleHeaderProto
  BundleHeaderProto
  (Maybe VersionDef)
  (Maybe VersionDef)
-> BundleHeaderProto -> Maybe VersionDef
forall a s t b. FoldLike a s t a b -> s -> a
Lens.Family2.view (forall s a (f :: * -> *).
(HasField s "maybe'version" a, Functor f) =>
(a -> f a) -> s -> f s
forall (x :: Symbol) s a (f :: * -> *).
(HasField s x a, Functor f) =>
(a -> f a) -> s -> f s
Data.ProtoLens.Field.field @"maybe'version") BundleHeaderProto
_x
                    of
                      Prelude.Nothing -> Builder
forall a. Monoid a => a
Data.Monoid.mempty
                      (Prelude.Just _v :: VersionDef
_v)
                        -> Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                             (Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt 26)
                             ((ByteString -> Builder)
-> (VersionDef -> ByteString) -> VersionDef -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
(Prelude..)
                                (\ bs :: ByteString
bs
                                   -> Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
(Data.Monoid.<>)
                                        (Word64 -> Builder
Data.ProtoLens.Encoding.Bytes.putVarInt
                                           (Int -> Word64
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral (ByteString -> Int
Data.ByteString.length ByteString
bs)))
                                        (ByteString -> Builder
Data.ProtoLens.Encoding.Bytes.putBytes ByteString
bs))
                                VersionDef -> ByteString
forall msg. Message msg => msg -> ByteString
Data.ProtoLens.encodeMessage
                                VersionDef
_v))
                   (FieldSet -> Builder
Data.ProtoLens.Encoding.Wire.buildFieldSet
                      (FoldLike
  FieldSet BundleHeaderProto BundleHeaderProto FieldSet FieldSet
-> BundleHeaderProto -> FieldSet
forall a s t b. FoldLike a s t a b -> s -> a
Lens.Family2.view FoldLike
  FieldSet BundleHeaderProto BundleHeaderProto FieldSet FieldSet
forall msg. Message msg => Lens' msg FieldSet
Data.ProtoLens.unknownFields BundleHeaderProto
_x))))
instance Control.DeepSeq.NFData BundleHeaderProto where
  rnf :: BundleHeaderProto -> ()
rnf
    = \ x__ :: BundleHeaderProto
x__
        -> FieldSet -> () -> ()
forall a b. NFData a => a -> b -> b
Control.DeepSeq.deepseq
             (BundleHeaderProto -> FieldSet
_BundleHeaderProto'_unknownFields BundleHeaderProto
x__)
             (Int32 -> () -> ()
forall a b. NFData a => a -> b -> b
Control.DeepSeq.deepseq
                (BundleHeaderProto -> Int32
_BundleHeaderProto'numShards BundleHeaderProto
x__)
                (BundleHeaderProto'Endianness -> () -> ()
forall a b. NFData a => a -> b -> b
Control.DeepSeq.deepseq
                   (BundleHeaderProto -> BundleHeaderProto'Endianness
_BundleHeaderProto'endianness BundleHeaderProto
x__)
                   (Maybe VersionDef -> () -> ()
forall a b. NFData a => a -> b -> b
Control.DeepSeq.deepseq (BundleHeaderProto -> Maybe VersionDef
_BundleHeaderProto'version BundleHeaderProto
x__) ())))
newtype BundleHeaderProto'Endianness'UnrecognizedValue
  = BundleHeaderProto'Endianness'UnrecognizedValue Data.Int.Int32
  deriving stock (BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
(BundleHeaderProto'Endianness'UnrecognizedValue
 -> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool)
-> (BundleHeaderProto'Endianness'UnrecognizedValue
    -> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool)
-> Eq BundleHeaderProto'Endianness'UnrecognizedValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
$c/= :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
== :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
$c== :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
Prelude.Eq, Eq BundleHeaderProto'Endianness'UnrecognizedValue
Eq BundleHeaderProto'Endianness'UnrecognizedValue =>
(BundleHeaderProto'Endianness'UnrecognizedValue
 -> BundleHeaderProto'Endianness'UnrecognizedValue -> Ordering)
-> (BundleHeaderProto'Endianness'UnrecognizedValue
    -> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool)
-> (BundleHeaderProto'Endianness'UnrecognizedValue
    -> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool)
-> (BundleHeaderProto'Endianness'UnrecognizedValue
    -> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool)
-> (BundleHeaderProto'Endianness'UnrecognizedValue
    -> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool)
-> (BundleHeaderProto'Endianness'UnrecognizedValue
    -> BundleHeaderProto'Endianness'UnrecognizedValue
    -> BundleHeaderProto'Endianness'UnrecognizedValue)
-> (BundleHeaderProto'Endianness'UnrecognizedValue
    -> BundleHeaderProto'Endianness'UnrecognizedValue
    -> BundleHeaderProto'Endianness'UnrecognizedValue)
-> Ord BundleHeaderProto'Endianness'UnrecognizedValue
BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Ordering
BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue
$cmin :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue
max :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue
$cmax :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue
>= :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
$c>= :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
> :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
$c> :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
<= :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
$c<= :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
< :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
$c< :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Bool
compare :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Ordering
$ccompare :: BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness'UnrecognizedValue -> Ordering
$cp1Ord :: Eq BundleHeaderProto'Endianness'UnrecognizedValue
Prelude.Ord, Int -> BundleHeaderProto'Endianness'UnrecognizedValue -> ShowS
[BundleHeaderProto'Endianness'UnrecognizedValue] -> ShowS
BundleHeaderProto'Endianness'UnrecognizedValue -> String
(Int -> BundleHeaderProto'Endianness'UnrecognizedValue -> ShowS)
-> (BundleHeaderProto'Endianness'UnrecognizedValue -> String)
-> ([BundleHeaderProto'Endianness'UnrecognizedValue] -> ShowS)
-> Show BundleHeaderProto'Endianness'UnrecognizedValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BundleHeaderProto'Endianness'UnrecognizedValue] -> ShowS
$cshowList :: [BundleHeaderProto'Endianness'UnrecognizedValue] -> ShowS
show :: BundleHeaderProto'Endianness'UnrecognizedValue -> String
$cshow :: BundleHeaderProto'Endianness'UnrecognizedValue -> String
showsPrec :: Int -> BundleHeaderProto'Endianness'UnrecognizedValue -> ShowS
$cshowsPrec :: Int -> BundleHeaderProto'Endianness'UnrecognizedValue -> ShowS
Prelude.Show)
data BundleHeaderProto'Endianness
  = BundleHeaderProto'LITTLE |
    BundleHeaderProto'BIG |
    BundleHeaderProto'Endianness'Unrecognized !BundleHeaderProto'Endianness'UnrecognizedValue
  deriving stock (Int -> BundleHeaderProto'Endianness -> ShowS
[BundleHeaderProto'Endianness] -> ShowS
BundleHeaderProto'Endianness -> String
(Int -> BundleHeaderProto'Endianness -> ShowS)
-> (BundleHeaderProto'Endianness -> String)
-> ([BundleHeaderProto'Endianness] -> ShowS)
-> Show BundleHeaderProto'Endianness
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BundleHeaderProto'Endianness] -> ShowS
$cshowList :: [BundleHeaderProto'Endianness] -> ShowS
show :: BundleHeaderProto'Endianness -> String
$cshow :: BundleHeaderProto'Endianness -> String
showsPrec :: Int -> BundleHeaderProto'Endianness -> ShowS
$cshowsPrec :: Int -> BundleHeaderProto'Endianness -> ShowS
Prelude.Show, BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
(BundleHeaderProto'Endianness
 -> BundleHeaderProto'Endianness -> Bool)
-> (BundleHeaderProto'Endianness
    -> BundleHeaderProto'Endianness -> Bool)
-> Eq BundleHeaderProto'Endianness
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
$c/= :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
== :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
$c== :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
Prelude.Eq, Eq BundleHeaderProto'Endianness
Eq BundleHeaderProto'Endianness =>
(BundleHeaderProto'Endianness
 -> BundleHeaderProto'Endianness -> Ordering)
-> (BundleHeaderProto'Endianness
    -> BundleHeaderProto'Endianness -> Bool)
-> (BundleHeaderProto'Endianness
    -> BundleHeaderProto'Endianness -> Bool)
-> (BundleHeaderProto'Endianness
    -> BundleHeaderProto'Endianness -> Bool)
-> (BundleHeaderProto'Endianness
    -> BundleHeaderProto'Endianness -> Bool)
-> (BundleHeaderProto'Endianness
    -> BundleHeaderProto'Endianness -> BundleHeaderProto'Endianness)
-> (BundleHeaderProto'Endianness
    -> BundleHeaderProto'Endianness -> BundleHeaderProto'Endianness)
-> Ord BundleHeaderProto'Endianness
BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Ordering
BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> BundleHeaderProto'Endianness
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> BundleHeaderProto'Endianness
$cmin :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> BundleHeaderProto'Endianness
max :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> BundleHeaderProto'Endianness
$cmax :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> BundleHeaderProto'Endianness
>= :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
$c>= :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
> :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
$c> :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
<= :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
$c<= :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
< :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
$c< :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Bool
compare :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Ordering
$ccompare :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> Ordering
$cp1Ord :: Eq BundleHeaderProto'Endianness
Prelude.Ord)
instance Data.ProtoLens.MessageEnum BundleHeaderProto'Endianness where
  maybeToEnum :: Int -> Maybe BundleHeaderProto'Endianness
maybeToEnum 0 = BundleHeaderProto'Endianness -> Maybe BundleHeaderProto'Endianness
forall a. a -> Maybe a
Prelude.Just BundleHeaderProto'Endianness
BundleHeaderProto'LITTLE
  maybeToEnum 1 = BundleHeaderProto'Endianness -> Maybe BundleHeaderProto'Endianness
forall a. a -> Maybe a
Prelude.Just BundleHeaderProto'Endianness
BundleHeaderProto'BIG
  maybeToEnum k :: Int
k
    = BundleHeaderProto'Endianness -> Maybe BundleHeaderProto'Endianness
forall a. a -> Maybe a
Prelude.Just
        (BundleHeaderProto'Endianness'UnrecognizedValue
-> BundleHeaderProto'Endianness
BundleHeaderProto'Endianness'Unrecognized
           (Int32 -> BundleHeaderProto'Endianness'UnrecognizedValue
BundleHeaderProto'Endianness'UnrecognizedValue
              (Int -> Int32
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral Int
k)))
  showEnum :: BundleHeaderProto'Endianness -> String
showEnum BundleHeaderProto'LITTLE = "LITTLE"
  showEnum BundleHeaderProto'BIG = "BIG"
  showEnum
    (BundleHeaderProto'Endianness'Unrecognized (BundleHeaderProto'Endianness'UnrecognizedValue k :: Int32
k))
    = Int32 -> String
forall a. Show a => a -> String
Prelude.show Int32
k
  readEnum :: String -> Maybe BundleHeaderProto'Endianness
readEnum k :: String
k
    | String -> String -> Bool
forall a. Eq a => a -> a -> Bool
(Prelude.==) String
k "LITTLE" = BundleHeaderProto'Endianness -> Maybe BundleHeaderProto'Endianness
forall a. a -> Maybe a
Prelude.Just BundleHeaderProto'Endianness
BundleHeaderProto'LITTLE
    | String -> String -> Bool
forall a. Eq a => a -> a -> Bool
(Prelude.==) String
k "BIG" = BundleHeaderProto'Endianness -> Maybe BundleHeaderProto'Endianness
forall a. a -> Maybe a
Prelude.Just BundleHeaderProto'Endianness
BundleHeaderProto'BIG
    | Bool
Prelude.otherwise
    = Maybe Int
-> (Int -> Maybe BundleHeaderProto'Endianness)
-> Maybe BundleHeaderProto'Endianness
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
(Prelude.>>=) (String -> Maybe Int
forall a. Read a => String -> Maybe a
Text.Read.readMaybe String
k) Int -> Maybe BundleHeaderProto'Endianness
forall a. MessageEnum a => Int -> Maybe a
Data.ProtoLens.maybeToEnum
instance Prelude.Bounded BundleHeaderProto'Endianness where
  minBound :: BundleHeaderProto'Endianness
minBound = BundleHeaderProto'Endianness
BundleHeaderProto'LITTLE
  maxBound :: BundleHeaderProto'Endianness
maxBound = BundleHeaderProto'Endianness
BundleHeaderProto'BIG
instance Prelude.Enum BundleHeaderProto'Endianness where
  toEnum :: Int -> BundleHeaderProto'Endianness
toEnum k__ :: Int
k__
    = BundleHeaderProto'Endianness
-> (BundleHeaderProto'Endianness -> BundleHeaderProto'Endianness)
-> Maybe BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness
forall b a. b -> (a -> b) -> Maybe a -> b
Prelude.maybe
        (String -> BundleHeaderProto'Endianness
forall a. HasCallStack => String -> a
Prelude.error
           (String -> ShowS
forall a. [a] -> [a] -> [a]
(Prelude.++)
              "toEnum: unknown value for enum Endianness: " (Int -> String
forall a. Show a => a -> String
Prelude.show Int
k__)))
        BundleHeaderProto'Endianness -> BundleHeaderProto'Endianness
forall a. a -> a
Prelude.id
        (Int -> Maybe BundleHeaderProto'Endianness
forall a. MessageEnum a => Int -> Maybe a
Data.ProtoLens.maybeToEnum Int
k__)
  fromEnum :: BundleHeaderProto'Endianness -> Int
fromEnum BundleHeaderProto'LITTLE = 0
  fromEnum BundleHeaderProto'BIG = 1
  fromEnum
    (BundleHeaderProto'Endianness'Unrecognized (BundleHeaderProto'Endianness'UnrecognizedValue k :: Int32
k))
    = Int32 -> Int
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral Int32
k
  succ :: BundleHeaderProto'Endianness -> BundleHeaderProto'Endianness
succ BundleHeaderProto'BIG
    = String -> BundleHeaderProto'Endianness
forall a. HasCallStack => String -> a
Prelude.error
        "BundleHeaderProto'Endianness.succ: bad argument BundleHeaderProto'BIG. This value would be out of bounds."
  succ BundleHeaderProto'LITTLE = BundleHeaderProto'Endianness
BundleHeaderProto'BIG
  succ (BundleHeaderProto'Endianness'Unrecognized _)
    = String -> BundleHeaderProto'Endianness
forall a. HasCallStack => String -> a
Prelude.error
        "BundleHeaderProto'Endianness.succ: bad argument: unrecognized value"
  pred :: BundleHeaderProto'Endianness -> BundleHeaderProto'Endianness
pred BundleHeaderProto'LITTLE
    = String -> BundleHeaderProto'Endianness
forall a. HasCallStack => String -> a
Prelude.error
        "BundleHeaderProto'Endianness.pred: bad argument BundleHeaderProto'LITTLE. This value would be out of bounds."
  pred BundleHeaderProto'BIG = BundleHeaderProto'Endianness
BundleHeaderProto'LITTLE
  pred (BundleHeaderProto'Endianness'Unrecognized _)
    = String -> BundleHeaderProto'Endianness
forall a. HasCallStack => String -> a
Prelude.error
        "BundleHeaderProto'Endianness.pred: bad argument: unrecognized value"
  enumFrom :: BundleHeaderProto'Endianness -> [BundleHeaderProto'Endianness]
enumFrom = BundleHeaderProto'Endianness -> [BundleHeaderProto'Endianness]
forall a. (Enum a, Bounded a) => a -> [a]
Data.ProtoLens.Message.Enum.messageEnumFrom
  enumFromTo :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> [BundleHeaderProto'Endianness]
enumFromTo = BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> [BundleHeaderProto'Endianness]
forall a. Enum a => a -> a -> [a]
Data.ProtoLens.Message.Enum.messageEnumFromTo
  enumFromThen :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> [BundleHeaderProto'Endianness]
enumFromThen = BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness -> [BundleHeaderProto'Endianness]
forall a. (Enum a, Bounded a) => a -> a -> [a]
Data.ProtoLens.Message.Enum.messageEnumFromThen
  enumFromThenTo :: BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness
-> [BundleHeaderProto'Endianness]
enumFromThenTo = BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness
-> BundleHeaderProto'Endianness
-> [BundleHeaderProto'Endianness]
forall a. Enum a => a -> a -> a -> [a]
Data.ProtoLens.Message.Enum.messageEnumFromThenTo
instance Data.ProtoLens.FieldDefault BundleHeaderProto'Endianness where
  fieldDefault :: BundleHeaderProto'Endianness
fieldDefault = BundleHeaderProto'Endianness
BundleHeaderProto'LITTLE
instance Control.DeepSeq.NFData BundleHeaderProto'Endianness where
  rnf :: BundleHeaderProto'Endianness -> ()
rnf x__ :: BundleHeaderProto'Endianness
x__ = BundleHeaderProto'Endianness -> () -> ()
forall a b. a -> b -> b
Prelude.seq BundleHeaderProto'Endianness
x__ ()
packedFileDescriptor :: Data.ByteString.ByteString
packedFileDescriptor :: ByteString
packedFileDescriptor
  = "\n\
    \,tensorflow/core/protobuf/tensor_bundle.proto\DC2\n\
    \tensorflow\SUB,tensorflow/core/framework/tensor_shape.proto\SUB,tensorflow/core/framework/tensor_slice.proto\SUB%tensorflow/core/framework/types.proto\SUB(tensorflow/core/framework/versions.proto\"\209\SOH\n\
    \\DC1BundleHeaderProto\DC2\GS\n\
    \\n\
    \num_shards\CAN\SOH \SOH(\ENQR\tnumShards\DC2H\n\
    \\n\
    \endianness\CAN\STX \SOH(\SO2(.tensorflow.BundleHeaderProto.EndiannessR\n\
    \endianness\DC20\n\
    \\aversion\CAN\ETX \SOH(\v2\SYN.tensorflow.VersionDefR\aversion\"!\n\
    \\n\
    \Endianness\DC2\n\
    \\n\
    \\ACKLITTLE\DLE\NUL\DC2\a\n\
    \\ETXBIG\DLE\SOH\"\135\STX\n\
    \\DLEBundleEntryProto\DC2*\n\
    \\ENQdtype\CAN\SOH \SOH(\SO2\DC4.tensorflow.DataTypeR\ENQdtype\DC22\n\
    \\ENQshape\CAN\STX \SOH(\v2\FS.tensorflow.TensorShapeProtoR\ENQshape\DC2\EM\n\
    \\bshard_id\CAN\ETX \SOH(\ENQR\ashardId\DC2\SYN\n\
    \\ACKoffset\CAN\EOT \SOH(\ETXR\ACKoffset\DC2\DC2\n\
    \\EOTsize\CAN\ENQ \SOH(\ETXR\EOTsize\DC2\SYN\n\
    \\ACKcrc32c\CAN\ACK \SOH(\aR\ACKcrc32c\DC24\n\
    \\ACKslices\CAN\a \ETX(\v2\FS.tensorflow.TensorSliceProtoR\ACKslicesBx\n\
    \\DC3org.tensorflow.utilB\DC2TensorBundleProtosP\SOHZHgithub.com/tensorflow/tensorflow/tensorflow/go/core/core_protos_go_proto\248\SOH\SOHJ\174\DC2\n\
    \\ACK\DC2\EOT\NUL\NULA\SOH\n\
    \\b\n\
    \\SOH\f\DC2\ETX\NUL\NUL\DC2\n\
    \\b\n\
    \\SOH\STX\DC2\ETX\STX\NUL\DC3\n\
    \\t\n\
    \\STX\ETX\NUL\DC2\ETX\EOT\NUL6\n\
    \\t\n\
    \\STX\ETX\SOH\DC2\ETX\ENQ\NUL6\n\
    \\t\n\
    \\STX\ETX\STX\DC2\ETX\ACK\NUL/\n\
    \\t\n\
    \\STX\ETX\ETX\DC2\ETX\a\NUL2\n\
    \\b\n\
    \\SOH\b\DC2\ETX\t\NUL\US\n\
    \\t\n\
    \\STX\b\US\DC2\ETX\t\NUL\US\n\
    \\b\n\
    \\SOH\b\DC2\ETX\n\
    \\NUL3\n\
    \\t\n\
    \\STX\b\b\DC2\ETX\n\
    \\NUL3\n\
    \\b\n\
    \\SOH\b\DC2\ETX\v\NUL\"\n\
    \\t\n\
    \\STX\b\n\
    \\DC2\ETX\v\NUL\"\n\
    \\b\n\
    \\SOH\b\DC2\ETX\f\NUL,\n\
    \\t\n\
    \\STX\b\SOH\DC2\ETX\f\NUL,\n\
    \\b\n\
    \\SOH\b\DC2\ETX\r\NUL_\n\
    \\t\n\
    \\STX\b\v\DC2\ETX\r\NUL_\n\
    \\251\ETX\n\
    \\STX\EOT\NUL\DC2\EOT\CAN\NUL)\SOH\SUB\164\ETX Special header that is associated with a bundle.\n\
    \\n\
    \ TODO(zongheng,zhifengc): maybe in the future, we can add information about\n\
    \ which binary produced this checkpoint, timestamp, etc. Sometime, these can be\n\
    \ valuable debugging information. And if needed, these can be used as defensive\n\
    \ information ensuring reader (binary version) of the checkpoint and the writer\n\
    \ (binary version) must match within certain range, etc.\n\
    \2H Protos used in the tensor bundle module (tf/core/util/tensor_bundle/).\n\
    \\n\
    \\n\
    \\n\
    \\ETX\EOT\NUL\SOH\DC2\ETX\CAN\b\EM\n\
    \2\n\
    \\EOT\EOT\NUL\STX\NUL\DC2\ETX\SUB\STX\ETB\SUB% Number of data files in the bundle.\n\
    \\n\
    \\f\n\
    \\ENQ\EOT\NUL\STX\NUL\ENQ\DC2\ETX\SUB\STX\a\n\
    \\f\n\
    \\ENQ\EOT\NUL\STX\NUL\SOH\DC2\ETX\SUB\b\DC2\n\
    \\f\n\
    \\ENQ\EOT\NUL\STX\NUL\ETX\DC2\ETX\SUB\NAK\SYN\n\
    \\174\STX\n\
    \\EOT\EOT\NUL\EOT\NUL\DC2\EOT!\STX$\ETX\SUB\159\STX An enum indicating the endianness of the platform that produced this\n\
    \ bundle.  A bundle can only be read by a platform with matching endianness.\n\
    \ Defaults to LITTLE, as most modern platforms are little-endian.\n\
    \\n\
    \ Affects the binary tensor data bytes only, not the metadata in protobufs.\n\
    \\n\
    \\f\n\
    \\ENQ\EOT\NUL\EOT\NUL\SOH\DC2\ETX!\a\DC1\n\
    \\r\n\
    \\ACK\EOT\NUL\EOT\NUL\STX\NUL\DC2\ETX\"\EOT\SI\n\
    \\SO\n\
    \\a\EOT\NUL\EOT\NUL\STX\NUL\SOH\DC2\ETX\"\EOT\n\
    \\n\
    \\SO\n\
    \\a\EOT\NUL\EOT\NUL\STX\NUL\STX\DC2\ETX\"\r\SO\n\
    \\r\n\
    \\ACK\EOT\NUL\EOT\NUL\STX\SOH\DC2\ETX#\EOT\f\n\
    \\SO\n\
    \\a\EOT\NUL\EOT\NUL\STX\SOH\SOH\DC2\ETX#\EOT\a\n\
    \\SO\n\
    \\a\EOT\NUL\EOT\NUL\STX\SOH\STX\DC2\ETX#\n\
    \\v\n\
    \\v\n\
    \\EOT\EOT\NUL\STX\SOH\DC2\ETX%\STX\FS\n\
    \\f\n\
    \\ENQ\EOT\NUL\STX\SOH\ACK\DC2\ETX%\STX\f\n\
    \\f\n\
    \\ENQ\EOT\NUL\STX\SOH\SOH\DC2\ETX%\r\ETB\n\
    \\f\n\
    \\ENQ\EOT\NUL\STX\SOH\ETX\DC2\ETX%\SUB\ESC\n\
    \6\n\
    \\EOT\EOT\NUL\STX\STX\DC2\ETX(\STX\EM\SUB) Versioning of the tensor bundle format.\n\
    \\n\
    \\f\n\
    \\ENQ\EOT\NUL\STX\STX\ACK\DC2\ETX(\STX\f\n\
    \\f\n\
    \\ENQ\EOT\NUL\STX\STX\SOH\DC2\ETX(\r\DC4\n\
    \\f\n\
    \\ENQ\EOT\NUL\STX\STX\ETX\DC2\ETX(\ETB\CAN\n\
    \F\n\
    \\STX\EOT\SOH\DC2\EOT,\NULA\SOH\SUB: Describes the metadata related to a checkpointed tensor.\n\
    \\n\
    \\n\
    \\n\
    \\ETX\EOT\SOH\SOH\DC2\ETX,\b\CAN\n\
    \*\n\
    \\EOT\EOT\SOH\STX\NUL\DC2\ETX.\STX\NAK\SUB\GS The tensor dtype and shape.\n\
    \\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\NUL\ACK\DC2\ETX.\STX\n\
    \\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\NUL\SOH\DC2\ETX.\v\DLE\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\NUL\ETX\DC2\ETX.\DC3\DC4\n\
    \\v\n\
    \\EOT\EOT\SOH\STX\SOH\DC2\ETX/\STX\GS\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\SOH\ACK\DC2\ETX/\STX\DC2\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\SOH\SOH\DC2\ETX/\DC3\CAN\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\SOH\ETX\DC2\ETX/\ESC\FS\n\
    \k\n\
    \\EOT\EOT\SOH\STX\STX\DC2\ETX2\STX\NAK\SUB^ The binary content of the tensor lies in:\n\
    \   File \"shard_id\": bytes [offset, offset + size).\n\
    \\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\STX\ENQ\DC2\ETX2\STX\a\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\STX\SOH\DC2\ETX2\b\DLE\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\STX\ETX\DC2\ETX2\DC3\DC4\n\
    \\v\n\
    \\EOT\EOT\SOH\STX\ETX\DC2\ETX3\STX\DC3\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\ETX\ENQ\DC2\ETX3\STX\a\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\ETX\SOH\DC2\ETX3\b\SO\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\ETX\ETX\DC2\ETX3\DC1\DC2\n\
    \\v\n\
    \\EOT\EOT\SOH\STX\EOT\DC2\ETX4\STX\DC1\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\EOT\ENQ\DC2\ETX4\STX\a\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\EOT\SOH\DC2\ETX4\b\f\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\EOT\ETX\DC2\ETX4\SI\DLE\n\
    \7\n\
    \\EOT\EOT\SOH\STX\ENQ\DC2\ETX7\STX\NAK\SUB* The CRC32C checksum of the tensor bytes.\n\
    \\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\ENQ\ENQ\DC2\ETX7\STX\t\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\ENQ\SOH\DC2\ETX7\n\
    \\DLE\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\ENQ\ETX\DC2\ETX7\DC3\DC4\n\
    \\219\STX\n\
    \\EOT\EOT\SOH\STX\ACK\DC2\ETX@\STX'\SUB\205\STX Iff present, this entry represents a partitioned tensor.  The previous\n\
    \ fields are interpreted as follows:\n\
    \\n\
    \   \"dtype\", \"shape\": describe the full tensor.\n\
    \   \"shard_id\", \"offset\", \"size\", \"crc32c\": all IGNORED.\n\
    \      These information for each slice can be looked up in their own\n\
    \      BundleEntryProto, keyed by each \"slice_name\".\n\
    \\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\ACK\EOT\DC2\ETX@\STX\n\
    \\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\ACK\ACK\DC2\ETX@\v\ESC\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\ACK\SOH\DC2\ETX@\FS\"\n\
    \\f\n\
    \\ENQ\EOT\SOH\STX\ACK\ETX\DC2\ETX@%&b\ACKproto3"