public PagedRangeCommand deserialize(DataInput in, int version) throws IOException {
      String keyspace = in.readUTF();
      String columnFamily = in.readUTF();
      long timestamp = in.readLong();

      AbstractBounds<RowPosition> keyRange =
          AbstractBounds.serializer.deserialize(in, version).toRowBounds();

      SliceQueryFilter predicate = SliceQueryFilter.serializer.deserialize(in, version);

      ByteBuffer start = ByteBufferUtil.readWithShortLength(in);
      ByteBuffer stop = ByteBufferUtil.readWithShortLength(in);

      int filterCount = in.readInt();
      List<IndexExpression> rowFilter = new ArrayList<IndexExpression>(filterCount);
      for (int i = 0; i < filterCount; i++) {
        IndexExpression expr =
            new IndexExpression(
                ByteBufferUtil.readWithShortLength(in),
                IndexExpression.Operator.findByOrdinal(in.readInt()),
                ByteBufferUtil.readWithShortLength(in));
        rowFilter.add(expr);
      }

      int limit = in.readInt();
      return new PagedRangeCommand(
          keyspace, columnFamily, timestamp, keyRange, predicate, start, stop, rowFilter, limit);
    }
  @Override
  public void readFields(DataInput dIn) throws IOException {
    instanceId = dIn.readUTF();

    // Hadoop Configuration has to get its act right
    int len = dIn.readInt();
    byte[] array = new byte[len];
    dIn.readFully(array);
    ByteArrayInputStream bais = new ByteArrayInputStream(array);
    conf = new XConfiguration(bais);

    def = new LiteWorkflowApp();
    def.readFields(dIn);
    status = Status.valueOf(dIn.readUTF());
    int numExPaths = dIn.readInt();
    for (int x = 0; x < numExPaths; x++) {
      String path = dIn.readUTF();
      String nodeName = dIn.readUTF();
      boolean isStarted = dIn.readBoolean();
      NodeInstance nodeInstance = new NodeInstance(nodeName);
      nodeInstance.started = isStarted;
      executionPaths.put(path, nodeInstance);
    }
    int numVars = dIn.readInt();
    for (int x = 0; x < numVars; x++) {
      String vName = dIn.readUTF();
      String vVal = readBytesAsString(dIn);
      persistentVars.put(vName, vVal);
    }
    refreshLog();
  }
Exemple #3
0
 @Override
 public ResultSetMetaData read(DataInput dataInput, ResultSetMetaData rsmd)
     throws IOException {
   int columnCount = dataInput.readInt();
   StoredColumnMetaData[] columnMetaData = new StoredColumnMetaData[columnCount];
   for (int column = 1; column <= columnCount; column++)
     columnMetaData[column - 1] =
         new StoredColumnMetaData(
             dataInput.readBoolean(),
             dataInput.readBoolean(),
             dataInput.readBoolean(),
             dataInput.readBoolean(),
             dataInput.readInt(),
             dataInput.readBoolean(),
             dataInput.readInt(),
             dataInput.readUTF(),
             dataInput.readUTF(),
             dataInput.readUTF(),
             dataInput.readInt(),
             dataInput.readInt(),
             dataInput.readUTF(),
             dataInput.readUTF(),
             dataInput.readInt(),
             dataInput.readUTF(),
             dataInput.readBoolean(),
             dataInput.readBoolean(),
             dataInput.readBoolean(),
             dataInput.readUTF());
   return new ColumnMetaDataResultSetMetaData(columnMetaData);
 }
 HistoryEntry(int version, DataInput in) throws IOException {
   if (version >= VERSION_1) {
     mBase = in.readUTF();
     mEdited = in.readUTF();
   } else {
     throw new IOException("invalid version " + version);
   }
 }
 public void readData(DataInput in) throws IOException {
   name = in.readUTF();
   initialPermits = in.readInt();
   boolean hasFactory = in.readBoolean();
   if (hasFactory) {
     factoryClassName = in.readUTF();
   }
 }
 public void readData(DataInput in) throws IOException {
   if (!in.readBoolean()) this.name = in.readUTF();
   if (!in.readBoolean()) this.familyName = in.readUTF();
   if (!in.readBoolean()) this.middleName = in.readUTF();
   this.age = in.readInt();
   this.active = in.readBoolean();
   this.salary = in.readDouble();
 }
 /**
  * ************************************************************************ PAY ATTENTION: This
  * method is only internally used for message. [1] Row-Mutation (RowMutationSerializer) [2]
  * Query-Result (RowSerializer)
  * ************************************************************************
  */
 public ColumnFamily deserialize(DataInput dis) throws IOException {
   String cfName = dis.readUTF();
   if (cfName.isEmpty()) return null;
   ColumnFamily cf =
       deserializeFromSSTableNoColumns(
           cfName, dis.readUTF(), readComparator(dis), readComparator(dis), dis);
   deserializeColumns(dis, cf);
   return cf;
 }
