if ( !mode.derefInSearching() )
if ( !mode.isDerefInSearching() )
    public boolean assertSubtreeScope( final ScopeNode node, final BigInteger id ) throws NamingException    {        String dn = db.getEntryDn( id );        DerefAliasesEnum mode = node.getDerefAliases();        Object baseId = db.getEntryId( node.getBaseDn() );        boolean isDescendant = dn.endsWith( node.getBaseDn() );        /*         * The candidate id could be any entry in the db.  If search          * dereferencing is not enabled then we return the results of the          * descendant test.         */        if ( !mode.derefInSearching() )        {            return isDescendant;        }        /*         * From here down alias dereferencing is enabled.  We determine if the         * candidate id is an alias, if so we reject it since aliases should         * not be returned.         */        Index idx = db.getAliasIndex();        if ( null != idx.reverseLookup( id ) )        {            return false;        }        /*         * The candidate is NOT an alias at this point.  So if it is a          * descendant we just return it since it is in normal subtree scope.         */        if ( isDescendant )        {            return true;        }        /*         * At this point the candidate is not a descendant and it is not an          * alias.  We need to check if the candidate is in extended subtree          * scope by performing a lookup on the subtree alias index.  This index          * stores a tuple mapping the baseId to the ids of objects brought          * into subtree scope of the base by an alias:          *          * ( baseId, aliasedObjId )         *          * If the candidate id is an object brought into subtree scope then          * the lookup returns true accepting the candidate.  Otherwise the          * candidate is rejected with a false return because it is not in scope.         */        idx = db.getSubAliasIndex();        return idx.hasValue( baseId, id );    }