{-# LANGUAGE DeriveDataTypeable,GeneralizedNewtypeDeriving,CPP #-}
-- | "Text.ProtocolBuffers.Basic" defines or re-exports most of the
-- basic field types; 'Maybe','Bool', 'Double', and 'Float' come from
-- the Prelude instead. This module also defines the 'Mergeable' and
-- 'Default' classes. The 'Wire' class is not defined here to avoid orphans.
module Text.ProtocolBuffers.Basic
  ( -- * Basic types for protocol buffer fields in Haskell
    Double,Float,Bool,Maybe,Seq,Utf8(Utf8),ByteString,Int32,Int64,Word32,Word64
    -- * Haskell types that act in the place of DescritorProto values
  , WireTag(..),FieldId(..),WireType(..),FieldType(..),EnumCode(..),WireSize
    -- * Some of the type classes implemented messages and fields
  , Mergeable(..),Default(..) -- ,Wire(..)
  , isValidUTF8, toUtf8, utf8, uToString, uFromString
  ) where

import Data.Aeson
import Data.Bits(Bits)
import Data.ByteString.Lazy(ByteString)
import Data.Foldable as F(Foldable(foldl))
import Data.Generics(Data(..))
import Data.Int(Int32,Int64)
import Data.Ix(Ix)
import Data.Semigroup (Semigroup(..))
import Data.Sequence(Seq,(><))
import Data.String (IsString(..))
import Data.Typeable(Typeable)
import Data.Word(Word8,Word32,Word64)

import qualified Data.ByteString.Lazy as L(unpack)
import Data.ByteString.Lazy.UTF8 as U (toString,fromString)
import qualified Data.Text.Lazy as TL
import qualified Data.Text.Lazy.Encoding as TL

-- Num instances are derived below for the purpose of getting fromInteger for case matching

-- | 'Utf8' is used to mark 'ByteString' values that (should) contain
-- valid utf8 encoded strings.  This type is used to represent
-- 'TYPE_STRING' values.
newtype Utf8 = Utf8 ByteString deriving (Typeable Utf8
DataType
Constr
Typeable Utf8
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Utf8 -> c Utf8)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Utf8)
-> (Utf8 -> Constr)
-> (Utf8 -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Utf8))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Utf8))
-> ((forall b. Data b => b -> b) -> Utf8 -> Utf8)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r)
-> (forall u. (forall d. Data d => d -> u) -> Utf8 -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Utf8 -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Utf8 -> m Utf8)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Utf8 -> m Utf8)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Utf8 -> m Utf8)
-> Data Utf8
Utf8 -> DataType
Utf8 -> Constr
(forall b. Data b => b -> b) -> Utf8 -> Utf8
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Utf8 -> c Utf8
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Utf8
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) -> Utf8 -> u
forall u. (forall d. Data d => d -> u) -> Utf8 -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Utf8 -> m Utf8
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Utf8 -> m Utf8
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Utf8
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Utf8 -> c Utf8
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Utf8)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Utf8)
$cUtf8 :: Constr
$tUtf8 :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Utf8 -> m Utf8
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Utf8 -> m Utf8
gmapMp :: (forall d. Data d => d -> m d) -> Utf8 -> m Utf8
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Utf8 -> m Utf8
gmapM :: (forall d. Data d => d -> m d) -> Utf8 -> m Utf8
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Utf8 -> m Utf8
gmapQi :: Int -> (forall d. Data d => d -> u) -> Utf8 -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Utf8 -> u
gmapQ :: (forall d. Data d => d -> u) -> Utf8 -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Utf8 -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r
gmapT :: (forall b. Data b => b -> b) -> Utf8 -> Utf8
$cgmapT :: (forall b. Data b => b -> b) -> Utf8 -> Utf8
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Utf8)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Utf8)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Utf8)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Utf8)
dataTypeOf :: Utf8 -> DataType
$cdataTypeOf :: Utf8 -> DataType
toConstr :: Utf8 -> Constr
$ctoConstr :: Utf8 -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Utf8
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Utf8
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Utf8 -> c Utf8
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Utf8 -> c Utf8
$cp1Data :: Typeable Utf8
Data,Typeable,Utf8 -> Utf8 -> Bool
(Utf8 -> Utf8 -> Bool) -> (Utf8 -> Utf8 -> Bool) -> Eq Utf8
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Utf8 -> Utf8 -> Bool
$c/= :: Utf8 -> Utf8 -> Bool
== :: Utf8 -> Utf8 -> Bool
$c== :: Utf8 -> Utf8 -> Bool
Eq,Eq Utf8
Eq Utf8
-> (Utf8 -> Utf8 -> Ordering)
-> (Utf8 -> Utf8 -> Bool)
-> (Utf8 -> Utf8 -> Bool)
-> (Utf8 -> Utf8 -> Bool)
-> (Utf8 -> Utf8 -> Bool)
-> (Utf8 -> Utf8 -> Utf8)
-> (Utf8 -> Utf8 -> Utf8)
-> Ord Utf8
Utf8 -> Utf8 -> Bool
Utf8 -> Utf8 -> Ordering
Utf8 -> Utf8 -> Utf8
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 :: Utf8 -> Utf8 -> Utf8
$cmin :: Utf8 -> Utf8 -> Utf8
max :: Utf8 -> Utf8 -> Utf8
$cmax :: Utf8 -> Utf8 -> Utf8
>= :: Utf8 -> Utf8 -> Bool
$c>= :: Utf8 -> Utf8 -> Bool
> :: Utf8 -> Utf8 -> Bool
$c> :: Utf8 -> Utf8 -> Bool
<= :: Utf8 -> Utf8 -> Bool
$c<= :: Utf8 -> Utf8 -> Bool
< :: Utf8 -> Utf8 -> Bool
$c< :: Utf8 -> Utf8 -> Bool
compare :: Utf8 -> Utf8 -> Ordering
$ccompare :: Utf8 -> Utf8 -> Ordering
$cp1Ord :: Eq Utf8
Ord)

utf8 :: Utf8 -> ByteString
utf8 :: Utf8 -> ByteString
utf8 (Utf8 ByteString
bs) = ByteString
bs

instance Read Utf8 where
  readsPrec :: Int -> ReadS Utf8
readsPrec Int
d String
xs = let r :: Int -> ReadS String
                       r :: Int -> ReadS String
r = Int -> ReadS String
forall a. Read a => Int -> ReadS a
readsPrec
                       f :: (String,String) -> (Utf8,String)
                       f :: (String, String) -> (Utf8, String)
f (String
a,String
b) = (ByteString -> Utf8
Utf8 (String -> ByteString
U.fromString String
a),String
b)
                   in ((String, String) -> (Utf8, String))
-> [(String, String)] -> [(Utf8, String)]
forall a b. (a -> b) -> [a] -> [b]
map (String, String) -> (Utf8, String)
f ([(String, String)] -> [(Utf8, String)])
-> ReadS String -> ReadS Utf8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ReadS String
r Int
d ReadS Utf8 -> ReadS Utf8
forall a b. (a -> b) -> a -> b
$ String
xs

instance Show Utf8 where
  showsPrec :: Int -> Utf8 -> ShowS
showsPrec Int
d (Utf8 ByteString
bs) = let s :: Int -> String -> ShowS
                              s :: Int -> String -> ShowS
s = Int -> String -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec
                          in Int -> String -> ShowS
s Int
d (ByteString -> String
U.toString ByteString
bs)