Exemple #8
0
 TVEditorial(DataInput in, byte ver, Map<Integer, Integer> idMap) throws IOException {
   super(in, ver, idMap);
   showID = readID(in, idMap);
   title = Wizard.getInstance().getTitleForID(readID(in, idMap));
   network = Wizard.getInstance().getNetworkForID(readID(in, idMap));
   airdate = in.readUTF();
   description = in.readUTF();
   imageURL = in.readUTF();
   setMediaMask(MEDIA_MASK_TV);
 }
 @Override
 public void readData(DataInput in) throws IOException {
   this.webServiceId = in.readUTF();
   this.quantityId = in.readUTF();
   this.timeStamp = in.readUTF();
   this.elementSetId = in.readUTF();
   this.scenarioId = in.readUTF();
   this.needsUpload = in.readBoolean();
   this.dataLength = in.readInt();
   this.dataBytes = new byte[this.dataLength];
   in.readFully(this.dataBytes);
 }
 @Override
 public void readFields(DataInput in) throws IOException {
   String libDeps = in.readUTF();
   Plugins.loadAllLibraries(libDeps);
   String className = in.readUTF();
   _is = pp.InputSplit.create(className);
   int length = in.readInt();
   byte[] data = new byte[length];
   // System.out.printf("Java read data length: %d\n", length);
   in.readFully(data);
   _is.readFields(data);
 }
Exemple #11
0
    public IndexScanCommand deserialize(DataInput in, int version) throws IOException {
      String keyspace = in.readUTF();
      String columnFamily = in.readUTF();

      TDeserializer dser = new TDeserializer(new TBinaryProtocol.Factory());
      IndexClause indexClause = new IndexClause();
      FBUtilities.deserialize(dser, indexClause, in);
      SlicePredicate predicate = new SlicePredicate();
      FBUtilities.deserialize(dser, predicate, in);
      AbstractBounds<RowPosition> range =
          AbstractBounds.serializer().deserialize(in, version).toRowBounds();
      return new IndexScanCommand(keyspace, columnFamily, indexClause, predicate, range);
    }
