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


{-# LINE 1 "./QuantLib/Commodity.chs" #-}
module QuantLib.Commodity
  (
    -- * Types
    -- ** Commodity types
    CommodityType
    -- ** Units of measure
  , UnitOfMeasure
  , UnitOfMeasureType(..)
    -- ** Payment terms
  , PaymentTerm
  , PaymentTermEventType(..)
    -- ** Quantities and costs
  , Quantity
  , CommodityUnitCost
    -- ** Date intervals and pricing periods
  , DateInterval
  , PricingPeriod
  , PricingPeriods
    -- ** Unit conversions
  , UnitOfMeasureConversion
  , UnitOfMeasureConversionType(..)

    -- * Constructors
    -- ** Commodity metadata
  , commodityType
  , nullCommodityType
  , unitOfMeasure
  , lotUnitOfMeasure
  , barrelUnitOfMeasure
  , mtUnitOfMeasure
  , mbUnitOfMeasure
  , gallonUnitOfMeasure
  , litreUnitOfMeasure
  , kilolitreUnitOfMeasure
  , tokyoKilolitreUnitOfMeasure
  , paymentTerm
  , pricingPeriod
  , unitOfMeasureConversion

    -- * Mutators
    -- ** Conversion repository
  , addUomConversion
  , clearUomConversions
    -- ** Global commodity settings
  , setCommoditySettingsCurrency
  , setCommoditySettingsUnitOfMeasure

    -- * Inspectors
    -- ** Quantity, period and conversion calculations
  , roundedQuantity
  , closeQuantity
  , closeEnoughQuantity
  , isDateBetween
  , intersection
  , convertQuantity
  , chainUnitOfMeasureConversion
    -- ** Commodity metadata
  , commodityTypeCode
  , commodityTypeName
  , commodityTypeEmpty
  , unitOfMeasureName
  , unitOfMeasureCode
  , unitOfMeasureType
  , unitOfMeasureEmpty
  , paymentTermName
  , paymentTermEventType
  , paymentTermOffsetDays
  , paymentTermCalendar
  , paymentTermEmpty
  , paymentTermPaymentDate
    -- ** Pricing periods and conversions
  , pricingPeriodStartDate
  , pricingPeriodEndDate
  , pricingPeriodPaymentDate
  , pricingPeriodQuantity
  , unitOfMeasureConversionSource
  , unitOfMeasureConversionTarget
  , unitOfMeasureConversionCommodityType
  , unitOfMeasureConversionType
  , unitOfMeasureConversionFactor
  , unitOfMeasureConversionCode
  , lookupUomConversion
    -- ** Global commodity settings
  , commoditySettingsCurrency
  , commoditySettingsUnitOfMeasure
  ) where
import qualified Foreign.C.String as C2HSImp
import qualified Foreign.C.Types as C2HSImp
import qualified Foreign.ForeignPtr as C2HSImp
import qualified Foreign.Marshal.Utils as C2HSImp
import qualified Foreign.Ptr as C2HSImp
import qualified System.IO.Unsafe as C2HSImp


import Control.Exception (mask_)
import System.IO.Unsafe (unsafePerformIO)
import QuantLib.Internal
import QuantLib.Internal.Type
import QuantLib.Internal.Common
import Foreign.Marshal.Alloc(alloca)








{-# LINE 100 "./QuantLib/Commodity.chs" #-}


{-# LINE 101 "./QuantLib/Commodity.chs" #-}


{-# LINE 102 "./QuantLib/Commodity.chs" #-}


{-# LINE 103 "./QuantLib/Commodity.chs" #-}


{-# LINE 104 "./QuantLib/Commodity.chs" #-}


{-# LINE 105 "./QuantLib/Commodity.chs" #-}


data UnitOfMeasureConversionType = UomDirect
                                 | UomDerived
  deriving (Enum,Show,Eq,Read)

{-# LINE 107 "./QuantLib/Commodity.chs" #-}


-- |Construct a custom commodity type identified by its code (e.g. \"HO\") and descriptive name
-- (e.g. \"Heating Oil\"). QuantLib has no fixed enum of commodity types -- every instance is
-- user-registered by code, the same way a custom 'QuantLib.Currency.customCurrency' is.
commodityType :: (String) -- ^code
 -> (String) -- ^name
 -> IO ((CommodityType))
commodityType :: String -> String -> IO CommodityType
commodityType String
a1 String
a2 =
  String -> (CString -> IO CommodityType) -> IO CommodityType
forall a. String -> (CString -> IO a) -> IO a
C2HSImp.withCString String
a1 ((CString -> IO CommodityType) -> IO CommodityType)
-> (CString -> IO CommodityType) -> IO CommodityType
forall a b. (a -> b) -> a -> b
$ \CString
a1' -> 
  String -> (CString -> IO CommodityType) -> IO CommodityType
forall a. String -> (CString -> IO a) -> IO a
C2HSImp.withCString String
a2 ((CString -> IO CommodityType) -> IO CommodityType)
-> (CString -> IO CommodityType) -> IO CommodityType
forall a b. (a -> b) -> a -> b
$ \CString
a2' -> 
  (Ptr (Ptr ()) -> IO CommodityType) -> IO CommodityType
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr (Ptr ()) -> IO CommodityType) -> IO CommodityType)
-> (Ptr (Ptr ()) -> IO CommodityType) -> IO CommodityType
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr ())
a3' -> 
  CString -> CString -> Ptr (Ptr ()) -> IO (Ptr CCommodityType)
commodityType'_ CString
a1' CString
a2' Ptr (Ptr ())
a3' IO (Ptr CCommodityType)
-> (Ptr CCommodityType -> IO CommodityType) -> IO CommodityType
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Ptr CCommodityType
res ->
  Ptr CCommodityType -> IO CommodityType
peekCommodityType Ptr CCommodityType
res IO CommodityType
-> (CommodityType -> IO CommodityType) -> IO CommodityType
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \CommodityType
res' ->
  Ptr (Ptr ()) -> IO ()
forall a. Ptr (Ptr a) -> IO ()
errorCheck  Ptr (Ptr ())
a3'IO () -> IO CommodityType -> IO CommodityType
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
  CommodityType -> IO CommodityType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (CommodityType
res')

{-# LINE 114 "./QuantLib/Commodity.chs" #-}


-- |The fixed placeholder commodity type QuantLib itself uses where no real commodity type
-- applies (e.g. in unit-of-measure-only conversions).
nullCommodityType :: IO ((CommodityType))
nullCommodityType =
  preErrorCheck $ \a1' -> 
  nullCommodityType'_ a1' >>= \res ->
  peekCommodityType res >>= \res' ->
  errorCheck  a1'>>
  return (res')

{-# LINE 118 "./QuantLib/Commodity.chs" #-}


-- |The commodity code, e.g. \"HO\".
commodityTypeCode :: CommodityType -> String
commodityTypeCode x = unsafePerformIO $ mask_ (commodityTypeCodeRaw x)
commodityTypeCodeRaw :: (CommodityType) -> IO ((String))
commodityTypeCodeRaw a1 =
  withCommodityType a1 $ \a1' -> 
  commodityTypeCodeRaw'_ a1' >>= \res ->
  peekDynString res >>= \res' ->
  return (res')

{-# LINE 123 "./QuantLib/Commodity.chs" #-}


-- |The descriptive name, e.g. \"Heating Oil\".
commodityTypeName :: CommodityType -> String
commodityTypeName x = unsafePerformIO $ mask_ (commodityTypeNameRaw x)
commodityTypeNameRaw :: (CommodityType) -> IO ((String))
commodityTypeNameRaw a1 =
  withCommodityType a1 $ \a1' -> 
  commodityTypeNameRaw'_ a1' >>= \res ->
  peekDynString res >>= \res' ->
  return (res')

{-# LINE 128 "./QuantLib/Commodity.chs" #-}


-- |Whether this is a usable instance (as opposed to one built via a default constructor).
commodityTypeEmpty :: (CommodityType) -> (Bool)
commodityTypeEmpty a1 =
  C2HSImp.unsafePerformIO $
  withCommodityType a1 $ \a1' -> 
  commodityTypeEmpty'_ a1' >>= \res ->
  let {res' = C2HSImp.toBool res} in
  return (res')

{-# LINE 131 "./QuantLib/Commodity.chs" #-}


-- |Construct a custom unit of measure from its descriptive name (e.g. \"Barrels\"), code (e.g.
-- \"BBL\"), and type (mass/volume/energy/quantity).
unitOfMeasure :: (String) -- ^name
 -> (String) -- ^code
 -> (UnitOfMeasureType) -> IO ((UnitOfMeasure))
unitOfMeasure a1 a2 a3 =
  C2HSImp.withCString a1 $ \a1' -> 
  C2HSImp.withCString a2 $ \a2' -> 
  let {a3' = fromEnumC a3} in 
  preErrorCheck $ \a4' -> 
  unitOfMeasure'_ a1' a2' a3' a4' >>= \res ->
  peekUnitOfMeasure res >>= \res' ->
  errorCheck  a4'>>
  return (res')

{-# LINE 138 "./QuantLib/Commodity.chs" #-}


-- |The descriptive name, e.g. \"Barrels\".
unitOfMeasureName :: UnitOfMeasure -> String
unitOfMeasureName x = unsafePerformIO $ mask_ (unitOfMeasureNameRaw x)
unitOfMeasureNameRaw :: (UnitOfMeasure) -> IO ((String))
unitOfMeasureNameRaw a1 =
  withUnitOfMeasure a1 $ \a1' -> 
  unitOfMeasureNameRaw'_ a1' >>= \res ->
  peekDynString res >>= \res' ->
  return (res')

{-# LINE 143 "./QuantLib/Commodity.chs" #-}


-- |The code, e.g. \"BBL\", \"MT\".
unitOfMeasureCode :: UnitOfMeasure -> String
unitOfMeasureCode x = unsafePerformIO $ mask_ (unitOfMeasureCodeRaw x)
unitOfMeasureCodeRaw :: (UnitOfMeasure) -> IO ((String))
unitOfMeasureCodeRaw a1 =
  withUnitOfMeasure a1 $ \a1' -> 
  unitOfMeasureCodeRaw'_ a1' >>= \res ->
  peekDynString res >>= \res' ->
  return (res')

{-# LINE 148 "./QuantLib/Commodity.chs" #-}


-- |The unit's type (mass/volume/energy/quantity).
unitOfMeasureType :: (UnitOfMeasure) -> (UnitOfMeasureType)
unitOfMeasureType a1 =
  C2HSImp.unsafePerformIO $
  withUnitOfMeasure a1 $ \a1' -> 
  unitOfMeasureType'_ a1' >>= \res ->
  let {res' = toEnumC res} in
  return (res')

{-# LINE 151 "./QuantLib/Commodity.chs" #-}


-- |Whether this is a usable instance (as opposed to one built via a default constructor).
unitOfMeasureEmpty :: (UnitOfMeasure) -> (Bool)
unitOfMeasureEmpty a1 =
  C2HSImp.unsafePerformIO $
  withUnitOfMeasure a1 $ \a1' -> 
  unitOfMeasureEmpty'_ a1' >>= \res ->
  let {res' = C2HSImp.toBool res} in
  return (res')

{-# LINE 154 "./QuantLib/Commodity.chs" #-}


-- |The lot, a dimensionless 'UnitOfMeasure::Quantity' unit.
lotUnitOfMeasure :: IO ((UnitOfMeasure))
lotUnitOfMeasure =
  preErrorCheck $ \a1' -> 
  lotUnitOfMeasure'_ a1' >>= \res ->
  peekUnitOfMeasure res >>= \res' ->
  errorCheck  a1'>>
  return (res')

{-# LINE 157 "./QuantLib/Commodity.chs" #-}


-- |Barrels (BBL), the base petroleum volume unit.
barrelUnitOfMeasure :: IO ((UnitOfMeasure))
barrelUnitOfMeasure =
  preErrorCheck $ \a1' -> 
  barrelUnitOfMeasure'_ a1' >>= \res ->
  peekUnitOfMeasure res >>= \res' ->
  errorCheck  a1'>>
  return (res')

{-# LINE 160 "./QuantLib/Commodity.chs" #-}


-- |Metric tonnes (MT).
mtUnitOfMeasure :: IO ((UnitOfMeasure))
mtUnitOfMeasure =
  preErrorCheck $ \a1' -> 
  mtUnitOfMeasure'_ a1' >>= \res ->
  peekUnitOfMeasure res >>= \res' ->
  errorCheck  a1'>>
  return (res')

{-# LINE 163 "./QuantLib/Commodity.chs" #-}


-- |Thousand barrels (MB).
mbUnitOfMeasure :: IO ((UnitOfMeasure))
mbUnitOfMeasure =
  preErrorCheck $ \a1' -> 
  mbUnitOfMeasure'_ a1' >>= \res ->
  peekUnitOfMeasure res >>= \res' ->
  errorCheck  a1'>>
  return (res')

{-# LINE 166 "./QuantLib/Commodity.chs" #-}


-- |US gallons.
gallonUnitOfMeasure :: IO ((UnitOfMeasure))
gallonUnitOfMeasure =
  preErrorCheck $ \a1' -> 
  gallonUnitOfMeasure'_ a1' >>= \res ->
  peekUnitOfMeasure res >>= \res' ->
  errorCheck  a1'>>
  return (res')

{-# LINE 169 "./QuantLib/Commodity.chs" #-}


-- |Litres.
litreUnitOfMeasure :: IO ((UnitOfMeasure))
litreUnitOfMeasure =
  preErrorCheck $ \a1' -> 
  litreUnitOfMeasure'_ a1' >>= \res ->
  peekUnitOfMeasure res >>= \res' ->
  errorCheck  a1'>>
  return (res')

{-# LINE 172 "./QuantLib/Commodity.chs" #-}


-- |Kilolitres.
kilolitreUnitOfMeasure :: IO ((UnitOfMeasure))
kilolitreUnitOfMeasure =
  preErrorCheck $ \a1' -> 
  kilolitreUnitOfMeasure'_ a1' >>= \res ->
  peekUnitOfMeasure res >>= \res' ->
  errorCheck  a1'>>
  return (res')

{-# LINE 175 "./QuantLib/Commodity.chs" #-}


-- |Tokyo kilolitres.
tokyoKilolitreUnitOfMeasure :: IO ((UnitOfMeasure))
tokyoKilolitreUnitOfMeasure =
  preErrorCheck $ \a1' -> 
  tokyoKilolitreUnitOfMeasure'_ a1' >>= \res ->
  peekUnitOfMeasure res >>= \res' ->
  errorCheck  a1'>>
  return (res')

{-# LINE 178 "./QuantLib/Commodity.chs" #-}


-- |Construct a payment term: a named offset (in calendar-adjusted days) from either the trade
-- date or the pricing-period end date.
paymentTerm :: (String) -- ^name
 -> (PaymentTermEventType) -> (Int) -- ^offsetDays
 -> (Calendar) -> IO ((PaymentTerm))
paymentTerm a1 a2 a3 a4 =
  C2HSImp.withCString a1 $ \a1' -> 
  let {a2' = fromEnumC a2} in 
  let {a3' = fromIntegral a3} in 
  withCalendar a4 $ \a4' -> 
  preErrorCheck $ \a5' -> 
  paymentTerm'_ a1' a2' a3' a4' a5' >>= \res ->
  peekPaymentTerm res >>= \res' ->
  errorCheck  a5'>>
  return (res')

{-# LINE 186 "./QuantLib/Commodity.chs" #-}


-- |The payment term's name, e.g. \"Pricing end + 5 days\".
paymentTermName :: PaymentTerm -> String
paymentTermName x = unsafePerformIO $ mask_ (paymentTermNameRaw x)
paymentTermNameRaw :: (PaymentTerm) -> IO ((String))
paymentTermNameRaw a1 =
  withPaymentTerm a1 $ \a1' -> 
  paymentTermNameRaw'_ a1' >>= \res ->
  peekDynString res >>= \res' ->
  return (res')

{-# LINE 191 "./QuantLib/Commodity.chs" #-}


-- |Whether the offset is measured from the trade date or the pricing date.
paymentTermEventType :: (PaymentTerm) -> (PaymentTermEventType)
paymentTermEventType a1 =
  C2HSImp.unsafePerformIO $
  withPaymentTerm a1 $ \a1' -> 
  paymentTermEventType'_ a1' >>= \res ->
  let {res' = toEnumC res} in
  return (res')

{-# LINE 194 "./QuantLib/Commodity.chs" #-}


-- |The number of (calendar-adjusted) offset days.
paymentTermOffsetDays :: (PaymentTerm) -> (Int)
paymentTermOffsetDays a1 =
  C2HSImp.unsafePerformIO $
  withPaymentTerm a1 $ \a1' -> 
  paymentTermOffsetDays'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 197 "./QuantLib/Commodity.chs" #-}


-- |The calendar used to adjust the payment date.
paymentTermCalendar :: (PaymentTerm) -> IO ((Calendar))
paymentTermCalendar a1 =
  withPaymentTerm a1 $ \a1' -> 
  preErrorCheck $ \a2' -> 
  paymentTermCalendar'_ a1' a2' >>= \res ->
  peekCalendar res >>= \res' ->
  errorCheck  a2'>>
  return (res')

{-# LINE 200 "./QuantLib/Commodity.chs" #-}


-- |Whether this is a usable instance (as opposed to one built via a default constructor).
paymentTermEmpty :: (PaymentTerm) -> (Bool)
paymentTermEmpty a1 =
  C2HSImp.unsafePerformIO $
  withPaymentTerm a1 $ \a1' -> 
  paymentTermEmpty'_ a1' >>= \res ->
  let {res' = C2HSImp.toBool res} in
  return (res')

{-# LINE 203 "./QuantLib/Commodity.chs" #-}


-- |Applies the term's offset (and calendar adjustment) to a trade or pricing-period-end date to
-- get the actual payment date.
paymentTermPaymentDate :: (PaymentTerm) -> (Day) -> IO ((Day))
paymentTermPaymentDate a1 a2 =
  withPaymentTerm a1 $ \a1' -> 
  withDay a2 $ \a2' -> 
  preErrorCheck $ \a3' -> 
  paymentTermPaymentDate'_ a1' a2' a3' >>= \res ->
  let {res' = toDay res} in
  errorCheck  a3'>>
  return (res')

{-# LINE 208 "./QuantLib/Commodity.chs" #-}


-- |A commodity type, unit of measure, and amount. Its FFI arguments are flat because c2hs's
-- @&@ tuple-splitter supports only pairs.
type Quantity = (CommodityType, UnitOfMeasure, Double)

quantityRoundedAmount :: (UnitOfMeasure) -> (Double) -> (Double)
quantityRoundedAmount a1 a2 =
  C2HSImp.unsafePerformIO $
  withUnitOfMeasure a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  quantityRoundedAmount'_ a1' a2' >>= \res ->
  let {res' = realToFrac res} in
  return (res')

{-# LINE 214 "./QuantLib/Commodity.chs" #-}


-- |Round a quantity's amount per its unit of measure's rounding convention. The commodity type and
-- unit of measure are unaffected by rounding, so they're carried straight through in Haskell
-- rather than round-tripped through the C++ call.
roundedQuantity :: Quantity -> Quantity
roundedQuantity (ct, uom, amount) = (ct, uom, quantityRoundedAmount uom amount)

qlQuantityClose_ :: (CommodityType) -> (UnitOfMeasure) -> (Double) -> (CommodityType) -> (UnitOfMeasure) -> (Double) -> (Int) -> IO ((Bool))
qlQuantityClose_ :: CommodityType
-> UnitOfMeasure
-> Double
-> CommodityType
-> UnitOfMeasure
-> Double
-> Int
-> IO Bool
qlQuantityClose_ CommodityType
a1 UnitOfMeasure
a2 Double
a3 CommodityType
a4 UnitOfMeasure
a5 Double
a6 Int
a7 =
  CommodityType -> (Ptr CCommodityType -> IO Bool) -> IO Bool
forall b. CommodityType -> (Ptr CCommodityType -> IO b) -> IO b
withCommodityType CommodityType
a1 ((Ptr CCommodityType -> IO Bool) -> IO Bool)
-> (Ptr CCommodityType -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr CCommodityType
a1' -> 
  UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO Bool) -> IO Bool
forall b. UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b
withUnitOfMeasure UnitOfMeasure
a2 ((Ptr CUnitOfMeasure -> IO Bool) -> IO Bool)
-> (Ptr CUnitOfMeasure -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasure
a2' -> 
  let {a3' :: CDouble
a3' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
a3} in 
  CommodityType -> (Ptr CCommodityType -> IO Bool) -> IO Bool
forall b. CommodityType -> (Ptr CCommodityType -> IO b) -> IO b
withCommodityType CommodityType
a4 ((Ptr CCommodityType -> IO Bool) -> IO Bool)
-> (Ptr CCommodityType -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr CCommodityType
a4' -> 
  UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO Bool) -> IO Bool
forall b. UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b
withUnitOfMeasure UnitOfMeasure
a5 ((Ptr CUnitOfMeasure -> IO Bool) -> IO Bool)
-> (Ptr CUnitOfMeasure -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasure
a5' -> 
  let {a6' :: CDouble
a6' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
a6} in 
  let {a7' :: CInt
a7' = Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a7} in 
  (Ptr (Ptr ()) -> IO Bool) -> IO Bool
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr (Ptr ()) -> IO Bool) -> IO Bool)
-> (Ptr (Ptr ()) -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr ())
a8' -> 
  Ptr CCommodityType
-> Ptr CUnitOfMeasure
-> CDouble
-> Ptr CCommodityType
-> Ptr CUnitOfMeasure
-> CDouble
-> CInt
-> Ptr (Ptr ())
-> IO CInt
qlQuantityClose_'_ Ptr CCommodityType
a1' Ptr CUnitOfMeasure
a2' CDouble
a3' Ptr CCommodityType
a4' Ptr CUnitOfMeasure
a5' CDouble
a6' CInt
a7' Ptr (Ptr ())
a8' IO CInt -> (CInt -> IO Bool) -> IO Bool
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \CInt
res ->
  let {res' :: Bool
res' = CInt -> Bool
forall a. (Eq a, Num a) => a -> Bool
C2HSImp.toBool CInt
res} in
  Ptr (Ptr ()) -> IO ()
forall a. Ptr (Ptr a) -> IO ()
errorCheck  Ptr (Ptr ())
a8'IO () -> IO Bool -> IO Bool
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
  Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
res')

{-# LINE 225 "./QuantLib/Commodity.chs" #-}


-- |Whether two quantities are close to within @n@ ULPs (default 42 upstream), after converting
-- the second to the first's unit of measure if their units differ (which throws unless a
-- conversion is reachable -- see 'lookupUomConversion').
closeQuantity :: Quantity -> Quantity -> Int -> IO Bool
closeQuantity (ct1, uom1, amt1) (ct2, uom2, amt2) n = qlQuantityClose_ ct1 uom1 amt1 ct2 uom2 amt2 n

qlQuantityCloseEnough_ :: (CommodityType) -> (UnitOfMeasure) -> (Double) -> (CommodityType) -> (UnitOfMeasure) -> (Double) -> (Int) -> IO ((Bool))
qlQuantityCloseEnough_ a1 a2 a3 a4 a5 a6 a7 =
  withCommodityType a1 $ \a1' -> 
  withUnitOfMeasure a2 $ \a2' -> 
  let {a3' = realToFrac a3} in 
  withCommodityType a4 $ \a4' -> 
  withUnitOfMeasure a5 $ \a5' -> 
  let {a6' = realToFrac a6} in 
  let {a7' = fromIntegral a7} in 
  preErrorCheck $ \a8' -> 
  qlQuantityCloseEnough_'_ a1' a2' a3' a4' a5' a6' a7' a8' >>= \res ->
  let {res' = C2HSImp.toBool res} in
  errorCheck  a8'>>
  return (res')

{-# LINE 236 "./QuantLib/Commodity.chs" #-}


-- |As 'closeQuantity', but using QuantLib's relative (rather than absolute) closeness test.
closeEnoughQuantity :: Quantity -> Quantity -> Int -> IO Bool
closeEnoughQuantity (ct1, uom1, amt1) (ct2, uom2, amt2) n = qlQuantityCloseEnough_ ct1 uom1 amt1 ct2 uom2 amt2 n

-- |A commodity's unit cost: a cash amount (a @(Double, Currency)@ pair, standing in for
-- QuantLib's @Money@) per 'UnitOfMeasure'. A plain tuple, like 'Quantity' -- it carries no
-- calculation of its own upstream.
type CommodityUnitCost = (Double, Currency, UnitOfMeasure)

-- |A date range, inclusive of both ends. No C++ call is needed for either operation below --
-- 'Day' (from @Data.Time.Calendar@) already has the 'Ord' instance QuantLib's own comparisons rely
-- on, so both are plain Haskell functions rather than shim calls.
type DateInterval = (Day, Day)

-- |Whether a date falls within the interval, optionally excluding either end.
isDateBetween :: DateInterval
              -> Day -- ^date
              -> Bool -- ^includeFirst
              -> Bool -- ^includeLast
              -> Bool
isDateBetween :: DateInterval -> Day -> Bool -> Bool -> Bool
isDateBetween (Day
startDate, Day
endDate) Day
date Bool
includeFirst Bool
includeLast =
  (if Bool
includeFirst then Day
date Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
>= Day
startDate else Day
date Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
> Day
startDate) Bool -> Bool -> Bool
&&
  (if Bool
includeLast then Day
date Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
<= Day
endDate else Day
date Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
< Day
endDate)

-- |The overlap of two date intervals, or 'Nothing' if they don't overlap at all (upstream returns
-- a default-constructed, both-dates-null 'DateInterval' in this case; a 'Maybe' is the natural
-- Haskell equivalent).
intersection :: DateInterval -> DateInterval -> Maybe DateInterval
intersection :: DateInterval -> DateInterval -> Maybe DateInterval
intersection (Day
s1, Day
e1) (Day
s2, Day
e2)
  | (Day
s1 Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
< Day
s2 Bool -> Bool -> Bool
&& Day
e1 Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
< Day
s2) Bool -> Bool -> Bool
|| (Day
s1 Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
> Day
e2 Bool -> Bool -> Bool
&& Day
e1 Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
> Day
e2) = Maybe DateInterval
forall a. Maybe a
Nothing
  | Bool
otherwise = DateInterval -> Maybe DateInterval
forall a. a -> Maybe a
Just (Day -> Day -> Day
forall a. Ord a => a -> a -> a
max Day
s1 Day
s2, Day -> Day -> Day
forall a. Ord a => a -> a -> a
min Day
e1 Day
e2)

-- |A 'DateInterval' over which a fixed 'Quantity' is priced, paid on
-- 'pricingPeriodPaymentDate'. Named fields keep the value readable across energy-swap APIs.
data PricingPeriod = PricingPeriod
  { PricingPeriod -> Day
pricingPeriodStartDate :: Day
  , PricingPeriod -> Day
pricingPeriodEndDate :: Day
  , PricingPeriod -> Day
pricingPeriodPaymentDate :: Day
  , PricingPeriod -> Quantity
pricingPeriodQuantity :: Quantity
  } deriving (Int -> PricingPeriod -> ShowS
[PricingPeriod] -> ShowS
PricingPeriod -> String
(Int -> PricingPeriod -> ShowS)
-> (PricingPeriod -> String)
-> ([PricingPeriod] -> ShowS)
-> Show PricingPeriod
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PricingPeriod -> ShowS
showsPrec :: Int -> PricingPeriod -> ShowS
$cshow :: PricingPeriod -> String
show :: PricingPeriod -> String
$cshowList :: [PricingPeriod] -> ShowS
showList :: [PricingPeriod] -> ShowS
Show, PricingPeriod -> PricingPeriod -> Bool
(PricingPeriod -> PricingPeriod -> Bool)
-> (PricingPeriod -> PricingPeriod -> Bool) -> Eq PricingPeriod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PricingPeriod -> PricingPeriod -> Bool
== :: PricingPeriod -> PricingPeriod -> Bool
$c/= :: PricingPeriod -> PricingPeriod -> Bool
/= :: PricingPeriod -> PricingPeriod -> Bool
Eq)

type PricingPeriods = [PricingPeriod]

-- |Construct a 'PricingPeriod', enforcing upstream's @DateInterval@ invariant that the end date
-- is not before the start date.
pricingPeriod :: Day -> Day -> Day -> Quantity -> PricingPeriod
pricingPeriod :: Day -> Day -> Day -> Quantity -> PricingPeriod
pricingPeriod Day
startDate Day
endDate
  | Day
endDate Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
< Day
startDate = String -> Day -> Quantity -> PricingPeriod
forall a. HasCallStack => String -> a
error String
"pricingPeriod: end date must be >= start date"
  | Bool
otherwise = Day -> Day -> Day -> Quantity -> PricingPeriod
PricingPeriod Day
startDate Day
endDate

-- |Construct a conversion factor between two units of measure for a given commodity type: a unit
-- of @source@ is worth @conversionFactor@ units of @target@.
unitOfMeasureConversion :: (CommodityType) -> (UnitOfMeasure) -- ^source
 -> (UnitOfMeasure) -- ^target
 -> (Double) -- ^conversionFactor
 -> IO ((UnitOfMeasureConversion))
unitOfMeasureConversion :: CommodityType
-> UnitOfMeasure
-> UnitOfMeasure
-> Double
-> IO UnitOfMeasureConversion
unitOfMeasureConversion CommodityType
a1 UnitOfMeasure
a2 UnitOfMeasure
a3 Double
a4 =
  CommodityType
-> (Ptr CCommodityType -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b. CommodityType -> (Ptr CCommodityType -> IO b) -> IO b
withCommodityType CommodityType
a1 ((Ptr CCommodityType -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr CCommodityType -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CCommodityType
a1' -> 
  UnitOfMeasure
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b. UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b
withUnitOfMeasure UnitOfMeasure
a2 ((Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasure
a2' -> 
  UnitOfMeasure
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b. UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b
withUnitOfMeasure UnitOfMeasure
a3 ((Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasure
a3' -> 
  let {a4' :: CDouble
a4' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
a4} in 
  (Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr ())
a5' -> 
  Ptr CCommodityType
-> Ptr CUnitOfMeasure
-> Ptr CUnitOfMeasure
-> CDouble
-> Ptr (Ptr ())
-> IO (Ptr CUnitOfMeasureConversion)
unitOfMeasureConversion'_ Ptr CCommodityType
a1' Ptr CUnitOfMeasure
a2' Ptr CUnitOfMeasure
a3' CDouble
a4' Ptr (Ptr ())
a5' IO (Ptr CUnitOfMeasureConversion)
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Ptr CUnitOfMeasureConversion
res ->
  Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion
peekUnitOfMeasureConversion Ptr CUnitOfMeasureConversion
res IO UnitOfMeasureConversion
-> (UnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \UnitOfMeasureConversion
res' ->
  Ptr (Ptr ()) -> IO ()
forall a. Ptr (Ptr a) -> IO ()
errorCheck  Ptr (Ptr ())
a5'IO () -> IO UnitOfMeasureConversion -> IO UnitOfMeasureConversion
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
  UnitOfMeasureConversion -> IO UnitOfMeasureConversion
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (UnitOfMeasureConversion
res')

{-# LINE 295 "./QuantLib/Commodity.chs" #-}


-- |The source unit of measure.
unitOfMeasureConversionSource :: (UnitOfMeasureConversion) -> IO ((UnitOfMeasure))
unitOfMeasureConversionSource a1 =
  withUnitOfMeasureConversion a1 $ \a1' -> 
  preErrorCheck $ \a2' -> 
  unitOfMeasureConversionSource'_ a1' a2' >>= \res ->
  peekUnitOfMeasure res >>= \res' ->
  errorCheck  a2'>>
  return (res')

{-# LINE 298 "./QuantLib/Commodity.chs" #-}


-- |The target unit of measure.
unitOfMeasureConversionTarget :: (UnitOfMeasureConversion) -> IO ((UnitOfMeasure))
unitOfMeasureConversionTarget a1 =
  withUnitOfMeasureConversion a1 $ \a1' -> 
  preErrorCheck $ \a2' -> 
  unitOfMeasureConversionTarget'_ a1' a2' >>= \res ->
  peekUnitOfMeasure res >>= \res' ->
  errorCheck  a2'>>
  return (res')

{-# LINE 301 "./QuantLib/Commodity.chs" #-}


-- |The commodity type this conversion applies to.
unitOfMeasureConversionCommodityType :: (UnitOfMeasureConversion) -> IO ((CommodityType))
unitOfMeasureConversionCommodityType a1 =
  withUnitOfMeasureConversion a1 $ \a1' -> 
  preErrorCheck $ \a2' -> 
  unitOfMeasureConversionCommodityType'_ a1' a2' >>= \res ->
  peekCommodityType res >>= \res' ->
  errorCheck  a2'>>
  return (res')

{-# LINE 304 "./QuantLib/Commodity.chs" #-}


-- |Whether the conversion was given directly, or derived by chaining two other conversions.
unitOfMeasureConversionType :: (UnitOfMeasureConversion) -> (UnitOfMeasureConversionType)
unitOfMeasureConversionType a1 =
  C2HSImp.unsafePerformIO $
  withUnitOfMeasureConversion a1 $ \a1' -> 
  unitOfMeasureConversionType'_ a1' >>= \res ->
  let {res' = (toEnum . fromIntegral) res} in
  return (res')

{-# LINE 307 "./QuantLib/Commodity.chs" #-}


-- |The conversion factor: a unit of the source is worth this many units of the target.
unitOfMeasureConversionFactor :: (UnitOfMeasureConversion) -> (Double)
unitOfMeasureConversionFactor a1 =
  C2HSImp.unsafePerformIO $
  withUnitOfMeasureConversion a1 $ \a1' -> 
  unitOfMeasureConversionFactor'_ a1' >>= \res ->
  let {res' = realToFrac res} in
  return (res')

{-# LINE 310 "./QuantLib/Commodity.chs" #-}


-- |A code identifying the conversion, e.g. \"Heating OilMTBBL\".
unitOfMeasureConversionCode :: UnitOfMeasureConversion -> String
unitOfMeasureConversionCode x = unsafePerformIO $ mask_ (unitOfMeasureConversionCodeRaw x)
unitOfMeasureConversionCodeRaw :: (UnitOfMeasureConversion) -> IO ((String))
unitOfMeasureConversionCodeRaw a1 =
  withUnitOfMeasureConversion a1 $ \a1' -> 
  unitOfMeasureConversionCodeRaw'_ a1' >>= \res ->
  peekDynString res >>= \res' ->
  return (res')

{-# LINE 315 "./QuantLib/Commodity.chs" #-}


qlUnitOfMeasureConversionConvert_ :: (UnitOfMeasureConversion) -> (CommodityType) -> (UnitOfMeasure) -> (Double) -> IO ((Double), (CommodityType), (UnitOfMeasure))
qlUnitOfMeasureConversionConvert_ a1 a2 a3 a4 =
  withUnitOfMeasureConversion a1 $ \a1' -> 
  withCommodityType a2 $ \a2' -> 
  withUnitOfMeasure a3 $ \a3' -> 
  let {a4' = realToFrac a4} in 
  alloca $ \a5' -> 
  alloca $ \a6' -> 
  preErrorCheck $ \a7' -> 
  qlUnitOfMeasureConversionConvert_'_ a1' a2' a3' a4' a5' a6' a7' >>= \res ->
  let {res' = realToFrac res} in
  peekCommodityTypePtr  a5'>>= \a5'' -> 
  peekUnitOfMeasurePtr  a6'>>= \a6'' -> 
  errorCheck  a7'>>
  return (res', a5'', a6'')

{-# LINE 322 "./QuantLib/Commodity.chs" #-}


-- |Apply the conversion factor to a quantity, converting it from the conversion's source to its
-- target unit of measure (or vice versa). Throws if the quantity's unit of measure is on neither
-- side of the conversion.
convertQuantity :: UnitOfMeasureConversion -> Quantity -> IO Quantity
convertQuantity conv (ct, uom, amount) = do
  (amount', ct', uom') <- qlUnitOfMeasureConversionConvert_ conv ct uom amount
  pure (ct', uom', amount')

-- |Combine two conversions sharing a common unit of measure into a derived conversion between
-- their other two units. Throws if the conversions don't share a common unit.
chainUnitOfMeasureConversion :: (UnitOfMeasureConversion) -> (UnitOfMeasureConversion) -> IO ((UnitOfMeasureConversion))
chainUnitOfMeasureConversion :: UnitOfMeasureConversion
-> UnitOfMeasureConversion -> IO UnitOfMeasureConversion
chainUnitOfMeasureConversion UnitOfMeasureConversion
a1 UnitOfMeasureConversion
a2 =
  UnitOfMeasureConversion
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b.
UnitOfMeasureConversion
-> (Ptr CUnitOfMeasureConversion -> IO b) -> IO b
withUnitOfMeasureConversion UnitOfMeasureConversion
a1 ((Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasureConversion
a1' -> 
  UnitOfMeasureConversion
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b.
UnitOfMeasureConversion
-> (Ptr CUnitOfMeasureConversion -> IO b) -> IO b
withUnitOfMeasureConversion UnitOfMeasureConversion
a2 ((Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasureConversion
a2' -> 
  (Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr ())
a3' -> 
  Ptr CUnitOfMeasureConversion
-> Ptr CUnitOfMeasureConversion
-> Ptr (Ptr ())
-> IO (Ptr CUnitOfMeasureConversion)
chainUnitOfMeasureConversion'_ Ptr CUnitOfMeasureConversion
a1' Ptr CUnitOfMeasureConversion
a2' Ptr (Ptr ())
a3' IO (Ptr CUnitOfMeasureConversion)
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Ptr CUnitOfMeasureConversion
res ->
  Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion
peekUnitOfMeasureConversion Ptr CUnitOfMeasureConversion
res IO UnitOfMeasureConversion
-> (UnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \UnitOfMeasureConversion
res' ->
  Ptr (Ptr ()) -> IO ()
forall a. Ptr (Ptr a) -> IO ()
errorCheck  Ptr (Ptr ())
a3'IO () -> IO UnitOfMeasureConversion -> IO UnitOfMeasureConversion
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
  UnitOfMeasureConversion -> IO UnitOfMeasureConversion
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (UnitOfMeasureConversion
res')

{-# LINE 337 "./QuantLib/Commodity.chs" #-}


-- |Look up a (possibly derived, via triangulation) conversion between two units of measure for a
-- given commodity type. Throws if none can be found. Pre-populated with a set of known petroleum
-- conversion factors even before any 'addUomConversion' call.
lookupUomConversion :: (CommodityType) -> (UnitOfMeasure) -- ^source
 -> (UnitOfMeasure) -- ^target
 -> (UnitOfMeasureConversionType) -> IO ((UnitOfMeasureConversion))
lookupUomConversion :: CommodityType
-> UnitOfMeasure
-> UnitOfMeasure
-> UnitOfMeasureConversionType
-> IO UnitOfMeasureConversion
lookupUomConversion CommodityType
a1 UnitOfMeasure
a2 UnitOfMeasure
a3 UnitOfMeasureConversionType
a4 =
  CommodityType
-> (Ptr CCommodityType -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b. CommodityType -> (Ptr CCommodityType -> IO b) -> IO b
withCommodityType CommodityType
a1 ((Ptr CCommodityType -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr CCommodityType -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CCommodityType
a1' -> 
  UnitOfMeasure
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b. UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b
withUnitOfMeasure UnitOfMeasure
a2 ((Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasure
a2' -> 
  UnitOfMeasure
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b. UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b
withUnitOfMeasure UnitOfMeasure
a3 ((Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasure
a3' -> 
  let {a4' :: CInt
a4' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt)
-> (UnitOfMeasureConversionType -> Int)
-> UnitOfMeasureConversionType
-> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnitOfMeasureConversionType -> Int
forall a. Enum a => a -> Int
fromEnum) UnitOfMeasureConversionType
a4} in 
  (Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr ())
a5' -> 
  Ptr CCommodityType
-> Ptr CUnitOfMeasure
-> Ptr CUnitOfMeasure
-> CInt
-> Ptr (Ptr ())
-> IO (Ptr CUnitOfMeasureConversion)
lookupUomConversion'_ Ptr CCommodityType
a1' Ptr CUnitOfMeasure
a2' Ptr CUnitOfMeasure
a3' CInt
a4' Ptr (Ptr ())
a5' IO (Ptr CUnitOfMeasureConversion)
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Ptr CUnitOfMeasureConversion
res ->
  Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion
peekUnitOfMeasureConversion Ptr CUnitOfMeasureConversion
res IO UnitOfMeasureConversion
-> (UnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \UnitOfMeasureConversion
res' ->
  Ptr (Ptr ()) -> IO ()
forall a. Ptr (Ptr a) -> IO ()
errorCheck  Ptr (Ptr ())
a5'IO () -> IO UnitOfMeasureConversion -> IO UnitOfMeasureConversion
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
  UnitOfMeasureConversion -> IO UnitOfMeasureConversion
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (UnitOfMeasureConversion
res')

{-# LINE 347 "./QuantLib/Commodity.chs" #-}


-- |Register a conversion with the global unit-of-measure conversion repository, replacing any
-- existing conversion between the same commodity type and pair of units.
addUomConversion :: (UnitOfMeasureConversion) -> IO ()
addUomConversion a1 =
  withUnitOfMeasureConversion a1 $ \a1' -> 
  addUomConversion'_ a1' >>
  return ()

{-# LINE 351 "./QuantLib/Commodity.chs" #-}


-- |Reset the unit-of-measure conversion repository back to its built-in set of known petroleum
-- conversion factors, discarding anything added via 'addUomConversion'.
clearUomConversions :: IO ()
clearUomConversions =
  clearUomConversions'_ >>
  return ()

{-# LINE 355 "./QuantLib/Commodity.chs" #-}


-- |The global commodity currency setting (defaults to USD).
commoditySettingsCurrency :: IO ((Currency))
commoditySettingsCurrency =
  preErrorCheck $ \a1' -> 
  commoditySettingsCurrency'_ a1' >>= \res ->
  peekCurrency res >>= \res' ->
  errorCheck  a1'>>
  return (res')

{-# LINE 358 "./QuantLib/Commodity.chs" #-}


-- |Set the global commodity currency setting.
setCommoditySettingsCurrency :: (Currency) -> IO ()
setCommoditySettingsCurrency a1 =
  withCurrency a1 $ \a1' -> 
  setCommoditySettingsCurrency'_ a1' >>
  return ()

{-# LINE 361 "./QuantLib/Commodity.chs" #-}


-- |The global commodity unit-of-measure setting (defaults to barrels).
commoditySettingsUnitOfMeasure :: IO ((UnitOfMeasure))
commoditySettingsUnitOfMeasure =
  preErrorCheck $ \a1' -> 
  commoditySettingsUnitOfMeasure'_ a1' >>= \res ->
  peekUnitOfMeasure res >>= \res' ->
  errorCheck  a1'>>
  return (res')

{-# LINE 364 "./QuantLib/Commodity.chs" #-}


-- |Set the global commodity unit-of-measure setting.
setCommoditySettingsUnitOfMeasure :: (UnitOfMeasure) -> IO ()
setCommoditySettingsUnitOfMeasure a1 =
  withUnitOfMeasure a1 $ \a1' -> 
  setCommoditySettingsUnitOfMeasure'_ a1' >>
  return ()

{-# LINE 367 "./QuantLib/Commodity.chs" #-}


-- vim: set ff=unix ts=8 sts=2 sw=2 et:

foreign import ccall safe "QuantLib/Commodity.chs.h qlCommodityType"
  commodityType'_ :: ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CCommodityType))))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlNullCommodityType"
  nullCommodityType'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CCommodityType))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlCommodityTypeCode"
  commodityTypeCodeRaw'_ :: ((C2HSImp.Ptr (CCommodityType)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall safe "QuantLib/Commodity.chs.h qlCommodityTypeName"
  commodityTypeNameRaw'_ :: ((C2HSImp.Ptr (CCommodityType)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall safe "QuantLib/Commodity.chs.h qlCommodityTypeEmpty"
  commodityTypeEmpty'_ :: ((C2HSImp.Ptr (CCommodityType)) -> (IO C2HSImp.CInt))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasure"
  unitOfMeasure'_ :: ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (C2HSImp.CInt -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure)))))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureName"
  unitOfMeasureNameRaw'_ :: ((C2HSImp.Ptr (CUnitOfMeasure)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureCode"
  unitOfMeasureCodeRaw'_ :: ((C2HSImp.Ptr (CUnitOfMeasure)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureUnitType"
  unitOfMeasureType'_ :: ((C2HSImp.Ptr (CUnitOfMeasure)) -> (IO C2HSImp.CInt))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureEmpty"
  unitOfMeasureEmpty'_ :: ((C2HSImp.Ptr (CUnitOfMeasure)) -> (IO C2HSImp.CInt))

foreign import ccall safe "QuantLib/Commodity.chs.h qlLotUnitOfMeasure"
  lotUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlBarrelUnitOfMeasure"
  barrelUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlMTUnitOfMeasure"
  mtUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlMBUnitOfMeasure"
  mbUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlGallonUnitOfMeasure"
  gallonUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlLitreUnitOfMeasure"
  litreUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlKilolitreUnitOfMeasure"
  kilolitreUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlTokyoKilolitreUnitOfMeasure"
  tokyoKilolitreUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTerm"
  paymentTerm'_ :: ((C2HSImp.Ptr C2HSImp.CChar) -> (C2HSImp.CInt -> (C2HSImp.CInt -> ((C2HSImp.Ptr (CCalendar)) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CPaymentTerm))))))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTermName"
  paymentTermNameRaw'_ :: ((C2HSImp.Ptr (CPaymentTerm)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTermEventType_"
  paymentTermEventType'_ :: ((C2HSImp.Ptr (CPaymentTerm)) -> (IO C2HSImp.CInt))

foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTermOffsetDays"
  paymentTermOffsetDays'_ :: ((C2HSImp.Ptr (CPaymentTerm)) -> (IO C2HSImp.CInt))

foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTermCalendar"
  paymentTermCalendar'_ :: ((C2HSImp.Ptr (CPaymentTerm)) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CCalendar)))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTermEmpty"
  paymentTermEmpty'_ :: ((C2HSImp.Ptr (CPaymentTerm)) -> (IO C2HSImp.CInt))

foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTermGetPaymentDate"
  paymentTermPaymentDate'_ :: ((C2HSImp.Ptr (CPaymentTerm)) -> (C2HSImp.CInt -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO C2HSImp.CInt))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlQuantityRoundedAmount"
  quantityRoundedAmount'_ :: ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> (IO C2HSImp.CDouble)))

foreign import ccall safe "QuantLib/Commodity.chs.h qlQuantityClose"
  qlQuantityClose_'_ :: ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> (C2HSImp.CInt -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO C2HSImp.CInt)))))))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlQuantityCloseEnough"
  qlQuantityCloseEnough_'_ :: ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> (C2HSImp.CInt -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO C2HSImp.CInt)))))))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversion"
  unitOfMeasureConversion'_ :: ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasureConversion))))))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionSource"
  unitOfMeasureConversionSource'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure)))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionTarget"
  unitOfMeasureConversionTarget'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure)))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionCommodityType"
  unitOfMeasureConversionCommodityType'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CCommodityType)))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionType_"
  unitOfMeasureConversionType'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> (IO C2HSImp.CInt))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionFactor"
  unitOfMeasureConversionFactor'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> (IO C2HSImp.CDouble))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionCode"
  unitOfMeasureConversionCodeRaw'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionConvert"
  qlUnitOfMeasureConversionConvert_'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> ((C2HSImp.Ptr (C2HSImp.Ptr (CCommodityType))) -> ((C2HSImp.Ptr (C2HSImp.Ptr (CUnitOfMeasure))) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO C2HSImp.CDouble))))))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionChain"
  chainUnitOfMeasureConversion'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasureConversion))))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionManagerLookup"
  lookupUomConversion'_ :: ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CInt -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasureConversion))))))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionManagerAdd"
  addUomConversion'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> (IO ()))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionManagerClear"
  clearUomConversions'_ :: (IO ())

foreign import ccall safe "QuantLib/Commodity.chs.h qlCommoditySettingsCurrency"
  commoditySettingsCurrency'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CCurrency))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlCommoditySettingsSetCurrency"
  setCommoditySettingsCurrency'_ :: ((C2HSImp.Ptr (CCurrency)) -> (IO ()))

foreign import ccall safe "QuantLib/Commodity.chs.h qlCommoditySettingsUnitOfMeasure"
  commoditySettingsUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlCommoditySettingsSetUnitOfMeasure"
  setCommoditySettingsUnitOfMeasure'_ :: ((C2HSImp.Ptr (CUnitOfMeasure)) -> (IO ()))