Example.hs

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE UndecidableInstances #-}

module Example
    ( Example.Test(..)
    , pattern Example.Test_a
    , pattern Example.Test_count
    )
  where

import qualified HsBindgen.Runtime.CEnum as CEnum
import qualified HsBindgen.Runtime.HasCField as HasCField
import qualified HsBindgen.Runtime.Marshal as Marshal
import qualified HsBindgen.Runtime.Support as BG
import qualified HsBindgen.Runtime.Support.CompatHasField as BG.CompatHasField
import Prelude ((<*>), Eq, Int, Ord, Read, Show, pure, type (~))

{-| __C declaration:__ @enum test@

    __defined at:__ @edge-cases\/enum_as_array_size.h 3:6@

    __exported by:__ @edge-cases\/enum_as_array_size.h@
-}
newtype Test = Test
  { unwrapTest :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Test where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Test where

  readRaw =
    \ptr0 ->
          pure Test
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Test where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Test unwrapTest2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapTest2

deriving via Marshal.EquivStorable Test instance BG.Storable Test

deriving via BG.CUInt instance BG.Prim Test

instance CEnum.CEnum Test where

  type CEnumZ Test = BG.CUInt

  toCEnum = Test

  fromCEnum = BG.getField @"unwrapTest"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [(0, BG.singleton "Test_a"), (1, BG.singleton "Test_count")]

  showsUndeclared = CEnum.showsWrappedUndeclared "Test"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Test"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Test where

  minDeclaredValue = Test_a

  maxDeclaredValue = Test_count

instance Show Test where

  showsPrec = CEnum.shows

instance Read Test where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapTest" Test ty where

  hasField =
    \x0 ->
      (\y1 ->
         Test {unwrapTest = y1}, BG.getField @"unwrapTest" x0)

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapTest" (BG.Ptr Test) (BG.Ptr ty) where

  getField = HasCField.fromPtr (BG.Proxy @"unwrapTest")

instance HasCField.HasCField Test "unwrapTest" where

  type CFieldType Test "unwrapTest" = BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @test_a@

    __defined at:__ @edge-cases\/enum_as_array_size.h 4:3@

    __exported by:__ @edge-cases\/enum_as_array_size.h@
-}
pattern Test_a :: Test
pattern Test_a = Test 0

{-| __C declaration:__ @test_count@

    __defined at:__ @edge-cases\/enum_as_array_size.h 5:3@

    __exported by:__ @edge-cases\/enum_as_array_size.h@
-}
pattern Test_count :: Test
pattern Test_count = Test 1