Reconstitute the <tt>ConcurrentHashMap</tt> instance from a
stream (i.e., deserialize it).
@param s the stream
503416
@SuppressWarnings("unchecked")
    private void readObject(java.io.ObjectInputStream s)
        throws IOException, ClassNotFoundException {
        // Don't call defaultReadObject()
        ObjectInputStream.GetField oisFields = s.readFields();
        final Segment<K,V>[] oisSegments = (Segment<K,V>[])oisFields.get("segments", null);

        final int ssize = oisSegments.length;
        if (ssize < 1 || ssize > MAX_SEGMENTS
            || (ssize & (ssize-1)) != 0 ) {
          throw new java.io.InvalidObjectException("Bad number of segments:"
                                                   + ssize);
        }
        int sshift = 0, ssizeTmp = ssize;
        while (ssizeTmp > 1) {
            ++sshift;
            ssizeTmp >>>= 1;
        }
        UNSAFE.putIntVolatile(this, SEGSHIFT_OFFSET, 32 - sshift);
        UNSAFE.putIntVolatile(this, SEGMASK_OFFSET, ssize - 1);
        UNSAFE.putObjectVolatile(this, SEGMENTS_OFFSET, oisSegments);

        // set hashMask
        UNSAFE.putIntVolatile(this, HASHSEED_OFFSET, randomHashSeed(this));

        // Re-initialize segments to be minimally sized, and let grow.
        int cap = MIN_SEGMENT_TABLE_CAPACITY;
        final Segment<K,V>[] segments = this.segments;
        for (int k = 0; k < segments.length; ++k) {
            Segment<K,V> seg = segments[k];
            if (seg != null) {
                seg.threshold = (int)(cap * seg.loadFactor);
                seg.table = new HashEntry[cap];
            }
        }

        // Read the keys and values, and put the mappings in the table
        for (;;) {
            K key = (K) s.readObject();
            V value = (V) s.readObject();
            if (key == null) {
              break;
            }
            put(key, value);
        }
    }
300196
private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();

        // Read in elements until trailing null sentinel found
        Node<E> h = null, t = null;
        for (Object item; (item = s.readObject()) != null; ) {
            @SuppressWarnings("unchecked")
            Node<E> newNode = newNode((E) item);
            if (h == null)
                h = t = newNode;
            else {
                NEXT.set(t, newNode);
                PREV.set(newNode, t);
                t = newNode;
            }
        }
        initHeadTail(h, t);
    }
1324081
public static <T> Callable<T> memoizeCallable(final Callable<T> s) {
        final Map<Object, T> lazy = new ConcurrentHashMap<>();
        return () -> lazy.computeIfAbsent("k", a -> {

            return ExceptionSoftener.softenCallable(s)
                                    .get();

        });
    }
119934
private void readObject(ObjectInputStream s) throws java.io.IOException, java.lang.ClassNotFoundException {
        throw new UnsupportedOperationException(); // not serializable
    }
135128
@Override
    public void readExternal(ObjectInput s) throws IOException, ClassNotFoundException {
        super.readExternal(s);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "Deserializing " + this);
        }
    }
998874
private void deserializeMethod(ObjectInput stream) throws IOException, ClassNotFoundException {
        MethodValues method = null;
        if (SERIALIZATION_V2 == getDeserializationVersion()) {
            method = MethodValues.find(readByteArray(stream));
        } else {
            method = MethodValues.find((String) stream.readObject());
        }
        if (null == method) {
            throw new IOException("Missing method");
        }
        setMethod(method);
    }
148508
protected void reconstitute(
      MessageProcessor processor,
      HashMap durableSubscriptionsTable,
      int startMode) throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "reconstitute", new Object[] { processor,
          durableSubscriptionsTable, new Integer(startMode) });
    
    getLocalisationManager().setMessageProcessor(processor);
    
    super.reconstitute(processor, durableSubscriptionsTable, startMode);
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "reconstitute");
  }
468684
private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden stuff
        s.defaultReadObject();

        // Read in Comparator
        @SuppressWarnings("unchecked")
            Comparator<? super E> c = (Comparator<? super E>) s.readObject();

        // Create backing TreeMap
        TreeMap<E,Object> tm = new TreeMap<>(c);
        m = tm;

        // Read in size
        int size = s.readInt();

        tm.readTreeSet(size, s, PRESENT);
    }
1193345
private void readObject(java.io.ObjectInputStream s)
        throws IOException, ClassNotFoundException
    {
        // Read in the threshold, loadfactor, and any hidden stuff
        s.defaultReadObject();
        
        // Read in number of buckets and allocate the bucket array;
        int numBuckets = s.readInt();
        table = new Entry[numBuckets];
        
        // Read in size (number of Mappings)
        int size = s.readInt();
        
        // Read the keys and values, and put the mappings in the IntHashMap
        for (int i=0; i<size; i++) {
            int key = s.readInt();
            V value = (V) s.readObject();
            put(key, value);
        }
    }
