예제 #1
0
  /**
   * Return a collection of intervals that intersect 'marker' Query resulting genes, transcripts and
   * exons to get ALL types of intervals possible
   *
   * @return
   */
  public Markers queryDeep(Marker marker) {
    if (Config.get().isErrorOnMissingChromo() && isChromosomeMissing(marker))
      throw new RuntimeEOFException("Chromosome missing for marker: " + marker);

    boolean hitChromo = false;
    Markers hits = new Markers();
    Markers intersects = query(marker);

    if (intersects.size() > 0) {
      for (Marker m : intersects) {
        hits.add(m);

        if (m instanceof Chromosome) {
          hitChromo = true; // OK (we have to hit a chromosome, otherwise it's an error
        } else if (m instanceof Gene) {
          // Analyze Genes
          Gene gene = (Gene) m;
          hits.addAll(gene.query(marker));
        }
      }
    }

    if (!hitChromo && Config.get().isErrorChromoHit())
      throw new RuntimeException("ERROR: Out of chromosome range. " + marker);
    return hits;
  }
예제 #2
0
 static String mapHostToRealm(String name) {
   String result = null;
   try {
     String subname = null;
     Config c = Config.getInstance();
     if ((result = c.get("domain_realm", name)) != null) return result;
     else {
       for (int i = 1; i < name.length(); i++) {
         if ((name.charAt(i) == '.')
             && (i != name.length() - 1)) { // mapping could be .ibm.com = AUSTIN.IBM.COM
           subname = name.substring(i);
           result = c.get("domain_realm", subname);
           if (result != null) {
             break;
           } else {
             subname = name.substring(i + 1); // or mapping could be ibm.com = AUSTIN.IBM.COM
             result = c.get("domain_realm", subname);
             if (result != null) {
               break;
             }
           }
         }
       }
     }
   } catch (KrbException e) {
   }
   return result;
 }
예제 #3
0
 /** Test default value. */
 public void testDefaultGet() {
   final String defaultString = "default value";
   assertEquals(defaultString, config.get("unknown", defaultString));
   final String missingPropertyName = "missing.property.name";
   assertEquals(defaultString, config.get(getClass(), missingPropertyName, defaultString));
   final int defaultInt = 42;
   assertEquals(defaultInt, config.getInt(getClass(), missingPropertyName, defaultInt));
 }
예제 #4
0
  /**
   * Predict the effect of a seqChange
   *
   * @param seqChange : Sequence change
   * @param seqChangeRef : Before analyzing results, we have to change markers using seqChangerRef
   *     to create a new reference 'on the fly'
   */
  public ChangeEffects seqChangeEffect(Variant seqChange, Variant seqChangeRef) {
    ChangeEffects changeEffects = new ChangeEffects(seqChange, seqChangeRef);

    // ---
    // Chromosome missing?
    // ---
    if (Config.get().isErrorOnMissingChromo() && isChromosomeMissing(seqChange)) {
      changeEffects.addErrorWarning(ErrorWarningType.ERROR_CHROMOSOME_NOT_FOUND);
      return changeEffects;
    }

    // ---
    // Check that this is not a huge deletion.
    // Huge deletions would crash the rest of the algorithm, so we need to stop them here.
    // ---
    if (seqChange.isDel() && (seqChange.size() > HUGE_DELETION_SIZE_THRESHOLD)) {
      // Get chromosome
      String chromoName = seqChange.getChromosomeName();
      Chromosome chr = genome.getChromosome(chromoName);

      if (chr.size() > 0) {
        double ratio = seqChange.size() / ((double) chr.size());
        if (ratio > HUGE_DELETION_RATIO_THRESHOLD) {
          changeEffects.add(chr, EffectType.CHROMOSOME_LARGE_DELETION, "");
          return changeEffects;
        }
      }
    }

    // ---
    // Query interval tree: Which intervals does seqChange intersect?
    // ---
    Markers intersects = query(seqChange);

    // Show all results
    boolean hitChromo = false, hitSomething = false;
    if (intersects.size() > 0) {
      for (Marker marker : intersects) {
        if (marker instanceof Chromosome) hitChromo = true; // Do we hit any chromosome?
        else { // Analyze all markers
          marker.seqChangeEffect(seqChange, changeEffects, seqChangeRef);
          hitSomething = true;
        }
      }
    }

    // Any errors or intergenic (i.e. did not hit any gene)
    if (!hitChromo) {
      if (Config.get().isErrorChromoHit())
        changeEffects.addErrorWarning(ErrorWarningType.ERROR_OUT_OF_CHROMOSOME_RANGE);
    } else if (!hitSomething) {
      if (Config.get().isOnlyRegulation()) changeEffects.setEffectType(EffectType.NONE);
      else changeEffects.setEffectType(EffectType.INTERGENIC);
    }

    return changeEffects;
  }
예제 #5
0
  private void init() throws IOException {
    //        zooKeeper = new ZooKeeper(SystemConfig.getProperty("zk.quorum"),
    // Integer.parseInt(SystemConfig.getProperty("zk.session.timeout", "30000")), defaultWatch);
    String zkQuorum = Config.get().get("zk.quorum", "localhost:2181");

    //		zooKeeper = new ZooKeeper(StringUtils.join(zkHostList, ","), new
    // Integer(BaseConfig.getValue("zk.session.timeout", "30000")), defaultWatch);
    zooKeeper =
        new ZooKeeperRetry(
            zkQuorum, new Integer(Config.get().get("zk.session.timeout", "30000")), defaultWatch);
  }
예제 #6
0
  @Test
  public void shouldBeAbleToRegisterSettingsClassesAfterInstantiation() throws Exception {
    // Given
    Config config = new Config(stringMap("old", "hello!"));

    // When
    config.registerSettingsClasses(asList(MySettingsWithDefaults.class, MyMigratingSettings.class));

    // Then
    assertThat(config.get(MyMigratingSettings.newer), equalTo("hello!"));
    assertThat(config.get(MySettingsWithDefaults.hello), equalTo("Hello, World!"));
  }
예제 #7
0
파일: Effect.java 프로젝트: linhua55/trime
  public void reset() {
    Config config = Config.get();
    vibrateOn = config.getBoolean("key_vibrate");
    duration = config.getInt("key_vibrate_duration");
    if (vibrateOn && (vibrator == null)) {
      vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
    }

    soundOn = config.getBoolean("key_sound");
    volume = config.getFloat("key_sound_volume");
    if (soundOn && (audioManager == null)) {
      audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
    }

    isSpeakCommit = config.getBoolean("speak_commit");
    isSpeakKey = config.getBoolean("speak_key");
    if (mTTS == null && (isSpeakCommit || isSpeakKey)) {
      mTTS =
          new TextToSpeech(
              context,
              new TextToSpeech.OnInitListener() {
                public void onInit(int status) {
                  // 初始化結果
                }
              });
    }
  }