Exemple #12
0
 public void readFields(DataInput in) throws IOException {
   contentType = in.readUTF();
   UUID = in.readUTF();
   dateString = in.readUTF();
   recordType = in.readUTF();
   metadata.clear();
   int numMetaItems = in.readInt();
   for (int i = 0; i < numMetaItems; i++) {
     String thisKey = in.readUTF();
     String thisValue = in.readUTF();
     metadata.put(thisKey, thisValue);
   }
   contentLength = in.readInt();
 }
 @Override
 public void readFrom(DataInput in) throws IOException {
   commandName = in.readUTF();
   commandIdentifier = in.readUTF();
   expectReply = in.readBoolean();
   payloadType = in.readUTF();
   payloadRevision = in.readUTF();
   if ("_null".equals(payloadRevision)) {
     payloadRevision = null;
   }
   serializedPayload = new byte[in.readInt()];
   in.readFully(serializedPayload);
   serializedMetaData = new byte[in.readInt()];
   in.readFully(serializedMetaData);
 }
    public TreeRequest deserialize(DataInput dis, int version) throws IOException {
      String sessId = dis.readUTF();
      InetAddress endpoint = CompactEndpointSerializationHelper.deserialize(dis);
      CFPair cfpair = new CFPair(dis.readUTF(), dis.readUTF());
      Range<Token> range;
      if (version > MessagingService.VERSION_07)
        range = (Range<Token>) AbstractBounds.serializer().deserialize(dis, version);
      else
        range =
            new Range<Token>(
                StorageService.getPartitioner().getMinimumToken(),
                StorageService.getPartitioner().getMinimumToken());

      return new TreeRequest(sessId, endpoint, range, cfpair);
    }
 public void readInternal(DataInput in) throws IOException {
   name = in.readUTF();
   int targetBytesLength = in.readInt();
   byte[] targetBytes = new byte[targetBytesLength];
   in.readFully(targetBytes);
   this.target = (ActorRef) Util.toObject(targetBytes);
 }
  /*
   * (non-Javadoc)
   * @see eu.stratosphere.core.io.IOReadableWritable#read(java.io.DataInput)
   */
  @Override
  public void read(final DataInput in) throws IOException {
    this.mode = ExecutionMode.values()[in.readInt()];

    final ArrayList<String> requiredPackages = new ArrayList<String>();
    for (int count = in.readInt(); count > 0; count--) requiredPackages.add(in.readUTF());
    this.query = null;
    final byte[] planBuffer = new byte[in.readInt()];
    in.readFully(planBuffer);

    final JobID dummId = new JobID();
    try {
      LibraryCacheManager.register(
          dummId, requiredPackages.toArray(new String[requiredPackages.size()]));
      SopremoEnvironment.getInstance().setClassLoader(LibraryCacheManager.getClassLoader(dummId));
      this.query = SopremoUtil.deserialize(planBuffer, SopremoPlan.class);
    } catch (final IOException e) {
      e.printStackTrace();
    } finally {
      try {
        LibraryCacheManager.unregister(dummId);
      } catch (final IOException e) {
      }
    }
  }
 /** Serializes this object. */
 public void readFields(DataInput in) throws IOException {
   int length = WritableUtils.readVInt(in);
   byte[] bytes = new byte[length];
   in.readFully(bytes, 0, length);
   WikipediaPage.readPage(this, new String(bytes, "UTF-8"));
   language = in.readUTF();
 }
  /** Return {@code true} if a double slot is read (in case of Double or Long constant). */
  private boolean readConstantPoolEntry(final DataInput di, final int index) throws IOException {

    final int tag = di.readUnsignedByte();
    switch (tag) {
      case CP_METHOD_TYPE:
        di.skipBytes(2); // readUnsignedShort()
        return false;
      case CP_METHOD_HANDLE:
        di.skipBytes(3);
        return false;
      case CP_INTEGER:
      case CP_FLOAT:
      case CP_REF_FIELD:
      case CP_REF_METHOD:
      case CP_REF_INTERFACE:
      case CP_NAME_AND_TYPE:
      case CP_INVOKE_DYNAMIC:
        di.skipBytes(4); // readInt() / readFloat() / readUnsignedShort() * 2
        return false;
      case CP_LONG:
      case CP_DOUBLE:
        di.skipBytes(8); // readLong() / readDouble()
        return true;
      case CP_UTF8:
        constantPool[index] = di.readUTF();
        return false;
      case CP_CLASS:
      case CP_STRING:
        // reference to CP_UTF8 entry. The referenced index can have a higher number!
        constantPool[index] = di.readUnsignedShort();
        return false;
      default:
        throw new ClassFormatError("Unkown tag value for constant pool entry: " + tag);
    }
  }
