-- GENERATED by C->Haskell Compiler, version 0.28.8 Switcheroo, 25 November 2017 (Haskell)
-- Edit the ORIGNAL .chs file instead!


{-# LINE 1 "src/Notmuch/Binding.chs" #-}
-- Copyright (C) 2014-2019  Fraser Tweedale
--
-- hs-notmuch is free software: you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program.  If not, see <http://www.gnu.org/licenses/>.

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}

module Notmuch.Binding where
import qualified Foreign.C.Types as C2HSImp
import qualified Foreign.ForeignPtr as C2HSImp
import qualified Foreign.Ptr as C2HSImp



import Control.Monad ((>=>), (<=<), void, when)
import Control.Monad.Except (MonadError(..))
import Control.Monad.IO.Class (MonadIO(..))
import Data.Coerce (coerce)
import Data.Foldable (traverse_)
import Data.Functor (($>))
import Data.Functor.Identity (Identity(..))
import Data.List (isPrefixOf)
import Data.Proxy
import GHC.TypeLits (Nat, type (<=), type (+), type (-))
import System.FilePath (addTrailingPathSeparator, isAbsolute, splitPath)

import Notmuch.Tag
import Notmuch.Util



{-# LINE 43 "src/Notmuch/Binding.chs" #-}


import Foreign
  ( ForeignPtr, Ptr, castForeignPtr
  , alloca, newForeignPtr, nullFunPtr, nullPtr, peek
  , touchForeignPtr
  )
import Foreign.C
import Foreign.Storable (Storable)
import qualified System.IO.Unsafe

import qualified Data.ByteString as B

import Notmuch.Talloc


-- | @Message-Id@ header value.
type MessageId = B.ByteString

-- | Thread identifier generated and used by /libnotmuch/.
type ThreadId = B.ByteString

--
-- BINDING API
--

data Status = StatusSuccess
            | StatusOutOfMemory
            | StatusReadOnlyDatabase
            | StatusXapianException
            | StatusFileError
            | StatusFileNotEmail
            | StatusDuplicateMessageId
            | StatusNullPointer
            | StatusTagTooLong
            | StatusUnbalancedFreezeThaw
            | StatusUnbalancedAtomic
            | StatusUnsupportedOperation
            | StatusUpgradeRequired
            | StatusPathError
            | StatusIgnored
            | StatusIllegalArgument
            | StatusMalformedCryptoProtocol
            | StatusFailedCryptoContextCreation
            | StatusUnknownCryptoProtocol
            | StatusNoConfig
            | StatusNoDatabase
            | StatusDatabaseExists
            | StatusBadQuerySyntax
            | StatusNoMailRoot
            | StatusClosedDatabase
            | StatusLastStatus
  deriving (Eq)
instance Enum Status where
  succ StatusSuccess = StatusOutOfMemory
  succ StatusOutOfMemory = StatusReadOnlyDatabase
  succ StatusReadOnlyDatabase = StatusXapianException
  succ StatusXapianException = StatusFileError
  succ StatusFileError = StatusFileNotEmail
  succ StatusFileNotEmail = StatusDuplicateMessageId
  succ StatusDuplicateMessageId = StatusNullPointer
  succ StatusNullPointer = StatusTagTooLong
  succ StatusTagTooLong = StatusUnbalancedFreezeThaw
  succ StatusUnbalancedFreezeThaw = StatusUnbalancedAtomic
  succ StatusUnbalancedAtomic = StatusUnsupportedOperation
  succ StatusUnsupportedOperation = StatusUpgradeRequired
  succ StatusUpgradeRequired = StatusPathError
  succ StatusPathError = StatusIgnored
  succ StatusIgnored = StatusIllegalArgument
  succ StatusIllegalArgument = StatusMalformedCryptoProtocol
  succ StatusMalformedCryptoProtocol = StatusFailedCryptoContextCreation
  succ StatusFailedCryptoContextCreation = StatusUnknownCryptoProtocol
  succ StatusUnknownCryptoProtocol = StatusNoConfig
  succ StatusNoConfig = StatusNoDatabase
  succ StatusNoDatabase = StatusDatabaseExists
  succ StatusDatabaseExists = StatusBadQuerySyntax
  succ StatusBadQuerySyntax = StatusNoMailRoot
  succ StatusNoMailRoot = StatusClosedDatabase
  succ StatusClosedDatabase = StatusLastStatus
  succ StatusLastStatus = error "Status.succ: StatusLastStatus has no successor"

  pred :: Status -> Status
pred Status
StatusOutOfMemory = Status
StatusSuccess
  pred Status
StatusReadOnlyDatabase = Status
StatusOutOfMemory
  pred Status
StatusXapianException = Status
StatusReadOnlyDatabase
  pred Status
StatusFileError = Status
StatusXapianException
  pred Status
StatusFileNotEmail = Status
StatusFileError
  pred Status
StatusDuplicateMessageId = Status
StatusFileNotEmail
  pred Status
StatusNullPointer = Status
StatusDuplicateMessageId
  pred Status
StatusTagTooLong = Status
StatusNullPointer
  pred StatusUnbalancedFreezeThaw = StatusTagTooLong
  pred StatusUnbalancedAtomic = StatusUnbalancedFreezeThaw
  pred StatusUnsupportedOperation = StatusUnbalancedAtomic
  pred Status
StatusUpgradeRequired = Status
StatusUnsupportedOperation
  pred StatusPathError = StatusUpgradeRequired
  pred StatusIgnored = StatusPathError
  pred StatusIllegalArgument = StatusIgnored
  pred StatusMalformedCryptoProtocol = StatusIllegalArgument
  pred Status
StatusFailedCryptoContextCreation = Status
StatusMalformedCryptoProtocol
  pred Status
StatusUnknownCryptoProtocol = Status
StatusFailedCryptoContextCreation
  pred StatusNoConfig = StatusUnknownCryptoProtocol
  pred StatusNoDatabase = StatusNoConfig
  pred StatusDatabaseExists = StatusNoDatabase
  pred StatusBadQuerySyntax = StatusDatabaseExists
  pred StatusNoMailRoot = StatusBadQuerySyntax
  pred StatusClosedDatabase = StatusNoMailRoot
  pred StatusLastStatus = StatusClosedDatabase
  pred Status
StatusSuccess = String -> Status
forall a. HasCallStack => String -> a
error String
"Status.pred: StatusSuccess has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom :: Status -> [Status]
enumFrom Status
from = Status -> Status -> [Status]
forall a. Enum a => a -> a -> [a]
enumFromTo Status
from Status
StatusLastStatus

  fromEnum :: Status -> Int
fromEnum Status
StatusSuccess = Int
0
  fromEnum StatusOutOfMemory = 1
  fromEnum StatusReadOnlyDatabase = 2
  fromEnum StatusXapianException = 3
  fromEnum StatusFileError = 4
  fromEnum StatusFileNotEmail = 5
  fromEnum StatusDuplicateMessageId = 6
  fromEnum StatusNullPointer = 7
  fromEnum Status
StatusTagTooLong = Int
8
  fromEnum StatusUnbalancedFreezeThaw = 9
  fromEnum StatusUnbalancedAtomic = 10
  fromEnum StatusUnsupportedOperation = 11
  fromEnum Status
StatusUpgradeRequired = Int
12
  fromEnum StatusPathError = 13
  fromEnum StatusIgnored = 14
  fromEnum StatusIllegalArgument = 15
  fromEnum StatusMalformedCryptoProtocol = 16
  fromEnum Status
StatusFailedCryptoContextCreation = Int
17
  fromEnum Status
StatusUnknownCryptoProtocol = Int
18
  fromEnum StatusNoConfig = 19
  fromEnum StatusNoDatabase = 20
  fromEnum Status
StatusDatabaseExists = Int
21
  fromEnum StatusBadQuerySyntax = 22
  fromEnum StatusNoMailRoot = 23
  fromEnum Status
StatusClosedDatabase = Int
24
  fromEnum Status
StatusLastStatus = Int
25

  toEnum :: Int -> Status
toEnum Int
0 = Status
StatusSuccess
  toEnum 1 = StatusOutOfMemory
  toEnum 2 = StatusReadOnlyDatabase
  toEnum 3 = StatusXapianException
  toEnum 4 = StatusFileError
  toEnum 5 = StatusFileNotEmail
  toEnum 6 = StatusDuplicateMessageId
  toEnum 7 = StatusNullPointer
  toEnum 8 = StatusTagTooLong
  toEnum Int
9 = Status
StatusUnbalancedFreezeThaw
  toEnum 10 = StatusUnbalancedAtomic
  toEnum Int
11 = Status
StatusUnsupportedOperation
  toEnum Int
12 = Status
StatusUpgradeRequired
  toEnum Int
13 = Status
StatusPathError
  toEnum 14 = StatusIgnored
  toEnum 15 = StatusIllegalArgument
  toEnum 16 = StatusMalformedCryptoProtocol
  toEnum 17 = StatusFailedCryptoContextCreation
  toEnum 18 = StatusUnknownCryptoProtocol
  toEnum Int
19 = Status
StatusNoConfig
  toEnum 20 = StatusNoDatabase
  toEnum 21 = StatusDatabaseExists
  toEnum 22 = StatusBadQuerySyntax
  toEnum Int
23 = Status
StatusNoMailRoot
  toEnum Int
24 = Status
StatusClosedDatabase
  toEnum Int
25 = Status
StatusLastStatus
  toEnum Int
unmatched = String -> Status
forall a. HasCallStack => String -> a
error (String
"Status.toEnum: Cannot match " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
unmatched)

{-# LINE 69 "src/Notmuch/Binding.chs" #-}

data DatabaseMode = DatabaseModeReadOnly
                  | DatabaseModeReadWrite
instance Enum DatabaseMode where
  succ DatabaseModeReadOnly = DatabaseModeReadWrite
  succ DatabaseModeReadWrite = error "DatabaseMode.succ: DatabaseModeReadWrite has no successor"

  pred DatabaseModeReadWrite = DatabaseModeReadOnly
  pred DatabaseModeReadOnly = error "DatabaseMode.pred: DatabaseModeReadOnly has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from DatabaseModeReadWrite

  fromEnum DatabaseModeReadOnly = 0
  fromEnum DatabaseModeReadWrite = 1

  toEnum 0 = DatabaseModeReadOnly
  toEnum 1 = DatabaseModeReadWrite
  toEnum unmatched = error ("DatabaseMode.toEnum: Cannot match " ++ show unmatched)

{-# LINE 70 "src/Notmuch/Binding.chs" #-}

data Sort = SortOldestFirst
          | SortNewestFirst
          | SortMessageId
          | SortUnsorted
  deriving (Enum)

{-# LINE 71 "src/Notmuch/Binding.chs" #-}

data MessageFlag = MessageFlagMatch
                 | MessageFlagExcluded
                 | MessageFlagGhost
  deriving (Enum)

{-# LINE 72 "src/Notmuch/Binding.chs" #-}

newtype DatabaseHandle = DatabaseHandle (C2HSImp.ForeignPtr (DatabaseHandle))
withDatabaseHandle :: DatabaseHandle -> (C2HSImp.Ptr DatabaseHandle -> IO b) -> IO b
withDatabaseHandle (DatabaseHandle fptr) = C2HSImp.withForeignPtr fptr
{-# LINE 73 "src/Notmuch/Binding.chs" #-}

newtype QueryHandle = QueryHandle (C2HSImp.ForeignPtr (QueryHandle))
withQueryHandle :: QueryHandle -> (C2HSImp.Ptr QueryHandle -> IO b) -> IO b
withQueryHandle (QueryHandle fptr) = C2HSImp.withForeignPtr fptr
{-# LINE 74 "src/Notmuch/Binding.chs" #-}

newtype Threads = Threads (C2HSImp.Ptr (Threads))
{-# LINE 75 "src/Notmuch/Binding.chs" #-}

newtype ThreadHandle = ThreadHandle (C2HSImp.ForeignPtr (ThreadHandle))
withThreadHandle :: ThreadHandle -> (C2HSImp.Ptr ThreadHandle -> IO b) -> IO b
withThreadHandle (ThreadHandle fptr) = C2HSImp.withForeignPtr fptr
{-# LINE 76 "src/Notmuch/Binding.chs" #-}

newtype Messages = Messages (C2HSImp.Ptr (Messages))
{-# LINE 77 "src/Notmuch/Binding.chs" #-}

newtype MessageHandle = MessageHandle (C2HSImp.ForeignPtr (MessageHandle))
withMessageHandle :: MessageHandle -> (C2HSImp.Ptr MessageHandle -> IO b) -> IO b
withMessageHandle (MessageHandle fptr) = C2HSImp.withForeignPtr fptr
{-# LINE 78 "src/Notmuch/Binding.chs" #-}

newtype Tags = Tags (C2HSImp.Ptr (Tags))
{-# LINE 79 "src/Notmuch/Binding.chs" #-}

newtype Directory = Directory (C2HSImp.ForeignPtr (Directory))
withDirectory :: Directory -> (C2HSImp.Ptr Directory -> IO b) -> IO b
withDirectory (Directory fptr) = C2HSImp.withForeignPtr fptr
{-# LINE 80 "src/Notmuch/Binding.chs" #-}

newtype Filenames = Filenames (C2HSImp.ForeignPtr (Filenames))
withFilenames :: Filenames -> (C2HSImp.Ptr Filenames -> IO b) -> IO b
withFilenames (Filenames fptr) = C2HSImp.withForeignPtr fptr
{-# LINE 81 "src/Notmuch/Binding.chs" #-}


deriving instance Storable Threads
deriving instance Storable Messages

instance Show Status where
  show a = System.IO.Unsafe.unsafePerformIO $
    notmuch_status_to_string (fromEnum' a) >>= peekCString

-- | Classy prism for injecting a /libnotmuch/ status code.
class AsNotmuchError s where
  _NotmuchError :: Prism' s Status

instance AsNotmuchError Status where
  _NotmuchError = id

throwOr :: (AsNotmuchError e, MonadError e m) => (a -> m b) -> Either Status a -> m b
throwOr = either (throwError . review _NotmuchError)

-- | Convenience synonym for the promoted 'DatabaseModeReadOnly' constructor.
type RO = 'DatabaseModeReadOnly

-- | Convenience synonym for the promoted 'DatabaseModeReadWrite' constructor.
type RW = 'DatabaseModeReadWrite

-- | A database handle.  The database will be closed and freed when
-- it is garbage collected.
--
-- Use 'query' to perform a search or 'findMessage' to search for a
-- particular message.
--
-- The @Database@ type carries a phantom for the database mode, which
-- is propgated to derived 'Query', 'Thread' and 'Message' objects.
-- This is used to prevent write operations being performed against
-- a read-only database.
--
newtype Database (a :: DatabaseMode) = Database DatabaseHandle

withDatabase :: Database a -> (Ptr DatabaseHandle -> IO b) -> IO b
withDatabase (Database dbh) = withDatabaseHandle dbh

-- | Message object.  Cleaned up when garbage collected.
--
-- The @Message@ type carries a phantom for the database mode, so that
-- write operations are restricted to read/write database sessions.
--
-- There is also a phantom type parameter for the degree of frozenness
-- of the message.  Tag operations on a frozen message are atomic, only
-- becoming visible to other threads/processes after the thaw.  The
-- freeze/thaw behaviour is available via 'withFrozenMessage'.
--
data Message (n :: Nat) (a :: DatabaseMode) = Message
                 ![ForeignPtr () {- owners -}]
  {-# UNPACK #-} !MessageHandle

withMessage :: Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage (Message owners a) k = do
  r <- withMessageHandle a k
  traverse_ touchForeignPtr owners
  pure r

-- | Thread object.  Cleaned up when garbage collected.
--
-- Use 'messages' to get the messages of a thread.
--
-- The @Thread@ type carries a phantom for the database mode, so that
-- write operations on messages derived from it are restricted to
-- read/write database sessions.
--
data Thread (a :: DatabaseMode) = Thread
  {-# UNPACK #-} !(ForeignPtr DatabaseHandle {- owner -})
  {-# UNPACK #-} !(ForeignPtr QueryHandle {- owner -})
  {-# UNPACK #-} !ThreadHandle

withThread :: Thread a -> (Ptr ThreadHandle -> IO b) -> IO b
withThread (Thread dfp qfp a) k = do
  r <- withThreadHandle a k
  touchForeignPtr dfp
  touchForeignPtr qfp
  pure r

-- | Query object.  Cleaned up when garbage collected.
--
-- Use 'messages' or 'threads' to get the results.
--
-- The @Query@ type carries a phantom for the database mode, so that
-- write operations on messages derived from it are restricted to
-- read/write database sessions.
--
data Query (a :: DatabaseMode) = Query
  {-# UNPACK #-} !(ForeignPtr DatabaseHandle)
  {-# UNPACK #-} !QueryHandle

withQuery :: Query a -> (Ptr QueryHandle -> IO b) -> IO b
withQuery (Query owner a) f = do
  r <- withQueryHandle a f
  touchForeignPtr owner
  pure r

fromEnum' :: (Enum a, Integral b) => a -> b
fromEnum' = fromIntegral . fromEnum

-- | If @e == StatusSuccess@ then apply @Right@ in the given effect,
-- otherwise return @pure (Left e)@
--
status :: (Applicative f) => f a -> Status -> f (Either Status a)
status = status' (== StatusSuccess)

-- | Like 'status'' but with predicate parameter (False if status
-- should be raised as an error, otherwise True).
status'
  :: (Applicative f)
  => (Status -> Bool) -> f a -> Status -> f (Either Status a)
status' f a e
  | f e = Right <$> a
  | otherwise = pure $ Left e

toStatus :: (Integral a, Enum b) => a -> b
toStatus = toEnum . fromIntegral


-- | This is an internal class whose instances are the promoted
-- 'DatabaseMode' constructors.
class Mode a where
  getMode :: Proxy a -> DatabaseMode
  upgrade :: (AsNotmuchError e, MonadError e m, MonadIO m) => Database a -> m (Database a)

instance Mode 'DatabaseModeReadOnly where
  getMode _ = DatabaseModeReadOnly
  upgrade = pure

instance Mode 'DatabaseModeReadWrite where
  getMode _ = DatabaseModeReadWrite
  upgrade db =
    liftIO (toEnum . fromIntegral <$> withDatabase db (\dbPtr ->
      notmuch_database_upgrade dbPtr nullFunPtr nullPtr))
    >>= \rv -> case rv of
      StatusSuccess -> pure db
      e -> throwError $ review _NotmuchError e

-- | Open a Notmuch database
--
-- The database will be closed and resources freed when it gets
-- garbage collected.
--
database_open
  :: forall a e m. (AsNotmuchError e, Mode a, MonadError e m, MonadIO m)
  => FilePath
  -> m (Database a)
database_open :: forall (a :: DatabaseMode) e (m :: * -> *).
(AsNotmuchError e, Mode a, MonadError e m, MonadIO m) =>
String -> m (Database a)
database_open String
s =
  IO (Either Status (Database a)) -> m (Either Status (Database a))
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (
    String
-> (Ptr CChar -> IO (Either Status (Database a)))
-> IO (Either Status (Database a))
forall a. String -> (Ptr CChar -> IO a) -> IO a
withCString String
s (\Ptr CChar
s' -> ((Either Status (Identity (Database a))
 -> Either Status (Database a))
-> IO (Either Status (Identity (Database a)))
-> IO (Either Status (Database a))
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Either Status (Identity (Database a))
  -> Either Status (Database a))
 -> IO (Either Status (Identity (Database a)))
 -> IO (Either Status (Database a)))
-> ((Identity (Database a) -> Database a)
    -> Either Status (Identity (Database a))
    -> Either Status (Database a))
-> (Identity (Database a) -> Database a)
-> IO (Either Status (Identity (Database a)))
-> IO (Either Status (Database a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identity (Database a) -> Database a)
-> Either Status (Identity (Database a))
-> Either Status (Database a)
forall a b. (a -> b) -> Either Status a -> Either Status b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap) Identity (Database a) -> Database a
forall a. Identity a -> a
runIdentity (IO (Either Status (Identity (Database a)))
 -> IO (Either Status (Database a)))
-> IO (Either Status (Identity (Database a)))
-> IO (Either Status (Database a))
forall a b. (a -> b) -> a -> b
$
      (Ptr DatabaseHandle -> Identity (Ptr DatabaseHandle))
-> (Ptr DatabaseHandle -> IO (Database a))
-> (Ptr (Ptr DatabaseHandle) -> IO CInt)
-> IO (Either Status (Identity (Database a)))
forall ptr (t :: * -> *) r.
(Storable ptr, Traversable t) =>
(ptr -> t ptr)
-> (ptr -> IO r)
-> (Ptr ptr -> IO CInt)
-> IO (Either Status (t r))
constructF
        Ptr DatabaseHandle -> Identity (Ptr DatabaseHandle)
forall a. a -> Identity a
Identity
        ((ForeignPtr DatabaseHandle -> Database a)
-> IO (ForeignPtr DatabaseHandle) -> IO (Database a)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (DatabaseHandle -> Database a
forall (a :: DatabaseMode). DatabaseHandle -> Database a
Database (DatabaseHandle -> Database a)
-> (ForeignPtr DatabaseHandle -> DatabaseHandle)
-> ForeignPtr DatabaseHandle
-> Database a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr DatabaseHandle -> DatabaseHandle
DatabaseHandle) (IO (ForeignPtr DatabaseHandle) -> IO (Database a))
-> (Ptr DatabaseHandle -> IO (ForeignPtr DatabaseHandle))
-> Ptr DatabaseHandle
-> IO (Database a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FinalizerPtr DatabaseHandle
-> Ptr DatabaseHandle -> IO (ForeignPtr DatabaseHandle)
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr DatabaseHandle
notmuch_database_destroy)
        (Ptr CChar -> CInt -> Ptr (Ptr DatabaseHandle) -> IO CInt
notmuch_database_open Ptr CChar
s' (DatabaseMode -> CInt
forall a b. (Enum a, Integral b) => a -> b
fromEnum' (Proxy a -> DatabaseMode
forall (a :: DatabaseMode). Mode a => Proxy a -> DatabaseMode
getMode (Proxy a
forall {k} (t :: k). Proxy t
Proxy :: Proxy a))))
    ))
  m (Either Status (Database a))
-> (Either Status (Database a) -> m (Database a)) -> m (Database a)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Database a -> m (Database a))
-> Either Status (Database a) -> m (Database a)
forall e (m :: * -> *) a b.
(AsNotmuchError e, MonadError e m) =>
(a -> m b) -> Either Status a -> m b
throwOr Database a -> m (Database a)
forall e (m :: * -> *).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
Database a -> m (Database a)
forall (a :: DatabaseMode) e (m :: * -> *).
(Mode a, AsNotmuchError e, MonadError e m, MonadIO m) =>
Database a -> m (Database a)
upgrade

-- notmuch_status_t notmuch_database_compact(path, backup_path, status_cb, closure)

database_get_path :: Database a -> IO FilePath
database_get_path :: forall (a :: DatabaseMode). Database a -> IO String
database_get_path Database a
db =
  Database a
-> (Ptr DatabaseHandle -> IO (Ptr CChar)) -> IO (Ptr CChar)
forall (a :: DatabaseMode) b.
Database a -> (Ptr DatabaseHandle -> IO b) -> IO b
withDatabase Database a
db Ptr DatabaseHandle -> IO (Ptr CChar)
notmuch_database_get_path IO (Ptr CChar) -> (Ptr CChar -> IO String) -> IO String
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Ptr CChar -> IO String
peekCString

-- | Get the path of the database
databasePath :: Database a -> FilePath
databasePath :: forall (a :: DatabaseMode). Database a -> String
databasePath = IO String -> String
forall a. IO a -> a
System.IO.Unsafe.unsafePerformIO (IO String -> String)
-> (Database a -> IO String) -> Database a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Database a -> IO String
forall (a :: DatabaseMode). Database a -> IO String
database_get_path

database_get_version :: Database a -> IO Int
database_get_version :: forall (a :: DatabaseMode). Database a -> IO Int
database_get_version Database a
db =
  CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CUInt -> Int) -> IO CUInt -> IO Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Database a -> (Ptr DatabaseHandle -> IO CUInt) -> IO CUInt
forall (a :: DatabaseMode) b.
Database a -> (Ptr DatabaseHandle -> IO b) -> IO b
withDatabase Database a
db Ptr DatabaseHandle -> IO CUInt
notmuch_database_get_version
{-# LINE 252 "src/Notmuch/Binding.chs" #-}


-- | Index a file with the default indexing options.
-- (This binding does not yet provide a way to change
-- the indexing options.)  Returns the indexed message.
--
-- If message has same message ID as another message in the
-- database, the new filename will be added to the message
-- and the existing message is returned.
--
-- Possible errors include:
--
-- * 'StatusPathError' if file path is not absolute or is not an
--    extension of the database path.  This check is performed in
--    this binding, not in the foreign /libnotmuch/ code.
-- * 'StatusFileError' when file does not exist or cannot be opened
-- * 'StatusFileNotEmail' when file does not look like an email
--
indexFile
  :: (AsNotmuchError e, MonadError e m, MonadIO m)
  => Database RW -> FilePath -> m (Message 0 RW)
indexFile :: forall e (m :: * -> *).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
Database 'DatabaseModeReadWrite
-> String -> m (Message 0 'DatabaseModeReadWrite)
indexFile db :: Database 'DatabaseModeReadWrite
db@(Database (DatabaseHandle ForeignPtr DatabaseHandle
dfp)) String
path =
  Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not Bool
validPath) (e -> m ()
forall a. e -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Prism' e Status -> Status -> e
forall b (m :: * -> *) t. MonadReader b m => Prism' t b -> m t
review p Status (f Status) -> p e (f e)
forall s. AsNotmuchError s => Prism' s Status
Prism' e Status
_NotmuchError Status
StatusPathError))
  m ()
-> m (Either Status (Identity (Message 0 'DatabaseModeReadWrite)))
-> m (Either Status (Identity (Message 0 'DatabaseModeReadWrite)))
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> IO (Either Status (Identity (Message 0 'DatabaseModeReadWrite)))
-> m (Either Status (Identity (Message 0 'DatabaseModeReadWrite)))
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Database 'DatabaseModeReadWrite
-> (Ptr DatabaseHandle
    -> IO
         (Either Status (Identity (Message 0 'DatabaseModeReadWrite))))
-> IO (Either Status (Identity (Message 0 'DatabaseModeReadWrite)))
forall (a :: DatabaseMode) b.
Database a -> (Ptr DatabaseHandle -> IO b) -> IO b
withDatabase Database 'DatabaseModeReadWrite
db ((Ptr DatabaseHandle
  -> IO
       (Either Status (Identity (Message 0 'DatabaseModeReadWrite))))
 -> IO
      (Either Status (Identity (Message 0 'DatabaseModeReadWrite))))
-> (Ptr DatabaseHandle
    -> IO
         (Either Status (Identity (Message 0 'DatabaseModeReadWrite))))
-> IO (Either Status (Identity (Message 0 'DatabaseModeReadWrite)))
forall a b. (a -> b) -> a -> b
$ \Ptr DatabaseHandle
db' ->
    String
-> (Ptr CChar
    -> IO
         (Either Status (Identity (Message 0 'DatabaseModeReadWrite))))
-> IO (Either Status (Identity (Message 0 'DatabaseModeReadWrite)))
forall a. String -> (Ptr CChar -> IO a) -> IO a
withCString String
path ((Ptr CChar
  -> IO
       (Either Status (Identity (Message 0 'DatabaseModeReadWrite))))
 -> IO
      (Either Status (Identity (Message 0 'DatabaseModeReadWrite))))
-> (Ptr CChar
    -> IO
         (Either Status (Identity (Message 0 'DatabaseModeReadWrite))))
-> IO (Either Status (Identity (Message 0 'DatabaseModeReadWrite)))
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
path' ->
      (Status -> Bool)
-> (Ptr MessageHandle -> Identity (Ptr MessageHandle))
-> (Ptr MessageHandle -> IO (Message 0 'DatabaseModeReadWrite))
-> (Ptr (Ptr MessageHandle) -> IO CInt)
-> IO (Either Status (Identity (Message 0 'DatabaseModeReadWrite)))
forall ptr (t :: * -> *) r.
(Storable ptr, Traversable t) =>
(Status -> Bool)
-> (ptr -> t ptr)
-> (ptr -> IO r)
-> (Ptr ptr -> IO CInt)
-> IO (Either Status (t r))
constructF'
        (\Status
r -> Status
r Status -> Status -> Bool
forall a. Eq a => a -> a -> Bool
== Status
StatusSuccess Bool -> Bool -> Bool
|| Status
r Status -> Status -> Bool
forall a. Eq a => a -> a -> Bool
== Status
StatusDuplicateMessageId)
        Ptr MessageHandle -> Identity (Ptr MessageHandle)
forall a. a -> Identity a
Identity
        ((ForeignPtr MessageHandle -> Message 0 'DatabaseModeReadWrite)
-> IO (ForeignPtr MessageHandle)
-> IO (Message 0 'DatabaseModeReadWrite)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([ForeignPtr ()]
-> MessageHandle -> Message 0 'DatabaseModeReadWrite
forall (n :: Nat) (a :: DatabaseMode).
[ForeignPtr ()] -> MessageHandle -> Message n a
Message [ForeignPtr DatabaseHandle -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr DatabaseHandle
dfp] (MessageHandle -> Message 0 'DatabaseModeReadWrite)
-> (ForeignPtr MessageHandle -> MessageHandle)
-> ForeignPtr MessageHandle
-> Message 0 'DatabaseModeReadWrite
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr MessageHandle -> MessageHandle
MessageHandle)
          (IO (ForeignPtr MessageHandle)
 -> IO (Message 0 'DatabaseModeReadWrite))
-> (Ptr MessageHandle -> IO (ForeignPtr MessageHandle))
-> Ptr MessageHandle
-> IO (Message 0 'DatabaseModeReadWrite)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FinalizerPtr MessageHandle
-> Ptr MessageHandle -> IO (ForeignPtr MessageHandle)
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr MessageHandle
notmuch_message_destroy (Ptr MessageHandle -> IO (ForeignPtr MessageHandle))
-> (Ptr MessageHandle -> IO (Ptr MessageHandle))
-> Ptr MessageHandle
-> IO (ForeignPtr MessageHandle)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Ptr MessageHandle -> IO (Ptr MessageHandle)
forall a. Ptr a -> IO (Ptr a)
detachPtr))
        (Ptr DatabaseHandle
-> Ptr CChar -> Ptr () -> Ptr (Ptr MessageHandle) -> IO CInt
notmuch_database_index_file Ptr DatabaseHandle
db' Ptr CChar
path' Ptr ()
forall a. Ptr a
nullPtr)
  )
  m (Either Status (Identity (Message 0 'DatabaseModeReadWrite)))
-> (Either Status (Identity (Message 0 'DatabaseModeReadWrite))
    -> m (Message 0 'DatabaseModeReadWrite))
-> m (Message 0 'DatabaseModeReadWrite)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Identity (Message 0 'DatabaseModeReadWrite)
 -> m (Message 0 'DatabaseModeReadWrite))
-> Either Status (Identity (Message 0 'DatabaseModeReadWrite))
-> m (Message 0 'DatabaseModeReadWrite)
forall e (m :: * -> *) a b.
(AsNotmuchError e, MonadError e m) =>
(a -> m b) -> Either Status a -> m b
throwOr (Message 0 'DatabaseModeReadWrite
-> m (Message 0 'DatabaseModeReadWrite)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Message 0 'DatabaseModeReadWrite
 -> m (Message 0 'DatabaseModeReadWrite))
-> (Identity (Message 0 'DatabaseModeReadWrite)
    -> Message 0 'DatabaseModeReadWrite)
-> Identity (Message 0 'DatabaseModeReadWrite)
-> m (Message 0 'DatabaseModeReadWrite)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity (Message 0 'DatabaseModeReadWrite)
-> Message 0 'DatabaseModeReadWrite
forall a. Identity a -> a
runIdentity)
  where
    validPath :: Bool
validPath =
      String -> Bool
isAbsolute String
path
      Bool -> Bool -> Bool
&& String -> [String]
splitPath (ShowS
addTrailingPathSeparator (Database 'DatabaseModeReadWrite -> String
forall (a :: DatabaseMode). Database a -> String
databasePath Database 'DatabaseModeReadWrite
db))
          [String] -> [String] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` String -> [String]
splitPath String
path

-- | Result of a 'removeFile' operation.
data RemoveResult = MessageRemoved | MessagePersists
  deriving (RemoveResult -> RemoveResult -> Bool
(RemoveResult -> RemoveResult -> Bool)
-> (RemoveResult -> RemoveResult -> Bool) -> Eq RemoveResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RemoveResult -> RemoveResult -> Bool
== :: RemoveResult -> RemoveResult -> Bool
$c/= :: RemoveResult -> RemoveResult -> Bool
/= :: RemoveResult -> RemoveResult -> Bool
Eq, Int -> RemoveResult -> ShowS
[RemoveResult] -> ShowS
RemoveResult -> String
(Int -> RemoveResult -> ShowS)
-> (RemoveResult -> String)
-> ([RemoveResult] -> ShowS)
-> Show RemoveResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RemoveResult -> ShowS
showsPrec :: Int -> RemoveResult -> ShowS
$cshow :: RemoveResult -> String
show :: RemoveResult -> String
$cshowList :: [RemoveResult] -> ShowS
showList :: [RemoveResult] -> ShowS
Show)

-- | Remove a message filename.  If the message has no more
-- filenames return 'MessageRemoved', otherwise 'MessagePersists'.
--
-- The underlying routine (as of notmuch v0.28) returns
-- @NOTMUCH_STATUS_SUCCESS@ even when the given path does not
-- exist, is not an internet message, or is not recorded in the
-- database.  Therefore @removeFile@ also returns 'MessageRemoved'
-- in this scenario.  This is particularly confusing when the
-- @Message-Id@ of the given file is known, but the the file itself
-- is unknown.
--
removeFile
  :: (AsNotmuchError e, MonadError e m, MonadIO m)
  => Database RW -> FilePath -> m RemoveResult
removeFile :: forall e (m :: * -> *).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
Database 'DatabaseModeReadWrite -> String -> m RemoveResult
removeFile Database 'DatabaseModeReadWrite
db String
path =
  IO Status -> m Status
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Database 'DatabaseModeReadWrite
-> (Ptr DatabaseHandle -> IO Status) -> IO Status
forall (a :: DatabaseMode) b.
Database a -> (Ptr DatabaseHandle -> IO b) -> IO b
withDatabase Database 'DatabaseModeReadWrite
db ((Ptr DatabaseHandle -> IO Status) -> IO Status)
-> (Ptr DatabaseHandle -> IO Status) -> IO Status
forall a b. (a -> b) -> a -> b
$ \Ptr DatabaseHandle
db' ->
    String -> (Ptr CChar -> IO Status) -> IO Status
forall a. String -> (Ptr CChar -> IO a) -> IO a
withCString String
path ((Ptr CChar -> IO Status) -> IO Status)
-> (Ptr CChar -> IO Status) -> IO Status
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
path' ->
      CInt -> Status
forall a b. (Integral a, Enum b) => a -> b
toStatus (CInt -> Status) -> IO CInt -> IO Status
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr DatabaseHandle -> Ptr CChar -> IO CInt
notmuch_database_remove_message Ptr DatabaseHandle
db' Ptr CChar
path'
  )
  m Status -> (Status -> m RemoveResult) -> m RemoveResult
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Status
e -> case Status
e of
    Status
StatusSuccess -> RemoveResult -> m RemoveResult
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RemoveResult
MessageRemoved
    Status
StatusDuplicateMessageId -> RemoveResult -> m RemoveResult
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RemoveResult
MessagePersists
    Status
_ -> e -> m RemoveResult
forall a. e -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (e -> m RemoveResult) -> e -> m RemoveResult
forall a b. (a -> b) -> a -> b
$ Prism' e Status -> Status -> e
forall b (m :: * -> *) t. MonadReader b m => Prism' t b -> m t
review p Status (f Status) -> p e (f e)
forall s. AsNotmuchError s => Prism' s Status
Prism' e Status
_NotmuchError Status
e

-- notmuch_database_needs_upgrade ## do automatically for updates
-- notmuch_database_upgrade ## do automatically for updates
-- notmuch_database_begin_atomic ## do automatically for updates
-- notmuch_database_end_atomic ## do automatically for updates

-- notmuch_database_get_directory

database_find_message
  :: (AsNotmuchError e, MonadError e m, MonadIO m)
  => Database a
  -> MessageId
  -> m (Maybe (Message 0 a))
database_find_message :: forall e (m :: * -> *) (a :: DatabaseMode).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
Database a -> MessageId -> m (Maybe (Message 0 a))
database_find_message =
  (MessageId
 -> (Ptr CChar -> IO (Either Status (Maybe (Message 0 a))))
 -> IO (Either Status (Maybe (Message 0 a))))
-> (Ptr DatabaseHandle
    -> Ptr CChar -> Ptr (Ptr MessageHandle) -> IO CInt)
-> Database a
-> MessageId
-> m (Maybe (Message 0 a))
forall e (m :: * -> *) s s' (a :: DatabaseMode).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
(s
 -> (s' -> IO (Either Status (Maybe (Message 0 a))))
 -> IO (Either Status (Maybe (Message 0 a))))
-> (Ptr DatabaseHandle -> s' -> Ptr (Ptr MessageHandle) -> IO CInt)
-> Database a
-> s
-> m (Maybe (Message 0 a))
database_find_message_x MessageId
-> (Ptr CChar -> IO (Either Status (Maybe (Message 0 a))))
-> IO (Either Status (Maybe (Message 0 a)))
forall a. MessageId -> (Ptr CChar -> IO a) -> IO a
B.useAsCString Ptr DatabaseHandle
-> Ptr CChar -> Ptr (Ptr MessageHandle) -> IO CInt
notmuch_database_find_message
{-# LINE 332 "src/Notmuch/Binding.chs" #-}


database_find_message_by_filename
  :: (AsNotmuchError e, MonadError e m, MonadIO m)
  => Database a -- ^ Database
  -> FilePath   -- ^ Filename
  -> m (Maybe (Message 0 a))
database_find_message_by_filename :: forall e (m :: * -> *) (a :: DatabaseMode).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
Database a -> String -> m (Maybe (Message 0 a))
database_find_message_by_filename =
  (String
 -> (Ptr CChar -> IO (Either Status (Maybe (Message 0 a))))
 -> IO (Either Status (Maybe (Message 0 a))))
-> (Ptr DatabaseHandle
    -> Ptr CChar -> Ptr (Ptr MessageHandle) -> IO CInt)
-> Database a
-> String
-> m (Maybe (Message 0 a))
forall e (m :: * -> *) s s' (a :: DatabaseMode).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
(s
 -> (s' -> IO (Either Status (Maybe (Message 0 a))))
 -> IO (Either Status (Maybe (Message 0 a))))
-> (Ptr DatabaseHandle -> s' -> Ptr (Ptr MessageHandle) -> IO CInt)
-> Database a
-> s
-> m (Maybe (Message 0 a))
database_find_message_x String
-> (Ptr CChar -> IO (Either Status (Maybe (Message 0 a))))
-> IO (Either Status (Maybe (Message 0 a)))
forall a. String -> (Ptr CChar -> IO a) -> IO a
withCString Ptr DatabaseHandle
-> Ptr CChar -> Ptr (Ptr MessageHandle) -> IO CInt
notmuch_database_find_message_by_filename
{-# LINE 340 "src/Notmuch/Binding.chs" #-}


database_find_message_x
  :: (AsNotmuchError e, MonadError e m, MonadIO m)
  => (s -> (s' -> IO (Either Status (Maybe (Message 0 a)))) -> IO (Either Status (Maybe (Message 0 a))))
  -> (Ptr DatabaseHandle -> s' -> Ptr (Ptr MessageHandle) -> IO CInt)
  -> Database a -- ^ Database
  -> s
  -> m (Maybe (Message 0 a))
database_find_message_x :: forall e (m :: * -> *) s s' (a :: DatabaseMode).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
(s
 -> (s' -> IO (Either Status (Maybe (Message 0 a))))
 -> IO (Either Status (Maybe (Message 0 a))))
-> (Ptr DatabaseHandle -> s' -> Ptr (Ptr MessageHandle) -> IO CInt)
-> Database a
-> s
-> m (Maybe (Message 0 a))
database_find_message_x s
-> (s' -> IO (Either Status (Maybe (Message 0 a))))
-> IO (Either Status (Maybe (Message 0 a)))
prep Ptr DatabaseHandle -> s' -> Ptr (Ptr MessageHandle) -> IO CInt
f db :: Database a
db@(Database (DatabaseHandle ForeignPtr DatabaseHandle
dfp)) s
s =
  IO (Either Status (Maybe (Message 0 a)))
-> m (Either Status (Maybe (Message 0 a)))
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Database a
-> (Ptr DatabaseHandle -> IO (Either Status (Maybe (Message 0 a))))
-> IO (Either Status (Maybe (Message 0 a)))
forall (a :: DatabaseMode) b.
Database a -> (Ptr DatabaseHandle -> IO b) -> IO b
withDatabase Database a
db ((Ptr DatabaseHandle -> IO (Either Status (Maybe (Message 0 a))))
 -> IO (Either Status (Maybe (Message 0 a))))
-> (Ptr DatabaseHandle -> IO (Either Status (Maybe (Message 0 a))))
-> IO (Either Status (Maybe (Message 0 a)))
forall a b. (a -> b) -> a -> b
$ \Ptr DatabaseHandle
db' ->
    s
-> (s' -> IO (Either Status (Maybe (Message 0 a))))
-> IO (Either Status (Maybe (Message 0 a)))
prep s
s ((s' -> IO (Either Status (Maybe (Message 0 a))))
 -> IO (Either Status (Maybe (Message 0 a))))
-> (s' -> IO (Either Status (Maybe (Message 0 a))))
-> IO (Either Status (Maybe (Message 0 a)))
forall a b. (a -> b) -> a -> b
$ \s'
s' ->
      (Ptr MessageHandle -> Maybe (Ptr MessageHandle))
-> (Ptr MessageHandle -> IO (Message 0 a))
-> (Ptr (Ptr MessageHandle) -> IO CInt)
-> IO (Either Status (Maybe (Message 0 a)))
forall ptr (t :: * -> *) r.
(Storable ptr, Traversable t) =>
(ptr -> t ptr)
-> (ptr -> IO r)
-> (Ptr ptr -> IO CInt)
-> IO (Either Status (t r))
constructF
        (\Ptr MessageHandle
ptr -> if Ptr MessageHandle
ptr Ptr MessageHandle -> Ptr MessageHandle -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr MessageHandle
forall a. Ptr a
nullPtr then Ptr MessageHandle -> Maybe (Ptr MessageHandle)
forall a. a -> Maybe a
Just Ptr MessageHandle
ptr else Maybe (Ptr MessageHandle)
forall a. Maybe a
Nothing)
        ((ForeignPtr MessageHandle -> Message 0 a)
-> IO (ForeignPtr MessageHandle) -> IO (Message 0 a)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([ForeignPtr ()] -> MessageHandle -> Message 0 a
forall (n :: Nat) (a :: DatabaseMode).
[ForeignPtr ()] -> MessageHandle -> Message n a
Message [ForeignPtr DatabaseHandle -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr DatabaseHandle
dfp] (MessageHandle -> Message 0 a)
-> (ForeignPtr MessageHandle -> MessageHandle)
-> ForeignPtr MessageHandle
-> Message 0 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr MessageHandle -> MessageHandle
MessageHandle)
          (IO (ForeignPtr MessageHandle) -> IO (Message 0 a))
-> (Ptr MessageHandle -> IO (ForeignPtr MessageHandle))
-> Ptr MessageHandle
-> IO (Message 0 a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FinalizerPtr MessageHandle
-> Ptr MessageHandle -> IO (ForeignPtr MessageHandle)
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr MessageHandle
notmuch_message_destroy (Ptr MessageHandle -> IO (ForeignPtr MessageHandle))
-> (Ptr MessageHandle -> IO (Ptr MessageHandle))
-> Ptr MessageHandle
-> IO (ForeignPtr MessageHandle)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Ptr MessageHandle -> IO (Ptr MessageHandle)
forall a. Ptr a -> IO (Ptr a)
detachPtr))
        (Ptr DatabaseHandle -> s' -> Ptr (Ptr MessageHandle) -> IO CInt
f Ptr DatabaseHandle
db' s'
s')
  )
  m (Either Status (Maybe (Message 0 a)))
-> (Either Status (Maybe (Message 0 a)) -> m (Maybe (Message 0 a)))
-> m (Maybe (Message 0 a))
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Maybe (Message 0 a) -> m (Maybe (Message 0 a)))
-> Either Status (Maybe (Message 0 a)) -> m (Maybe (Message 0 a))
forall e (m :: * -> *) a b.
(AsNotmuchError e, MonadError e m) =>
(a -> m b) -> Either Status a -> m b
throwOr Maybe (Message 0 a) -> m (Maybe (Message 0 a))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure

-- Tags are always copied from the libnotmuch-managed memory,
-- and all the copying takes place under 'withDatabase', so
-- we don't need to detach the pointer or use a ForeignPtr.
--
-- TODO: check for NULL, indicating error
--
database_get_all_tags :: Database a -> IO [Tag]
database_get_all_tags :: forall (a :: DatabaseMode). Database a -> IO [Tag]
database_get_all_tags Database a
ptr = Database a -> (Ptr DatabaseHandle -> IO [Tag]) -> IO [Tag]
forall (a :: DatabaseMode) b.
Database a -> (Ptr DatabaseHandle -> IO b) -> IO b
withDatabase Database a
ptr ((Ptr DatabaseHandle -> IO [Tag]) -> IO [Tag])
-> (Ptr DatabaseHandle -> IO [Tag]) -> IO [Tag]
forall a b. (a -> b) -> a -> b
$ \Ptr DatabaseHandle
ptr' ->
  Ptr DatabaseHandle -> IO Tags
notmuch_database_get_all_tags Ptr DatabaseHandle
ptr' IO Tags -> (Tags -> IO [Tag]) -> IO [Tag]
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Tags -> IO [Tag]
tagsToList

-- TODO: check for NULL, indicating error
query_create :: Database a -> String -> IO (Query a)
query_create :: forall (a :: DatabaseMode). Database a -> String -> IO (Query a)
query_create db :: Database a
db@(Database (DatabaseHandle ForeignPtr DatabaseHandle
dfp)) String
s = String -> (Ptr CChar -> IO (Query a)) -> IO (Query a)
forall a. String -> (Ptr CChar -> IO a) -> IO a
withCString String
s ((Ptr CChar -> IO (Query a)) -> IO (Query a))
-> (Ptr CChar -> IO (Query a)) -> IO (Query a)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
s' ->
  Database a -> (Ptr DatabaseHandle -> IO (Query a)) -> IO (Query a)
forall (a :: DatabaseMode) b.
Database a -> (Ptr DatabaseHandle -> IO b) -> IO b
withDatabase Database a
db ((Ptr DatabaseHandle -> IO (Query a)) -> IO (Query a))
-> (Ptr DatabaseHandle -> IO (Query a)) -> IO (Query a)
forall a b. (a -> b) -> a -> b
$ \Ptr DatabaseHandle
db' ->
    Ptr DatabaseHandle -> Ptr CChar -> IO (Ptr QueryHandle)
notmuch_query_create Ptr DatabaseHandle
db' Ptr CChar
s'
      IO (Ptr QueryHandle)
-> (Ptr QueryHandle -> IO (Ptr QueryHandle))
-> IO (Ptr QueryHandle)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Ptr QueryHandle -> IO (Ptr QueryHandle)
forall a. Ptr a -> IO (Ptr a)
detachPtr
      IO (Ptr QueryHandle)
-> (Ptr QueryHandle -> IO (Query a)) -> IO (Query a)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ForeignPtr QueryHandle -> Query a)
-> IO (ForeignPtr QueryHandle) -> IO (Query a)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ForeignPtr DatabaseHandle -> QueryHandle -> Query a
forall (a :: DatabaseMode).
ForeignPtr DatabaseHandle -> QueryHandle -> Query a
Query ForeignPtr DatabaseHandle
dfp (QueryHandle -> Query a)
-> (ForeignPtr QueryHandle -> QueryHandle)
-> ForeignPtr QueryHandle
-> Query a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr QueryHandle -> QueryHandle
QueryHandle) (IO (ForeignPtr QueryHandle) -> IO (Query a))
-> (Ptr QueryHandle -> IO (ForeignPtr QueryHandle))
-> Ptr QueryHandle
-> IO (Query a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FinalizerPtr QueryHandle
-> Ptr QueryHandle -> IO (ForeignPtr QueryHandle)
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr QueryHandle
notmuch_query_destroy

query_get_query_string :: Query a -> IO String
query_get_query_string :: forall (a :: DatabaseMode). Query a -> IO String
query_get_query_string Query a
ptr =
  Query a -> (Ptr QueryHandle -> IO String) -> IO String
forall (a :: DatabaseMode) b.
Query a -> (Ptr QueryHandle -> IO b) -> IO b
withQuery Query a
ptr (Ptr QueryHandle -> IO (Ptr CChar)
notmuch_query_get_query_string (Ptr QueryHandle -> IO (Ptr CChar))
-> (Ptr CChar -> IO String) -> Ptr QueryHandle -> IO String
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr CChar -> IO String
peekCString)

query_set_sort :: Query a -> Sort -> IO ()
query_set_sort :: forall (a :: DatabaseMode). Query a -> Sort -> IO ()
query_set_sort Query a
ptr Sort
x = Query a -> (Ptr QueryHandle -> IO ()) -> IO ()
forall (a :: DatabaseMode) b.
Query a -> (Ptr QueryHandle -> IO b) -> IO b
withQuery Query a
ptr ((Ptr QueryHandle -> IO ()) -> IO ())
-> (Ptr QueryHandle -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr QueryHandle
ptr' ->
  Ptr QueryHandle -> CInt -> IO ()
notmuch_query_set_sort Ptr QueryHandle
ptr' (Sort -> CInt
forall a b. (Enum a, Integral b) => a -> b
fromEnum' Sort
x)

query_get_sort :: Query a -> IO Sort
query_get_sort :: forall (a :: DatabaseMode). Query a -> IO Sort
query_get_sort Query a
ptr = Query a -> (Ptr QueryHandle -> IO Sort) -> IO Sort
forall (a :: DatabaseMode) b.
Query a -> (Ptr QueryHandle -> IO b) -> IO b
withQuery Query a
ptr ((Ptr QueryHandle -> IO Sort) -> IO Sort)
-> (Ptr QueryHandle -> IO Sort) -> IO Sort
forall a b. (a -> b) -> a -> b
$
  (CInt -> Sort) -> IO CInt -> IO Sort
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> Sort
forall a. Enum a => Int -> a
toEnum (Int -> Sort) -> (CInt -> Int) -> CInt -> Sort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) (IO CInt -> IO Sort)
-> (Ptr QueryHandle -> IO CInt) -> Ptr QueryHandle -> IO Sort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr QueryHandle -> IO CInt
notmuch_query_get_sort
{-# LINE 388 "src/Notmuch/Binding.chs" #-}


query_add_tag_exclude :: Query a -> Tag -> IO ()
query_add_tag_exclude :: forall (a :: DatabaseMode). Query a -> Tag -> IO ()
query_add_tag_exclude Query a
ptr Tag
tag = IO CInt -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
  Query a -> (Ptr QueryHandle -> IO CInt) -> IO CInt
forall (a :: DatabaseMode) b.
Query a -> (Ptr QueryHandle -> IO b) -> IO b
withQuery Query a
ptr ((Ptr QueryHandle -> IO CInt) -> IO CInt)
-> (Ptr QueryHandle -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \Ptr QueryHandle
ptr' ->
    Tag -> (Ptr CChar -> IO CInt) -> IO CInt
forall a. Tag -> (Ptr CChar -> IO a) -> IO a
tagUseAsCString Tag
tag ((Ptr CChar -> IO CInt) -> IO CInt)
-> (Ptr CChar -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
s' ->
      Ptr QueryHandle -> Ptr CChar -> IO CInt
notmuch_query_add_tag_exclude Ptr QueryHandle
ptr' Ptr CChar
s'

query_search_threads
  :: (AsNotmuchError e, MonadError e m, MonadIO m)
  => Query a -> m [Thread a]
query_search_threads :: forall e (m :: * -> *) (a :: DatabaseMode).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
Query a -> m [Thread a]
query_search_threads q :: Query a
q@(Query ForeignPtr DatabaseHandle
dfp (QueryHandle ForeignPtr QueryHandle
qfp)) =
  IO (Either Status (Identity [Thread a]))
-> m (Either Status (Identity [Thread a]))
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO ( Query a
-> (Ptr QueryHandle -> IO (Either Status (Identity [Thread a])))
-> IO (Either Status (Identity [Thread a]))
forall (a :: DatabaseMode) b.
Query a -> (Ptr QueryHandle -> IO b) -> IO b
withQuery Query a
q ((Ptr QueryHandle -> IO (Either Status (Identity [Thread a])))
 -> IO (Either Status (Identity [Thread a])))
-> (Ptr QueryHandle -> IO (Either Status (Identity [Thread a])))
-> IO (Either Status (Identity [Thread a]))
forall a b. (a -> b) -> a -> b
$ \Ptr QueryHandle
qPtr ->
    (Threads -> Identity Threads)
-> (Threads -> IO [Thread a])
-> (Ptr Threads -> IO CInt)
-> IO (Either Status (Identity [Thread a]))
forall ptr (t :: * -> *) r.
(Storable ptr, Traversable t) =>
(ptr -> t ptr)
-> (ptr -> IO r)
-> (Ptr ptr -> IO CInt)
-> IO (Either Status (t r))
constructF
      Threads -> Identity Threads
forall a. a -> Identity a
Identity
      (ForeignPtr DatabaseHandle
-> ForeignPtr QueryHandle -> Threads -> IO [Thread a]
forall (mode :: DatabaseMode).
ForeignPtr DatabaseHandle
-> ForeignPtr QueryHandle -> Threads -> IO [Thread mode]
threadsToList ForeignPtr DatabaseHandle
dfp ForeignPtr QueryHandle
qfp)
      (Ptr QueryHandle -> Ptr Threads -> IO CInt
notmuch_query_search_threads Ptr QueryHandle
qPtr)
  )
  m (Either Status (Identity [Thread a]))
-> (Either Status (Identity [Thread a]) -> m [Thread a])
-> m [Thread a]
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Identity [Thread a] -> m [Thread a])
-> Either Status (Identity [Thread a]) -> m [Thread a]
forall e (m :: * -> *) a b.
(AsNotmuchError e, MonadError e m) =>
(a -> m b) -> Either Status a -> m b
throwOr ([Thread a] -> m [Thread a]
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Thread a] -> m [Thread a])
-> (Identity [Thread a] -> [Thread a])
-> Identity [Thread a]
-> m [Thread a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity [Thread a] -> [Thread a]
forall a. Identity a -> a
runIdentity)

query_search_messages
  :: (AsNotmuchError e, MonadError e m, MonadIO m)
  => Query a -> m [Message 0 a]
query_search_messages :: forall e (m :: * -> *) (a :: DatabaseMode).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
Query a -> m [Message 0 a]
query_search_messages q :: Query a
q@(Query ForeignPtr DatabaseHandle
dfp (QueryHandle ForeignPtr QueryHandle
qfp)) =
  IO (Either Status (Identity [Message 0 a]))
-> m (Either Status (Identity [Message 0 a]))
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO ( Query a
-> (Ptr QueryHandle -> IO (Either Status (Identity [Message 0 a])))
-> IO (Either Status (Identity [Message 0 a]))
forall (a :: DatabaseMode) b.
Query a -> (Ptr QueryHandle -> IO b) -> IO b
withQuery Query a
q ((Ptr QueryHandle -> IO (Either Status (Identity [Message 0 a])))
 -> IO (Either Status (Identity [Message 0 a])))
-> (Ptr QueryHandle -> IO (Either Status (Identity [Message 0 a])))
-> IO (Either Status (Identity [Message 0 a]))
forall a b. (a -> b) -> a -> b
$ \Ptr QueryHandle
qPtr ->
    (Messages -> Identity Messages)
-> (Messages -> IO [Message 0 a])
-> (Ptr Messages -> IO CInt)
-> IO (Either Status (Identity [Message 0 a]))
forall ptr (t :: * -> *) r.
(Storable ptr, Traversable t) =>
(ptr -> t ptr)
-> (ptr -> IO r)
-> (Ptr ptr -> IO CInt)
-> IO (Either Status (t r))
constructF
      Messages -> Identity Messages
forall a. a -> Identity a
Identity
      ([ForeignPtr ()] -> Messages -> IO [Message 0 a]
forall (mode :: DatabaseMode).
[ForeignPtr ()] -> Messages -> IO [Message 0 mode]
messagesToList [ForeignPtr DatabaseHandle -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr DatabaseHandle
dfp, ForeignPtr QueryHandle -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr QueryHandle
qfp])
      (Ptr QueryHandle -> Ptr Messages -> IO CInt
notmuch_query_search_messages Ptr QueryHandle
qPtr)
  )
  m (Either Status (Identity [Message 0 a]))
-> (Either Status (Identity [Message 0 a]) -> m [Message 0 a])
-> m [Message 0 a]
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Identity [Message 0 a] -> m [Message 0 a])
-> Either Status (Identity [Message 0 a]) -> m [Message 0 a]
forall e (m :: * -> *) a b.
(AsNotmuchError e, MonadError e m) =>
(a -> m b) -> Either Status a -> m b
throwOr ([Message 0 a] -> m [Message 0 a]
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Message 0 a] -> m [Message 0 a])
-> (Identity [Message 0 a] -> [Message 0 a])
-> Identity [Message 0 a]
-> m [Message 0 a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity [Message 0 a] -> [Message 0 a]
forall a. Identity a -> a
runIdentity)

query_count_x
  :: (AsNotmuchError e, MonadError e m, MonadIO m)
  => (Ptr QueryHandle -> Ptr CUInt -> IO CInt)
  -> Query a -> m Int
query_count_x :: forall e (m :: * -> *) (a :: DatabaseMode).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
(Ptr QueryHandle -> Ptr CUInt -> IO CInt) -> Query a -> m Int
query_count_x Ptr QueryHandle -> Ptr CUInt -> IO CInt
f Query a
q = (CUInt -> Int) -> m CUInt -> m Int
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (m CUInt -> m Int) -> m CUInt -> m Int
forall a b. (a -> b) -> a -> b
$
  IO (Either Status CUInt) -> m (Either Status CUInt)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (
    Query a
-> (Ptr QueryHandle -> IO (Either Status CUInt))
-> IO (Either Status CUInt)
forall (a :: DatabaseMode) b.
Query a -> (Ptr QueryHandle -> IO b) -> IO b
withQuery Query a
q ((Ptr QueryHandle -> IO (Either Status CUInt))
 -> IO (Either Status CUInt))
-> (Ptr QueryHandle -> IO (Either Status CUInt))
-> IO (Either Status CUInt)
forall a b. (a -> b) -> a -> b
$ \Ptr QueryHandle
qPtr ->
      (Ptr CUInt -> IO (Either Status CUInt)) -> IO (Either Status CUInt)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CUInt -> IO (Either Status CUInt))
 -> IO (Either Status CUInt))
-> (Ptr CUInt -> IO (Either Status CUInt))
-> IO (Either Status CUInt)
forall a b. (a -> b) -> a -> b
$ \Ptr CUInt
intPtr ->
        CInt -> Status
forall a b. (Integral a, Enum b) => a -> b
toStatus (CInt -> Status) -> IO CInt -> IO Status
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr QueryHandle -> Ptr CUInt -> IO CInt
f Ptr QueryHandle
qPtr Ptr CUInt
intPtr
        IO Status
-> (Status -> IO (Either Status CUInt)) -> IO (Either Status CUInt)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= IO CUInt -> Status -> IO (Either Status CUInt)
forall (f :: * -> *) a.
Applicative f =>
f a -> Status -> f (Either Status a)
status (Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
intPtr)
  ) m (Either Status CUInt)
-> (Either Status CUInt -> m CUInt) -> m CUInt
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (CUInt -> m CUInt) -> Either Status CUInt -> m CUInt
forall e (m :: * -> *) a b.
(AsNotmuchError e, MonadError e m) =>
(a -> m b) -> Either Status a -> m b
throwOr CUInt -> m CUInt
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure

query_count_messages, query_count_threads
  :: (AsNotmuchError e, MonadError e m, MonadIO m) => Query a -> m Int
query_count_messages :: forall e (m :: * -> *) (a :: DatabaseMode).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
Query a -> m Int
query_count_messages = (Ptr QueryHandle -> Ptr CUInt -> IO CInt) -> Query a -> m Int
forall e (m :: * -> *) (a :: DatabaseMode).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
(Ptr QueryHandle -> Ptr CUInt -> IO CInt) -> Query a -> m Int
query_count_x Ptr QueryHandle -> Ptr CUInt -> IO CInt
notmuch_query_count_messages
{-# LINE 453 "src/Notmuch/Binding.chs" #-}

query_count_threads :: forall e (m :: * -> *) (a :: DatabaseMode).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
Query a -> m Int
query_count_threads = (Ptr QueryHandle -> Ptr CUInt -> IO CInt) -> Query a -> m Int
forall e (m :: * -> *) (a :: DatabaseMode).
(AsNotmuchError e, MonadError e m, MonadIO m) =>
(Ptr QueryHandle -> Ptr CUInt -> IO CInt) -> Query a -> m Int
query_count_x Ptr QueryHandle -> Ptr CUInt -> IO CInt
notmuch_query_count_threads
{-# LINE 454 "src/Notmuch/Binding.chs" #-}



thread_get_thread_id :: Thread a -> IO ThreadId
thread_get_thread_id :: forall (a :: DatabaseMode). Thread a -> IO MessageId
thread_get_thread_id Thread a
ptr =
  Thread a -> (Ptr ThreadHandle -> IO MessageId) -> IO MessageId
forall (a :: DatabaseMode) b.
Thread a -> (Ptr ThreadHandle -> IO b) -> IO b
withThread Thread a
ptr (Ptr ThreadHandle -> IO (Ptr CChar)
notmuch_thread_get_thread_id (Ptr ThreadHandle -> IO (Ptr CChar))
-> (Ptr CChar -> IO MessageId) -> Ptr ThreadHandle -> IO MessageId
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr CChar -> IO MessageId
B.packCString)

thread_get_total_messages :: Thread a -> IO Int
thread_get_total_messages :: forall (a :: DatabaseMode). Thread a -> IO Int
thread_get_total_messages Thread a
ptr =
  CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Int) -> IO CInt -> IO Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Thread a -> (Ptr ThreadHandle -> IO CInt) -> IO CInt
forall (a :: DatabaseMode) b.
Thread a -> (Ptr ThreadHandle -> IO b) -> IO b
withThread Thread a
ptr (Ptr ThreadHandle -> IO CInt
notmuch_thread_get_total_messages)

thread_get_toplevel_messages :: MonadIO m => Thread a -> m [Message 0 a]
thread_get_toplevel_messages :: forall (m :: * -> *) (a :: DatabaseMode).
MonadIO m =>
Thread a -> m [Message 0 a]
thread_get_toplevel_messages t :: Thread a
t@(Thread ForeignPtr DatabaseHandle
dfp ForeignPtr QueryHandle
qfp (ThreadHandle ForeignPtr ThreadHandle
tfp))
  = IO [Message 0 a] -> m [Message 0 a]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Message 0 a] -> m [Message 0 a])
-> IO [Message 0 a] -> m [Message 0 a]
forall a b. (a -> b) -> a -> b
$ Thread a
-> (Ptr ThreadHandle -> IO [Message 0 a]) -> IO [Message 0 a]
forall (a :: DatabaseMode) b.
Thread a -> (Ptr ThreadHandle -> IO b) -> IO b
withThread Thread a
t ((Ptr ThreadHandle -> IO [Message 0 a]) -> IO [Message 0 a])
-> (Ptr ThreadHandle -> IO [Message 0 a]) -> IO [Message 0 a]
forall a b. (a -> b) -> a -> b
$ \Ptr ThreadHandle
ptr ->
    Ptr ThreadHandle -> IO Messages
notmuch_thread_get_toplevel_messages Ptr ThreadHandle
ptr
    IO Messages -> (Messages -> IO [Message 0 a]) -> IO [Message 0 a]
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [ForeignPtr ()] -> Messages -> IO [Message 0 a]
forall (mode :: DatabaseMode).
[ForeignPtr ()] -> Messages -> IO [Message 0 mode]
messagesToList [ForeignPtr DatabaseHandle -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr DatabaseHandle
dfp, ForeignPtr QueryHandle -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr QueryHandle
qfp, ForeignPtr ThreadHandle -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr ThreadHandle
tfp]

thread_get_messages :: MonadIO m => Thread a -> m [Message 0 a]
thread_get_messages :: forall (m :: * -> *) (a :: DatabaseMode).
MonadIO m =>
Thread a -> m [Message 0 a]
thread_get_messages t :: Thread a
t@(Thread ForeignPtr DatabaseHandle
dfp ForeignPtr QueryHandle
qfp (ThreadHandle ForeignPtr ThreadHandle
tfp))
  = IO [Message 0 a] -> m [Message 0 a]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Message 0 a] -> m [Message 0 a])
-> IO [Message 0 a] -> m [Message 0 a]
forall a b. (a -> b) -> a -> b
$ Thread a
-> (Ptr ThreadHandle -> IO [Message 0 a]) -> IO [Message 0 a]
forall (a :: DatabaseMode) b.
Thread a -> (Ptr ThreadHandle -> IO b) -> IO b
withThread Thread a
t ((Ptr ThreadHandle -> IO [Message 0 a]) -> IO [Message 0 a])
-> (Ptr ThreadHandle -> IO [Message 0 a]) -> IO [Message 0 a]
forall a b. (a -> b) -> a -> b
$ \Ptr ThreadHandle
ptr ->
    Ptr ThreadHandle -> IO Messages
notmuch_thread_get_messages Ptr ThreadHandle
ptr
    IO Messages -> (Messages -> IO [Message 0 a]) -> IO [Message 0 a]
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [ForeignPtr ()] -> Messages -> IO [Message 0 a]
forall (mode :: DatabaseMode).
[ForeignPtr ()] -> Messages -> IO [Message 0 mode]
messagesToList [ForeignPtr DatabaseHandle -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr DatabaseHandle
dfp, ForeignPtr QueryHandle -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr QueryHandle
qfp, ForeignPtr ThreadHandle -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr ThreadHandle
tfp]

-- notmuch_thread_get_matched_messages -> Int

thread_get_authors :: Thread a -> IO (Maybe B.ByteString)
thread_get_authors :: forall (a :: DatabaseMode). Thread a -> IO (Maybe MessageId)
thread_get_authors Thread a
ptr = Thread a
-> (Ptr ThreadHandle -> IO (Maybe MessageId))
-> IO (Maybe MessageId)
forall (a :: DatabaseMode) b.
Thread a -> (Ptr ThreadHandle -> IO b) -> IO b
withThread Thread a
ptr ((Ptr ThreadHandle -> IO (Maybe MessageId))
 -> IO (Maybe MessageId))
-> (Ptr ThreadHandle -> IO (Maybe MessageId))
-> IO (Maybe MessageId)
forall a b. (a -> b) -> a -> b
$ \Ptr ThreadHandle
ptr' -> do
  Ptr CChar
r <- Ptr ThreadHandle -> IO (Ptr CChar)
notmuch_thread_get_authors Ptr ThreadHandle
ptr'
  if Ptr CChar
r Ptr CChar -> Ptr CChar -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr CChar
forall a. Ptr a
nullPtr
     then Maybe MessageId -> IO (Maybe MessageId)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe MessageId
forall a. Maybe a
Nothing
     else MessageId -> Maybe MessageId
forall a. a -> Maybe a
Just (MessageId -> Maybe MessageId)
-> IO MessageId -> IO (Maybe MessageId)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CChar -> IO MessageId
B.packCString Ptr CChar
r

thread_get_subject :: Thread a -> IO B.ByteString
thread_get_subject :: forall (a :: DatabaseMode). Thread a -> IO MessageId
thread_get_subject Thread a
ptr = Thread a -> (Ptr ThreadHandle -> IO MessageId) -> IO MessageId
forall (a :: DatabaseMode) b.
Thread a -> (Ptr ThreadHandle -> IO b) -> IO b
withThread Thread a
ptr (Ptr ThreadHandle -> IO (Ptr CChar)
notmuch_thread_get_subject (Ptr ThreadHandle -> IO (Ptr CChar))
-> (Ptr CChar -> IO MessageId) -> Ptr ThreadHandle -> IO MessageId
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr CChar -> IO MessageId
B.packCString)
-- notmuch_thread_get_oldest_date
thread_get_newest_date :: Thread a -> IO CLong
thread_get_newest_date :: forall (a :: DatabaseMode). Thread a -> IO CLong
thread_get_newest_date = (Thread a -> (Ptr ThreadHandle -> IO CLong) -> IO CLong)
-> (Ptr ThreadHandle -> IO CLong) -> Thread a -> IO CLong
forall a b c. (a -> b -> c) -> b -> a -> c
flip Thread a -> (Ptr ThreadHandle -> IO CLong) -> IO CLong
forall (a :: DatabaseMode) b.
Thread a -> (Ptr ThreadHandle -> IO b) -> IO b
withThread Ptr ThreadHandle -> IO CLong
notmuch_thread_get_newest_date
{-# LINE 490 "src/Notmuch/Binding.chs" #-}


-- Tags are always copied from the libnotmuch-managed memory,
-- and all the copying takes place under 'withThread', so
-- we don't need to detach the pointer or use a ForeignPtr.
thread_get_tags :: Thread a -> IO [Tag]
thread_get_tags :: forall (a :: DatabaseMode). Thread a -> IO [Tag]
thread_get_tags Thread a
ptr = Thread a -> (Ptr ThreadHandle -> IO [Tag]) -> IO [Tag]
forall (a :: DatabaseMode) b.
Thread a -> (Ptr ThreadHandle -> IO b) -> IO b
withThread Thread a
ptr ((Ptr ThreadHandle -> IO [Tag]) -> IO [Tag])
-> (Ptr ThreadHandle -> IO [Tag]) -> IO [Tag]
forall a b. (a -> b) -> a -> b
$
  Ptr ThreadHandle -> IO Tags
notmuch_thread_get_tags (Ptr ThreadHandle -> IO Tags)
-> (Tags -> IO [Tag]) -> Ptr ThreadHandle -> IO [Tag]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Tags -> IO [Tag]
tagsToList

message_get_message_id :: Message n a -> IO MessageId
message_get_message_id :: forall (n :: Nat) (a :: DatabaseMode). Message n a -> IO MessageId
message_get_message_id Message n a
ptr =
  Message n a -> (Ptr MessageHandle -> IO MessageId) -> IO MessageId
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Message n a
ptr (Ptr MessageHandle -> IO (Ptr CChar)
notmuch_message_get_message_id (Ptr MessageHandle -> IO (Ptr CChar))
-> (Ptr CChar -> IO MessageId) -> Ptr MessageHandle -> IO MessageId
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr CChar -> IO MessageId
B.packCString)

message_get_thread_id :: Message n a -> IO ThreadId
message_get_thread_id :: forall (n :: Nat) (a :: DatabaseMode). Message n a -> IO MessageId
message_get_thread_id Message n a
ptr =
  Message n a -> (Ptr MessageHandle -> IO MessageId) -> IO MessageId
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Message n a
ptr (Ptr MessageHandle -> IO (Ptr CChar)
notmuch_message_get_thread_id (Ptr MessageHandle -> IO (Ptr CChar))
-> (Ptr CChar -> IO MessageId) -> Ptr MessageHandle -> IO MessageId
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr CChar -> IO MessageId
B.packCString)

message_get_replies :: MonadIO m => Message n a -> m [Message 0 a]
message_get_replies :: forall (m :: * -> *) (n :: Nat) (a :: DatabaseMode).
MonadIO m =>
Message n a -> m [Message 0 a]
message_get_replies msg :: Message n a
msg@(Message [ForeignPtr ()]
owners (MessageHandle ForeignPtr MessageHandle
mfp))
  = IO [Message 0 a] -> m [Message 0 a]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Message 0 a] -> m [Message 0 a])
-> IO [Message 0 a] -> m [Message 0 a]
forall a b. (a -> b) -> a -> b
$ Message n a
-> (Ptr MessageHandle -> IO [Message 0 a]) -> IO [Message 0 a]
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Message n a
msg ((Ptr MessageHandle -> IO [Message 0 a]) -> IO [Message 0 a])
-> (Ptr MessageHandle -> IO [Message 0 a]) -> IO [Message 0 a]
forall a b. (a -> b) -> a -> b
$ \Ptr MessageHandle
ptr ->
    Ptr MessageHandle -> IO Messages
notmuch_message_get_replies Ptr MessageHandle
ptr
      IO Messages -> (Messages -> IO [Message 0 a]) -> IO [Message 0 a]
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [ForeignPtr ()] -> Messages -> IO [Message 0 a]
forall (mode :: DatabaseMode).
[ForeignPtr ()] -> Messages -> IO [Message 0 mode]
messagesToList (ForeignPtr MessageHandle -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr MessageHandle
mfp ForeignPtr () -> [ForeignPtr ()] -> [ForeignPtr ()]
forall a. a -> [a] -> [a]
: [ForeignPtr ()]
owners)
          -- have to keep this message alive, as well as its owners

message_get_filename :: Message n a -> IO FilePath
message_get_filename :: forall (n :: Nat) (a :: DatabaseMode). Message n a -> IO String
message_get_filename Message n a
ptr =
  Message n a -> (Ptr MessageHandle -> IO String) -> IO String
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Message n a
ptr (Ptr MessageHandle -> IO (Ptr CChar)
notmuch_message_get_filename (Ptr MessageHandle -> IO (Ptr CChar))
-> (Ptr CChar -> IO String) -> Ptr MessageHandle -> IO String
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr CChar -> IO String
peekCString)

message_get_flag :: Message n a -> MessageFlag -> IO Bool
message_get_flag :: forall (n :: Nat) (a :: DatabaseMode).
Message n a -> MessageFlag -> IO Bool
message_get_flag Message n a
ptr MessageFlag
flag = Message n a -> (Ptr MessageHandle -> IO Bool) -> IO Bool
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Message n a
ptr ((Ptr MessageHandle -> IO Bool) -> IO Bool)
-> (Ptr MessageHandle -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr MessageHandle
ptr' -> do
  (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) (CInt -> Bool) -> IO CInt -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr MessageHandle -> CInt -> IO CInt
notmuch_message_get_flag Ptr MessageHandle
ptr' (MessageFlag -> CInt
forall a. Enum a => a -> CInt
enumToCInt MessageFlag
flag)

-- DB NEEDS TO BE WRITABLE???
message_set_flag :: Message n a -> MessageFlag -> Bool -> IO ()
message_set_flag :: forall (n :: Nat) (a :: DatabaseMode).
Message n a -> MessageFlag -> Bool -> IO ()
message_set_flag Message n a
ptr MessageFlag
flag Bool
v = Message n a -> (Ptr MessageHandle -> IO ()) -> IO ()
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Message n a
ptr ((Ptr MessageHandle -> IO ()) -> IO ())
-> (Ptr MessageHandle -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr MessageHandle
ptr' ->
  Ptr MessageHandle -> CInt -> CInt -> IO ()
notmuch_message_set_flag Ptr MessageHandle
ptr' (MessageFlag -> CInt
forall a. Enum a => a -> CInt
enumToCInt MessageFlag
flag) (Bool -> CInt
forall a. Enum a => a -> CInt
enumToCInt Bool
v)

message_get_date :: Message n a -> IO CLong
message_get_date :: forall (n :: Nat) (a :: DatabaseMode). Message n a -> IO CLong
message_get_date = (Message n a -> (Ptr MessageHandle -> IO CLong) -> IO CLong)
-> (Ptr MessageHandle -> IO CLong) -> Message n a -> IO CLong
forall a b c. (a -> b -> c) -> b -> a -> c
flip Message n a -> (Ptr MessageHandle -> IO CLong) -> IO CLong
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Ptr MessageHandle -> IO CLong
notmuch_message_get_date
{-# LINE 528 "src/Notmuch/Binding.chs" #-}


-- returns EMPTY STRING on missing header,
-- NOTHING on error (I know, confusing)
--
message_get_header :: Message n a -> B.ByteString -> IO (Maybe B.ByteString)
message_get_header :: forall (n :: Nat) (a :: DatabaseMode).
Message n a -> MessageId -> IO (Maybe MessageId)
message_get_header Message n a
ptr MessageId
s =
  MessageId
-> (Ptr CChar -> IO (Maybe MessageId)) -> IO (Maybe MessageId)
forall a. MessageId -> (Ptr CChar -> IO a) -> IO a
B.useAsCString MessageId
s ((Ptr CChar -> IO (Maybe MessageId)) -> IO (Maybe MessageId))
-> (Ptr CChar -> IO (Maybe MessageId)) -> IO (Maybe MessageId)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
s' ->
    Message n a
-> (Ptr MessageHandle -> IO (Maybe MessageId))
-> IO (Maybe MessageId)
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Message n a
ptr ((Ptr MessageHandle -> IO (Maybe MessageId))
 -> IO (Maybe MessageId))
-> (Ptr MessageHandle -> IO (Maybe MessageId))
-> IO (Maybe MessageId)
forall a b. (a -> b) -> a -> b
$ \Ptr MessageHandle
ptr' -> do
      Ptr CChar
r <- Ptr MessageHandle -> Ptr CChar -> IO (Ptr CChar)
notmuch_message_get_header Ptr MessageHandle
ptr' Ptr CChar
s'
      if Ptr CChar
r Ptr CChar -> Ptr CChar -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr CChar
forall a. Ptr a
nullPtr
        then Maybe MessageId -> IO (Maybe MessageId)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe MessageId
forall a. Maybe a
Nothing
        else MessageId -> Maybe MessageId
forall a. a -> Maybe a
Just (MessageId -> Maybe MessageId)
-> IO MessageId -> IO (Maybe MessageId)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CChar -> IO MessageId
B.packCString Ptr CChar
r

-- Tags are always copied from the libnotmuch-managed memory,
-- and all the copying takes place under 'withMessage', so
-- we don't need to detach the pointer or use a ForeignPtr.
message_get_tags :: Message n a -> IO [Tag]
message_get_tags :: forall (n :: Nat) (a :: DatabaseMode). Message n a -> IO [Tag]
message_get_tags Message n a
ptr = Message n a -> (Ptr MessageHandle -> IO [Tag]) -> IO [Tag]
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Message n a
ptr ((Ptr MessageHandle -> IO [Tag]) -> IO [Tag])
-> (Ptr MessageHandle -> IO [Tag]) -> IO [Tag]
forall a b. (a -> b) -> a -> b
$
  Ptr MessageHandle -> IO Tags
notmuch_message_get_tags (Ptr MessageHandle -> IO Tags)
-> (Tags -> IO [Tag]) -> Ptr MessageHandle -> IO [Tag]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Tags -> IO [Tag]
tagsToList

-- According to the header file, possible errors are:
--
-- * NOTMUCH_STATUS_READ_ONLY_DATABASE (excluded by @Message n RW@)
--
-- Therefore assume everything worked!
--
message_remove_all_tags :: Message n RW -> IO ()
message_remove_all_tags :: forall (n :: Nat). Message n 'DatabaseModeReadWrite -> IO ()
message_remove_all_tags Message n 'DatabaseModeReadWrite
msg = IO CInt -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$ Message n 'DatabaseModeReadWrite
-> (Ptr MessageHandle -> IO CInt) -> IO CInt
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Message n 'DatabaseModeReadWrite
msg ((Ptr MessageHandle -> IO CInt) -> IO CInt)
-> (Ptr MessageHandle -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$
  Ptr MessageHandle -> IO CInt
notmuch_message_remove_all_tags
{-# LINE 557 "src/Notmuch/Binding.chs" #-}


-- According to the header file, possible errors are:
--
-- * NOTMUCH_STATUS_NULL_POINTER (excluded by @Tag@ type)
-- * NOTMUCH_STATUS_TAG_TOO_LONG (excluded by @Tag@ type)
-- * NOTMUCH_STATUS_READ_ONLY_DATABASE (excluded by @Message RW@)
--
-- Therefore assume everything worked!
--
message_add_tag :: Message n RW -> Tag -> IO ()
message_add_tag :: forall (n :: Nat). Message n 'DatabaseModeReadWrite -> Tag -> IO ()
message_add_tag Message n 'DatabaseModeReadWrite
msg Tag
tag = IO CInt -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$ Message n 'DatabaseModeReadWrite
-> (Ptr MessageHandle -> IO CInt) -> IO CInt
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Message n 'DatabaseModeReadWrite
msg ((Ptr MessageHandle -> IO CInt) -> IO CInt)
-> (Ptr MessageHandle -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$
  Tag -> (Ptr CChar -> IO CInt) -> IO CInt
forall a. Tag -> (Ptr CChar -> IO a) -> IO a
tagUseAsCString Tag
tag ((Ptr CChar -> IO CInt) -> IO CInt)
-> (Ptr MessageHandle -> Ptr CChar -> IO CInt)
-> Ptr MessageHandle
-> IO CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr MessageHandle -> Ptr CChar -> IO CInt
notmuch_message_add_tag
{-# LINE 569 "src/Notmuch/Binding.chs" #-}


-- According to the header file, possible errors are:
--
-- * NOTMUCH_STATUS_NULL_POINTER (excluded by @Tag@ type)
-- * NOTMUCH_STATUS_TAG_TOO_LONG (excluded by @Tag@ type)
-- * NOTMUCH_STATUS_READ_ONLY_DATABASE (excluded by @Message RW@)
--
-- Therefore assume everything worked!
--
message_remove_tag :: Message n RW -> Tag -> IO ()
message_remove_tag :: forall (n :: Nat). Message n 'DatabaseModeReadWrite -> Tag -> IO ()
message_remove_tag Message n 'DatabaseModeReadWrite
msg Tag
tag = IO CInt -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$ Message n 'DatabaseModeReadWrite
-> (Ptr MessageHandle -> IO CInt) -> IO CInt
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Message n 'DatabaseModeReadWrite
msg ((Ptr MessageHandle -> IO CInt) -> IO CInt)
-> (Ptr MessageHandle -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$
  Tag -> (Ptr CChar -> IO CInt) -> IO CInt
forall a. Tag -> (Ptr CChar -> IO a) -> IO a
tagUseAsCString Tag
tag ((Ptr CChar -> IO CInt) -> IO CInt)
-> (Ptr MessageHandle -> Ptr CChar -> IO CInt)
-> Ptr MessageHandle
-> IO CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr MessageHandle -> Ptr CChar -> IO CInt
notmuch_message_remove_tag
{-# LINE 581 "src/Notmuch/Binding.chs" #-}


-- According to the header file, possible errors are:
--
-- * NOTMUCH_STATUS_READ_ONLY_DATABASE (excluded by @Message n RW@)
--
-- Therefore assume everything worked!
--
message_freeze :: Message n RW -> IO (Message (n + 1) RW)
message_freeze :: forall (n :: Nat).
Message n 'DatabaseModeReadWrite
-> IO (Message (n + 1) 'DatabaseModeReadWrite)
message_freeze Message n 'DatabaseModeReadWrite
msg = Message n 'DatabaseModeReadWrite
-> (Ptr MessageHandle -> IO CInt) -> IO CInt
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Message n 'DatabaseModeReadWrite
msg Ptr MessageHandle -> IO CInt
notmuch_message_freeze IO CInt
-> Message (n + 1) 'DatabaseModeReadWrite
-> IO (Message (n + 1) 'DatabaseModeReadWrite)
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Message n 'DatabaseModeReadWrite
-> Message (n + 1) 'DatabaseModeReadWrite
forall a b. Coercible a b => a -> b
coerce Message n 'DatabaseModeReadWrite
msg

-- According to the header file, possible errors are:
--
-- * NOTMUCH_STATUS_READ_ONLY_DATABASE (excluded by @Message n RW@)
-- * NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW
--     (excluded by @(CmpNat n 0 ~ 'GT) => Message n RW@)
--
-- Therefore assume everything worked!
--
message_thaw :: (1 <= n) => Message n RW -> IO (Message (n - 1) RW)
message_thaw :: forall (n :: Nat).
(1 <= n) =>
Message n 'DatabaseModeReadWrite
-> IO (Message (n - 1) 'DatabaseModeReadWrite)
message_thaw Message n 'DatabaseModeReadWrite
msg = Message n 'DatabaseModeReadWrite
-> (Ptr MessageHandle -> IO CInt) -> IO CInt
forall (n :: Nat) (a :: DatabaseMode) b.
Message n a -> (Ptr MessageHandle -> IO b) -> IO b
withMessage Message n 'DatabaseModeReadWrite
msg Ptr MessageHandle -> IO CInt
notmuch_message_thaw IO CInt
-> Message (n - 1) 'DatabaseModeReadWrite
-> IO (Message (n - 1) 'DatabaseModeReadWrite)
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Message n 'DatabaseModeReadWrite
-> Message (n - 1) 'DatabaseModeReadWrite
forall a b. Coercible a b => a -> b
coerce Message n 'DatabaseModeReadWrite
msg

-- message_maildir_flags_to_tags
-- message_tags_to_maildir_flags

-- directory functions

-- filenames functions


--
-- UTILITY FUNCTIONS
--

enumToCInt :: Enum a => a -> CInt
enumToCInt :: forall a. Enum a => a -> CInt
enumToCInt = Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (a -> Int) -> a -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Int
forall a. Enum a => a -> Int
fromEnum

constructF
  :: (Storable ptr, Traversable t)
  => (ptr -> t ptr)
  -- ^ Inspect received pointer and lift it into a Traversable
  -> (ptr -> IO r)
  -- ^ Wrap pointer, including attaching finalizers
  -> (Ptr ptr -> IO CInt)
  -- ^ C double-pointer-style constructor
  -> IO (Either Status (t r))
constructF :: forall ptr (t :: * -> *) r.
(Storable ptr, Traversable t) =>
(ptr -> t ptr)
-> (ptr -> IO r)
-> (Ptr ptr -> IO CInt)
-> IO (Either Status (t r))
constructF = (Status -> Bool)
-> (ptr -> t ptr)
-> (ptr -> IO r)
-> (Ptr ptr -> IO CInt)
-> IO (Either Status (t r))
forall ptr (t :: * -> *) r.
(Storable ptr, Traversable t) =>
(Status -> Bool)
-> (ptr -> t ptr)
-> (ptr -> IO r)
-> (Ptr ptr -> IO CInt)
-> IO (Either Status (t r))
constructF' (Status -> Status -> Bool
forall a. Eq a => a -> a -> Bool
== Status
StatusSuccess)

constructF'
  :: (Storable ptr, Traversable t)
  => (Status -> Bool)
  -- ^ Which statuses are considered a "success"?
  -> (ptr -> t ptr)
  -- ^ Inspect received pointer and lift it into a Traversable
  -> (ptr -> IO r)
  -- ^ Wrap pointer, including attaching finalizers
  -> (Ptr ptr -> IO CInt)
  -- ^ C double-pointer-style constructor
  -> IO (Either Status (t r))
constructF' :: forall ptr (t :: * -> *) r.
(Storable ptr, Traversable t) =>
(Status -> Bool)
-> (ptr -> t ptr)
-> (ptr -> IO r)
-> (Ptr ptr -> IO CInt)
-> IO (Either Status (t r))
constructF' Status -> Bool
test ptr -> t ptr
mkF ptr -> IO r
dcon Ptr ptr -> IO CInt
constructor =
  (Ptr ptr -> IO (Either Status (t r))) -> IO (Either Status (t r))
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr ptr -> IO (Either Status (t r))) -> IO (Either Status (t r)))
-> (Ptr ptr -> IO (Either Status (t r)))
-> IO (Either Status (t r))
forall a b. (a -> b) -> a -> b
$ \Ptr ptr
ptr ->
    Int -> Status
forall a. Enum a => Int -> a
toEnum (Int -> Status) -> (CInt -> Int) -> CInt -> Status
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Status) -> IO CInt -> IO Status
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr ptr -> IO CInt
constructor Ptr ptr
ptr
    IO Status
-> (Status -> IO (Either Status (t r))) -> IO (Either Status (t r))
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Status -> Bool) -> IO (t r) -> Status -> IO (Either Status (t r))
forall (f :: * -> *) a.
Applicative f =>
(Status -> Bool) -> f a -> Status -> f (Either Status a)
status' Status -> Bool
test ((ptr -> IO r) -> t ptr -> IO (t r)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b)
traverse ptr -> IO r
dcon (t ptr -> IO (t r)) -> (ptr -> t ptr) -> ptr -> IO (t r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ptr -> t ptr
mkF (ptr -> IO (t r)) -> IO ptr -> IO (t r)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr ptr -> IO ptr
forall a. Storable a => Ptr a -> IO a
peek Ptr ptr
ptr)


type PtrToList =
  forall a b ptr.
     (ptr -> IO CInt) -- ^ Iterator predicate function
  -> (ptr -> IO a)    -- ^ Iterator get function
  -> (ptr -> IO ())   -- ^ Iterator next function
  -> (a -> IO b)      -- ^ Item mapper
  -> ptr              -- ^ Iterator
  -> IO [b]

-- | Strictly read a C iterator into a list.
--
ptrToList :: PtrToList
ptrToList :: PtrToList
ptrToList = (forall r. IO r -> IO r) -> PtrToList
ptrToListIO IO r -> IO r
forall a. a -> a
forall r. IO r -> IO r
id

-- | Lazily read a C iterator into a list.
--
lazyPtrToList :: PtrToList
lazyPtrToList :: PtrToList
lazyPtrToList = (forall r. IO r -> IO r) -> PtrToList
ptrToListIO IO r -> IO r
forall r. IO r -> IO r
System.IO.Unsafe.unsafeInterleaveIO

ptrToListIO :: (forall r. IO r -> IO r) -> PtrToList
ptrToListIO :: (forall r. IO r -> IO r) -> PtrToList
ptrToListIO forall r. IO r -> IO r
tweakIO ptr -> IO CInt
test ptr -> IO a
get ptr -> IO ()
next a -> IO b
f ptr
ptr = IO [b]
go
  where
  go :: IO [b]
go = ptr -> IO CInt
test ptr
ptr IO CInt -> (CInt -> IO [b]) -> IO [b]
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \CInt
valid -> case CInt
valid of
    CInt
0 -> [b] -> IO [b]
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
    CInt
_ -> (:)
          (b -> [b] -> [b]) -> IO b -> IO ([b] -> [b])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ptr -> IO a
get ptr
ptr IO a -> (a -> IO b) -> IO b
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> IO b
f IO b -> (b -> IO b) -> IO b
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \b
x -> ptr -> IO ()
next ptr
ptr IO () -> b -> IO b
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> b
x)
          IO ([b] -> [b]) -> IO [b] -> IO [b]
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IO [b] -> IO [b]
forall r. IO r -> IO r
tweakIO IO [b]
go

-- It's assumed that tag lists are short and that it doesn't make
-- sense to read the list lazily.  Tere
tagsToList :: Tags -> IO [Tag]
tagsToList :: Tags -> IO [Tag]
tagsToList = (Tags -> IO CInt)
-> (Tags -> IO (Ptr CChar))
-> (Tags -> IO ())
-> (Ptr CChar -> IO Tag)
-> Tags
-> IO [Tag]
PtrToList
ptrToList
  Tags -> IO CInt
notmuch_tags_valid
{-# LINE 678 "src/Notmuch/Binding.chs" #-}

  notmuch_tags_get
{-# LINE 679 "src/Notmuch/Binding.chs" #-}

  notmuch_tags_move_to_next
{-# LINE 680 "src/Notmuch/Binding.chs" #-}

  tagFromCString

threadsToList
  :: ForeignPtr DatabaseHandle
  -> ForeignPtr QueryHandle
  -> Threads
  -> IO [Thread mode]
threadsToList :: forall (mode :: DatabaseMode).
ForeignPtr DatabaseHandle
-> ForeignPtr QueryHandle -> Threads -> IO [Thread mode]
threadsToList ForeignPtr DatabaseHandle
dfp ForeignPtr QueryHandle
qfp = (Threads -> IO CInt)
-> (Threads -> IO (Ptr ThreadHandle))
-> (Threads -> IO ())
-> (Ptr ThreadHandle -> IO (Thread mode))
-> Threads
-> IO [Thread mode]
PtrToList
lazyPtrToList
  Threads -> IO CInt
notmuch_threads_valid
{-# LINE 689 "src/Notmuch/Binding.chs" #-}

  notmuch_threads_get
{-# LINE 690 "src/Notmuch/Binding.chs" #-}

  notmuch_threads_move_to_next
{-# LINE 691 "src/Notmuch/Binding.chs" #-}

  (fmap (Thread dfp qfp . ThreadHandle) . newForeignPtr notmuch_thread_destroy <=< detachPtr)

messagesToList :: [ForeignPtr ()] -> Messages -> IO [Message 0 mode]
messagesToList :: forall (mode :: DatabaseMode).
[ForeignPtr ()] -> Messages -> IO [Message 0 mode]
messagesToList [ForeignPtr ()]
owners = (Messages -> IO CInt)
-> (Messages -> IO (Ptr MessageHandle))
-> (Messages -> IO ())
-> (Ptr MessageHandle -> IO (Message 0 mode))
-> Messages
-> IO [Message 0 mode]
PtrToList
lazyPtrToList
  Messages -> IO CInt
notmuch_messages_valid
{-# LINE 696 "src/Notmuch/Binding.chs" #-}

  notmuch_messages_get
{-# LINE 697 "src/Notmuch/Binding.chs" #-}

  notmuch_messages_move_to_next
{-# LINE 698 "src/Notmuch/Binding.chs" #-}

  (fmap (Message owners . MessageHandle) . newForeignPtr notmuch_message_destroy <=< detachPtr)

foreign import ccall "Notmuch/Binding.chs.h &notmuch_database_destroy"
  notmuch_database_destroy :: C2HSImp.FinalizerPtr DatabaseHandle

foreign import ccall "Notmuch/Binding.chs.h &notmuch_query_destroy"
  notmuch_query_destroy :: C2HSImp.FinalizerPtr QueryHandle

foreign import ccall "Notmuch/Binding.chs.h &notmuch_thread_destroy"
  notmuch_thread_destroy :: C2HSImp.FinalizerPtr ThreadHandle

foreign import ccall "Notmuch/Binding.chs.h &notmuch_message_destroy"
  notmuch_message_destroy :: C2HSImp.FinalizerPtr MessageHandle

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_status_to_string"
  notmuch_status_to_string :: (C2HSImp.CInt -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_database_upgrade"
  notmuch_database_upgrade :: ((C2HSImp.Ptr (DatabaseHandle)) -> ((C2HSImp.FunPtr ((C2HSImp.Ptr ()) -> (C2HSImp.CDouble -> (IO ())))) -> ((C2HSImp.Ptr ()) -> (IO C2HSImp.CInt))))

foreign import ccall safe "Notmuch/Binding.chs.h notmuch_database_open"
  notmuch_database_open :: ((C2HSImp.Ptr C2HSImp.CChar) -> (C2HSImp.CInt -> ((C2HSImp.Ptr (C2HSImp.Ptr (DatabaseHandle))) -> (IO C2HSImp.CInt))))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_database_get_path"
  notmuch_database_get_path :: ((C2HSImp.Ptr (DatabaseHandle)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_database_get_version"
  notmuch_database_get_version :: ((C2HSImp.Ptr (DatabaseHandle)) -> (IO C2HSImp.CUInt))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_database_index_file"
  notmuch_database_index_file :: ((C2HSImp.Ptr (DatabaseHandle)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr ()) -> ((C2HSImp.Ptr (C2HSImp.Ptr (MessageHandle))) -> (IO C2HSImp.CInt)))))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_database_remove_message"
  notmuch_database_remove_message :: ((C2HSImp.Ptr (DatabaseHandle)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (IO C2HSImp.CInt)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_database_find_message"
  notmuch_database_find_message :: ((C2HSImp.Ptr (DatabaseHandle)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr (C2HSImp.Ptr (MessageHandle))) -> (IO C2HSImp.CInt))))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_database_find_message_by_filename"
  notmuch_database_find_message_by_filename :: ((C2HSImp.Ptr (DatabaseHandle)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr (C2HSImp.Ptr (MessageHandle))) -> (IO C2HSImp.CInt))))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_database_get_all_tags"
  notmuch_database_get_all_tags :: ((C2HSImp.Ptr (DatabaseHandle)) -> (IO (Tags)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_query_create"
  notmuch_query_create :: ((C2HSImp.Ptr (DatabaseHandle)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (IO (C2HSImp.Ptr (QueryHandle)))))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_query_get_query_string"
  notmuch_query_get_query_string :: ((C2HSImp.Ptr (QueryHandle)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_query_set_sort"
  notmuch_query_set_sort :: ((C2HSImp.Ptr (QueryHandle)) -> (C2HSImp.CInt -> (IO ())))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_query_get_sort"
  notmuch_query_get_sort :: ((C2HSImp.Ptr (QueryHandle)) -> (IO C2HSImp.CInt))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_query_add_tag_exclude"
  notmuch_query_add_tag_exclude :: ((C2HSImp.Ptr (QueryHandle)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (IO C2HSImp.CInt)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_query_search_threads"
  notmuch_query_search_threads :: ((C2HSImp.Ptr (QueryHandle)) -> ((C2HSImp.Ptr (Threads)) -> (IO C2HSImp.CInt)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_query_search_messages"
  notmuch_query_search_messages :: ((C2HSImp.Ptr (QueryHandle)) -> ((C2HSImp.Ptr (Messages)) -> (IO C2HSImp.CInt)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_query_count_messages"
  notmuch_query_count_messages :: ((C2HSImp.Ptr (QueryHandle)) -> ((C2HSImp.Ptr C2HSImp.CUInt) -> (IO C2HSImp.CInt)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_query_count_threads"
  notmuch_query_count_threads :: ((C2HSImp.Ptr (QueryHandle)) -> ((C2HSImp.Ptr C2HSImp.CUInt) -> (IO C2HSImp.CInt)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_thread_get_thread_id"
  notmuch_thread_get_thread_id :: ((C2HSImp.Ptr (ThreadHandle)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_thread_get_total_messages"
  notmuch_thread_get_total_messages :: ((C2HSImp.Ptr (ThreadHandle)) -> (IO C2HSImp.CInt))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_thread_get_toplevel_messages"
  notmuch_thread_get_toplevel_messages :: ((C2HSImp.Ptr (ThreadHandle)) -> (IO (Messages)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_thread_get_messages"
  notmuch_thread_get_messages :: ((C2HSImp.Ptr (ThreadHandle)) -> (IO (Messages)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_thread_get_authors"
  notmuch_thread_get_authors :: ((C2HSImp.Ptr (ThreadHandle)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_thread_get_subject"
  notmuch_thread_get_subject :: ((C2HSImp.Ptr (ThreadHandle)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_thread_get_newest_date"
  notmuch_thread_get_newest_date :: ((C2HSImp.Ptr (ThreadHandle)) -> (IO C2HSImp.CLong))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_thread_get_tags"
  notmuch_thread_get_tags :: ((C2HSImp.Ptr (ThreadHandle)) -> (IO (Tags)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_get_message_id"
  notmuch_message_get_message_id :: ((C2HSImp.Ptr (MessageHandle)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_get_thread_id"
  notmuch_message_get_thread_id :: ((C2HSImp.Ptr (MessageHandle)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_get_replies"
  notmuch_message_get_replies :: ((C2HSImp.Ptr (MessageHandle)) -> (IO (Messages)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_get_filename"
  notmuch_message_get_filename :: ((C2HSImp.Ptr (MessageHandle)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_get_flag"
  notmuch_message_get_flag :: ((C2HSImp.Ptr (MessageHandle)) -> (C2HSImp.CInt -> (IO C2HSImp.CInt)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_set_flag"
  notmuch_message_set_flag :: ((C2HSImp.Ptr (MessageHandle)) -> (C2HSImp.CInt -> (C2HSImp.CInt -> (IO ()))))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_get_date"
  notmuch_message_get_date :: ((C2HSImp.Ptr (MessageHandle)) -> (IO C2HSImp.CLong))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_get_header"
  notmuch_message_get_header :: ((C2HSImp.Ptr (MessageHandle)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (IO (C2HSImp.Ptr C2HSImp.CChar))))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_get_tags"
  notmuch_message_get_tags :: ((C2HSImp.Ptr (MessageHandle)) -> (IO (Tags)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_remove_all_tags"
  notmuch_message_remove_all_tags :: ((C2HSImp.Ptr (MessageHandle)) -> (IO C2HSImp.CInt))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_add_tag"
  notmuch_message_add_tag :: ((C2HSImp.Ptr (MessageHandle)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (IO C2HSImp.CInt)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_remove_tag"
  notmuch_message_remove_tag :: ((C2HSImp.Ptr (MessageHandle)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (IO C2HSImp.CInt)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_freeze"
  notmuch_message_freeze :: ((C2HSImp.Ptr (MessageHandle)) -> (IO C2HSImp.CInt))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_message_thaw"
  notmuch_message_thaw :: ((C2HSImp.Ptr (MessageHandle)) -> (IO C2HSImp.CInt))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_tags_valid"
  notmuch_tags_valid :: ((Tags) -> (IO C2HSImp.CInt))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_tags_get"
  notmuch_tags_get :: ((Tags) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_tags_move_to_next"
  notmuch_tags_move_to_next :: ((Tags) -> (IO ()))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_threads_valid"
  notmuch_threads_valid :: ((Threads) -> (IO C2HSImp.CInt))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_threads_get"
  notmuch_threads_get :: ((Threads) -> (IO (C2HSImp.Ptr (ThreadHandle))))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_threads_move_to_next"
  notmuch_threads_move_to_next :: ((Threads) -> (IO ()))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_messages_valid"
  notmuch_messages_valid :: ((Messages) -> (IO C2HSImp.CInt))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_messages_get"
  notmuch_messages_get :: ((Messages) -> (IO (C2HSImp.Ptr (MessageHandle))))

foreign import ccall unsafe "Notmuch/Binding.chs.h notmuch_messages_move_to_next"
  notmuch_messages_move_to_next :: ((Messages) -> (IO ()))