instance IsString Utf8 where
  fromString :: String -> Utf8
fromString = String -> Utf8
uFromString

instance Semigroup Utf8 where
  <> :: Utf8 -> Utf8 -> Utf8
(<>) (Utf8 ByteString
x) (Utf8 ByteString
y) = ByteString -> Utf8
Utf8 (ByteString
x ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> ByteString
y)

instance Monoid Utf8 where
  mempty :: Utf8
mempty = ByteString -> Utf8
Utf8 ByteString
forall a. Monoid a => a
mempty
  mappend :: Utf8 -> Utf8 -> Utf8
mappend = Utf8 -> Utf8 -> Utf8
forall a. Semigroup a => a -> a -> a
(<>)

instance ToJSON Utf8 where
    toJSON :: Utf8 -> Value
toJSON (Utf8 ByteString
t) = Text -> Value
forall a. ToJSON a => a -> Value
toJSON (ByteString -> Text
TL.decodeUtf8 ByteString
t)

instance FromJSON Utf8 where
    parseJSON :: Value -> Parser Utf8
parseJSON Value
value =
        case Value
value of
          String Text
t -> Utf8 -> Parser Utf8
forall (m :: * -> *) a. Monad m => a -> m a
return (Utf8 -> Parser Utf8) -> (Text -> Utf8) -> Text -> Parser Utf8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Utf8
Utf8 (ByteString -> Utf8) -> (Text -> ByteString) -> Text -> Utf8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
TL.encodeUtf8 (Text -> ByteString) -> (Text -> Text) -> Text -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
TL.fromStrict (Text -> Parser Utf8) -> Text -> Parser Utf8
forall a b. (a -> b) -> a -> b
$ Text
t
          Value
_ -> String -> Parser Utf8
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Value " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Value -> String
forall a. Show a => a -> String
show Value
value String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" is not a UTF-8 string")

-- | 'WireTag' is the 32 bit value with the upper 29 bits being the
-- 'FieldId' and the lower 3 bits being the 'WireType'
newtype WireTag = WireTag { WireTag -> Word32
getWireTag :: Word32 } -- bit concatenation of FieldId and WireType
  deriving (WireTag -> WireTag -> Bool
(WireTag -> WireTag -> Bool)
-> (WireTag -> WireTag -> Bool) -> Eq WireTag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WireTag -> WireTag -> Bool
$c/= :: WireTag -> WireTag -> Bool
== :: WireTag -> WireTag -> Bool
$c== :: WireTag -> WireTag -> Bool
Eq,Eq WireTag
Eq WireTag
-> (WireTag -> WireTag -> Ordering)
-> (WireTag -> WireTag -> Bool)
-> (WireTag -> WireTag -> Bool)
-> (WireTag -> WireTag -> Bool)
-> (WireTag -> WireTag -> Bool)
-> (WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag -> WireTag)
-> Ord WireTag
WireTag -> WireTag -> Bool
WireTag -> WireTag -> Ordering
WireTag -> WireTag -> WireTag
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 :: WireTag -> WireTag -> WireTag
$cmin :: WireTag -> WireTag -> WireTag
max :: WireTag -> WireTag -> WireTag
$cmax :: WireTag -> WireTag -> WireTag
>= :: WireTag -> WireTag -> Bool
$c>= :: WireTag -> WireTag -> Bool
> :: WireTag -> WireTag -> Bool
$c> :: WireTag -> WireTag -> Bool
<= :: WireTag -> WireTag -> Bool
$c<= :: WireTag -> WireTag -> Bool
< :: WireTag -> WireTag -> Bool
$c< :: WireTag -> WireTag -> Bool
compare :: WireTag -> WireTag -> Ordering
$ccompare :: WireTag -> WireTag -> Ordering
$cp1Ord :: Eq WireTag
Ord,Int -> WireTag
WireTag -> Int
WireTag -> [WireTag]
WireTag -> WireTag
WireTag -> WireTag -> [WireTag]
WireTag -> WireTag -> WireTag -> [WireTag]
(WireTag -> WireTag)
-> (WireTag -> WireTag)
-> (Int -> WireTag)
-> (WireTag -> Int)
-> (WireTag -> [WireTag])
-> (WireTag -> WireTag -> [WireTag])
-> (WireTag -> WireTag -> [WireTag])
-> (WireTag -> WireTag -> WireTag -> [WireTag])
-> Enum WireTag
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: WireTag -> WireTag -> WireTag -> [WireTag]
$cenumFromThenTo :: WireTag -> WireTag -> WireTag -> [WireTag]
enumFromTo :: WireTag -> WireTag -> [WireTag]
$cenumFromTo :: WireTag -> WireTag -> [WireTag]
enumFromThen :: WireTag -> WireTag -> [WireTag]
$cenumFromThen :: WireTag -> WireTag -> [WireTag]
enumFrom :: WireTag -> [WireTag]
$cenumFrom :: WireTag -> [WireTag]
fromEnum :: WireTag -> Int
$cfromEnum :: WireTag -> Int
toEnum :: Int -> WireTag
$ctoEnum :: Int -> WireTag
pred :: WireTag -> WireTag
$cpred :: WireTag -> WireTag
succ :: WireTag -> WireTag
$csucc :: WireTag -> WireTag
Enum,ReadPrec [WireTag]
ReadPrec WireTag
Int -> ReadS WireTag
ReadS [WireTag]
(Int -> ReadS WireTag)
-> ReadS [WireTag]
-> ReadPrec WireTag
-> ReadPrec [WireTag]
-> Read WireTag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [WireTag]
$creadListPrec :: ReadPrec [WireTag]
readPrec :: ReadPrec WireTag
$creadPrec :: ReadPrec WireTag
readList :: ReadS [WireTag]
$creadList :: ReadS [WireTag]
readsPrec :: Int -> ReadS WireTag
$creadsPrec :: Int -> ReadS WireTag
Read,Int -> WireTag -> ShowS
[WireTag] -> ShowS
WireTag -> String
(Int -> WireTag -> ShowS)
-> (WireTag -> String) -> ([WireTag] -> ShowS) -> Show WireTag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WireTag] -> ShowS
$cshowList :: [WireTag] -> ShowS
show :: WireTag -> String
$cshow :: WireTag -> String
showsPrec :: Int -> WireTag -> ShowS
$cshowsPrec :: Int -> WireTag -> ShowS
Show,Integer -> WireTag
WireTag -> WireTag
WireTag -> WireTag -> WireTag
(WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag)
-> (WireTag -> WireTag)
-> (WireTag -> WireTag)
-> (Integer -> WireTag)
-> Num WireTag
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> WireTag
$cfromInteger :: Integer -> WireTag
signum :: WireTag -> WireTag
$csignum :: WireTag -> WireTag
abs :: WireTag -> WireTag
$cabs :: WireTag -> WireTag
negate :: WireTag -> WireTag
$cnegate :: WireTag -> WireTag
* :: WireTag -> WireTag -> WireTag
$c* :: WireTag -> WireTag -> WireTag
- :: WireTag -> WireTag -> WireTag
$c- :: WireTag -> WireTag -> WireTag
+ :: WireTag -> WireTag -> WireTag
$c+ :: WireTag -> WireTag -> WireTag
Num,Eq WireTag
WireTag
Eq WireTag
-> (WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> WireTag
-> (Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> Bool)
-> (WireTag -> Maybe Int)
-> (WireTag -> Int)
-> (WireTag -> Bool)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int)
-> Bits WireTag
Int -> WireTag
WireTag -> Bool
WireTag -> Int
WireTag -> Maybe Int
WireTag -> WireTag
WireTag -> Int -> Bool
WireTag -> Int -> WireTag
WireTag -> WireTag -> WireTag
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: WireTag -> Int
$cpopCount :: WireTag -> Int
rotateR :: WireTag -> Int -> WireTag
$crotateR :: WireTag -> Int -> WireTag
rotateL :: WireTag -> Int -> WireTag
$crotateL :: WireTag -> Int -> WireTag
unsafeShiftR :: WireTag -> Int -> WireTag
$cunsafeShiftR :: WireTag -> Int -> WireTag
shiftR :: WireTag -> Int -> WireTag
$cshiftR :: WireTag -> Int -> WireTag
unsafeShiftL :: WireTag -> Int -> WireTag
$cunsafeShiftL :: WireTag -> Int -> WireTag
shiftL :: WireTag -> Int -> WireTag
$cshiftL :: WireTag -> Int -> WireTag
isSigned :: WireTag -> Bool
$cisSigned :: WireTag -> Bool
bitSize :: WireTag -> Int
$cbitSize :: WireTag -> Int
bitSizeMaybe :: WireTag -> Maybe Int
$cbitSizeMaybe :: WireTag -> Maybe Int
testBit :: WireTag -> Int -> Bool
$ctestBit :: WireTag -> Int -> Bool
complementBit :: WireTag -> Int -> WireTag
$ccomplementBit :: WireTag -> Int -> WireTag
clearBit :: WireTag -> Int -> WireTag
$cclearBit :: WireTag -> Int -> WireTag
setBit :: WireTag -> Int -> WireTag
$csetBit :: WireTag -> Int -> WireTag
bit :: Int -> WireTag
$cbit :: Int -> WireTag
zeroBits :: WireTag
$czeroBits :: WireTag
rotate :: WireTag -> Int -> WireTag
$crotate :: WireTag -> Int -> WireTag
shift :: WireTag -> Int -> WireTag
$cshift :: WireTag -> Int -> WireTag
complement :: WireTag -> WireTag
$ccomplement :: WireTag -> WireTag
xor :: WireTag -> WireTag -> WireTag
$cxor :: WireTag -> WireTag -> WireTag
.|. :: WireTag -> WireTag -> WireTag
$c.|. :: WireTag -> WireTag -> WireTag
.&. :: WireTag -> WireTag -> WireTag
$c.&. :: WireTag -> WireTag -> WireTag
$cp1Bits :: Eq WireTag
Bits,WireTag
WireTag -> WireTag -> Bounded WireTag
forall a. a -> a -> Bounded a
maxBound :: WireTag
$cmaxBound :: WireTag
minBound :: WireTag
$cminBound :: WireTag
Bounded,Typeable WireTag
DataType
Constr
Typeable WireTag
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WireTag -> c WireTag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WireTag)
-> (WireTag -> Constr)
-> (WireTag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c WireTag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireTag))
-> ((forall b. Data b => b -> b) -> WireTag -> WireTag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WireTag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WireTag -> r)
-> (forall u. (forall d. Data d => d -> u) -> WireTag -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> WireTag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> WireTag -> m WireTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WireTag -> m WireTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WireTag -> m WireTag)
-> Data WireTag
WireTag -> DataType
WireTag -> Constr
(forall b. Data b => b -> b) -> WireTag -> WireTag
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireTag -> c WireTag
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireTag
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) -> WireTag -> u
forall u. (forall d. Data d => d -> u) -> WireTag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WireTag -> m WireTag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireTag -> m WireTag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireTag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireTag -> c WireTag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireTag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireTag)
$cWireTag :: Constr
$tWireTag :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> WireTag -> m WireTag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireTag -> m WireTag
gmapMp :: (forall d. Data d => d -> m d) -> WireTag -> m WireTag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireTag -> m WireTag
gmapM :: (forall d. Data d => d -> m d) -> WireTag -> m WireTag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WireTag -> m WireTag
gmapQi :: Int -> (forall d. Data d => d -> u) -> WireTag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WireTag -> u
gmapQ :: (forall d. Data d => d -> u) -> WireTag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> WireTag -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r
gmapT :: (forall b. Data b => b -> b) -> WireTag -> WireTag
$cgmapT :: (forall b. Data b => b -> b) -> WireTag -> WireTag
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireTag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireTag)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c WireTag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireTag)
dataTypeOf :: WireTag -> DataType
$cdataTypeOf :: WireTag -> DataType
toConstr :: WireTag -> Constr
$ctoConstr :: WireTag -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireTag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireTag
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireTag -> c WireTag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireTag -> c WireTag
$cp1Data :: Typeable WireTag
Data,Typeable)

