module Data.Radius.Scalar (
  AtText (..), AtString (..), AtInteger (..), AtIpV4 (..),
  Bin128, fromBin128, mayBin128, word64Bin128, bin128Zero,
  ) where

import Data.Monoid ((<>))
import Data.Word (Word32, Word64)
import Data.ByteString (ByteString)
import qualified Data.ByteString as BS
import Data.ByteString.Lazy (toStrict)
import Data.Serialize (encodeLazy)


newtype AtText     =  AtText     { AtText -> String
unAtText :: String }        deriving (AtText -> AtText -> Bool
(AtText -> AtText -> Bool)
-> (AtText -> AtText -> Bool) -> Eq AtText
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AtText -> AtText -> Bool
== :: AtText -> AtText -> Bool
$c/= :: AtText -> AtText -> Bool
/= :: AtText -> AtText -> Bool
Eq, Eq AtText
Eq AtText =>
(AtText -> AtText -> Ordering)
-> (AtText -> AtText -> Bool)
-> (AtText -> AtText -> Bool)
-> (AtText -> AtText -> Bool)
-> (AtText -> AtText -> Bool)
-> (AtText -> AtText -> AtText)
-> (AtText -> AtText -> AtText)
-> Ord AtText
AtText -> AtText -> Bool
AtText -> AtText -> Ordering
AtText -> AtText -> AtText
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
$ccompare :: AtText -> AtText -> Ordering
compare :: AtText -> AtText -> Ordering
$c< :: AtText -> AtText -> Bool
< :: AtText -> AtText -> Bool
$c<= :: AtText -> AtText -> Bool
<= :: AtText -> AtText -> Bool
$c> :: AtText -> AtText -> Bool
> :: AtText -> AtText -> Bool
$c>= :: AtText -> AtText -> Bool
>= :: AtText -> AtText -> Bool
$cmax :: AtText -> AtText -> AtText
max :: AtText -> AtText -> AtText
$cmin :: AtText -> AtText -> AtText
min :: AtText -> AtText -> AtText
Ord, Int -> AtText -> String -> String
[AtText] -> String -> String
AtText -> String
(Int -> AtText -> String -> String)
-> (AtText -> String)
-> ([AtText] -> String -> String)
-> Show AtText
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AtText -> String -> String
showsPrec :: Int -> AtText -> String -> String
$cshow :: AtText -> String
show :: AtText -> String
$cshowList :: [AtText] -> String -> String
showList :: [AtText] -> String -> String
Show)
newtype AtString   =  AtString   { AtString -> ByteString
unAtString :: ByteString }  deriving (AtString -> AtString -> Bool
(AtString -> AtString -> Bool)
-> (AtString -> AtString -> Bool) -> Eq AtString
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AtString -> AtString -> Bool
== :: AtString -> AtString -> Bool
$c/= :: AtString -> AtString -> Bool
/= :: AtString -> AtString -> Bool
Eq, Eq AtString
Eq AtString =>
(AtString -> AtString -> Ordering)
-> (AtString -> AtString -> Bool)
-> (AtString -> AtString -> Bool)
-> (AtString -> AtString -> Bool)
-> (AtString -> AtString -> Bool)
-> (AtString -> AtString -> AtString)
-> (AtString -> AtString -> AtString)
-> Ord AtString
AtString -> AtString -> Bool
AtString -> AtString -> Ordering
AtString -> AtString -> AtString
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
$ccompare :: AtString -> AtString -> Ordering
compare :: AtString -> AtString -> Ordering
$c< :: AtString -> AtString -> Bool
< :: AtString -> AtString -> Bool
$c<= :: AtString -> AtString -> Bool
<= :: AtString -> AtString -> Bool
$c> :: AtString -> AtString -> Bool
> :: AtString -> AtString -> Bool
$c>= :: AtString -> AtString -> Bool
>= :: AtString -> AtString -> Bool
$cmax :: AtString -> AtString -> AtString
max :: AtString -> AtString -> AtString
$cmin :: AtString -> AtString -> AtString
min :: AtString -> AtString -> AtString
Ord, Int -> AtString -> String -> String
[AtString] -> String -> String
AtString -> String
(Int -> AtString -> String -> String)
-> (AtString -> String)
-> ([AtString] -> String -> String)
-> Show AtString
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AtString -> String -> String
showsPrec :: Int -> AtString -> String -> String
$cshow :: AtString -> String
show :: AtString -> String
$cshowList :: [AtString] -> String -> String
showList :: [AtString] -> String -> String
Show)
newtype AtInteger  =  AtInteger  { AtInteger -> Word32
unAtInteger :: Word32 }     deriving (AtInteger -> AtInteger -> Bool
(AtInteger -> AtInteger -> Bool)
-> (AtInteger -> AtInteger -> Bool) -> Eq AtInteger
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AtInteger -> AtInteger -> Bool
== :: AtInteger -> AtInteger -> Bool
$c/= :: AtInteger -> AtInteger -> Bool
/= :: AtInteger -> AtInteger -> Bool
Eq, Eq AtInteger
Eq AtInteger =>
(AtInteger -> AtInteger -> Ordering)
-> (AtInteger -> AtInteger -> Bool)
-> (AtInteger -> AtInteger -> Bool)
-> (AtInteger -> AtInteger -> Bool)
-> (AtInteger -> AtInteger -> Bool)
-> (AtInteger -> AtInteger -> AtInteger)
-> (AtInteger -> AtInteger -> AtInteger)
-> Ord AtInteger
AtInteger -> AtInteger -> Bool
AtInteger -> AtInteger -> Ordering
AtInteger -> AtInteger -> AtInteger
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
$ccompare :: AtInteger -> AtInteger -> Ordering
compare :: AtInteger -> AtInteger -> Ordering
$c< :: AtInteger -> AtInteger -> Bool
< :: AtInteger -> AtInteger -> Bool
$c<= :: AtInteger -> AtInteger -> Bool
<= :: AtInteger -> AtInteger -> Bool
$c> :: AtInteger -> AtInteger -> Bool
> :: AtInteger -> AtInteger -> Bool
$c>= :: AtInteger -> AtInteger -> Bool
>= :: AtInteger -> AtInteger -> Bool
$cmax :: AtInteger -> AtInteger -> AtInteger
max :: AtInteger -> AtInteger -> AtInteger
$cmin :: AtInteger -> AtInteger -> AtInteger
min :: AtInteger -> AtInteger -> AtInteger
Ord, Int -> AtInteger -> String -> String
[AtInteger] -> String -> String
AtInteger -> String
(Int -> AtInteger -> String -> String)
-> (AtInteger -> String)
-> ([AtInteger] -> String -> String)
-> Show AtInteger
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AtInteger -> String -> String
showsPrec :: Int -> AtInteger -> String -> String
$cshow :: AtInteger -> String
show :: AtInteger -> String
$cshowList :: [AtInteger] -> String -> String
showList :: [AtInteger] -> String -> String
Show)
newtype AtIpV4     =  AtIpV4     { AtIpV4 -> Word32
unAtIpV4 :: Word32 }        deriving (AtIpV4 -> AtIpV4 -> Bool
(AtIpV4 -> AtIpV4 -> Bool)
-> (AtIpV4 -> AtIpV4 -> Bool) -> Eq AtIpV4
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AtIpV4 -> AtIpV4 -> Bool
== :: AtIpV4 -> AtIpV4 -> Bool
$c/= :: AtIpV4 -> AtIpV4 -> Bool
/= :: AtIpV4 -> AtIpV4 -> Bool
Eq, Eq AtIpV4
Eq AtIpV4 =>
(AtIpV4 -> AtIpV4 -> Ordering)
-> (AtIpV4 -> AtIpV4 -> Bool)
-> (AtIpV4 -> AtIpV4 -> Bool)
-> (AtIpV4 -> AtIpV4 -> Bool)
-> (AtIpV4 -> AtIpV4 -> Bool)
-> (AtIpV4 -> AtIpV4 -> AtIpV4)
-> (AtIpV4 -> AtIpV4 -> AtIpV4)
-> Ord AtIpV4
AtIpV4 -> AtIpV4 -> Bool
AtIpV4 -> AtIpV4 -> Ordering
AtIpV4 -> AtIpV4 -> AtIpV4
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
$ccompare :: AtIpV4 -> AtIpV4 -> Ordering
compare :: AtIpV4 -> AtIpV4 -> Ordering
$c< :: AtIpV4 -> AtIpV4 -> Bool
< :: AtIpV4 -> AtIpV4 -> Bool
$c<= :: AtIpV4 -> AtIpV4 -> Bool
<= :: AtIpV4 -> AtIpV4 -> Bool
$c> :: AtIpV4 -> AtIpV4 -> Bool
> :: AtIpV4 -> AtIpV4 -> Bool
$c>= :: AtIpV4 -> AtIpV4 -> Bool
>= :: AtIpV4 -> AtIpV4 -> Bool
$cmax :: AtIpV4 -> AtIpV4 -> AtIpV4
max :: AtIpV4 -> AtIpV4 -> AtIpV4
$cmin :: AtIpV4 -> AtIpV4 -> AtIpV4
min :: AtIpV4 -> AtIpV4 -> AtIpV4
Ord, Int -> AtIpV4 -> String -> String
[AtIpV4] -> String -> String
AtIpV4 -> String
(Int -> AtIpV4 -> String -> String)
-> (AtIpV4 -> String)
-> ([AtIpV4] -> String -> String)
-> Show AtIpV4
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AtIpV4 -> String -> String
showsPrec :: Int -> AtIpV4 -> String -> String
$cshow :: AtIpV4 -> String
show :: AtIpV4 -> String
$cshowList :: [AtIpV4] -> String -> String
showList :: [AtIpV4] -> String -> String
Show)

