Read-only method: pass the call to the {@link ManagementDelegate}.
320442
public StreamingOutput stream(Context context,
                              String pid,
                              String format,
                              String exportContext,
                              String encoding) throws ServerException {
        return delegate.stream(context, pid, format, exportContext, encoding);
    }
257477
protected SIBusMessage readMessage (SIMessageHandle handle)
                throws ResourceException, SIMessageNotLockedException
    {
        final String methodName = "readMessage";
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
        {
            SibTr.entry(this, TRACE, methodName, handle);
        }

        SIBusMessage message = null;

        // If we are enlisted in the xa transaction then delete the message
        // under that transaction.
        if ((_xaResource != null) && (_xaResource.isEnlisted ()))
        {
            if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled ())
            {
                SibTr.debug(this, TRACE, "Deleting the message under the xa transaction (Handle=" + handle + ") (xaResource=" + _xaResource + ")");
            }

            message = readAndDeleteMessage(handle, _xaResource);
        }
        else
        {
            // If we have not been enlisted then we can assume that we have
            // inherited the transaction from the local thread which was imported
            // from the message itself. As such we can not delete the message
            // under this transaction because if the message rolls back the message
            // will be redelivered and we can not reuse the same transaction since
            // it is no longer a valid transaction. Once the transaction has been
            // imported then the message has done its "work" and we can auto commit
            // the deletion.
            if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled ())
            {
                SibTr.debug(this, TRACE, "xaResource is either null or is not enlisted so deleting the message non transactional (auto commit) (Handle=" + handle + ")");
            }

            message = readAndDeleteMessage(handle, null);
        }

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
        {
            SibTr.exit(this, TRACE, methodName, message);
        }

        return message;
    }
829145
private void makeReadOnly(final Session session, final String tracingId)
	{
		Tracing.logOngoing(tracingId, "TX:makeReadonly Set Default ReadOnly");

		session.setDefaultReadOnly(true);

		Tracing.logOngoing(tracingId, "TX:makeReadonly Set Hibernate Flush Mode to MANUAL");

		session.setHibernateFlushMode(FlushMode.MANUAL);

		Tracing.logOngoing(tracingId, "TX:makeReadonly Make Connection Read Only");

		// Make the Connection read only
		session.doWork(SetJDBCConnectionReadOnlyWork.READ_ONLY);

		Tracing.logOngoing(tracingId, "TX:makeReadonly Complete");
	}
974381
public AccessControlList read(ObjectReader in) throws UnknownClassIdException, IOException
   {
      // read id
      int key;
      if ((key = in.readInt()) != SerializationConstants.ACCESS_CONTROL_LIST)
      {
         throw new UnknownClassIdException("There is unexpected class [" + key + "]");
      }

      // reading owner
      String owner;
      if (in.readByte() == SerializationConstants.NOT_NULL_DATA)
      {
         owner = in.readString();
      }
      else
      {
         owner = null;
      }

      List<AccessControlEntry> accessList = new ArrayList<AccessControlEntry>();
      // reading access control entrys size
      int listSize = in.readInt();
      for (int i = 0; i < listSize; i++)
      {
         // reading access control entrys identity
         String ident = in.readString();
         // reading permission
         String perm = in.readString();

         accessList.add(new AccessControlEntry(ident, perm));
      }

      return new AccessControlList(owner, accessList);
   }
631311
public Storage<S> storageDelegate(StorableIndex<S> index) {
        if (mAllIndexInfoMap.get(index) instanceof ManagedIndex) {
            // Index is managed by this storage, which is typical.
            return null;
        }
        // Index is managed by master storage, most likely a primary key index.
        return mMasterStorage;
    }
1290867
private void readObject(java.io.ObjectInputStream objectInputStream)
                    throws java.io.IOException
                    , java.lang.ClassNotFoundException
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass,
                        "readObject",
                        "objectInputStream=" + objectInputStream + "(java.io.ObjectInputStream)");

        objectInputStream.defaultReadObject();
        // We cannot set the available head during recovery because the links may get deleted before
        // recovery is complete, instead force a scan when we use availableHead for the first time.    
        availableHead = null;
        availableSize = size; // All links are initially available.
        availableSizeLock = new Object();
        managedObjectsToAdd = new java.util.ArrayList(1);
        managedObjectsToReplace = new java.util.ArrayList(3);
        tokensToNotify = new java.util.ArrayList(1);

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass,
                       "readObject");
    }
18031
public void setCustomFinderAccessIntentThreadState(boolean cfwithupdateaccess,
                                                       boolean readonly,
                                                       String methodname) {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled(); // d532639.2

        // create a thread local context for ContainerManagedBeanO to determine CF Access Information
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "setCustomFinderAccessIntentThreadState");

        //CMP11CustomFinderAIContext = new WSThreadLocal();    deleted PQ95614
        CMP11CustomFinderAccIntentState _state = new CMP11CustomFinderAccIntentState(methodname, cfwithupdateaccess, readonly);

        if (isTraceOn && tc.isDebugEnabled())
            Tr.debug(tc, "current thread CMP11 Finder state" + _state);

        svThreadData.get().ivCMP11CustomFinderAccIntentState = _state; // d630940

        if (isTraceOn && tc.isEntryEnabled()) //PQ95614
            Tr.exit(tc, "setCustomFinderAccessIntentThreadState");
    }