982705
protected synchronized void setStream(InputStream s)
    {
        if (stream != null)
        {
            throw new UnsupportedOperationException("Cannot set the stream of an open resource");
        }
        stream = s;
        streamState = StreamStates.OPEN;
    }
690071
public void doAfterDeserialization() {
        if ( listeners == null ) {
            listeners = new ArrayList<SessionListener>();
        }
        if ( notes == null ) {
            notes = new ConcurrentHashMap<String, Object>();
        }
    }
1178122
private void readObject(java.io.ObjectInputStream s)
		throws java.io.IOException, ClassNotFoundException {
		// Read in size, and any hidden stuff
		s.defaultReadObject();

		// Read in array length and allocate array
		int arrayLength = s.readInt();
		long[] a = elementData = new long[arrayLength];

		// Read in all elements in the proper order.
		for (int i=0; i<size; i++)
			a[i] = s.readLong();
	}
241675
private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();

        // Read in elements until trailing null sentinel found
        Node<E> h = null, t = null;
        for (Object item; (item = s.readObject()) != null; ) {
            @SuppressWarnings("unchecked")
            Node<E> newNode = new Node<E>((E) item);
            if (h == null)
                h = t = newNode;
            else {
                t.lazySetNext(newNode);
                newNode.lazySetPrev(t);
                t = newNode;
            }
        }
        initHeadTail(h, t);
    }
241433
private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {

        // Read in all fields
        s.defaultReadObject();
        compile();
    }
460716
private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException
    {
        s.defaultReadObject();
        if (encryptedContent != null)
            encryptedContent = encryptedContent.clone();
        if (encodedParams != null)
            encodedParams = encodedParams.clone();
    }
1110173
protected void reconstitute(
                                MessageProcessor processor,
                                HashMap<String, Object> durableSubscriptionsTable,
                                int startMode) throws SIResourceException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(
                        tc,
                        "reconstitute",
                        new Object[] { processor, durableSubscriptionsTable, Integer.valueOf(startMode) });

        super.reconstitute(processor);

        // Links are 'BaseDestinationHandlers' but have no destination-like addressibility.
        if (!isLink())
        {
            _name = getDefinition().getName();
            _destinationAddr = SIMPUtils.createJsDestinationAddress(_name, null, getBus());
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            SibTr.debug(
                        tc,
                        "Reconstituting "
                                        + (isPubSub() ? "pubsub" : "ptp")
                                        + " BaseDestinationHandler "
                                        + getName());

        String name = getName();
        if ((name.startsWith(SIMPConstants.TEMPORARY_QUEUE_DESTINATION_PREFIX) || name.startsWith(SIMPConstants.TEMPORARY_PUBSUB_DESTINATION_PREFIX)))
        {
            _isTemporary = true;
            _isSystem = false;
        }
        else
        {
            _isTemporary = false;
            _isSystem = name.startsWith(SIMPConstants.SYSTEM_DESTINATION_PREFIX);
        }

        /*
         * Any kind of failure while retrieving data from the message store (whether
         * problems with the MS itself or with the data retrieved) means this
         * destination should be marked as corrupt. The only time an exception
         * should be thrown back up to the DM is when the corruption of the
         * destination is fatal to starting the ME (such as a corrupt system
         * destination, currently).
         */
        try
        {
            // Create appropriate state objects
            createRealizationAndState(messageProcessor);

            // Restore GD ProtocolItemStream before creating InputHandler
            _protoRealization.
                            getRemoteSupport().
                            reconstituteGD();

            // Reconstitute message ItemStreams
            if (isPubSub())
            {
                // Indicate that the destinationHandler has not yet been reconciled
                _reconciled = false;

                createControlAdapter();

                //Check if we are running in an ND environment.  If not we can skip
                //some performance intensive WLM work
                _singleServer = messageProcessor.isSingleServer();
                _pubSubRealization.reconstitute(startMode,
                                                durableSubscriptionsTable);

            }
            else
            {
                initializeNonPersistent(processor, durableSubscriptionsTable, null);

                // Indicate that the destinationHandler has not yet been reconciled
                _reconciled = false;

                _ptoPRealization.reconstitute(startMode,
                                              definition,
                                              isToBeDeleted(),
                                              isSystem());
            }

            // Reconstitute GD target streams
            _protoRealization.
                            reconstituteGDTargetStreams();
        } catch (Exception e)
        {
            FFDCFilter.processException(
                                        e,
                                        "com.ibm.ws.sib.processor.impl.BaseDestinationHandler.reconstitute",
                                        "1:945:1.700.3.45",
                                        this);

            SibTr.exception(tc, e);

            // At the moment, any exception we get while reconstituting means that we
            // want to mark the destination as corrupt.
            _isCorruptOrIndoubt = true;

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "reconstitute", e);

            throw new SIResourceException(e);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            SibTr.debug(
                        tc,
                        "Reconstituted "
                                        + (isPubSub() ? "pubsub" : "ptp")
                                        + " BaseDestinationHandler "
                                        + getName());

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "reconstitute");
    }
534621
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
		// Read in size, and any hidden stuff
		s.defaultReadObject();
		
		this.stringDecoder = new Utf8();
		this.in = null;
	}