Esempio n. 1
1
  static void serTest(Map s, int size) throws Exception {
    if (!(s instanceof Serializable)) return;
    System.out.print("Serialize              : ");

    for (int i = 0; i < size; i++) {
      s.put(new Integer(i), Boolean.TRUE);
    }

    long startTime = System.currentTimeMillis();

    FileOutputStream fs = new FileOutputStream("MapCheck.dat");
    ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(fs));
    out.writeObject(s);
    out.close();

    FileInputStream is = new FileInputStream("MapCheck.dat");
    ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(is));
    Map m = (Map) in.readObject();

    long endTime = System.currentTimeMillis();
    long time = endTime - startTime;

    System.out.print(time + "ms");

    if (s instanceof IdentityHashMap) return;
    reallyAssert(s.equals(m));
  }
Esempio n. 2
0
 /**
  * Copy method. Return an exact copy of this column. A deep copy is attempted, but if it fails a
  * new column will be created, initialized with the same data as this column.
  *
  * @return A new Column with a copy of the contents of this column.
  */
 public Column copy() {
   LongColumn newCol;
   try {
     ByteArrayOutputStream baos = new ByteArrayOutputStream();
     ObjectOutputStream oos = new ObjectOutputStream(baos);
     oos.writeObject(this);
     byte buf[] = baos.toByteArray();
     oos.close();
     ByteArrayInputStream bais = new ByteArrayInputStream(buf);
     ObjectInputStream ois = new ObjectInputStream(bais);
     newCol = (LongColumn) ois.readObject();
     ois.close();
     return newCol;
   } catch (Exception e) {
     // newCol = new LongColumn(getNumRows());
     long[] newVals = new long[getNumRows()];
     for (int i = 0; i < getNumRows(); i++)
       // newCol.setLong(internal[i], i);
       newVals[i] = getLong(i);
     boolean[] miss = new boolean[internal.length];
     boolean[] em = new boolean[internal.length];
     for (int i = 0; i < internal.length; i++) {
       miss[i] = missing[i];
       em[i] = empty[i];
     }
     newCol = new LongColumn(newVals, miss, em, getLabel(), getComment());
     return newCol;
   }
 }
 private void load(InputStream is) throws IOException, ClassNotFoundException, CoreException {
   // try to read the file version number. Pre 2.0 versions had no number
   int version = is.read();
   if (version == KEYRING_FILE_VERSION) {
     // read the authorization data
     CipherInputStream cis = new CipherInputStream(is, password);
     ObjectInputStream ois = new ObjectInputStream(cis);
     try {
       authorizationInfo = (Hashtable) ois.readObject();
       protectionSpace = (Hashtable) ois.readObject();
     } finally {
       ois.close();
     }
   } else {
     // the format has changed, just log a warning
     InternalPlatform.getDefault()
         .log(
             new Status(
                 IStatus.WARNING,
                 Platform.PI_RUNTIME,
                 Platform.FAILED_READ_METADATA,
                 Messages.meta_authFormatChanged,
                 null));
     // close the stream and save a new file in the correct format
     try {
       is.close();
     } catch (IOException e) {
       // ignore failure to close
     }
     needsSaving = true;
     save();
   }
 }
Esempio n. 4
0
 public static TaggedDictionary loadFrom(File f) throws Exception {
   FileInputStream fi = null;
   BufferedInputStream bi = null;
   ObjectInputStream oin = null;
   TaggedDictionary result = null;
   try {
     fi = new FileInputStream(f);
     bi = new BufferedInputStream(fi, 1000000);
     oin = new ObjectInputStream(bi);
     result = new TaggedDictionary();
     result.readFrom(oin);
   } finally {
     try {
       oin.close();
     } catch (Exception exx) {
     }
     try {
       bi.close();
     } catch (Exception exx) {
     }
     try {
       fi.close();
     } catch (Exception exx) {
     }
   }
   return result;
 }
