예제 #1
0
  private static void addElement(
      List<String> lines, Patch patch, Map<String, RevFeatureType> featureTypes)
      throws IOException {
    String[] headerTokens = lines.get(0).split("\t");
    if (headerTokens.length == 4 || headerTokens.length == 3) { // feature or feature type
      // modified // modification
      if (lines.size() == 1) { // feature type
        FeatureTypeDiff diff =
            new FeatureTypeDiff(
                headerTokens[0],
                ObjectId.valueOf(headerTokens[1]),
                ObjectId.valueOf(headerTokens[2]));
        patch.addAlteredTree(diff);
      } else { // feature
        String element = Joiner.on("\n").join(lines.subList(1, lines.size()));
        ByteArrayInputStream stream;
        stream = new ByteArrayInputStream(element.getBytes(Charsets.UTF_8));
        String operation = headerTokens[0].trim();
        if (operation.equals("M")) {
          String fullPath = headerTokens[1].trim();
          String oldMetadataId = headerTokens[2].trim();
          String newMetadataId = headerTokens[3].trim();
          RevFeatureType newRevFeatureType = featureTypes.get(newMetadataId);
          RevFeatureType oldRevFeatureType = featureTypes.get(oldMetadataId);

          Map<PropertyDescriptor, AttributeDiff> map = Maps.newHashMap();
          for (int i = 1; i < lines.size(); i++) {
            addDifference(lines.get(i), map, oldRevFeatureType, newRevFeatureType);
          }
          FeatureDiff featureDiff =
              new FeatureDiff(fullPath, map, oldRevFeatureType, newRevFeatureType);
          patch.addModifiedFeature(featureDiff);
        } else if (operation.equals("A") || operation.equals("R")) {
          String fullPath = headerTokens[1].trim();
          String featureTypeId = headerTokens[2].trim();
          RevFeatureType revFeatureType;
          revFeatureType = featureTypes.get(featureTypeId);
          FeatureBuilder featureBuilder = new FeatureBuilder(revFeatureType);
          RevFeature revFeature = (RevFeature) serializer.read(null, stream);
          Feature feature = featureBuilder.build(NodeRef.nodeFromPath(fullPath), revFeature);
          if (operation.equals("R")) {
            patch.addRemovedFeature(fullPath, feature, revFeatureType);
          } else {
            patch.addAddedFeature(fullPath, feature, revFeatureType);
          }
        } else {
          throw new IllegalArgumentException("Wrong patch content: " + lines.get(0));
        }
      }

    } else if (headerTokens.length == 1) { // feature type definition
      String element = Joiner.on("\n").join(lines);
      ByteArrayInputStream stream = new ByteArrayInputStream(element.getBytes(Charsets.UTF_8));
      String[] tokens = lines.get(1).split("\t");
      RevFeatureType featureType = (RevFeatureType) serializer.read(null, stream);
      featureTypes.put(featureType.getId().toString(), featureType);
    } else {
      throw new IllegalArgumentException("Wrong patch content: " + lines.get(0));
    }
  }
예제 #2
0
  /**
   * Creates a patch object to apply on a GeoGig working tree
   *
   * @param reader the read from where to read the patch description
   * @return a Patch
   */
  public static Patch read(BufferedReader reader) {
    Preconditions.checkNotNull(reader);

    Patch patch = new Patch();
    List<String> subset = Lists.newArrayList();
    Map<String, RevFeatureType> featureTypes = Maps.newHashMap();
    try {
      String line;
      while ((line = reader.readLine()) != null) {
        line = line.trim();
        if (line.isEmpty() && !subset.isEmpty()) {
          addElement(subset, patch, featureTypes);
          subset.clear();
        } else if (!line.isEmpty()) {
          subset.add(line);
        }
      }
      if (!subset.isEmpty()) {
        addElement(subset, patch, featureTypes);
      }
      Set<Entry<String, RevFeatureType>> entries = featureTypes.entrySet();
      for (Iterator<Entry<String, RevFeatureType>> iterator = entries.iterator();
          iterator.hasNext(); ) {
        Entry<String, RevFeatureType> entry = iterator.next();
        patch.addFeatureType(entry.getValue());
      }
      return patch;
    } catch (IOException e) {
      throw new IllegalArgumentException("Can't read patch: " + e.getMessage());
    }
  }
