docs: public synchronized void commit_one_phase() throws RollbackException, HeuristicHazardException, SystemException {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "commit_one_phase", this);
  
          // Ensure timeout cannot rollback the underlying transaction
          ((DistributableTransaction) _transaction).addAssociation();
  
          // If the transaction that this object represents has already been completed,
          // raise an exception if necessary.
          boolean rolledBack = false; // Use locals in case of async completion
          boolean sysException = false;
  
          final int state = _transaction.getTransactionState().getState();
          switch (state) {
              case TransactionState.STATE_ACTIVE:
                  // We have received a commit one phase request
                  // from our superior. This transaction should
                  // no longer act as a subordinate and should
                  // assume superior status prior to beginning
                  // commit processing - this is enabled by calling
                  // the top-level commit operation.
  
                  // The commit operation may throw the HeuristicHazard exception.  In this case
                  // allow it to go back to the caller.  The commit call performs all state checks.
                  try {
                      // Resume the transaction created from the incoming
                      // request so that it is installed on the thread.
                      ((EmbeddableTranManagerSet) TransactionManagerFactory.getTransactionManager()).resume(_transaction);
  
                      // need to prolongFinish to deal with heuristics
                      // as commit_one_phase always calls notifyCompletion
                      _transaction.prolongFinish();
                      _transaction.commit_one_phase();
                      _transaction.notifyCompletion();
                  } catch (HeuristicMixedException exc) {
                      // No FFDC code needed.
                      _heuristic = StatefulResource.HEURISTIC_MIXED;
                  } catch (HeuristicHazardException exc) {
                      // No FFDC code needed.
                      _heuristic = StatefulResource.HEURISTIC_HAZARD;
                  } catch (HeuristicRollbackException exc) {
                      // No FFDC code needed.
                      rolledBack = true;
                      _transaction.notifyCompletion();
                  } catch (RollbackException exc) {
                      // No FFDC as rollback is a valid response
                      rolledBack = true;
                      _transaction.notifyCompletion();
                  } catch (Throwable exc) { // SecurityException/IllegalStateException/SystemException
                      FFDCFilter.processException(exc, "com.ibm.tx.remote.TransactionWrapper.commit_one_phase", "456", this);
                      Tr.error(tc, "WTRN0070_ONE_PHASE_COMMIT_FAILED", exc);
                      sysException = true;
                      _transaction.notifyCompletion();
                      // destroy();
                  }
                  break;
  
              case TransactionState.STATE_COMMITTING:
                  // We should only get in this state if the superior failed to get a
                  // response on the original commit calls.  We can be in committing
                  // state either if we are retrying local resources or in recovery
                  // Check the heuristic state and return that.
                  _heuristic = _transaction.getResources().getHeuristicOutcome();
                  if (_heuristic != StatefulResource.NONE)
                      break;
  
                  // If we are not in any heuristic state then we are not retrying and
                  // must be in recovery about to perform the commit. 
                  // Continue to return transient until we have a real outcome to return.
                  // The superior will consider this as heuristic hazard.  Also the
                  // same for LPS state.
              case TransactionState.STATE_LAST_PARTICIPANT:
                  ((DistributableTransaction) _transaction).removeAssociation();
                  final TRANSIENT tre = new TRANSIENT();
                  if (tc.isEntryEnabled())
                      Tr.exit(tc, "commit_one_phase", tre);
                  throw tre;
  
              case TransactionState.STATE_COMMITTED:
                  // this is probably a retry ... check heuristic state 
                  _heuristic = _transaction.getResources().getHeuristicOutcome();
                  break;
  
              case TransactionState.STATE_HEURISTIC_ON_COMMIT:
              case TransactionState.STATE_HEURISTIC_ON_ROLLBACK:
                  // Should never get in this state as C1P never gets
                  // in this state as it presumes superior status even
                  // for admin heuristic commit
                  break;
  
              case TransactionState.STATE_ROLLING_BACK:
              case TransactionState.STATE_ROLLED_BACK:
                  // Transaction timed out or admin heuristic rollback or LPS rollback
                  // again, probably a retry ... throw exception
                  rolledBack = true;
                  break;
  
              case TransactionState.STATE_NONE:
                  // Transaction has completed and is now finished
                  // Normally the remoteable object would be disconnected from the orb,
                  // but ... timing may mean get got here while it was happenning
                  ((DistributableTransaction) _transaction).removeAssociation();
                  final OBJECT_NOT_EXIST one = new OBJECT_NOT_EXIST();
                  if (tc.isEntryEnabled())
                      Tr.exit(tc, "commit_one_phase", one);
                  throw one;
  
              default:
                  Tr.error(tc, "WTRN0069_COMMIT_BAD_STATE", TransactionState.stateToString(state));
                  sysException = true;
                  break;
          } // end switch
  
          ((DistributableTransaction) _transaction).removeAssociation();
  
          switch (_heuristic)
          {
              case StatefulResource.NONE:
                  break;
  
              default:
  //                _transaction.addHeuristic();
                  final HeuristicHazardException hh = new HeuristicHazardException();
                  if (tc.isEntryEnabled())
                      Tr.exit(tc, "commit_one_phase", hh);
                  throw hh;
          }
  
          if (rolledBack)
          {
              final TRANSACTION_ROLLEDBACK tre = new TRANSACTION_ROLLEDBACK(0, Boolean.TRUE);
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "commit_one_phase", tre);
              throw tre;
          }
          else if (sysException)
          {
              final INTERNAL ie = new INTERNAL(MinorCode.LOGIC_ERROR, null);
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "commit_one_phase", ie);
              throw ie;
          }
  
          if (tc.isEntryEnabled())
              Tr.exit(tc, "commit_one_phase");
      }