Esempio n. 5
0
 public static WordClass[] loadWordClassesFrom(File f) throws Exception {
   FileInputStream fi = null;
   BufferedInputStream bi = null;
   ObjectInputStream oin = null;
   WordClass result[];
   try {
     fi = new FileInputStream(f);
     bi = new BufferedInputStream(fi, 1000000);
     oin = new ObjectInputStream(bi);
     result = (WordClass[]) oin.readObject();
   } finally {
     try {
       oin.close();
     } catch (Exception exx) {
     }
     try {
       bi.close();
     } catch (Exception exx) {
     }
     try {
       fi.close();
     } catch (Exception exx) {
     }
   }
   return result;
 }
Esempio n. 6
0
  public void run() {
    boolean gotByePacket = false;

    try {
      /* stream to read from client */
      ObjectInputStream fromClient = new ObjectInputStream(socket.getInputStream());
      Packet packetFromClient;

      /* stream to write back to client */
      ObjectOutputStream toClient = new ObjectOutputStream(socket.getOutputStream());

      // writer to the disk
      // String file = "list";

      // while (( packetFromClient = (Packet) fromClient.readObject()) != null) {
      /* create a packet to send reply back to client */

      packetFromClient = (Packet) fromClient.readObject();
      Packet packetToClient = new Packet();
      packetToClient.type = Packet.LOOKUP_REPLY;
      packetToClient.data = new ArrayList<String>();

      if (packetFromClient.type == Packet.LOOKUP_REQUEST) {
        // called by client
        System.out.println("Request from Client:" + packetFromClient.type);

        packetToClient.type = Packet.LOOKUP_REPLY;
        long start = packetFromClient.start;
        long length = packetFromClient.length;

        if (start > dict.size()) {
          // set the error field, return
          packetToClient.error_code = Packet.ERROR_OUT_OF_RANGE;
        } else {
          for (int i = (int) start; i < start + length && i < dict.size(); i++) {
            packetToClient.data.add(dict.get(i));
          }
        }

        toClient.writeObject(packetToClient);
        // continue;
      }

      // }

      /* cleanup when client exits */
      fromClient.close();
      toClient.close();
      socket.close();

      // close the filehandle

    } catch (IOException e) {
      if (!gotByePacket) {
        e.printStackTrace();
      }
    } catch (ClassNotFoundException e) {
      if (!gotByePacket) e.printStackTrace();
    }
  }
Esempio n. 7
0
  /**
   * Load the database from the database file given in "database.json" if the file doesn't exist, it
   * gets created here if the file has a database in it already, it is loaded here
   *
   * @return false if there is an error opening the database
   */
  public boolean open() {
    try {
      System.out.println(dbPath);
      File dbFile = new File(dbPath);

      // Only read the database from the file if it exists
      if (dbFile.exists()) {
        FileInputStream fileIn = new FileInputStream(dbPath);
        ObjectInputStream in = new ObjectInputStream(fileIn);
        // load the database here
        database = (HashMap<K, V>) in.readObject();
        // make sure the streams close properly
        in.close();
        fileIn.close();

        Debug.println("Database loaded");
      } else {
        dbFile.getParentFile().mkdirs();
        dbFile.createNewFile();

        Debug.println("Database created");
      }
      return true;
    } catch (Exception e) {
      System.err.println("Error opening database");
      System.err.println(e);
      return false;
    }
  }
Esempio n. 8
0
 /**
  * Load, creates if missing, information about the local users
  *
  * @param file The file with the data
  * @throws IOException On I/O error
  */
 private static void loadMe(final String file) throws IOException {
   myFile = file;
   final File $file = new File(file);
   if ($file.exists() == false) {
     myUUID = UUID.randomUUID();
     updateMe(null);
   } else {
     ObjectInputStream is = null;
     try {
       is = new ObjectInputStream(new BufferedInputStream(new FileInputStream($file)));
       Object obj;
       for (; ; )
         if ((obj = is.readObject()) instanceof UUID) {
           System.err.println("Loading UUID: " + obj);
           myUUID = (UUID) obj;
           break;
         } else {
           System.err.println("Loading DNS: " + obj);
           myDNSes.add((String) obj);
         }
     } catch (final ClassNotFoundException err) {
       throw new IOError(err);
     } finally {
       if (is != null)
         try {
           is.close();
         } catch (final Throwable err) {
           // Do nothing
         }
     }
   }
 }