예제 #3
0
  public static void write(Writer w, Patch patch) throws IOException {
    StringBuilder sb = new StringBuilder();
    List<RevFeatureType> featureTypes = patch.getFeatureTypes();
    for (RevFeatureType featureType : featureTypes) {
      ByteArrayOutputStream output = new ByteArrayOutputStream();
      serializer.write(featureType, output);
      sb.append(output.toString());
      sb.append('\n');
    }

    for (FeatureInfo feature : patch.getAddedFeatures()) {
      String path = feature.getPath();
      sb.append("A\t" + path + "\t" + feature.getFeatureType().getId() + "\n");
      ByteArrayOutputStream output = new ByteArrayOutputStream();
      RevFeature revFeature = RevFeatureBuilder.build(feature.getFeature());
      try {
        serializer.write(revFeature, output);
      } catch (IOException e) {
      }
      sb.append(output.toString());
      sb.append('\n');
    }
    for (FeatureInfo feature : patch.getRemovedFeatures()) {
      String path = feature.getPath();
      sb.append("R\t" + path + "\t" + feature.getFeatureType().getId() + "\n");
      ByteArrayOutputStream output = new ByteArrayOutputStream();
      RevFeature revFeature = RevFeatureBuilder.build(feature.getFeature());
      try {
        serializer.write(revFeature, output);
      } catch (IOException e) {
      }
      sb.append(output.toString());
      sb.append('\n');
    }
    for (FeatureDiff diff : patch.getModifiedFeatures()) {
      sb.append(
          "M\t"
              + diff.getPath()
              + "\t"
              + diff.getOldFeatureType().getId().toString()
              + "\t"
              + diff.getNewFeatureType().getId().toString()
              + "\n");
      sb.append(diff.asText() + "\n");
    }
    for (FeatureTypeDiff diff : patch.getAlteredTrees()) {
      sb.append(diff.toString() + "\n");
    }

    w.write(sb.toString());
    w.flush();
  }
  public XSSchemaSet getResult() throws SAXException {
    // run all the patchers
    for (Patch patcher : patchers) patcher.run();
    patchers.clear();

    // build the element substitutability map
    Iterator itr = schemaSet.iterateElementDecls();
    while (itr.hasNext()) ((ElementDecl) itr.next()).updateSubstitutabilityMap();

    // run all the error checkers
    for (Patch patcher : errorCheckers) patcher.run();
    errorCheckers.clear();

    if (hadError) return null;
    else return schemaSet;
  }
 public Patch[] extractPatch(Patch p) {
   // get all bytes from the (64 * ((32*pads)+settings)) + chain + system
   byte[] msgs = p.getByteArray();
   // create a Patch[] pa to hold the created Patches (2*Single and 64*Bank)
   Patch[] pa = new Patch[66];
   // do 64 times this:
   for (int i = 0; i < NR_OF_PATCHBANKS; i++) {
     // create a new byte array for a CompletePatch
     byte[] ptchbnk = new byte[PATCHBANKSIZE];
     // copy the current 915 bytes to this byte array
     System.arraycopy(msgs, i * PATCHBANKSIZE, ptchbnk, 0, PATCHBANKSIZE);
     // create a new CompletePatch with these bytes and put it in pa at the current position
     pa[i] = new Patch(ptchbnk, patch2Driver);
     // increase i with 1 or go on if i is already 63
   }
   // all CompletePatches are created
   // now create the chain patch byte array chn
   byte[] chn = new byte[CHAINSIZE];
   // copy the chain bytes into chn
   System.arraycopy(msgs, NR_OF_PATCHBANKS * PATCHBANKSIZE, chn, 0, CHAINSIZE);
   // create a new chain patch with these bytes and put it in the patcharray
   pa[64] = new Patch(chn, chainDriver);
   // now create the system byte array sstm
   byte[] sstm = new byte[SYSTEMSIZE];
   // copy the system bytes into sstm
   System.arraycopy(msgs, (NR_OF_PATCHBANKS * PATCHBANKSIZE) + CHAINSIZE, sstm, 0, SYSTEMSIZE);
   // create a new system patch with these bytes and put it in the patcharray
   pa[65] = new Patch(sstm, systemDriver);
   // return the full array of (64*CompletePatch)+Chain+System
   return pa;
 }
  @Override
  protected boolean build() {

    for (int i = 0; i < 5; i++) {

      int top = Random.IntRange(2, ROOM_TOP - 1);
      int bottom = Random.IntRange(ROOM_BOTTOM + 1, 22);
      Painter.fill(this, 2 + i * 4, top, 4, bottom - top + 1, Terrain.EMPTY);

      if (i == 2) {
        exit = (i * 4 + 3) + (top - 1) * WIDTH;
      }

      for (int j = 0; j < 4; j++) {
        if (Random.Int(2) == 0) {
          int y = Random.IntRange(top + 1, bottom - 1);
          map[i * 4 + j + y * WIDTH] =
              map[i * 4 + j + 1 + y * WIDTH] = map[i * 4 + j - 1 + y * WIDTH] = Terrain.WALL_DECO;
        }
      }
    }

    map[exit] = Terrain.LOCKED_EXIT;

    Painter.fill(
        this,
        ROOM_LEFT - 1,
        ROOM_TOP - 1,
        ROOM_RIGHT - ROOM_LEFT + 3,
        ROOM_BOTTOM - ROOM_TOP + 3,
        Terrain.WALL);
    Painter.fill(
        this,
        ROOM_LEFT,
        ROOM_TOP,
        ROOM_RIGHT - ROOM_LEFT + 1,
        ROOM_BOTTOM - ROOM_TOP + 1,
        Terrain.EMPTY);

    entrance =
        Random.Int(ROOM_LEFT + 1, ROOM_RIGHT - 1)
            + Random.Int(ROOM_TOP + 1, ROOM_BOTTOM - 1) * WIDTH;
    map[entrance] = Terrain.ENTRANCE;

    boolean[] patch = Patch.generate(0.45f, 6);
    for (int i = 0; i < LENGTH; i++) {
      if (map[i] == Terrain.EMPTY && patch[i]) {
        map[i] = Terrain.WATER;
      }
    }

    return true;
  }
