Examples of org.fudgemsg.FudgeMsg

org.fudgemsg.FudgeMsg

  @Override
  public CurveSpecificationBuilderConfiguration buildObject(final FudgeDeserializer deserializer, final FudgeMsg message) {
    Map<Tenor, CurveInstrumentProvider> cashInstrumentProviders = null;
    if (message.hasField(CASH)) {
      cashInstrumentProviders = new HashMap<>();
      final FudgeMsg cashInstrumentProvidersMessage = message.getMessage(CASH);
      for (final FudgeField field : cashInstrumentProvidersMessage.getAllFields()) {
        cashInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    if (message.hasField(FRA_3M) && message.hasField(FRA)) {
      throw new OpenGammaRuntimeException("Have message with the old FRA field and the new FRA_3M field: should not happen");
    }


    Map<Tenor, CurveInstrumentProvider> fra3MInstrumentProviders = null;
    if (message.hasField(FRA)) {
      // Treat all old definitions as if they were 3m FRA rates
      final FudgeMsg fraInstrumentProvidersMessage = message.getMessage(FRA);
      fra3MInstrumentProviders = new HashMap<>();
      for (final FudgeField field : fraInstrumentProvidersMessage.getAllFields()) {
        fra3MInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    } else if (message.hasField(FRA_3M)) {
      fra3MInstrumentProviders = new HashMap<>();
      final FudgeMsg fra3MInstrumentProvidersMessage = message.getMessage(FRA_3M);
      for (final FudgeField field : fra3MInstrumentProvidersMessage.getAllFields()) {
        fra3MInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    if (message.hasField(FRA_6M) && message.hasField(FRA)) {
      throw new OpenGammaRuntimeException("Have message with the old FRA field and the new FRA_6M field: should not happen");
    }


    Map<Tenor, CurveInstrumentProvider> fra6MInstrumentProviders = null;
    if (message.hasField(FRA_6M)) {
      fra6MInstrumentProviders = new HashMap<>();
      final FudgeMsg fra6MInstrumentProvidersMessage = message.getMessage(FRA_6M);
      for (final FudgeField field : fra6MInstrumentProvidersMessage.getAllFields()) {
        fra6MInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    Map<Tenor, CurveInstrumentProvider> futureInstrumentProviders = null;
    if (message.hasField(FUTURE)) {
      futureInstrumentProviders = new HashMap<>();
      final FudgeMsg futureInstrumentProvidersMessage = message.getMessage(FUTURE);
      for (final FudgeField field : futureInstrumentProvidersMessage.getAllFields()) {
        futureInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }
    if (message.hasField(RATE) && message.hasField(LIBOR)) {
      throw new OpenGammaRuntimeException("Have message with old RATE field and new LIBOR field: should not happen");
    }


    Map<Tenor, CurveInstrumentProvider> liborInstrumentProviders = null;
    if (message.hasField(RATE)) {
      // Treat all old definitions as if they were Libor rates
      liborInstrumentProviders = new HashMap<>();
      final FudgeMsg rateInstrumentProvidersMessage = message.getMessage(RATE);
      for (final FudgeField field : rateInstrumentProvidersMessage.getAllFields()) {
        liborInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    } else if (message.hasField(LIBOR)) {
      liborInstrumentProviders = new HashMap<>();
      final FudgeMsg liborInstrumentProvidersMessage = message.getMessage(LIBOR);
      for (final FudgeField field : liborInstrumentProvidersMessage.getAllFields()) {
        liborInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    if (message.hasField(RATE) && message.hasField(EURIBOR)) {
      throw new OpenGammaRuntimeException("Have message with old RATE field and new EURIBOR field: should not happen");
    }


    Map<Tenor, CurveInstrumentProvider> euriborInstrumentProviders = null;
    if (message.hasField(EURIBOR)) {
      euriborInstrumentProviders = new HashMap<>();
      final FudgeMsg euriborInstrumentProvidersMessage = message.getMessage(EURIBOR);
      for (final FudgeField field : euriborInstrumentProvidersMessage.getAllFields()) {
        euriborInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    Map<Tenor, CurveInstrumentProvider> cdorInstrumentProviders = null;
    if (message.hasField(CDOR)) {
      cdorInstrumentProviders = new HashMap<>();
      final FudgeMsg cdorInstrumentProvidersMessage = message.getMessage(CDOR);
      for (final FudgeField field : cdorInstrumentProvidersMessage.getAllFields()) {
        cdorInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    Map<Tenor, CurveInstrumentProvider> ciborInstrumentProviders = null;
    if (message.hasField(CIBOR)) {
      ciborInstrumentProviders = new HashMap<>();
      final FudgeMsg ciborInstrumentProvidersMessage = message.getMessage(CIBOR);
      for (final FudgeField field : ciborInstrumentProvidersMessage.getAllFields()) {
        ciborInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    Map<Tenor, CurveInstrumentProvider> stiborInstrumentProviders = null;
    if (message.hasField(STIBOR)) {
      stiborInstrumentProviders = new HashMap<>();
      final FudgeMsg stiborInstrumentProvidersMessage = message.getMessage(STIBOR);
      for (final FudgeField field : stiborInstrumentProvidersMessage.getAllFields()) {
        stiborInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    if (message.hasField(SWAP) && message.hasField(SWAP_3M)) {
      throw new OpenGammaRuntimeException("Have message with old SWAP field and new SWAP_3M field: should not happen");
    }


    Map<Tenor, CurveInstrumentProvider> swap3MInstrumentProviders = null;
    if (message.hasField(SWAP)) {
      // Treat all old definitions as if they were swaps with 3m floating legs
      swap3MInstrumentProviders = new HashMap<>();
      final FudgeMsg swapInstrumentProvidersMessage = message.getMessage(SWAP);
      for (final FudgeField field : swapInstrumentProvidersMessage.getAllFields()) {
        swap3MInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    } else if (message.hasField(SWAP_3M)) {
      swap3MInstrumentProviders = new HashMap<>();
      final FudgeMsg swap3MInstrumentProvidersMessage = message.getMessage(SWAP_3M);
      for (final FudgeField field : swap3MInstrumentProvidersMessage.getAllFields()) {
        swap3MInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    if (message.hasField(SWAP) && message.hasField(SWAP_6M)) {
      throw new OpenGammaRuntimeException("Have message with old SWAP field and new SWAP_6M field: should not happen");
    }


    Map<Tenor, CurveInstrumentProvider> swap6MInstrumentProviders = null;
    if (message.hasField(SWAP_6M)) {
      swap6MInstrumentProviders = new HashMap<>();
      final FudgeMsg swap6MInstrumentProvidersMessage = message.getMessage(SWAP_6M);
      for (final FudgeField field : swap6MInstrumentProvidersMessage.getAllFields()) {
        swap6MInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    Map<Tenor, CurveInstrumentProvider> swap12MInstrumentProviders = null;
    if (message.hasField(SWAP_12M)) {
      swap12MInstrumentProviders = new HashMap<>();
      final FudgeMsg swap12MInstrumentProvidersMessage = message.getMessage(SWAP_12M);
      for (final FudgeField field : swap12MInstrumentProvidersMessage.getAllFields()) {
        swap12MInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    Map<Tenor, CurveInstrumentProvider> swap28DInstrumentProviders = null;
    if (message.hasField(SWAP_28D)) {
      swap28DInstrumentProviders = new HashMap<>();
      final FudgeMsg swap28DInstrumentProvidersMessage = message.getMessage(SWAP_28D);
      for (final FudgeField field : swap28DInstrumentProvidersMessage.getAllFields()) {
        swap28DInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    Map<Tenor, CurveInstrumentProvider> basisSwapInstrumentProviders = null;
    if (message.hasField(BASIS_SWAP)) {
      basisSwapInstrumentProviders = new HashMap<>();
      final FudgeMsg basisSwapInstrumentProvidersMessage = message.getMessage(BASIS_SWAP);
      for (final FudgeField field : basisSwapInstrumentProvidersMessage.getAllFields()) {
        basisSwapInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    Map<Tenor, CurveInstrumentProvider> tenorSwapInstrumentProviders = null;
    if (message.hasField(TENOR_SWAP)) {
      tenorSwapInstrumentProviders = new HashMap<>();
      final FudgeMsg tenorSwapInstrumentProvidersMessage = message.getMessage(TENOR_SWAP);
      for (final FudgeField field : tenorSwapInstrumentProvidersMessage.getAllFields()) {
        tenorSwapInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    Map<Tenor, CurveInstrumentProvider> oisSwapInstrumentProviders = null;
    if (message.hasField(OIS_SWAP)) {
      final FudgeMsg oisSwapInstrumentProvidersMessage = message.getMessage(OIS_SWAP);
      oisSwapInstrumentProviders = new HashMap<>();
      for (final FudgeField field : oisSwapInstrumentProvidersMessage.getAllFields()) {
        oisSwapInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    Map<Tenor, CurveInstrumentProvider> simpleZeroDepositInstrumentProviders = null;
    if (message.hasField(SIMPLE_ZERO_DEPOSIT)) {
      final FudgeMsg simpleZeroDepositInstrumentProvidersMessage = message.getMessage(SIMPLE_ZERO_DEPOSIT);
      simpleZeroDepositInstrumentProviders = new HashMap<>();
      for (final FudgeField field : simpleZeroDepositInstrumentProvidersMessage.getAllFields()) {
        simpleZeroDepositInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    Map<Tenor, CurveInstrumentProvider> periodicZeroDepositInstrumentProviders = null;
    if (message.hasField(PERIODIC_ZERO_DEPOSIT)) {
      final FudgeMsg periodicZeroDepositInstrumentProvidersMessage = message.getMessage(PERIODIC_ZERO_DEPOSIT);
      periodicZeroDepositInstrumentProviders = new HashMap<>();
      for (final FudgeField field : periodicZeroDepositInstrumentProvidersMessage.getAllFields()) {
        periodicZeroDepositInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    Map<Tenor, CurveInstrumentProvider> continuousZeroDepositInstrumentProviders = null;
    if (message.hasField(CONTINUOUS_ZERO_DEPOSIT)) {
      final FudgeMsg continuousZeroDepositInstrumentProvidersMessage = message.getMessage(CONTINUOUS_ZERO_DEPOSIT);
      continuousZeroDepositInstrumentProviders = new HashMap<>();
      for (final FudgeField field : continuousZeroDepositInstrumentProvidersMessage.getAllFields()) {
        continuousZeroDepositInstrumentProviders.put(Tenor.of(DateUtils.toPeriod(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
    }


    return new CurveSpecificationBuilderConfiguration(cashInstrumentProviders, fra3MInstrumentProviders, fra6MInstrumentProviders, liborInstrumentProviders, euriborInstrumentProviders,

View Full Code Here

    return LiveDataValueUpdateBeanFudgeBuilder.fromFudgeMsg(deserializer, msg);
  }


  public static LiveDataValueUpdateBean fromFudgeMsg(FudgeDeserializer deserializer, FudgeMsg msg) {
    Long sequenceNumber = msg.getLong(SEQUENCE_NUMBER_FIELD_NAME);
    FudgeMsg specificationFields = msg.getMessage(SPECIFICATION_FIELD_NAME);
    FudgeMsg fields = msg.getMessage(FIELDS_FIELD_NAME);
    // REVIEW kirk 2009-10-28 -- Right thing to do here?
    if (sequenceNumber == null) {
      return null;
    }
    if (specificationFields == null) {

View Full Code Here

    assertEncodeDecodeCycle(Pair.class, object);
  }


  public void test_staticTypedMethods() {
    ObjectsPair<Tenor, Tenor> in = Pair.of(Tenor.DAY, Tenor.TEN_YEARS);
    FudgeMsg msg = ObjectsPairFudgeBuilder.buildMessage(getFudgeSerializer(), in, Tenor.class, Tenor.class);
    ObjectsPair<Tenor, Tenor> out = ObjectsPairFudgeBuilder.buildObject(getFudgeDeserializer(), msg, Tenor.class, Tenor.class);
    assertEquals(out, in);
    msg = cycleMessage(msg);
    out = ObjectsPairFudgeBuilder.buildObject(getFudgeDeserializer(), msg, Tenor.class, Tenor.class);
    assertEquals(out, in);

View Full Code Here

  public SecurityInfo(final ComparisonContext context, final Security security) {
    super(security);
    s_logger.debug("Extracting core information from {}", security);
    final FudgeSerializer serializer = context.getFudgeSerializer();
    serializer.reset();
    final FudgeMsg rawMsg = serializer.objectToFudgeMsg(security);
    s_logger.debug("Raw message = {}", rawMsg);
    final Iterator<FudgeField> itr = rawMsg.iterator();
    while (itr.hasNext()) {
      final FudgeField field = itr.next();
      if (ManageableSecurityFudgeBuilder.UNIQUE_ID_FIELD_NAME.equals(field.getName()) || ManageableSecurityFudgeBuilder.IDENTIFIERS_FIELD_NAME.equals(field.getName())) {
        continue;
      }

View Full Code Here

  public DependencyGraphBuildTrace buildObject(FudgeDeserializer deserializer, FudgeMsg message) {
    DependencyGraph dependencyGraph = deserializer.fudgeMsgToObject(DependencyGraph.class, message.getMessage("dependencyGraph"));
    Map<Throwable, Integer> exceptionsWithCounts = new LinkedHashMap<>();
    List<FudgeField> exceptionSubMessages = message.getAllByName("exception");
    for (FudgeField field : exceptionSubMessages) {
      FudgeMsg subMessage = (FudgeMsg) field.getValue();
      String clazzName = subMessage.getString("class");
      String exceptionMessage = subMessage.getString("message");
      Throwable throwable;
      try {
        throwable = new ThrowableWithClass(exceptionMessage, Class.forName(clazzName));
      } catch (ClassNotFoundException ex) {
        throwable = new ThrowableWithClass(exceptionMessage, null);
        s_logger.error("Exception class not found, setting exception class to null");
      }
      if (subMessage.hasField("repeat")) {
        Integer repeat = subMessage.getInt("repeat");
        if (repeat == null) {
          s_logger.error("repeat field was present, but not integer");
        }
        exceptionsWithCounts.put(throwable, repeat);
      } else {
        exceptionsWithCounts.put(throwable, 1);
      }
    }
    List<ResolutionFailure> failures = new ArrayList<>();
    List<FudgeField> failureMessages = message.getAllByName("failure");
    for (FudgeField field : failureMessages) {
      FudgeMsg subMessage = (FudgeMsg) field.getValue();
      ResolutionFailure failure = deserializer.fudgeMsgToObject(ResolutionFailure.class, subMessage);
      if (failure == null) {
        s_logger.error("Couldn't deserialize failure " + subMessage.toString());
      }
      failures.add(failure);
    }
    Map<ValueRequirement, ValueSpecification> mappings = new HashMap<>();
    FudgeField mapping = message.getByName("mapping");
    FudgeMsg mappingMsg = (FudgeMsg) mapping.getValue();
    List<FudgeField> keys = mappingMsg.getAllByOrdinal(1); // keys
    List<FudgeField> values = mappingMsg.getAllByOrdinal(2); // values
    if (keys.size() != values.size()) {
      s_logger.error("keys and values list in map don't have the same number of elements: message = {}", message);
      throw new OpenGammaRuntimeException("keys and values list in map don't have the same number of elements");
    }
    for (int i = 0; i < keys.size(); i++) { // better to use iterators?

View Full Code Here

  private static final FudgeContext s_fudgeContext = OpenGammaFudgeContext.getInstance();


  @Override
  protected <T extends ManageableSecurity> void assertSecurity(Class<T> securityClass, T security) {
    final FudgeSerializer serializer = new FudgeSerializer(s_fudgeContext);
    FudgeMsg msg = serializer.objectToFudgeMsg(security);
    s_logger.debug("Security {}", security);
    s_logger.debug("Encoded to {}", msg);
    final byte[] bytes = s_fudgeContext.toByteArray(msg);
    msg = s_fudgeContext.deserialize(bytes).getMessage();
    s_logger.debug("Serialised to to {}", msg);

View Full Code Here

    // Sort the symbols for the current index by market cap (highest to lowest), skipping any in the list of EXCLUDED_SECTORS
    final TreeMap<Double, String> equityByMarketCap = new TreeMap<Double, String>();
    final Map<String, FudgeMsg> refDataMap = referenceDataProvider.getReferenceData(memberEquities,
        Sets.newHashSet(BloombergFields.CURRENT_MARKET_CAP_FIELD, BloombergConstants.FIELD_GICS_SUB_INDUSTRY));
    for (final String equity : memberEquities) {
      final FudgeMsg fieldData = refDataMap.get(equity);
      if (fieldData == null) {
        throw new OpenGammaRuntimeException("Information not found for equity: " + equity);
      }
      final String gicsCodeString = fieldData.getString(BloombergConstants.FIELD_GICS_SUB_INDUSTRY);
      if (gicsCodeString == null) {
        continue;
      }
      final GICSCode gicsCode = GICSCode.of(gicsCodeString);
      if (EXCLUDED_SECTORS.contains(gicsCode.getSectorDescription())) {
        continue;
      }
      final Double marketCap = fieldData.getDouble(BloombergFields.CURRENT_MARKET_CAP_FIELD);
      if (marketCap != null) {
        equityByMarketCap.put(marketCap, equity);
      }
    }

View Full Code Here

  }


  public static Map<Tenor, CurveInstrumentProvider> getMapForField(final String fieldName, final FudgeDeserializer deserializer, final FudgeMsg message) {
    if (message.hasField(fieldName)) {
      final Map<Tenor, CurveInstrumentProvider> nodeIds = new HashMap<>();
      final FudgeMsg idsMessage = message.getMessage(fieldName);
      for (final FudgeField field : idsMessage.getAllFields()) {
        nodeIds.put(Tenor.of(Period.parse(field.getName())), deserializer.fieldValueToObject(CurveInstrumentProvider.class, field));
      }
      return nodeIds;
    }
    return null;

View Full Code Here


    private void loadFixed(final FudgeMsg message) {
      final Map<Pair<Currency, Currency>, CurrencyMatrixValue> values = new HashMap<Pair<Currency, Currency>, CurrencyMatrixValue>();
      for (final FudgeField field : message) {
        final Currency source = Currency.of(field.getName());
        final FudgeMsg message2 = message.getFieldValue(FudgeMsg.class, field);
        for (final FudgeField field2 : message2) {
          final Currency target = Currency.of(field2.getName());
          if (field2.getValue() instanceof Double) {
            final CurrencyMatrixValue value = CurrencyMatrixValue.of((Double) field2.getValue());
            values.put(Pair.of(source, target), value);

View Full Code Here

    FudgeMsgReader reader = null;
    try {
      FileInputStream fis = new FileInputStream(inputFile);
      reader = fudgeContext.createMessageReader(fis);
      while (reader.hasNext()) {
        FudgeMsg msg = reader.nextMessage();
        LoggedReferenceData loggedData = fudgeContext.fromFudgeMsg(LoggedReferenceData.class, msg);
        addDataToMap(fudgeContext, dataMap, loggedData);
      }
    } catch (FileNotFoundException ex) {
      throw new OpenGammaRuntimeException("Cannot open " + inputFile + " for reading");

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.fudgemsg.FudgeMsg

com.opengamma.bbg.livedata.AbstractBloombergLiveDataServer

com.opengamma.bbg.livedata.BloombergJmsTopicNameResolver

com.opengamma.bbg.livedata.LoggedReferenceDataProvider

com.opengamma.bbg.model.SecurityMasterRequestMessage

com.opengamma.bbg.referencedata.BloombergReferenceDataProviderTest

com.opengamma.bbg.RemoteBloombergSecuritySource

com.opengamma.bbg.replay.BloombergTickWriter

com.opengamma.bbg.util.BloombergDataUtils

com.opengamma.bbg.util.ReferenceDataProviderUtils

com.opengamma.core.marketdatasnapshot.impl.ManageableVolatilityCubeSnapshot

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.