{-# LANGUAGE DeriveDataTypeable,RankNTypes #-}
-- | This module add unknown field support to the library.  There are no user API things here,
-- except for advanced spelunking into the data structures which can and have changed with no
-- notice.  Importer beware.
module Text.ProtocolBuffers.Unknown
  ( UnknownField(..),UnknownMessage(..),UnknownFieldValue(..)
  , wireSizeUnknownField,wirePutUnknownField, wirePutUnknownFieldWithSize
  , catch'Unknown, catch'Unknown', loadUnknown, discardUnknown
  ) where

import qualified Data.ByteString.Lazy as L
import qualified Data.Foldable as F
import Data.Generics
import Data.Sequence((|>))
import Data.Typeable()
import Control.Monad.Error.Class(catchError)

import Text.ProtocolBuffers.Basic
import Text.ProtocolBuffers.WireMessage

-- err :: String -> b
-- err msg = error $ "Text.ProtocolBuffers.Unknown error\n"++msg

-- | Messages that can store unknown fields implement this interface.
-- UnknownField is a supposedly opaque type.
class UnknownMessage msg where
  getUnknownField :: msg -> UnknownField
  putUnknownField :: UnknownField -> msg -> msg

-- | This is a suposedly opaque type
newtype UnknownField = UnknownField (Seq UnknownFieldValue)
  deriving (UnknownField -> UnknownField -> Bool
(UnknownField -> UnknownField -> Bool)
-> (UnknownField -> UnknownField -> Bool) -> Eq UnknownField
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnknownField -> UnknownField -> Bool
$c/= :: UnknownField -> UnknownField -> Bool
== :: UnknownField -> UnknownField -> Bool
$c== :: UnknownField -> UnknownField -> Bool
Eq,Eq UnknownField
Eq UnknownField
-> (UnknownField -> UnknownField -> Ordering)
-> (UnknownField -> UnknownField -> Bool)
-> (UnknownField -> UnknownField -> Bool)
-> (UnknownField -> UnknownField -> Bool)
-> (UnknownField -> UnknownField -> Bool)
-> (UnknownField -> UnknownField -> UnknownField)
-> (UnknownField -> UnknownField -> UnknownField)
-> Ord UnknownField
UnknownField -> UnknownField -> Bool
UnknownField -> UnknownField -> Ordering
UnknownField -> UnknownField -> UnknownField
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 :: UnknownField -> UnknownField -> UnknownField
$cmin :: UnknownField -> UnknownField -> UnknownField
max :: UnknownField -> UnknownField -> UnknownField
$cmax :: UnknownField -> UnknownField -> UnknownField
>= :: UnknownField -> UnknownField -> Bool
$c>= :: UnknownField -> UnknownField -> Bool
> :: UnknownField -> UnknownField -> Bool
$c> :: UnknownField -> UnknownField -> Bool
<= :: UnknownField -> UnknownField -> Bool
$c<= :: UnknownField -> UnknownField -> Bool
< :: UnknownField -> UnknownField -> Bool
$c< :: UnknownField -> UnknownField -> Bool
compare :: UnknownField -> UnknownField -> Ordering
$ccompare :: UnknownField -> UnknownField -> Ordering
$cp1Ord :: Eq UnknownField
Ord,Int -> UnknownField -> ShowS
[UnknownField] -> ShowS
UnknownField -> String
(Int -> UnknownField -> ShowS)
-> (UnknownField -> String)
-> ([UnknownField] -> ShowS)
-> Show UnknownField
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnknownField] -> ShowS
$cshowList :: [UnknownField] -> ShowS
show :: UnknownField -> String
$cshow :: UnknownField -> String
showsPrec :: Int -> UnknownField -> ShowS
$cshowsPrec :: Int -> UnknownField -> ShowS
Show,ReadPrec [UnknownField]
ReadPrec UnknownField
Int -> ReadS UnknownField
ReadS [UnknownField]
(Int -> ReadS UnknownField)
-> ReadS [UnknownField]
-> ReadPrec UnknownField
-> ReadPrec [UnknownField]
-> Read UnknownField
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UnknownField]
$creadListPrec :: ReadPrec [UnknownField]
readPrec :: ReadPrec UnknownField
$creadPrec :: ReadPrec UnknownField
readList :: ReadS [UnknownField]
$creadList :: ReadS [UnknownField]
readsPrec :: Int -> ReadS UnknownField
$creadsPrec :: Int -> ReadS UnknownField
Read,Typeable UnknownField
DataType
Constr
Typeable UnknownField
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> UnknownField -> c UnknownField)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UnknownField)
-> (UnknownField -> Constr)
-> (UnknownField -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UnknownField))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c UnknownField))
-> ((forall b. Data b => b -> b) -> UnknownField -> UnknownField)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UnknownField -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UnknownField -> r)
-> (forall u. (forall d. Data d => d -> u) -> UnknownField -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UnknownField -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> UnknownField -> m UnknownField)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnknownField -> m UnknownField)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnknownField -> m UnknownField)
-> Data UnknownField
UnknownField -> DataType
UnknownField -> Constr
(forall b. Data b => b -> b) -> UnknownField -> UnknownField
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnknownField -> c UnknownField
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnknownField
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> UnknownField -> u
forall u. (forall d. Data d => d -> u) -> UnknownField -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnknownField -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnknownField -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnknownField -> m UnknownField
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnknownField -> m UnknownField
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnknownField
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnknownField -> c UnknownField
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnknownField)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnknownField)
$cUnknownField :: Constr
$tUnknownField :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> UnknownField -> m UnknownField
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnknownField -> m UnknownField
gmapMp :: (forall d. Data d => d -> m d) -> UnknownField -> m UnknownField
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnknownField -> m UnknownField
gmapM :: (forall d. Data d => d -> m d) -> UnknownField -> m UnknownField
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnknownField -> m UnknownField
gmapQi :: Int -> (forall d. Data d => d -> u) -> UnknownField -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnknownField -> u
gmapQ :: (forall d. Data d => d -> u) -> UnknownField -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UnknownField -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnknownField -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnknownField -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnknownField -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnknownField -> r
gmapT :: (forall b. Data b => b -> b) -> UnknownField -> UnknownField
$cgmapT :: (forall b. Data b => b -> b) -> UnknownField -> UnknownField
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnknownField)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnknownField)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c UnknownField)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnknownField)
dataTypeOf :: UnknownField -> DataType
$cdataTypeOf :: UnknownField -> DataType
toConstr :: UnknownField -> Constr
$ctoConstr :: UnknownField -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnknownField
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnknownField
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnknownField -> c UnknownField
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnknownField -> c UnknownField
$cp1Data :: Typeable UnknownField
Data,Typeable)

