from interface RootDObjectManager
509951
public <T extends DObject> T registerObject (T object)
    {
        if (_dobjThread != null && !isDispatchThread()) {
            log.warning("Registering DObject on non-dobject thread",
                        "class", object.getClass().getName(), new Exception());
        }

        int oid = getNextOid();

        // initialize this object
        object.setOid(oid);
        object.setManager(this);

        // set the default access controller if a controller hasn't already been specified
        if (object.getAccessController() == null) {
            object.setAccessController(_defaultController);
        }

        // insert it into the table
        _objects.put(oid, object);

//         log.info("Registered object", "obj", object);

        return object;
    }
952474
private byte[] getRootItem(String rootName, String servlet) throws IOException
   {
      ByteArrayOutputStream outStream = new ByteArrayOutputStream();

      byte[] rootHead = getRootHeader();
      writeBytes(rootHead, outStream);

      byte[] rootValue = getRootValue(rootName);
      writeInt(rootValue.length / 2, outStream);
      writeBytes(rootValue, outStream);

      outStream.write(0);
      outStream.write(0);

      writeSizedString(servlet, outStream);

      writeZeroQWord(outStream);

      return outStream.toByteArray();
   }
781038
protected CmsObject getRootCmsObject() {

        if (m_rootCms == null) {

            m_rootCms = getOfflineCmsObject(A_CmsUI.getCmsObject());
            m_rootCms.getRequestContext().setSiteRoot("");

        }
        return m_rootCms;
    }
1321774
public void setRootMethodAdapter(JavaRootMethodAdapter rootMethodAdapter) {
        if (rootMethodAdapter == null) {
            throw new NullPointerException();
        }
        if (acceptableTestFramework == null) {
            throw new IllegalStateException("acceptableTestFramework is not set");
        }
        if (acceptableTestFramework.equals(rootMethodAdapter.getName())) {
            this.rootMethodAdapter = rootMethodAdapter;
        }
    }
657387
@Override
    public void readObject(DataInputStream dataInputStream, ObjectManagerState objectManagerState) throws ObjectManagerException, IOException
    {
    	final String methodName = "readObject";
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, methodName, "bytes available==" + dataInputStream.available());

        super.readObject(dataInputStream, objectManagerState);

        long serialVersionUIDRead = dataInputStream.readLong();
       
        _uniqueID = dataInputStream.readLong();
        _streamID = dataInputStream.readLong();
        _lockID = dataInputStream.readLong();
        _referredID = dataInputStream.readLong();
        _sequence = dataInputStream.readLong();
        _expiryTime = dataInputStream.readLong();

        // redeliveredCount was added for serialVersionUIDV1 and later.
        // otherwise set it to 0.
        if (serialVersionUIDRead == serialVersionUIDV0)
          _redeliveredCount = 0;
        else
          _redeliveredCount = dataInputStream.readInt();

        _storageStrategy = dataInputStream.readInt();
        _priority = dataInputStream.readInt();
        _persistentSize = dataInputStream.readInt();
        _maxDepth = dataInputStream.readInt();

        _canExpireSilently = dataInputStream.readBoolean();
        _containsExpirables = dataInputStream.readBoolean();

        // Read the strings in but only if they were
        // not null on the write.
        boolean read = dataInputStream.readBoolean();
        if (read)
        {
            _type = dataInputStream.readUTF();
        }
        read = dataInputStream.readBoolean();
        if (read)
        {
            _className = dataInputStream.readUTF();
        }

        // In order to read in the tran ID we need to read
        // its length so we can create the byte array.
        int length = dataInputStream.readInt();

        if (length != -1)
        {
            _transactionId = new byte[length];

            dataInputStream.readFully(_transactionId, 0, length);
        }

        // Call the Tokens to read themselves in but
        // only if the flag preceding them says that
        // they exist in the stream.
        read = dataInputStream.readBoolean();
        if (read)
        {
            _streamListToken = Token.restore(dataInputStream, objectManagerState);
        }
        read = dataInputStream.readBoolean();
        if (read)
        {
            _itemListToken = Token.restore(dataInputStream, objectManagerState);
        }
        read = dataInputStream.readBoolean();
        if (read)
        {
            _rawDataToken = Token.restore(dataInputStream, objectManagerState);
        }
        read = dataInputStream.readBoolean();
        if (read)
        {
            _streamListEntryToken = Token.restore(dataInputStream, objectManagerState);
        }
        read = dataInputStream.readBoolean();
        if (read)
        {
            _itemListEntryToken = Token.restore(dataInputStream, objectManagerState);
        }

        // _deliveryDelayTime was added for serialVersionUID=2 and serialVersionUIDV1 
        // in releases 8.5.6 and higher.
        if (serialVersionUIDRead == serialVersionUIDV0) {
        	_deliveryDelayTime = 0;
        } else if (serialVersionUIDRead == serialVersionUIDV1) {
        	
        	// _deliveryDelayTime was initially added without changing serialVersionUID, so 
        	// PersistableMetaData was stored using serialVersionUIDV1 and may or may not contain 
        	// _deliveryDelayTime. If there are fewer than 8 bytes remaining in the dataInputStream 
        	// then we can safely assume the _deliveryDelayTime was not stored.
            if (dataInputStream.available() >= 8 && _className.equals("com.ibm.ws.sib.processor.impl.store.items.MessageItem")) {
                _deliveryDelayTime = dataInputStream.readLong();
                // We could have just read garbage from spare space in the ObjectStore.
                _deliveryDelayTimeIsSuspect = true;
            }
            else 
        	    _deliveryDelayTime = 0;  
        } else {
        	_deliveryDelayTime = dataInputStream.readLong();
        }

        // Reset _estimatedLength so that it is re-calculated
        // when it is needed.
        _estimatedLength = -1;
        
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, methodName, "serialVersionUIDRead="+serialVersionUIDRead+" bytes available==" + dataInputStream.available());
    }