Exemple #19
0
 @SuppressWarnings("unchecked")
 public void readFields(DataInput is) throws IOException {
   disableCounter = is.readBoolean();
   isMultiInputs = is.readBoolean();
   totalSplits = is.readInt();
   splitIndex = is.readInt();
   inputIndex = is.readInt();
   targetOps = (ArrayList<OperatorKey>) readObject(is);
   int splitLen = is.readInt();
   String splitClassName = is.readUTF();
   try {
     Class splitClass = conf.getClassByName(splitClassName);
     SerializationFactory sf = new SerializationFactory(conf);
     // The correct call sequence for Deserializer is, we shall open, then deserialize, but we
     // shall not close
     Deserializer d = sf.getDeserializer(splitClass);
     d.open((InputStream) is);
     wrappedSplits = new InputSplit[splitLen];
     for (int i = 0; i < splitLen; i++) {
       wrappedSplits[i] = (InputSplit) ReflectionUtils.newInstance(splitClass, conf);
       d.deserialize(wrappedSplits[i]);
     }
   } catch (ClassNotFoundException e) {
     throw new IOException(e);
   }
 }
 @Override
 public void handleRequest(
     final DataInput input,
     final ActiveOperation.ResultHandler<Void> resultHandler,
     final ManagementRequestContext<Void> context)
     throws IOException {
   byte param = input.readByte();
   // If it failed
   if (param != DomainControllerProtocol.PARAM_OK) {
     final byte errorCode = input.readByte();
     final String message = input.readUTF();
     resultHandler.failed(
         new SlaveRegistrationException(
             SlaveRegistrationException.ErrorCode.parseCode(errorCode), message));
     return;
   }
   final ModelNode extensions = new ModelNode();
   extensions.readExternal(input);
   context.executeAsync(
       new ManagementRequestContext.AsyncTask<Void>() {
         @Override
         public void execute(ManagementRequestContext<Void> voidManagementRequestContext)
             throws Exception {
           //
           final ModelNode subsystems = resolveSubsystemVersions(extensions);
           channelHandler.executeRequest(
               context.getOperationId(), new RegisterSubsystemsRequest(subsystems));
         }
       });
 }
 @Override
 public void readFields(DataInput in) throws IOException {
   // read head (rows, cols)
   _numRows = in.readInt();
   int numCols = in.readInt();
   // read columns (value type, data)
   _schema.clear();
   _coldata.clear();
   for (int j = 0; j < numCols; j++) {
     ValueType vt = ValueType.values()[in.readByte()];
     String name = in.readUTF();
     Array arr = null;
     switch (vt) {
       case STRING:
         arr = new StringArray(new String[_numRows]);
         break;
       case BOOLEAN:
         arr = new BooleanArray(new boolean[_numRows]);
         break;
       case INT:
         arr = new LongArray(new long[_numRows]);
         break;
       case DOUBLE:
         arr = new DoubleArray(new double[_numRows]);
         break;
       default:
         throw new IOException("Unsupported value type: " + vt);
     }
     arr.readFields(in);
     _schema.add(vt);
     _colnames.add(name);
     _coldata.add(arr);
   }
 }
    @Override
    protected void readRequest(final DataInput input) throws IOException {
      int batchId = getHeader().getBatchId();
      ProtocolUtils.expectHeader(input, ModelControllerProtocol.PARAM_MESSAGE_SEVERITY);
      MessageSeverity severity = Enum.valueOf(MessageSeverity.class, input.readUTF());
      ProtocolUtils.expectHeader(input, ModelControllerProtocol.PARAM_MESSAGE);
      String message = input.readUTF();

      ExecuteRequestContext requestContext = activeRequests.get(batchId);
      if (requestContext == null) {
        throw new IOException("No active request found for " + batchId);
      }
      if (requestContext.getMessageHandler() != null) {
        requestContext.getMessageHandler().handleReport(severity, message);
      }
    }
  public static PCRecord deserialize(DataInput in, Map<Integer, String> fromIntMap) {
    PCRecord ret = new PCRecord();
    try {
      for (PCRecord.StrField fld : PCRecord.StrField.values()) {
        int id = in.readInt();
        ret.setField(fld, fromIntMap.get(id));
      }
      ret.setLatitude(new BigDecimal(in.readUTF()));
      ret.setLongitude(new BigDecimal(in.readUTF()));
      ret.setAccuracy(in.readShort());
    } catch (Throwable e) {
      throw new RuntimeException(e);
    }

    return ret;
  }
 protected String looseUnmarshalString(DataInput dataIn) throws IOException {
   if (dataIn.readBoolean()) {
     return dataIn.readUTF();
   } else {
     return null;
   }
 }
  @Override
  public void readFields(DataInput in) throws IOException {
    initialize();
    int numFields = in.readInt();

    for (int i = 0; i < numFields; ++i) {
      byte type = in.readByte();

      if (type == BYTE) {
        fields.add(in.readByte());
      } else if (type == BOOLEAN) {
        fields.add(in.readBoolean());
      } else if (type == INT) {
        fields.add(in.readInt());
      } else if (type == LONG) {
        fields.add(in.readLong());
      } else if (type == FLOAT) {
        fields.add(in.readFloat());
      } else if (type == DOUBLE) {
        fields.add(in.readDouble());
      } else if (type == STRING) {
        fields.add(in.readUTF());
      } else if (type == BYTE_ARRAY) {
        int len = in.readShort();
        byte[] bytes = new byte[len];
        in.readFully(bytes);
        fields.add(bytes);
      } else {
        throw new IllegalArgumentException("Failed encoding, unknown element type in stream");
      }
    }
  }
  public void readFields(DataInput in) throws IOException {
    if (in.readBoolean()) {
      this.semiClusterId = in.readUTF();
    }
    this.semiClusterScore = in.readDouble();

    if (in.readBoolean()) {
      int len = in.readInt();
      if (len > 0) {
        for (int i = 0; i < len; i++) {
          SemiClusteringVertex v = new SemiClusteringVertex();
          v.readFields(in);
          semiClusterVertexList.add(v);
        }
      }
    }
    int len = in.readInt();
    if (len > 0) {
      for (int i = 0; i < len; i++) {
        SemiClusterDetails sd = new SemiClusterDetails();
        sd.readFields(in);
        semiClusterContainThis.add(sd);
      }
    }
  }