data UnknownFieldValue = UFV {-# UNPACK #-} !WireTag !ByteString
  deriving (UnknownFieldValue -> UnknownFieldValue -> Bool
(UnknownFieldValue -> UnknownFieldValue -> Bool)
-> (UnknownFieldValue -> UnknownFieldValue -> Bool)
-> Eq UnknownFieldValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnknownFieldValue -> UnknownFieldValue -> Bool
$c/= :: UnknownFieldValue -> UnknownFieldValue -> Bool
== :: UnknownFieldValue -> UnknownFieldValue -> Bool
$c== :: UnknownFieldValue -> UnknownFieldValue -> Bool
Eq,Eq UnknownFieldValue
Eq UnknownFieldValue
-> (UnknownFieldValue -> UnknownFieldValue -> Ordering)
-> (UnknownFieldValue -> UnknownFieldValue -> Bool)
-> (UnknownFieldValue -> UnknownFieldValue -> Bool)
-> (UnknownFieldValue -> UnknownFieldValue -> Bool)
-> (UnknownFieldValue -> UnknownFieldValue -> Bool)
-> (UnknownFieldValue -> UnknownFieldValue -> UnknownFieldValue)
-> (UnknownFieldValue -> UnknownFieldValue -> UnknownFieldValue)
-> Ord UnknownFieldValue
UnknownFieldValue -> UnknownFieldValue -> Bool
UnknownFieldValue -> UnknownFieldValue -> Ordering
UnknownFieldValue -> UnknownFieldValue -> UnknownFieldValue
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 :: UnknownFieldValue -> UnknownFieldValue -> UnknownFieldValue
$cmin :: UnknownFieldValue -> UnknownFieldValue -> UnknownFieldValue
max :: UnknownFieldValue -> UnknownFieldValue -> UnknownFieldValue
$cmax :: UnknownFieldValue -> UnknownFieldValue -> UnknownFieldValue
>= :: UnknownFieldValue -> UnknownFieldValue -> Bool
$c>= :: UnknownFieldValue -> UnknownFieldValue -> Bool
> :: UnknownFieldValue -> UnknownFieldValue -> Bool
$c> :: UnknownFieldValue -> UnknownFieldValue -> Bool
<= :: UnknownFieldValue -> UnknownFieldValue -> Bool
$c<= :: UnknownFieldValue -> UnknownFieldValue -> Bool
< :: UnknownFieldValue -> UnknownFieldValue -> Bool
$c< :: UnknownFieldValue -> UnknownFieldValue -> Bool
compare :: UnknownFieldValue -> UnknownFieldValue -> Ordering
$ccompare :: UnknownFieldValue -> UnknownFieldValue -> Ordering
$cp1Ord :: Eq UnknownFieldValue
Ord,Int -> UnknownFieldValue -> ShowS
[UnknownFieldValue] -> ShowS
UnknownFieldValue -> String
(Int -> UnknownFieldValue -> ShowS)
-> (UnknownFieldValue -> String)
-> ([UnknownFieldValue] -> ShowS)
-> Show UnknownFieldValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnknownFieldValue] -> ShowS
$cshowList :: [UnknownFieldValue] -> ShowS
show :: UnknownFieldValue -> String
$cshow :: UnknownFieldValue -> String
showsPrec :: Int -> UnknownFieldValue -> ShowS
$cshowsPrec :: Int -> UnknownFieldValue -> ShowS
Show,ReadPrec [UnknownFieldValue]
ReadPrec UnknownFieldValue
Int -> ReadS UnknownFieldValue
ReadS [UnknownFieldValue]
(Int -> ReadS UnknownFieldValue)
-> ReadS [UnknownFieldValue]
-> ReadPrec UnknownFieldValue
-> ReadPrec [UnknownFieldValue]
-> Read UnknownFieldValue
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UnknownFieldValue]
$creadListPrec :: ReadPrec [UnknownFieldValue]
readPrec :: ReadPrec UnknownFieldValue
$creadPrec :: ReadPrec UnknownFieldValue
readList :: ReadS [UnknownFieldValue]
$creadList :: ReadS [UnknownFieldValue]
readsPrec :: Int -> ReadS UnknownFieldValue
$creadsPrec :: Int -> ReadS UnknownFieldValue
Read,Typeable UnknownFieldValue
DataType
Constr
Typeable UnknownFieldValue
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> UnknownFieldValue
    -> c UnknownFieldValue)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UnknownFieldValue)
