-- 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
  , paymentTermGetPaymentDate
    -- ** 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 QuantLib.Internal
import QuantLib.Internal.Type
import QuantLib.Internal.Common
import Foreign.Marshal.Alloc(alloca)








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


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


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


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


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


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


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

{-# LINE 105 "./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 CString -> IO CommodityType) -> IO CommodityType
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr CString -> IO CommodityType) -> IO CommodityType)
-> (Ptr CString -> IO CommodityType) -> IO CommodityType
forall a b. (a -> b) -> a -> b
$ \Ptr CString
a3' -> 
  CString -> CString -> Ptr CString -> IO (Ptr CCommodityType)
commodityType'_ CString
a1' CString
a2' Ptr CString
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 CString -> IO ()
errorCheck  Ptr CString
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 112 "./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 116 "./QuantLib/Commodity.chs" #-}


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

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


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

{-# LINE 122 "./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 125 "./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 132 "./QuantLib/Commodity.chs" #-}


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

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


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

{-# LINE 138 "./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 141 "./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 144 "./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 147 "./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 150 "./QuantLib/Commodity.chs" #-}


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

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


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

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


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

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


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

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


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

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


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

{-# LINE 168 "./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 176 "./QuantLib/Commodity.chs" #-}


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

{-# LINE 179 "./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 182 "./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 185 "./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 188 "./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 191 "./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.
paymentTermGetPaymentDate :: (PaymentTerm) -> (Day) -> IO ((Day))
paymentTermGetPaymentDate a1 a2 =
  withPaymentTerm a1 $ \a1' -> 
  withDay a2 $ \a2' -> 
  preErrorCheck $ \a3' -> 
  paymentTermGetPaymentDate'_ a1' a2' a3' >>= \res ->
  let {res' = toDay res} in
  errorCheck  a3'>>
  return (res')

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


-- |An amount of a commodity: a 'CommodityType', a 'UnitOfMeasure', and a plain amount. Marshalled
-- as a flat triple rather than a wrapper type (per the @Money@-as-tuple convention) -- and, unlike
-- 'CommodityUnitCost' below, its three inspectors are just tuple projections, so they need no
-- binding at all. c2hs's @&@ tuple-splitter only ever consumes two C arguments (confirmed against
-- its source, not just by trial), so every function below that takes or returns a 'Quantity'
-- marshals it as three flat 'CommodityType'\/'UnitOfMeasure'\/'Double' arguments instead of one
-- combined tuple.
type Quantity = (CommodityType, UnitOfMeasure, Double)

quantityRoundedAmount :: (UnitOfMeasure) -> (Double) -> (Double)
quantityRoundedAmount :: UnitOfMeasure -> Double -> Double
quantityRoundedAmount UnitOfMeasure
a1 Double
a2 =
  IO Double -> Double
forall a. IO a -> a
C2HSImp.unsafePerformIO (IO Double -> Double) -> IO Double -> Double
forall a b. (a -> b) -> a -> b
$
  UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO Double) -> IO Double
forall b. UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b
withUnitOfMeasure UnitOfMeasure
a1 ((Ptr CUnitOfMeasure -> IO Double) -> IO Double)
-> (Ptr CUnitOfMeasure -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasure
a1' -> 
  let {a2' :: CDouble
a2' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
a2} in 
  Ptr CUnitOfMeasure -> CDouble -> IO CDouble
quantityRoundedAmount'_ Ptr CUnitOfMeasure
a1' CDouble
a2' IO CDouble -> (CDouble -> IO Double) -> IO Double
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \CDouble
res ->
  let {res' = realToFrac res} in
  Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Double
res')

{-# LINE 207 "./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 CString -> IO Bool) -> IO Bool
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr CString -> IO Bool) -> IO Bool)
-> (Ptr CString -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr CString
a8' -> 
  Ptr CCommodityType
-> Ptr CUnitOfMeasure
-> CDouble
-> Ptr CCommodityType
-> Ptr CUnitOfMeasure
-> CDouble
-> CInt
-> Ptr CString
-> IO CInt
qlQuantityClose_'_ Ptr CCommodityType
a1' Ptr CUnitOfMeasure
a2' CDouble
a3' Ptr CCommodityType
a4' Ptr CUnitOfMeasure
a5' CDouble
a6' CInt
a7' Ptr CString
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 CString -> IO ()
errorCheck  Ptr CString
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 218 "./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 229 "./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 CString -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr CString -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr CString -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CString
a5' -> 
  Ptr CCommodityType
-> Ptr CUnitOfMeasure
-> Ptr CUnitOfMeasure
-> CDouble
-> Ptr CString
-> IO (Ptr CUnitOfMeasureConversion)
unitOfMeasureConversion'_ Ptr CCommodityType
a1' Ptr CUnitOfMeasure
a2' Ptr CUnitOfMeasure
a3' CDouble
a4' Ptr CString
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 CString -> IO ()
errorCheck  Ptr CString
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 288 "./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 291 "./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 294 "./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 297 "./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 300 "./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 303 "./QuantLib/Commodity.chs" #-}


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

{-# LINE 306 "./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 313 "./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 CString -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr CString -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr CString -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CString
a3' -> 
  Ptr CUnitOfMeasureConversion
-> Ptr CUnitOfMeasureConversion
-> Ptr CString
-> IO (Ptr CUnitOfMeasureConversion)
chainUnitOfMeasureConversion'_ Ptr CUnitOfMeasureConversion
a1' Ptr CUnitOfMeasureConversion
a2' Ptr CString
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 CString -> IO ()
errorCheck  Ptr CString
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 328 "./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 CString -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr CString -> IO UnitOfMeasureConversion)
 -> IO UnitOfMeasureConversion)
-> (Ptr CString -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CString
a5' -> 
  Ptr CCommodityType
-> Ptr CUnitOfMeasure
-> Ptr CUnitOfMeasure
-> CInt
-> Ptr CString
-> IO (Ptr CUnitOfMeasureConversion)
lookupUomConversion'_ Ptr CCommodityType
a1' Ptr CUnitOfMeasure
a2' Ptr CUnitOfMeasure
a3' CInt
a4' Ptr CString
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 CString -> IO ()
errorCheck  Ptr CString
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 338 "./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 342 "./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 346 "./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 349 "./QuantLib/Commodity.chs" #-}


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

{-# LINE 352 "./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 355 "./QuantLib/Commodity.chs" #-}


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

{-# LINE 358 "./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 C2HSImp.CChar)) -> (IO (C2HSImp.Ptr (CCommodityType))))))

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

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

foreign import ccall safe "QuantLib/Commodity.chs.h qlCommodityTypeName"
  commodityTypeName'_ :: ((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 C2HSImp.CChar)) -> (IO (C2HSImp.Ptr (CUnitOfMeasure)))))))

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

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureCode"
  unitOfMeasureCode'_ :: ((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 C2HSImp.CChar)) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))

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

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

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

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

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

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

foreign import ccall safe "QuantLib/Commodity.chs.h qlTokyoKilolitreUnitOfMeasure"
  tokyoKilolitreUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)) -> (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 C2HSImp.CChar)) -> (IO (C2HSImp.Ptr (CPaymentTerm))))))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTermName"
  paymentTermName'_ :: ((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 C2HSImp.CChar)) -> (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"
  paymentTermGetPaymentDate'_ :: ((C2HSImp.Ptr (CPaymentTerm)) -> (C2HSImp.CInt -> ((C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)) -> (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 C2HSImp.CChar)) -> (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 C2HSImp.CChar)) -> (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 C2HSImp.CChar)) -> (IO (C2HSImp.Ptr (CUnitOfMeasureConversion))))))))

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

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

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionCommodityType"
  unitOfMeasureConversionCommodityType'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)) -> (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"
  unitOfMeasureConversionCode'_ :: ((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 C2HSImp.CChar)) -> (IO C2HSImp.CDouble))))))))

foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionChain"
  chainUnitOfMeasureConversion'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)) -> (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 C2HSImp.CChar)) -> (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 C2HSImp.CChar)) -> (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 C2HSImp.CChar)) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))

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