1344039
public void write(String packageName, String implClassName, PrintWriter printWriter,
      GinjectorBindings rootBindings) throws UnableToCompleteException {
    writeInjectorHierarchy(rootBindings);

    TypeLiteral<?> ginjectorInterface = rootBindings.getGinjectorInterface();
    if (ginjectorInterface != null) {
      writeInterface(ginjectorInterface, packageName, implClassName, printWriter, rootBindings);
    }
  }
1280009
@Override
    public void visit(final Root root) {
        final Map<String, GedObject> objectMap = root.getObjects();
        final Collection<GedObject> objects = objectMap.values();
        for (final GedObject gob : objects) {
            gob.accept(this);
        }
    }
713356
private ObjectMapper createObjectMapperWithRootUnWrap() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, true);
        mapper.addHandler(new CustomDeserializationProblemHandler());
       
        
        mapper.registerModule(new JodaModule());
        return mapper;
    }
689471
public final <T> T saveObject(final T obj) throws Exception {
        return executeInTransaction(new Runnable<T>() {
            @Override
            public T run(final EntityManager entityManager) {
                return persist(obj, entityManager);
            }
        });
    }
318672
def _set_up_object_manager(self):
        ''''''
        if self.path == '/':
            cond = 'k != \'/\''
        else:
            cond = 'k.startswith(\'%s/\')' % self.path

        self.AddMethod(OBJECT_MANAGER_IFACE,
                       'GetManagedObjects', '', 'a{oa{sa{sv}}}',
                       'ret = {dbus.ObjectPath(k): objects[k].props ' +
                       '  for k in objects.keys() if ' + cond + '}')
        self.object_manager = self
377136
@Override
    public final Object get(Context cx, Object id) {
        if (cx == null) cx = Context.getCurrentContext();
        XMLName xmlName = lib.toXMLNameOrIndex(cx, id);
        if (xmlName == null) {
            long index = ScriptRuntime.lastUint32Result(cx);
            // XXX Fix this cast
            Object result = get((int)index, this);
            if (result == Scriptable.NOT_FOUND) {
                result = Undefined.instance;
            }
            return result;
        }
        return getXMLProperty(xmlName);
    }
611464
private void registerGinjectorBinding() {
    Key<? extends Ginjector> ginjectorKey = Key.get(ginjectorInterface);
    rootGinjectorBindings.addBinding(ginjectorKey, bindingFactory.getGinjectorBinding());
  }
284550
@Override
    public byte[] getObjectXML(String pid) {
        assertInitialized();
        try {
            MessageContext ctx = context.getMessageContext();
            InputStream in =
                    m_management.getObjectXML(ReadOnlyContext
                            .getSoapContext(ctx), pid, "UTF-8");
            ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
            pipeStream(in, out);
            return out.toByteArray();
        } catch (Throwable th) {
            LOG.error("Error getting object XML", th);
            throw CXFUtility.getFault(th);
        }
    }
833288
public RootMethodRunResult getRunResultByRootMethod(TestMethod rootMethod) {
        if (rootMethod == null) {
            throw new NullPointerException();
        }
        return getRunResultByRootMethodKey(rootMethod.getKey());
    }
1181241
private void init()
    {
        TreeNode delegateRoot = null;
        if (delegate != null)
        {
            delegateRoot = (TreeNode) delegate.getRoot();
        }
        thisToDelegate.clear();
        delegateToThis.clear();
        if (delegateRoot == null)
        {
            root = null;
            return;
        }
        root = createNode(delegateRoot);
    }
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");
    }
218591
void parkHandleList() // d662032
    {
        if (connectionHandleList != null)
        {
            final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
            if (isTraceOn && tc.isDebugEnabled())
                Tr.debug(tc, "parkHandleList: " + connectionHandleList);

            try
            {
                connectionHandleList.parkHandle();
            } catch (Exception ex)
            {
                if (isTraceOn && tc.isDebugEnabled())
                    Tr.debug(tc, "parkHandleList: exception", ex);
            }
        }
    }