-> (UnknownFieldValue -> Constr)
-> (UnknownFieldValue -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UnknownFieldValue))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c UnknownFieldValue))
-> ((forall b. Data b => b -> b)
    -> UnknownFieldValue -> UnknownFieldValue)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UnknownFieldValue -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UnknownFieldValue -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> UnknownFieldValue -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UnknownFieldValue -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> UnknownFieldValue -> m UnknownFieldValue)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> UnknownFieldValue -> m UnknownFieldValue)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> UnknownFieldValue -> m UnknownFieldValue)
-> Data UnknownFieldValue
UnknownFieldValue -> DataType
UnknownFieldValue -> Constr
(forall b. Data b => b -> b)
-> UnknownFieldValue -> UnknownFieldValue
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnknownFieldValue -> c UnknownFieldValue
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnknownFieldValue
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> UnknownFieldValue -> u
forall u. (forall d. Data d => d -> u) -> UnknownFieldValue -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnknownFieldValue -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnknownFieldValue -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UnknownFieldValue -> m UnknownFieldValue
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UnknownFieldValue -> m UnknownFieldValue
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnknownFieldValue
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnknownFieldValue -> c UnknownFieldValue
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnknownFieldValue)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnknownFieldValue)
$cUFV :: Constr
$tUnknownFieldValue :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> UnknownFieldValue -> m UnknownFieldValue
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UnknownFieldValue -> m UnknownFieldValue
gmapMp :: (forall d. Data d => d -> m d)
-> UnknownFieldValue -> m UnknownFieldValue
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UnknownFieldValue -> m UnknownFieldValue
gmapM :: (forall d. Data d => d -> m d)
-> UnknownFieldValue -> m UnknownFieldValue
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UnknownFieldValue -> m UnknownFieldValue
gmapQi :: Int -> (forall d. Data d => d -> u) -> UnknownFieldValue -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> UnknownFieldValue -> u
gmapQ :: (forall d. Data d => d -> u) -> UnknownFieldValue -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UnknownFieldValue -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnknownFieldValue -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnknownFieldValue -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnknownFieldValue -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnknownFieldValue -> r
gmapT :: (forall b. Data b => b -> b)
-> UnknownFieldValue -> UnknownFieldValue
$cgmapT :: (forall b. Data b => b -> b)
-> UnknownFieldValue -> UnknownFieldValue
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnknownFieldValue)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnknownFieldValue)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c UnknownFieldValue)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnknownFieldValue)
dataTypeOf :: UnknownFieldValue -> DataType
$cdataTypeOf :: UnknownFieldValue -> DataType
toConstr :: UnknownFieldValue -> Constr
$ctoConstr :: UnknownFieldValue -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnknownFieldValue
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnknownFieldValue
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnknownFieldValue -> c UnknownFieldValue
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnknownFieldValue -> c UnknownFieldValue
$cp1Data :: Typeable UnknownFieldValue
Data,Typeable)

