{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# LANGUAGE NoImplicitPrelude           #-}
{-# LANGUAGE TemplateHaskell             #-}
{-# LANGUAGE RecordWildCards             #-}

-- |
-- Module:      SwiftNav.SBP.FileIo
-- Copyright:   Copyright (C) 2015-2021 Swift Navigation, Inc.
-- License:     MIT
-- Contact:     https://support.swiftnav.com
-- Stability:   experimental
-- Portability: portable
--
-- \< Messages for using device's onboard flash filesystem functionality. This
-- allows data to be stored persistently in the device's program flash with
-- wear-levelling using a simple filesystem interface. The file system
-- interface (CFS) defines an abstract API for reading directories and for
-- reading and writing files.
--
-- Note that some of these messages share the same message type ID for both
-- the host request and the device response. \>

module SwiftNav.SBP.FileIo
  ( module SwiftNav.SBP.FileIo
  ) where

import BasicPrelude
import Control.Lens
import Control.Monad.Loops
import Data.Binary
import Data.Binary.Get
import Data.Binary.IEEE754
import Data.Binary.Put
import Data.ByteString.Lazy    hiding (ByteString)
import Data.Int
import Data.Word
import SwiftNav.SBP.TH
import SwiftNav.SBP.Types

{-# ANN module ("HLint: ignore Use camelCase"::String) #-}
{-# ANN module ("HLint: ignore Redundant do"::String) #-}
{-# ANN module ("HLint: ignore Use newtype instead of data"::String) #-}


msgFileioReadReq :: Word16
msgFileioReadReq :: Word16
msgFileioReadReq = Word16
0x00A8

-- | SBP class for message MSG_FILEIO_READ_REQ (0x00A8).
--
-- The file read message reads a certain length (up to 255 bytes) from a given
-- offset into a file, and returns the data in a MSG_FILEIO_READ_RESP message
-- where the message length field indicates how many bytes were successfully
-- read. The sequence number in the request will be returned in the response.
-- If the message is invalid, a followup MSG_PRINT message will print "Invalid
-- fileio read message". A device will only respond to this message when it is
-- received from sender ID 0x42.
data MsgFileioReadReq = MsgFileioReadReq
  { MsgFileioReadReq -> Word32
_msgFileioReadReq_sequence :: !Word32
    -- ^ Read sequence number
  , MsgFileioReadReq -> Word32
_msgFileioReadReq_offset   :: !Word32
    -- ^ File offset
  , MsgFileioReadReq -> Word8
_msgFileioReadReq_chunk_size :: !Word8
    -- ^ Chunk size to read
  , MsgFileioReadReq -> Text
_msgFileioReadReq_filename :: !Text
    -- ^ Name of the file to read from
  } deriving ( Int -> MsgFileioReadReq -> ShowS
[MsgFileioReadReq] -> ShowS
MsgFileioReadReq -> String
(Int -> MsgFileioReadReq -> ShowS)
-> (MsgFileioReadReq -> String)
-> ([MsgFileioReadReq] -> ShowS)
-> Show MsgFileioReadReq
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioReadReq] -> ShowS
$cshowList :: [MsgFileioReadReq] -> ShowS
show :: MsgFileioReadReq -> String
$cshow :: MsgFileioReadReq -> String
showsPrec :: Int -> MsgFileioReadReq -> ShowS
$cshowsPrec :: Int -> MsgFileioReadReq -> ShowS
Show, ReadPrec [MsgFileioReadReq]
ReadPrec MsgFileioReadReq
Int -> ReadS MsgFileioReadReq
ReadS [MsgFileioReadReq]
(Int -> ReadS MsgFileioReadReq)
-> ReadS [MsgFileioReadReq]
-> ReadPrec MsgFileioReadReq
-> ReadPrec [MsgFileioReadReq]
-> Read MsgFileioReadReq
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioReadReq]
$creadListPrec :: ReadPrec [MsgFileioReadReq]
readPrec :: ReadPrec MsgFileioReadReq
$creadPrec :: ReadPrec MsgFileioReadReq
readList :: ReadS [MsgFileioReadReq]
$creadList :: ReadS [MsgFileioReadReq]
readsPrec :: Int -> ReadS MsgFileioReadReq
$creadsPrec :: Int -> ReadS MsgFileioReadReq
Read, MsgFileioReadReq -> MsgFileioReadReq -> Bool
(MsgFileioReadReq -> MsgFileioReadReq -> Bool)
-> (MsgFileioReadReq -> MsgFileioReadReq -> Bool)
-> Eq MsgFileioReadReq
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioReadReq -> MsgFileioReadReq -> Bool
$c/= :: MsgFileioReadReq -> MsgFileioReadReq -> Bool
== :: MsgFileioReadReq -> MsgFileioReadReq -> Bool
$c== :: MsgFileioReadReq -> MsgFileioReadReq -> Bool
Eq )

instance Binary MsgFileioReadReq where
  get :: Get MsgFileioReadReq
get = do
    Word32
_msgFileioReadReq_sequence <- Get Word32
getWord32le
    Word32
_msgFileioReadReq_offset <- Get Word32
getWord32le
    Word8
_msgFileioReadReq_chunk_size <- Get Word8
getWord8
    Text
_msgFileioReadReq_filename <- ByteString -> Text
decodeUtf8 (ByteString -> Text)
-> (ByteString -> ByteString) -> ByteString -> Text
forall k (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ByteString -> ByteString
toStrict (ByteString -> Text) -> Get ByteString -> Get Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get ByteString
getRemainingLazyByteString
    MsgFileioReadReq -> Get MsgFileioReadReq
forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioReadReq :: Word32 -> Word32 -> Word8 -> Text -> MsgFileioReadReq
MsgFileioReadReq {Word8
Word32
Text
_msgFileioReadReq_filename :: Text
_msgFileioReadReq_chunk_size :: Word8
_msgFileioReadReq_offset :: Word32
_msgFileioReadReq_sequence :: Word32
_msgFileioReadReq_filename :: Text
_msgFileioReadReq_chunk_size :: Word8
_msgFileioReadReq_offset :: Word32
_msgFileioReadReq_sequence :: Word32
..}

  put :: MsgFileioReadReq -> Put
put MsgFileioReadReq {Word8
Word32
Text
_msgFileioReadReq_filename :: Text
_msgFileioReadReq_chunk_size :: Word8
_msgFileioReadReq_offset :: Word32
_msgFileioReadReq_sequence :: Word32
_msgFileioReadReq_filename :: MsgFileioReadReq -> Text
_msgFileioReadReq_chunk_size :: MsgFileioReadReq -> Word8
_msgFileioReadReq_offset :: MsgFileioReadReq -> Word32
_msgFileioReadReq_sequence :: MsgFileioReadReq -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioReadReq_sequence
    Word32 -> Put
putWord32le Word32
_msgFileioReadReq_offset
    Word8 -> Put
putWord8 Word8
_msgFileioReadReq_chunk_size
    ByteString -> Put
putByteString (ByteString -> Put) -> ByteString -> Put
forall a b. (a -> b) -> a -> b
$ Text -> ByteString
encodeUtf8 Text
_msgFileioReadReq_filename

$(makeSBP 'msgFileioReadReq ''MsgFileioReadReq)
$(makeJSON "_msgFileioReadReq_" ''MsgFileioReadReq)
$(makeLenses ''MsgFileioReadReq)

msgFileioReadResp :: Word16
msgFileioReadResp :: Word16
msgFileioReadResp = Word16
0x00A3

-- | SBP class for message MSG_FILEIO_READ_RESP (0x00A3).
--
-- The file read message reads a certain length (up to 255 bytes) from a given
-- offset into a file, and returns the data in a message where the message
-- length field indicates how many bytes were successfully read. The sequence
-- number in the response is preserved from the request.
data MsgFileioReadResp = MsgFileioReadResp
  { MsgFileioReadResp -> Word32
_msgFileioReadResp_sequence :: !Word32
    -- ^ Read sequence number
  , MsgFileioReadResp -> [Word8]
_msgFileioReadResp_contents :: ![Word8]
    -- ^ Contents of read file
  } deriving ( Int -> MsgFileioReadResp -> ShowS
[MsgFileioReadResp] -> ShowS
MsgFileioReadResp -> String
(Int -> MsgFileioReadResp -> ShowS)
-> (MsgFileioReadResp -> String)
-> ([MsgFileioReadResp] -> ShowS)
-> Show MsgFileioReadResp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioReadResp] -> ShowS
$cshowList :: [MsgFileioReadResp] -> ShowS
show :: MsgFileioReadResp -> String
$cshow :: MsgFileioReadResp -> String
showsPrec :: Int -> MsgFileioReadResp -> ShowS
$cshowsPrec :: Int -> MsgFileioReadResp -> ShowS
Show, ReadPrec [MsgFileioReadResp]
ReadPrec MsgFileioReadResp
Int -> ReadS MsgFileioReadResp
ReadS [MsgFileioReadResp]
(Int -> ReadS MsgFileioReadResp)
-> ReadS [MsgFileioReadResp]
-> ReadPrec MsgFileioReadResp
-> ReadPrec [MsgFileioReadResp]
-> Read MsgFileioReadResp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioReadResp]
$creadListPrec :: ReadPrec [MsgFileioReadResp]
readPrec :: ReadPrec MsgFileioReadResp
$creadPrec :: ReadPrec MsgFileioReadResp
readList :: ReadS [MsgFileioReadResp]
$creadList :: ReadS [MsgFileioReadResp]
readsPrec :: Int -> ReadS MsgFileioReadResp
$creadsPrec :: Int -> ReadS MsgFileioReadResp
Read, MsgFileioReadResp -> MsgFileioReadResp -> Bool
(MsgFileioReadResp -> MsgFileioReadResp -> Bool)
-> (MsgFileioReadResp -> MsgFileioReadResp -> Bool)
-> Eq MsgFileioReadResp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioReadResp -> MsgFileioReadResp -> Bool
$c/= :: MsgFileioReadResp -> MsgFileioReadResp -> Bool
== :: MsgFileioReadResp -> MsgFileioReadResp -> Bool
$c== :: MsgFileioReadResp -> MsgFileioReadResp -> Bool
Eq )

instance Binary MsgFileioReadResp where
  get :: Get MsgFileioReadResp
get = do
    Word32
_msgFileioReadResp_sequence <- Get Word32
getWord32le
    [Word8]
_msgFileioReadResp_contents <- Get Bool -> Get Word8 -> Get [Word8]
forall (m :: * -> *) a. Monad m => m Bool -> m a -> m [a]
whileM (Bool -> Bool
not (Bool -> Bool) -> Get Bool -> Get Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Bool
isEmpty) Get Word8
getWord8
    MsgFileioReadResp -> Get MsgFileioReadResp
forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioReadResp :: Word32 -> [Word8] -> MsgFileioReadResp
MsgFileioReadResp {[Word8]
Word32
_msgFileioReadResp_contents :: [Word8]
_msgFileioReadResp_sequence :: Word32
_msgFileioReadResp_contents :: [Word8]
_msgFileioReadResp_sequence :: Word32
..}

  put :: MsgFileioReadResp -> Put
put MsgFileioReadResp {[Word8]
Word32
_msgFileioReadResp_contents :: [Word8]
_msgFileioReadResp_sequence :: Word32
_msgFileioReadResp_contents :: MsgFileioReadResp -> [Word8]
_msgFileioReadResp_sequence :: MsgFileioReadResp -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioReadResp_sequence
    (Word8 -> Put) -> [Word8] -> Put
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Word8 -> Put
putWord8 [Word8]
_msgFileioReadResp_contents

$(makeSBP 'msgFileioReadResp ''MsgFileioReadResp)
$(makeJSON "_msgFileioReadResp_" ''MsgFileioReadResp)
$(makeLenses ''MsgFileioReadResp)

msgFileioReadDirReq :: Word16
msgFileioReadDirReq :: Word16
msgFileioReadDirReq = Word16
0x00A9

-- | SBP class for message MSG_FILEIO_READ_DIR_REQ (0x00A9).
--
-- The read directory message lists the files in a directory on the device's
-- onboard flash file system.  The offset parameter can be used to skip the
-- first n elements of the file list. Returns a MSG_FILEIO_READ_DIR_RESP
-- message containing the directory listings as a NULL delimited list. The
-- listing is chunked over multiple SBP packets. The sequence number in the
-- request will be returned in the response.  If message is invalid, a
-- followup MSG_PRINT message will print "Invalid fileio read message". A
-- device will only respond to this message when it is received from sender ID
-- 0x42.
data MsgFileioReadDirReq = MsgFileioReadDirReq
  { MsgFileioReadDirReq -> Word32
_msgFileioReadDirReq_sequence :: !Word32
    -- ^ Read sequence number
  , MsgFileioReadDirReq -> Word32
_msgFileioReadDirReq_offset :: !Word32
    -- ^ The offset to skip the first n elements of the file list
  , MsgFileioReadDirReq -> Text
_msgFileioReadDirReq_dirname :: !Text
    -- ^ Name of the directory to list
  } deriving ( Int -> MsgFileioReadDirReq -> ShowS
[MsgFileioReadDirReq] -> ShowS
MsgFileioReadDirReq -> String
(Int -> MsgFileioReadDirReq -> ShowS)
-> (MsgFileioReadDirReq -> String)
-> ([MsgFileioReadDirReq] -> ShowS)
-> Show MsgFileioReadDirReq
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioReadDirReq] -> ShowS
$cshowList :: [MsgFileioReadDirReq] -> ShowS
show :: MsgFileioReadDirReq -> String
$cshow :: MsgFileioReadDirReq -> String
showsPrec :: Int -> MsgFileioReadDirReq -> ShowS
$cshowsPrec :: Int -> MsgFileioReadDirReq -> ShowS
Show, ReadPrec [MsgFileioReadDirReq]
ReadPrec MsgFileioReadDirReq
Int -> ReadS MsgFileioReadDirReq
ReadS [MsgFileioReadDirReq]
(Int -> ReadS MsgFileioReadDirReq)
-> ReadS [MsgFileioReadDirReq]
-> ReadPrec MsgFileioReadDirReq
-> ReadPrec [MsgFileioReadDirReq]
-> Read MsgFileioReadDirReq
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioReadDirReq]
$creadListPrec :: ReadPrec [MsgFileioReadDirReq]
readPrec :: ReadPrec MsgFileioReadDirReq
$creadPrec :: ReadPrec MsgFileioReadDirReq
readList :: ReadS [MsgFileioReadDirReq]
$creadList :: ReadS [MsgFileioReadDirReq]
readsPrec :: Int -> ReadS MsgFileioReadDirReq
$creadsPrec :: Int -> ReadS MsgFileioReadDirReq
Read, MsgFileioReadDirReq -> MsgFileioReadDirReq -> Bool
(MsgFileioReadDirReq -> MsgFileioReadDirReq -> Bool)
-> (MsgFileioReadDirReq -> MsgFileioReadDirReq -> Bool)
-> Eq MsgFileioReadDirReq
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioReadDirReq -> MsgFileioReadDirReq -> Bool
$c/= :: MsgFileioReadDirReq -> MsgFileioReadDirReq -> Bool
== :: MsgFileioReadDirReq -> MsgFileioReadDirReq -> Bool
$c== :: MsgFileioReadDirReq -> MsgFileioReadDirReq -> Bool
Eq )

instance Binary MsgFileioReadDirReq where
  get :: Get MsgFileioReadDirReq
get = do
    Word32
_msgFileioReadDirReq_sequence <- Get Word32
getWord32le
    Word32
_msgFileioReadDirReq_offset <- Get Word32
getWord32le
    Text
_msgFileioReadDirReq_dirname <- ByteString -> Text
decodeUtf8 (ByteString -> Text)
-> (ByteString -> ByteString) -> ByteString -> Text
forall k (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ByteString -> ByteString
toStrict (ByteString -> Text) -> Get ByteString -> Get Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get ByteString
getRemainingLazyByteString
    MsgFileioReadDirReq -> Get MsgFileioReadDirReq
forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioReadDirReq :: Word32 -> Word32 -> Text -> MsgFileioReadDirReq
MsgFileioReadDirReq {Word32
Text
_msgFileioReadDirReq_dirname :: Text
_msgFileioReadDirReq_offset :: Word32
_msgFileioReadDirReq_sequence :: Word32
_msgFileioReadDirReq_dirname :: Text
_msgFileioReadDirReq_offset :: Word32
_msgFileioReadDirReq_sequence :: Word32
..}

  put :: MsgFileioReadDirReq -> Put
put MsgFileioReadDirReq {Word32
Text
_msgFileioReadDirReq_dirname :: Text
_msgFileioReadDirReq_offset :: Word32
_msgFileioReadDirReq_sequence :: Word32
_msgFileioReadDirReq_dirname :: MsgFileioReadDirReq -> Text
_msgFileioReadDirReq_offset :: MsgFileioReadDirReq -> Word32
_msgFileioReadDirReq_sequence :: MsgFileioReadDirReq -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioReadDirReq_sequence
    Word32 -> Put
putWord32le Word32
_msgFileioReadDirReq_offset
    ByteString -> Put
putByteString (ByteString -> Put) -> ByteString -> Put
forall a b. (a -> b) -> a -> b
$ Text -> ByteString
encodeUtf8 Text
_msgFileioReadDirReq_dirname

$(makeSBP 'msgFileioReadDirReq ''MsgFileioReadDirReq)
$(makeJSON "_msgFileioReadDirReq_" ''MsgFileioReadDirReq)
$(makeLenses ''MsgFileioReadDirReq)

msgFileioReadDirResp :: Word16
msgFileioReadDirResp :: Word16
msgFileioReadDirResp = Word16
0x00AA

-- | SBP class for message MSG_FILEIO_READ_DIR_RESP (0x00AA).
--
-- The read directory message lists the files in a directory on the device's
-- onboard flash file system. Message contains the directory listings as a
-- NULL delimited list. The listing is chunked over multiple SBP packets and
-- the end of the list is identified by an packet with no entries. The
-- sequence number in the response is preserved from the request.
data MsgFileioReadDirResp = MsgFileioReadDirResp
  { MsgFileioReadDirResp -> Word32
_msgFileioReadDirResp_sequence :: !Word32
    -- ^ Read sequence number
  , MsgFileioReadDirResp -> [Word8]
_msgFileioReadDirResp_contents :: ![Word8]
    -- ^ Contents of read directory
  } deriving ( Int -> MsgFileioReadDirResp -> ShowS
[MsgFileioReadDirResp] -> ShowS
MsgFileioReadDirResp -> String
(Int -> MsgFileioReadDirResp -> ShowS)
-> (MsgFileioReadDirResp -> String)
-> ([MsgFileioReadDirResp] -> ShowS)
-> Show MsgFileioReadDirResp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioReadDirResp] -> ShowS
$cshowList :: [MsgFileioReadDirResp] -> ShowS
show :: MsgFileioReadDirResp -> String
$cshow :: MsgFileioReadDirResp -> String
showsPrec :: Int -> MsgFileioReadDirResp -> ShowS
$cshowsPrec :: Int -> MsgFileioReadDirResp -> ShowS
Show, ReadPrec [MsgFileioReadDirResp]
ReadPrec MsgFileioReadDirResp
Int -> ReadS MsgFileioReadDirResp
ReadS [MsgFileioReadDirResp]
(Int -> ReadS MsgFileioReadDirResp)
-> ReadS [MsgFileioReadDirResp]
-> ReadPrec MsgFileioReadDirResp
-> ReadPrec [MsgFileioReadDirResp]
-> Read MsgFileioReadDirResp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioReadDirResp]
$creadListPrec :: ReadPrec [MsgFileioReadDirResp]
readPrec :: ReadPrec MsgFileioReadDirResp
$creadPrec :: ReadPrec MsgFileioReadDirResp
readList :: ReadS [MsgFileioReadDirResp]
$creadList :: ReadS [MsgFileioReadDirResp]
readsPrec :: Int -> ReadS MsgFileioReadDirResp
$creadsPrec :: Int -> ReadS MsgFileioReadDirResp
Read, MsgFileioReadDirResp -> MsgFileioReadDirResp -> Bool
(MsgFileioReadDirResp -> MsgFileioReadDirResp -> Bool)
-> (MsgFileioReadDirResp -> MsgFileioReadDirResp -> Bool)
-> Eq MsgFileioReadDirResp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioReadDirResp -> MsgFileioReadDirResp -> Bool
$c/= :: MsgFileioReadDirResp -> MsgFileioReadDirResp -> Bool
== :: MsgFileioReadDirResp -> MsgFileioReadDirResp -> Bool
$c== :: MsgFileioReadDirResp -> MsgFileioReadDirResp -> Bool
Eq )

instance Binary MsgFileioReadDirResp where
  get :: Get MsgFileioReadDirResp
get = do
    Word32
_msgFileioReadDirResp_sequence <- Get Word32
getWord32le
    [Word8]
_msgFileioReadDirResp_contents <- Get Bool -> Get Word8 -> Get [Word8]
forall (m :: * -> *) a. Monad m => m Bool -> m a -> m [a]
whileM (Bool -> Bool
not (Bool -> Bool) -> Get Bool -> Get Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Bool
isEmpty) Get Word8
getWord8
    MsgFileioReadDirResp -> Get MsgFileioReadDirResp
forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioReadDirResp :: Word32 -> [Word8] -> MsgFileioReadDirResp
MsgFileioReadDirResp {[Word8]
Word32
_msgFileioReadDirResp_contents :: [Word8]
_msgFileioReadDirResp_sequence :: Word32
_msgFileioReadDirResp_contents :: [Word8]
_msgFileioReadDirResp_sequence :: Word32
..}

  put :: MsgFileioReadDirResp -> Put
put MsgFileioReadDirResp {[Word8]
Word32
_msgFileioReadDirResp_contents :: [Word8]
_msgFileioReadDirResp_sequence :: Word32
_msgFileioReadDirResp_contents :: MsgFileioReadDirResp -> [Word8]
_msgFileioReadDirResp_sequence :: MsgFileioReadDirResp -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioReadDirResp_sequence
    (Word8 -> Put) -> [Word8] -> Put
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Word8 -> Put
putWord8 [Word8]
_msgFileioReadDirResp_contents

$(makeSBP 'msgFileioReadDirResp ''MsgFileioReadDirResp)
$(makeJSON "_msgFileioReadDirResp_" ''MsgFileioReadDirResp)
$(makeLenses ''MsgFileioReadDirResp)

msgFileioRemove :: Word16
msgFileioRemove :: Word16
msgFileioRemove = Word16
0x00AC

-- | SBP class for message MSG_FILEIO_REMOVE (0x00AC).
--
-- The file remove message deletes a file from the file system. If the message
-- is invalid, a followup MSG_PRINT message will print "Invalid fileio remove
-- message". A device will only process this message when it is received from
-- sender ID 0x42.
data MsgFileioRemove = MsgFileioRemove
  { MsgFileioRemove -> Text
_msgFileioRemove_filename :: !Text
    -- ^ Name of the file to delete
  } deriving ( Int -> MsgFileioRemove -> ShowS
[MsgFileioRemove] -> ShowS
MsgFileioRemove -> String
(Int -> MsgFileioRemove -> ShowS)
-> (MsgFileioRemove -> String)
-> ([MsgFileioRemove] -> ShowS)
-> Show MsgFileioRemove
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioRemove] -> ShowS
$cshowList :: [MsgFileioRemove] -> ShowS
show :: MsgFileioRemove -> String
$cshow :: MsgFileioRemove -> String
showsPrec :: Int -> MsgFileioRemove -> ShowS
$cshowsPrec :: Int -> MsgFileioRemove -> ShowS
Show, ReadPrec [MsgFileioRemove]
ReadPrec MsgFileioRemove
Int -> ReadS MsgFileioRemove
ReadS [MsgFileioRemove]
(Int -> ReadS MsgFileioRemove)
-> ReadS [MsgFileioRemove]
-> ReadPrec MsgFileioRemove
-> ReadPrec [MsgFileioRemove]
-> Read MsgFileioRemove
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioRemove]
$creadListPrec :: ReadPrec [MsgFileioRemove]
readPrec :: ReadPrec MsgFileioRemove
$creadPrec :: ReadPrec MsgFileioRemove
readList :: ReadS [MsgFileioRemove]
$creadList :: ReadS [MsgFileioRemove]
readsPrec :: Int -> ReadS MsgFileioRemove
$creadsPrec :: Int -> ReadS MsgFileioRemove
Read, MsgFileioRemove -> MsgFileioRemove -> Bool
(MsgFileioRemove -> MsgFileioRemove -> Bool)
-> (MsgFileioRemove -> MsgFileioRemove -> Bool)
-> Eq MsgFileioRemove
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioRemove -> MsgFileioRemove -> Bool
$c/= :: MsgFileioRemove -> MsgFileioRemove -> Bool
== :: MsgFileioRemove -> MsgFileioRemove -> Bool
$c== :: MsgFileioRemove -> MsgFileioRemove -> Bool
Eq )

instance Binary MsgFileioRemove where
  get :: Get MsgFileioRemove
get = do
    Text
_msgFileioRemove_filename <- ByteString -> Text
decodeUtf8 (ByteString -> Text)
-> (ByteString -> ByteString) -> ByteString -> Text
forall k (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ByteString -> ByteString
toStrict (ByteString -> Text) -> Get ByteString -> Get Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get ByteString
getRemainingLazyByteString
    MsgFileioRemove -> Get MsgFileioRemove
forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioRemove :: Text -> MsgFileioRemove
MsgFileioRemove {Text
_msgFileioRemove_filename :: Text
_msgFileioRemove_filename :: Text
..}

  put :: MsgFileioRemove -> Put
put MsgFileioRemove {Text
_msgFileioRemove_filename :: Text
_msgFileioRemove_filename :: MsgFileioRemove -> Text
..} = do
    ByteString -> Put
putByteString (ByteString -> Put) -> ByteString -> Put
forall a b. (a -> b) -> a -> b
$ Text -> ByteString
encodeUtf8 Text
_msgFileioRemove_filename

$(makeSBP 'msgFileioRemove ''MsgFileioRemove)
$(makeJSON "_msgFileioRemove_" ''MsgFileioRemove)
$(makeLenses ''MsgFileioRemove)

msgFileioWriteReq :: Word16
msgFileioWriteReq :: Word16
msgFileioWriteReq = Word16
0x00AD

-- | SBP class for message MSG_FILEIO_WRITE_REQ (0x00AD).
--
-- The file write message writes a certain length (up to 255 bytes) of data to
-- a file at a given offset. Returns a copy of the original
-- MSG_FILEIO_WRITE_RESP message to check integrity of the write. The sequence
-- number in the request will be returned in the response. If message is
-- invalid, a followup MSG_PRINT message will print "Invalid fileio write
-- message". A device will only process this message when it is received from
-- sender ID 0x42.
data MsgFileioWriteReq = MsgFileioWriteReq
  { MsgFileioWriteReq -> Word32
_msgFileioWriteReq_sequence :: !Word32
    -- ^ Write sequence number
  , MsgFileioWriteReq -> Word32
_msgFileioWriteReq_offset :: !Word32
    -- ^ Offset into the file at which to start writing in bytes
  , MsgFileioWriteReq -> Text
_msgFileioWriteReq_filename :: !Text
    -- ^ Name of the file to write to
  , MsgFileioWriteReq -> [Word8]
_msgFileioWriteReq_data   :: ![Word8]
    -- ^ Variable-length array of data to write
  } deriving ( Int -> MsgFileioWriteReq -> ShowS
[MsgFileioWriteReq] -> ShowS
MsgFileioWriteReq -> String
(Int -> MsgFileioWriteReq -> ShowS)
-> (MsgFileioWriteReq -> String)
-> ([MsgFileioWriteReq] -> ShowS)
-> Show MsgFileioWriteReq
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioWriteReq] -> ShowS
$cshowList :: [MsgFileioWriteReq] -> ShowS
show :: MsgFileioWriteReq -> String
$cshow :: MsgFileioWriteReq -> String
showsPrec :: Int -> MsgFileioWriteReq -> ShowS
$cshowsPrec :: Int -> MsgFileioWriteReq -> ShowS
Show, ReadPrec [MsgFileioWriteReq]
ReadPrec MsgFileioWriteReq
Int -> ReadS MsgFileioWriteReq
ReadS [MsgFileioWriteReq]
(Int -> ReadS MsgFileioWriteReq)
-> ReadS [MsgFileioWriteReq]
-> ReadPrec MsgFileioWriteReq
-> ReadPrec [MsgFileioWriteReq]
-> Read MsgFileioWriteReq
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioWriteReq]
$creadListPrec :: ReadPrec [MsgFileioWriteReq]
readPrec :: ReadPrec MsgFileioWriteReq
$creadPrec :: ReadPrec MsgFileioWriteReq
readList :: ReadS [MsgFileioWriteReq]
$creadList :: ReadS [MsgFileioWriteReq]
readsPrec :: Int -> ReadS MsgFileioWriteReq
$creadsPrec :: Int -> ReadS MsgFileioWriteReq
Read, MsgFileioWriteReq -> MsgFileioWriteReq -> Bool
(MsgFileioWriteReq -> MsgFileioWriteReq -> Bool)
-> (MsgFileioWriteReq -> MsgFileioWriteReq -> Bool)
-> Eq MsgFileioWriteReq
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioWriteReq -> MsgFileioWriteReq -> Bool
$c/= :: MsgFileioWriteReq -> MsgFileioWriteReq -> Bool
== :: MsgFileioWriteReq -> MsgFileioWriteReq -> Bool
$c== :: MsgFileioWriteReq -> MsgFileioWriteReq -> Bool
Eq )

instance Binary MsgFileioWriteReq where
  get :: Get MsgFileioWriteReq
get = do
    Word32
_msgFileioWriteReq_sequence <- Get Word32
getWord32le
    Word32
_msgFileioWriteReq_offset <- Get Word32
getWord32le
    Text
_msgFileioWriteReq_filename <- ByteString -> Text
decodeUtf8 (ByteString -> Text)
-> (ByteString -> ByteString) -> ByteString -> Text
forall k (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ByteString -> ByteString
toStrict (ByteString -> Text) -> Get ByteString -> Get Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get ByteString
getRemainingLazyByteString
    [Word8]
_msgFileioWriteReq_data <- Get Bool -> Get Word8 -> Get [Word8]
forall (m :: * -> *) a. Monad m => m Bool -> m a -> m [a]
whileM (Bool -> Bool
not (Bool -> Bool) -> Get Bool -> Get Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Bool
isEmpty) Get Word8
getWord8
    MsgFileioWriteReq -> Get MsgFileioWriteReq
forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioWriteReq :: Word32 -> Word32 -> Text -> [Word8] -> MsgFileioWriteReq
MsgFileioWriteReq {[Word8]
Word32
Text
_msgFileioWriteReq_data :: [Word8]
_msgFileioWriteReq_filename :: Text
_msgFileioWriteReq_offset :: Word32
_msgFileioWriteReq_sequence :: Word32
_msgFileioWriteReq_data :: [Word8]
_msgFileioWriteReq_filename :: Text
_msgFileioWriteReq_offset :: Word32
_msgFileioWriteReq_sequence :: Word32
..}

  put :: MsgFileioWriteReq -> Put
put MsgFileioWriteReq {[Word8]
Word32
Text
_msgFileioWriteReq_data :: [Word8]
_msgFileioWriteReq_filename :: Text
_msgFileioWriteReq_offset :: Word32
_msgFileioWriteReq_sequence :: Word32
_msgFileioWriteReq_data :: MsgFileioWriteReq -> [Word8]
_msgFileioWriteReq_filename :: MsgFileioWriteReq -> Text
_msgFileioWriteReq_offset :: MsgFileioWriteReq -> Word32
_msgFileioWriteReq_sequence :: MsgFileioWriteReq -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioWriteReq_sequence
    Word32 -> Put
putWord32le Word32
_msgFileioWriteReq_offset
    ByteString -> Put
putByteString (ByteString -> Put) -> ByteString -> Put
forall a b. (a -> b) -> a -> b
$ Text -> ByteString
encodeUtf8 Text
_msgFileioWriteReq_filename
    (Word8 -> Put) -> [Word8] -> Put
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Word8 -> Put
putWord8 [Word8]
_msgFileioWriteReq_data

$(makeSBP 'msgFileioWriteReq ''MsgFileioWriteReq)
$(makeJSON "_msgFileioWriteReq_" ''MsgFileioWriteReq)
$(makeLenses ''MsgFileioWriteReq)

msgFileioWriteResp :: Word16
msgFileioWriteResp :: Word16
msgFileioWriteResp = Word16
0x00AB

-- | SBP class for message MSG_FILEIO_WRITE_RESP (0x00AB).
--
-- The file write message writes a certain length (up to 255 bytes) of data to
-- a file at a given offset. The message is a copy of the original
-- MSG_FILEIO_WRITE_REQ message to check integrity of the write. The sequence
-- number in the response is preserved from the request.
data MsgFileioWriteResp = MsgFileioWriteResp
  { MsgFileioWriteResp -> Word32
_msgFileioWriteResp_sequence :: !Word32
    -- ^ Write sequence number
  } deriving ( Int -> MsgFileioWriteResp -> ShowS
[MsgFileioWriteResp] -> ShowS
MsgFileioWriteResp -> String
(Int -> MsgFileioWriteResp -> ShowS)
-> (MsgFileioWriteResp -> String)
-> ([MsgFileioWriteResp] -> ShowS)
-> Show MsgFileioWriteResp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioWriteResp] -> ShowS
$cshowList :: [MsgFileioWriteResp] -> ShowS
show :: MsgFileioWriteResp -> String
$cshow :: MsgFileioWriteResp -> String
showsPrec :: Int -> MsgFileioWriteResp -> ShowS
$cshowsPrec :: Int -> MsgFileioWriteResp -> ShowS
Show, ReadPrec [MsgFileioWriteResp]
ReadPrec MsgFileioWriteResp
Int -> ReadS MsgFileioWriteResp
ReadS [MsgFileioWriteResp]
(Int -> ReadS MsgFileioWriteResp)
-> ReadS [MsgFileioWriteResp]
-> ReadPrec MsgFileioWriteResp
-> ReadPrec [MsgFileioWriteResp]
-> Read MsgFileioWriteResp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioWriteResp]
$creadListPrec :: ReadPrec [MsgFileioWriteResp]
readPrec :: ReadPrec MsgFileioWriteResp
$creadPrec :: ReadPrec MsgFileioWriteResp
readList :: ReadS [MsgFileioWriteResp]
$creadList :: ReadS [MsgFileioWriteResp]
readsPrec :: Int -> ReadS MsgFileioWriteResp
$creadsPrec :: Int -> ReadS MsgFileioWriteResp
Read, MsgFileioWriteResp -> MsgFileioWriteResp -> Bool
(MsgFileioWriteResp -> MsgFileioWriteResp -> Bool)
-> (MsgFileioWriteResp -> MsgFileioWriteResp -> Bool)
-> Eq MsgFileioWriteResp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioWriteResp -> MsgFileioWriteResp -> Bool
$c/= :: MsgFileioWriteResp -> MsgFileioWriteResp -> Bool
== :: MsgFileioWriteResp -> MsgFileioWriteResp -> Bool
$c== :: MsgFileioWriteResp -> MsgFileioWriteResp -> Bool
Eq )

instance Binary MsgFileioWriteResp where
  get :: Get MsgFileioWriteResp
get = do
    Word32
_msgFileioWriteResp_sequence <- Get Word32
getWord32le
    MsgFileioWriteResp -> Get MsgFileioWriteResp
forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioWriteResp :: Word32 -> MsgFileioWriteResp
MsgFileioWriteResp {Word32
_msgFileioWriteResp_sequence :: Word32
_msgFileioWriteResp_sequence :: Word32
..}

  put :: MsgFileioWriteResp -> Put
put MsgFileioWriteResp {Word32
_msgFileioWriteResp_sequence :: Word32
_msgFileioWriteResp_sequence :: MsgFileioWriteResp -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioWriteResp_sequence

$(makeSBP 'msgFileioWriteResp ''MsgFileioWriteResp)
$(makeJSON "_msgFileioWriteResp_" ''MsgFileioWriteResp)
$(makeLenses ''MsgFileioWriteResp)

msgFileioConfigReq :: Word16
msgFileioConfigReq :: Word16
msgFileioConfigReq = Word16
0x1001

-- | SBP class for message MSG_FILEIO_CONFIG_REQ (0x1001).
--
-- Requests advice on the optimal configuration for a FileIO transfer.  Newer
-- version of FileIO can support greater throughput by supporting a large
-- window of FileIO data that can be in-flight during read or write
-- operations.
data MsgFileioConfigReq = MsgFileioConfigReq
  { MsgFileioConfigReq -> Word32
_msgFileioConfigReq_sequence :: !Word32
    -- ^ Advice sequence number
  } deriving ( Int -> MsgFileioConfigReq -> ShowS
[MsgFileioConfigReq] -> ShowS
MsgFileioConfigReq -> String
(Int -> MsgFileioConfigReq -> ShowS)
-> (MsgFileioConfigReq -> String)
-> ([MsgFileioConfigReq] -> ShowS)
-> Show MsgFileioConfigReq
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioConfigReq] -> ShowS
$cshowList :: [MsgFileioConfigReq] -> ShowS
show :: MsgFileioConfigReq -> String
$cshow :: MsgFileioConfigReq -> String
showsPrec :: Int -> MsgFileioConfigReq -> ShowS
$cshowsPrec :: Int -> MsgFileioConfigReq -> ShowS
Show, ReadPrec [MsgFileioConfigReq]
ReadPrec MsgFileioConfigReq
Int -> ReadS MsgFileioConfigReq
ReadS [MsgFileioConfigReq]
(Int -> ReadS MsgFileioConfigReq)
-> ReadS [MsgFileioConfigReq]
-> ReadPrec MsgFileioConfigReq
-> ReadPrec [MsgFileioConfigReq]
-> Read MsgFileioConfigReq
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioConfigReq]
$creadListPrec :: ReadPrec [MsgFileioConfigReq]
readPrec :: ReadPrec MsgFileioConfigReq
$creadPrec :: ReadPrec MsgFileioConfigReq
readList :: ReadS [MsgFileioConfigReq]
$creadList :: ReadS [MsgFileioConfigReq]
readsPrec :: Int -> ReadS MsgFileioConfigReq
$creadsPrec :: Int -> ReadS MsgFileioConfigReq
Read, MsgFileioConfigReq -> MsgFileioConfigReq -> Bool
(MsgFileioConfigReq -> MsgFileioConfigReq -> Bool)
-> (MsgFileioConfigReq -> MsgFileioConfigReq -> Bool)
-> Eq MsgFileioConfigReq
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioConfigReq -> MsgFileioConfigReq -> Bool
$c/= :: MsgFileioConfigReq -> MsgFileioConfigReq -> Bool
== :: MsgFileioConfigReq -> MsgFileioConfigReq -> Bool
$c== :: MsgFileioConfigReq -> MsgFileioConfigReq -> Bool
Eq )

instance Binary MsgFileioConfigReq where
  get :: Get MsgFileioConfigReq
get = do
    Word32
_msgFileioConfigReq_sequence <- Get Word32
getWord32le
    MsgFileioConfigReq -> Get MsgFileioConfigReq
forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioConfigReq :: Word32 -> MsgFileioConfigReq
MsgFileioConfigReq {Word32
_msgFileioConfigReq_sequence :: Word32
_msgFileioConfigReq_sequence :: Word32
..}

  put :: MsgFileioConfigReq -> Put
put MsgFileioConfigReq {Word32
_msgFileioConfigReq_sequence :: Word32
_msgFileioConfigReq_sequence :: MsgFileioConfigReq -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioConfigReq_sequence

$(makeSBP 'msgFileioConfigReq ''MsgFileioConfigReq)
$(makeJSON "_msgFileioConfigReq_" ''MsgFileioConfigReq)
$(makeLenses ''MsgFileioConfigReq)

msgFileioConfigResp :: Word16
msgFileioConfigResp :: Word16
msgFileioConfigResp = Word16
0x1002

-- | SBP class for message MSG_FILEIO_CONFIG_RESP (0x1002).
--
-- The advice on the optimal configuration for a FileIO transfer.  Newer
-- version of FileIO can support greater throughput by supporting a large
-- window of FileIO data that can be in-flight during read or write
-- operations.
data MsgFileioConfigResp = MsgFileioConfigResp
  { MsgFileioConfigResp -> Word32
_msgFileioConfigResp_sequence     :: !Word32
    -- ^ Advice sequence number
  , MsgFileioConfigResp -> Word32
_msgFileioConfigResp_window_size  :: !Word32
    -- ^ The number of SBP packets in the data in-flight window
  , MsgFileioConfigResp -> Word32
_msgFileioConfigResp_batch_size   :: !Word32
    -- ^ The number of SBP packets sent in one PDU
  , MsgFileioConfigResp -> Word32
_msgFileioConfigResp_fileio_version :: !Word32
    -- ^ The version of FileIO that is supported
  } deriving ( Int -> MsgFileioConfigResp -> ShowS
[MsgFileioConfigResp] -> ShowS
MsgFileioConfigResp -> String
(Int -> MsgFileioConfigResp -> ShowS)
-> (MsgFileioConfigResp -> String)
-> ([MsgFileioConfigResp] -> ShowS)
-> Show MsgFileioConfigResp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioConfigResp] -> ShowS
$cshowList :: [MsgFileioConfigResp] -> ShowS
show :: MsgFileioConfigResp -> String
$cshow :: MsgFileioConfigResp -> String
showsPrec :: Int -> MsgFileioConfigResp -> ShowS
$cshowsPrec :: Int -> MsgFileioConfigResp -> ShowS
Show, ReadPrec [MsgFileioConfigResp]
ReadPrec MsgFileioConfigResp
Int -> ReadS MsgFileioConfigResp
ReadS [MsgFileioConfigResp]
(Int -> ReadS MsgFileioConfigResp)
-> ReadS [MsgFileioConfigResp]
-> ReadPrec MsgFileioConfigResp
-> ReadPrec [MsgFileioConfigResp]
-> Read MsgFileioConfigResp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioConfigResp]
$creadListPrec :: ReadPrec [MsgFileioConfigResp]
readPrec :: ReadPrec MsgFileioConfigResp
$creadPrec :: ReadPrec MsgFileioConfigResp
readList :: ReadS [MsgFileioConfigResp]
$creadList :: ReadS [MsgFileioConfigResp]
readsPrec :: Int -> ReadS MsgFileioConfigResp
$creadsPrec :: Int -> ReadS MsgFileioConfigResp
Read, MsgFileioConfigResp -> MsgFileioConfigResp -> Bool
(MsgFileioConfigResp -> MsgFileioConfigResp -> Bool)
-> (MsgFileioConfigResp -> MsgFileioConfigResp -> Bool)
-> Eq MsgFileioConfigResp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioConfigResp -> MsgFileioConfigResp -> Bool
$c/= :: MsgFileioConfigResp -> MsgFileioConfigResp -> Bool
== :: MsgFileioConfigResp -> MsgFileioConfigResp -> Bool
$c== :: MsgFileioConfigResp -> MsgFileioConfigResp -> Bool
Eq )

instance Binary MsgFileioConfigResp where
  get :: Get MsgFileioConfigResp
get = do
    Word32
_msgFileioConfigResp_sequence <- Get Word32
getWord32le
    Word32
_msgFileioConfigResp_window_size <- Get Word32
getWord32le
    Word32
_msgFileioConfigResp_batch_size <- Get Word32
getWord32le
    Word32
_msgFileioConfigResp_fileio_version <- Get Word32
getWord32le
    MsgFileioConfigResp -> Get MsgFileioConfigResp
forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioConfigResp :: Word32 -> Word32 -> Word32 -> Word32 -> MsgFileioConfigResp
MsgFileioConfigResp {Word32
_msgFileioConfigResp_fileio_version :: Word32
_msgFileioConfigResp_batch_size :: Word32
_msgFileioConfigResp_window_size :: Word32
_msgFileioConfigResp_sequence :: Word32
_msgFileioConfigResp_fileio_version :: Word32
_msgFileioConfigResp_batch_size :: Word32
_msgFileioConfigResp_window_size :: Word32
_msgFileioConfigResp_sequence :: Word32
..}

  put :: MsgFileioConfigResp -> Put
put MsgFileioConfigResp {Word32
_msgFileioConfigResp_fileio_version :: Word32
_msgFileioConfigResp_batch_size :: Word32
_msgFileioConfigResp_window_size :: Word32
_msgFileioConfigResp_sequence :: Word32
_msgFileioConfigResp_fileio_version :: MsgFileioConfigResp -> Word32
_msgFileioConfigResp_batch_size :: MsgFileioConfigResp -> Word32
_msgFileioConfigResp_window_size :: MsgFileioConfigResp -> Word32
_msgFileioConfigResp_sequence :: MsgFileioConfigResp -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioConfigResp_sequence
    Word32 -> Put
putWord32le Word32
_msgFileioConfigResp_window_size
    Word32 -> Put
putWord32le Word32
_msgFileioConfigResp_batch_size
    Word32 -> Put
putWord32le Word32
_msgFileioConfigResp_fileio_version

$(makeSBP 'msgFileioConfigResp ''MsgFileioConfigResp)
$(makeJSON "_msgFileioConfigResp_" ''MsgFileioConfigResp)
$(makeLenses ''MsgFileioConfigResp)