Reconstitutes this task from a stream (that is, deserializes it).
346917
private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        Object ex = s.readObject();
        if (ex != null)
            setExceptionalCompletion((Throwable)ex);
    }
985012
private void readObject(ObjectInputStream stream)
            throws IOException, ClassNotFoundException {

        stream.defaultReadObject();

        initInternal();

        isTimeSet = true;
        areFieldsSet = areAllFieldsSet = false;
        areFieldsVirtuallySet = true; // cause fields to be recalculated if requested.
        nextStamp = MINIMUM_USER_STAMP;
    }
250529
public void reconstituteGDTargetStreams() 
    throws MessageStoreException, SIException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "reconstituteGDTargetStreams");

    _targetProtocolItemStream.reconstitute(_baseDestinationHandler, 
                                           _baseDestinationHandler.getTransactionManager(), 
                                           (ProducerInputHandler)_baseDestinationHandler.getInputHandler());
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "reconstituteGDTargetStreams");
  }
1083631
def FromStream(cls, stream):
        

        if stream.system:
            specifier = DataStreamSelector.MatchSystemOnly
        else:
            specifier = DataStreamSelector.MatchUserOnly

        return DataStreamSelector(stream.stream_type, stream.stream_id, specifier)
340062
private synchronized void readObject(java.io.ObjectInputStream stream)
			throws java.io.IOException, ClassNotFoundException
	{
		stream.defaultReadObject();
		this.threadState = (ThreadState) serilizationCache.load(this.threadStateSerilizationHashedId);
		this.threadStateSerilizationHashedId = null;
	}
1097472
def deserialize(stream_or_string, **options):
    '''
    
    '''

    if six.PY3:
        cp = configparser.ConfigParser(**options)
    else:
        cp = configparser.SafeConfigParser(**options)

    try:
        if not isinstance(stream_or_string, (bytes, six.string_types)):
            if six.PY3:
                cp.read_file(stream_or_string)
            else:
                cp.readfp(stream_or_string)
        else:
            if six.PY3:
                cp.read_file(six.moves.StringIO(stream_or_string))
            else:
                # python2's ConfigParser cannot parse a config from a string
                cp.readfp(six.moves.StringIO(stream_or_string))
        data = {}
        for section_name in cp.sections():
            section = {}
            for k, v in cp.items(section_name):
                section[k] = v
            data[section_name] = section
        return data
    except Exception as error:
        raise DeserializationError(error)
1076151
public Object fromStream(final byte[] iStream) throws IOException {
		if (iStream == null || iStream.length == 0)
			// NULL VALUE
			return null;

		final ByteArrayInputStream is = new ByteArrayInputStream(iStream);
		final ObjectInputStream in = new ObjectInputStream(is);
		try {
			return in.readObject();
		} catch (ClassNotFoundException e) {
			throw new OSerializationException("Cannot unmarshall Java serialized object", e);
		} finally {
			in.close();
			is.close();
		}
	}
703752
void performStreamingRepair()
    {
        InetAddress local = FBUtilities.getBroadcastAddress();
        // We can take anyone of the node as source or destination, however if one is localhost, we put at source to avoid a forwarding
        InetAddress src = r2.endpoint.equals(local) ? r2.endpoint : r1.endpoint;
        InetAddress dst = r2.endpoint.equals(local) ? r1.endpoint : r2.endpoint;

        SyncRequest request = new SyncRequest(desc, local, src, dst, differences);
        StreamingRepairTask task = new StreamingRepairTask(desc, request);
        task.run();
    }
33809
private Serializable deserializeObject(byte[] buffer) throws IOException, ClassNotFoundException {

		Serializable theObject = null;
		ObjectInputStream objectIn = null;

		if (buffer != null) {
			objectIn = new ObjectInputStream(new ByteArrayInputStream(buffer));
			theObject = (Serializable)objectIn.readObject();
			objectIn.close();
		}
		return theObject;
	}
23824
public void reconstitute(BaseDestinationHandler destinationHandler) throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "reconstitute", destinationHandler); 

    super.reconstitute(destinationHandler);
      
    _destHighMsgs = destinationHandler.getMessageProcessor().getHighMessageThreshold();

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.exit(tc, "reconstitute");           
    }
  }
1024699
@Override
    public T fromStream(final InputStream in) throws IllegalArgumentException, DescriptorImportException {
        return fromStream(in, true);
    }
1277469
private void readObject(ObjectInputStream in)
      throws IOException, ClassNotFoundException {
    // Init
    COUNTER = new AtomicInteger();
    serializers = new HashMap<Class, SerializerWrapper>();
    serializersArray = new Serializer[0];

    deserialize(in, this);
  }
1175879
@SuppressWarnings("unchecked")
  private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
    int capacity = stream.readInt();
    initialize(capacity);
    int size = stream.readInt();
    for (int i = 0; i < size; i++) {
      addEntry((K) stream.readObject(), (V) stream.readObject());
    }
  }
1052793
def load_wc(cls, stream):
        """"""
        wc = wcxf.WC.load(stream)
        return cls.from_wc(wc)
204074
def from_stream(cls, stream):
        
        chunk_parser = _ChunkParser.from_stream(stream)
        chunks = [chunk for chunk in chunk_parser.iter_chunks()]
        return cls(chunks)
1220463
public static void consumeStream(InputStream is) {
        if (is != null) {
            try {
                // Copy the stream to a null destination
                long copied = IOUtils.copyLarge(is, NullOutputStream.NULL_OUTPUT_STREAM);
                if (copied > 0) {
                    logger.log(Level.WARNING, "Consumed unused HTTP response error stream.");
                }
            } catch (IOException ioe) {
                // The stream was probably already closed, there's nothing further we can do anyway
                logger.log(Level.FINEST, "Unable to consume stream.", ioe);
            }
        }
    }
1227227
public static Object convertInputStreamToObject(InputStream is) throws IOException, ClassNotFoundException{
		ObjectInputStream ois = new ObjectInputStream(is);
		return ois.readObject();
	}