src.com.ibm.as400.access.ProductLicense Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400 Show documentation
Show all versions of jt400 Show documentation
The Open Source version of the IBM Toolbox for Java
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: ProductLicense.java
//
// The source code contained herein is licensed under the IBM Public License
// Version 1.0, which has been approved by the Open Source Initiative.
// Copyright (C) 1997-2004 International Business Machines Corporation and
// others. All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////
package com.ibm.as400.access;
import java.beans.PropertyChangeSupport; // @A2A
import java.beans.PropertyChangeListener; // @A2A
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Vector; // @A2A
/**
* Represents a license for a product on the IBM i system. To request
* a license, construct a ProductLicense object then invoke the request() method.
* The caller must keep a reference to the ProductLicense object until the
* license is no longer needed since the ProductLicense object will release
* the license when it is garbage collected. Licenses are managed on a
* per-connection basis. Each ProductLicense object has a separate connection to
* the system. If the connection ends unexpectedly the system
* releases the license. To maintain an accurate count, the application should
* call release() instead of relying on the license being released when the object
* is garbage collected or when the connection ends. Cleanup during garbage
* collection and/or system cleanup is not as reliable as calling release().
*
*
* The ProductLicense class does not enforce the license policy. It is up to the
* application to enforce the policy based on information contained in the ProductLicense
* object after the license is requested. If a license is not granted, indicated by a
* LicenseException, it is up to the application to notify the user and not perform the
* behavior that requires a license.
*
*
* The ProductLicense object may successfully get a license even though there was an error
* retrieving the product license. These "soft" errors are usage limit exceeded, but license
* limit not strictly enforced (CONDITION_EXCEEDED_OK), usage limit exceeded, but within grace
* period (CONDITION_EXCEED_GRACE_PERIOD) and usage limit exceeded and grace period expired
* but not strictly enforced (CONDITION_GRACE_PERIOD_EXPIRED.) The application must decide
* to continue or end the application based on this information.
*
*
* The request() method will throw a LicenseException if no license is available. If a license
* is granted, the ProductLicense object contains information about the license such
* as the compliance type and license condition.
*
*
Example
*
*
*
* AS400 system = new AS400("myas400");
* // request a license for "myproductID" and "myfeatureID" for "myrelease"
* try
* {
* ProductLicense license = new ProductLicense(system,
* "myproductID",
* "myfeatureID",
* "myrelease");
* license.request();
* switch (license.getCondition())
* {
* case ProductLicense.CONDITION_OK:
* // license retrieved successfully
* break;
* case ProductLicense.CONDITION_EXCEEDED_OK:
* // usage limit exceeded, but license limit not strictly enforced
* // issue message but allow to proceed.
* sendMessage("Usage limit exceeded, but license limit not strictly enforced");
* break;
* case ProductLicense.CONDITION_EXCEEDED_GRACE_PERIOD:
* // usage limit exceeded, but within grace period
* // issue message but allow to proceed
* sendMessage("Usage limit exceeded, but within grace period");
* break;
* case ProductLicense.CONDITION_GRACE_PERIOD_EXPIRED:
* // usage limit exceeded and grace period expired but not strictly enforced
* // issue message but allow to proceed
* sendMessage("Usage limit exceeded and grace period expired but not strictly enforced");
* break;
* default:
* // Some other condition.
* // This should never happen, but if it does, display value.
* sendMessage("Unrecognized condition: " + license.getCondition());
* }
* ..
* ..
* // product code...
* ..
* ..
* // release the license
* license.release();
* }
* catch (LicenseException le)
* {
* // handle license failures such as license expired...
* }
* catch (Exception e)
* {
* // handle general failures (security error, communication error, etc.)
* }
*
*
**/
public class ProductLicense implements java.io.Serializable
{
/**
* Value for license usage type, concurrent usage license type.
**/
public final static int USAGE_CONCURRENT = 1;
/**
* Value for license usage type, registered usage license type.
**/
public final static int USAGE_REGISTERED = 2;
/**
* Value for compliance type, operator action compliance indicates a form
* of soft compliance that will not allow a license in the usage limit exceeded
* case until the operator increases the maximum number of licenses on the system
* (this does not require a license key to increase.)
**/
public final static int COMPLIANCE_OPERATOR_ACTION = 1;
/**
* Value for compliance type, warning compliance indicates that a
* warning message will be sent to the system operators message queue
* when a license violation, such as usage limit exceeded is encountered.
**/
public final static int COMPLIANCE_WARNING = 2;
/**
* Value for compliance type, keyed compliance indicates a license
* that requires a license key to activate the license.
**/
public final static int COMPLIANCE_KEYED = 3;
/**
* Value for license condition, license granted.
**/
public static final int CONDITION_OK = 0;
/**
* Value for license condition, usage limit exceeded, but not enforced.
**/
public static final int CONDITION_EXCEEDED_OK = 0x002b;
/**
* Value for license condition, usage limit exceeded, but within grace period.
**/
public static final int CONDITION_EXCEEDED_GRACE_PERIOD = 0x002c;
/**
* Value for license condition, usage limit exceeded and grace period expired, but not
* enforced.
**/
public static final int CONDITION_GRACE_PERIOD_EXPIRED = 0x002e;
static
{
AS400Server.addReplyStream(new NLSExchangeAttrReply(), "as-central");
AS400Server.addReplyStream(new LicenseGetReply(), "as-central");
AS400Server.addReplyStream(new LicenseReleaseReply(), "as-central");
AS400Server.addReplyStream(new LicenseGetInformationReply(), "as-central");
}
transient private PropertyChangeSupport changes_; // @A2A
transient private Vector productLicenseListeners_; // @A2A
static final long serialVersionUID = 4L; // @A2A
transient private boolean released_; // @A2C
transient private int condition_; // @A2C
transient private AS400 sys_; // @A2C
transient private AS400Server server_; // @A2C
transient private AS400ImplRemote sysImpl_; // @A2C
private String productID_;
private String featureID_;
private String releaseLevel_; // @A1C
transient private int usageLimit_; // @A2C
transient private int usageCount_; // @A2C
transient private int usageType_; // @A2C
transient private int complianceType_; // @A2C
transient private String licenseTerm_; // @A2C
/**
* Constructs a default ProductLicense object. The system,
* product, feature and release must be set for requesting a license.
**/
public ProductLicense()
{
initializeTransient(); // @A2A
productID_ = null;
featureID_ = null;
}
/**
* Constructs a ProductLicense object for a system, product, feature,
* and release.
* @param system the system from which the license will be requested.
* @param productID the product identifier. For example, "5769JC1".
* @param featureID the product feature. For example, "5050".
* @param release the product release. For example, "V4R5M0".
**/
public ProductLicense(AS400 system, String productID, String featureID, String release)
{
this();
// get a new AS400 object to make sure we get a separate connection
sys_ = new AS400(system);
if(sys_ == null)
{
throw new NullPointerException("system");
}
if(productID == null)
{
throw new NullPointerException("productID");
}
else
{
productID_ = productID;
}
if(featureID == null)
{
throw new NullPointerException("featureID");
}
else
{
featureID_ = featureID;
}
if(release == null)
{
releaseLevel_ = " "; // set correct release variable @A1C
}
else
{
releaseLevel_ = release; // set correct release variable @A1C
}
}
/**
Adds a file listener to receive file events from this IFSFile.
@param listener The file listener.
**/
// This function added to enable beans @A2A
public void addProductLicenseListener(ProductLicenseListener listener)
{
if (listener == null)
throw new NullPointerException("listener");
productLicenseListeners_.addElement(listener);
}
/**
Adds a property change listener.
@param listener The property change listener to add.
**/
// This function added to enable beans @A2A
public void addPropertyChangeListener(PropertyChangeListener listener)
{
if (listener == null)
throw new NullPointerException("listener");
changes_.addPropertyChangeListener(listener);
}
/**
* Disconnect from the host server.
**/
void disconnect()
{
synchronized(sys_)
{
if(server_ != null)
{
if(Trace.traceOn_)
{
Trace.log(Trace.DIAGNOSTIC, "Disconnecting from server");
}
try
{
sysImpl_.disconnectServer(server_);
server_ = null;
}
catch(Exception e)
{
if(Trace.traceOn_)
{
Trace.log(Trace.ERROR, "Exception encountered while disconnecting", e);
}
}
} // (server_ != null)
} // synchronized(sys_)
} // disconnect()
/**
* The finalizer.
**/
protected void finalize()
{
if(Trace.traceOn_)
{
Trace.log(Trace.DIAGNOSTIC, "finalize() - ProductLicense");
}
try
{
release();
}
catch(Exception e)
{
if(Trace.traceOn_)
{
Trace.log(Trace.ERROR, "release license failed", e);
}
}
}
// Fire connect events here so source is public object.
private void fireProductLicenseEvent(int status)
{
ProductLicenseEvent event = new ProductLicenseEvent(this, status);
Vector targets = (Vector)productLicenseListeners_.clone();
for (int i = 0; i < targets.size(); ++i)
{
ProductLicenseListener target = (ProductLicenseListener)targets.elementAt(i);
switch(status)
{
case ProductLicenseEvent.PRODUCT_LICENSE_RELEASED:
target.licenseReleased(event);
break;
case ProductLicenseEvent.PRODUCT_LICENSE_REQUESTED:
target.licenseRequested(event);
break;
default:
// This should never happen, but if it does, trace it.
Trace.log(Trace.ERROR, "Event status:", status);
}
}
}
/**
* Returns the compliance type for this license. Possible values are
* COMPLIANCE_OPERATOR_ACTION, COMPLIANCE_WARNING and COMPLIANCE_KEYED.
* A license must have been requested prior to calling this method.
* @return The compliance type.
**/
public int getComplianceType()
{
if(released_)
{
throw new ExtendedIllegalStateException(ExtendedIllegalStateException.INFORMATION_NOT_AVAILABLE);
}
return complianceType_;
}
/**
* Returns the condition of the license. Possible values are CONDITION_OK,
* CONDITION_EXCEEDED_OK, CONDITION_EXCEEDED_GRACE_PERIOD,
* and CONDITION_GRACE_EXPIRED. A license must have been requested prior to
* calling this method.
* @return The license condition.
**/
public int getCondition()
{
if(released_)
throw new ExtendedIllegalStateException(("Object= "+ sys_.getSystemName()),
ExtendedIllegalStateException.INFORMATION_NOT_AVAILABLE);
return condition_;
}
/**
* Returns the feature identifier for this license.
* @return The feature identifier.
**/
public String getFeature()
{
return featureID_;
}
/**
* Returns the license term for this license. A license must
* have been requested prior to calling this method.
* @return The license term.
**/
public String getLicenseTerm()
{
if(released_)
throw new ExtendedIllegalStateException(("Object= "+ sys_.getSystemName()),
ExtendedIllegalStateException.INFORMATION_NOT_AVAILABLE);
return licenseTerm_;
}
/**
* Returns the product identifier for this license.
* @return The product identifier.
**/
public String getProductID()
{
return productID_;
}
/**
* Returns the release level for this license.
* @return The release level.
**/
public String getReleaseLevel()
{
return releaseLevel_;
}
/**
* Return the name of the system for this license. A license must have been
* requested prior to calling this method.
* @return The name of the AS400.
**/
/* String getSystemName()
{
if(released_)
throw new ExtendedIllegalStateException(ExtendedIllegalStateException.INFORMATION_NOT_AVAILABLE);
return sys_.getSystemName();
} */
/**
* Returns the system object for this license.
* @return The system.
**/
public AS400 getSystem()
{
return sys_;
}
/**
* Returns the usage count for this license. The count returned is the number
* of licenses that are in use on the system for that product ID, feature, and
* release when this license was requested. A license must have been requested
* prior to calling this method.
* @return The usage count when this license was retrieved.
**/
public int getUsageCount()
{
if(released_)
throw new ExtendedIllegalStateException(ExtendedIllegalStateException.INFORMATION_NOT_AVAILABLE);
return usageCount_;
}
/**
* Returns the usage limit for this license.A license must have been requested prior to
* calling this method.
* @return The usage limit.
**/
public int getUsageLimit()
{
if(released_)
throw new ExtendedIllegalStateException(("Object= "+ sys_.getSystemName()),
ExtendedIllegalStateException.INFORMATION_NOT_AVAILABLE);
return usageLimit_;
}
/**
* Returns the usage type for this license. Possible values are USAGE_CONCURRENT and
* USAGE_REGISTERED. A license must have been requested prior to calling this method.
* @return The usage type.
**/
public int getUsageType()
{
if(released_)
throw new ExtendedIllegalStateException("UsageType",
ExtendedIllegalStateException.INFORMATION_NOT_AVAILABLE);
return usageType_;
}
/**
Provided to initialize transient data if this object is de-serialized. // @A2A
**/
private void initializeTransient()
{
changes_ = new PropertyChangeSupport(this);
productLicenseListeners_ = new Vector();
sys_ = null;
sysImpl_ = null;
condition_ = CONDITION_OK;
released_ = true;
usageLimit_ = 0;
usageCount_ = -1;
usageType_ = -1;
complianceType_ = -1;
licenseTerm_ = null;
releaseLevel_ = null;
}
/**
* Release this license. This method must be called to release the license. Failure
* to do so may result in incorrect license usage count. Calling this method will
* disconnect from the IBM i Optimized License Management server.
* @exception IOException If an error occurs while communicating with the system.
* @exception InterruptedException If this thread is interrupted.
* @exception LicenseException If a license error occurs.
**/
public void release()
throws IOException, InterruptedException, LicenseException
{
// Verify that the bean properties are set prior to attempting the release.
if (sys_ == null)
{
if(Trace.traceOn_)
{
Trace.log(Trace.ERROR, "System not set yet.");
}
throw new ExtendedIllegalStateException("system", ExtendedIllegalStateException.PROPERTY_NOT_SET);
}
if (productID_ == null)
{
if(Trace.traceOn_)
{
Trace.log(Trace.ERROR, "Product ID not set yet.");
}
throw new ExtendedIllegalStateException("productID", ExtendedIllegalStateException.PROPERTY_NOT_SET);
}
if (featureID_ == null)
{
if(Trace.traceOn_)
{
Trace.log(Trace.ERROR, "Feature ID not set yet.");
}
throw new ExtendedIllegalStateException("featureID", ExtendedIllegalStateException.PROPERTY_NOT_SET);
}
if (releaseLevel_ == null)
{
if(Trace.traceOn_)
{
Trace.log(Trace.ERROR, "Release not set yet.");
}
throw new ExtendedIllegalStateException("release", ExtendedIllegalStateException.PROPERTY_NOT_SET);
}
synchronized(sys_)
{
if(released_) return;
if(Trace.traceOn_)
{
// release license from server
Trace.log(Trace.DIAGNOSTIC, "Releasing license from server");
}
if(server_ != null)
{
LicenseReleaseRequest releaseRequest = new LicenseReleaseRequest(sys_);
releaseRequest.setProductID(productID_);
releaseRequest.setFeature(featureID_);
releaseRequest.setRelease(releaseLevel_);
DataStream baseReply = server_.sendAndReceive(releaseRequest);
if(baseReply instanceof LicenseReleaseReply)
{
LicenseReleaseReply releaseReply = (LicenseReleaseReply)baseReply;
released_ = true;
disconnect();
if(releaseReply.getPrimaryRC() != 0)
{
Trace.log(Trace.DIAGNOSTIC, "Release license failed, primary return code = ", releaseReply.getPrimaryRC());
Trace.log(Trace.DIAGNOSTIC, "Release license failed, secondary return code = ", releaseReply.getSecondaryRC());
throw new LicenseException(releaseReply.getPrimaryRC(), releaseReply.getSecondaryRC());
}
// Fire the license released event.
fireProductLicenseEvent(ProductLicenseEvent.PRODUCT_LICENSE_RELEASED);
} // baseReply instanceof LicenseReleaseReply
} // server_ != null
} // synchronized(sys_)
} // public void release()
/**
* Request a license.
* @return The condition of the license. Possible values are CONDITION_OK,
* CONDITION_EXCEEDED_OK, CONDITION_EXCEEDED_GRACE_PERIOD,
* and CONDITION_GRACE_EXPIRED.
* @exception IOException If an error occurs while communicating with the system.
* @exception AS400SecurityException Unable to connect due to some problem with the user ID or password used to authenticate.
* @exception InterruptedException If this thread is interrupted.
* @exception LicenseException If a license error occurs.
* @exception ExtendedIllegalStateException If a license is requested a second time for the same ProductLicense object.
**/
public int request()
throws IOException, AS400SecurityException, InterruptedException, LicenseException
{
// Verify that the bean properties are set prior to attempting the release.
if (sys_ == null)
{
if(Trace.traceOn_)
{
Trace.log(Trace.ERROR, "System not set yet.");
}
throw new ExtendedIllegalStateException("system", ExtendedIllegalStateException.PROPERTY_NOT_SET);
}
if (productID_ == null)
{
if(Trace.traceOn_)
{
Trace.log(Trace.ERROR, "Product ID not set yet.");
}
throw new ExtendedIllegalStateException("productID", ExtendedIllegalStateException.PROPERTY_NOT_SET);
}
if (featureID_ == null)
{
if(Trace.traceOn_)
{
Trace.log(Trace.ERROR, "Feature ID not set yet.");
}
throw new ExtendedIllegalStateException("featureID", ExtendedIllegalStateException.PROPERTY_NOT_SET);
}
if (releaseLevel_ == null)
{
if(Trace.traceOn_)
{
Trace.log(Trace.ERROR, "Release not set yet.");
}
throw new ExtendedIllegalStateException("release", ExtendedIllegalStateException.PROPERTY_NOT_SET);
}
synchronized(sys_)
{
if(!released_)
throw new ExtendedIllegalStateException(("Object= "+ sys_.getSystemName()),
ExtendedIllegalStateException.LICENSE_CAN_NOT_BE_REQUESTED);
if(Trace.traceOn_)
{
// request license from server
Trace.log(Trace.DIAGNOSTIC, "retrieving license from server");
}
sys_.connectService(AS400.CENTRAL);
sysImpl_= (AS400ImplRemote) sys_.getImpl();
server_ = sysImpl_.getConnection(AS400.CENTRAL, false, false);
NLSExchangeAttrRequest request = new NLSExchangeAttrRequest();
try
{
server_.sendExchangeAttrRequest(request);
}
catch(IOException e)
{
Trace.log(Trace.ERROR, "IOException After Exchange Attribute Request", e);
disconnect();
throw e;
}
DataStream baseReply = server_.getExchangeAttrReply();
if(baseReply instanceof NLSExchangeAttrReply)
{
// means request completed CONDITION_OK
NLSExchangeAttrReply NLSReply = (NLSExchangeAttrReply)baseReply;
if(NLSReply.primaryRC_ != 0)
{
Trace.log(Trace.ERROR, ("Exchange attribute failed, primary return code =" +
NLSReply.primaryRC_ +
"secondary return code =" +
NLSReply.getSecondaryRC_()) );
disconnect();
throw new IOException();
}
}
else
{ // unknown data stream
if(Trace.traceOn_)
{
Trace.log(Trace.ERROR, "Unknown instance returned from Exchange Attribute Reply");
}
throw new InternalErrorException(InternalErrorException.DATA_STREAM_UNKNOWN);
}
LicenseGetRequest getLicReq = new LicenseGetRequest(sys_);
getLicReq.setProductID(productID_);
getLicReq.setFeature(featureID_);
getLicReq.setRelease(releaseLevel_);
try
{
baseReply = server_.sendAndReceive(getLicReq);
}
catch(IOException e)
{
Trace.log(Trace.ERROR, "IOException occured - Request license", e);
disconnect();
throw e;
}
if(baseReply instanceof LicenseGetReply)
{
LicenseGetReply getReply = (LicenseGetReply)baseReply;
if(getReply.getPrimaryRC() == 0)
{
usageLimit_ = getReply.getUsageLimit();
usageCount_ = getReply.getUsageCount();
// bump usage count by one, because server gets usage count before retrieving
// license, so the count is off by 1.
usageCount_++;
usageType_ = getReply.getUsageType();
complianceType_ = getReply.getComplianceType();
licenseTerm_ = getReply.getLicenseTerm();
releaseLevel_ = getReply.getReleaseLevel();
condition_ = getReply.getSecondaryRC();
switch (condition_) // verify that it's a recognized value
{
case CONDITION_OK:
case CONDITION_EXCEEDED_OK:
case CONDITION_EXCEEDED_GRACE_PERIOD:
case CONDITION_GRACE_PERIOD_EXPIRED:
break;
default: // This should never happen; but if it does, trace it.
Trace.log(Trace.ERROR, "LicenseGetReply.getSecondaryRC():", condition_);
}
released_ = false;
// Fire the license released event.
fireProductLicenseEvent(ProductLicenseEvent.PRODUCT_LICENSE_REQUESTED);
}
else
{
if(Trace.traceOn_)
{
Trace.log(Trace.DIAGNOSTIC, ("Request license failed, primary return code =" +
getReply.getPrimaryRC() +
"secondary return code =" +
getReply.getSecondaryRC()) );
}
throw new LicenseException(getReply.getPrimaryRC(), getReply.getSecondaryRC());
}
}
else
{
if(Trace.traceOn_)
{
Trace.log(Trace.ERROR, "Unknown instance returned from Get License Reply");
}
throw new InternalErrorException(InternalErrorException.DATA_STREAM_UNKNOWN);
}
return condition_;
} // synchronized(sys_)
} // public void request()
/**
Removes this listener from being notified when a bound property changes.
@param listener The PropertyChangeListener.
**/
public void removePropertyChangeListener(PropertyChangeListener listener)
{
if (listener == null)
{
Trace.log(Trace.ERROR, "Parameter 'listener' is null.");
throw new NullPointerException("listener");
}
changes_.removePropertyChangeListener(listener);
}
/**
Removes a listener from the ProductLicense listeners list.
@param listener The product license listener.
**/
public void removeProductLicenseListener(ProductLicenseListener listener)
{
if (listener == null)
{
Trace.log(Trace.ERROR, "Parameter 'listener' is null.");
throw new NullPointerException("listener");
}
productLicenseListeners_.removeElement(listener);
}
/**
* Sets the feature identifier for this license.
* @param featureID the product feature. For example, "5050".
**/
public void setFeature(String featureID)
{
if(featureID == null) // @A2C
{
throw new NullPointerException("featureID"); // @A2C
}
// Ensure that the featureID is not altered after the connection is
// established.
if (sysImpl_ != null)
{
throw new ExtendedIllegalStateException("featureID",
ExtendedIllegalStateException.PROPERTY_NOT_CHANGED); // @A2A
}
String oldFeatureID = featureID_; // @A2A
featureID_ = featureID;
// Fire the property change event having null as the name to
// indicate that the path, parent, etc. have changed.
changes_.firePropertyChange("featureID",
oldFeatureID,
featureID_); // @A2A
}
/**
* Sets the product identifier for this license.
* @param productID the product identifier. For example, "5769JC1".
**/
public void setProductID(String productID)
{
if(productID == null)
{
throw new NullPointerException("productID");
}
// Ensure that the productID is not altered after the connection is
// established.
if (sysImpl_ != null)
{
throw new ExtendedIllegalStateException("productID",
ExtendedIllegalStateException.PROPERTY_NOT_CHANGED); // @A2A
}
String oldProductID = productID_; // @A2A
productID_ = productID;
// Fire the property change event having null as the name to
// indicate that the path, parent, etc. have changed.
changes_.firePropertyChange("productID",
oldProductID,
productID_); // @A2A
}
/**
* Sets the product release for this license.
* @param releaseLevel the product release. For example, "V4R5M0".
**/
public void setReleaseLevel(String releaseLevel)
{
if(releaseLevel == null)
{
throw new NullPointerException("releaseLevel");
}
// Ensure that the releaseLevel is not altered after the connection is
// established.
if (sysImpl_ != null)
{
throw new ExtendedIllegalStateException("releaseLevel",
ExtendedIllegalStateException.PROPERTY_NOT_CHANGED); // @A2A
}
String oldReleaseLevel = releaseLevel_; // @A2A
releaseLevel_ = releaseLevel;
// Fire the property change event having null as the name to
// indicate that the path, parent, etc. have changed.
changes_.firePropertyChange("releaseLevel",
oldReleaseLevel,
releaseLevel_); // @A2A
}
/**
* Sets the system object for this license.
* @param system the system from which the license will be requested.
**/
public void setSystem(AS400 system) // @A2C
{
if(system == null) // @A2C
{
throw new NullPointerException("system"); // @A2C
}
// Ensure that the system is not altered after the connection is
// established.
if (sysImpl_ != null)
{
throw new ExtendedIllegalStateException("system",
ExtendedIllegalStateException.PROPERTY_NOT_CHANGED); // @A2A
}
AS400 oldSystem = sys_; // @A2A
sys_ = system; // @A2C
// Fire the property change event having null as the name to
// indicate that the path, parent, etc. have changed.
changes_.firePropertyChange("path", oldSystem, sys_);
}
// Called when this object is de-serialized
private void readObject(ObjectInputStream in) throws ClassNotFoundException, IOException
{
in.defaultReadObject();
initializeTransient();
}
} // public class ProductLicense