-- | 'FieldId' is the field number which can be in the range 1 to
-- 2^29-1 but the value from 19000 to 19999 are forbidden (so sayeth
-- Google).
newtype FieldId = FieldId { FieldId -> Int32
getFieldId :: Int32 } -- really 29 bits
  deriving (FieldId -> FieldId -> Bool
(FieldId -> FieldId -> Bool)
-> (FieldId -> FieldId -> Bool) -> Eq FieldId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldId -> FieldId -> Bool
$c/= :: FieldId -> FieldId -> Bool
== :: FieldId -> FieldId -> Bool
$c== :: FieldId -> FieldId -> Bool
Eq,Eq FieldId
Eq FieldId
-> (FieldId -> FieldId -> Ordering)
-> (FieldId -> FieldId -> Bool)
-> (FieldId -> FieldId -> Bool)
-> (FieldId -> FieldId -> Bool)
-> (FieldId -> FieldId -> Bool)
-> (FieldId -> FieldId -> FieldId)
-> (FieldId -> FieldId -> FieldId)
-> Ord FieldId
FieldId -> FieldId -> Bool
FieldId -> FieldId -> Ordering
FieldId -> FieldId -> FieldId
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 :: FieldId -> FieldId -> FieldId
$cmin :: FieldId -> FieldId -> FieldId
max :: FieldId -> FieldId -> FieldId
$cmax :: FieldId -> FieldId -> FieldId
>= :: FieldId -> FieldId -> Bool
$c>= :: FieldId -> FieldId -> Bool
> :: FieldId -> FieldId -> Bool
$c> :: FieldId -> FieldId -> Bool
<= :: FieldId -> FieldId -> Bool
$c<= :: FieldId -> FieldId -> Bool
< :: FieldId -> FieldId -> Bool
$c< :: FieldId -> FieldId -> Bool
compare :: FieldId -> FieldId -> Ordering
$ccompare :: FieldId -> FieldId -> Ordering
$cp1Ord :: Eq FieldId
Ord,Int -> FieldId
FieldId -> Int
FieldId -> [FieldId]
FieldId -> FieldId
FieldId -> FieldId -> [FieldId]
FieldId -> FieldId -> FieldId -> [FieldId]
(FieldId -> FieldId)
-> (FieldId -> FieldId)
-> (Int -> FieldId)
-> (FieldId -> Int)
-> (FieldId -> [FieldId])
-> (FieldId -> FieldId -> [FieldId])
-> (FieldId -> FieldId -> [FieldId])
-> (FieldId -> FieldId -> FieldId -> [FieldId])
-> Enum FieldId
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: FieldId -> FieldId -> FieldId -> [FieldId]
$cenumFromThenTo :: FieldId -> FieldId -> FieldId -> [FieldId]
enumFromTo :: FieldId -> FieldId -> [FieldId]
$cenumFromTo :: FieldId -> FieldId -> [FieldId]
enumFromThen :: FieldId -> FieldId -> [FieldId]
$cenumFromThen :: FieldId -> FieldId -> [FieldId]
enumFrom :: FieldId -> [FieldId]
$cenumFrom :: FieldId -> [FieldId]
fromEnum :: FieldId -> Int
$cfromEnum :: FieldId -> Int
toEnum :: Int -> FieldId
$ctoEnum :: Int -> FieldId
pred :: FieldId -> FieldId
$cpred :: FieldId -> FieldId
succ :: FieldId -> FieldId
$csucc :: FieldId -> FieldId
Enum,ReadPrec [FieldId]
ReadPrec FieldId
Int -> ReadS FieldId
ReadS [FieldId]
(Int -> ReadS FieldId)
-> ReadS [FieldId]
-> ReadPrec FieldId
-> ReadPrec [FieldId]
-> Read FieldId
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FieldId]
$creadListPrec :: ReadPrec [FieldId]
readPrec :: ReadPrec FieldId
$creadPrec :: ReadPrec FieldId
readList :: ReadS [FieldId]
$creadList :: ReadS [FieldId]
readsPrec :: Int -> ReadS FieldId
$creadsPrec :: Int -> ReadS FieldId
Read,Int -> FieldId -> ShowS
[FieldId] -> ShowS
FieldId -> String
(Int -> FieldId -> ShowS)
-> (FieldId -> String) -> ([FieldId] -> ShowS) -> Show FieldId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FieldId] -> ShowS
$cshowList :: [FieldId] -> ShowS
show :: FieldId -> String
$cshow :: FieldId -> String
showsPrec :: Int -> FieldId -> ShowS
$cshowsPrec :: Int -> FieldId -> ShowS
Show,Integer -> FieldId
FieldId -> FieldId
FieldId -> FieldId -> FieldId
(FieldId -> FieldId -> FieldId)
-> (FieldId -> FieldId -> FieldId)
-> (FieldId -> FieldId -> FieldId)
-> (FieldId -> FieldId)
-> (FieldId -> FieldId)
-> (FieldId -> FieldId)
-> (Integer -> FieldId)
-> Num FieldId
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> FieldId
$cfromInteger :: Integer -> FieldId
signum :: FieldId -> FieldId
$csignum :: FieldId -> FieldId
abs :: FieldId -> FieldId
$cabs :: FieldId -> FieldId
negate :: FieldId -> FieldId
$cnegate :: FieldId -> FieldId
* :: FieldId -> FieldId -> FieldId
$c* :: FieldId -> FieldId -> FieldId
- :: FieldId -> FieldId -> FieldId
$c- :: FieldId -> FieldId -> FieldId
+ :: FieldId -> FieldId -> FieldId
$c+ :: FieldId -> FieldId -> FieldId
Num,Typeable FieldId
DataType
Constr
Typeable FieldId
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FieldId -> c FieldId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FieldId)
-> (FieldId -> Constr)
-> (FieldId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FieldId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldId))
-> ((forall b. Data b => b -> b) -> FieldId -> FieldId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldId -> r)
-> (forall u. (forall d. Data d => d -> u) -> FieldId -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FieldId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FieldId -> m FieldId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldId -> m FieldId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldId -> m FieldId)
-> Data FieldId
FieldId -> DataType
FieldId -> Constr
(forall b. Data b => b -> b) -> FieldId -> FieldId
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldId -> c FieldId
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldId
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) -> FieldId -> u
forall u. (forall d. Data d => d -> u) -> FieldId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldId -> c FieldId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldId)
$cFieldId :: Constr
$tFieldId :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FieldId -> m FieldId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
gmapMp :: (forall d. Data d => d -> m d) -> FieldId -> m FieldId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
gmapM :: (forall d. Data d => d -> m d) -> FieldId -> m FieldId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldId -> u
gmapQ :: (forall d. Data d => d -> u) -> FieldId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FieldId -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
gmapT :: (forall b. Data b => b -> b) -> FieldId -> FieldId
$cgmapT :: (forall b. Data b => b -> b) -> FieldId -> FieldId
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldId)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FieldId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldId)
dataTypeOf :: FieldId -> DataType
$cdataTypeOf :: FieldId -> DataType
toConstr :: FieldId -> Constr
$ctoConstr :: FieldId -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldId
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldId -> c FieldId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldId -> c FieldId
$cp1Data :: Typeable FieldId
Data,Typeable,Ord FieldId
Ord FieldId
-> ((FieldId, FieldId) -> [FieldId])
-> ((FieldId, FieldId) -> FieldId -> Int)
-> ((FieldId, FieldId) -> FieldId -> Int)
-> ((FieldId, FieldId) -> FieldId -> Bool)
-> ((FieldId, FieldId) -> Int)
-> ((FieldId, FieldId) -> Int)
-> Ix FieldId
(FieldId, FieldId) -> Int
(FieldId, FieldId) -> [FieldId]
(FieldId, FieldId) -> FieldId -> Bool
(FieldId, FieldId) -> FieldId -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (FieldId, FieldId) -> Int
$cunsafeRangeSize :: (FieldId, FieldId) -> Int
rangeSize :: (FieldId, FieldId) -> Int
$crangeSize :: (FieldId, FieldId) -> Int
inRange :: (FieldId, FieldId) -> FieldId -> Bool
$cinRange :: (FieldId, FieldId) -> FieldId -> Bool
unsafeIndex :: (FieldId, FieldId) -> FieldId -> Int
$cunsafeIndex :: (FieldId, FieldId) -> FieldId -> Int
index :: (FieldId, FieldId) -> FieldId -> Int
$cindex :: (FieldId, FieldId) -> FieldId -> Int
range :: (FieldId, FieldId) -> [FieldId]
$crange :: (FieldId, FieldId) -> [FieldId]
$cp1Ix :: Ord FieldId
Ix)

