示例#1
1
 /**
  * checks if a particular chained task is ready for processing
  *
  * @param chain_id the id this process is part off order
  * @param process_id the process_id
  * @return
  * @throws java.sql.SQLException
  */
 public boolean canExecute(int chain_id, int process_id) throws SQLException {
   boolean isReady = false;
   try (AutoCloseableDBConnection c = new AutoCloseableDBConnection();
       PreparedStatement getChain =
           c.prepareStatement(
               "SELECT process_id,busy FROM chain_activities WHERE (chain_id=?) ORDER BY process_id")) {
     getChain.setInt(1, chain_id);
     LinkedHashMap<Integer, Boolean> clearedToRunMap = new LinkedHashMap<>();
     try (ResultSet executeQuery = getChain.executeQuery()) {
       while (executeQuery.next()) {
         clearedToRunMap.put(executeQuery.getInt("process_id"), executeQuery.getBoolean("busy"));
       }
     }
     int predecessingProcess = -1;
     for (Entry<Integer, Boolean> aProcess : clearedToRunMap.entrySet()) {
       if (aProcess.getKey() == process_id) {
         break;
       } else {
         predecessingProcess = aProcess.getKey();
         // check if this process is already busy
       }
     }
     if (predecessingProcess == -1) {
       // then there's no predecessing process, meaning it can be run for sure
       isReady = true;
     } else if (clearedToRunMap.get(predecessingProcess)) {
       try ( // then it's busy, but it can be that it's not yet done !
       ProcessDAO pdao = ProcessDAO.getInstance()) {
         isReady = pdao.isCompletedProcess(process_id);
       }
     }
   }
   return isReady;
 }
 public void stopSingleSongs() {
   for (Entry<Song, PlayerController> entry : singleSongPlayers.entrySet()) {
     PlayerController controller = entry.getValue();
     controller.close(true);
   }
   singleSongPlayers.clear();
 }