예제 #8
0
    @Override
    public Component getListCellRendererComponent(
        JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {

      // Get the renderer component from parent class

      JLabel label =
          (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

      // Get icon to use for the list item value
      Character character = (Character) value;
      Config.ConfigEntry ce = config.get(character.getName());
      Icon icon = null;

      if (ce == null) {
        icon = icons.get(NOTOK);
        label.setToolTipText(
            "Double-click to enter configuration information for this character, right-click for more options");
      } else {
        if (ce.isOk()) {
          icon = icons.get(OK);
          ui.exportAllButton.setEnabled(true);
        } else {
          icon = icons.get(NOTOK);
        }
      }
      // Set icon to display for value

      label.setIcon(icon);
      return label;
    }
예제 #9
0
  public TraceLevel getTraceLevel(String id) {
    TraceLevel level;
    Integer value;

    /*
     ** See if ID has already been processed.
     */
    if ((level = (TraceLevel) levels.get(id)) == null) {
      String str;
      int val = 0;

      /*
       ** See if ID is defined for trace key.
       */
      if ((str = config.get(id)) != null)
        try {
          val = Integer.parseInt(str);
        } catch (Exception ignore) {
        }

      /*
       ** Save determined value for future reference.
       */
      level = new TraceLevel(val);
      levels.put(id, level);
    }

    return (level);
  } // getTraceLevel
예제 #10
0
  public static void initStatic() {
    String temp = null;
    Config cfg = null;
    try {
      cfg = Config.getInstance();
      temp = cfg.get("libdefaults", "default_checksum");
      if (temp != null) {
        CKSUMTYPE_DEFAULT = Config.getType(temp);
      } else {
        /*
         * If the default checksum is not
         * specified in the configuration we
         * set it to RSA_MD5. We follow the MIT and
         * SEAM implementation.
         */
        CKSUMTYPE_DEFAULT = CKSUMTYPE_RSA_MD5;
      }
    } catch (Exception exc) {
      if (DEBUG) {
        System.out.println(
            "Exception in getting default checksum "
                + "value from the configuration "
                + "Setting default checksum to be RSA-MD5");
        exc.printStackTrace();
      }
      CKSUMTYPE_DEFAULT = CKSUMTYPE_RSA_MD5;
    }

    try {
      temp = cfg.get("libdefaults", "safe_checksum_type");
      if (temp != null) {
        SAFECKSUMTYPE_DEFAULT = Config.getType(temp);
      } else {
        SAFECKSUMTYPE_DEFAULT = CKSUMTYPE_RSA_MD5_DES;
      }
    } catch (Exception exc) {
      if (DEBUG) {
        System.out.println(
            "Exception in getting safe default "
                + "checksum value "
                + "from the configuration Setting  "
                + "safe default checksum to be RSA-MD5");
        exc.printStackTrace();
      }
      SAFECKSUMTYPE_DEFAULT = CKSUMTYPE_RSA_MD5_DES;
    }
  }
예제 #11
0
 @Override
 public Worker create(final Config config, final DependencyResolver dependencies) {
   final MSMSEvalWorker worker = new MSMSEvalWorker();
   worker.setMsmsEvalExecutable(
       FileUtilities.getAbsoluteFileForExecutables(new File(config.get(MSMS_EVAL_EXECUTABLE))));
   worker.setConverter(getConverter());
   return worker;
 }
예제 #12
0
  @Test
  public void shouldApplyMigrations() {
    // When
    Config config = new Config(stringMap("old", "hello!"), MyMigratingSettings.class);

    // Then
    assertThat(config.get(MyMigratingSettings.newer), is("hello!"));
  }
예제 #13
0
파일: Speech.java 프로젝트: linhua55/trime
 @Override
 public void onResults(Bundle results) {
   stop();
   destory();
   Log.i(TAG, "onResults");
   Trime trime = Trime.getService();
   if (trime == null) return;
   ArrayList<String> matches = results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);
   String opencc_config = Config.get(context).getString("speech_opencc_config");
   for (String result : matches) trime.commitText(Rime.openccConvert(result, opencc_config));
 }
  /**
   * Method that initializes all vital prerequisites, including POS Tagger
   *
   * @param language Language to be processed with this copy of HeidelTime
   * @param typeToProcess Domain type to be processed
   * @param outputType Output type
   * @param configPath Path to the configuration file for HeidelTimeStandalone
   * @param posTagger POS Tagger to use for preprocessing
   * @param doIntervalTagging Whether or not to invoke the IntervalTagger
   */
  public void initialize(
      Language language,
      DocumentType typeToProcess,
      OutputType outputType,
      String configPath,
      POSTagger posTagger,
      Boolean doIntervalTagging) {
    logger.log(
        Level.INFO, "HeidelTimeStandalone initialized with language " + this.language.getName());

    // set the POS tagger
    this.posTagger = posTagger;

    // set doIntervalTagging flag
    this.doIntervalTagging = doIntervalTagging;

    // read in configuration in case it's not yet initialized
    if (!Config.isInitialized()) {
      if (configPath == null) readConfigFile(CLISwitch.CONFIGFILE.getValue().toString());
      else readConfigFile(configPath);
    }

    try {
      heidelTime = new HeidelTime();
      heidelTime.initialize(
          new UimaContextImpl(language, typeToProcess, CLISwitch.VERBOSITY2.getIsActive()));
      logger.log(Level.INFO, "HeidelTime initialized");
    } catch (Exception e) {
      e.printStackTrace();
      logger.log(Level.WARNING, "HeidelTime could not be initialized");
    }

    // Initialize JCas factory -------------
    logger.log(Level.FINE, "Initializing JCas factory...");
    try {
      TypeSystemDescription[] descriptions =
          new TypeSystemDescription[] {
            UIMAFramework.getXMLParser()
                .parseTypeSystemDescription(
                    new XMLInputSource(
                        this.getClass()
                            .getClassLoader()
                            .getResource(Config.get(Config.TYPESYSTEMHOME))))
          };
      jcasFactory = new JCasFactoryImpl(descriptions);
      logger.log(Level.INFO, "JCas factory initialized");
    } catch (Exception e) {
      e.printStackTrace();
      logger.log(Level.WARNING, "JCas factory could not be initialized");
    }
  }
예제 #15
0
  public static void configCheck(ConfigType type) {
    FileConfiguration config;
    switch (type) {
      case linkConfig:
        config = linkConfig.get();

        config.addDefault("Links.YouTube", "http://youtube.com");
        config.addDefault("Links.Twitter", "http://twitter.com");
        config.addDefault("Links.Website", "http://www.elementum.me");
        config.addDefault("Links.Donate", "http://www.elementum.me/donate");
        config.addDefault("Links.Vote", "http://");

        linkConfig.save();

      case opConfig:
        config = opConfig.get();

        config.addDefault("Ops.KickMessage", "&cHa, you thought. Go watch space jam kid.");
        config.addDefault("Ops.Names", Arrays.asList("Loonyy"));

        opConfig.save();

      case commandsConfig:
        config = commandConfig.get();

        config.addDefault("CommandMessage", "&c&lNot in my house! :)");
        config.addDefault("Commands", Arrays.asList("fly"));

        commandConfig.save();

      case respawnConfig:
        config = respawnConfig.get();

        config.addDefault("RespawnLocation.FallbackSpawn", "null");

        respawnConfig.save();
    }
  }
예제 #16
0
  public HgvsProtein(VariantEffect variantEffect) {
    super(variantEffect);

    codonNum = variantEffect.getCodonNum();

    hgvsOneLetterAa = Config.get().isHgvs1LetterAA();
    hgvsOld = Config.get().isHgvsOld();
    stop = hgvsOld ? 'X' : '*';
    lettersPerAa = hgvsOneLetterAa ? 1 : 3;

    // No marker? Nothing to do
    if (marker != null) {
      // Codon numbering
      // HGVS: the translation initiator Methionine is numbered as +1
      if (codonNum >= 0) aaPos = codonNum + 1;

      aaNew = aaCode(variantEffect.getAaAlt());
      aaOld = aaCode(variantEffect.getAaRef());
    } else {
      aaPos = -1;
      aaNew = aaOld = "";
    }
  }
예제 #17
0
  /**
   * @param args
   * @throws IOException
   */
  public static void main(String[] args) throws IOException {
    // 读取配置文件对象
    Config config = new Config();

    // 获取配置参数
    String host = config.get("smgwip");
    String account = config.get("smgwaccount");
    String passwd = config.get("smgwpasswd");
    String spid = config.get("smgwspid");
    String spnum = config.get("smgpspnum");
    int port = Integer.parseInt(config.get("smgwport"));
    String productid = config.get("productid");

    // 目标号码:18918911891
    String destnum = config.get("destnum");
    String content = config.get("longconent");

    // 初始化client
    Client client = new Client(host, port, 2, account, passwd, spid, 0);

    // 设置submit
    Submit submit = new Submit();
    submit.setSrcTermid(spnum);
    submit.setDestTermid(destnum);
    submit.setMsgContent(content.getBytes("iso-10646-ucs-2"));
    submit.setMsgFormat(8);
    if (productid != null) submit.setProductID(productid);

    // 发送短信
    Result[] result = client.SendLong(submit);
    for (int i = 0; i < result.length; i++) {
      System.out.println("--------------------------------");
      System.out.println("Message " + i + "");
      System.out.println("Status:" + result[i].ErrorCode);
      System.out.println("MsgID:" + result[i].ErrorDescription);
      System.out.println("--------------------------------");
    }

    // 退出
    client.Close();
  }
예제 #18
0
 private void exportSelectedCharacters() {
   if (herolabsCharacterList.getSelectedIndex() >= 0) {
     Character c =
         (Character)
             herolabsCharacterList
                 .getModel()
                 .getElementAt(herolabsCharacterList.getSelectedIndex());
     Config.ConfigEntry ce = config.get(c.getName());
     if (ce != null && ce.isOk()) {
       exportCharacters();
     } else {
       JOptionPane.showMessageDialog(
           panel,
           "The character you selected hasn't been configured yet.  Please configure "
               + "and try again.",
           "Export Warning",
           JOptionPane.WARNING_MESSAGE);
     }
   }
 }
예제 #19
0
  /**
   * Imprime en el formato Osm el nodo con la informacion
   *
   * @param id Id del nodo
   * @param huso Huso geografico para la conversion UTM a Lat/Long
   * @return Devuelve en un String el nodo listo para imprimir
   * @throws UnsupportedEncodingException
   */
  public String printNode(Long id) {
    String s = "";

    // Si no pertenece a ningun shape porque se ha visto que no tenia tags representativos
    // o se ha delimitado la busqueda
    if (shapes == null || shapes.isEmpty()) {
      return s;
    }

    s =
        ("<node id=\""
            + id
            + "\" timestamp=\""
            + new Timestamp(new Date().getTime())
            + "\" version=\"6\" lat=\""
            + this.coor.y
            + "\" lon=\""
            + this.coor.x
            + "\">\n");

    if (tags != null)
      for (int x = 0; x < tags.size(); x++)
        if (tags.get(x)[0].startsWith("CAT2OSMSHAPEID") && Config.get("PrintShapeIds").equals("1"))
          s += "<tag k=\"" + tags.get(x)[0] + "\" v=\"" + tags.get(x)[1] + "\"/>\n";
        else if (!tags.get(x)[0].startsWith("CAT2OSMSHAPEID"))
          s += "<tag k=\"" + tags.get(x)[0] + "\" v=\"" + tags.get(x)[1] + "\"/>\n";

    s += "<tag k=\"source\" v=\"catastro\"/>\n";
    s +=
        "<tag k=\"source:date\" v=\""
            + new StringBuffer(Cat2OsmUtils.getFechaArchivos() + "")
                .insert(4, "-")
                .toString()
                .substring(0, 7)
            + "\"/>\n";

    s += ("</node>\n");

    return s;
  }
예제 #20
0
  /** Resolve include statements */
  private static boolean resolveIncludes(
      ParseTree tree, boolean debug, Set<String> alreadyIncluded) {
    boolean changed = false;
    if (tree instanceof IncludeFileContext) {
      // Parent file: The one that is including the other file
      File parentFile =
          new File(((IncludeFileContext) tree).getStart().getInputStream().getSourceName());

      // Included file name
      String includedFilename = StatementInclude.includeFileName(tree.getChild(1).getText());

      // Find file (look into all include paths)
      File includedFile = StatementInclude.includeFile(includedFilename, parentFile);
      if (includedFile == null) {
        CompilerMessages.get()
            .add(
                tree,
                parentFile,
                "\n\tIncluded file not found: '"
                    + includedFilename
                    + "'\n\tSearch path: "
                    + Config.get().getIncludePath(),
                MessageType.ERROR);
        return false;
      }

      // Already included? don't bother
      String canonicalFileName = Gpr.getCanonicalFileName(includedFile);
      if (alreadyIncluded.contains(canonicalFileName)) {
        if (debug)
          Gpr.debug(
              "File already included: '"
                  + includedFilename
                  + "'\tCanonical path: '"
                  + canonicalFileName
                  + "'");
        return false;
      }
      if (!includedFile.canRead()) {
        CompilerMessages.get()
            .add(
                tree,
                parentFile,
                "\n\tCannot read included file: '" + includedFilename + "'",
                MessageType.ERROR);
        return false;
      }

      // Parse
      ParseTree treeinc = createAst(includedFile, debug, alreadyIncluded);
      if (treeinc == null) {
        CompilerMessages.get()
            .add(
                tree,
                parentFile,
                "\n\tFatal error including file '" + includedFilename + "'",
                MessageType.ERROR);
        return false;
      }

      // Is a child always a RuleContext?
      for (int i = 0; i < treeinc.getChildCount(); i++) {
        ((IncludeFileContext) tree).addChild((RuleContext) treeinc.getChild(i));
      }
    } else {
      for (int i = 0; i < tree.getChildCount(); i++)
        changed |= resolveIncludes(tree.getChild(i), debug, alreadyIncluded);
    }

    return changed;
  }
예제 #21
0
 public static void War(
     String section, String playersection, String targetsection, String playername) {
   if (serverdata.get(section).get(playersection).get("ene") == null) {
     serverdata.get(section).get(playersection).put("ene", new HashMap<>());
   }
   if (section.equals("villages")) {
     ((HashMap) serverdata.get(section).get(playersection).get("ene"))
         .put(targetsection, Config.get("Village Settings.War Time Delay"));
   } else {
     ((HashMap) serverdata.get(section).get(playersection).get("ene"))
         .put(targetsection, Config.get("Empire Settings.War Time Delay"));
   }
   if (serverdata.get(section).get(targetsection).get("ene") == null) {
     serverdata.get(section).get(targetsection).put("ene", new HashMap<>());
   }
   if (section.equals("villages")) {
     ((HashMap) serverdata.get(section).get(targetsection).get("ene"))
         .put(playersection, Config.get("Village Settings.War Time Delay"));
   } else {
     ((HashMap) serverdata.get(section).get(targetsection).get("ene"))
         .put(playersection, Config.get("Empire Settings.War Time Delay"));
   }
   if (serverdata.get(section).get(playersection).get("all") != null) {
     if (((ArrayList) serverdata.get(section).get(playersection).get("all"))
         .contains(targetsection)) {
       ((ArrayList) serverdata.get(section).get(playersection).get("all")).remove(targetsection);
       ((ArrayList) serverdata.get(section).get(targetsection).get("all")).remove(playersection);
     }
   }
   if (serverdata.get(section).get(playersection).get("alr") != null) {
     if (((ArrayList) serverdata.get(section).get(playersection).get("alr"))
         .contains(targetsection)) {
       ((ArrayList) serverdata.get(section).get(playersection).get("alr")).remove(targetsection);
     }
   }
   if (serverdata.get(section).get(targetsection).get("alr") != null) {
     if (((ArrayList) serverdata.get(section).get(targetsection).get("alr"))
         .contains(playersection)) {
       ((ArrayList) serverdata.get(section).get(targetsection).get("alr")).remove(playersection);
     }
   }
   Bukkit.getPlayer(UUID.fromString(playername))
       .sendMessage(
           ChatColor.BLUE
               + " you have successfully declared war on "
               + ChatColor.AQUA
               + targetsection);
   if (section.equals("villages")) {
     if ((Bukkit.getOfflinePlayer(
             UUID.fromString(serverdata.get(section).get(targetsection).get("own").toString())))
         .isOnline()) {
       Bukkit.getPlayer(
               UUID.fromString(serverdata.get(section).get(targetsection).get("own").toString()))
           .sendMessage(
               ChatColor.LIGHT_PURPLE
                   + Bukkit.getPlayer(UUID.fromString(playername)).getName()
                   + ChatColor.DARK_PURPLE
                   + ", owner of the village "
                   + ChatColor.LIGHT_PURPLE
                   + playersection
                   + ChatColor.DARK_PURPLE
                   + ", has declared war on you!");
     }
     temparraylist.clear();
     if (serverdata.get(section).get(playersection) != null) {
       if (serverdata.get(section).get(playersection).get("mem") != null) {
         temparraylist.addAll(
             (Collection<? extends String>) serverdata.get(section).get(playersection).get("mem"));
       }
       if (serverdata.get(section).get(playersection).get("man") != null) {
         temparraylist.addAll(
             (Collection<? extends String>) serverdata.get(section).get(playersection).get("man"));
       }
     }
     temparraylist
         .stream()
         .filter((p) -> ((Bukkit.getOfflinePlayer(UUID.fromString(p))).isOnline()))
         .forEach(
             (p) -> {
               Bukkit.getPlayer(UUID.fromString(p))
                   .sendMessage(
                       ChatColor.LIGHT_PURPLE
                           + playersection
                           + ChatColor.DARK_PURPLE
                           + ", Has declared war on you!");
             });
     temparraylist.clear();
     if (serverdata.get(section).get(targetsection) != null) {
       if (serverdata.get(section).get(targetsection).get("mem") != null) {
         temparraylist.addAll(
             (Collection<? extends String>) serverdata.get(section).get(targetsection).get("mem"));
       }
       if (serverdata.get(section).get(targetsection).get("man") != null) {
         temparraylist.addAll(
             (Collection<? extends String>) serverdata.get(section).get(targetsection).get("man"));
       }
     }
     temparraylist
         .stream()
         .filter((p) -> ((Bukkit.getOfflinePlayer(UUID.fromString(p))).isOnline()))
         .forEach(
             (p) -> {
               Bukkit.getPlayer(UUID.fromString(p))
                   .sendMessage(
                       ChatColor.LIGHT_PURPLE
                           + Bukkit.getPlayer(UUID.fromString(playername)).getName()
                           + ChatColor.DARK_PURPLE
                           + ", has declared war on "
                           + ChatColor.LIGHT_PURPLE
                           + targetsection);
             });
   } else {
     ((ArrayList<String>) serverdata.get("empires").get(targetsection).get("vils"))
         .stream()
         .map(
             (v) -> {
               if ((Bukkit.getOfflinePlayer(
                       UUID.fromString(serverdata.get("villages").get(v).get("own").toString())))
                   .isOnline()) {
                 Bukkit.getPlayer(
                         UUID.fromString(serverdata.get("villages").get(v).get("own").toString()))
                     .sendMessage(
                         ChatColor.LIGHT_PURPLE
                             + Bukkit.getPlayer(UUID.fromString(playername)).getName()
                             + ChatColor.DARK_PURPLE
                             + ", leader of the empire "
                             + ChatColor.LIGHT_PURPLE
                             + playersection
                             + ChatColor.DARK_PURPLE
                             + ", has declared war on your empire!");
               }
               return v;
             })
         .map(
             (v) -> {
               temparraylist.clear();
               return v;
             })
         .map(
             (v) -> {
               if (serverdata.get("villages").get(v) != null) {
                 if (serverdata.get("villages").get(v).get("mem") != null) {
                   temparraylist.addAll(
                       (Collection<? extends String>)
                           serverdata.get("villages").get(v).get("mem"));
                 }
                 if (serverdata.get("villages").get(v).get("man") != null) {
                   temparraylist.addAll(
                       (Collection<? extends String>)
                           serverdata.get("villages").get(v).get("man"));
                 }
               }
               return v;
             })
         .forEach(
             (_item) -> {
               temparraylist
                   .stream()
                   .filter((p) -> ((Bukkit.getOfflinePlayer(UUID.fromString(p))).isOnline()))
                   .forEach(
                       (p) -> {
                         Bukkit.getPlayer(UUID.fromString(p))
                             .sendMessage(
                                 ChatColor.LIGHT_PURPLE
                                     + playersection
                                     + ChatColor.DARK_PURPLE
                                     + ", Has declared war on you!");
                       });
             });
     ((ArrayList<String>) serverdata.get("empires").get(playersection).get("vils"))
         .stream()
         .map(
             (v) -> {
               temparraylist.clear();
               return v;
             })
         .map(
             (v) -> {
               if (serverdata.get("villages").get(v) != null) {
                 if (serverdata.get("villages").get(v).get("mem") != null) {
                   temparraylist.addAll(
                       (Collection<? extends String>)
                           serverdata.get("villages").get(v).get("mem"));
                 }
                 if (serverdata.get("villages").get(v).get("man") != null) {
                   temparraylist.addAll(
                       (Collection<? extends String>)
                           serverdata.get("villages").get(v).get("man"));
                 }
               }
               return v;
             })
         .forEach(
             (_item) -> {
               temparraylist
                   .stream()
                   .filter((p) -> ((Bukkit.getOfflinePlayer(UUID.fromString(p))).isOnline()))
                   .forEach(
                       (p) -> {
                         Bukkit.getPlayer(UUID.fromString(p))
                             .sendMessage(
                                 ChatColor.LIGHT_PURPLE
                                     + Bukkit.getPlayer(UUID.fromString(playername)).getName()
                                     + ChatColor.DARK_PURPLE
                                     + ", has declared war on "
                                     + ChatColor.LIGHT_PURPLE
                                     + targetsection);
                       });
             });
   }
 }
예제 #22
0
  @Override
  public void run() {
    for (Location l : Storage.blackholes.keySet()) {
      for (Entity e : Utilities.getNearbyEntities(l, 10, 10, 10)) {
        if (e instanceof Player) {
          if (((Player) e).getGameMode().equals(CREATIVE)) {
            continue;
          }
        }
        if (Storage.blackholes.get(l)) {
          Vector v = l.clone().subtract(e.getLocation()).toVector();
          v.setX(v.getX() + (-.5f + Storage.rnd.nextFloat()) * 10);
          v.setY(v.getY() + (-.5f + Storage.rnd.nextFloat()) * 10);
          v.setZ(v.getZ() + (-.5f + Storage.rnd.nextFloat()) * 10);
          e.setVelocity(v.multiply(.35f));
          e.setFallDistance(0);
        } else {
          Vector v = e.getLocation().subtract(l.clone()).toVector();
          v.setX(v.getX() + (-.5f + Storage.rnd.nextFloat()) * 2);
          v.setY(v.getY() + Storage.rnd.nextFloat());
          v.setZ(v.getZ() + (-.5f + Storage.rnd.nextFloat()) * 2);
          e.setVelocity(v.multiply(.35f));
        }
      }
    }
    // Arrows
    toRemove.clear();
    for (Set<CustomArrow> pro : Storage.advancedProjectiles.values()) {
      for (CustomArrow a : pro) {
        a.onFlight();
        a.tick++;
        if (a.entity.isDead() || a.tick > 600) {
          toRemove.add(a);
        }
      }
    }
    for (CustomArrow pro : toRemove) {
      Storage.advancedProjectiles.remove(pro.entity);
      pro.entity.remove();
    }
    for (Block block : Storage.webs) {
      if (Storage.rnd.nextInt(175) == 0 && block.getChunk().isLoaded()) {
        block.setType(AIR);
        websToRemove.add(block);
      }
    }
    for (Block block : websToRemove) {
      Storage.webs.remove(block);
    }
    websToRemove.clear();
    for (LivingEntity ent : Storage.derpingEntities) {
      Location loc = ent.getLocation();
      loc.setYaw(Storage.rnd.nextFloat() * 360F);
      loc.setPitch(Storage.rnd.nextFloat() * 180F - 90F);
      ent.teleport(loc);
    }
    tick++;
    // Other stuff
    for (FallingBlock b : Storage.anthMobs2) {
      if (!Storage.anthVortex.contains(Storage.anthMobs.get(b))) {
        for (Entity e : b.getNearbyEntities(7, 7, 7)) {
          if (e instanceof LivingEntity) {
            LivingEntity lE = (LivingEntity) e;
            if (!(lE instanceof Player) && lE instanceof Monster) {
              b.setVelocity(e.getLocation().subtract(b.getLocation()).toVector().multiply(.25));
              if (lE.getLocation().getWorld().equals(b.getLocation().getWorld())) {
                if (lE.getLocation().distance(b.getLocation()) < 1.2) {
                  EntityDamageEvent evt =
                      new EntityDamageEvent(lE, EntityDamageEvent.DamageCause.SUFFOCATION, 100);
                  Bukkit.getPluginManager().callEvent(evt);
                  lE.setLastDamageCause(evt);
                  if (!evt.isCancelled()) {
                    lE.damage(8f);
                  }
                }
              }
            }
          }
        }
      }
    }
    boolean r = Storage.fallBool;
    Storage.fallBool = !Storage.fallBool;
    for (FallingBlock b : Storage.anthMobs.keySet()) {
      if (Storage.anthVortex.contains(Storage.anthMobs.get(b))) {
        Location loc = Storage.anthMobs.get(b).getLocation();
        Vector v;
        if (b.getLocation().getWorld().equals(Storage.anthMobs.get(b).getLocation().getWorld())) {
          if (r && b.getLocation().distance(Storage.anthMobs.get(b).getLocation()) < 10) {
            v = b.getLocation().subtract(loc).toVector();
          } else {
            int x = Storage.rnd.nextInt(12) - 6;
            int z = Storage.rnd.nextInt(12) - 6;
            Location tLoc = loc.clone();
            tLoc.setX(tLoc.getX() + x);
            tLoc.setZ(tLoc.getZ() + z);
            v = tLoc.subtract(b.getLocation()).toVector();
          }
          v.multiply(.05);
          boolean close = false;
          for (int x = -3; x < 0; x++) {
            if (b.getLocation().getBlock().getRelative(0, x, 0).getType() != AIR) {
              close = true;
            }
          }
          if (close) {
            v.setY(5);
          } else {
            v.setY(-.1);
          }
          b.setVelocity(v);
        }
      }
    }

    for (Arrow e : Storage.tracer.keySet()) {
      Entity close = null;
      double distance = 100;
      int level = Storage.tracer.get(e);
      level = level + 2;
      for (Entity e1 : e.getNearbyEntities(level, level, level)) {
        if (e1.getLocation().getWorld().equals(e.getLocation().getWorld())) {
          double d = e1.getLocation().distance(e.getLocation());
          if (e.getLocation()
              .getWorld()
              .equals(((Entity) e.getShooter()).getLocation().getWorld())) {
            if (d < distance
                && e1 instanceof LivingEntity
                && !e1.equals(e.getShooter())
                && e.getLocation().distance(((Entity) e.getShooter()).getLocation()) > 15) {
              distance = d;
              close = e1;
            }
          }
        }
      }
      if (close != null) {
        Location location = close.getLocation();
        org.bukkit.util.Vector v = new org.bukkit.util.Vector(0D, 0D, 0D);
        Location pos = e.getLocation();
        double its =
            Math.sqrt(
                (location.getBlockX() - pos.getBlockX()) * (location.getBlockX() - pos.getBlockX())
                    + (location.getBlockY() - pos.getBlockY())
                        * (location.getBlockY() - pos.getBlockY())
                    + (location.getBlockZ() - pos.getBlockZ())
                        * (location.getBlockZ() - pos.getBlockZ()));
        if (its == 0) {
          its = (double) 1;
        }
        v.setX((location.getBlockX() - pos.getBlockX()) / its);
        v.setY((location.getBlockY() - pos.getBlockY()) / its);
        v.setZ((location.getBlockZ() - pos.getBlockZ()) / its);
        e.setVelocity(v.multiply(2));
      }
    }

    for (Guardian g : Storage.guardianMove.keySet()) {
      if (g.getLocation().distance(Storage.guardianMove.get(g).getLocation()) > 2
          && g.getTicksLived() < 160) {
        g.setVelocity(
            Storage.guardianMove
                .get(g)
                .getLocation()
                .toVector()
                .subtract(g.getLocation().toVector()));
      } else {
        Storage.guardianMove.remove(g);
      }
    }

    for (Player player : Bukkit.getOnlinePlayers()) {
      Config config = Config.get(player.getWorld());
      for (ItemStack stk : player.getInventory().getArmorContents()) {
        HashMap<CustomEnchantment, Integer> map = config.getEnchants(stk);
        for (CustomEnchantment ench : map.keySet()) {
          ench.onFastScan(player, map.get(ench));
        }
      }
      HashMap<CustomEnchantment, Integer> map = config.getEnchants(player.getItemInHand());
      for (CustomEnchantment ench : map.keySet()) {
        ench.onFastScanHand(player, map.get(ench));
      }
    }
    HashSet<Player> toDelete = new HashSet<>();
    for (Player player : Storage.hungerPlayers.keySet()) {
      if (Storage.hungerPlayers.get(player) < 1) {
        toDelete.add(player);
      } else {
        Storage.hungerPlayers.put(player, Storage.hungerPlayers.get(player) - 1);
      }
    }
    for (Player p : toDelete) {
      Storage.hungerPlayers.remove(p);
    }
    toDelete.clear();
    for (Player player : Storage.moverBlockDecay.keySet()) {
      Storage.moverBlockDecay.put(player, Storage.moverBlockDecay.get(player) + 1);
      if (Storage.moverBlockDecay.get(player) > 5) {
        Storage.moverBlocks.remove(player);
        toDelete.add(player);
      }
    }
    for (Player p : toDelete) {
      Storage.moverBlockDecay.remove(p);
    }
  }
예제 #23
0
/**
 * Abstract class: it provides all methods and attributes for each instruction type
 *
 * @author Trubia Massimo, Russo Daniele
 */
public abstract class Instruction {

  protected BitSet32 repr;
  protected List<Integer> params;
  protected int paramCount;
  protected String syntax;
  protected String name;
  protected String comment;
  protected static Memory memory = Memory.getInstance();
  protected Register[] TR; // is not static because each instruction has got its own registers
  protected String fullname;
  protected static boolean enableForwarding = (Boolean) Config.get("forwarding");
  protected String label;
  protected static final Logger logger = Logger.getLogger(Instruction.class.getName());

  /** Creates a new instance of Instruction */
  public Instruction() {
    params = new LinkedList<Integer>();
    TR = new Register[5];
    repr = new BitSet32();
    repr.reset(false);
    syntax = new String();
    // initialization of temporary registers
    for (int i = 0; i < TR.length; i++) {
      TR[i] = new Register();
    }
  }

  /** <pre>
   *  Returns a BitSet32 holding the binary representation of the Instruction
   *  @return the Bitset32 representing the instruction
   *  </pre>
   * */
  public BitSet32 getRepr() {
    return repr;
  }

  /**
   * Creates a new instance of an Instruction's subclass
   *
   * @param name string value to pass in order to instanciate an instruction object
   * @return the instruction object
   */
  public static Instruction buildInstruction(String name) {
    Instruction returnedObject = null;
    for (InstructionEnumerator op : InstructionEnumerator.values()) {
      if (op.name().equals(name) == true) {
        returnedObject = op.getObject();
        return returnedObject;
      }
    }
    return returnedObject;
  }

  public enum InstructionEnumerator {

    // ALU R-Type 32-bits
    ADD {
      Instruction getObject() {
        ADD newObject = new ADD();
        return newObject;
      }
    },
    ADDU {
      Instruction getObject() {
        ADDU newObject = new ADDU();
        return newObject;
      }
    },
    SUB {
      Instruction getObject() {
        SUB newObject = new SUB();
        return newObject;
      }
    },
    SUBU {
      Instruction getObject() {
        SUBU newObject = new SUBU();
        return newObject;
      }
    },
    DIV {
      Instruction getObject() {
        DIV newObject = new DIV();
        return newObject;
      }
    },
    DIVU {
      Instruction getObject() {
        DIVU newObject = new DIVU();
        return newObject;
      }
    },
    MULT {
      Instruction getObject() {
        MULT newObject = new MULT();
        return newObject;
      }
    },
    MULTU {
      Instruction getObject() {
        MULTU newObject = new MULTU();
        return newObject;
      }
    },

    // ALU I-Type 32-bits
    ADDI {
      Instruction getObject() {
        ADDI newObject = new ADDI();
        return newObject;
      }
    },
    ADDIU {
      Instruction getObject() {
        ADDIU newObject = new ADDIU();
        return newObject;
      }
    },

    // ALU Shifting 32-bits
    SLL {
      Instruction getObject() {
        SLL newObject = new SLL();
        return newObject;
      }
    },
    SLLV {
      Instruction getObject() {
        SLLV newObject = new SLLV();
        return newObject;
      }
    },
    SRA {
      Instruction getObject() {
        SRA newObject = new SRA();
        return newObject;
      }
    },
    SRAV {
      Instruction getObject() {
        SRAV newObject = new SRAV();
        return newObject;
      }
    },
    SRL {
      Instruction getObject() {
        SRL newObject = new SRL();
        return newObject;
      }
    },
    SRLV {
      Instruction getObject() {
        SRLV newObject = new SRLV();
        return newObject;
      }
    },

    // ALU R-Type
    AND {
      Instruction getObject() {
        AND newObject = new AND();
        return newObject;
      }
    },
    DADD {
      Instruction getObject() {
        DADD newObject = new DADD();
        return newObject;
      }
    },
    DADDU {
      Instruction getObject() {
        DADDU newObject = new DADDU();
        return newObject;
      }
    },
    DSUB {
      Instruction getObject() {
        DSUB newObject = new DSUB();
        return newObject;
      }
    },
    DSUBU {
      Instruction getObject() {
        DSUBU newObject = new DSUBU();
        return newObject;
      }
    },
    OR {
      Instruction getObject() {
        OR newObject = new OR();
        return newObject;
      }
    },
    SLT {
      Instruction getObject() {
        SLT newObject = new SLT();
        return newObject;
      }
    },
    SLTU {
      Instruction getObject() {
        SLTU newObject = new SLTU();
        return newObject;
      }
    },
    XOR {
      Instruction getObject() {
        XOR newObject = new XOR();
        return newObject;
      }
    },
    MOVN {
      Instruction getObject() {
        MOVN newObject = new MOVN();
        return newObject;
      }
    },
    MOVZ {
      Instruction getObject() {
        MOVZ newObject = new MOVZ();
        return newObject;
      }
    },
    DDIV {
      Instruction getObject() {
        DDIV newObject = new DDIV();
        return newObject;
      }
    },
    DDIVU {
      Instruction getObject() {
        DDIVU newObject = new DDIVU();
        return newObject;
      }
    },
    DMULT {
      Instruction getObject() {
        DMULT newObject = new DMULT();
        return newObject;
      }
    },
    DMULTU {
      Instruction getObject() {
        DMULTU newObject = new DMULTU();
        return newObject;
      }
    },
    MFLO {
      Instruction getObject() {
        MFLO newObject = new MFLO();
        return newObject;
      }
    },
    MFHI {
      Instruction getObject() {
        MFHI newObject = new MFHI();
        return newObject;
      }
    },

    // ALU I-Type
    ANDI {
      Instruction getObject() {
        ANDI newObject = new ANDI();
        return newObject;
      }
    },
    DADDI {
      Instruction getObject() {
        DADDI newObject = new DADDI();
        return newObject;
      }
    },
    DADDUI {
      Instruction getObject() {
        DADDUI newObject = new DADDUI();
        return newObject;
      }
    },
    DADDIU {
      Instruction getObject() {
        DADDIU newObject = new DADDIU();
        return newObject;
      }
    },
    LUI {
      Instruction getObject() {
        LUI newObject = new LUI();
        return newObject;
      }
    },
    ORI {
      Instruction getObject() {
        ORI newObject = new ORI();
        return newObject;
      }
    },
    SLTI {
      Instruction getObject() {
        SLTI newObject = new SLTI();
        return newObject;
      }
    },
    SLTIU {
      Instruction getObject() {
        SLTIU newObject = new SLTIU();
        return newObject;
      }
    },
    XORI {
      Instruction getObject() {
        XORI newObject = new XORI();
        return newObject;
      }
    },
    // ALU Shifting
    DSLL {
      Instruction getObject() {
        DSLL newObject = new DSLL();
        return newObject;
      }
    },
    DSLLV {
      Instruction getObject() {
        DSLLV newObject = new DSLLV();
        return newObject;
      }
    },
    DSRA {
      Instruction getObject() {
        DSRA newObject = new DSRA();
        return newObject;
      }
    },
    DSRAV {
      Instruction getObject() {
        DSRAV newObject = new DSRAV();
        return newObject;
      }
    },
    DSRL {
      Instruction getObject() {
        DSRL newObject = new DSRL();
        return newObject;
      }
    },
    DSRLV {
      Instruction getObject() {
        DSRLV newObject = new DSRLV();
        return newObject;
      }
    },
    // Load-Signed
    LB {
      Instruction getObject() {
        LB newObject = new LB();
        return newObject;
      }
    },
    LH {
      Instruction getObject() {
        LH newObject = new LH();
        return newObject;
      }
    },
    LW {
      Instruction getObject() {
        LW newObject = new LW();
        return newObject;
      }
    },
    LD {
      Instruction getObject() {
        LD newObject = new LD();
        return newObject;
      }
    },
    // Load-Unsigned
    LBU {
      Instruction getObject() {
        LBU newObject = new LBU();
        return newObject;
      }
    },
    LHU {
      Instruction getObject() {
        LHU newObject = new LHU();
        return newObject;
      }
    },
    LWU {
      Instruction getObject() {
        LWU newObject = new LWU();
        return newObject;
      }
    },
    // Store
    SB {
      Instruction getObject() {
        SB newObject = new SB();
        return newObject;
      }
    },
    SH {
      Instruction getObject() {
        SH newObject = new SH();
        return newObject;
      }
    },
    SW {
      Instruction getObject() {
        SW newObject = new SW();
        return newObject;
      }
    },
    SD {
      Instruction getObject() {
        SD newObject = new SD();
        return newObject;
      }
    },
    // Unconditional branches
    J {
      Instruction getObject() {
        J newObject = new J();
        return newObject;
      }
    },
    JAL {
      Instruction getObject() {
        JAL newObject = new JAL();
        return newObject;
      }
    },
    JALR {
      Instruction getObject() {
        JALR newObject = new JALR();
        return newObject;
      }
    },
    JR {
      Instruction getObject() {
        JR newObject = new JR();
        return newObject;
      }
    },
    BNE {
      Instruction getObject() {
        BNE newObject = new BNE();
        return newObject;
      }
    },
    B {
      Instruction getObject() {
        B newObject = new B();
        return newObject;
      }
    },
    // Conditional branches
    BEQ {
      Instruction getObject() {
        BEQ newObject = new BEQ();
        return newObject;
      }
    },
    BNEZ {
      Instruction getObject() {
        BNEZ newObject = new BNEZ();
        return newObject;
      }
    },
    BEQZ {
      Instruction getObject() {
        BEQZ newObject = new BEQZ();
        return newObject;
      }
    },
    BGEZ {
      Instruction getObject() {
        BGEZ newObject = new BGEZ();
        return newObject;
      }
    },
    // Special instructions
    NOP {
      Instruction getObject() {
        NOP newObject = new NOP();
        return newObject;
      }
    },
    BUBBLE {
      Instruction getObject() {
        BUBBLE newObject = new BUBBLE();
        return newObject;
      }
    },
    HALT {
      Instruction getObject() {
        HALT newObject = new HALT();
        return newObject;
      }
    },
    TRAP {
      Instruction getObject() {
        TRAP newObject = new TRAP();
        return newObject;
      }
    },
    SYSCALL {
      Instruction getObject() {
        SYSCALL newObject = new SYSCALL();
        return newObject;
      }
    },
    BREAK {
      Instruction getObject() {
        BREAK newObject = new BREAK();
        return newObject;
      }
    };

    abstract Instruction getObject();
  }
  /**
   *
   *
   * <pre>
   * Instruction fetch.
   * Now it is used in order to generate the Dinero trace-file
   * </pre>
   */
  public void IF() throws BreakException {}

  /**
   *
   *
   * <pre>
   * Decode stage of the Pipeline
   * In this method all instructions that modify GPRs lock the involved register
   * </pre>
   */
  public abstract void ID()
      throws RAWException, IrregularWriteOperationException, IrregularStringOfBitsException,
          TwosComplementSumException, HaltException, JumpException, BreakException;

  /**
   *
   *
   * <pre>
   * Execute stage of the Pipeline
   * In this stage all Alu Instructions perform their computations and save results in temporary registers
   * </pre>
   */
  public abstract void EX()
      throws HaltException, IrregularStringOfBitsException, IntegerOverflowException,
          TwosComplementSumException, IrregularWriteOperationException,
          IrregularWriteOperationException, DivisionByZeroException;

  /**
   *
   *
   * <pre>
   * Memory stage of the Pipeline
   * In this stage all Load and Store instructions access memory for getting or putting data
   * </pre>
   */
  public abstract void MEM()
      throws HaltException, IrregularStringOfBitsException, MemoryElementNotFoundException,
          AddressErrorException, IrregularWriteOperationException;

  /**
   *
   *
   * <pre>
   * Write Back stage of the Pipeline
   * In this stage all instructions that modify registers write and unlock them
   * </pre>
   */
  public abstract void WB() throws HaltException, IrregularStringOfBitsException;

  /**
   *
   *
   * <pre>
   * Builds the binary encoding of instructions.
   * Every instruction is represented by a 32 bit field
   * </pre>
   */
  public abstract void pack() throws IrregularStringOfBitsException;

  /**
   * Gets the number of params to pass at the instruction object
   *
   * @return number of params
   */
  public int getNParams() {
    return paramCount;
  };

  /**
   *
   *
   * <pre>
   * Gets the syntax of any instruction as string composed by the following simbols
   * %R   Register
   * %I   Immediate
   * %U   Unsigned Immediate
   * %L   Memory Label
   * %E   Program Label used for Jump Instructions
   * %B   Program Label used for Brench Instructions
   *
   * examples:
   *   Instruction -----> Syntax
   * DADD  R1,R2,R3   |   %R,%R,%R
   * DADDI R1,R2,-3   |   %R,%R,%I
   * DSLL  R1,R2,15   |   %R,%R,%U
   * LD    R1,vet(R0) |   %R,%L(%R)
   * J     loop       |   %E
   * BNE   R1,R2,loop |   %R,%R,%B
   * </pre>
   */
  public String getSyntax() {
    return syntax;
  }

  /**
   * Returns the name of the instruction as string.
   *
   * @return the instruction name(e.g. "DADD")
   */
  public String getName() {
    return name;
  }

  /**
   *
   *
   * <pre>
   * Returns a list with the instruction parameters
   * e.g. DADD R1,R2,R3 --> params= { 1, 2, 3}
   *      LD R1, var(R0)--> params= { 1, address memory corresponding with var, 0}
   * </pre>
   *
   * @return the list of parameters
   */
  public List<Integer> getParams() {
    return params;
  }

  /**
   *<pre>
   * Sets the instruction with a list of parameters
   *          Passed list                                      | Instruction to set
   * e.g. list= { 1, 2, 3}                                     |   DADD R1,R2,R3
   *      list= { 1, address memory corresponding with var, 0} |   LD R1, var(R0)
   *@param params The list of parameters
   **/
  public void setParams(List<Integer> params) {
    this.params = params;
  }

  /**
   * Sets the full name of the instruction as string
   *
   * @param value full name of the instruction (e.g. "DADD R1,R2,R3")
   */
  public void setFullName(String value) {
    fullname = value;
  }

  /**
   * Sets the comment of the instruction as string. The comment is the text after every semicolon in
   * the file .s
   *
   * @params value the full name of the instruction (e.g. "DADD R1,R2,R3")
   */
  public void setComment(String comment) {
    this.comment = comment;
  }

  /**
   * Gets the comment of the instruction as string.The comment is the text after every semicolon in
   * the file .s
   *
   * @return the comment
   */
  public String getComment() {
    return comment;
  }

  /**
   * Gets the comment of the instruction as string. The comment is the text after every semicolon in
   * the file .s
   *
   * @return the full name of the instruction (e.g. "DADD R1,R2,R3")
   */
  public String getFullName() {
    return fullname;
  }

  public String toString() {
    return fullname;
  }

  /**
   * Enable forwarding mode
   *
   * @param value This variable enable the forwarding modality if it is true
   */
  public static void setEnableForwarding(boolean value) {
    enableForwarding = value;
  }

  /**
   * Gets the state of EnableForwarding. This modality anticipates writing on registers at EX stage
   * for Alu instructions or at MEM stage for Load-Store instructions
   *
   * @return The forwarding state
   */
  public static boolean getEnableForwarding() {
    return enableForwarding;
  }

  /**
   *
   *
   * <pre>
   * Gets the label of the instruction. Labels may be assigned to instructions
   * when they are inserted in the symbol table
   * </pre>
   *
   * @return label of the instruction
   */
  public String getLabel() {
    return label;
  }

  /**
   *
   *
   * <pre>
   * Sets the label of the instruction. Labels may be assigned to instructions
   * when they are inserted in the symbol table
   * </pre>
   *
   * @value label of the instruction
   */
  public void setLabel(String value) {
    label = value;
  }
}
예제 #24
0
  /**
   * Name of the regions hit by a marker
   *
   * @param marker
   * @param showGeneDetails
   * @param compareTemplate
   * @param id : Only use genes or transcripts matching this ID
   * @return
   */
  public Set<String> regions(
      Marker marker, boolean showGeneDetails, boolean compareTemplate, String id) {
    if (Config.get().isErrorOnMissingChromo() && isChromosomeMissing(marker))
      throw new RuntimeEOFException("Chromosome missing for marker: " + marker);

    boolean hitChromo = false;
    HashSet<String> hits = new HashSet<String>();

    Markers intersects = query(marker);
    if (intersects.size() > 0) {
      for (Marker markerInt : intersects) {

        if (markerInt instanceof Chromosome) {
          hitChromo = true; // OK (we have to hit a chromosome, otherwise it's an error
          hits.add(markerInt.getClass().getSimpleName()); // Add marker name to the list
        } else if (markerInt instanceof Gene) {
          // Analyze Genes
          Gene gene = (Gene) markerInt;
          regionsAddHit(hits, gene, marker, showGeneDetails, compareTemplate);

          // For all transcripts...
          for (Transcript tr : gene) {
            if ((id == null)
                || gene.getId().equals(id)
                || tr.getId().equals(id)) { // Mathes ID? (...or no ID to match)

              // Does it intersect this transcript?
              if (tr.intersects(marker)) {
                regionsAddHit(hits, tr, marker, showGeneDetails, compareTemplate);

                // Does it intersect a UTR?
                for (Utr utr : tr.getUtrs())
                  if (utr.intersects(marker))
                    regionsAddHit(hits, utr, marker, showGeneDetails, compareTemplate);

                // Does it intersect an exon?
                for (Exon ex : tr)
                  if (ex.intersects(marker))
                    regionsAddHit(hits, ex, marker, showGeneDetails, compareTemplate);

                // Does it intersect an intron?
                for (Intron intron : tr.introns())
                  if (intron.intersects(marker))
                    regionsAddHit(hits, intron, marker, showGeneDetails, compareTemplate);
              }
            }
          }
        } else {
          // No ID to match?
          if (id == null) regionsAddHit(hits, markerInt, marker, showGeneDetails, compareTemplate);
          else {
            // Is ID from transcript?
            Transcript tr = (Transcript) markerInt.findParent(Transcript.class);
            if ((tr != null) && (tr.getId().equals(id))) {
              regionsAddHit(
                  hits,
                  markerInt,
                  marker,
                  showGeneDetails,
                  compareTemplate); // Transcript ID matches => count
            } else {
              // Is ID from gene?
              Gene gene = (Gene) markerInt.findParent(Gene.class);
              if ((gene != null) && (gene.getId().equals(id)))
                regionsAddHit(
                    hits,
                    markerInt,
                    marker,
                    showGeneDetails,
                    compareTemplate); // Gene ID matches => count
            }
          }
        }
      }
    }

    if (!hitChromo) throw new RuntimeException("ERROR: Out of chromosome range. " + marker);
    return hits;
  }
예제 #25
0
 /** Test a null resource. */
 public void testNullResource() {
   assertTrue(config.get("null resource") == null);
 }
예제 #26
0
  /**
   * Runs a match; configures the controller and list of proxies, and starts running the game in a
   * separate thread.
   */
  private void runMatch(final Match match, final ProxyWriter proxyWriter) throws Exception {
    if (Mode.HEADLESS.equals(mode) || Mode.SCRIMMAGE.equals(mode) || Mode.TOURNAMENT.equals(mode)) {
      this.state = State.RUNNING;
      this.runUntil = Integer.MAX_VALUE;
    }

    // Poll for RUNNING, if mode == Mode.LOCAL
    while (!State.RUNNING.equals(state)) {
      try {
        Thread.sleep(250);
      } catch (InterruptedException e) {
      }
    }

    long startTime = System.currentTimeMillis();

    say("-------------------- Match Starting --------------------");
    say(match.toString());

    // Compute the header and send it to all listeners.
    MatchHeader header = match.getHeader();
    proxyWriter.enqueue(header);
    ExtensibleMetadata exHeader = match.getHeaderMetadata();
    proxyWriter.enqueue(exHeader);

    this.state = State.RUNNING;

    int count = 0;

    final String throttle = options.get("bc.server.throttle");
    final int throttleCount = options.getInt("bc.server.throttle-count");
    final boolean doYield = "yield".equals(throttle);
    final boolean doSleep = "sleep".equals(throttle);

    // If there are more rounds to be run, run them and
    // and send the round (and optionally stats) bytes to
    // recipients.
    while (match.hasMoreRounds()) {

      // If not paused/stopped:
      switch (this.state) {
        case RUNNING:
          if (match.getRoundNumber() == runUntil) {
            Thread.sleep(25);
            break;
          }

          final RoundDelta round = match.getRound();
          if (round == null) break;

          if (GameState.BREAKPOINT.equals(match.getGameState())) {
            this.state = State.PAUSED;
            proxyWriter.enqueue(new PauseEvent());
          } else if (GameState.DONE.equals(match.getGameState())) {
            this.state = State.FINISHED;
          }

          proxyWriter.enqueue(round);

          if (count++ == throttleCount) {
            if (doYield) Thread.yield();
            else if (doSleep) Thread.sleep(1);
            count = 0;
          }

          break;

        case PAUSED:
          Thread.sleep(250);
          break;
      }
    }

    // Compute footer data.
    GameStats gameStats = match.getGameStats();
    MatchFooter footer = match.getFooter();

    proxyWriter.enqueue(gameStats);
    proxyWriter.enqueue(footer);

    say(match.getWinnerString());
    say("-------------------- Match Finished --------------------");

    double timeDiff = (System.currentTimeMillis() - startTime) / 1000.0;
    debug(String.format("match completed in %.4g seconds", timeDiff));

    this.state = State.FINISHED;
  }
예제 #27
0
  @Test
  public void shouldApplyDefaults() {
    Config config = new Config(new HashMap<String, String>(), MySettingsWithDefaults.class);

    assertThat(config.get(MySettingsWithDefaults.hello), is("Hello, World!"));
  }
예제 #28
0
  /**
   * Figure out what kind of static adapter type was specified. By default it's a 10genDEFAULT app
   */
  protected void _setStaticAdapterType() {

    /*
     *  app configuration steps could have set this already.  If so, don't bother doing anything
     */
    if (_staticAdapterType != AdapterType.UNSET) {
      log("Static adapter type has already been directly set to " + _staticAdapterType);
      return;
    }

    /*
     * check to see if overridden in 10gen.properties
     */
    String override = Config.get().getProperty(INIT_ADAPTER_TYPE);

    if (override != null) {
      AdapterType t = getAdapterTypeFromString(override);

      if (t == null) {
        log(
            "Static adapter type specified as override ["
                + override
                + "] unknown - will use _init file specified or default");
      } else {
        log("Static adapter type overridden by 10gen.properties or env. Value : " + override);
        _staticAdapterType = t;
        return;
      }
    }

    /*
     *  if not, use the one from _init file if specified
     */

    _staticAdapterType = AdapterType.DIRECT_10GEN;
    Object o = getFromInitScope(INIT_ADAPTER_TYPE);

    if (o == null) {
      log("Static adapter type not specified in _init file - using default value of DIRECT_10GEN");
      return;
    }

    if (!(o instanceof JSString)) {
      log("Static adapter type from _init file not a string - using default value of DIRECT_10GEN");
      return;
    }

    _staticAdapterType = getAdapterTypeFromString(o.toString());

    if (_staticAdapterType == null) {
      log(
          "Static adapter type from _init file ["
              + o.toString()
              + "] unknown - using default value of DIRECT_10GEN");
      _staticAdapterType = AdapterType.DIRECT_10GEN;
      return;
    }

    log("Static adapter type specified in _init file = " + _staticAdapterType);

    return;
  }
  /**
   * Establishes part of speech information for cas object.
   *
   * @param jcas
   */
  private void establishPartOfSpeechInformation(JCas jcas) {
    logger.log(Level.FINEST, "Establishing part of speech information...");

    PartOfSpeechTagger partOfSpeechTagger = null;
    Properties settings = new Properties();
    switch (language) {
      case ARABIC:
        partOfSpeechTagger = new StanfordPOSTaggerWrapper();
        settings.put(PartOfSpeechTagger.STANFORDPOSTAGGER_ANNOTATE_TOKENS, true);
        settings.put(PartOfSpeechTagger.STANFORDPOSTAGGER_ANNOTATE_SENTENCES, true);
        settings.put(PartOfSpeechTagger.STANFORDPOSTAGGER_ANNOTATE_POS, true);
        settings.put(
            PartOfSpeechTagger.STANFORDPOSTAGGER_MODEL_PATH,
            Config.get(Config.STANFORDPOSTAGGER_MODEL_PATH));
        settings.put(
            PartOfSpeechTagger.STANFORDPOSTAGGER_CONFIG_PATH,
            Config.get(Config.STANFORDPOSTAGGER_CONFIG_PATH));
        break;
      case VIETNAMESE:
        partOfSpeechTagger = new JVnTextProWrapper();
        settings.put(PartOfSpeechTagger.JVNTEXTPRO_ANNOTATE_TOKENS, true);
        settings.put(PartOfSpeechTagger.JVNTEXTPRO_ANNOTATE_SENTENCES, true);
        settings.put(PartOfSpeechTagger.JVNTEXTPRO_ANNOTATE_POS, true);
        settings.put(
            PartOfSpeechTagger.JVNTEXTPRO_WORD_MODEL_PATH,
            Config.get(Config.JVNTEXTPRO_WORD_MODEL_PATH));
        settings.put(
            PartOfSpeechTagger.JVNTEXTPRO_SENT_MODEL_PATH,
            Config.get(Config.JVNTEXTPRO_SENT_MODEL_PATH));
        settings.put(
            PartOfSpeechTagger.JVNTEXTPRO_POS_MODEL_PATH,
            Config.get(Config.JVNTEXTPRO_POS_MODEL_PATH));
        break;
      case CROATIAN:
        partOfSpeechTagger = new HunPosTaggerWrapper();
        settings.put(PartOfSpeechTagger.HUNPOS_LANGUAGE, language);
        settings.put(PartOfSpeechTagger.HUNPOS_ANNOTATE_TOKENS, true);
        settings.put(PartOfSpeechTagger.HUNPOS_ANNOTATE_POS, true);
        settings.put(PartOfSpeechTagger.HUNPOS_ANNOTATE_SENTENCES, true);
        settings.put(PartOfSpeechTagger.HUNPOS_MODEL_PATH, Config.get(Config.HUNPOS_MODEL_PATH));
        break;
      default:
        if (POSTagger.STANFORDPOSTAGGER.equals(posTagger)) {
          partOfSpeechTagger = new StanfordPOSTaggerWrapper();
          settings.put(PartOfSpeechTagger.STANFORDPOSTAGGER_ANNOTATE_TOKENS, true);
          settings.put(PartOfSpeechTagger.STANFORDPOSTAGGER_ANNOTATE_SENTENCES, true);
          settings.put(PartOfSpeechTagger.STANFORDPOSTAGGER_ANNOTATE_POS, true);
          settings.put(
              PartOfSpeechTagger.STANFORDPOSTAGGER_MODEL_PATH,
              Config.get(Config.STANFORDPOSTAGGER_MODEL_PATH));
          settings.put(
              PartOfSpeechTagger.STANFORDPOSTAGGER_CONFIG_PATH,
              Config.get(Config.STANFORDPOSTAGGER_CONFIG_PATH));
        } else if (POSTagger.TREETAGGER.equals(posTagger)) {
          partOfSpeechTagger = new TreeTaggerWrapper();
          settings.put(PartOfSpeechTagger.TREETAGGER_LANGUAGE, language);
          settings.put(PartOfSpeechTagger.TREETAGGER_ANNOTATE_TOKENS, true);
          settings.put(PartOfSpeechTagger.TREETAGGER_ANNOTATE_SENTENCES, true);
          settings.put(PartOfSpeechTagger.TREETAGGER_ANNOTATE_POS, true);
          settings.put(
              PartOfSpeechTagger.TREETAGGER_IMPROVE_GERMAN_SENTENCES,
              (language == Language.GERMAN));
          settings.put(
              PartOfSpeechTagger.TREETAGGER_CHINESE_TOKENIZER_PATH,
              Config.get(Config.CHINESE_TOKENIZER_PATH));
        } else if (POSTagger.HUNPOS.equals(posTagger)) {
          partOfSpeechTagger = new HunPosTaggerWrapper();
          settings.put(PartOfSpeechTagger.HUNPOS_LANGUAGE, language);
          settings.put(PartOfSpeechTagger.HUNPOS_ANNOTATE_TOKENS, true);
          settings.put(PartOfSpeechTagger.HUNPOS_ANNOTATE_POS, true);
          settings.put(PartOfSpeechTagger.HUNPOS_ANNOTATE_SENTENCES, true);
          settings.put(PartOfSpeechTagger.HUNPOS_MODEL_PATH, Config.get(Config.HUNPOS_MODEL_PATH));
        } else if (POSTagger.NO.equals(posTagger)) {
          partOfSpeechTagger = new AllLanguagesTokenizerWrapper();
        } else {
          logger.log(Level.FINEST, "Sorry, but you can't use that tagger.");
        }
    }
    partOfSpeechTagger.initialize(settings);
    partOfSpeechTagger.process(jcas);
    partOfSpeechTagger.reset();

    logger.log(Level.FINEST, "Part of speech information established");
  }
예제 #30
0
 /** Test the default config resource. */
 public void todoTestDefault() {
   config.loadResource(RESOURCE);
   assertEquals("sa", config.get("mangotiger.db.user"));
   assertEquals("x", config.get("x", "x"));
 }