408447
private CompletableFuture<Void> processReadResult(Iterator<Operation> readResult) {
        long traceId = LoggerHelpers.traceEnterWithContext(log, this.traceObjectId, "processReadResult");
        InputReadStageResult result = new InputReadStageResult(this.state);
        if (readResult == null) {
            // This happens when we get a TimeoutException from the read operation.
            logStageEvent("InputRead", result);
            LoggerHelpers.traceLeave(log, this.traceObjectId, "processReadResult", traceId);
            return CompletableFuture.completedFuture(null);
        }

        return Futures.loop(
                () -> canRun() && readResult.hasNext(),
                () -> {
                    Operation op = readResult.next();
                    return processOperation(op).thenRun(() -> {
                        // We have now internalized all operations from this batch; and even if subsequent operations in this iteration
                        // fail, we no longer need to re-read these operations, so update the state with the last read SeqNo.
                        this.state.setLastReadSequenceNumber(op.getSequenceNumber());
                        result.operationProcessed(op);
                    });
                },
                this.executor)
                .thenRun(() -> {
                    logStageEvent("InputRead", result);
                    LoggerHelpers.traceLeave(log, this.traceObjectId, "processReadResult", traceId);
                });
    }
120190
public void setDelegate(Object delegate) {
        this.delegate = delegate;
        this.metaClass = InvokerHelper.getMetaClass(delegate.getClass());
    }
1223218
private void updateDelegate()
	{
		T parentValue = parent.getValue();
		
		Observable<U> child = childFactory.createObservable(parentValue);
		
		if (child == null)
		{
			child = Observables.nullObservable();
		}
		
		setDelegate(child);
	}
601835
public void purge( MessageSelector selector ) throws JMSException
    {
        if (volatileStore != null)
            purgeStore(volatileStore,selector);
        if (persistentStore != null)
        {
        	openTransaction();
        	try
        	{
        		purgeStore(persistentStore,selector);
        		commitChanges();
        	}
        	finally
        	{
        		closeTransaction();
        	}
        }
    }
194086
@Override
	public void setReadOnly(boolean readOnly) throws RemoteException {
		if (this.readOnly != readOnly) {
			tx.commit();
			this.readOnly = readOnly;
			try {
				tx = VanillaDb.txMgr().newTransaction(isolationLevel, readOnly);
			} catch (Exception e) {
				throw new RemoteException("error creating transaction ", e);
			}
		}
	}
530300
public void setDelegationStateString(String delegationState) {
    if (delegationState == null) {
      setDelegationStateWithoutCascade(null);
    } else {
      setDelegationStateWithoutCascade(DelegationState.valueOf(delegationState));
    }
  }
972751
public void readObject(java.io.DataInputStream dataInputStream,
                           ObjectManagerState objectManagerState)
                    throws ObjectManagerException
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass,
                        "readObject",
                        "dataInputStream="
                                        + dataInputStream
                                        + " objectManagerState="
                                        + objectManagerState);

        try {
            byte version = dataInputStream.readByte();
            if (Tracing.isAnyTracingEnabled() && trace.isDebugEnabled())
                trace.debug(this, cclass
                            , "readObject"
                            , "version=" + version + "(byte)"
                                );
            super.readObject(dataInputStream,
                             objectManagerState);
            // Re-establish the owning ConcurrentLinkedList.
            concurrentListToken = Token.restore(dataInputStream,
                                                objectManagerState);

        } catch (java.io.IOException exception) {
            // No FFDC Code Needed.
            ObjectManager.ffdc.processException(this, cclass, "readObject", exception, "1:497:1.23");

            if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                trace.exit(this, cclass
                           , "readObject"
                           , "via PermanentIOException"
                                );
            throw new PermanentIOException(this,
                                           exception);
        } // catch (java.io.IOException exception).

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass,
                       "readObject");
    }
59026
public synchronized void setDelegateMap(PropertyMap delegateMap)
    {
        if (!isCompatibleClass(delegateMap.getMapClass()))
            throw new IllegalArgumentException("The delegate map type (" + delegateMap.getMapClass() + " is an incompatible type with " + _mapClass);

        _delegateMap = delegateMap;
    }
1124339
protected boolean getReadOnly(final String dataSourceName) {
		Map<String, String> props = getConnPropsByDataSourceName(dataSourceName);
		return Boolean.parseBoolean(props.get(PROPS_READ_ONLY));
	}
1162311
public void applyToDelegates (DelegateOp op)
    {
        if (_delegates != null) {
            for (int ii = 0, ll = _delegates.size(); ii < ll; ii++) {
                PlaceManagerDelegate delegate = _delegates.get(ii);
                if (op.shouldApply(delegate)) {
                    op.apply(delegate);
                }
            }
        }
    }