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;
          synchronized (this) { // Avoid collisions with write operations.
  
              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 });
  
                  byte[] managedObjectBytes = new byte[(int) storeArea.length];
  
                  try {
                      // Now read the serialized form of the ManagedObject.
                      storeFile.seek(storeArea.byteAddress);
                      storeFile.readFully(managedObjectBytes);
  
                  } catch (java.io.IOException exception) {
                      // No FFDC Code Needed.
                      ObjectManager.ffdc.processException(this,
                                                          cclass,
                                                          methodName,
                                                          exception,
                                                          "1:455:1.35");
  
                      // check if the file handle is still good
                      try {
                          if (storeFile.getFD().valid())
                          {
                              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;
                          }
                      } catch (java.io.IOException e)
                      {
                          // 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;
                      }
  
                  } // catch (java.io.IOException exception).
  
                  // 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).
          } // synchronized(this).
  
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.exit(this, cclass, methodName, new Object[] { objectFromStore });
          return objectFromStore;
      }