-- Note that values 19000-19999 are forbidden for FieldId
instance Bounded FieldId where
  minBound :: FieldId
minBound = FieldId
1
  maxBound :: FieldId
maxBound = FieldId
536870911 -- 2^29-1

-- | 'WireType' is the 3 bit wire encoding value, and is currently in
-- the range 0 to 5, leaving 6 and 7 currently invalid.
--
-- * 0 /Varint/ : int32, int64, uint32, uint64, sint32, sint64, bool, enum
--
-- * 1 /64-bit/ : fixed64, sfixed64, double
--
-- * 2 /Length-delimited/ : string, bytes, embedded messages
--
-- * 3 /Start group/ : groups (deprecated)
--
-- * 4 /End group/ : groups (deprecated)
--
-- * 5 /32-bit/ : fixed32, sfixed32, float
--
newtype WireType = WireType { WireType -> Word32
getWireType :: Word32 }    -- really 3 bits
  deriving (WireType -> WireType -> Bool
(WireType -> WireType -> Bool)
-> (WireType -> WireType -> Bool) -> Eq WireType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WireType -> WireType -> Bool
$c/= :: WireType -> WireType -> Bool
== :: WireType -> WireType -> Bool
$c== :: WireType -> WireType -> Bool
Eq,Eq WireType
Eq WireType
-> (WireType -> WireType -> Ordering)
-> (WireType -> WireType -> Bool)
-> (WireType -> WireType -> Bool)
-> (WireType -> WireType -> Bool)
-> (WireType -> WireType -> Bool)
-> (WireType -> WireType -> WireType)
-> (WireType -> WireType -> WireType)
-> Ord WireType
WireType -> WireType -> Bool
WireType -> WireType -> Ordering
WireType -> WireType -> WireType
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 :: WireType -> WireType -> WireType
$cmin :: WireType -> WireType -> WireType
max :: WireType -> WireType -> WireType
$cmax :: WireType -> WireType -> WireType
>= :: WireType -> WireType -> Bool
$c>= :: WireType -> WireType -> Bool
> :: WireType -> WireType -> Bool
$c> :: WireType -> WireType -> Bool
<= :: WireType -> WireType -> Bool
$c<= :: WireType -> WireType -> Bool
< :: WireType -> WireType -> Bool
$c< :: WireType -> WireType -> Bool
compare :: WireType -> WireType -> Ordering
$ccompare :: WireType -> WireType -> Ordering
$cp1Ord :: Eq WireType
Ord,Int -> WireType
WireType -> Int
WireType -> [WireType]
WireType -> WireType
WireType -> WireType -> [WireType]
WireType -> WireType -> WireType -> [WireType]
(WireType -> WireType)
-> (WireType -> WireType)
-> (Int -> WireType)
-> (WireType -> Int)
-> (WireType -> [WireType])
-> (WireType -> WireType -> [WireType])
-> (WireType -> WireType -> [WireType])
-> (WireType -> WireType -> WireType -> [WireType])
-> Enum WireType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: WireType -> WireType -> WireType -> [WireType]
$cenumFromThenTo :: WireType -> WireType -> WireType -> [WireType]
enumFromTo :: WireType -> WireType -> [WireType]
$cenumFromTo :: WireType -> WireType -> [WireType]
enumFromThen :: WireType -> WireType -> [WireType]
$cenumFromThen :: WireType -> WireType -> [WireType]
enumFrom :: WireType -> [WireType]
$cenumFrom :: WireType -> [WireType]
fromEnum :: WireType -> Int
$cfromEnum :: WireType -> Int
toEnum :: Int -> WireType
$ctoEnum :: Int -> WireType
pred :: WireType -> WireType
$cpred :: WireType -> WireType
succ :: WireType -> WireType
$csucc :: WireType -> WireType
Enum,ReadPrec [WireType]
ReadPrec WireType
Int -> ReadS WireType
ReadS [WireType]
(Int -> ReadS WireType)
-> ReadS [WireType]
-> ReadPrec WireType
-> ReadPrec [WireType]
-> Read WireType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [WireType]
$creadListPrec :: ReadPrec [WireType]
readPrec :: ReadPrec WireType
$creadPrec :: ReadPrec WireType
readList :: ReadS [WireType]
$creadList :: ReadS [WireType]
readsPrec :: Int -> ReadS WireType
$creadsPrec :: Int -> ReadS WireType
Read,Int -> WireType -> ShowS
[WireType] -> ShowS
WireType -> String
(Int -> WireType -> ShowS)
-> (WireType -> String) -> ([WireType] -> ShowS) -> Show WireType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WireType] -> ShowS
$cshowList :: [WireType] -> ShowS
show :: WireType -> String
$cshow :: WireType -> String
showsPrec :: Int -> WireType -> ShowS
$cshowsPrec :: Int -> WireType -> ShowS
Show,Integer -> WireType
WireType -> WireType
WireType -> WireType -> WireType
(WireType -> WireType -> WireType)
-> (WireType -> WireType -> WireType)
-> (WireType -> WireType -> WireType)
-> (WireType -> WireType)
-> (WireType -> WireType)
-> (WireType -> WireType)
-> (Integer -> WireType)
-> Num WireType
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> WireType
$cfromInteger :: Integer -> WireType
signum :: WireType -> WireType
$csignum :: WireType -> WireType
abs :: WireType -> WireType
$cabs :: WireType -> WireType
negate :: WireType -> WireType
$cnegate :: WireType -> WireType
* :: WireType -> WireType -> WireType
$c* :: WireType -> WireType -> WireType
- :: WireType -> WireType -> WireType
$c- :: WireType -> WireType -> WireType
+ :: WireType -> WireType -> WireType
$c+ :: WireType -> WireType -> WireType
Num,Typeable WireType
DataType
Constr
Typeable WireType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WireType -> c WireType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WireType)
-> (WireType -> Constr)
-> (WireType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c WireType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireType))
-> ((forall b. Data b => b -> b) -> WireType -> WireType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WireType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WireType -> r)
-> (forall u. (forall d. Data d => d -> u) -> WireType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> WireType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> WireType -> m WireType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WireType -> m WireType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WireType -> m WireType)
-> Data WireType
WireType -> DataType
WireType -> Constr
(forall b. Data b => b -> b) -> WireType -> WireType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireType -> c WireType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireType
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) -> WireType -> u
forall u. (forall d. Data d => d -> u) -> WireType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WireType -> m WireType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireType -> m WireType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireType -> c WireType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireType)
$cWireType :: Constr
$tWireType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> WireType -> m WireType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireType -> m WireType
gmapMp :: (forall d. Data d => d -> m d) -> WireType -> m WireType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireType -> m WireType
gmapM :: (forall d. Data d => d -> m d) -> WireType -> m WireType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WireType -> m WireType
gmapQi :: Int -> (forall d. Data d => d -> u) -> WireType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WireType -> u
gmapQ :: (forall d. Data d => d -> u) -> WireType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> WireType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r
gmapT :: (forall b. Data b => b -> b) -> WireType -> WireType
$cgmapT :: (forall b. Data b => b -> b) -> WireType -> WireType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c WireType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireType)
dataTypeOf :: WireType -> DataType
$cdataTypeOf :: WireType -> DataType
toConstr :: WireType -> Constr
$ctoConstr :: WireType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireType -> c WireType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireType -> c WireType
$cp1Data :: Typeable WireType
Data,Typeable)