instance Mergeable UnknownField where
--  mergeEmpty = UnknownField mempty
  mergeAppend :: UnknownField -> UnknownField -> UnknownField
mergeAppend (UnknownField Seq UnknownFieldValue
m1) (UnknownField Seq UnknownFieldValue
m2) = Seq UnknownFieldValue -> UnknownField
UnknownField (Seq UnknownFieldValue
-> Seq UnknownFieldValue -> Seq UnknownFieldValue
forall a. Monoid a => a -> a -> a
mappend Seq UnknownFieldValue
m1 Seq UnknownFieldValue
m2)

instance Default UnknownField where
  defaultValue :: UnknownField
defaultValue = Seq UnknownFieldValue -> UnknownField
UnknownField Seq UnknownFieldValue
forall a. Monoid a => a
mempty

-- | This is used by the generated code
wireSizeUnknownField :: UnknownField -> WireSize
wireSizeUnknownField :: UnknownField -> WireSize
wireSizeUnknownField (UnknownField Seq UnknownFieldValue
m) = (WireSize -> UnknownFieldValue -> WireSize)
-> WireSize -> Seq UnknownFieldValue -> WireSize
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl' WireSize -> UnknownFieldValue -> WireSize
aSize WireSize
0 Seq UnknownFieldValue
m  where
  aSize :: WireSize -> UnknownFieldValue -> WireSize
aSize WireSize
old (UFV WireTag
tag ByteString
bs) = WireSize
old WireSize -> WireSize -> WireSize
forall a. Num a => a -> a -> a
+ WireTag -> WireSize
size'WireTag WireTag
tag WireSize -> WireSize -> WireSize
forall a. Num a => a -> a -> a
+ ByteString -> WireSize
L.length ByteString
bs

-- | This is used by the generated code
wirePutUnknownField :: UnknownField -> Put
wirePutUnknownField :: UnknownField -> Put
wirePutUnknownField (UnknownField Seq UnknownFieldValue
m) = (UnknownFieldValue -> Put) -> Seq UnknownFieldValue -> Put
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
F.mapM_ UnknownFieldValue -> Put
aPut Seq UnknownFieldValue
m where
  aPut :: UnknownFieldValue -> Put
aPut (UFV WireTag
tag ByteString
bs) = Word32 -> Put
forall a. (Integral a, Bits a) => a -> Put
putVarUInt (WireTag -> Word32
getWireTag WireTag
tag) Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ByteString -> Put
putLazyByteString ByteString
bs

-- | This is used by the generated code
wirePutUnknownFieldWithSize :: UnknownField -> PutM WireSize
wirePutUnknownFieldWithSize :: UnknownField -> PutM WireSize
wirePutUnknownFieldWithSize UnknownField
m =
  UnknownField -> Put
wirePutUnknownField UnknownField
m Put -> PutM WireSize -> PutM WireSize
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> WireSize -> PutM WireSize
forall (m :: * -> *) a. Monad m => a -> m a
return (UnknownField -> WireSize
wireSizeUnknownField UnknownField
m)

