Custom de-serialization method handling the transient values

@param stream
@throws java.io.IOException
@throws ClassNotFoundException
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;
	}
278483
void removeStream(DefaultStream stream, Iterator<?> itr) {
        final boolean removed;
        if (itr == null) {
            removed = streamMap.remove(stream.id()) != null;
        } else {
            itr.remove();
            removed = true;
        }

        if (removed) {
            for (int i = 0; i < listeners.size(); i++) {
                try {
                    listeners.get(i).onStreamRemoved(stream);
                } catch (Throwable cause) {
                    logger.error("Caught Throwable from listener onStreamRemoved.", cause);
                }
            }

            if (closePromise != null && isStreamMapEmpty()) {
                closePromise.trySuccess(null);
            }
        }
    }
1241030
private void readObject(ObjectInputStream stream)
         throws IOException, ClassNotFoundException
    {
        stream.defaultReadObject();

        if (serialVersionOnStream < 1) {
            // Fix a bug in the 1.1 SimpleTimeZone code -- namely,
            // startDayOfWeek and endDayOfWeek were usually uninitialized.  We can't do
            // too much, so we assume SUNDAY, which actually works most of the time.
            if (startDayOfWeek == 0) {
                startDayOfWeek = Calendar.SUNDAY;
            }
            if (endDayOfWeek == 0) {
                endDayOfWeek = Calendar.SUNDAY;
            }

            // The variables dstSavings, startMode, and endMode are post-1.1, so they
            // won't be present if we're reading from a 1.1 stream.  Fix them up.
            startMode = endMode = DOW_IN_MONTH_MODE;
            dstSavings = millisPerHour;
        } else {
            // For 1.1.4, in addition to the 3 new instance variables, we also
            // store the actual rules (which have not be made compatible with 1.1)
            // in the optional area.  Read them in here and parse them.
            int length = stream.readInt();
            byte[] rules = new byte[length];
            stream.readFully(rules);
            unpackRules(rules);
        }

        if (serialVersionOnStream >= 2) {
            int[] times = (int[]) stream.readObject();
            unpackTimes(times);
        }

        serialVersionOnStream = currentSerialVersion;
    }
410963
private void readObject(ObjectInputStream in)
        throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        if (null != params) {
            this.serializer = params.getDefaultSerializer();
        }
    }
548616
@GwtIncompatible("ObjectOutputStream")
  public void serialize(OutputStream objectOutputStream) throws IOException {
    new java.io.ObjectOutputStream(objectOutputStream).writeObject(this);
  }
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);
  }
1107924
private Header parseHeader(InputStream stream) throws IOException, ClassNotFoundException {
        DataInputStream dis = new DataInputStream(stream);
        // Check if the stream starts with the expected header
        String header = dis.readUTF();
        if (!header.equals(HEADER)) {
            throw new IllegalArgumentException(
                    "Could not restore normalizer: invalid header. If this normalizer was saved with a opType-specific "
                            + "strategy like StandardizeSerializerStrategy, use that class to restore it as well.");
        }

        // The next byte is an integer indicating the version
        int version = dis.readInt();

        // Right now, we only support version 1
        if (version != 1) {
            throw new IllegalArgumentException("Could not restore normalizer: invalid version (" + version + ")");
        }
        // The next value is a string indicating the normalizer opType
        NormalizerType type = NormalizerType.valueOf(dis.readUTF());
        if (type.equals(NormalizerType.CUSTOM)) {
            // For custom serializers, the next value is a string with the class opName
            String strategyClassName = dis.readUTF();
            //noinspection unchecked
            return new Header(type, (Class<? extends NormalizerSerializerStrategy>) Class.forName(strategyClassName));
        } else {
            return new Header(type, null);
        }
    }
1138284
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
		// Call the default implementation to de-serialize our object
		in.defaultReadObject();
		// init transients
		_validateLastModified = new AtomicBoolean(true);
		_cacheKeyGenMutex = new Semaphore(1);
		_isReportCacheInfo = false;
	}
97259
private synchronized void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();

        // the transient _nameMap is null after an instance of
        // NameService has been serialized.
        if (_nameMap == null) {
            _nameMap = new HashMap();
        }
    }
1036437
void cleanup(Http2Stream stream, EmbeddedChannel compressor) {
        if (compressor.finish()) {
            for (;;) {
                final ByteBuf buf = compressor.readOutbound();
                if (buf == null) {
                    break;
                }

                buf.release();
            }
        }
        stream.removeProperty(propertyKey);
    }
