Пример #1
1
    private static Media readMedia(DataInputStream in) throws IOException {
      String uri = in.readUTF();
      String title = readMaybeString(in);
      int width = in.readInt();
      int height = in.readInt();
      String format = in.readUTF();
      long duration = in.readLong();
      long size = in.readLong();
      boolean hasBitrate = in.readBoolean();
      int bitrate = 0;
      if (hasBitrate) bitrate = in.readInt();
      int numPersons = in.readInt();
      ArrayList<String> persons = new ArrayList<String>(numPersons);
      for (int i = 0; i < numPersons; i++) {
        persons.add(in.readUTF());
      }
      Media.Player player = Media.Player.values()[in.readByte()];
      String copyright = readMaybeString(in);

      return new Media(
          uri,
          title,
          width,
          height,
          format,
          duration,
          size,
          bitrate,
          hasBitrate,
          persons,
          player,
          copyright);
    }
Пример #2
1
 /**
  * Create a FreenetURI from the binary form of the key, read from a stream, with no length.
  *
  * @throws MalformedURLException If there was a format error in the data.
  * @throws IOException If a read error occurred
  */
 public static FreenetURI readFullBinaryKey(DataInputStream dis) throws IOException {
   byte type = dis.readByte();
   String keyType;
   if (type == CHK) keyType = "CHK";
   else if (type == SSK) keyType = "SSK";
   else if (type == KSK) keyType = "KSK";
   else throw new MalformedURLException("Unrecognized type " + type);
   byte[] routingKey = null;
   byte[] cryptoKey = null;
   byte[] extra = null;
   if ((type == CHK) || (type == SSK)) {
     // routingKey is a hash, so is exactly 32 bytes
     routingKey = new byte[32];
     dis.readFully(routingKey);
     // cryptoKey is a 256 bit AES key, so likewise
     cryptoKey = new byte[32];
     dis.readFully(cryptoKey);
     // Number of bytes of extra depends on key type
     int extraLen;
     extraLen =
         (type == CHK ? Constants.CLIENT_CHK_EXTRA_LENGTH : Constants.CLIENT_SSK_EXTRA_LENGTH);
     extra = new byte[extraLen];
     dis.readFully(extra);
   }
   String docName = null;
   if (type != CHK) docName = dis.readUTF();
   int count = dis.readInt();
   String[] metaStrings = new String[count];
   for (int i = 0; i < metaStrings.length; i++) metaStrings[i] = dis.readUTF();
   return new FreenetURI(keyType, docName, metaStrings, routingKey, cryptoKey, extra);
 }