Esempio n. 9
0
  public void testSerial() {
    assertTrue(_nbhm.isEmpty());
    final String k1 = "k1";
    final String k2 = "k2";
    assertThat(_nbhm.put(k1, "v1"), nullValue());
    assertThat(_nbhm.put(k2, "v2"), nullValue());

    // Serialize it out
    try {
      FileOutputStream fos = new FileOutputStream("NBHM_test.txt");
      ObjectOutputStream out = new ObjectOutputStream(fos);
      out.writeObject(_nbhm);
      out.close();
    } catch (IOException ex) {
      ex.printStackTrace();
    }

    // Read it back
    try {
      File f = new File("NBHM_test.txt");
      FileInputStream fis = new FileInputStream(f);
      ObjectInputStream in = new ObjectInputStream(fis);
      NonBlockingIdentityHashMap nbhm = (NonBlockingIdentityHashMap) in.readObject();
      in.close();
      assertThat(
          "serialization works",
          nbhm.toString(),
          anyOf(is("{k1=v1, k2=v2}"), is("{k2=v2, k1=v1}")));
      if (!f.delete()) throw new IOException("delete failed");
    } catch (IOException ex) {
      ex.printStackTrace();
    } catch (ClassNotFoundException ex) {
      ex.printStackTrace();
    }
  }
Esempio n. 10
0
  public static GA GAWithCheckpoint(String checkpoint) throws Exception {
    File checkpointFile = new File(checkpoint);
    FileInputStream zin = new FileInputStream(checkpointFile);
    GZIPInputStream in = new GZIPInputStream(zin);
    ObjectInputStream oin = new ObjectInputStream(in);

    Checkpoint ckpt = (Checkpoint) oin.readObject();
    GA ga = ckpt.ga;
    ga._checkpoint = ckpt;
    ckpt.checkpointNumber++; // because it gets increased only after ckpt is
    // written

    oin.close();

    System.out.println(ckpt.report.toString());

    // Do we want to append to the file if it exists? Or just overwrite it?
    // Heu! Quae enim quaestio animas virorum vero pertemptit.
    // Wowzers! This is, indeed, a question that truly tests mens' souls.

    if (ga._outputfile != null) ga._outputStream = new FileOutputStream(new File(ga._outputfile));
    else ga._outputStream = System.out;

    return ga;
  }
 private void setHPubAccessHandleString(String encodedHandleWithSpaces) {
   String encodedHandle = removeSpaceCharacters(encodedHandleWithSpaces);
   if ((encodedHandle == null) || (encodedHandle.length() < 5)) {
     return;
   }
   try {
     byte[] handleByteArray = null;
     sun.misc.BASE64Decoder dec = new sun.misc.BASE64Decoder();
     try {
       handleByteArray = dec.decodeBuffer(encodedHandle);
     } catch (Exception e) {
       System.out.println("AccessEJBTemplate::setHPubAccessHandleString()  decoding buffer");
     }
     ;
     ByteArrayInputStream bais = new ByteArrayInputStream(handleByteArray);
     javax.ejb.Handle h1 = null;
     try {
       ObjectInputStream ois = new ObjectInputStream(bais);
       hPubAccessHandle = (javax.ejb.Handle) ois.readObject();
     } catch (Exception ioe) {
       System.out.println("Exception reading handle object");
     }
   } catch (Exception e) {
     e.printStackTrace(System.err);
     System.out.println("Exception AccessEJBTemplate::setHPubAccessHandleString()");
   }
   return;
 }