newtype Bin128  =  Bin128 ByteString deriving (Bin128 -> Bin128 -> Bool
(Bin128 -> Bin128 -> Bool)
-> (Bin128 -> Bin128 -> Bool) -> Eq Bin128
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Bin128 -> Bin128 -> Bool
== :: Bin128 -> Bin128 -> Bool
$c/= :: Bin128 -> Bin128 -> Bool
/= :: Bin128 -> Bin128 -> Bool
Eq, Eq Bin128
Eq Bin128 =>
(Bin128 -> Bin128 -> Ordering)
-> (Bin128 -> Bin128 -> Bool)
-> (Bin128 -> Bin128 -> Bool)
-> (Bin128 -> Bin128 -> Bool)
-> (Bin128 -> Bin128 -> Bool)
-> (Bin128 -> Bin128 -> Bin128)
-> (Bin128 -> Bin128 -> Bin128)
-> Ord Bin128
Bin128 -> Bin128 -> Bool
Bin128 -> Bin128 -> Ordering
Bin128 -> Bin128 -> Bin128
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
$ccompare :: Bin128 -> Bin128 -> Ordering
compare :: Bin128 -> Bin128 -> Ordering
$c< :: Bin128 -> Bin128 -> Bool
< :: Bin128 -> Bin128 -> Bool
$c<= :: Bin128 -> Bin128 -> Bool
<= :: Bin128 -> Bin128 -> Bool
$c> :: Bin128 -> Bin128 -> Bool
> :: Bin128 -> Bin128 -> Bool
$c>= :: Bin128 -> Bin128 -> Bool
>= :: Bin128 -> Bin128 -> Bool
$cmax :: Bin128 -> Bin128 -> Bin128
max :: Bin128 -> Bin128 -> Bin128
$cmin :: Bin128 -> Bin128 -> Bin128
min :: Bin128 -> Bin128 -> Bin128
Ord, Int -> Bin128 -> String -> String
[Bin128] -> String -> String
Bin128 -> String
(Int -> Bin128 -> String -> String)
-> (Bin128 -> String)
-> ([Bin128] -> String -> String)
-> Show Bin128
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Bin128 -> String -> String
showsPrec :: Int -> Bin128 -> String -> String
$cshow :: Bin128 -> String
show :: Bin128 -> String
$cshowList :: [Bin128] -> String -> String
showList :: [Bin128] -> String -> String
Show)

