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.MyEnum(..)
    , pattern Example.Say你好
    , pattern Example.Say拜拜
    )
  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 MyEnum@

    __defined at:__ @edge-cases\/uses_utf8.h 4:6@

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

instance Marshal.StaticSize MyEnum where

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

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

instance Marshal.ReadRaw MyEnum where

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

instance Marshal.WriteRaw MyEnum where

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

deriving via Marshal.EquivStorable MyEnum instance BG.Storable MyEnum

deriving via BG.CUInt instance BG.Prim MyEnum

instance CEnum.CEnum MyEnum where

  type CEnumZ MyEnum = BG.CUInt

  toCEnum = MyEnum

  fromCEnum = BG.getField @"unwrapMyEnum"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [(0, BG.singleton "Say\20320\22909"), (1, BG.singleton "Say\25308\25308")]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "MyEnum"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "MyEnum"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum MyEnum where

  minDeclaredValue = Say你好

  maxDeclaredValue = Say拜拜

instance Show MyEnum where

  showsPrec = CEnum.shows

instance Read MyEnum where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapMyEnum" MyEnum ty where

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

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapMyEnum" (BG.Ptr MyEnum) (BG.Ptr ty) where

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

instance HasCField.HasCField MyEnum "unwrapMyEnum" where

  type CFieldType MyEnum "unwrapMyEnum" = BG.CUInt

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

{-| __C declaration:__ @Say你好@

    __defined at:__ @edge-cases\/uses_utf8.h 5:9@

    __exported by:__ @edge-cases\/uses_utf8.h@
-}
pattern Say你好 :: MyEnum
pattern Say你好 = MyEnum 0

{-| __C declaration:__ @Say拜拜@

    __defined at:__ @edge-cases\/uses_utf8.h 6:9@

    __exported by:__ @edge-cases\/uses_utf8.h@
-}
pattern Say拜拜 :: MyEnum
pattern Say拜拜 = MyEnum 1