module Data.FpML.V53.Option.Bond
( module Data.FpML.V53.Option.Bond
, module Data.FpML.V53.Shared.Option
) where
import Text.XML.HaXml.Schema.Schema (SchemaType(..),SimpleType(..),Extension(..),Restricts(..))
import Text.XML.HaXml.Schema.Schema as Schema
import Text.XML.HaXml.OneOfN
import qualified Text.XML.HaXml.Schema.PrimitiveTypes as Xsd
import Data.FpML.V53.Shared.Option
data BondOption = BondOption
{ bondOption_ID :: Maybe Xsd.ID
, bondOption_primaryAssetClass :: Maybe AssetClass
, bondOption_secondaryAssetClass :: [AssetClass]
, bondOption_productType :: [ProductType]
, bondOption_productId :: [ProductId]
, bondOption_buyerPartyReference :: Maybe PartyReference
, bondOption_buyerAccountReference :: Maybe AccountReference
, bondOption_sellerPartyReference :: Maybe PartyReference
, bondOption_sellerAccountReference :: Maybe AccountReference
, bondOption_optionType :: OptionTypeEnum
, bondOption_premium :: Premium
, bondOption_exercise :: Exercise
, bondOption_exerciseProcedure :: Maybe ExerciseProcedure
, bondOption_feature :: Maybe OptionFeature
, bondOption_choice13 :: (Maybe (OneOf2 NotionalAmountReference Money))
, bondOption_optionEntitlement :: Maybe PositiveDecimal
, bondOption_entitlementCurrency :: Maybe Currency
, bondOption_numberOfOptions :: Maybe PositiveDecimal
, bondOption_settlementType :: Maybe SettlementTypeEnum
, bondOption_settlementDate :: Maybe AdjustableOrRelativeDate
, bondOption_choice19 :: (Maybe (OneOf2 Money Currency))
, bondOption_strike :: BondOptionStrike
, bondOption_choice21 :: OneOf2 Bond ConvertibleBond
}
deriving (Eq,Show)
instance SchemaType BondOption where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (BondOption a0)
`apply` optional (parseSchemaType "primaryAssetClass")
`apply` many (parseSchemaType "secondaryAssetClass")
`apply` many (parseSchemaType "productType")
`apply` many (parseSchemaType "productId")
`apply` optional (parseSchemaType "buyerPartyReference")
`apply` optional (parseSchemaType "buyerAccountReference")
`apply` optional (parseSchemaType "sellerPartyReference")
`apply` optional (parseSchemaType "sellerAccountReference")
`apply` parseSchemaType "optionType"
`apply` parseSchemaType "premium"
`apply` elementExercise
`apply` optional (parseSchemaType "exerciseProcedure")
`apply` optional (parseSchemaType "feature")
`apply` optional (oneOf' [ ("NotionalAmountReference", fmap OneOf2 (parseSchemaType "notionalReference"))
, ("Money", fmap TwoOf2 (parseSchemaType "notionalAmount"))
])
`apply` optional (parseSchemaType "optionEntitlement")
`apply` optional (parseSchemaType "entitlementCurrency")
`apply` optional (parseSchemaType "numberOfOptions")
`apply` optional (parseSchemaType "settlementType")
`apply` optional (parseSchemaType "settlementDate")
`apply` optional (oneOf' [ ("Money", fmap OneOf2 (parseSchemaType "settlementAmount"))
, ("Currency", fmap TwoOf2 (parseSchemaType "settlementCurrency"))
])
`apply` parseSchemaType "strike"
`apply` oneOf' [ ("Bond", fmap OneOf2 (elementBond))
, ("ConvertibleBond", fmap TwoOf2 (elementConvertibleBond))
]
schemaTypeToXML s x@BondOption{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ bondOption_ID x
]
[ maybe [] (schemaTypeToXML "primaryAssetClass") $ bondOption_primaryAssetClass x
, concatMap (schemaTypeToXML "secondaryAssetClass") $ bondOption_secondaryAssetClass x
, concatMap (schemaTypeToXML "productType") $ bondOption_productType x
, concatMap (schemaTypeToXML "productId") $ bondOption_productId x
, maybe [] (schemaTypeToXML "buyerPartyReference") $ bondOption_buyerPartyReference x
, maybe [] (schemaTypeToXML "buyerAccountReference") $ bondOption_buyerAccountReference x
, maybe [] (schemaTypeToXML "sellerPartyReference") $ bondOption_sellerPartyReference x
, maybe [] (schemaTypeToXML "sellerAccountReference") $ bondOption_sellerAccountReference x
, schemaTypeToXML "optionType" $ bondOption_optionType x
, schemaTypeToXML "premium" $ bondOption_premium x
, elementToXMLExercise $ bondOption_exercise x
, maybe [] (schemaTypeToXML "exerciseProcedure") $ bondOption_exerciseProcedure x
, maybe [] (schemaTypeToXML "feature") $ bondOption_feature x
, maybe [] (foldOneOf2 (schemaTypeToXML "notionalReference")
(schemaTypeToXML "notionalAmount")
) $ bondOption_choice13 x
, maybe [] (schemaTypeToXML "optionEntitlement") $ bondOption_optionEntitlement x
, maybe [] (schemaTypeToXML "entitlementCurrency") $ bondOption_entitlementCurrency x
, maybe [] (schemaTypeToXML "numberOfOptions") $ bondOption_numberOfOptions x
, maybe [] (schemaTypeToXML "settlementType") $ bondOption_settlementType x
, maybe [] (schemaTypeToXML "settlementDate") $ bondOption_settlementDate x
, maybe [] (foldOneOf2 (schemaTypeToXML "settlementAmount")
(schemaTypeToXML "settlementCurrency")
) $ bondOption_choice19 x
, schemaTypeToXML "strike" $ bondOption_strike x
, foldOneOf2 (elementToXMLBond)
(elementToXMLConvertibleBond)
$ bondOption_choice21 x
]
instance Extension BondOption OptionBaseExtended where
supertype v = OptionBaseExtended_BondOption v
instance Extension BondOption OptionBase where
supertype = (supertype :: OptionBaseExtended -> OptionBase)
. (supertype :: BondOption -> OptionBaseExtended)
instance Extension BondOption Option where
supertype = (supertype :: OptionBase -> Option)
. (supertype :: OptionBaseExtended -> OptionBase)
. (supertype :: BondOption -> OptionBaseExtended)
instance Extension BondOption Product where
supertype = (supertype :: Option -> Product)
. (supertype :: OptionBase -> Option)
. (supertype :: OptionBaseExtended -> OptionBase)
. (supertype :: BondOption -> OptionBaseExtended)
data BondOptionStrike = BondOptionStrike
{ bondOptionStrike_choice0 :: (Maybe (OneOf2 ReferenceSwapCurve OptionStrike))
}
deriving (Eq,Show)
instance SchemaType BondOptionStrike where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return BondOptionStrike
`apply` optional (oneOf' [ ("ReferenceSwapCurve", fmap OneOf2 (parseSchemaType "referenceSwapCurve"))
, ("OptionStrike", fmap TwoOf2 (parseSchemaType "price"))
])
schemaTypeToXML s x@BondOptionStrike{} =
toXMLElement s []
[ maybe [] (foldOneOf2 (schemaTypeToXML "referenceSwapCurve")
(schemaTypeToXML "price")
) $ bondOptionStrike_choice0 x
]
data MakeWholeAmount = MakeWholeAmount
{ makeWholeAmount_floatingRateIndex :: FloatingRateIndex
, makeWholeAmount_indexTenor :: Maybe Period
, makeWholeAmount_spread :: Maybe Xsd.Decimal
, makeWholeAmount_side :: Maybe QuotationSideEnum
, makeWholeAmount_interpolationMethod :: Maybe InterpolationMethod
, makeWholeAmount_earlyCallDate :: Maybe IdentifiedDate
}
deriving (Eq,Show)
instance SchemaType MakeWholeAmount where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return MakeWholeAmount
`apply` parseSchemaType "floatingRateIndex"
`apply` optional (parseSchemaType "indexTenor")
`apply` optional (parseSchemaType "spread")
`apply` optional (parseSchemaType "side")
`apply` optional (parseSchemaType "interpolationMethod")
`apply` optional (parseSchemaType "earlyCallDate")
schemaTypeToXML s x@MakeWholeAmount{} =
toXMLElement s []
[ schemaTypeToXML "floatingRateIndex" $ makeWholeAmount_floatingRateIndex x
, maybe [] (schemaTypeToXML "indexTenor") $ makeWholeAmount_indexTenor x
, maybe [] (schemaTypeToXML "spread") $ makeWholeAmount_spread x
, maybe [] (schemaTypeToXML "side") $ makeWholeAmount_side x
, maybe [] (schemaTypeToXML "interpolationMethod") $ makeWholeAmount_interpolationMethod x
, maybe [] (schemaTypeToXML "earlyCallDate") $ makeWholeAmount_earlyCallDate x
]
instance Extension MakeWholeAmount SwapCurveValuation where
supertype (MakeWholeAmount e0 e1 e2 e3 e4 e5) =
SwapCurveValuation e0 e1 e2 e3
data ReferenceSwapCurve = ReferenceSwapCurve
{ refSwapCurve_swapUnwindValue :: Maybe SwapCurveValuation
, refSwapCurve_makeWholeAmount :: Maybe MakeWholeAmount
}
deriving (Eq,Show)
instance SchemaType ReferenceSwapCurve where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return ReferenceSwapCurve
`apply` optional (parseSchemaType "swapUnwindValue")
`apply` optional (parseSchemaType "makeWholeAmount")
schemaTypeToXML s x@ReferenceSwapCurve{} =
toXMLElement s []
[ maybe [] (schemaTypeToXML "swapUnwindValue") $ refSwapCurve_swapUnwindValue x
, maybe [] (schemaTypeToXML "makeWholeAmount") $ refSwapCurve_makeWholeAmount x
]
data SwapCurveValuation = SwapCurveValuation
{ swapCurveVal_floatingRateIndex :: FloatingRateIndex
, swapCurveVal_indexTenor :: Maybe Period
, swapCurveVal_spread :: Maybe Xsd.Decimal
, swapCurveVal_side :: Maybe QuotationSideEnum
}
deriving (Eq,Show)
instance SchemaType SwapCurveValuation where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return SwapCurveValuation
`apply` parseSchemaType "floatingRateIndex"
`apply` optional (parseSchemaType "indexTenor")
`apply` optional (parseSchemaType "spread")
`apply` optional (parseSchemaType "side")
schemaTypeToXML s x@SwapCurveValuation{} =
toXMLElement s []
[ schemaTypeToXML "floatingRateIndex" $ swapCurveVal_floatingRateIndex x
, maybe [] (schemaTypeToXML "indexTenor") $ swapCurveVal_indexTenor x
, maybe [] (schemaTypeToXML "spread") $ swapCurveVal_spread x
, maybe [] (schemaTypeToXML "side") $ swapCurveVal_side x
]
elementBondOption :: XMLParser BondOption
elementBondOption = parseSchemaType "bondOption"
elementToXMLBondOption :: BondOption -> [Content ()]
elementToXMLBondOption = schemaTypeToXML "bondOption"