Пример #3
1
  public void read(InputStream is) throws IOException {
    DataInputStream oin = new DataInputStream(is);
    byte[] magic = new byte[MAGIC_NUMBER.length];
    oin.read(magic, 0, magic.length);

    if (Arrays.equals(MAGIC_NUMBER_OFH_20040908, magic)) {
      // Old format requires us to read the OModel to get the type and guid.
      this.format = oin.readShort();
      this.compileTime = oin.readLong();
      oin.readInt();
      ObjectInputStream ois = new CustomObjectInputStream(_inputStream);
      OProcess oprocess;
      try {
        oprocess = (OProcess) ois.readObject();
      } catch (ClassNotFoundException e) {
        throw new IOException("DataStream Error");
      }
      this.type = new QName(oprocess.targetNamespace, oprocess.processName);
      this.guid = "OLD-FORMAT-NO-GUID";

      return;
    }
    // The current (most recent) scheme
    if (Arrays.equals(MAGIC_NUMBER, magic)) {
      this.format = oin.readShort();
      this.compileTime = oin.readLong();
      this.guid = oin.readUTF();
      String tns = oin.readUTF();
      String name = oin.readUTF();
      this.type = new QName(tns, name);
      return;
    }

    throw new IOException("Unrecognized file format (bad magic number).");
  }
  /**
   * Method declaration
   *
   * @return
   */
  private Session init() {

    try {
      mSocket.setTcpNoDelay(true);

      mInput = new DataInputStream(new BufferedInputStream(mSocket.getInputStream()));
      mOutput = new DataOutputStream(new BufferedOutputStream(mSocket.getOutputStream()));
      user = mInput.readUTF();

      String password = mInput.readUTF();
      Session c;

      try {
        mServer.trace(mThread + ":trying to connect user " + user);

        return mServer.mDatabase.connect(user, password);
      } catch (SQLException e) {
        write(new Result(e.getMessage(), e.getErrorCode()).getBytes());
      }
    } catch (Exception e) {
      mServer.trace(mThread + ":couldn't connect " + user);
    }

    close();

    return null;
  }
 /** Dumps a snapshot to the log. Useful for debugging. */
 public static void logSnapshot(byte[] snapshot) {
   DataInputStream in = new DataInputStream(new ByteArrayInputStream(snapshot));
   try {
     int version = in.readUnsignedShort();
     int classCount = in.readUnsignedShort();
     StringBuilder sb = new StringBuilder();
     sb.append("version=")
         .append(version)
         .append(' ')
         .append("classes=")
         .append(classCount)
         .append('\n');
     logger.info(sb.toString());
     for (int i = 0; i < classCount; i++) {
       sb = new StringBuilder();
       sb.append("class ").append(in.readUTF()).append('\n');
       int methodCount = in.readUnsignedShort();
       for (int m = 0; m < methodCount; m++) {
         sb.append("  ").append(in.readUTF()).append(":\n");
         sb.append("    event:\n");
         appendCounts(in, sb);
         sb.append("    other:\n");
         appendCounts(in, sb);
       }
       logger.info(sb.toString());
     }
   } catch (IOException e) {
     logger.warning(e.toString());
   }
 }
Пример #6
0
  private void deserialize0(ParameterTable.Builder builder, DataInputStream data)
      throws IOException {
    int magic = data.readInt();
    if (magic != MAGIC) {
      throw new IOException("parameter table is broken: invalid magic number");
    }
    int version = data.readInt();
    if (version != VERSION) {
      throw new IOException(
          MessageFormat.format(
              "inconsistent parameter table version: required={0}, actual={1}", VERSION, version));
    }

    INTERPRETER:
    while (true) {
      byte op = data.readByte();
      switch (op) {
        case OP_ROW:
          builder.next();
          break;
        case OP_CELL:
          String name = data.readUTF();
          String value = data.readUTF();
          builder.put(name, value);
          break;
        case OP_END:
          break INTERPRETER;
        default:
          throw new IOException(MessageFormat.format("unknown op: {0}", op));
      }
    }
  }
