module Rattletrap.Type.Property.Float where

import Prelude hiding (Float)
import qualified Rattletrap.ByteGet as ByteGet
import qualified Rattletrap.BytePut as BytePut
import qualified Rattletrap.Schema as Schema
import qualified Rattletrap.Type.F32 as F32
import qualified Rattletrap.Utility.Json as Json

newtype Float
  = Float F32.F32
  deriving (Float -> Float -> Bool
(Float -> Float -> Bool) -> (Float -> Float -> Bool) -> Eq Float
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Float -> Float -> Bool
$c/= :: Float -> Float -> Bool
== :: Float -> Float -> Bool
$c== :: Float -> Float -> Bool
Eq, Int -> Float -> ShowS
[Float] -> ShowS
Float -> String
(Int -> Float -> ShowS)
-> (Float -> String) -> ([Float] -> ShowS) -> Show Float
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Float] -> ShowS
$cshowList :: [Float] -> ShowS
show :: Float -> String
$cshow :: Float -> String
showsPrec :: Int -> Float -> ShowS
$cshowsPrec :: Int -> Float -> ShowS
Show)

fromF32 :: F32.F32 -> Float
fromF32 :: F32 -> Float
fromF32 = F32 -> Float
Float

toF32 :: Float -> F32.F32
toF32 :: Float -> F32
toF32 (Float F32
x) = F32
x

instance Json.FromJSON Float where
  parseJSON :: Value -> Parser Float
parseJSON = (F32 -> Float) -> Parser F32 -> Parser Float
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap F32 -> Float
fromF32 (Parser F32 -> Parser Float)
-> (Value -> Parser F32) -> Value -> Parser Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Parser F32
forall a. FromJSON a => Value -> Parser a
Json.parseJSON

instance Json.ToJSON Float where
  toJSON :: Float -> Value
toJSON = F32 -> Value
forall a. ToJSON a => a -> Value
Json.toJSON (F32 -> Value) -> (Float -> F32) -> Float -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> F32
toF32

schema :: Schema.Schema
schema :: Schema
schema = Schema
F32.schema

bytePut :: Float -> BytePut.BytePut
bytePut :: Float -> BytePut
bytePut = F32 -> BytePut
F32.bytePut (F32 -> BytePut) -> (Float -> F32) -> Float -> BytePut
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> F32
toF32

byteGet :: ByteGet.ByteGet Float
byteGet :: ByteGet Float
byteGet = String -> ByteGet Float -> ByteGet Float
forall a. String -> ByteGet a -> ByteGet a
ByteGet.label String
"Float" (ByteGet Float -> ByteGet Float) -> ByteGet Float -> ByteGet Float
forall a b. (a -> b) -> a -> b
$ (F32 -> Float) -> Get ByteString Identity F32 -> ByteGet Float
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap F32 -> Float
fromF32 Get ByteString Identity F32
F32.byteGet