예제 #7
0
  public byte[] create() throws IOException {
    List<Patch> patches = this.project.getIncludedPatches();

    int length = 0;
    length += HEADER_LENGTH;

    int indicesLength = Offset.SIZE * patches.size();
    length += indicesLength;

    byte[] metadataBytes = project.getAuthor().getBytes("UTF-8");
    length += metadataBytes.length;

    length += (Offset.SIZE * patches.size());

    for (Patch patch : patches) {
      length += patch.getValue().getBytesLength();
    }

    byte[] mod = new byte[length];

    writeBytes(mod, new byte[] {(byte) 0xFF, 0x50, 0x54, 0x50, 0x00, (byte) patches.size()}, 0);
    writeBytes(mod, metadataBytes, HEADER_LENGTH + indicesLength);

    int patchStart = HEADER_LENGTH + indicesLength + metadataBytes.length;

    for (int i = 0; i < patches.size(); i++) {
      Patch patch = patches.get(i);

      writeBytes(mod, Value.intToByteArray(patchStart), HEADER_LENGTH + Offset.SIZE * i);
      int offsetBytesLength = writeBytes(mod, patch.getOffset().getBytes(), patchStart);
      int valueBytesLength = writeBytes(mod, patch.getValue().getBytes(), patchStart + Offset.SIZE);

      patchStart += (offsetBytesLength + valueBytesLength);
    }
    return mod;
  }
  @Test(
      groups = "integration",
      dependsOnMethods = {"testGetCreditCard"})
  public void testUpdateCreditCard() throws PayPalRESTException {
    logger.info("**** Update CreditCard ****");
    logger.info("Generated Access Token = " + TokenHolder.accessToken);

    // set up patch request
    Patch patch = new Patch();
    patch.setOp("replace");
    patch.setPath("/expire_year");
    patch.setValue(new Integer(2020));
    List<Patch> patchRequest = new ArrayList<Patch>();
    patchRequest.add(patch);

    // send patch request
    CreditCard creditCard = new CreditCard();
    creditCard.setId(createdCreditCardId);
    CreditCard retrievedCreditCard = creditCard.update(TokenHolder.accessToken, patchRequest);

    logger.info("Request = " + CreditCard.getLastRequest());
    logger.info("Response = " + CreditCard.getLastResponse());
    Assert.assertEquals(2020, retrievedCreditCard.getExpireYear());
  }
예제 #9
0
  // HACK?
  public void setPatch(Patch inPatch) {
    // update the "model"
    this.bank.setPatch(inPatch);

    // give the user some nice visual feedback that the window has changed
    // (most likely Mac only)
    setBankModified(true);

    // update the *other* "model" - sigh
    int patchNumber = inPatch.getPatchNumber();
    int row = patchNumber / kTableColumnCount;
    int col = patchNumber % kTableColumnCount;

    this.table.setValueAt(this.bank.getPatch(patchNumber), row, col);
  }