Esempio n. 12
0
 public static Object loadObjectFromFile(String fileName) throws Exception {
   FileInputStream fis = new FileInputStream(fileName);
   ObjectInputStream ois = new ObjectInputStream(fis);
   Object obj = ois.readObject();
   ois.close();
   return obj;
 }
Esempio n. 13
0
 /**
  * Read an object from a deserialization stream.
  *
  * @param s An object deserialization stream.
  * @throws ClassNotFoundException If the object's class read from the stream cannot be found.
  * @throws IOException If an error occurs reading from the stream.
  */
 @SuppressWarnings("unchecked")
 private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException {
   s.defaultReadObject();
   final T value = (T) s.readObject();
   final List<Node<T>> children = (List<Node<T>>) s.readObject();
   node = new Node<>(value, children);
 }
Esempio n. 14
0
 public void testResultListSerializableComplex() throws Exception {
   // Create mutliple objects
   removeAll(Object.class);
   for (int i = 0; i < 20; i++) getStore().save(new Book("Learning Java 1." + i, "" + i));
   for (int i = 0; i < 20; i++) getStore().save(new Referrer(i));
   for (int i = 0; i < 20; i++) getStore().save(new User());
   for (int i = 0; i < 20; i++) getStore().save(new MapHolder());
   // Get the result list for all objects
   List result = getStore().find("find object");
   Assert.assertEquals(result.size(), 80);
   // Now serialize
   ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
   ObjectOutputStream objectOut = new ObjectOutputStream(byteOut);
   objectOut.writeObject(result);
   objectOut.close();
   // Close the store, let's pretend we're outside it
   tearDownStore();
   try {
     // Deserialize
     ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
     ObjectInputStream objectIn = new ObjectInputStream(byteIn);
     List deList = (List) objectIn.readObject();
     // Test object
     Assert.assertEquals(deList.size(), 80);
     Assert.assertEquals(getCount(deList, Book.class), 20);
     Assert.assertEquals(getCount(deList, Referrer.class), 20);
     Assert.assertEquals(getCount(deList, User.class), 20);
     Assert.assertEquals(getCount(deList, MapHolder.class), 20);
   } finally {
     // Setup store for next tests
     setUpStore();
   }
 }
Esempio n. 15
0
 /**
  * Loads the friends list
  *
  * @param file The file with the data
  * @throws IOException On I/O error
  */
 private static void loadFriends(final String file) throws IOException {
   friendFile = file;
   final File $file = new File(file);
   friends = new HashSet<Player>();
   if ($file.exists() == false) saveFriends();
   else {
     ObjectInputStream is = null;
     Object obj = null;
     try {
       is = new ObjectInputStream(new BufferedInputStream(new FileInputStream($file)));
       while ((obj = is.readObject()) != null) friends.add((Player) obj);
     } catch (final ClassNotFoundException err) {
       throw new IOError(err);
     } catch (final IOException | RuntimeException | Error err) {
       System.err.println(err);
       System.err.println("obj: " + obj);
       System.err.println("is: " + is);
       throw err;
     } finally {
       if (is != null)
         try {
           is.close();
         } catch (final Throwable err) {
           // Do nothing
         }
     }
   }
 }
Esempio n. 16
0
  /** DOCUMENT ME! */
  public void loadRaids() {
    File f = new File(REPO);

    if (!f.exists()) {
      return;
    }

    FileInputStream fIn = null;
    ObjectInputStream oIn = null;

    try {
      fIn = new FileInputStream(REPO);
      oIn = new ObjectInputStream(fIn);
      // de-serializing object
      raids = (HashMap<String, GregorianCalendar>) oIn.readObject();
    } catch (IOException e) {
      e.printStackTrace();
    } catch (ClassNotFoundException e) {
      e.printStackTrace();
    } finally {
      try {
        oIn.close();
        fIn.close();
      } catch (IOException e1) {
        e1.printStackTrace();
      }
    }
  }
