Exemple #1
0
  /**
   * Changes the sequence itself. BaseSequence doesn't care what sequence you try feeding in here.
   */
  public void changeSequence(String seq) throws SequenceException {
    StringBuffer buff = new StringBuffer();

    // important step: is this sequence actually 'valid' (are all the brackets closed?)
    //
    // Also: convert round brackets into 'system-standard' (i.e. TaxonDNA specific) square brackets.
    //
    int count = 0;
    int length = 0;
    for (int x = 0; x < seq.length(); x++) {
      char ch = seq.charAt(x);

      // convert round brackets to square
      if (ch == '(') ch = '[';
      else if (ch == ')') ch = ']';

      // count the brackets!
      if (ch == '[') count++;
      if (ch == ']') count--;

      // this way, we delete this *once*
      if (count == 0) length++;

      buff.append(ch);
    }

    if (count != 0)
      throw new SequenceException(
          getFullName(),
          "This sequence cannot be changed to the specified sequence, as the brackets are not properly closed. Please ensure that all brackets are closed, and try again.");

    seq = buff.toString(); // hey, if we _can_ ...

    synchronized (this) {
      this.id = new UUID();
      this.seq = seq.toCharArray();
      this.len = length;
    }
  }
Exemple #2
0
  /**
   * Returns a subsequence of this sequence. If the subsequence is completely 'valid', we might
   * return a Sequence! Otherwise, we return a BaseSequence.
   */
  public Sequence getSubsequence(int from, int to) throws SequenceException {
    // make sure we're not being fed garbage
    if (from < 1
        || // the first char is index = 1
        to > getLength() // the 'to' field must not be greater than the length of the sequence
    )
      throw new SequenceException(
          this.getFullName(),
          "There is no subsequence at (" + from + ", " + to + ") in sequence " + this);

    if (to < from) {
      throw new SequenceException(
          this.getFullName(),
          "I cannot generate the reverse-complement of this sequence, since I do not understand what sort of data it is.");
    }

    // so, now we have a 'from' and a 'to'.
    // Let's get cracking!
    java.io.StringReader r = new java.io.StringReader(getSequence());
    StringBuffer output = new StringBuffer();

    // System.err.println("Base.cut: from: " + from + " to: " + to);

    boolean writing = false;
    int char_at = 0;
    try {
      while (r.ready()) {
        int x = r.read();

        if (x == -1) throw new java.io.EOFException();

        if (char_at == from - 1) // off by one, here
        writing = true;

        if (char_at == to) // off by one, here too, but for a slightly different reason
        writing = false;

        if (x == '(' || x == '[') {
          int initial_char = x;
          int final_char = ' ';

          if (x == '(') final_char = ')';
          else final_char = ']';

          // convert brackets to the Real Thing
          if (writing) output.append('[');

          while (x != ']') {
            x = r.read();

            if (x == final_char) x = ']';

            if (x == -1) throw new java.io.EOFException();

            if (writing) output.append((char) x);
          }
        } else {
          if (writing) output.append((char) x);
        }

        char_at++;
      }
    } catch (java.io.EOFException e) {
      // okay, done.
      // did you know that
    } catch (java.io.IOException e) {
      throw new RuntimeException("Why is reading from a string causing an IOException?! " + e);
    }

    String seq_str = output.toString();
    // System.err.println("What've we got: " + seq_str);
    Sequence seq =
        BaseSequence.createSequence(
            getFullName() + " (segment:" + from + "-" + to + ":inclusive)", seq_str);

    // System.err.println("Ended up with: " + seq);

    return seq;
  }