1191535
protected void doReadObject(final ObjectInputStream stream) throws IOException, ClassNotFoundException {
        final GetField readFields = stream.readFields();

        for (final String fieldName : getFieldNamesInAdditionToId()) {
            final Object value = readFields.get(fieldName, null);
            setField(fieldName, value);
        }

        // fix issue of deserializing _rowNumber in it's previous int form
        final long rowNumber;
        final ObjectStreamField legacyRowNumberField =
                readFields.getObjectStreamClass().getField(getFieldNameForOldId());
        if (legacyRowNumberField != null) {
            rowNumber = readFields.get(getFieldNameForOldId(), -1);
        } else {
            rowNumber = readFields.get(getFieldNameForNewId(), -1L);
        }

        setField(getFieldNameForNewId(), rowNumber);
    }
991395
private void readObject(ObjectInputStream stream)
        throws IOException, ClassNotFoundException {
        stream.defaultReadObject();
        int capitalizationSettingValue = (serialVersionOnStream > 1)? stream.readInt(): -1;
        ///CLOVER:OFF
        // don't have old serial data to test with
        if (serialVersionOnStream < 1) {
            // didn't have defaultCenturyStart field
            defaultCenturyBase = System.currentTimeMillis();
        }
        ///CLOVER:ON
        else {
            // fill in dependent transient field
            parseAmbiguousDatesAsAfter(defaultCenturyStart);
        }
        serialVersionOnStream = currentSerialVersion;
        locale = getLocale(ULocale.VALID_LOCALE);
        if (locale == null) {
            // ICU4J 3.6 or older versions did not have UFormat locales
            // in the serialized data. This is just for preventing the
            // worst case scenario...
            locale = ULocale.getDefault(Category.FORMAT);
        }

        initLocalZeroPaddingNumberFormat();

        setContext(DisplayContext.CAPITALIZATION_NONE);
        if (capitalizationSettingValue >= 0) {
            for (DisplayContext context: DisplayContext.values()) {
                if (context.value() == capitalizationSettingValue) {
                    setContext(context);
                    break;
                }
            }
        }

        // if serialized pre-56 update & turned off partial match switch to new enum value
        if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_PARTIAL_MATCH) == false) {
            setBooleanAttribute(DateFormat.BooleanAttribute.PARSE_PARTIAL_LITERAL_MATCH, false);
        }

        parsePattern();
    }
1017361
@SuppressWarnings("unchecked")
    protected void readFromSerializedStream(final ObjectInputStream stream) throws IOException, ClassNotFoundException {
        cas = stream.readLong();
        expiry = stream.readInt();
        id = stream.readUTF();
        content = (T) stream.readObject();
        mutationToken = (MutationToken) stream.readObject();
    }
211833
@Deprecated
    public void dump(java.io.PrintStream out) {
        if (out == null) {
            out = System.out;
        }
        this.fRData.dump(out);
    }
245548
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
		in.defaultReadObject();

		// may be null if this serializer was deserialized from an older version
		if (this.values == null) {
			this.values = enumClass.getEnumConstants();

			this.valueToOrdinal = new EnumMap<>(this.enumClass);
			int i = 0;
			for (T value : values) {
				this.valueToOrdinal.put(value, i++);
			}
		}
	}
14375
@Override
    @SuppressWarnings ("unchecked")
    public void deserialize(byte[] serializedData, boolean wipe) throws IOException {
        if (wipe) {
            map.clear();
        }
        InputStream in = new ByteArrayInputStream(serializedData);
        ObjectInputStream ois = new ClassResolverObjectInputStream(in);
        try {
            // Because it may be a map of maps, we want to UPDATE inner maps, not overwrite
            for (Map.Entry<String, ? extends Serializable> e : ((Map<String, ? extends Serializable>) ois.readObject()).entrySet()) {
                if (e.getValue() instanceof Map && map.get(e.getKey()) instanceof Map) {
                    ((Map) map.get(e.getKey())).putAll((Map) e.getValue());
                } else {
                    put(e.getKey(), e.getValue());
                }
            }
        } catch (ClassNotFoundException ex) {
            throw new IllegalStateException("Unable to decompress SerializableHashMap", ex);
        }
    }
947868
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
        jsonObject = Utils.mapper().readValue((DataInput) stream, ObjectNode.class);
    }