Esempio n. 17
0
  public static void main(String[] argv) {
    String hostName;
    if (argv.length == 0) hostName = "localhost";
    else hostName = argv[0];

    try {
      Socket sock = new Socket(hostName, TIME_PORT);
      ObjectInputStream is = new ObjectInputStream(new BufferedInputStream(sock.getInputStream()));

      // Read and validate the Object
      Object o = is.readObject();
      if (o == null) {
        System.err.println("Read null from server!");
      } else if ((o instanceof Date)) {

        // Valid, so cast to Date, and print
        Date d = (Date) o;
        System.out.println("Server host is " + hostName);
        System.out.println("Time there is " + d.toString());

      } else {
        throw new IllegalArgumentException("Wanted Date, got " + o);
      }
    } catch (ClassNotFoundException e) {
      System.err.println("Wanted date, got INVALID CLASS (" + e + ")");
    } catch (IOException e) {
      System.err.println(e);
    }
  }
  private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
    // We have to call defaultReadObject first.
    in.defaultReadObject();

    // Read version number.
    byte major = in.readByte();
    byte minor = in.readByte();
    if (major != 1) {
      throw new IOException("LogRecord: bad version: " + major + "." + minor);
    }
    int len = in.readInt();
    if (len == -1) {
      parameters = null;
    } else {
      parameters = new Object[len];
      for (int i = 0; i < parameters.length; i++) {
        parameters[i] = in.readObject();
      }
    }
    // If necessary, try to regenerate the resource bundle.
    if (resourceBundleName != null) {
      try {
        resourceBundle = ResourceBundle.getBundle(resourceBundleName);
      } catch (MissingResourceException ex) {
        // This is not a good place to throw an exception,
        // so we simply leave the resourceBundle null.
        resourceBundle = null;
      }
    }

    needToInferCaller = false;
  }
  /**
   * @param it Iterator.
   * @param bound Value bound.
   * @throws Exception If failed.
   */
  private void testIteratorSerialization(Iterator<?> it, int bound) throws Exception {
    ByteArrayOutputStream byteOut = new ByteArrayOutputStream();

    try (ObjectOutputStream out = new ObjectOutputStream(byteOut)) {
      out.writeObject(it);
    }

    byte[] bytes = byteOut.toByteArray();

    ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bytes));

    Iterator<?> it0 = (Iterator<?>) in.readObject();

    int cnt = 0;

    while (it0.hasNext()) {
      Object obj = it0.next();

      if (obj instanceof GridCacheEntry) checkEntry((GridCacheEntry<String, Integer>) obj, bound);
      else if (obj instanceof String) checkKey((String) obj);
      else if (obj instanceof Integer) checkValue((Integer) obj, bound);
      else assert false : "Wrong type.";

      cnt++;
    }

    assert cnt == bound;
  }