예제 #10
0
  public void actionPerformed(ActionEvent inEvent) {
    String actionCommand = inEvent.getActionCommand();

    if (actionCommand.equalsIgnoreCase("KEYBOARD_CLOSE_ACTION")) {
      setVisible(false);

      if (!isVisible()) {
        dispose();
      }
    } else if (actionCommand.equalsIgnoreCase("SAVE")
        || actionCommand.equalsIgnoreCase("SAVE_AS")) {
      boolean askForFile = false;

      if (actionCommand.equalsIgnoreCase("SAVE_AS")) {
        askForFile = true;
      } else {
        if (this.file == null) {
          askForFile = true;
        }
      }

      saveBank(askForFile);
    } else if (actionCommand.equalsIgnoreCase("SEND_BANK")) {
      int response =
          ControlWindow.getInstance()
              .showConfirmDialog("Transmit", "OK to overwrite bank in Prophet?");

      if (response == JOptionPane.YES_OPTION) {
        try {
          ControlWindow.getInstance().sendMidiMessage(Machine.makeBankDumpMessage(this.bank));

          // this bank is now in the Prophet
          setBankInProphet(true);
        } catch (Exception inException) {
          ControlWindow.getInstance().showErrorDialog("Error", inException);
        }
      }
    } else if (actionCommand.equalsIgnoreCase("SEND_PATCH")) {
      int row = this.table.getSelectedRow();
      int column = this.table.getSelectedColumn();

      if (row == -1 || column == -1) {
        ControlWindow.getInstance()
            .showErrorDialog("Error", "Please select a patch location to send.");
      } else {
        int patchNumber = (row * kTableColumnCount) + column;
        Patch patch = this.bank.getPatch(patchNumber);

        StringBuffer buffer = new StringBuffer();
        buffer.append("OK to overwrite patch ");
        buffer.append(patch.getPatchNumber());
        buffer.append(" in Prophet?");

        int response = ControlWindow.getInstance().showConfirmDialog("Transmit", buffer.toString());

        if (response == JOptionPane.YES_OPTION) {
          try {
            ControlWindow.getInstance().sendMidiMessage(Machine.makePatchDumpMessage(patch));
          } catch (Exception inException) {
            ControlWindow.getInstance().showErrorDialog("Error", inException);
          }
        }
      }
    } else if (actionCommand.equalsIgnoreCase("VARY")) {
      int row = this.table.getSelectedRow();
      int column = this.table.getSelectedColumn();

      if (row == -1 || column == -1) {
        ControlWindow.getInstance()
            .showErrorDialog("Error", "Please select a patch location to vary.");
      } else {
        int patchNumber = (row * kTableColumnCount) + column;
        Patch patch = this.bank.getPatchCopy(patchNumber);
        VaryWindow varyWindow = new VaryWindow(patch);
        varyWindow.setLocationRelativeTo(null);
        varyWindow.setVisible(true);
      }
    } else if (actionCommand.equalsIgnoreCase("COPY")) {
      int row = this.table.getSelectedRow();
      int column = this.table.getSelectedColumn();

      if (row == -1 || column == -1) {
        ControlWindow.getInstance()
            .showErrorDialog("Error", "Please select a patch location to copy.");
      } else {
        int patchNumber = (row * kTableColumnCount) + column;
        Patch patch = this.bank.getPatchCopy(patchNumber);
        TransferablePatch transferable = new TransferablePatch(patch);
        Toolkit.getDefaultToolkit().getSystemClipboard().setContents(transferable, this);
      }
    } else if (actionCommand.equalsIgnoreCase("PASTE")) {
      int row = this.table.getSelectedRow();
      int column = this.table.getSelectedColumn();

      if (row == -1 || column == -1) {
        ControlWindow.getInstance()
            .showErrorDialog("Error", "Please select a patch location to paste.");
      } else {
        int patchNumber = (row * kTableColumnCount) + column;

        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
        Transferable transferable = clipboard.getContents(this);

        if (transferable != null) {
          DataFlavor flavour = new DataFlavor(Patch.class, "Prophet VS Patch");

          try {
            Object data = transferable.getTransferData(flavour);

            if (data != null && data instanceof Patch) {
              Patch patch = (Patch) data;

              // copy the patch!
              // it might get pasted twice and this is only a reference
              Patch copy = new Patch(patch);

              // override the patch number in the patch
              // so it goes in the right place
              copy.setPatchNumber(patchNumber);
              setPatch(copy);
            }
          } catch (Exception inException) {
            System.err.println(inException);
          }
        }
      }
    } else if (actionCommand.equalsIgnoreCase("SWAP_PASTE")) {
      // this is a nondestructive paste which swaps the selection & paste buffer

      int row = this.table.getSelectedRow();
      int column = this.table.getSelectedColumn();

      if (row == -1 || column == -1) {
        ControlWindow.getInstance()
            .showErrorDialog("Error", "Please select a patch location to swap paste.");
      } else {
        int patchNumber = (row * kTableColumnCount) + column;

        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
        Transferable transferable = clipboard.getContents(this);

        if (transferable != null) {
          DataFlavor flavour = new DataFlavor(Patch.class, "Prophet VS Patch");

          try {
            Object data = transferable.getTransferData(flavour);

            if (data != null && data instanceof Patch) {
              Patch pastePatch = (Patch) data;

              // ok now copy the selection into the clipboard
              Patch copyPatch = this.bank.getPatchCopy(patchNumber);
              transferable = new TransferablePatch(copyPatch);
              Toolkit.getDefaultToolkit().getSystemClipboard().setContents(transferable, this);

              // and now paste the saved patch into place
              // override the patch number in the patch
              // so it goes in the right place
              pastePatch.setPatchNumber(patchNumber);
              setPatch(pastePatch);
            }
          } catch (Exception inException) {
            System.err.println(inException);
          }
        }
      }
    }
  }
