/// <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>();
}