Esempio n. 20
0
  public static void main(String args[]) {
    List<User> users =
        Arrays.asList(
            new User("jack", 40), new User("john", 32), new User("jill", 47), new User("mike", 28));

    List<User> readUsers = null;

    try {
      ObjectOutputStream objWrite = new ObjectOutputStream(new FileOutputStream(output_fn));

      try {
        objWrite.writeObject(users);
        objWrite.flush();
      } finally {
        objWrite.close();
      }

      // Olion tietojen lukeminen
      ObjectInputStream objRead = new ObjectInputStream(new FileInputStream(output_fn));

      try {
        readUsers = (List<User>) objRead.readObject();
      } finally {
        objRead.close();
      }

    } catch (IOException | ClassNotFoundException ex) {
      System.out.println(ex);
    }
    for (User user : readUsers) {
      System.out.print(user.name + ": ");
      System.out.println(user.age);
    }
  }
  void ReceiveFileChunksFromServer() throws Exception, ClassNotFoundException {
    try {
      if (flagFilename) {
        filename = (String) in.readObject();
        totalChunks = Integer.parseInt((String) in.readObject());
        flagFilename = false;
      }

      if (availableChunks == null) availableChunks = new File[totalChunks];

      if (requiredChunks == null) requiredChunks = new File[totalChunks];

      int partNumber = Integer.parseInt((String) in.readObject());

      File partFile = new File("chunks/" + filename + "." + partNumber);
      byte[] msg = (byte[]) in.readObject();
      Files.write(partFile.toPath(), msg);
      availableChunks[partNumber] = partFile;
      System.out.println("Received chunk " + partNumber);
    } catch (ClassNotFoundException e) {
      flag = true;
    } catch (Exception e) {
      flag = true;
    }
  }
  /** Loads the extraction model from the file. */
  public void loadModel() throws Exception {

    BufferedInputStream inStream = new BufferedInputStream(new FileInputStream(m_modelName));
    ObjectInputStream in = new ObjectInputStream(inStream);
    m_KEAFilter = (KEAFilter) in.readObject();
    in.close();
  }
  // get drivername, user, pw & server, and return connection id
  public void serve(InputStream i, OutputStream o) throws IOException {
    // TODOServiceList.getSingleInstance();
    initialize();
    NameListMessage nameListMessage = null;

    try {
      // read input to know which target panel is required
      ObjectInputStream input = new ObjectInputStream(i);
      nameListMessage = (NameListMessage) input.readObject();

      // parse the required panel
      parseSqlFile(nameListMessage);

    } catch (ClassNotFoundException ex) {
      if (Debug.isDebug()) ex.printStackTrace();
      nameListMessage.errorMessage = ex.toString();
    }

    // send object to the caller
    ObjectOutputStream output = new ObjectOutputStream(o);
    output.writeObject(nameListMessage);

    // end socket connection
    o.close();
    i.close();
  }
Esempio n. 24
0
 public FileCollectionSnapshot snapshot(FileCollection files) {
   try {
     File snapshotFile = cache.get(files);
     if (snapshotFile == null) {
       assert cache.size() == 0;
       FileCollectionSnapshot snapshot = snapshotter.snapshot(files);
       snapshotFile = new File(tmpDir, String.valueOf(cache.size()));
       ObjectOutputStream outstr =
           new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(snapshotFile)));
       try {
         outstr.writeObject(snapshot);
       } finally {
         outstr.close();
       }
       cache.put(files, snapshotFile);
       return snapshot;
     } else {
       ObjectInputStream instr =
           new ObjectInputStream(new BufferedInputStream(new FileInputStream(snapshotFile)));
       try {
         return (FileCollectionSnapshot) instr.readObject();
       } finally {
         instr.close();
       }
     }
   } catch (Exception e) {
     throw new UncheckedIOException(e);
   }
 }
  // @include
  public static String findStudentWithTopThreeAverageScores(InputStream ifs) {
    Map<String, TreeSet<UniqueInteger>> studentScores = new HashMap<>();
    try {
      long sequence = 0;
      ObjectInputStream ois = new ObjectInputStream(ifs);
      while (true) {
        String name = ois.readUTF();
        int score = ois.readInt();
        TreeSet<UniqueInteger> scores = studentScores.get(name);
        if (scores == null) {
          scores = new TreeSet<>();
        }
        scores.add(new UniqueInteger(score, sequence++));
        studentScores.put(name, scores);
      }
    } catch (IOException e) {
    }

    String topStudent = "no such student";
    int currentTopThreeScoresSum = 0;
    for (Map.Entry<String, TreeSet<UniqueInteger>> scores : studentScores.entrySet()) {
      if (scores.getValue().size() >= 3) {
        int currentScoresSum = getTopThreeScoresSum(scores.getValue());
        if (currentScoresSum > currentTopThreeScoresSum) {
          currentTopThreeScoresSum = currentScoresSum;
          topStudent = scores.getKey();
        }
      }
    }
    return topStudent;
  }
 static LMClassifier loadModel(String model) throws ClassNotFoundException, IOException {
   System.out.println("-----Loading Model File <" + model + ">-----");
   FileInputStream fileIn = new FileInputStream(model);
   ObjectInputStream objIn = new ObjectInputStream(fileIn);
   LMClassifier loadedModelClassifier = (LMClassifier) objIn.readObject();
   Streams.closeInputStream(objIn);
   return loadedModelClassifier;
 }