instance Bounded WireType where
  minBound :: WireType
minBound = WireType
0
  maxBound :: WireType
maxBound = WireType
5

{- | 'FieldType' is the integer associated with the
  FieldDescriptorProto's Type.  The allowed range is currently 1 to
  18, as shown below (excerpt from descritor.proto)

>    // 0 is reserved for errors.
>    // Order is weird for historical reasons.
>    TYPE_DOUBLE         = 1;
>    TYPE_FLOAT          = 2;
>    TYPE_INT64          = 3;   // Not ZigZag encoded.  Negative numbers
>                               // take 10 bytes.  Use TYPE_SINT64 if negative
>                               // values are likely.
>    TYPE_UINT64         = 4;
>    TYPE_INT32          = 5;   // Not ZigZag encoded.  Negative numbers
>                               // take 10 bytes.  Use TYPE_SINT32 if negative
>                               // values are likely.
>    TYPE_FIXED64        = 6;
>    TYPE_FIXED32        = 7;
>    TYPE_BOOL           = 8;
>    TYPE_STRING         = 9;
>    TYPE_GROUP          = 10;  // Tag-delimited aggregate.
>    TYPE_MESSAGE        = 11;  // Length-delimited aggregate.
>
>    // New in version 2.
>    TYPE_BYTES          = 12;
>    TYPE_UINT32         = 13;
>    TYPE_ENUM           = 14;
>    TYPE_SFIXED32       = 15;
>    TYPE_SFIXED64       = 16;
>    TYPE_SINT32         = 17;  // Uses ZigZag encoding.
>    TYPE_SINT64         = 18;  // Uses ZigZag encoding.

-}

