protected Result(
final org.fudgemsg.mapping.FudgeDeserializationContext fudgeContext,
final org.fudgemsg.FudgeMsg fudgeMsg) {
super(fudgeContext, fudgeMsg);
org.fudgemsg.FudgeField fudgeField;
fudgeField = fudgeMsg.getByName(RESULT_KEY);
if (fudgeField == null)
throw new IllegalArgumentException(
"Fudge message is not a Result - field 'result' is not present");
try {
_result =
fudgeContext.fieldValueToObject(
com.opengamma.engine.view.calcnode.CalculationJobResult.class, fudgeField);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(
"Fudge message is not a Result - field 'result' is not CalculationJobResult message", e);
}
fudgeField = fudgeMsg.getByName(READY_KEY);
if (fudgeField != null) {
try {
final com.opengamma.engine.view.calcnode.msg.Ready fudge1;
fudge1 =
com.opengamma.engine.view.calcnode.msg.Ready.fromFudgeMsg(
fudgeContext, fudgeMsg.getFieldValue(org.fudgemsg.FudgeMsg.class, fudgeField));
setReady(fudge1);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(
"Fudge message is not a Result - field 'ready' is not Ready message", e);
}
}
}
@Override
public CurveBuildingBlockBundle buildObject(
final FudgeDeserializer deserializer, final FudgeMsg message) {
final List<FudgeField> curveNames = message.getAllByName(CURVE_NAME_FIELD);
final List<FudgeField> blocks = message.getAllByName(BLOCK_FIELD);
final List<FudgeField> matrices = message.getAllByName(MATRIX_FIELD);
final int n = curveNames.size();
if (blocks.size() != n) {
throw new IllegalStateException(
"Should have one block for each curve name; have " + curveNames + " and " + blocks);
}
if (matrices.size() != n) {
throw new IllegalStateException(
"Should have one matrix for each curve name; have " + curveNames + " and " + matrices);
}
final LinkedHashMap<String, Pair<CurveBuildingBlock, DoubleMatrix2D>> data =
new LinkedHashMap<>();
for (int i = 0; i < n; i++) {
final String curveName = (String) curveNames.get(i).getValue();
final CurveBuildingBlock block =
deserializer.fieldValueToObject(CurveBuildingBlock.class, blocks.get(i));
final DoubleMatrix2D m =
new DoubleMatrix2D(deserializer.fieldValueToObject(double[][].class, matrices.get(i)));
data.put(curveName, Pair.of(block, m));
}
return new CurveBuildingBlockBundle(data);
}
public static FlexiDateTime fromFudgeMsg(
final FudgeDeserializer deserializer, final FudgeMsg msg) {
if (msg == null) {
return null;
}
final ZoneId zone = msg.getValue(ZoneId.class, ZONE_FIELD_NAME);
final Object obj = msg.getValue(DATETIME_FIELD_NAME);
if (obj instanceof FudgeDateTime) {
FudgeDateTime fudge = (FudgeDateTime) obj;
if (fudge.getTime().hasTimezoneOffset()) {
OffsetDateTime odt = fudge.toOffsetDateTime();
if (zone != null) {
return FlexiDateTime.of(odt.atZoneSameInstant(zone));
}
return FlexiDateTime.of(odt);
} else {
return FlexiDateTime.of(fudge.toLocalDateTime());
}
} else if (obj instanceof FudgeDate) {
FudgeDate fudge = (FudgeDate) obj;
return FlexiDateTime.of(fudge.toLocalDate());
} else if (obj instanceof OffsetDateTime) {
OffsetDateTime odt = (OffsetDateTime) obj;
if (zone != null) {
return FlexiDateTime.of(odt.atZoneSameInstant(zone));
}
return FlexiDateTime.of(odt);
} else if (obj instanceof LocalDateTime) {
return FlexiDateTime.of((LocalDateTime) obj);
} else if (obj instanceof LocalDate) {
return FlexiDateTime.of((LocalDate) obj);
} else {
throw new IllegalStateException("Fudge message did not contain a valid date-time");
}
}
@Test
public void testGetBulkSecuritiesByUniqueId() {
final FudgeMsgEnvelope fme =
getSecuritySourceResource()
.getSecurities(Lists.newArrayList(_uid1.toString(), _uid2.toString()));
assertNotNull(fme);
final FudgeMsg msg = fme.getMessage();
assertNotNull(msg);
FudgeMsgFormatter.outputToSystemOut(msg);
final Collection<FudgeField> securities = msg.getAllByName(SECURITYSOURCE_SECURITY);
assertNotNull(securities);
assertEquals(2, securities.size());
FudgeDeserializer deserializer =
new FudgeDeserializer(getSecuritySourceResource().getFudgeContext());
for (FudgeField fudgeField : securities) {
assertNotNull(fudgeField);
ObjectsPair<UniqueId, Security> objectsPair =
ObjectsPairFudgeBuilder.buildObject(
deserializer, (FudgeMsg) fudgeField.getValue(), UniqueId.class, Security.class);
assertNotNull(objectsPair);
UniqueId uniqueId = objectsPair.getKey();
assertNotNull(uniqueId);
Security security = objectsPair.getValue();
assertNotNull(security);
}
}
@Override
public YieldCurveBundle buildObject(
final FudgeDeserializer deserializer, final FudgeMsg message) {
// note name in curve & name in bundle may be different!
final List<FudgeField> curveFields = message.getAllByName(CURVES_FIELD_NAME);
final List<FudgeField> curveNameFields = message.getAllByName(CURVES_NAME_FIELD_NAME);
final List<FudgeField> ccyFields = message.getAllByName(CURRENCY_FIELD_NAME);
final List<FudgeField> ccyCurveFields = message.getAllByName(CURRENCY_CURVE_FIELD_NAME);
final Map<String, YieldAndDiscountCurve> curves = new LinkedHashMap<>(curveFields.size());
final Map<String, Currency> curveCurrencys = Maps.newHashMapWithExpectedSize(ccyFields.size());
final FXMatrix fxMatrix =
deserializer.fieldValueToObject(FXMatrix.class, message.getByName(FX_MATRIX_FIELD_NAME));
for (int i = 0; i < curveFields.size(); i++) {
final YieldAndDiscountCurve curve =
deserializer.fieldValueToObject(YieldAndDiscountCurve.class, curveFields.get(i));
final String name = deserializer.fieldValueToObject(String.class, curveNameFields.get(i));
curves.put(name, curve);
}
for (int i = 0; i < ccyFields.size(); i++) {
final String name = deserializer.fieldValueToObject(String.class, ccyCurveFields.get(i));
final Currency ccy = deserializer.fieldValueToObject(Currency.class, ccyFields.get(i));
curveCurrencys.put(name, ccy);
}
return new YieldCurveBundle(fxMatrix, curveCurrencys, curves);
}
@Override
public CurveBuildingBlock buildObject(
final FudgeDeserializer deserializer, final FudgeMsg message) {
final List<FudgeField> curveNames = message.getAllByName(CURVE_NAME_FIELD);
final List<FudgeField> startIndices = message.getAllByName(START_INDEX_FIELD);
final int n = curveNames.size();
if (startIndices.size() != n) {
throw new IllegalStateException(
"Should have one start index for each curve name; have "
+ curveNames
+ " and "
+ startIndices);
}
final List<FudgeField> numbers = message.getAllByName(NUMBER_FIELD);
if (numbers.size() != n) {
throw new IllegalStateException(
"Should have one parameter number for each curve name; have "
+ curveNames
+ " and "
+ numbers);
}
final LinkedHashMap<String, Pair<Integer, Integer>> data = new LinkedHashMap<>();
for (int i = 0; i < n; i++) {
final String curveName = (String) curveNames.get(i).getValue();
final Integer startIndex = ((Number) startIndices.get(i).getValue()).intValue();
final Integer number = ((Number) numbers.get(i).getValue()).intValue();
data.put(curveName, Pair.of(startIndex, number));
}
return new CurveBuildingBlock(data);
}
@Override
public MoneynessPiecewiseSABRSurfaceFitter buildObject(
final FudgeDeserializer deserializer, final FudgeMsg message) {
final boolean useLogTime = message.getBoolean(TIME_FIELD_NAME);
final boolean useIntegratedVar = message.getBoolean(SPACE_FIELD_NAME);
final double lambda = message.getDouble(LAMBDA_FIELD_NAME);
return new MoneynessPiecewiseSABRSurfaceFitter(useLogTime, useIntegratedVar, lambda);
}
private void checkSecurityMessage(final FudgeMsgEnvelope fme) {
assertNotNull(fme);
final FudgeMsg msg = fme.getMessage();
assertNotNull(msg);
FudgeMsgFormatter.outputToSystemOut(msg);
final FudgeMsg security =
msg.getFieldValue(FudgeMsg.class, msg.getByName(SECURITYSOURCE_SECURITY));
assertNotNull(security);
}
@Override
public IndexON buildObject(final FudgeDeserializer deserializer, final FudgeMsg message) {
final String name = message.getString(NAME_FIELD);
final Currency currency = Currency.of(message.getString(CURRENCY_FIELD));
final DayCount dayCount =
DayCountFactory.INSTANCE.getDayCount(message.getString(DAY_COUNT_FIELD));
final int publicationLag = message.getInt(PUBLICATION_LAG_FIELD);
return new IndexON(name, currency, dayCount, publicationLag);
}
private void checkSecuritiesMessage(final FudgeMsgEnvelope fme) {
assertNotNull(fme);
final FudgeMsg msg = fme.getMessage();
assertNotNull(msg);
FudgeMsgFormatter.outputToSystemOut(msg);
final Collection<FudgeField> securities = msg.getAllByName(SECURITYSOURCE_SECURITY);
assertNotNull(securities);
assertEquals(2, securities.size());
}
@Override
public CycleExecutionFailedCall buildObject(FudgeDeserializationContext context, FudgeMsg msg) {
ViewCycleExecutionOptions cycleExecutionOptions =
context.fieldValueToObject(
ViewCycleExecutionOptions.class, msg.getByName(EXECUTION_OPTIONS_FIELD));
FudgeField exceptionField = msg.getByName(EXCEPTION_FIELD);
Exception exception =
exceptionField != null ? context.fieldValueToObject(Exception.class, exceptionField) : null;
return new CycleExecutionFailedCall(cycleExecutionOptions, exception);
}
@Test
public void testGetAllBondsOfIssuerType() {
final FudgeMsgEnvelope fme =
getSecuritySourceResource().getBondsWithIssuerName("US TREASURY N/B");
assertNotNull(fme);
final FudgeMsg msg = fme.getMessage();
assertNotNull(msg);
FudgeMsgFormatter.outputToSystemOut(msg);
final Collection<FudgeField> securities = msg.getAllByName(SECURITYSOURCE_SECURITY);
assertNotNull(securities);
assertEquals(1, securities.size());
}
public static Entry fromFudgeMsg(final FudgeDeserializer context, final FudgeMsg msg) {
final Entry e = new Entry();
final Iterator<FudgeField> keys = msg.getAllByOrdinal(1).iterator();
final Iterator<FudgeField> values = msg.getAllByOrdinal(2).iterator();
while (keys.hasNext() && values.hasNext()) {
final FudgeField key = keys.next();
final FudgeField value = values.next();
e.add(
context.fieldValueToObject(ExternalIdBundle.class, key),
context.fieldValueToObject(HistoricalTimeSeries.class, value));
}
return e;
}
@Override
public ZonedDateTime buildObject(FudgeDeserializationContext context, FudgeMsg msg) {
final OffsetDateTime odt = msg.getValue(OffsetDateTime.class, ODT_FIELD_NAME);
if (odt == null) {
throw new IllegalArgumentException(
"Fudge message is not a ZonedDateTime - field 'odt' is not present");
}
final String zone = msg.getString(ZONE_FIELD_NAME);
if (zone == null) {
throw new IllegalArgumentException(
"Fudge message is not a ZonedDateTime - field 'zone' is not present");
}
return ZonedDateTime.of(odt, TimeZone.of(zone));
}
// -------------------------------------------------------------------------
@SuppressWarnings("unchecked")
@Override
public T buildObject(FudgeDeserializer deserializer, FudgeMsg outerMsg) {
FudgeField fudgeField = outerMsg.getByName("inner");
FudgeMsg msg = (FudgeMsg) fudgeField.getValue();
final FudgeField classNameField = msg.getByOrdinal(FudgeSerializer.TYPES_HEADER_ORDINAL);
final String className = (String) classNameField.getValue();
try {
final List<Object> parameters = newArrayList();
parameters.add(null); // the omitted enclosing object
for (FudgeField parameterField : msg.getAllByOrdinal(1)) {
parameters.add(deserializer.fieldValueToObject(parameterField));
}
return (T)
AccessController.doPrivileged(
new PrivilegedAction<Object>() {
@Override
public Object run() {
try {
final Class<?> innerClass = Class.forName(className);
final Constructor<?>[] ctors = innerClass.getDeclaredConstructors();
// We require that inner classes got only one ctor (anonymous inner classes will
// do)
// in order to avoid disambiguity
if (ctors.length == 1) {
final Constructor<?> ctor = ctors[0];
ctor.setAccessible(true); // solution
Object inner = ctor.newInstance(parameters.toArray());
return new AutoFudgable<Object>(inner);
}
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
return null;
}
});
} catch (RuntimeException ex) {
throw new FudgeRuntimeException("Unable to deserialize: " + className, ex);
}
}
@Override
public StandardSmileSurfaceDataBundle buildObject(
final FudgeDeserializer deserializer, final FudgeMsg message) {
final ForwardCurve forwardCurve =
deserializer.fieldValueToObject(
ForwardCurve.class, message.getByName(FORWARD_CURVE_FIELD_NAME));
final double[] expiries =
deserializer.fieldValueToObject(double[].class, message.getByName(EXPIRIES_FIELD_NAME));
final double[][] strikes =
deserializer.fieldValueToObject(double[][].class, message.getByName(STRIKES_FIELD_NAME));
final double[][] vols =
deserializer.fieldValueToObject(double[][].class, message.getByName(VOLS_FIELD_NAME));
final boolean isCallData = message.getBoolean(IS_CALL_FIELD_NAME);
return new StandardSmileSurfaceDataBundle(forwardCurve, expiries, strikes, vols, isCallData);
}
@Override
public DoubleMatrix2D buildObject(
final FudgeDeserializer deserializer, final FudgeMsg message) {
final double[][] data =
deserializer.fieldValueToObject(double[][].class, message.getByName(DATA_FIELD_NAME));
return new DoubleMatrix2D(data);
}
protected Set<ComputationTargetSpecification> decodeComputationTargets(
final FudgeDeserializer deserializer, final FudgeMsg msg) {
final FudgeMsg submsg = msg.getMessage(COMPUTATION_TARGETS_FIELD);
if (submsg == null) {
return Collections.emptySet();
}
final Set<ComputationTargetSpecification> result =
Sets.newHashSetWithExpectedSize(submsg.getNumFields());
for (final FudgeField field : submsg) {
result.add(
deserializer
.fieldValueToObject(ComputationTargetReference.class, field)
.getSpecification());
}
return result;
}
public static void fromFudgeMsg(
FudgeDeserializer deserializer, FudgeMsg msg, EnergyFutureSecurity object) {
CommodityFutureSecurityFudgeBuilder.fromFudgeMsg(deserializer, msg, object);
object.setUnderlyingId(
ExternalIdFudgeBuilder.fromFudgeMsg(
deserializer, msg.getMessage(UNDERLYING_IDENTIFIER_FIELD_NAME)));
}
protected SimpleChooserPayoffStyle(
final org.fudgemsg.mapping.FudgeDeserializationContext fudgeContext,
final org.fudgemsg.FudgeMsg fudgeMsg) {
super(fudgeContext, fudgeMsg);
org.fudgemsg.FudgeField fudgeField;
fudgeField = fudgeMsg.getByName(CHOOSE_DATE_KEY);
if (fudgeField == null)
throw new IllegalArgumentException(
"Fudge message is not a SimpleChooserPayoffStyle - field 'chooseDate' is not present");
try {
_chooseDate =
fudgeContext.fieldValueToObject(javax.time.calendar.ZonedDateTime.class, fudgeField);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(
"Fudge message is not a SimpleChooserPayoffStyle - field 'chooseDate' is not ZonedDateTime typedef",
e);
}
fudgeField = fudgeMsg.getByName(UNDERLYING_STRIKE_KEY);
if (fudgeField == null)
throw new IllegalArgumentException(
"Fudge message is not a SimpleChooserPayoffStyle - field 'underlyingStrike' is not present");
try {
_underlyingStrike = fudgeMsg.getFieldValue(Double.class, fudgeField);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(
"Fudge message is not a SimpleChooserPayoffStyle - field 'underlyingStrike' is not double",
e);
}
fudgeField = fudgeMsg.getByName(UNDERLYING_EXPIRY_KEY);
if (fudgeField == null)
throw new IllegalArgumentException(
"Fudge message is not a SimpleChooserPayoffStyle - field 'underlyingExpiry' is not present");
try {
_underlyingExpiry =
com.opengamma.util.time.Expiry.fromFudgeMsg(
fudgeContext, fudgeMsg.getFieldValue(org.fudgemsg.FudgeMsg.class, fudgeField));
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(
"Fudge message is not a SimpleChooserPayoffStyle - field 'underlyingExpiry' is not Expiry message",
e);
}
}
@SuppressWarnings("synthetic-access")
@Override
public CurrencyLabelledMatrix1D buildObject(
final FudgeDeserializer deserializer, final FudgeMsg message) {
final FudgeMsg msg = message.getMessage(MATRIX_FIELD_NAME);
final Queue<String> labelTypes = new LinkedList<String>();
final Queue<FudgeField> labelValues = new LinkedList<FudgeField>();
final List<Currency> keys = new LinkedList<Currency>();
final List<Object> labels = new LinkedList<Object>();
final List<Double> values = new LinkedList<Double>();
for (final FudgeField field : msg) {
switch (field.getOrdinal()) {
case LABEL_TYPE_ORDINAL:
labelTypes.add((String) field.getValue());
break;
case KEY_ORDINAL:
keys.add(Currency.of((String) field.getValue()));
break;
case LABEL_ORDINAL:
labelValues.add(field);
break;
case VALUE_ORDINAL:
values.add((Double) field.getValue());
break;
}
if (!labelTypes.isEmpty() && !labelValues.isEmpty()) {
// Have a type and a value, which can be consumed
final String labelType = labelTypes.remove();
Class<?> labelClass;
try {
labelClass = LabelledMatrix1DBuilder.getLabelClass(labelType, _loadedClasses);
} catch (final ClassNotFoundException ex) {
throw new OpenGammaRuntimeException(
"Could not deserialize label of type " + labelType, ex);
}
final FudgeField labelValue = labelValues.remove();
final Object label = deserializer.fieldValueToObject(labelClass, labelValue);
// labels.add(Currency.of((String) label));
labels.add(label);
}
}
final int matrixSize = keys.size();
final Currency[] keysArray = new Currency[matrixSize];
keys.toArray(keysArray);
final Object[] labelsArray = new Object[matrixSize];
labels.toArray(labelsArray);
final double[] valuesArray = Doubles.toArray(values);
return new CurrencyLabelledMatrix1D(keysArray, labelsArray, valuesArray);
}
public void fudgeEncoding() {
List<HistoricalTimeSeriesRatingRule> rules = new ArrayList<HistoricalTimeSeriesRatingRule>();
rules.add(HistoricalTimeSeriesRatingRule.of(DATA_SOURCE_NAME, "BLOOMBERG", 2));
rules.add(HistoricalTimeSeriesRatingRule.of(DATA_SOURCE_NAME, "REUTERS", 1));
rules.add(HistoricalTimeSeriesRatingRule.of(DATA_PROVIDER_NAME, "CMPL", 3));
HistoricalTimeSeriesRating inputConfig = HistoricalTimeSeriesRating.of(rules);
FudgeSerializer serializationContext = new FudgeSerializer(s_fudgeContext);
MutableFudgeMsg inputMsg = serializationContext.objectToFudgeMsg(inputConfig);
FudgeMsg outputMsg =
s_fudgeContext.deserialize(s_fudgeContext.toByteArray(inputMsg)).getMessage();
assertNotNull(outputMsg);
assertEquals(3, outputMsg.getNumFields());
FudgeDeserializer deserializationContext = new FudgeDeserializer(s_fudgeContext);
HistoricalTimeSeriesRating outputConfig =
deserializationContext.fudgeMsgToObject(HistoricalTimeSeriesRating.class, outputMsg);
assertEquals(inputConfig, outputConfig);
}
@Override
public Position buildObject(final FudgeDeserializer deserializer, final FudgeMsg message) {
final SimplePosition position = buildObjectImpl(deserializer, message);
final FudgeField parentField = message.getByName(FIELD_PARENT);
final UniqueId parentId =
(parentField != null) ? deserializer.fieldValueToObject(UniqueId.class, parentField) : null;
if (parentId != null) {
position.setParentNodeId(parentId);
}
return position;
}
@Override
public SimpleHistoricalTimeSeries buildObject(FudgeDeserializer deserializer, FudgeMsg message) {
UniqueId uniqueId = null;
LocalDateDoubleTimeSeries timeseries = null;
if (message.getByName(UNIQUE_ID_FIELD_NAME) != null) {
uniqueId =
deserializer.fieldValueToObject(UniqueId.class, message.getByName(UNIQUE_ID_FIELD_NAME));
}
if (message.hasField(TIMESERIES_FIELD_NAME)) {
Object fieldValue = deserializer.fieldValueToObject(message.getByName(TIMESERIES_FIELD_NAME));
if (fieldValue instanceof LocalDateDoubleTimeSeries) {
timeseries = (LocalDateDoubleTimeSeries) fieldValue;
}
}
if (uniqueId != null && timeseries != null) {
return new SimpleHistoricalTimeSeries(uniqueId, timeseries);
} else {
throw new OpenGammaRuntimeException(
"Cannot deserialize " + message + " to SimpleHistoricalTimeSeries");
}
}
@Override
public InflationProviderDiscount buildObject(
final FudgeDeserializer deserializer, final FudgeMsg message) {
final MulticurveProviderDiscount yieldCurves =
deserializer.fieldValueToObject(
MulticurveProviderDiscount.class, message.getByName(YIELD_CURVES_FIELD));
final List<FudgeField> indexFields = message.getAllByName(PRICE_INDEX_FIELD);
final List<FudgeField> indexCurveFields = message.getAllByName(PRICE_INDEX_CURVE_FIELD);
final Map<IndexPrice, PriceIndexCurve> priceIndexCurves = new LinkedHashMap<>();
final int n = indexFields.size();
for (int i = 0; i < n; i++) {
final IndexPrice index =
deserializer.fudgeMsgToObject(
IndexPrice.class, (FudgeMsg) indexFields.get(i).getValue());
final PriceIndexCurve curve =
deserializer.fudgeMsgToObject(
PriceIndexCurve.class, (FudgeMsg) indexCurveFields.get(i).getValue());
priceIndexCurves.put(index, curve);
}
return new InflationProviderDiscount(yieldCurves, priceIndexCurves);
}
public static void fromFudgeMsg(
FudgeDeserializer deserializer, FudgeMsg msg, EquitySecurity object) {
FinancialSecurityFudgeBuilder.fromFudgeMsg(deserializer, msg, object);
object.setShortName(msg.getString(SHORT_NAME_FIELD_NAME));
object.setExchange(msg.getString(EXCHANGE_FIELD_NAME));
object.setExchangeCode(msg.getString(EXCHANGE_CODE_FIELD_NAME));
object.setCompanyName(msg.getString(COMPANY_NAME_FIELD_NAME));
object.setCurrency(msg.getValue(Currency.class, CURRENCY_FIELD_NAME));
object.setGicsCode(msg.getValue(GICSCode.class, GICS_CODE_FIELD_NAME));
object.setPreferred(BooleanUtils.isTrue(msg.getBoolean(PREFERRED_FIELD_NAME)));
}
@Override
public CalculationJobItem buildObject(FudgeDeserializer deserializer, FudgeMsg message) {
ComputationTargetSpecification computationTargetSpecification =
deserializer.fudgeMsgToObject(ComputationTargetSpecification.class, message);
Validate.notNull(
computationTargetSpecification,
"Fudge message is not a CalculationJobItem - field 'computationTargetSpecification' is not present");
String functionUniqueId = message.getString(FUNCTION_UNIQUE_ID_FIELD_NAME);
Validate.notNull(
functionUniqueId,
"Fudge message is not a CalculationJobItem - field 'functionUniqueIdentifier' is not present");
FudgeField fudgeField = message.getByName(FUNCTION_PARAMETERS_FIELD_NAME);
Validate.notNull(
fudgeField,
"Fudge message is not a CalculationJobItem - field 'functionParameters' is not present");
FunctionParameters functionParameters =
deserializer.fieldValueToObject(FunctionParameters.class, fudgeField);
final long[] inputIdentifiers = (long[]) message.getByName(INPUT_FIELD_NAME).getValue();
List<ValueRequirement> desiredValues = new ArrayList<ValueRequirement>();
for (FudgeField field : message.getAllByName(DESIRED_VALUE_FIELD_NAME)) {
FudgeMsg valueMsg = (FudgeMsg) field.getValue();
ValueRequirement desiredValue =
deserializer.fudgeMsgToObject(ValueRequirement.class, valueMsg);
desiredValues.add(desiredValue);
}
return CalculationJobItem.create(
functionUniqueId,
functionParameters,
computationTargetSpecification,
inputIdentifiers,
desiredValues);
}
/**
* Deserializes this pair from a Fudge message.
*
* @param fudgeContext the Fudge context
* @param msg the Fudge message, not null
* @return the pair, not null
*/
public static IdentifierBundleWithDates fromFudgeMsg(
FudgeDeserializationContext fudgeContext, FudgeMsg msg) {
Set<IdentifierWithDates> identifiers = new HashSet<IdentifierWithDates>();
for (FudgeField field : msg.getAllByName(ID_FUDGE_FIELD_NAME)) {
if (field.getValue() instanceof FudgeMsg == false) {
throw new IllegalArgumentException(
"Message provider has field named "
+ ID_FUDGE_FIELD_NAME
+ " which doesn't contain a sub-Message");
}
identifiers.add(IdentifierWithDates.fromFudgeMsg(fudgeContext, (FudgeMsg) field.getValue()));
}
return new IdentifierBundleWithDates(identifiers);
}
protected EntitlementResponseMsg(
final org.fudgemsg.mapping.FudgeDeserializer deserializer,
final org.fudgemsg.FudgeMsg fudgeMsg) {
java.util.List<org.fudgemsg.FudgeField> fudgeFields;
fudgeFields = fudgeMsg.getAllByName(RESPONSES_KEY);
if (fudgeFields.size() == 0)
throw new IllegalArgumentException(
"Fudge message is not a EntitlementResponseMsg - field 'responses' is not present");
_responses =
new java.util.ArrayList<com.opengamma.livedata.msg.EntitlementResponse>(fudgeFields.size());
for (org.fudgemsg.FudgeField fudge1 : fudgeFields) {
try {
final com.opengamma.livedata.msg.EntitlementResponse fudge2;
fudge2 =
com.opengamma.livedata.msg.EntitlementResponse.fromFudgeMsg(
deserializer, fudgeMsg.getFieldValue(org.fudgemsg.FudgeMsg.class, fudge1));
_responses.add(fudge2);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(
"Fudge message is not a EntitlementResponseMsg - field 'responses' is not EntitlementResponse message",
e);
}
}
}
@Override
public IborIndex buildObject(final FudgeDeserializer deserializer, final FudgeMsg message) {
final Currency currency = Currency.of(message.getString(CURRENCY_FIELD));
final int spotLag = message.getInt(SPOT_LAG_FIELD);
final DayCount dayCount =
DayCountFactory.INSTANCE.getDayCount(message.getString(DAY_COUNT_FIELD));
final BusinessDayConvention businessDayConvention =
BusinessDayConventionFactory.INSTANCE.getBusinessDayConvention(
message.getString(BUSINESS_DAY_CONVENTION_FIELD));
final boolean isEOM = message.getBoolean(EOM_FIELD);
final Period tenor = Period.parse(message.getString(TENOR_FIELD));
final String name = message.getString(NAME_FIELD);
return new IborIndex(currency, tenor, spotLag, dayCount, businessDayConvention, isEOM, name);
}
