//----------------------------------------------------------------------- /// <summary> /// Sets the additional position information, defaulted to an empty instance. /// <para> /// This allows additional information to be attached to the position. /// </para> /// </summary> /// <param name="info"> the new value, not null </param> /// <returns> this, for chaining, not null </returns> public Builder info(PositionInfo info) { JodaBeanUtils.notNull(info, "info"); this.info_Renamed = info; return(this); }
//------------------------------------------------------------------------- /// <summary> /// Obtains an instance from the security and net quantity. /// <para> /// The net quantity is the long quantity minus the short quantity, which may be negative. /// If the quantity is positive it is treated as a long quantity. /// Otherwise it is treated as a short quantity. /// /// </para> /// </summary> /// <param name="security"> the underlying security </param> /// <param name="netQuantity"> the net quantity of the underlying security </param> /// <returns> the position </returns> public static GenericSecurityPosition ofNet(GenericSecurity security, double netQuantity) { return(ofNet(PositionInfo.empty(), security, netQuantity)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @ImmutableDefaults private static void applyDefaults(Builder builder) private static void applyDefaults(Builder builder) { builder.info_Renamed = PositionInfo.empty(); }
//------------------------------------------------------------------------- public GenericSecurityPosition withInfo(PositionInfo info) { return(new GenericSecurityPosition(info, security, longQuantity, shortQuantity)); }
/// <summary> /// Obtains an instance from the security, long quantity and short quantity. /// <para> /// The long quantity and short quantity must be zero or positive, not negative. /// In many cases, only a long quantity or short quantity will be present with the other set to zero. /// However it is also possible for both to be non-zero, allowing long and short positions to be treated separately. /// /// </para> /// </summary> /// <param name="security"> the underlying security </param> /// <param name="longQuantity"> the long quantity of the underlying security </param> /// <param name="shortQuantity"> the short quantity of the underlying security </param> /// <returns> the position </returns> public static GenericSecurityPosition ofLongShort(GenericSecurity security, double longQuantity, double shortQuantity) { return(ofLongShort(PositionInfo.empty(), security, longQuantity, shortQuantity)); }
/// <summary> /// Obtains an instance from position information, security, long quantity and short quantity. /// <para> /// The long quantity and short quantity must be zero or positive, not negative. /// In many cases, only a long quantity or short quantity will be present with the other set to zero. /// However it is also possible for both to be non-zero, allowing long and short positions to be treated separately. /// /// </para> /// </summary> /// <param name="positionInfo"> the position information </param> /// <param name="security"> the underlying security </param> /// <param name="longQuantity"> the long quantity of the underlying security </param> /// <param name="shortQuantity"> the short quantity of the underlying security </param> /// <returns> the position </returns> public static GenericSecurityPosition ofLongShort(PositionInfo positionInfo, GenericSecurity security, double longQuantity, double shortQuantity) { return(new GenericSecurityPosition(positionInfo, security, longQuantity, shortQuantity)); }
//------------------------------------------------------------------------- public virtual void test_of() { GenericSecurity test = sut(); assertEquals(test.Info, INFO); assertEquals(test.SecurityId, INFO.Id); assertEquals(test.Currency, INFO.PriceInfo.Currency); assertEquals(test.UnderlyingIds, ImmutableSet.of()); assertEquals(test, GenericSecurity.of(INFO)); assertEquals(test.createProduct(ReferenceData.empty()), test); assertEquals(test.createTrade(TradeInfo.empty(), 1, 2, ReferenceData.empty()), GenericSecurityTrade.of(TradeInfo.empty(), GenericSecurity.of(INFO), 1, 2)); assertEquals(test.createPosition(PositionInfo.empty(), 1, ReferenceData.empty()), GenericSecurityPosition.ofNet(PositionInfo.empty(), GenericSecurity.of(INFO), 1)); assertEquals(test.createPosition(PositionInfo.empty(), 1, 2, ReferenceData.empty()), GenericSecurityPosition.ofLongShort(PositionInfo.empty(), GenericSecurity.of(INFO), 1, 2)); }
public virtual void test_serialization() { PositionInfo test = PositionInfo.builder().id(ID).addAttribute(AttributeType.DESCRIPTION, "A").build(); assertSerialization(test); }
internal static GenericSecurityPosition sut2() { return(GenericSecurityPosition.builder().info(PositionInfo.empty()).security(SECURITY2).longQuantity(LONG_QUANTITY2).shortQuantity(SHORT_QUANTITY2).build()); }
public GenericSecurityPosition createPosition(PositionInfo positionInfo, double longQuantity, double shortQuantity, ReferenceData refData) { return(GenericSecurityPosition.ofLongShort(positionInfo, this, longQuantity, shortQuantity)); }
public GenericSecurityPosition createPosition(PositionInfo tradeInfo, double quantity, ReferenceData refData) { return(GenericSecurityPosition.ofNet(tradeInfo, this, quantity)); }
//------------------------------------------------------------------------- /// <summary> /// Obtains an instance from the security identifier and net quantity. /// <para> /// The net quantity is the long quantity minus the short quantity, which may be negative. /// If the quantity is positive it is treated as a long quantity. /// Otherwise it is treated as a short quantity. /// /// </para> /// </summary> /// <param name="securityId"> the identifier of the underlying security </param> /// <param name="netQuantity"> the net quantity of the underlying security </param> /// <returns> the position </returns> public static SecurityPosition ofNet(SecurityId securityId, double netQuantity) { return(ofNet(PositionInfo.empty(), securityId, netQuantity)); }
/// <summary> /// Obtains an instance from position information, security identifier, long quantity and short quantity. /// <para> /// The long quantity and short quantity must be zero or positive, not negative. /// In many cases, only a long quantity or short quantity will be present with the other set to zero. /// However it is also possible for both to be non-zero, allowing long and short positions to be treated separately. /// /// </para> /// </summary> /// <param name="positionInfo"> the position information </param> /// <param name="securityId"> the identifier of the underlying security </param> /// <param name="longQuantity"> the long quantity of the underlying security </param> /// <param name="shortQuantity"> the short quantity of the underlying security </param> /// <returns> the position </returns> public static SecurityPosition ofLongShort(PositionInfo positionInfo, SecurityId securityId, double longQuantity, double shortQuantity) { return(new SecurityPosition(positionInfo, securityId, longQuantity, shortQuantity)); }