newtype FieldType = FieldType { FieldType -> Int
getFieldType :: Int } -- really [1..18] as fromEnum of Type from Type.hs
  deriving (FieldType -> FieldType -> Bool
(FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> Bool) -> Eq FieldType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldType -> FieldType -> Bool
$c/= :: FieldType -> FieldType -> Bool
== :: FieldType -> FieldType -> Bool
$c== :: FieldType -> FieldType -> Bool
Eq,Eq FieldType
Eq FieldType
-> (FieldType -> FieldType -> Ordering)
-> (FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> FieldType)
-> (FieldType -> FieldType -> FieldType)
-> Ord FieldType
FieldType -> FieldType -> Bool
FieldType -> FieldType -> Ordering
FieldType -> FieldType -> FieldType
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 :: FieldType -> FieldType -> FieldType
$cmin :: FieldType -> FieldType -> FieldType
max :: FieldType -> FieldType -> FieldType
$cmax :: FieldType -> FieldType -> FieldType
>= :: FieldType -> FieldType -> Bool
$c>= :: FieldType -> FieldType -> Bool
> :: FieldType -> FieldType -> Bool
$c> :: FieldType -> FieldType -> Bool
<= :: FieldType -> FieldType -> Bool
$c<= :: FieldType -> FieldType -> Bool
< :: FieldType -> FieldType -> Bool
$c< :: FieldType -> FieldType -> Bool
compare :: FieldType -> FieldType -> Ordering
$ccompare :: FieldType -> FieldType -> Ordering
$cp1Ord :: Eq FieldType
Ord,Int -> FieldType
FieldType -> Int
FieldType -> [FieldType]
FieldType -> FieldType
FieldType -> FieldType -> [FieldType]
FieldType -> FieldType -> FieldType -> [FieldType]
(FieldType -> FieldType)
-> (FieldType -> FieldType)
-> (Int -> FieldType)
-> (FieldType -> Int)
-> (FieldType -> [FieldType])
-> (FieldType -> FieldType -> [FieldType])
-> (FieldType -> FieldType -> [FieldType])
-> (FieldType -> FieldType -> FieldType -> [FieldType])
-> Enum FieldType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: FieldType -> FieldType -> FieldType -> [FieldType]
$cenumFromThenTo :: FieldType -> FieldType -> FieldType -> [FieldType]
enumFromTo :: FieldType -> FieldType -> [FieldType]
$cenumFromTo :: FieldType -> FieldType -> [FieldType]
enumFromThen :: FieldType -> FieldType -> [FieldType]
$cenumFromThen :: FieldType -> FieldType -> [FieldType]
enumFrom :: FieldType -> [FieldType]
$cenumFrom :: FieldType -> [FieldType]
fromEnum :: FieldType -> Int
$cfromEnum :: FieldType -> Int
toEnum :: Int -> FieldType
$ctoEnum :: Int -> FieldType
pred :: FieldType -> FieldType
$cpred :: FieldType -> FieldType
succ :: FieldType -> FieldType
$csucc :: FieldType -> FieldType
Enum,ReadPrec [FieldType]
ReadPrec FieldType
Int -> ReadS FieldType
ReadS [FieldType]
(Int -> ReadS FieldType)
-> ReadS [FieldType]
-> ReadPrec FieldType
-> ReadPrec [FieldType]
-> Read FieldType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FieldType]
$creadListPrec :: ReadPrec [FieldType]
readPrec :: ReadPrec FieldType
$creadPrec :: ReadPrec FieldType
readList :: ReadS [FieldType]
$creadList :: ReadS [FieldType]
readsPrec :: Int -> ReadS FieldType
$creadsPrec :: Int -> ReadS FieldType
Read,Int -> FieldType -> ShowS
[FieldType] -> ShowS
FieldType -> String
(Int -> FieldType -> ShowS)
-> (FieldType -> String)
-> ([FieldType] -> ShowS)
-> Show FieldType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FieldType] -> ShowS
$cshowList :: [FieldType] -> ShowS
show :: FieldType -> String
$cshow :: FieldType -> String
showsPrec :: Int -> FieldType -> ShowS
$cshowsPrec :: Int -> FieldType -> ShowS
Show,Integer -> FieldType
FieldType -> FieldType
FieldType -> FieldType -> FieldType
(FieldType -> FieldType -> FieldType)
-> (FieldType -> FieldType -> FieldType)
-> (FieldType -> FieldType -> FieldType)
-> (FieldType -> FieldType)
-> (FieldType -> FieldType)
-> (FieldType -> FieldType)
-> (Integer -> FieldType)
-> Num FieldType
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> FieldType
$cfromInteger :: Integer -> FieldType
signum :: FieldType -> FieldType
$csignum :: FieldType -> FieldType
abs :: FieldType -> FieldType
$cabs :: FieldType -> FieldType
negate :: FieldType -> FieldType
$cnegate :: FieldType -> FieldType
* :: FieldType -> FieldType -> FieldType
$c* :: FieldType -> FieldType -> FieldType
- :: FieldType -> FieldType -> FieldType
$c- :: FieldType -> FieldType -> FieldType
+ :: FieldType -> FieldType -> FieldType
$c+ :: FieldType -> FieldType -> FieldType
Num,Typeable FieldType
DataType
Constr
Typeable FieldType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FieldType -> c FieldType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FieldType)
-> (FieldType -> Constr)
-> (FieldType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FieldType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldType))
-> ((forall b. Data b => b -> b) -> FieldType -> FieldType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldType -> r)
-> (forall u. (forall d. Data d => d -> u) -> FieldType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FieldType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FieldType -> m FieldType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldType -> m FieldType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldType -> m FieldType)
-> Data FieldType
FieldType -> DataType
FieldType -> Constr
(forall b. Data b => b -> b) -> FieldType -> FieldType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldType -> c FieldType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldType
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) -> FieldType -> u
forall u. (forall d. Data d => d -> u) -> FieldType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldType -> m FieldType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldType -> m FieldType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldType -> c FieldType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldType)
$cFieldType :: Constr
$tFieldType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FieldType -> m FieldType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldType -> m FieldType
gmapMp :: (forall d. Data d => d -> m d) -> FieldType -> m FieldType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldType -> m FieldType
gmapM :: (forall d. Data d => d -> m d) -> FieldType -> m FieldType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldType -> m FieldType
gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldType -> u
gmapQ :: (forall d. Data d => d -> u) -> FieldType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FieldType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r
gmapT :: (forall b. Data b => b -> b) -> FieldType -> FieldType
$cgmapT :: (forall b. Data b => b -> b) -> FieldType -> FieldType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FieldType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldType)
dataTypeOf :: FieldType -> DataType
$cdataTypeOf :: FieldType -> DataType
toConstr :: FieldType -> Constr
$ctoConstr :: FieldType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldType -> c FieldType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldType -> c FieldType
$cp1Data :: Typeable FieldType
Data,Typeable)