Пример #7
0
 private void processSetStartupCmd(DataInputStream params, IOTACommandHelper helper)
     throws IOException {
   ConfigPage configPage = spot.getConfigPage();
   configPage.setStartup(params.readUTF(), params.readUTF(), params.readUTF());
   spot.flashConfigPage(configPage);
   helper.sendPrompt();
 }
  /**
   * this method defines the job of the client thread. the client connects to the server to see if
   * there is message for it in every other interval.
   */
  @Override
  public void run() {
    while (true) {
      Socket socket;
      try {
        Thread.sleep(INTERVAL);
        socket = new Socket(serverUrl, serverPost);
        DataOutputStream out = new DataOutputStream(socket.getOutputStream());
        out.writeUTF(clientId);
        DataInputStream in = new DataInputStream(socket.getInputStream());

        String hasMessage = in.readUTF();
        // check to see if there is unread message
        if (hasMessage != null && hasMessage.equals("yes")) {
          boolean done = false;
          while (!done) {
            String messageString = in.readUTF();
            if (messageString != null) {
              if (messageString.equals("done!")) break;
              else {
                Message message = getMessage(messageString);
                unReadMessage.add(message);
              }
            }
          }
        }
        socket.close();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }
Пример #9
0
  @Override
  public void run() {
    try {
      msg = dis.readUTF();
      System.out.println("메세지 받음");
      System.out.println(msg);
      if (msg.equals("using")) {
        cMain.loginFrame.UsingMessage();
        return;
      } else {

      }
      while (dis != null) {

        msg = dis.readUTF();
        System.out.println(msg);
        if (msg.equals("stopCom")) {
          dao_User.UserStop(seatNum);
          cMain.usingFrame.user.setRun(false);
          cMain.ShowLogin(cMain.usingFrame);
          return;
        } else {
          chat.receiveMsg(msg);
        }
        System.out.println(msg);
        // cGui.receiveMsg(msg);

      }
    } catch (IOException e) {
      e.printStackTrace();
    } // catch(ClassNotFoundException ce){ce.printStackTrace();}
  }
  @Override
  public void onPacketData(INetworkManager manager, Packet250CustomPayload packet, Player player) {
    DataInputStream dis = new DataInputStream(new ByteArrayInputStream(packet.data));
    try {
      if ("ModConfig".equals(packet.channel)) {

        int mode = dis.readInt();
        if (mode == 0) {
          String modid = dis.readUTF();
          int entryCount = dis.readInt();
          int pos = 0;
          ConfigMod.dbg("modconfig packet, size: " + entryCount);
          // require a full resync of data, make sure other side sends it all
          if (!GuiConfigEditor.clientMode
              || ConfigMod.configLookup.get(modid).configData.size() == 0) {
            ConfigMod.configLookup.get(modid).configData.clear();
            for (int i = 0; i < entryCount; i++) {
              String str1 = dis.readUTF();
              String str2 = dis.readUTF();
              String str3 = ""; // dis.readUTF();
              ConfigMod.configLookup
                  .get(modid)
                  .configData
                  .add(new ConfigEntryInfo(pos++, str1, str2, str3));
            }
          }
        } else {
          openConfigGui();
        }
      }
    } catch (Exception ex) {
      // HostileWorlds.dbg("ERROR HANDLING HW PACKETS");
      ex.printStackTrace();
    }
  }
Пример #11
0
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    Logger.getLogger(getClass()).debug("LOGIN device J2ME");

    final UserWorkerLocal userWorkerLocal = ServiceLocator.lookupLocal(UserWorkerLocal.JNDI_NAME);
    final SubjectWorkerLocal subjectWorkerLocal =
        ServiceLocator.lookupLocal(SubjectWorkerLocal.JNDI_NAME);

    DataInputStream dis = null;
    try {
      dis = new DataInputStream(request.getInputStream());
      final String login = dis.readUTF();
      final String password = dis.readUTF();

      final User user = userWorkerLocal.login(login, password);

      final String deviceId = subjectWorkerLocal.loginDevice(user);
      final byte[] resultBytes = deviceId.getBytes("utf-8");
      response.setContentLength(resultBytes.length);
      response.getOutputStream().write(resultBytes);
    } catch (LoginFailedException e) {
      response.sendError(HttpServletResponse.SC_FORBIDDEN);
    } finally {
      if (dis != null) {
        dis.close();
      }
    }
  }
Пример #12
0
  private static Binder load(byte[] buffer) throws IOException {

    Binder b;

    try {

      DataInputStream dis = new DataInputStream(new ByteArrayInputStream(buffer));

      String fileName = dis.readUTF();

      b = new Binder(fileName);

      int numberOfNotes = dis.readInt();

      String title;
      String body;

      for (int i = 0; i < numberOfNotes; i++) {
        title = dis.readUTF();
        body = dis.readUTF();
        b.addNote(new Note(title, body));
      }

      dis.close();
    } catch (IOException ioe) {
      ioe.printStackTrace();
      throw ioe;
    }

    return b;
  }
Пример #13
0
 public static Member load(String number) throws IOException {
   Member member;
   try (DataInputStream input = new DataInputStream(new FileInputStream(number))) {
     member = new Member(input.readUTF(), input.readUTF(), input.readInt());
   }
   return member;
 }
  public void load(DataInputStream dis) throws IOException {
    dis.readInt(); // name length
    this.name = dis.readUTF();

    dis.readInt(); // map_kdLength
    this.map_kd = dis.readUTF();

    if (parent.hasTexcoords() && map_kd.length() > 0) {
      parent.loadTexture(map_kd);
    }

    this.ka[0] = dis.readFloat();
    this.ka[1] = dis.readFloat();
    this.ka[2] = dis.readFloat();
    this.ka[3] = dis.readFloat();

    this.kd[0] = dis.readFloat();
    this.kd[1] = dis.readFloat();
    this.kd[2] = dis.readFloat();
    this.kd[3] = dis.readFloat();

    this.ks[0] = dis.readFloat();
    this.ks[1] = dis.readFloat();
    this.ks[2] = dis.readFloat();
    this.ks[3] = dis.readFloat();

    this.ns = dis.readFloat();
    this.illum = dis.readInt();
    this.d = dis.readFloat();
  }
Пример #15
0
    /**
     * Keep calling this till you get a {@link EOFException} for getting logs of all types for a
     * single container.
     *
     * @param valueStream
     * @param out
     * @throws IOException
     */
    public static void readAContainerLogsForALogType(DataInputStream valueStream, PrintStream out)
        throws IOException {

      byte[] buf = new byte[65535];

      String fileType = valueStream.readUTF();
      String fileLengthStr = valueStream.readUTF();
      long fileLength = Long.parseLong(fileLengthStr);
      out.print("LogType: ");
      out.println(fileType);
      out.print("LogLength: ");
      out.println(fileLengthStr);
      out.println("Log Contents:");

      int curRead = 0;
      long pendingRead = fileLength - curRead;
      int toRead = pendingRead > buf.length ? buf.length : (int) pendingRead;
      int len = valueStream.read(buf, 0, toRead);
      while (len != -1 && curRead < fileLength) {
        out.write(buf, 0, len);
        curRead += len;

        pendingRead = fileLength - curRead;
        toRead = pendingRead > buf.length ? buf.length : (int) pendingRead;
        len = valueStream.read(buf, 0, toRead);
      }
      out.println("");
    }
Пример #16
0
    public String nextLog() throws IOException {
      if (currentLogData != null && currentLogLength > 0) {
        // seek to the end of the current log, relying on BoundedInputStream
        // to prevent seeking past the end of the current log
        do {
          if (currentLogData.skip(currentLogLength) < 0) {
            break;
          }
        } while (currentLogData.read() != -1);
      }

      currentLogType = null;
      currentLogLength = 0;
      currentLogData = null;
      currentLogISR = null;

      try {
        String logType = valueStream.readUTF();
        String logLengthStr = valueStream.readUTF();
        currentLogLength = Long.parseLong(logLengthStr);
        currentLogData = new BoundedInputStream(valueStream, currentLogLength);
        currentLogData.setPropagateClose(false);
        currentLogISR = new InputStreamReader(currentLogData);
        currentLogType = logType;
      } catch (EOFException e) {
      }

      return currentLogType;
    }
Пример #17
0
 /**
  * Returns ACLs for the application. An empty map is returned if no ACLs are found.
  *
  * @return a map of the Application ACLs.
  * @throws IOException
  */
 public Map<ApplicationAccessType, String> getApplicationAcls() throws IOException {
   // TODO Seek directly to the key once a comparator is specified.
   TFile.Reader.Scanner aclScanner = reader.createScanner();
   LogKey key = new LogKey();
   Map<ApplicationAccessType, String> acls = new HashMap<ApplicationAccessType, String>();
   while (!aclScanner.atEnd()) {
     TFile.Reader.Scanner.Entry entry = aclScanner.entry();
     key.readFields(entry.getKeyStream());
     if (key.toString().equals(APPLICATION_ACL_KEY.toString())) {
       DataInputStream valueStream = entry.getValueStream();
       while (true) {
         String appAccessOp = null;
         String aclString = null;
         try {
           appAccessOp = valueStream.readUTF();
         } catch (EOFException e) {
           // Valid end of stream.
           break;
         }
         try {
           aclString = valueStream.readUTF();
         } catch (EOFException e) {
           throw new YarnRuntimeException("Error reading ACLs", e);
         }
         acls.put(ApplicationAccessType.valueOf(appAccessOp), aclString);
       }
     }
     aclScanner.advance();
   }
   return acls;
 }
Пример #18
0
    /**
     * Writes all logs for a single container to the provided writer.
     *
     * @param valueStream
     * @param writer
     * @throws IOException
     */
    public static void readAcontainerLogs(DataInputStream valueStream, Writer writer)
        throws IOException {
      int bufferSize = 65536;
      char[] cbuf = new char[bufferSize];
      String fileType;
      String fileLengthStr;
      long fileLength;

      while (true) {
        try {
          fileType = valueStream.readUTF();
        } catch (EOFException e) {
          // EndOfFile
          return;
        }
        fileLengthStr = valueStream.readUTF();
        fileLength = Long.parseLong(fileLengthStr);
        writer.write("\n\nLogType:");
        writer.write(fileType);
        writer.write("\nLogLength:");
        writer.write(fileLengthStr);
        writer.write("\nLog Contents:\n");
        // ByteLevel
        BoundedInputStream bis = new BoundedInputStream(valueStream, fileLength);
        InputStreamReader reader = new InputStreamReader(bis);
        int currentRead = 0;
        int totalRead = 0;
        while ((currentRead = reader.read(cbuf, 0, bufferSize)) != -1) {
          writer.write(cbuf, 0, currentRead);
          totalRead += currentRead;
        }
      }
    }
Пример #19
0
 @Test
 public void dataRoundTrip() throws IOException {
   dos.writeUTF("Hello, world!");
   dos.writeInt(0xCAFEBABE);
   dos.writeUTF("Over & out.");
   dos.close();
   //    aos.close(); // important?
   byte[] bs = bos.toByteArray();
   if (verbose) {
     for (int i = 0; i < bs.length; i++) {
       System.out.printf("%02x ", bs[i]);
       if (i % 16 == 15) System.out.println();
     }
     System.out.println();
   }
   PPMModel pi = new PPMModel(4);
   ByteArrayInputStream bis = new ByteArrayInputStream(bs);
   ArithCodeInputStream ais = new ArithCodeInputStream(bis, pi);
   DataInputStream dis = new DataInputStream(ais);
   String s1 = dis.readUTF();
   assert s1.equals("Hello, world!") : s1;
   int i1 = dis.readInt();
   assert 0xCAFEBABE == i1 : i1;
   String s2 = dis.readUTF();
   assert s2.equals("Over & out.") : s2;
   int i2 = dis.read();
   assert -1 == i2 : i2;
 }
Пример #20
0
  public static ArrayList<Patient> getPatientList(Socket socket, ArrayList<Patient> patientList) {
    int id;
    String ic;
    String fname;
    String lname;
    int age;
    int cnumber;

    try {
      OutputStream output = socket.getOutputStream();
      DataOutputStream dos = new DataOutputStream(output);
      InputStream input = socket.getInputStream();
      DataInputStream dis = new DataInputStream(input);

      dos.writeInt(2);

      int numberOfPatients = dis.readInt();

      for (int i = 0; i < numberOfPatients; i++) {
        id = dis.readInt();
        ic = dis.readUTF();
        fname = dis.readUTF();
        lname = dis.readUTF();
        age = dis.readInt();
        cnumber = dis.readInt();

        patientList.add(new Patient(id, ic, fname, lname, age, cnumber));
      }

    } catch (IOException e) {
      System.out.println("Cannot get IO streams.");
    }

    return patientList;
  }
Пример #21
0
  void ReceiveFile() throws Exception {
    String fileName;

    fileName = din.readUTF();

    if (fileName != null && !fileName.equals("NOFILE")) {
      System.out.println("Receiving File");
      File f =
          new File(
              System.getProperty("user.home")
                  + "/Desktop"
                  + "/"
                  + fileName.substring(fileName.lastIndexOf("/") + 1));
      System.out.println(f.toString());
      f.createNewFile();
      FileOutputStream fout = new FileOutputStream(f);
      int ch;
      String temp;
      do {
        temp = din.readUTF();
        ch = Integer.parseInt(temp);
        if (ch != -1) {
          fout.write(ch);
        }
      } while (ch != -1);
      System.out.println("Received File : " + fileName);
      fout.close();
    } else {
    }
  }
Пример #22
0
  @Override
  public void run() {
    try {
      while (true) {
        clientMessage = this.nodeInput.readUTF();
        if (clientMessage.equals("chatClient-hello")) {
          this.nodeOutput.writeUTF("chat-request_name_id");

          this.nodeName = nodeInput.readUTF();
          this.nodeID = nodeInput.readInt();

          System.out.println("ChatClient: " + this.nodeName + " with ID: " + this.nodeID);
        } else if (clientMessage.equals("chatClient-sending_message")) {
          nodes = ChatServer.getNodes();
          messageToBeSent = nodeInput.readUTF();
          for (int i = 0; i < 4; i++) {
            this.nodes.get(i).nodeOutput.writeUTF("chat-sending_message");
            this.nodes.get(i).nodeOutput.writeUTF(this.nodeName + " says: " + messageToBeSent);
          }
          System.out.println("Message has been sent: " + messageToBeSent);
        }
      } // while
    } catch (IOException ex) {
      System.err.println("Error in ChatNode");
      ex.printStackTrace();
    }
  } // run()
Пример #23
0
  /** Reinstantiate a StateEngine from the stream. */
  public void deserializeFrom(InputStream is) throws IOException {
    DataInputStream dis = new DataInputStream(is);

    if (dis.readInt() != STATE_ENGINE_SERIALIZATION_FORMAT_VERSION) {
      throw new RuntimeException(
          "Refusing to reinstantiate FastBlobStateEngine due to serialized version mismatch.");
    }

    latestVersion = dis.readUTF();
    int numHeaderTagEntries = dis.readShort();
    headerTags.clear();
    headerTags = new HashMap<String, String>();
    for (int i = 0; i < numHeaderTagEntries; i++) {
      headerTags.put(dis.readUTF(), dis.readUTF());
    }

    int numConfigs = VarInt.readVInt(dis);

    int numStates = VarInt.readVInt(dis);

    for (int i = 0; i < numStates; i++) {
      String typeName = dis.readUTF();
      FastBlobTypeSerializationState<?> typeState = serializationTypeStates.get(typeName);

      if (typeState != null) {
        typeState.deserializeFrom(dis, numConfigs);
      } else {
        FastBlobTypeSerializationState.discardSerializedTypeSerializationState(dis, numConfigs);
      }
    }
  }
Пример #24
0
 public VoldemortOperation(byte[] bytes) {
   if (bytes == null || bytes.length <= 1)
     throw new SerializationException("Not enough bytes to serialize");
   DataInputStream inputStream = new DataInputStream(new ByteArrayInputStream(bytes));
   try {
     this.opCode = inputStream.readByte();
     switch (opCode) {
       case VoldemortOpCode.GET_OP_CODE:
         this.version = null;
         this.key = inputStream.readUTF();
         this.value = null;
         break;
       case VoldemortOpCode.PUT_OP_CODE:
         this.version = new VectorClock(bytes, 1);
         this.key = inputStream.readUTF();
         int valueSize = inputStream.readInt();
         this.value = new byte[valueSize];
         ByteUtils.read(inputStream, this.value);
         break;
       case VoldemortOpCode.DELETE_OP_CODE:
         this.version = new VectorClock(bytes, 1);
         this.key = inputStream.readUTF();
         this.value = null;
         break;
       default:
         throw new SerializationException("Unknown opcode: " + bytes[0]);
     }
   } catch (IOException e) {
     throw new SerializationException(e);
   }
 }
Пример #25
0
  public static void main(String[] args) throws IOException {
    FileReader in = new FileReader("frog.txt");
    FileWriter out = new FileWriter("prince.txt");

    int c;
    while ((c = in.read()) != -1) out.write(c);

    in.close();
    out.close();

    // Read file name from stdin
    BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
    System.out.print("Please enter a valid filename: ");
    String fileName = stdin.readLine();

    DataOutputStream outStream =
        new DataOutputStream(new BufferedOutputStream(new FileOutputStream(fileName)));
    outStream.writeDouble(3.14);
    outStream.writeUTF("That is pi");
    outStream.writeDouble(1.41413);
    outStream.writeUTF("Square root of 2");
    outStream.close();
    DataInputStream inStream =
        new DataInputStream(new BufferedInputStream(new FileInputStream(fileName)));
    System.out.println(inStream.readDouble());
    System.out.println(inStream.readUTF());
    System.out.println(inStream.readDouble());
    System.out.println(inStream.readUTF());
  }
 public static Client getClientInfo(DataInputStream in) {
   try {
     return new Client(in.readUTF(), in.readUTF(), in.readUTF(), in.readBoolean());
   } catch (Exception e) {
     e.printStackTrace();
     return null;
   }
 }
Пример #27
0
  protected void read(DataInputStream s) {
    try {
      ref = new WeakReference<DataBuffer>(this, Nd4j.bufferRefQueue());
      referencing = Collections.synchronizedSet(new HashSet<String>());
      dirty = new AtomicBoolean(false);
      allocationMode = AllocationMode.valueOf(s.readUTF());
      length = s.readInt();
      Type t = Type.valueOf(s.readUTF());
      if (t == Type.DOUBLE) {
        if (allocationMode == AllocationMode.HEAP) {
          if (this.dataType() == Type.FLOAT) { // DataBuffer type
            // double -> float
            floatData = new float[length()];
          } else if (this.dataType() == Type.DOUBLE) {
            // double -> double
            doubleData = new double[length()];
          } else {
            // double -> int
            intData = new int[length()];
          }
          for (int i = 0; i < length(); i++) {
            put(i, s.readDouble());
          }
        } else {
          wrappedBuffer = ByteBuffer.allocateDirect(length() * getElementSize());
          wrappedBuffer.order(ByteOrder.nativeOrder());
          for (int i = 0; i < length(); i++) {
            put(i, s.readDouble());
          }
        }
      } else {
        if (allocationMode == AllocationMode.HEAP) {
          if (this.dataType() == Type.FLOAT) { // DataBuffer type
            // float -> float
            floatData = new float[length()];
          } else if (this.dataType() == Type.DOUBLE) {
            // float -> double
            doubleData = new double[length()];
          } else {
            // float-> int
            intData = new int[length()];
          }
          for (int i = 0; i < length(); i++) {
            put(i, s.readFloat());
          }
        } else {
          wrappedBuffer = ByteBuffer.allocateDirect(length() * getElementSize());
          wrappedBuffer.order(ByteOrder.nativeOrder());
          for (int i = 0; i < length(); i++) {
            put(i, s.readFloat());
          }
        }
      }

    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
Пример #28
0
 private void getuserinfo(String name) throws IOException {
   ToServer.writeUTF("iserinfo");
   ToServer.writeUTF(name);
   txaddname.setText(FromServer.readUTF());
   txaddpass.setText(FromServer.readUTF());
   txgroupname.setText(FromServer.readUTF());
   if (FromServer.readUTF().equals("1")) cboxadmin.setSelected(true);
   else cboxadmin.setSelected(false);
 }
Пример #29
0
 public NameVersion(DataInputStream dis) throws IOException {
   String n = dis.readUTF();
   String v = dis.readUTF();
   String l = dis.readUTF();
   if (l.length() == 0) {
     l = null;
   }
   init(n, v, l);
 }
Пример #30
0
 /**
  * Read the form-lemma mapping not read by operations
  *
  * @param dis
  */
 public void readMap(DataInputStream dis) {
   try {
     int size = dis.readInt();
     for (int i = 0; i < size; i++) {
       opse.put(dis.readUTF(), dis.readUTF());
     }
   } catch (IOException e1) {
     e1.printStackTrace();
   }
 }