예제 #11
0
 protected boolean[] grass() {
   return Patch.generate(this, feeling == Feeling.GRASS ? 0.55f : 0.30f, 3);
 }
예제 #12
0
 protected boolean[] water() {
   return Patch.generate(this, feeling == Feeling.WATER ? 0.55f : 0.40f, 6);
 }
 protected void addPatch(Patch patch) {
   patchs.add(patch);
   patch.setListener(this);
 }
예제 #14
0
 protected boolean[] grass() {
   return Patch.generate(this, feeling == Feeling.GRASS ? 0.60f : 0.40f, 4);
 }
예제 #15
0
 protected boolean[] water() {
   return Patch.generate(this, feeling == Feeling.WATER ? 0.60f : 0.45f, 5);
 }
예제 #16
0
 protected boolean[] water() {
   return Patch.generate(feeling == Feeling.CHASM ? 0.60f : 0.45f, 6);
 }
예제 #17
0
  public static void main(String[] args) {
    int anzVersuche = 100000;
    Patch p = new Patch();
    Karte[] karten = new Karte[52];
    Karte[] hand = new Karte[5];
    Methoden m = new Methoden();
    JDBC j = new JDBC();
    int pz = 0, dpz = 0, fhz = 0, poz = 0, flz = 0, sz = 0, sfz = 0, rfz = 0, dz = 0;

    for (int i = 0; i < anzVersuche; i++) {

      karten = p.kartenErzeugen();

      hand = p.handSuchen(karten);

      switch (m.ParrDrillingPoker(hand)) {
          // paar
        case (1):
          pz++;
          break;
          // zwei paare
        case (2):
          dpz++;
          break;
          // drilling
        case (3):
          dz++;
          break;
          // poker
        case (4):
          poz++;
          break;
          // fullhouse
        case (5):
          fhz++;
          break;
      }

      if ((m.IstFlush(hand) == true) && (m.Straße(hand) == false)) {
        flz++;
      }
      if ((m.IstFlush(hand) == true) && (m.Straße(hand) == true)) {
        sfz++;
      }
      if ((m.IstFlush(hand) == false) && (m.Straße(hand) == true)) {
        sz++;
      }
      if ((m.Royal(hand) == true) && (m.IstFlush(hand) == true)) {
        rfz++;
      }
    }

    paar = pz;
    doppelpaar = dpz;
    drilling = dz;
    poker = poz;
    fullhouse = fhz;
    flush = flz;
    straße = sz;
    straightFlush = sfz;
    roylflush = rfz;
    highkart =
        anzVersuche
            - paar
            - doppelpaar
            - drilling
            - poker
            - fullhouse
            - flush
            - straße
            - straightFlush
            - roylflush;
    j.dadenbankErzeugen();
    j.tableErzeugen();
    j.insertTable();
    // j.drop();
    j.select();
  }