示例#3
0
 public void setStaticUserProperties(final Map<String, String> staticUserPropertiesMap) {
   // trim map
   staticUserProperties = new HashMap<String, String>();
   for (final Entry<String, String> entry : staticUserPropertiesMap.entrySet()) {
     staticUserProperties.put(entry.getKey().trim(), entry.getValue().trim());
   }
 }
  /**
   * Test with a subtitle with multiple format to read.
   *
   * @throws IOException if there was an I/O error.
   */
  @Test
  public void testMultipleFormatSubtitle() throws IOException {
    final SubtitleFormat subtitleFormat = mock(SubtitleFormat.class);
    final SubtitleReader subtitleReader = mock(SubtitleReader.class);
    final SubtitleFile subtitleFile = mock(SubtitleFile.class);
    final Path file = subtitleFolder.newFile("single.srt").toPath();

    when(subtitleFormatManager.getFormatByPath(file))
        .thenReturn(new HashSet<>(Arrays.asList(subtitleFormat, mock(SubtitleFormat.class))));
    when(userPrompt.askChoice(
            anyCollectionOf(SubtitleFormat.class),
            eq(TRANSLATION_KEY.chooseSubtitleFormat()),
            eq(file)))
        .thenReturn(subtitleFormat);
    when(subtitleFormat.getReader()).thenReturn(subtitleReader);
    when(subtitleReader.readFile(file)).thenReturn(subtitleFile);
    final Map<SubtitleFile, SubtitleFormat> subtitles = subtitleProvider.loadSubtitles(file);
    assertEquals(1, subtitles.size());
    final Entry<SubtitleFile, SubtitleFormat> loaded = subtitles.entrySet().iterator().next();
    assertEquals(subtitleFile, loaded.getKey());
    assertEquals(subtitleFormat, loaded.getValue());
    verify(userPrompt)
        .askChoice(
            anyCollectionOf(SubtitleFormat.class),
            eq(TRANSLATION_KEY.chooseSubtitleFormat()),
            eq(file));
  }
  /** Saves the defaults and missing values. */
  public void save() {
    if (!this.folder.exists()) {
      this.folder.mkdirs();
    }

    if (!this.file.exists()) {
      try {
        this.file.createNewFile();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }

    this.config = YamlConfiguration.loadConfiguration(this.file);
    for (Entry<String, Object> en : this.defaults.entrySet()) {
      if (!this.config.contains(en.getKey())) {
        ConfigUtils.setObject(this.config, en.getKey(), en.getValue());
      }
    }

    try {
      this.config.save(this.file);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
示例#6
0
  @Override
  @SuppressWarnings("unchecked")
  public <T> T promptChoice(final String message, final Map<String, T> options) {
    println(message);
    List<Entry<String, T>> entries = new ArrayList<Map.Entry<String, T>>();
    entries.addAll(options.entrySet());

    Object result = InvalidInput.INSTANCE;
    while (result instanceof InvalidInput) {
      int count = 1;
      println();
      for (Entry<String, T> entry : entries) {
        println("  " + count + " - [" + entry.getKey() + "]");
        count++;
      }
      println();
      String input = prompt("Choose an option by typing the name or number of the selection: ");
      if (options.containsKey(input)) {
        result = options.get(input);
      } else if (input.matches("[0-9]+")) {
        int choice = Integer.parseInt(input);
        if ((choice > 0) && (choice <= options.size())) {
          result = entries.get(choice - 1).getValue();
        }
      }
    }
    return (T) result;
  }
  /** {@inheritDoc} */
  @Override
  public void setup(OAuth2Settings settings) throws OAuth2SettingsException {
    /* validate supplied settings */
    if (settings == null) {
      throw new OAuth2SettingsException("Missing settings.");
    }
    if (Utils.isNullOrEmpty(settings.getTokenUri())) {
      throw new OAuth2SettingsException("Token server URI missing.");
    } else {
      tokenServer = settings.getTokenUri();
    }
    if (Utils.isNullOrEmpty(settings.getRefreshToken())) {
      throw new OAuth2SettingsException("Refresh token cannot be null or empty.");
    }
    if (Utils.isNullOrEmpty(settings.getClientId())) {
      throw new OAuth2SettingsException("Client ID cannot be null or empty.");
    }
    if (settings.getClientSecret() != null) {
      tokenParams.put("client_secret", settings.getClientSecret());
    }
    if (!Utils.isNullOrEmpty(settings.getScope())) {
      tokenParams.put("scope", settings.getScope());
    }

    /* populate token request params */
    tokenParams.put("client_id", settings.getClientId());
    tokenParams.put("grant_type", "refresh_token");
    tokenParams.put("refresh_token", settings.getRefreshToken());
    for (Entry<String, String> entry : settings.getExtraTokenParams().entrySet()) {
      if (!tokenParams.containsKey(entry.getKey())) {
        tokenParams.put(entry.getKey(), entry.getValue());
      }
    }
  }
示例#8
0
  private static Map<String, Double> sortByComparator(
      Map<String, Double> map, final boolean order) {
    List<Entry<String, Double>> list = new LinkedList<Entry<String, Double>>(map.entrySet());

    // Sorting the list based on values
    Collections.sort(
        list,
        new Comparator<Entry<String, Double>>() {
          public int compare(Entry<String, Double> o1, Entry<String, Double> o2) {
            if (order) {
              return o1.getValue().compareTo(o2.getValue());
            } else {
              return o2.getValue().compareTo(o1.getValue());
            }
          }
        });

    // Maintaining insertion order with the help of LinkedList
    Map<String, Double> sortedMap = new LinkedHashMap<String, Double>();
    for (Entry<String, Double> entry : list) {
      sortedMap.put(entry.getKey(), entry.getValue());
    }

    return sortedMap;
  }
 public void loadProperties(InputStream in) throws IOException {
   Properties props = new Properties();
   props.load(in);
   for (Entry<Object, Object> prop : props.entrySet()) {
     properties.put(prop.getKey().toString(), prop.getValue().toString());
   }
 }
 /**
  * Computes the m matrix with one setup (you should execute it with the other setup too).
  *
  * @param root The ancestor of {@code w}, {@code x} nodes. ({@code v}).
  * @param d Distance matrix.
  * @param w The left node of {@code root}.
  * @param x The right node of {@code root}.
  * @param rightM The subtable for the right m.
  * @param ret The result table.
  * @param leftKeys The leaves of {@code w} tree.
  * @param rightKeys The leaves of {@code x} tree.
  */
 private void computeM(
     final DendrogramNode root,
     final Map<RowKey, DistanceVectorDataValue> d,
     final DendrogramNode w,
     final DendrogramNode x,
     final Map<Triple<DendrogramNode, RowKey, RowKey>, Number> rightM,
     final Map<Triple<DendrogramNode, RowKey, RowKey>, Number> ret,
     final Set<RowKey> leftKeys,
     final Set<RowKey> rightKeys) {
   final Map<RowKey, Map<RowKey, Number>> t = computeT(w, ret, d, leftKeys, rightKeys);
   for (final Entry<RowKey, Map<RowKey, Number>> entry : t.entrySet()) {
     for (final Entry<RowKey, Number> innerEntry : entry.getValue().entrySet()) {
       double max = Double.NEGATIVE_INFINITY;
       for (final RowKey l : rightKeys) {
         final Triple<DendrogramNode, RowKey, RowKey> key =
             Triple.apply(x, l, innerEntry.getKey());
         if (!rightM.containsKey(key)) {
           continue;
         }
         final double alternative =
             entry.getValue().get(l).doubleValue() + rightM.get(key).doubleValue();
         if (alternative > max) {
           max = alternative;
         }
       }
       ret.put(Triple.apply(root, entry.getKey(), innerEntry.getKey()), Double.valueOf(max));
     }
   }
 }
  private static void buildTextQueryPart(
      Query query, Map<IQueryField, ComboViewer> operators, Map<IQueryField, Text> values) {
    for (Entry<IQueryField, Text> entry : values.entrySet()) {
      IQueryField queryField = entry.getKey();
      Text text = entry.getValue();
      ComboViewer opCombo = operators.get(queryField);

      IStructuredSelection selection = (IStructuredSelection) opCombo.getSelection();
      if (selection.getFirstElement() instanceof CompareOperator) {
        CompareOperator operator = (CompareOperator) selection.getFirstElement();
        if (queryField instanceof CustomField) {
          CustomField customField = (CustomField) queryField;
          if (customField.getFieldFormat() == CustomField.Format.BOOL) {
            query.addFilter(
                customField,
                QueryField.BOOLEAN_TYPE,
                operator,
                IRedmineConstants.BOOLEAN_TRUE_SUBMIT_VALUE);
          } else {
            QueryField definition = customField.getQueryField();
            query.addFilter(customField, definition, operator, text.getText().trim());
          }
        } else {
          query.addFilter((QueryField) queryField, operator, text.getText().trim());
        }
      }
    }
  }
  public static void restoreTextQueryPart(
      Query query,
      Configuration configuration,
      Map<IQueryField, ComboViewer> operators,
      Map<IQueryField, Text> values) {
    for (Entry<IQueryField, Text> entry : values.entrySet()) {
      IQueryField queryField = entry.getKey();
      QueryFilter queryFilter = query.getQueryFilter(queryField);
      if (queryFilter == null) {
        continue;
      }

      Text control = entry.getValue();
      ComboViewer operatorCombo = operators.get(queryField);

      operatorCombo.setSelection(new StructuredSelection(queryFilter.getOperator()));
      if (queryFilter.getOperator().isValueBased()) {
        control.setEnabled(true);

        List<String> filterValues = queryFilter.getValues();
        if (filterValues.size() > 0) {
          control.setText(filterValues.get(0));
        }
      }
    }
  }
示例#13
0
 void save() throws FatalStorageException {
   if (!loaded) {
     return;
   }
   CommittableOutputStream cos = null;
   ATRWriter w = null;
   try {
     cos = l.getOutputStream();
     w = new ATRWriter(cos.stream());
     for (Entry<String, String> kv : __kv.entrySet()) {
       w.startRecord();
       w.write(kv.getKey());
       w.write(kv.getValue());
       w.endRecord();
     }
     w.flush();
   } catch (Exception e) {
     cos.abort();
     throw new FatalStorageException("Unable to save data to " + l.getName() + ".", e);
   } finally {
     try {
       w.close();
     } catch (Exception e) {
     }
     try {
       cos.commitIfNotAborted();
     } catch (Exception e) {
       throw new FatalStorageException("Unable to save data to " + l.getName() + ".", e);
     }
   }
 }
 /**
  * 将当前页面解析到的字段传递给新的request
  *
  * @param page
  * @param nextRequest
  */
 private void transmitResultItem(Page page, Request nextRequest) {
   // 将当前page解析下来的字段转交到nextRequest中
   Map<String, Object> fields = page.getResultItems().getAll();
   for (Entry<String, Object> entry : fields.entrySet()) {
     nextRequest.addInheritField(entry.getKey(), entry.getValue());
   }
 }
  @MapFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemovePropagatesToAsMapEntrySet() {
    List<Entry<K, V>> entries = Helpers.copyToList(multimap().entries());
    for (Entry<K, V> entry : entries) {
      resetContainer();

      K key = entry.getKey();
      V value = entry.getValue();

      Iterator<Entry<K, Collection<V>>> asMapItr = multimap().asMap().entrySet().iterator();
      Collection<V> collection = null;
      while (asMapItr.hasNext()) {
        Entry<K, Collection<V>> asMapEntry = asMapItr.next();
        if (key.equals(asMapEntry.getKey())) {
          collection = asMapEntry.getValue();
          break;
        }
      }
      assertNotNull(collection);
      Collection<V> expectedCollection = Helpers.copyToList(collection);

      multimap().remove(key, value);
      expectedCollection.remove(value);

      ASSERT.that(collection).hasContentsAnyOrder(expectedCollection.toArray());
      assertEquals(!expectedCollection.isEmpty(), multimap().containsKey(key));
    }
  }
示例#16
0
  @SuppressWarnings("unchecked")
  private void processNextNode() {
    if (stateStack.isEmpty()) {
      nextEvent = null;
      return;
    }

    currentItr = stateStack.peek();
    if (currentItr.hasNext()) {
      Object o = currentItr.next();
      if (inMap()) {
        Entry<String, HValue> entry = (Entry<String, HValue>) o;
        key = entry.getKey();
        value = entry.getValue();
      } else {
        key = null;
        value = HValue.initFromObject(o);
      }
      nextEvent = Types.getEventTypeForType(value.getType());
      if (!value.getType().isScalar()) {
        stateStack.push(new IteratorWithType(value));
      }
    } else {
      IteratorWithType iter = stateStack.pop();
      key = null;
      value = iter.getValue();
      nextEvent = (iter.getType() == Type.MAP) ? EventType.END_MAP : EventType.END_ARRAY;
      currentItr = stateStack.isEmpty() ? null : stateStack.peek();
    }
  }
  private void doMatches(Map<String, Object> ret, BagQueryResult bqr) {

    for (Entry<Integer, List> pair : bqr.getMatches().entrySet()) {
      Map<String, Object> resultItem;
      InterMineObject imo;
      try {
        imo = im.getObjectStore().getObjectById(pair.getKey());
      } catch (ObjectStoreException e) {
        throw new IllegalStateException("Could not retrieve object reported as match", e);
      }
      String idKey = String.valueOf(imo.getId());
      if (ret.containsKey(idKey)) {
        resultItem = (Map<String, Object>) ret.get(idKey);
      } else {
        resultItem = new HashMap<String, Object>();
        resultItem.put("identifiers", new HashMap<String, Object>());
      }
      if (!resultItem.containsKey("summary")) {
        resultItem.put("summary", getObjectDetails(imo));
      }
      Map<String, Object> identifiers = (Map<String, Object>) resultItem.get("identifiers");
      for (Object o : pair.getValue()) {
        String ident = (String) o;
        if (!identifiers.containsKey(ident)) {
          identifiers.put(ident, new HashSet<String>());
        }
        Set<String> categories = (Set<String>) identifiers.get(ident);
        categories.add("MATCH");
      }
      String className = DynamicUtil.getSimpleClassName(imo.getClass());
      resultItem.put("type", className.replaceAll("^.*\\.", ""));
      ret.put(idKey, resultItem);
    }
  }
示例#18
0
 /**
  * Check the logged out players for if any data can be removed.<br>
  * Currently only "dumb" full removal is performed. Later it is thinkable to remove "as much as
  * reasonable".
  */
 public void checkExpiration() {
   if (durExpireData <= 0) return;
   final long now = System.currentTimeMillis();
   final Set<CheckDataFactory> factories = new LinkedHashSet<CheckDataFactory>();
   final Set<Entry<String, Long>> entries = lastLogout.entrySet();
   final Iterator<Entry<String, Long>> iterator = entries.iterator();
   while (iterator.hasNext()) {
     final Entry<String, Long> entry = iterator.next();
     final long ts = entry.getValue();
     if (now - ts <= durExpireData) break;
     final String playerName = entry.getKey();
     if (deleteData) {
       factories.clear();
       for (final CheckType type : CheckType.values()) {
         final CheckDataFactory factory = type.getDataFactory();
         if (factory != null) factories.add(factory);
       }
       for (final CheckDataFactory factory : factories) {
         factory.removeData(playerName);
       }
       clearComponentData(CheckType.ALL, playerName);
     }
     if (deleteData || deleteHistory) removeExecutionHistory(CheckType.ALL, playerName);
     if (deleteHistory) ViolationHistory.removeHistory(playerName);
     iterator.remove();
   }
 }
  /**
   * {@link PersistentSnapshotDeletionPolicy} wraps another {@link IndexDeletionPolicy} to enable
   * flexible snapshotting.
   *
   * @param primary the {@link IndexDeletionPolicy} that is used on non-snapshotted commits.
   *     Snapshotted commits, by definition, are not deleted until explicitly released via {@link
   *     #release(String)}.
   * @param dir the {@link Directory} which will be used to persist the snapshots information.
   * @param mode specifies whether a new index should be created, deleting all existing snapshots
   *     information (immediately), or open an existing index, initializing the class with the
   *     snapshots information.
   * @param matchVersion specifies the {@link Version} that should be used when opening the
   *     IndexWriter.
   */
  public PersistentSnapshotDeletionPolicy(
      IndexDeletionPolicy primary, Directory dir, OpenMode mode, Version matchVersion)
      throws CorruptIndexException, LockObtainFailedException, IOException {
    super(primary, null);

    // Initialize the index writer over the snapshot directory.
    writer = new IndexWriter(dir, new IndexWriterConfig(matchVersion, null).setOpenMode(mode));
    if (mode != OpenMode.APPEND) {
      // IndexWriter no longer creates a first commit on an empty Directory. So
      // if we were asked to CREATE*, call commit() just to be sure. If the
      // index contains information and mode is CREATE_OR_APPEND, it's a no-op.
      writer.commit();
    }

    try {
      // Initializes the snapshots information. This code should basically run
      // only if mode != CREATE, but if it is, it's no harm as we only open the
      // reader once and immediately close it.
      for (Entry<String, String> e : readSnapshotsInfo(dir).entrySet()) {
        registerSnapshotInfo(e.getKey(), e.getValue(), null);
      }
    } catch (RuntimeException e) {
      writer.close(); // don't leave any open file handles
      throw e;
    } catch (IOException e) {
      writer.close(); // don't leave any open file handles
      throw e;
    }
  }
 @Override
 public String analyze(Iterable<Mutation> mutations, HtmlReport report) {
   List<String> lines = new ArrayList<String>();
   for (Mutation mutation : mutations) {
     if (mutation.isKilled()) {
       MutationTestResult result = mutation.getMutationResult();
       Set<TestMessage> detecting = new HashSet<TestMessage>();
       Collection<TestMessage> failures = result.getFailures();
       detecting.addAll(failures);
       Collection<TestMessage> errors = result.getErrors();
       detecting.addAll(errors);
       String tests = getIds(detecting);
       String line = mutation.getId() + "," + tests;
       lines.add(line);
     }
   }
   Set<Entry<String, Integer>> entrySet = testsIds.entrySet();
   lines.add("Ids");
   for (Entry<String, Integer> entry : entrySet) {
     lines.add(entry.getKey() + "," + entry.getValue());
   }
   try {
     FileUtils.writeLines(new File("detectedByTest.csv"), lines);
   } catch (IOException e) {
     e.printStackTrace();
   }
   return Joiner.on("\n").join(lines);
 }
 @Override
 public LocalDateDoubleTimeSeries evaluate(final LocalDateDoubleTimeSeries... x) {
   testInputData(x);
   if (x.length > 2) {
     s_logger.info("Have more than two time series in array; only using first two");
   }
   final FastIntDoubleTimeSeries ts1 = (FastIntDoubleTimeSeries) x[0].getFastSeries();
   final FastIntDoubleTimeSeries ts2 = (FastIntDoubleTimeSeries) x[1].getFastSeries();
   final int n = ts1.size();
   final int[] times = new int[n];
   final double[] returns = new double[n];
   final Iterator<Entry<Integer, Double>> iter1 = ts1.iterator();
   Entry<Integer, Double> entry1;
   Double value2;
   Integer t;
   int i = 0;
   while (iter1.hasNext()) {
     entry1 = iter1.next();
     t = entry1.getKey();
     value2 = ts2.getValue(t);
     if (value2 == null || Math.abs(value2) < ZERO) {
       if (getMode().equals(CalculationMode.STRICT)) {
         throw new TimeSeriesException("No data in second series for time " + t);
       }
     } else {
       times[i] = entry1.getKey();
       returns[i++] = Math.log(entry1.getValue() / value2);
     }
   }
   return getSeries(x[0], times, returns, i);
 }
示例#22
0
 /**
  * POSTs the variables and returns the body
  *
  * @param url - fully qualified and encoded URL to post to
  * @param params
  * @return
  */
 public String doPost(String url, Map<String, String> params)
     throws com.ettrema.httpclient.HttpException, NotAuthorizedException, ConflictException,
         BadRequestException, NotFoundException {
   notifyStartRequest();
   HttpPost m = new HttpPost(url);
   List<NameValuePair> formparams = new ArrayList<NameValuePair>();
   for (Entry<String, String> entry : params.entrySet()) {
     formparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
   }
   UrlEncodedFormEntity entity;
   try {
     entity = new UrlEncodedFormEntity(formparams);
   } catch (UnsupportedEncodingException ex) {
     throw new RuntimeException(ex);
   }
   m.setEntity(entity);
   try {
     ByteArrayOutputStream bout = new ByteArrayOutputStream();
     int res = Utils.executeHttpWithStatus(client, m, bout);
     Utils.processResultCode(res, url);
     return bout.toString();
   } catch (HttpException ex) {
     throw new RuntimeException(ex);
   } catch (IOException ex) {
     throw new RuntimeException(ex);
   } finally {
     notifyFinishRequest();
   }
 }
  public void loadSemanticModule(Properties properties) {
    String uri = properties.getProperty("uri", null);
    if (uri == null || uri.trim().equals("")) {
      throw new RuntimeException("Semantic Module URI property must not be empty");
    }

    DefaultSemanticModule module = new DefaultSemanticModule(uri);

    for (Entry<Object, Object> entry : properties.entrySet()) {
      String elementName = (String) entry.getKey();

      // uri is processed above, so skip
      if ("uri".equals(elementName)) {
        continue;
      }

      if (elementName == null || elementName.trim().equals("")) {
        throw new RuntimeException("Element name must be specified for Semantic Module handler");
      }
      String handlerName = (String) entry.getValue();
      if (handlerName == null || handlerName.trim().equals("")) {
        throw new RuntimeException("Handler name must be specified for Semantic Module");
      }

      Handler handler = (Handler) ClassUtils.instantiateObject(handlerName, this.classLoader);

      if (handler == null) {
        throw new RuntimeException(
            "Unable to load Semantic Module handler '" + elementName + ":" + handlerName + "'");
      } else {
        module.addHandler(elementName, handler);
      }
    }
    this.semanticModules.addSemanticModule(module);
  }
 private Instance getConnectorConfiguration(Model model, StringToExpressionConverter converter) {
   final Instance configuration =
       model.newInstance("connectorconfiguration.ConnectorConfiguration");
   configuration.set("definitionId", getDefinitionId());
   configuration.set("version", getDefinitionVersion());
   final Map<String, Object> additionalInputs = definitionMapper.getAdditionalInputs(inputs);
   final Map<String, Object> allInput = new HashMap<String, Object>(inputs);
   allInput.putAll(additionalInputs);
   for (Entry<String, Object> input : allInput.entrySet()) {
     final String parameterKeyFor = getParameterKeyFor(input.getKey());
     if (parameterKeyFor != null) {
       final Instance parameter = model.newInstance("connectorconfiguration.ConnectorParameter");
       parameter.set("key", parameterKeyFor);
       parameter.set(
           "expression",
           getParameterExpressionFor(
               model,
               parameterKeyFor,
               converter,
               definitionMapper.transformParameterValue(parameterKeyFor, input.getValue(), inputs),
               getReturnType(parameterKeyFor)));
       configuration.add("parameters", parameter);
     } else {
       if (BonitaStudioLog.isLoggable(IStatus.OK)) {
         BonitaStudioLog.debug(
             input.getKey() + " not mapped for " + getDefinitionId(), BarImporterPlugin.PLUGIN_ID);
       }
     }
   }
   return configuration;
 }
示例#25
0
  /**
   * Method to determine a comple argument based on the dependency declared by an argument. The
   * method calls a recursive method that searches in each line of the processed sentence for the
   * dependency declared and dependencies of each depency
   *
   * @param arg - The original argument
   * @param sentenceLines - all lines of the SRL file that compse the processed sentence
   */
  private static void preDetermineFullArg(SemanticRelationArgument arg, String[] sentenceLines) {
    TreeMap<Integer, ArgumentTerm> parts = new TreeMap<Integer, ArgumentTerm>();
    parts.put(
        arg.getArgLine(),
        new ArgumentTerm(arg.getShortArg(), arg.getShortArgLemma(), arg.getShortArgPosTag()));

    // call to recursive method
    parts.putAll(retrieveDependentArgs(parts, sentenceLines));

    // build a string based on all dependencies found and populate the array of ArgumentTerms
    // The TreeMap guarantees that the words are read in order, since
    // the nodes are ordered by the line ID
    String fullArg = "";
    int firstWordLine = arg.getArgLine();
    for (Entry<Integer, ArgumentTerm> part : parts.entrySet()) {

      // Add ArgumentTerm to array of ArgumentTerm objects
      arg.getArgumentTerms().add(part.getValue());

      fullArg += part.getValue().getWord() + " ";
      // check if the argument actually begins prior the argument lead
      if (part.getKey() < firstWordLine) {
        firstWordLine = part.getKey();
      }
    }

    arg.setArgLine(firstWordLine);
    arg.setFullArg(fullArg);
  }
示例#26
0
 public String getURL() {
   String url = this.baseURL + "?source=" + this.superid;
   for (Entry<String, String> temp : params.entrySet()) {
     url += "&" + temp.getKey() + "=" + temp.getValue();
   }
   return url;
 }
示例#27
0
 public void setReqAttrs(final Map<String, String> reqAttrs) {
   // trim map
   reqAttr = new HashMap<String, String>();
   for (final Entry<String, String> entry : reqAttrs.entrySet()) {
     reqAttr.put(entry.getKey().trim(), entry.getValue().trim());
   }
 }
示例#28
0
 public void cleanup(Context context) throws IOException, InterruptedException { // close
   for (Entry<String, Integer> entry : wordMap.entrySet()) {
     word.set(entry.getKey());
     counter.set(entry.getValue());
     context.write(word, counter);
   }
 }
 /**
  * @param format
  * @param bindings
  * @return formatted commit name
  */
 public static String formatName(final String format, Map<String, String> bindings) {
   String result = format;
   for (Entry<String, String> e : bindings.entrySet()) {
     result = result.replace(e.getKey(), e.getValue());
   }
   return result;
 }
示例#30
0
  public static void writePropagationContexts(MarshallerWriteContext context) throws IOException {
    ObjectOutputStream stream = context.stream;

    if (context.terminalTupleMap != null && context.terminalTupleMap.size() > 0) {
      Entry<LeftTuple, Integer>[] entries =
          context.terminalTupleMap.entrySet().toArray(new Entry[context.terminalTupleMap.size()]);
      Arrays.sort(entries, TupleSorter.instance);

      // Map<LeftTuple, Integer> tuples = context.terminalTupleMap;
      if (entries.length != 0) {
        Map<Long, PropagationContext> pcMap = new HashMap<Long, PropagationContext>();
        for (Entry<LeftTuple, Integer> entry : entries) {
          LeftTuple leftTuple = entry.getKey();
          if (leftTuple.getObject() != null) {
            PropagationContext pc = ((Activation) leftTuple.getObject()).getPropagationContext();
            if (!pcMap.containsKey(pc.getPropagationNumber())) {
              stream.writeShort(PersisterEnums.PROPAGATION_CONTEXT);
              writePropagationContext(context, pc);
              pcMap.put(pc.getPropagationNumber(), pc);
            }
          }
        }
      }
    }

    stream.writeShort(PersisterEnums.END);
  }