instance Bounded FieldType where
  minBound :: FieldType
minBound = FieldType
1
  maxBound :: FieldType
maxBound = FieldType
18

-- | 'EnumCode' is the Int32 assoicated with a
-- EnumValueDescriptorProto and is in the range 0 to 2^31-1.
newtype EnumCode = EnumCode { EnumCode -> Int32
getEnumCode :: Int32 }  -- really [0..maxBound::Int32] of some .proto defined enumeration
  deriving (EnumCode -> EnumCode -> Bool
(EnumCode -> EnumCode -> Bool)
-> (EnumCode -> EnumCode -> Bool) -> Eq EnumCode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EnumCode -> EnumCode -> Bool
$c/= :: EnumCode -> EnumCode -> Bool
== :: EnumCode -> EnumCode -> Bool
$c== :: EnumCode -> EnumCode -> Bool
Eq,Eq EnumCode
Eq EnumCode
-> (EnumCode -> EnumCode -> Ordering)
-> (EnumCode -> EnumCode -> Bool)
-> (EnumCode -> EnumCode -> Bool)
-> (EnumCode -> EnumCode -> Bool)
-> (EnumCode -> EnumCode -> Bool)
-> (EnumCode -> EnumCode -> EnumCode)
-> (EnumCode -> EnumCode -> EnumCode)
-> Ord EnumCode
EnumCode -> EnumCode -> Bool
EnumCode -> EnumCode -> Ordering
EnumCode -> EnumCode -> EnumCode
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 :: EnumCode -> EnumCode -> EnumCode
$cmin :: EnumCode -> EnumCode -> EnumCode
max :: EnumCode -> EnumCode -> EnumCode
$cmax :: EnumCode -> EnumCode -> EnumCode
>= :: EnumCode -> EnumCode -> Bool
$c>= :: EnumCode -> EnumCode -> Bool
> :: EnumCode -> EnumCode -> Bool
$c> :: EnumCode -> EnumCode -> Bool
<= :: EnumCode -> EnumCode -> Bool
$c<= :: EnumCode -> EnumCode -> Bool
< :: EnumCode -> EnumCode -> Bool
$c< :: EnumCode -> EnumCode -> Bool
compare :: EnumCode -> EnumCode -> Ordering
$ccompare :: EnumCode -> EnumCode -> Ordering
$cp1Ord :: Eq EnumCode
Ord,ReadPrec [EnumCode]
ReadPrec EnumCode
Int -> ReadS EnumCode
ReadS [EnumCode]
(Int -> ReadS EnumCode)
-> ReadS [EnumCode]
-> ReadPrec EnumCode
-> ReadPrec [EnumCode]
-> Read EnumCode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [EnumCode]
$creadListPrec :: ReadPrec [EnumCode]
readPrec :: ReadPrec EnumCode
$creadPrec :: ReadPrec EnumCode
readList :: ReadS [EnumCode]
$creadList :: ReadS [EnumCode]
readsPrec :: Int -> ReadS EnumCode
$creadsPrec :: Int -> ReadS EnumCode
Read,Int -> EnumCode -> ShowS
[EnumCode] -> ShowS
EnumCode -> String
(Int -> EnumCode -> ShowS)
-> (EnumCode -> String) -> ([EnumCode] -> ShowS) -> Show EnumCode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EnumCode] -> ShowS
$cshowList :: [EnumCode] -> ShowS
show :: EnumCode -> String
$cshow :: EnumCode -> String
showsPrec :: Int -> EnumCode -> ShowS
$cshowsPrec :: Int -> EnumCode -> ShowS
Show,Integer -> EnumCode
EnumCode -> EnumCode
EnumCode -> EnumCode -> EnumCode
(EnumCode -> EnumCode -> EnumCode)
-> (EnumCode -> EnumCode -> EnumCode)
-> (EnumCode -> EnumCode -> EnumCode)
-> (EnumCode -> EnumCode)
-> (EnumCode -> EnumCode)
-> (EnumCode -> EnumCode)
-> (Integer -> EnumCode)
-> Num EnumCode
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> EnumCode
$cfromInteger :: Integer -> EnumCode
signum :: EnumCode -> EnumCode
$csignum :: EnumCode -> EnumCode
abs :: EnumCode -> EnumCode
$cabs :: EnumCode -> EnumCode
negate :: EnumCode -> EnumCode
$cnegate :: EnumCode -> EnumCode
* :: EnumCode -> EnumCode -> EnumCode
$c* :: EnumCode -> EnumCode -> EnumCode
- :: EnumCode -> EnumCode -> EnumCode
$c- :: EnumCode -> EnumCode -> EnumCode
+ :: EnumCode -> EnumCode -> EnumCode
$c+ :: EnumCode -> EnumCode -> EnumCode
Num,Typeable EnumCode
DataType
Constr
Typeable EnumCode
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EnumCode -> c EnumCode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EnumCode)
-> (EnumCode -> Constr)
-> (EnumCode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EnumCode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumCode))
-> ((forall b. Data b => b -> b) -> EnumCode -> EnumCode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumCode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumCode -> r)
-> (forall u. (forall d. Data d => d -> u) -> EnumCode -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> EnumCode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EnumCode -> m EnumCode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EnumCode -> m EnumCode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EnumCode -> m EnumCode)
-> Data EnumCode
EnumCode -> DataType
EnumCode -> Constr
(forall b. Data b => b -> b) -> EnumCode -> EnumCode
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumCode -> c EnumCode
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumCode
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) -> EnumCode -> u
forall u. (forall d. Data d => d -> u) -> EnumCode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumCode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumCode -> c EnumCode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumCode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumCode)
$cEnumCode :: Constr
$tEnumCode :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
gmapMp :: (forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
gmapM :: (forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
gmapQi :: Int -> (forall d. Data d => d -> u) -> EnumCode -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnumCode -> u
gmapQ :: (forall d. Data d => d -> u) -> EnumCode -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EnumCode -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r
gmapT :: (forall b. Data b => b -> b) -> EnumCode -> EnumCode
$cgmapT :: (forall b. Data b => b -> b) -> EnumCode -> EnumCode
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumCode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumCode)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c EnumCode)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumCode)
dataTypeOf :: EnumCode -> DataType
$cdataTypeOf :: EnumCode -> DataType
toConstr :: EnumCode -> Constr
$ctoConstr :: EnumCode -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumCode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumCode
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumCode -> c EnumCode
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumCode -> c EnumCode
$cp1Data :: Typeable EnumCode
Data,Typeable)

instance Bounded EnumCode where
  minBound :: EnumCode
minBound = EnumCode
0
  maxBound :: EnumCode
maxBound = EnumCode
2147483647 -- 2^-31 -1

-- | 'WireSize' is the Int64 size type associated with the lazy
-- bytestrings used in the 'Put' and 'Get' monads.
type WireSize = Int64

