docs: public ManagedObject get(Token token)
                      throws ObjectManagerException {
          final String methodName = "get";
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.entry(this, cclass, methodName, new Object[] { token });
  
          if (gatherStatistics)
              numberOfGetRequests++;
  
          ManagedObject objectFromStore = null;
          Directory.StoreArea storeArea = (Directory.StoreArea) directory.getEntry(new Long(token.storedObjectIdentifier));
  
          if (storeArea != null) { // Was the object written?
              if (Tracing.isAnyTracingEnabled() && trace.isDebugEnabled())
                  trace.debug(this,
                              cclass,
                              methodName,
                              new Object[] { storeArea });
  
              java.nio.ByteBuffer serializedBuffer = java.nio.ByteBuffer.allocate((int) storeArea.length);
              getLock.readLock().lock();
              try {
                  // Now read the serialized form of the ManagedObject.
                  storeChannel.read(serializedBuffer,
                                    storeArea.byteAddress);
  
              } catch (java.io.IOException exception) {
                  // No FFDC Code Needed.
                  ObjectManager.ffdc.processException(this, cclass, methodName, exception, "1:480:1.39");
  
                  // check if the file handle is still good
                  if (storeChannel.isOpen())
                  {
                      TemporaryIOException tioe = new TemporaryIOException(this, exception);
                      if (trace.isEntryEnabled())
                          trace.exit(this,
                                     cclass,
                                     "get",
                                     tioe);
                      throw tioe;
                  }
                  else
                  {
                      // there is nothing more we can do really, so request a shutdown
                      // and throw a permanent ioexception.
                      objectManagerState.requestShutdown();
  
                      PermanentIOException pioe = new PermanentIOException(this, exception);
                      if (trace.isEntryEnabled())
                          trace.exit(this,
                                     cclass,
                                     "get",
                                     pioe);
  
                      throw pioe;
                  }
  
              } finally {
                  getLock.readLock().unlock();
              } // try... 
  
              byte[] managedObjectBytes = serializedBuffer.array();
  
              // For debugging check guardBytes added before and after the serialized ManagedObject.
              if (useGuardBytes) {
                  byte[] unGuardedBytes = new byte[-guardBytesLength + managedObjectBytes.length - guardBytesLength];
                  for (int i = 0; i < guardBytesLength; i++) {
                      if (managedObjectBytes[i] != managedObjectBytes[guardBytesLength + unGuardedBytes.length + i]) {
                          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                              trace.exit(this,
                                         cclass,
                                         methodName);
                          throw new GuardBytesException(this,
                                                        token);
                      }
                  } // for guardBytes.
  
                  System.arraycopy(managedObjectBytes, // Source.
                                   guardBytesLength, // Source position.
                                   unGuardedBytes, // Destination.
                                   0, // Destination position.
                                   unGuardedBytes.length); // Length.
  
                  managedObjectBytes = unGuardedBytes;
              } // If (useGuardBytes).
  
              // Recover the ManagedObject from its serialized bytes.
              objectFromStore = ManagedObject.restoreFromSerializedBytes(managedObjectBytes,
                                                                         objectManagerState);
              // Cache the ManagedObject in memory, possibly push out a previously
              // cached ManagedObject.
              cache(objectFromStore);
          } // if (storeArea != null).
  
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.exit(this, cclass, methodName, new Object[] { objectFromStore });
          return objectFromStore;
      }