| /* |
| * Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package com.sun.corba.se.impl.oa.poa; |
| |
| import java.util.HashMap ; |
| import java.util.BitSet ; |
| import java.util.Iterator ; |
| |
| import com.sun.corba.se.impl.orbutil.ORBConstants ; |
| import com.sun.corba.se.spi.extension.ServantCachingPolicy ; |
| import com.sun.corba.se.spi.extension.ZeroPortPolicy ; |
| import com.sun.corba.se.spi.extension.CopyObjectPolicy ; |
| |
| import org.omg.CORBA.*; |
| import org.omg.PortableServer.*; |
| import org.omg.PortableServer.POAPackage.*; |
| |
| public final class Policies { |
| /* Order of *POLICY_ID : |
| THREAD_ |
| LIFESPAN_ |
| ID_UNIQUENESS_ |
| ID_ASSIGNMENT_ |
| IMPLICIT_ACTIVATION_ |
| SERvANT_RETENTION_ |
| REQUEST_PROCESSING_ |
| The code in this class depends on this order! |
| */ |
| private static final int MIN_POA_POLICY_ID = THREAD_POLICY_ID.value ; |
| private static final int MAX_POA_POLICY_ID = REQUEST_PROCESSING_POLICY_ID.value ; |
| private static final int POLICY_TABLE_SIZE = MAX_POA_POLICY_ID - |
| MIN_POA_POLICY_ID + 1 ; |
| |
| int defaultObjectCopierFactoryId ; |
| |
| private HashMap policyMap = new HashMap() ; // Maps Integer(policy type) to Policy |
| |
| public static final Policies defaultPolicies |
| = new Policies() ; |
| |
| public static final Policies rootPOAPolicies |
| = new Policies( |
| ThreadPolicyValue._ORB_CTRL_MODEL, |
| LifespanPolicyValue._TRANSIENT, |
| IdUniquenessPolicyValue._UNIQUE_ID, |
| IdAssignmentPolicyValue._SYSTEM_ID, |
| ImplicitActivationPolicyValue._IMPLICIT_ACTIVATION, |
| ServantRetentionPolicyValue._RETAIN, |
| RequestProcessingPolicyValue._USE_ACTIVE_OBJECT_MAP_ONLY ) ; |
| |
| private int[] poaPolicyValues ; |
| |
| private int getPolicyValue( int id ) |
| { |
| return poaPolicyValues[ id - MIN_POA_POLICY_ID ] ; |
| } |
| |
| private void setPolicyValue( int id, int value ) |
| { |
| poaPolicyValues[ id - MIN_POA_POLICY_ID ] = value ; |
| } |
| |
| private Policies( |
| int threadModel, |
| int lifespan, |
| int idUniqueness, |
| int idAssignment, |
| int implicitActivation, |
| int retention, |
| int requestProcessing ) |
| { |
| poaPolicyValues = new int[] { |
| threadModel, |
| lifespan, |
| idUniqueness, |
| idAssignment, |
| implicitActivation, |
| retention, |
| requestProcessing }; |
| } |
| |
| private Policies() { |
| this( ThreadPolicyValue._ORB_CTRL_MODEL, |
| LifespanPolicyValue._TRANSIENT, |
| IdUniquenessPolicyValue._UNIQUE_ID, |
| IdAssignmentPolicyValue._SYSTEM_ID, |
| ImplicitActivationPolicyValue._NO_IMPLICIT_ACTIVATION, |
| ServantRetentionPolicyValue._RETAIN, |
| RequestProcessingPolicyValue._USE_ACTIVE_OBJECT_MAP_ONLY ) ; |
| } |
| |
| public String toString() { |
| StringBuffer buffer = new StringBuffer(); |
| buffer.append( "Policies[" ) ; |
| boolean first = true ; |
| Iterator iter = policyMap.values().iterator() ; |
| while (iter.hasNext()) { |
| if (first) |
| first = false ; |
| else |
| buffer.append( "," ) ; |
| |
| buffer.append( iter.next().toString() ) ; |
| } |
| buffer.append( "]" ) ; |
| return buffer.toString() ; |
| } |
| |
| /* Returns the integer value of the POA policy, if this is a |
| * POA policy, otherwise returns -1. |
| */ |
| private int getPOAPolicyValue( Policy policy) |
| { |
| if (policy instanceof ThreadPolicy) { |
| return ((ThreadPolicy) policy).value().value(); |
| } else if (policy instanceof LifespanPolicy) { |
| return ((LifespanPolicy) policy).value().value(); |
| } else if (policy instanceof IdUniquenessPolicy) { |
| return ((IdUniquenessPolicy) policy).value().value(); |
| } else if (policy instanceof IdAssignmentPolicy) { |
| return ((IdAssignmentPolicy) policy).value().value(); |
| } else if (policy instanceof ServantRetentionPolicy) { |
| return ((ServantRetentionPolicy) policy).value().value(); |
| } else if (policy instanceof RequestProcessingPolicy) { |
| return ((RequestProcessingPolicy) policy).value().value(); |
| } else if (policy instanceof ImplicitActivationPolicy) { |
| return ((ImplicitActivationPolicy) policy).value().value(); |
| } else |
| return -1 ; |
| } |
| |
| /** If any errors were found, throw INVALID_POLICY with the smallest |
| * index of any offending policy. |
| */ |
| private void checkForPolicyError( BitSet errorSet ) throws InvalidPolicy |
| { |
| for (short ctr=0; ctr<errorSet.length(); ctr++ ) |
| if (errorSet.get(ctr)) |
| throw new InvalidPolicy(ctr); |
| } |
| |
| /** Add the first index in policies at which the policy is of type |
| * policyId to errorSet, if the polictId is in policies (it may not be). |
| */ |
| private void addToErrorSet( Policy[] policies, int policyId, |
| BitSet errorSet ) |
| { |
| for (int ctr=0; ctr<policies.length; ctr++ ) |
| if (policies[ctr].policy_type() == policyId) { |
| errorSet.set( ctr ) ; |
| return ; |
| } |
| } |
| |
| /** Main constructor used from POA::create_POA. This need only be visible |
| * within the POA package. |
| */ |
| Policies(Policy[] policies, int id ) throws InvalidPolicy |
| { |
| // Make sure the defaults are set according to the POA spec |
| this(); |
| |
| defaultObjectCopierFactoryId = id ; |
| |
| if ( policies == null ) |
| return; |
| |
| // Set to record all indices in policies for which errors |
| // were observed. |
| BitSet errorSet = new BitSet( policies.length ) ; |
| |
| for(short i = 0; i < policies.length; i++) { |
| Policy policy = policies[i]; |
| int POAPolicyValue = getPOAPolicyValue( policy ) ; |
| |
| // Save the policy in policyMap to support |
| // POA.get_effective_policy, if it was not already saved |
| // in policyMap. |
| Integer key = new Integer( policy.policy_type() ) ; |
| Policy prev = (Policy)(policyMap.get( key )) ; |
| if (prev == null) |
| policyMap.put( key, policy ) ; |
| |
| if (POAPolicyValue >= 0) { |
| setPolicyValue( key.intValue(), POAPolicyValue ) ; |
| |
| // if the value of this POA policy was previously set to a |
| // different value than the current value given in |
| // POAPolicyValue, record an error. |
| if ((prev != null) && |
| (getPOAPolicyValue( prev ) != POAPolicyValue)) |
| errorSet.set( i ) ; |
| } |
| } |
| |
| // Check for bad policy combinations |
| |
| // NON_RETAIN requires USE_DEFAULT_SERVANT or USE_SERVANT_MANAGER |
| if (!retainServants() && useActiveMapOnly() ) { |
| addToErrorSet( policies, SERVANT_RETENTION_POLICY_ID.value, |
| errorSet ) ; |
| addToErrorSet( policies, REQUEST_PROCESSING_POLICY_ID.value, |
| errorSet ) ; |
| } |
| |
| // IMPLICIT_ACTIVATION requires SYSTEM_ID and RETAIN |
| if (isImplicitlyActivated()) { |
| if (!retainServants()) { |
| addToErrorSet( policies, IMPLICIT_ACTIVATION_POLICY_ID.value, |
| errorSet ) ; |
| addToErrorSet( policies, SERVANT_RETENTION_POLICY_ID.value, |
| errorSet ) ; |
| } |
| |
| if (!isSystemAssignedIds()) { |
| addToErrorSet( policies, IMPLICIT_ACTIVATION_POLICY_ID.value, |
| errorSet ) ; |
| addToErrorSet( policies, ID_ASSIGNMENT_POLICY_ID.value, |
| errorSet ) ; |
| } |
| } |
| |
| checkForPolicyError( errorSet ) ; |
| } |
| |
| public Policy get_effective_policy( int type ) |
| { |
| Integer key = new Integer( type ) ; |
| Policy result = (Policy)(policyMap.get(key)) ; |
| return result ; |
| } |
| |
| /* Thread Policies */ |
| public final boolean isOrbControlledThreads() { |
| return getPolicyValue( THREAD_POLICY_ID.value ) == |
| ThreadPolicyValue._ORB_CTRL_MODEL; |
| } |
| public final boolean isSingleThreaded() { |
| return getPolicyValue( THREAD_POLICY_ID.value ) == |
| ThreadPolicyValue._SINGLE_THREAD_MODEL; |
| } |
| |
| /* Lifespan */ |
| public final boolean isTransient() { |
| return getPolicyValue( LIFESPAN_POLICY_ID.value ) == |
| LifespanPolicyValue._TRANSIENT; |
| } |
| public final boolean isPersistent() { |
| return getPolicyValue( LIFESPAN_POLICY_ID.value ) == |
| LifespanPolicyValue._PERSISTENT; |
| } |
| |
| /* ID Uniqueness */ |
| public final boolean isUniqueIds() { |
| return getPolicyValue( ID_UNIQUENESS_POLICY_ID.value ) == |
| IdUniquenessPolicyValue._UNIQUE_ID; |
| } |
| public final boolean isMultipleIds() { |
| return getPolicyValue( ID_UNIQUENESS_POLICY_ID.value ) == |
| IdUniquenessPolicyValue._MULTIPLE_ID; |
| } |
| |
| /* ID Assignment */ |
| public final boolean isUserAssignedIds() { |
| return getPolicyValue( ID_ASSIGNMENT_POLICY_ID.value ) == |
| IdAssignmentPolicyValue._USER_ID; |
| } |
| public final boolean isSystemAssignedIds() { |
| return getPolicyValue( ID_ASSIGNMENT_POLICY_ID.value ) == |
| IdAssignmentPolicyValue._SYSTEM_ID; |
| } |
| |
| /* Servant Rentention */ |
| public final boolean retainServants() { |
| return getPolicyValue( SERVANT_RETENTION_POLICY_ID.value ) == |
| ServantRetentionPolicyValue._RETAIN; |
| } |
| |
| /* Request Processing */ |
| public final boolean useActiveMapOnly() { |
| return getPolicyValue( REQUEST_PROCESSING_POLICY_ID.value ) == |
| RequestProcessingPolicyValue._USE_ACTIVE_OBJECT_MAP_ONLY; |
| } |
| public final boolean useDefaultServant() { |
| return getPolicyValue( REQUEST_PROCESSING_POLICY_ID.value ) == |
| RequestProcessingPolicyValue._USE_DEFAULT_SERVANT; |
| } |
| public final boolean useServantManager() { |
| return getPolicyValue( REQUEST_PROCESSING_POLICY_ID.value ) == |
| RequestProcessingPolicyValue._USE_SERVANT_MANAGER; |
| } |
| |
| /* Implicit Activation */ |
| public final boolean isImplicitlyActivated() { |
| return getPolicyValue( IMPLICIT_ACTIVATION_POLICY_ID.value ) == |
| ImplicitActivationPolicyValue._IMPLICIT_ACTIVATION; |
| } |
| |
| /* proprietary servant caching policy */ |
| public final int servantCachingLevel() |
| { |
| Integer key = new Integer( ORBConstants.SERVANT_CACHING_POLICY ) ; |
| ServantCachingPolicy policy = (ServantCachingPolicy)policyMap.get( key ) ; |
| if (policy == null) |
| return ServantCachingPolicy.NO_SERVANT_CACHING ; |
| else |
| return policy.getType() ; |
| } |
| |
| public final boolean forceZeroPort() |
| { |
| Integer key = new Integer( ORBConstants.ZERO_PORT_POLICY ) ; |
| ZeroPortPolicy policy = (ZeroPortPolicy)policyMap.get( key ) ; |
| if (policy == null) |
| return false ; |
| else |
| return policy.forceZeroPort() ; |
| } |
| |
| public final int getCopierId() |
| { |
| Integer key = new Integer( ORBConstants.COPY_OBJECT_POLICY ) ; |
| CopyObjectPolicy policy = (CopyObjectPolicy)policyMap.get( key ) ; |
| if (policy != null) |
| return policy.getValue() ; |
| else |
| return defaultObjectCopierFactoryId ; |
| } |
| } |