Exemple #27
0
  public RangeSliceCommand deserialize(DataInput dis, int version) throws IOException {
    String keyspace = dis.readUTF();
    String columnFamily = dis.readUTF();

    int scLength = dis.readInt();
    ByteBuffer superColumn = null;
    if (scLength > 0) {
      byte[] buf = new byte[scLength];
      dis.readFully(buf);
      superColumn = ByteBuffer.wrap(buf);
    }

    TDeserializer dser = new TDeserializer(new TBinaryProtocol.Factory());
    SlicePredicate pred = new SlicePredicate();
    FBUtilities.deserialize(dser, pred, dis);

    List<IndexExpression> rowFilter = null;
    if (version >= MessagingService.VERSION_11) {
      int filterCount = dis.readInt();
      rowFilter = new ArrayList<IndexExpression>(filterCount);
      for (int i = 0; i < filterCount; i++) {
        IndexExpression expr = new IndexExpression();
        FBUtilities.deserialize(dser, expr, dis);
        rowFilter.add(expr);
      }
    }
    AbstractBounds<RowPosition> range =
        AbstractBounds.serializer().deserialize(dis, version).toRowBounds();

    int maxResults = dis.readInt();
    boolean maxIsColumns = false;
    boolean isPaging = false;
    if (version >= MessagingService.VERSION_11) {
      maxIsColumns = dis.readBoolean();
      isPaging = dis.readBoolean();
    }
    return new RangeSliceCommand(
        keyspace,
        columnFamily,
        superColumn,
        pred,
        range,
        rowFilter,
        maxResults,
        maxIsColumns,
        isPaging);
  }
 public Set<String> read(DataInput s) throws IOException {
   int count = s.readInt();
   Set<String> result = new THashSet<String>(count);
   while (count-- > 0) {
     result.add(s.readUTF());
   }
   return result;
 }
 public static String readLongString(DataInput in) throws IOException {
   int count = in.readInt();
   StringBuilder sb = new StringBuilder();
   for (int i = 0; i < count; i++) {
     sb.append(in.readUTF());
   }
   return sb.toString();
 }
 @Override
 public String readUTF() {
   try {
     return input.readUTF();
   } catch (IOException e) {
     throw new IllegalStateException(e);
   }
 }