fromBin128 :: Bin128 -> ByteString
fromBin128 :: Bin128 -> ByteString
fromBin128 (Bin128 ByteString
s) = ByteString
s

mayBin128 :: ByteString -> Maybe Bin128
mayBin128 :: ByteString -> Maybe Bin128
mayBin128 ByteString
bs
  | ByteString -> Int
BS.length ByteString
bs Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
16 = Bin128 -> Maybe Bin128
forall a. a -> Maybe a
Just (Bin128 -> Maybe Bin128) -> Bin128 -> Maybe Bin128
forall a b. (a -> b) -> a -> b
$ ByteString -> Bin128
Bin128 ByteString
bs
  | Bool
otherwise          = Maybe Bin128
forall a. Maybe a
Nothing

word64Bin128 :: Word64 -> Word64 -> Bin128
word64Bin128 :: Word64 -> Word64 -> Bin128
word64Bin128 Word64
h Word64
l = ByteString -> Bin128
Bin128 (ByteString -> Bin128)
-> (ByteString -> ByteString) -> ByteString -> Bin128
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
toStrict (ByteString -> Bin128) -> ByteString -> Bin128
forall a b. (a -> b) -> a -> b
$ Word64 -> ByteString
forall a. Serialize a => a -> ByteString
encodeLazy Word64
h ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> Word64 -> ByteString
forall a. Serialize a => a -> ByteString
encodeLazy Word64
l

bin128Zero :: Bin128
bin128Zero :: Bin128
bin128Zero = Word64 -> Word64 -> Bin128
word64Bin128 Word64
0 Word64
0