Esempio n. 27
0
 public static Object deserialize(InputStream in) throws IOException {
   ObjectInputStream oin = new ObjectInputStream(in);
   try {
     return (oin.readObject());
   } catch (ClassNotFoundException e) {
     return (null);
   }
 }
Esempio n. 28
0
 public static Grammar load(InputStream inputStream) {
   Grammar grammar;
   try (ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(inputStream))) {
     grammar = (Grammar) in.readObject();
   } catch (IOException | ClassNotFoundException e) {
     throw new RuntimeException(e);
   }
   return grammar;
 }
  private void doControlTask() throws IOException, ClassNotFoundException {
    BlockingTaskSummaryResponseHandler handler = new BlockingTaskSummaryResponseHandler();
    client.getTasksAssignedAsPotentialOwner("control", "en-UK", handler);
    List<TaskSummary> sums = handler.getResults();
    assertNotNull(sums);
    assertEquals(1, sums.size());

    BlockingTaskOperationResponseHandler startTaskOperationHandler =
        new BlockingTaskOperationResponseHandler();
    client.start(sums.get(0).getId(), "control", startTaskOperationHandler);

    BlockingGetTaskResponseHandler getTaskHandler = new BlockingGetTaskResponseHandler();
    client.getTask(sums.get(0).getId(), getTaskHandler);
    Task controlTask = getTaskHandler.getTask();

    BlockingGetContentResponseHandler getContentHandler = new BlockingGetContentResponseHandler();
    client.getContent(controlTask.getTaskData().getDocumentContentId(), getContentHandler);
    Content content = getContentHandler.getContent();

    assertNotNull(content);

    ByteArrayInputStream bais = new ByteArrayInputStream(content.getContent());
    ObjectInputStream ois = new ObjectInputStream(bais);
    Map<String, Object> deserializedContent = (Map<String, Object>) ois.readObject();
    Emergency retrivedEmergency = (Emergency) deserializedContent.get("emergency");
    assertNotNull(retrivedEmergency);
    ActivePatients retrivedActivePatients =
        (ActivePatients) deserializedContent.get("activePatients");
    assertNotNull(retrivedActivePatients);
    assertEquals(1, retrivedActivePatients.size());
    SuggestedProcedures retrivedSuggestedProcedures =
        (SuggestedProcedures) deserializedContent.get("suggestedProcedures");
    assertNotNull(retrivedSuggestedProcedures);
    assertEquals(
        "[DefaultHeartAttackProcedure: ]",
        retrivedSuggestedProcedures.getSuggestedProceduresString());

    Map<String, Object> info = new HashMap<String, Object>();
    SelectedProcedures selectedProcedures = new SelectedProcedures(retrivedEmergency.getId());

    selectedProcedures.addSelectedProcedureName("DefaultHeartAttackProcedure");
    info.put("selectedProcedures", selectedProcedures);

    ContentData result = new ContentData();
    result.setAccessType(AccessType.Inline);
    result.setType("java.util.Map");
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutputStream out = new ObjectOutputStream(bos);
    out.writeObject(info);
    out.close();
    result.setContent(bos.toByteArray());

    BlockingTaskOperationResponseHandler completeTaskOperationHandler =
        new BlockingTaskOperationResponseHandler();
    client.complete(sums.get(0).getId(), "control", result, completeTaskOperationHandler);
  }
Esempio n. 30
0
  /** Metodo que le os clientes de um ficheiro */
  public void lerobjLocalidades(String fileLocalidades)
      throws FileNotFoundException, IOException, ClassNotFoundException {
    FileInputStream fisloc = new FileInputStream(fileLocalidades);
    ObjectInputStream oisloc = new ObjectInputStream(fisloc);

    this.localidades = (TreeMap<String, Localidade>) oisloc.readObject();

    oisloc.close();
    fisloc.close();
  }