{-# INLINE catch'Unknown #-}
-- | This is used by the generated code. Here for backwards compatibility.
catch'Unknown :: (UnknownMessage a) => (WireTag -> a -> Get a) -> WireTag -> a -> Get a
catch'Unknown :: (WireTag -> a -> Get a) -> WireTag -> a -> Get a
catch'Unknown = (WireTag -> a -> Get a)
-> (WireTag -> a -> Get a) -> WireTag -> a -> Get a
forall a.
(WireTag -> a -> Get a)
-> (WireTag -> a -> Get a) -> WireTag -> a -> Get a
catch'Unknown' WireTag -> a -> Get a
forall a. UnknownMessage a => WireTag -> a -> Get a
loadUnknown

{-# INLINE catch'Unknown' #-}
catch'Unknown' :: (WireTag -> a -> Get a) -> (WireTag -> a -> Get a) -> WireTag -> a -> Get a
catch'Unknown' :: (WireTag -> a -> Get a)
-> (WireTag -> a -> Get a) -> WireTag -> a -> Get a
catch'Unknown' WireTag -> a -> Get a
handleUnknown WireTag -> a -> Get a
update'Self WireTag
wire'Tag a
old'Self =
    Get a -> (String -> Get a) -> Get a
forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
catchError (WireTag -> a -> Get a
update'Self WireTag
wire'Tag a
old'Self) (\String
_ -> WireTag -> a -> Get a
handleUnknown WireTag
wire'Tag a
old'Self)

{-# INLINE loadUnknown #-}
-- | This is used by the generated code
loadUnknown :: (UnknownMessage a) => WireTag -> a -> Get a
loadUnknown :: WireTag -> a -> Get a
loadUnknown WireTag
tag a
msg = do
  let (FieldId
fieldId,WireType
wireType) = WireTag -> (FieldId, WireType)
splitWireTag WireTag
tag
      (UnknownField Seq UnknownFieldValue
uf) = a -> UnknownField
forall msg. UnknownMessage msg => msg -> UnknownField
getUnknownField a
msg
  ByteString
bs <- FieldId -> WireType -> Get ByteString
wireGetFromWire FieldId
fieldId WireType
wireType
  let v' :: UnknownFieldValue
v' = ByteString -> UnknownFieldValue -> UnknownFieldValue
seq ByteString
bs (UnknownFieldValue -> UnknownFieldValue)
-> UnknownFieldValue -> UnknownFieldValue
forall a b. (a -> b) -> a -> b
$ WireTag -> ByteString -> UnknownFieldValue
UFV WireTag
tag ByteString
bs
      uf' :: Seq UnknownFieldValue
uf' = UnknownFieldValue -> Seq UnknownFieldValue -> Seq UnknownFieldValue
seq UnknownFieldValue
v' (Seq UnknownFieldValue -> Seq UnknownFieldValue)
-> Seq UnknownFieldValue -> Seq UnknownFieldValue
forall a b. (a -> b) -> a -> b
$ Seq UnknownFieldValue
uf Seq UnknownFieldValue -> UnknownFieldValue -> Seq UnknownFieldValue
forall a. Seq a -> a -> Seq a
|> UnknownFieldValue
v'
  Seq UnknownFieldValue -> Get a -> Get a
seq Seq UnknownFieldValue
uf' (Get a -> Get a) -> Get a -> Get a
forall a b. (a -> b) -> a -> b
$ a -> Get a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> Get a) -> a -> Get a
forall a b. (a -> b) -> a -> b
$ UnknownField -> a -> a
forall msg. UnknownMessage msg => UnknownField -> msg -> msg
putUnknownField (Seq UnknownFieldValue -> UnknownField
UnknownField Seq UnknownFieldValue
uf') a
msg

{-# INLINE discardUnknown #-}
-- | This is used by the generated code
discardUnknown :: WireTag -> a -> Get a
discardUnknown :: WireTag -> a -> Get a
discardUnknown WireTag
tag a
msg = do
  let (FieldId
fieldId,WireType
wireType) = WireTag -> (FieldId, WireType)
splitWireTag WireTag
tag
  ByteString
_bs <- FieldId -> WireType -> Get ByteString
wireGetFromWire FieldId
fieldId WireType
wireType
  a -> Get a
forall (m :: * -> *) a. Monad m => a -> m a
return a
msg