-- | The 'Mergeable' class is not a 'Monoid', 'mergeEmpty' is not a
-- left or right unit like 'mempty'.  The default 'mergeAppend' is to
-- take the second parameter and discard the first one.  The
-- 'mergeConcat' defaults to @foldl@ associativity.
--
-- NOTE: 'mergeEmpty' has been removed in protocol buffers version 2.
-- Use 'defaultValue' instead.  New strict fields would mean that required
-- fields in messages will be automatic errors with 'mergeEmpty'.
class Default a => Mergeable a where
{-
  -- | The 'mergeEmpty' value of a basic type or a message with
  -- required fields will be undefined and a runtime error to
  -- evaluate.  These are only handy for reading the wire encoding and
  -- users should employ 'defaultValue' instead.
  mergeEmpty :: a
  mergeEmpty = error "You did not define Mergeable.mergeEmpty!"
-}
  -- | 'mergeAppend' is the right-biased merge of two values.  A
  -- message (or group) is merged recursively.  Required field are
  -- always taken from the second message. Optional field values are
  -- taken from the most defined message or the second message if
  -- both are set.  Repeated fields have the sequences concatenated.
  -- Note that strings and bytes are NOT concatenated.
  mergeAppend :: a -> a -> a
  mergeAppend a
_a a
b = a
b

  -- | 'mergeConcat' is @ F.foldl mergeAppend defaultValue @ and this
  -- default definition is not overridden in any of the code except
  -- for the (Seq a) instance.
  mergeConcat :: F.Foldable t => t a -> a
  mergeConcat = (a -> a -> a) -> a -> t a -> a
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl a -> a -> a
forall a. Mergeable a => a -> a -> a
mergeAppend a
forall a. Default a => a
defaultValue

-- | The Default class has the default-default values of types.  See
-- <http://code.google.com/apis/protocolbuffers/docs/proto.html#optional>
-- and also note that 'Enum' types have a 'defaultValue' that is the
-- first one in the @.proto@ file (there is always at least one
-- value).  Instances of this for messages hold any default value
-- defined in the @.proto@ file.  'defaultValue' is where the
-- 'MessageAPI' function 'getVal' looks when an optional field is not
-- set.
class Default a where
  -- | The 'defaultValue' is never undefined or an error to evalute.
  -- This makes it much more useful compared to 'mergeEmpty'. In a
  -- default message all Optional field values are set to 'Nothing'
  -- and Repeated field values are empty.
  defaultValue :: a

-- Returns Nothing if valid, and the position of the error if invalid
isValidUTF8 :: ByteString -> Maybe Int
isValidUTF8 :: ByteString -> Maybe Int
isValidUTF8 ByteString
bs = Int -> [Word8] -> Int -> Maybe Int
go Int
0 (ByteString -> [Word8]
L.unpack ByteString
bs) Int
0 where
  go :: Int -> [Word8] -> Int -> Maybe Int
  go :: Int -> [Word8] -> Int -> Maybe Int
go Int
0 [] Int
_ = Maybe Int
forall a. Maybe a
Nothing
  go Int
0 (Word8
x:[Word8]
xs) Int
n | Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
127 = Int -> [Word8] -> Int -> Maybe Int
go Int
0 [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n -- binary 01111111
                | Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
193 = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n            -- binary 11000001, decodes to <=127, should not be here
                | Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
223 = Int -> [Word8] -> Int -> Maybe Int
go Int
1 [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n -- binary 11011111
                | Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
239 = Int -> [Word8] -> Int -> Maybe Int
go Int
2 [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n -- binary 11101111
                | Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
243 = Int -> [Word8] -> Int -> Maybe Int
go Int
3 [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n -- binary 11110011
                | Word8
x Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
244 = [Word8] -> Int -> Maybe Int
high [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n -- binary 11110100
                | Bool
otherwise = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n
  go Int
i (Word8
x:[Word8]
xs) Int
n | Word8
128 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
x Bool -> Bool -> Bool
&& Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
191 = Int -> [Word8] -> Int -> Maybe Int
go (Int -> Int
forall a. Enum a => a -> a
pred Int
i) [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n
  go Int
_ [Word8]
_ Int
n = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n
  -- leading 3 bits are 100, so next 6 are at most 001111, i.e. 10001111
  high :: [Word8] -> Int -> Maybe Int
high (Word8
x:[Word8]
xs) Int
n | Word8
128 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
x Bool -> Bool -> Bool
&& Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
143 = Int -> [Word8] -> Int -> Maybe Int
go Int
2 [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n
                | Bool
otherwise = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n
  high [] Int
n = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n

toUtf8 :: ByteString -> Either Int Utf8
toUtf8 :: ByteString -> Either Int Utf8
toUtf8 ByteString
bs = Either Int Utf8
-> (Int -> Either Int Utf8) -> Maybe Int -> Either Int Utf8
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Utf8 -> Either Int Utf8
forall a b. b -> Either a b
Right (ByteString -> Utf8
Utf8 ByteString
bs)) Int -> Either Int Utf8
forall a b. a -> Either a b
Left (ByteString -> Maybe Int
isValidUTF8 ByteString
bs)

uToString :: Utf8 -> String
uToString :: Utf8 -> String
uToString (Utf8 ByteString
bs) = ByteString -> String
U.toString ByteString
bs

uFromString :: String -> Utf8
uFromString :: String -> Utf8
uFromString String
s = ByteString -> Utf8
Utf8 (String -> ByteString
U.fromString String
s)


-- Base types are not very mergeable, but their Maybe and Seq versions are:
instance Mergeable a => Mergeable (Maybe a) where
--    mergeEmpty = Nothing
    mergeAppend :: Maybe a -> Maybe a -> Maybe a
mergeAppend = Maybe a -> Maybe a -> Maybe a
forall a. Mergeable a => Maybe a -> Maybe a -> Maybe a
mayMerge

{-# INLINE mayMerge #-}
mayMerge :: (Mergeable b) => Maybe b -> Maybe b -> Maybe b
mayMerge :: Maybe b -> Maybe b -> Maybe b
mayMerge Maybe b
Nothing  Maybe b
y        = Maybe b
y
mayMerge Maybe b
x        Maybe b
Nothing  = Maybe b
x
mayMerge (Just b
x) (Just b
y) = b -> Maybe b
forall a. a -> Maybe a
Just (b -> b -> b
forall a. Mergeable a => a -> a -> a
mergeAppend b
x b
y)

instance Mergeable (Seq a) where
--    mergeEmpty = empty
    mergeAppend :: Seq a -> Seq a -> Seq a
mergeAppend = Seq a -> Seq a -> Seq a
forall a. Seq a -> Seq a -> Seq a
(><)

-- These all have errors as mergeEmpty and use the second paramater for mergeAppend
instance Mergeable Bool
instance Mergeable Utf8
instance Mergeable ByteString
instance Mergeable Double
instance Mergeable Float
instance Mergeable Int32
instance Mergeable Int64
instance Mergeable Word32
instance Mergeable Word64

instance Default Word64 where defaultValue :: Word64
defaultValue = Word64
0
instance Default Word32 where defaultValue :: Word32
defaultValue = Word32
0
instance Default Int64 where defaultValue :: Int64
defaultValue = Int64
0
instance Default Int32 where defaultValue :: Int32
defaultValue = Int32
0
instance Default Float where defaultValue :: Float
defaultValue = Float
0
instance Default Double where defaultValue :: Double
defaultValue = Double
0
instance Default Bool where defaultValue :: Bool
defaultValue = Bool
False
instance Default (Maybe a) where defaultValue :: Maybe a
defaultValue = Maybe a
forall a. Maybe a
Nothing
instance Default (Seq a) where defaultValue :: Seq a
defaultValue = Seq a
forall a. Monoid a => a
mempty
instance Default ByteString where defaultValue :: ByteString
defaultValue = ByteString
forall a. Monoid a => a
mempty
instance Default Utf8 where defaultValue :: Utf8
defaultValue = Utf8
forall a. Monoid a => a
mempty