/// <summary> /// Read the ObjectInputStream. </summary> /// <exception cref="HeadlessException"> if /// <code>GraphicsEnvironment.isHeadless()</code> returns /// <code>true</code> </exception> /// <seealso cref= java.awt.GraphicsEnvironment#isHeadless </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream s) throws ClassNotFoundException, java.io.IOException, HeadlessException private void ReadObject(ObjectInputStream s) { // HeadlessException will be thrown by TextComponent's readObject s.DefaultReadObject(); // Make sure the state we just read in for columns, rows, // and scrollbarVisibility has legal values if (Columns_Renamed < 0) { Columns_Renamed = 0; } if (Rows_Renamed < 0) { Rows_Renamed = 0; } if ((ScrollbarVisibility_Renamed < SCROLLBARS_BOTH) || (ScrollbarVisibility_Renamed > SCROLLBARS_NONE)) { this.ScrollbarVisibility_Renamed = SCROLLBARS_BOTH; } if (TextAreaSerializedDataVersion < 2) { SetFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, ForwardTraversalKeys); SetFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, BackwardTraversalKeys); } }
/// <summary> /// Deserializes this <code>DragSource</code>. This method first performs /// default deserialization. Next, this object's <code>FlavorMap</code> is /// deserialized by using the next object in the stream. /// If the resulting <code>FlavorMap</code> is <code>null</code>, this /// object's <code>FlavorMap</code> is set to the default FlavorMap for /// this thread's <code>ClassLoader</code>. /// Next, this object's listeners are deserialized by reading a /// <code>null</code>-terminated sequence of 0 or more key/value pairs /// from the stream: /// <ul> /// <li>If a key object is a <code>String</code> equal to /// <code>dragSourceListenerK</code>, a <code>DragSourceListener</code> is /// deserialized using the corresponding value object and added to this /// <code>DragSource</code>. /// <li>If a key object is a <code>String</code> equal to /// <code>dragSourceMotionListenerK</code>, a /// <code>DragSourceMotionListener</code> is deserialized using the /// corresponding value object and added to this <code>DragSource</code>. /// <li>Otherwise, the key/value pair is skipped. /// </ul> /// </summary> /// <seealso cref= java.awt.datatransfer.SystemFlavorMap#getDefaultFlavorMap /// @since 1.4 </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream s) throws ClassNotFoundException, java.io.IOException private void ReadObject(ObjectInputStream s) { s.DefaultReadObject(); // 'flavorMap' was written explicitly FlavorMap_Renamed = (FlavorMap)s.ReadObject(); // Implementation assumes 'flavorMap' is never null. if (FlavorMap_Renamed == null) { FlavorMap_Renamed = SystemFlavorMap.DefaultFlavorMap; } Object keyOrNull; while (null != (keyOrNull = s.ReadObject())) { String key = ((String)keyOrNull).intern(); if (DragSourceListenerK == key) { AddDragSourceListener((DragSourceListener)(s.ReadObject())); } else if (DragSourceMotionListenerK == key) { AddDragSourceMotionListener((DragSourceMotionListener)(s.ReadObject())); } else { // skip value for unrecognized key s.ReadObject(); } } }
/// <summary> /// Read the ObjectInputStream and if it isn't null, /// add a listener to receive action events fired by the /// TextField. Unrecognized keys or values will be /// ignored. /// </summary> /// <exception cref="HeadlessException"> if /// <code>GraphicsEnvironment.isHeadless()</code> returns /// <code>true</code> </exception> /// <seealso cref= #removeActionListener(ActionListener) </seealso> /// <seealso cref= #addActionListener(ActionListener) </seealso> /// <seealso cref= java.awt.GraphicsEnvironment#isHeadless </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream s) throws ClassNotFoundException, java.io.IOException, HeadlessException private void ReadObject(ObjectInputStream s) { // HeadlessException will be thrown by TextComponent's readObject s.DefaultReadObject(); // Make sure the state we just read in for columns has legal values if (Columns_Renamed < 0) { Columns_Renamed = 0; } // Read in listeners, if any Object keyOrNull; while (null != (keyOrNull = s.ReadObject())) { String key = ((String)keyOrNull).intern(); if (ActionListenerK == key) { AddActionListener((ActionListener)(s.ReadObject())); } else { // skip value for unrecognized key s.ReadObject(); } } }
/// <summary> /// Deserialize the {@code CertificateRevokedException} instance. /// </summary> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream ois) throws java.io.IOException, ClassNotFoundException private void ReadObject(ObjectInputStream ois) { // Read in the non-transient fields // (revocationDate, reason, authority) ois.DefaultReadObject(); // Defensively copy the revocation date RevocationDate_Renamed = new DateTime(RevocationDate_Renamed.Ticks); // Read in the size (number of mappings) of the extensions map // and create the extensions map int size = ois.ReadInt(); if (size == 0) { Extensions_Renamed = Collections.EmptyMap(); } else { Extensions_Renamed = new Dictionary <String, Extension>(size); } // Read in the extensions and put the mappings in the extensions map for (int i = 0; i < size; i++) { String oid = (String)ois.ReadObject(); bool critical = ois.ReadBoolean(); int length = ois.ReadInt(); sbyte[] extVal = new sbyte[length]; ois.ReadFully(extVal); Extension ext = sun.security.x509.Extension.newExtension(new ObjectIdentifier(oid), critical, extVal); Extensions_Renamed[oid] = ext; } }
/// <exception cref="System.IO.IOException"/> /// <exception cref="System.TypeLoadException"/> private void ReadObject(ObjectInputStream stream) { stream.DefaultReadObject(); // log.info("Before decompression:"); // log.info("arg size: " + argCounter.size() + " total: " + argCounter.totalCount()); // log.info("stop size: " + stopCounter.size() + " total: " + stopCounter.totalCount()); ClassicCounter <IntDependency> compressedArgC = argCounter; argCounter = new ClassicCounter <IntDependency>(); ClassicCounter <IntDependency> compressedStopC = stopCounter; stopCounter = new ClassicCounter <IntDependency>(); foreach (IntDependency d in compressedArgC.KeySet()) { double count = compressedArgC.GetCount(d); ExpandArg(d, d.distance, count); } foreach (IntDependency d_1 in compressedStopC.KeySet()) { double count = compressedStopC.GetCount(d_1); ExpandStop(d_1, d_1.distance, count, false); } // log.info("After decompression:"); // log.info("arg size: " + argCounter.size() + " total: " + argCounter.totalCount()); // log.info("stop size: " + stopCounter.size() + " total: " + stopCounter.totalCount()); expandDependencyMap = null; }
/// <summary> /// This method is used by Java object deserialization, to fill in the /// transient /// <see cref="trackingUriPlugins"/> /// field. /// See /// <see cref="System.IO.ObjectInputStream.DefaultReadObject()"/> /// <p> /// <I>Do not remove</I> /// <p> /// Yarn isn't currently serializing this class, but findbugs /// complains in its absence. /// </summary> /// <param name="input">source</param> /// <exception cref="System.IO.IOException">IO failure</exception> /// <exception cref="System.TypeLoadException">classloader fun</exception> private void ReadObject(ObjectInputStream input) { input.DefaultReadObject(); conf = new YarnConfiguration(); this.trackingUriPlugins = conf.GetInstances <TrackingUriPlugin>(YarnConfiguration. YarnTrackingUrlGenerator); }
/// <summary> /// Reads the default serializable fields, provides default values for objects /// in older serial versions, and initializes non-serializable fields. /// If <code>serialVersionOnStream</code> /// is less than 1, initializes <code>monetarySeparator</code> to be /// the same as <code>decimalSeparator</code> and <code>exponential</code> /// to be 'E'. /// If <code>serialVersionOnStream</code> is less than 2, /// initializes <code>locale</code>to the root locale, and initializes /// If <code>serialVersionOnStream</code> is less than 3, it initializes /// <code>exponentialSeparator</code> using <code>exponential</code>. /// Sets <code>serialVersionOnStream</code> back to the maximum allowed value so that /// default serialization will work properly if this object is streamed out again. /// Initializes the currency from the intlCurrencySymbol field. /// /// @since JDK 1.1.6 /// </summary> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream stream) throws java.io.IOException, ClassNotFoundException private void ReadObject(ObjectInputStream stream) { stream.DefaultReadObject(); if (SerialVersionOnStream < 1) { // Didn't have monetarySeparator or exponential field; // use defaults. MonetarySeparator = DecimalSeparator_Renamed; Exponential = 'E'; } if (SerialVersionOnStream < 2) { // didn't have locale; use root locale Locale = Locale.ROOT; } if (SerialVersionOnStream < 3) { // didn't have exponentialSeparator. Create one using exponential ExponentialSeparator = char.ToString(Exponential); } SerialVersionOnStream = CurrentSerialVersion; if (IntlCurrencySymbol != null) { try { Currency_Renamed = Currency.GetInstance(IntlCurrencySymbol); } catch (IllegalArgumentException) { } } }
/// <exception cref="System.IO.IOException"/> /// <exception cref="System.TypeLoadException"/> private void ReadObject(ObjectInputStream ois) { ois.DefaultReadObject(); // Reinitialize the transient objects. This must be done here // rather than lazily so that there is no race condition to // reinitialize them later. InitRulesWithWord(); }
/// <summary> /// Read an applet from an object input stream. </summary> /// <exception cref="HeadlessException"> if /// <code>GraphicsEnvironment.isHeadless()</code> returns /// <code>true</code> /// @serial </exception> /// <seealso cref= java.awt.GraphicsEnvironment#isHeadless /// @since 1.4 </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream s) throws ClassNotFoundException, java.io.IOException, HeadlessException private void ReadObject(ObjectInputStream s) { if (GraphicsEnvironment.Headless) { throw new HeadlessException(); } s.DefaultReadObject(); }
/// <summary> /// After reading an object from the input stream, do a simple verification /// to maintain class invariants. </summary> /// <exception cref="InvalidObjectException"> if the objects read from the stream is invalid. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException private void ReadObject(ObjectInputStream @in) { @in.DefaultReadObject(); if (ChoiceLimits.Length != ChoiceFormats.Length) { throw new InvalidObjectException("limits and format arrays of different length."); } }
/// <summary> /// <code>readObject</code> for custom serialization. /// /// <para>This method reads this object's serialized form for this /// class as follows: /// /// </para> /// <para>This method first invokes <code>defaultReadObject</code> on /// the specified object input stream, and if <code>options</code> /// is <code>null</code>, then <code>options</code> is set to a /// zero-length array of <code>String</code>. /// </para> /// </summary> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException internal virtual void ReadObject(ObjectInputStream @in) { @in.DefaultReadObject(); if (Options == null) { Options = new String[0]; } }
// TODO [2014]: This should really be a long // TODO: add an option to set this to some other language pack // almost an owl // TODO: we can remove this if we reserialize all the models /// <exception cref="System.IO.IOException"/> /// <exception cref="System.TypeLoadException"/> private void ReadObject(ObjectInputStream @in) { @in.DefaultReadObject(); if (testOptions == null) { testOptions = new RNNTestOptions(); } }
/// <summary> /// readObject is called to restore the state of the PropertyPermission from /// a stream. /// </summary> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private synchronized void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException private void ReadObject(ObjectInputStream s) { lock (this) { // Read in the action, then initialize the rest s.DefaultReadObject(); Init(GetMask(Actions_Renamed)); } }
/// <summary> /// Initializes the <code>when</code> field if it is not present in the /// object input stream. In that case, the field will be initialized by /// invoking <seealso cref="java.awt.EventQueue#getMostRecentEventTime()"/>. /// </summary> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream s) throws ClassNotFoundException, java.io.IOException private void ReadObject(ObjectInputStream s) { s.DefaultReadObject(); if (When_Renamed == 0) { // Can't use getMostRecentEventTimeForSource because source is always null during deserialization When_Renamed = EventQueue.MostRecentEventTime; } }
/// <summary> /// Reads the <code>ObjectInputStream</code>. /// Unrecognized keys or values will be ignored. /// </summary> /// <param name="s"> the <code>ObjectInputStream</code> to read </param> /// <exception cref="HeadlessException"> if /// <code>GraphicsEnvironment.isHeadless</code> returns /// <code>true</code> </exception> /// <seealso cref= java.awt.GraphicsEnvironment#isHeadless </seealso> /// <seealso cref= #writeObject(java.io.ObjectOutputStream) </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream s) throws ClassNotFoundException, java.io.IOException, HeadlessException private void ReadObject(ObjectInputStream s) { // HeadlessException will be thrown from MenuComponent's readObject s.DefaultReadObject(); for (int i = 0; i < Menus.Count; i++) { Menu m = Menus[i]; m.Parent_Renamed = this; } }
/// <summary> /// Called to read the object from a stream. /// </summary> /// <exception cref="InvalidObjectException"> /// if the object is invalid or has a cause that is not /// an {@code IOException} </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException private void ReadObject(ObjectInputStream s) { s.DefaultReadObject(); Throwable cause = base.InnerException; if (!(cause is IOException)) { throw new InvalidObjectException("Cause must be an IOException"); } }
/// <summary> /// Reads the menu component from an object input stream. /// </summary> /// <param name="s"> the <code>ObjectInputStream</code> to read </param> /// <exception cref="HeadlessException"> if /// <code>GraphicsEnvironment.isHeadless</code> returns /// <code>true</code> /// @serial </exception> /// <seealso cref= java.awt.GraphicsEnvironment#isHeadless </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream s) throws ClassNotFoundException, java.io.IOException, HeadlessException private void ReadObject(ObjectInputStream s) { GraphicsEnvironment.CheckHeadless(); Acc = AccessController.Context; s.DefaultReadObject(); AppContext = AppContext.AppContext; }
/// <summary> /// Reads this object out of a serialization stream, handling /// objects written by older versions of the class that didn't contain all /// of the fields we use now.. /// </summary> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream stream) throws java.io.IOException, ClassNotFoundException private void ReadObject(ObjectInputStream stream) { stream.DefaultReadObject(); if (SerialVersionOnStream < 1) { // "newAlign" field wasn't present, so use the old "align" field. Alignment = this.Align; } SerialVersionOnStream = CurrentSerialVersion; }
/// <exception cref="System.IO.IOException"/> /// <exception cref="System.TypeLoadException"/> private void ReadObject(ObjectInputStream stream) { stream.DefaultReadObject(); ICollection <UnaryRule> allRules = Generics.NewHashSet(coreRules.Keys); Init(); foreach (UnaryRule ur in allRules) { AddRule(ur); } PurgeRules(); }
/* ---- * public Set<BinaryRule> ruleSetByRightChild(int state) { * if (state >= ruleSetWithRC.length) { * return Collections.<BinaryRule>emptySet(); * } * return ruleSetWithRC[state]; * } * * public Set<BinaryRule> ruleSetByLeftChild(int state) { * if (state >= ruleSetWithRC.length) { * return Collections.<BinaryRule>emptySet(); * } * return ruleSetWithLC[state]; * } * --- */ /// <exception cref="System.IO.IOException"/> /// <exception cref="System.TypeLoadException"/> private void ReadObject(ObjectInputStream stream) { stream.DefaultReadObject(); Init(); foreach (BinaryRule br in allRules) { rulesWithParent[br.parent].Add(br); rulesWithLC[br.leftChild].Add(br); rulesWithRC[br.rightChild].Add(br); ruleMap[br] = br; } SplitRules(); }
/// <summary> /// Reads the <code>ObjectInputStream</code> and performs /// a backwards compatibility check by converting /// either a <code>dir</code> or a <code>file</code> /// equal to an empty string to <code>null</code>. /// </summary> /// <param name="s"> the <code>ObjectInputStream</code> to read </param> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream s) throws ClassNotFoundException, java.io.IOException private void ReadObject(ObjectInputStream s) { s.DefaultReadObject(); // 1.1 Compatibility: "" is not converted to null in 1.1 if (Dir != null && Dir.Equals("")) { Dir = null; } if (File_Renamed != null && File_Renamed.Equals("")) { File_Renamed = null; } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException private void ReadObject(ObjectInputStream @in) { // We have to call defaultReadObject first. @in.DefaultReadObject(); // Read version number. sbyte major = @in.ReadByte(); sbyte minor = @in.ReadByte(); if (major != 1) { throw new IOException("LogRecord: bad version: " + major + "." + minor); } int len = @in.ReadInt(); if (len == -1) { Parameters_Renamed = null; } else { Parameters_Renamed = new Object[len]; for (int i = 0; i < Parameters_Renamed.Length; i++) { Parameters_Renamed[i] = @in.ReadObject(); } } // If necessary, try to regenerate the resource bundle. if (ResourceBundleName_Renamed != null) { try { // use system class loader to ensure the ResourceBundle // instance is a different instance than null loader uses //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final ResourceBundle bundle = ResourceBundle.getBundle(resourceBundleName, Locale.getDefault(), ClassLoader.getSystemClassLoader()); ResourceBundle bundle = ResourceBundle.GetBundle(ResourceBundleName_Renamed, Locale.Default, ClassLoader.SystemClassLoader); ResourceBundle_Renamed = bundle; } catch (MissingResourceException) { // This is not a good place to throw an exception, // so we simply leave the resourceBundle null. ResourceBundle_Renamed = null; } } NeedToInferCaller = false; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream stream) throws ClassNotFoundException, java.io.IOException private void ReadObject(ObjectInputStream stream) { stream.DefaultReadObject(); if (Reason_Renamed == null) { Reason_Renamed = BasicReason.UNSPECIFIED; } if (CertPath_Renamed == null && Index_Renamed != -1) { throw new InvalidObjectException("certpath is null and index != -1"); } if (Index_Renamed < -1 || (CertPath_Renamed != null && Index_Renamed >= CertPath_Renamed.Certificates.Count)) { throw new InvalidObjectException("index out of range"); } }
//----------------------------------------------------------------------- /// <summary> /// Restore the state of an ValueRange from the stream. /// Check that the values are valid. /// </summary> /// <param name="s"> the stream to read </param> /// <exception cref="InvalidObjectException"> if /// the smallest minimum is greater than the smallest maximum, /// or the smallest maximum is greater than the largest maximum /// or the largest minimum is greater than the largest maximum </exception> /// <exception cref="ClassNotFoundException"> if a class cannot be resolved </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException, java.io.InvalidObjectException private void ReadObject(ObjectInputStream s) { s.DefaultReadObject(); if (MinSmallest > MinLargest) { throw new InvalidObjectException("Smallest minimum value must be less than largest minimum value"); } if (MaxSmallest > MaxLargest) { throw new InvalidObjectException("Smallest maximum value must be less than largest maximum value"); } if (MinLargest > MaxLargest) { throw new InvalidObjectException("Minimum value must be less than maximum value"); } }
/* * Reads the <code>ObjectInputStream</code> and if it * isn't <code>null</code> adds a listener to receive * item events fired by the <code>Checkbox</code> menu item. * Unrecognized keys or values will be ignored. * * @param s the <code>ObjectInputStream</code> to read * @serial * @see removeActionListener() * @see addActionListener() * @see #writeObject */ //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream s) throws ClassNotFoundException, java.io.IOException private void ReadObject(ObjectInputStream s) { s.DefaultReadObject(); Object keyOrNull; while (null != (keyOrNull = s.ReadObject())) { String key = ((String)keyOrNull).intern(); if (ItemListenerK == key) { AddItemListener((ItemListener)(s.ReadObject())); } else // skip value for unrecognized key { s.ReadObject(); } } }
/// <summary> /// Reads the <code>ObjectInputStream</code> and if it /// isn't <code>null</code> adds a listener to receive /// action events fired by the <code>Menu</code> Item. /// Unrecognized keys or values will be ignored. /// </summary> /// <param name="s"> the <code>ObjectInputStream</code> to read </param> /// <exception cref="HeadlessException"> if /// <code>GraphicsEnvironment.isHeadless</code> returns /// <code>true</code> </exception> /// <seealso cref= #removeActionListener(ActionListener) </seealso> /// <seealso cref= #addActionListener(ActionListener) </seealso> /// <seealso cref= #writeObject(ObjectOutputStream) </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream s) throws ClassNotFoundException, java.io.IOException, HeadlessException private void ReadObject(ObjectInputStream s) { // HeadlessException will be thrown from MenuComponent's readObject s.DefaultReadObject(); Object keyOrNull; while (null != (keyOrNull = s.ReadObject())) { String key = ((String)keyOrNull).intern(); if (ActionListenerK == key) { AddActionListener((ActionListener)(s.ReadObject())); } else // skip value for unrecognized key { s.ReadObject(); } } }
/// <summary> /// Reads the <code>ObjectInputStream</code> and if /// it isn't <code>null</code> adds a listener to /// receive action events fired by the button. /// Unrecognized keys or values will be ignored. /// </summary> /// <param name="s"> the <code>ObjectInputStream</code> to read </param> /// <exception cref="HeadlessException"> if /// <code>GraphicsEnvironment.isHeadless</code> returns /// <code>true</code> /// @serial </exception> /// <seealso cref= #removeActionListener(ActionListener) </seealso> /// <seealso cref= #addActionListener(ActionListener) </seealso> /// <seealso cref= java.awt.GraphicsEnvironment#isHeadless </seealso> /// <seealso cref= #writeObject(ObjectOutputStream) </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(java.io.ObjectInputStream s) throws ClassNotFoundException, java.io.IOException, HeadlessException private void ReadObject(ObjectInputStream s) { GraphicsEnvironment.CheckHeadless(); s.DefaultReadObject(); Object keyOrNull; while (null != (keyOrNull = s.ReadObject())) { String key = ((String)keyOrNull).intern(); if (ActionListenerK == key) { AddActionListener((ActionListener)(s.ReadObject())); } else // skip value for unrecognized key { s.ReadObject(); } } }
// Explicitly reset hash code value to -1 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException private void ReadObject(ObjectInputStream ois) { ois.DefaultReadObject(); Myhash = -1; }
// Maps from basic category to the matrix transformation matrices for // binary nodes and unary nodes. // The indices are the children categories. For binaryTransform, for // example, we have a matrix for each type of child that appears. // score matrices for each node type // cache these for easy calculation of "theta" parameter size // we just keep this here for convenience // the seed we used to use was 19580427 /// <exception cref="System.IO.IOException"/> /// <exception cref="System.TypeLoadException"/> private void ReadObject(ObjectInputStream @in) { @in.DefaultReadObject(); identity = SimpleMatrix.Identity(numRows); }
/// <exception cref="System.IO.IOException"/> /// <exception cref="System.TypeLoadException"/> private void ReadObject(ObjectInputStream ois) { ois.DefaultReadObject(); // reinitialize the transient objects itwInterner = new Interner <IntTaggedWord>(); }