nav[aria-label="Primary Navigation"] { padding: 0; & ul { list-style: none; width: 100%; display: flex; flex-direction: row; justify-content: start; align-items: start; gap: 30px; padding: 0; & li { margin: 0; } & ul li { list-style: none; } } }

Does IDfCollection.DF_NO_MORE_ROWS_STATE even works

bhanu1987

Hi Experts

I was just writing a component and my requirnment is to figure out if it is last record then I have to set a boolean value and do some logic.

Issue is it never goes in to this if condition.any pointers or this implementation is dead.

if(coll.getState()==IDfCollection.DF_INITIAL_STATE)

{

System.out.println("inside initial state");

}

if(coll.getState()==IDfCollection.DF_CLOSED_STATE)

{

System.out.println("inside CLOSED state");

}

if(coll.getState()==IDfCollection.DF_NO_MORE_ROWS_STATE)

{

System.out.println("inside no more rows state");

}

if(!(coll.getState()==IDfCollection.DF_READY_STATE))

{

System.out.println("inside ready state");

}

code always goes in ready state

Regards

Bhanu

Find more posts tagged with

Documentum

Comments

christopher.imes

Please consider moving this question as-is (no need to recreate) to the proper forum for maximum visibility. Questions written to the users' own "Discussions" space don't get the same amount of attention and can go unanswered for a long time.

You can do so by selecting "Move" under ACTIONS along the upper-right. Then search for: "Documentum" and select the very first result that appears. This will relocate it to the Developer Network space of the Documentum community.

Documentum

For further guidance on engaging with the communities for Documentum and related products, please refer to the

IIG Communities Getting Started Guide.

PanfilovAB

You can't use getState() method to determine whether collection has more records or no, because state is updated by the next() call.

you should do smth. like:


IDfTypedObject object = null;
int rowCount = 0;
while (collection.next()) {
    rowCount++;
    object = collection.getTypedObject();
    // process object
}

if (rowCount > 0) {
    // process object
}

or:


IDfCollectionIterator collection = new IDfCollectionIterator(
        query.execute(session, IDfQuery.DF_EXEC_QUERY));
int i = 0;
collection.close();
while (collection.next()) {
    System.out.println("==========================================");
    System.out.println("Current row: " + ++i + " : "
            + collection.getString("r_object_id"));
    System.out.println("Has next row: " + collection.hasNext());
}



/**
* @author Andrey B. Panfilov <andrew@panfilov.tel>
*/
public final class IDfCollectionIterator implements IDfCollection {

    private IDfTypedObject _next;

    private IDfTypedObject _current;

    private final IDfCollection _wrappedCollection;

    public IDfCollectionIterator(IDfCollection wrappedCollection) {
        if (wrappedCollection == null) {
            throw new NullPointerException("wrappedCollection");
        }
        _wrappedCollection = wrappedCollection;
    }

    public boolean hasNext() throws DfException {
        if (_next != null) {
            return true;
        }

        if (_wrappedCollection.getState() == DF_CLOSED_STATE) {
            return false;
        }

        if (_wrappedCollection.next()) {
            _next = _wrappedCollection.getTypedObject();
            return true;
        } else {
            if (_wrappedCollection.getState() != DF_CLOSED_STATE) {
                _wrappedCollection.close();
            }
            return false;
        }
    }

    @Override
    public boolean next() throws DfException {
        if (hasNext()) {
            _current = _next;
            _next = null;
            return true;
        } else {
            _next = null;
            _current = null;
            return false;
        }
    }

    private IDfTypedObject getCurrent() {
        if (_current == null) {
            switch (getState()) {
            case DF_INITIAL_STATE:
            case DF_READY_STATE:
                throw new IllegalStateException("next() not called yet");
            case DF_CLOSED_STATE:
                throw new IllegalStateException("collection closed");
            case DF_NO_MORE_ROWS_STATE:
                throw new IllegalStateException("beyond end of collection");
            default:
                throw new IllegalStateException("Unknown state, state: "
                        + getState());
            }
        }
        return _current;
    }

    @Override
    public void close() throws DfException {
        if (_wrappedCollection.getState() != DF_CLOSED_STATE) {
            _wrappedCollection.close();
        }
    }

    @Override
    public IDfTypedObject getTypedObject() throws DfException {
        return getCurrent();
    }

    @Override
    public int getState() {
        return _wrappedCollection.getState();
    }

    @Override
    public int getStateEx() {
        return _wrappedCollection.getStateEx();
    }

    @Override
    public ByteArrayInputStream getBytesBuffer(String cmd, String buf,
            String buflen, int length) throws DfException {
        return _wrappedCollection.getBytesBuffer(cmd, buf, buflen, length);
    }

    @Override
    public void appendBoolean(String attr, boolean value) throws DfException {
        getCurrent().appendBoolean(attr, value);
    }

    @Override
    public void appendDouble(String attr, double value) throws DfException {
        getCurrent().appendDouble(attr, value);
    }

    @Override
    public void appendId(String attr, IDfId value) throws DfException {
        getCurrent().appendId(attr, value);
    }

    @Override
    public void appendInt(String attr, int value) throws DfException {
        getCurrent().appendInt(attr, value);
    }

    @Override
    public void appendString(String attr, String value) throws DfException {
        getCurrent().appendString(attr, value);
    }

    @Override
    public void appendTime(String attr, IDfTime value) throws DfException {
        getCurrent().appendTime(attr, value);
    }

    @Override
    public void appendValue(String attr, IDfValue value) throws DfException {
        getCurrent().appendValue(attr, value);
    }

    @Override
    public String dump() throws DfException {
        return getCurrent().dump();
    }

    @Override
    @SuppressWarnings("unchecked")
    public Enumeration enumAttrs() throws DfException {
        return getCurrent().enumAttrs();
    }

    @Override
    public int findAttrIndex(String attr) throws DfException {
        return getCurrent().findAttrIndex(attr);
    }

    @Override
    public int findBoolean(String attr, boolean value) throws DfException {
        return getCurrent().findBoolean(attr, value);
    }

    @Override
    public int findDouble(String attr, double value) throws DfException {
        return getCurrent().findDouble(attr, value);
    }

    @Override
    public int findId(String attr, IDfId value) throws DfException {
        return getCurrent().findId(attr, value);
    }

    @Override
    public int findInt(String attr, int value) throws DfException {
        return getCurrent().findInt(attr, value);
    }

    @Override
    public int findString(String attr, String value) throws DfException {
        return getCurrent().findString(attr, value);
    }

    @Override
    public int findTime(String attr, IDfTime value) throws DfException {
        return getCurrent().findTime(attr, value);
    }

    @Override
    public int findValue(String attr, IDfValue value) throws DfException {
        return getCurrent().findValue(attr, value);
    }

    @Override
    public String getAllRepeatingStrings(String attr, String separator)
        throws DfException {
        return getCurrent().getAllRepeatingStrings(attr, separator);
    }

    @Override
    public IDfAttr getAttr(int index) throws DfException {
        return getCurrent().getAttr(index);
    }

    @Override
    public int getAttrCount() throws DfException {
        return getCurrent().getAttrCount();
    }

    @Override
    public int getAttrDataType(String attr) throws DfException {
        return getCurrent().getAttrDataType(attr);
    }

    @Override
    public boolean getBoolean(String attr) throws DfException {
        return getCurrent().getBoolean(attr);
    }

    @Override
    public double getDouble(String attr) throws DfException {
        return getCurrent().getDouble(attr);
    }

    @Override
    public IDfId getId(String attr) throws DfException {
        return getCurrent().getId(attr);
    }

    @Override
    public int getInt(String attr) throws DfException {
        return getCurrent().getInt(attr);
    }

    @Override
    public long getLong(String attr) throws DfException {
        return getCurrent().getLong(attr);
    }

    @Override
    public IDfId getObjectId() throws DfException {
        return getCurrent().getObjectId();
    }

    @Override
    public IDfSession getObjectSession() {
        return getCurrent().getObjectSession();
    }

    @Override
    public IDfSession getOriginalSession() {
        return getCurrent().getOriginalSession();
    }

    @Override
    public boolean getRepeatingBoolean(String attr, int index)
        throws DfException {
        return getCurrent().getRepeatingBoolean(attr, index);
    }

    @Override
    public double getRepeatingDouble(String attr, int index) throws DfException {
        return getCurrent().getRepeatingDouble(attr, index);
    }

    @Override
    public IDfId getRepeatingId(String attr, int index) throws DfException {
        return getCurrent().getRepeatingId(attr, index);
    }

    @Override
    public int getRepeatingInt(String attr, int index) throws DfException {
        return getCurrent().getRepeatingInt(attr, index);
    }

    @Override
    public long getRepeatingLong(String attr, int index) throws DfException {
        return getCurrent().getRepeatingLong(attr, index);
    }

    @Override
    public String getRepeatingString(String attr, int index) throws DfException {
        return getCurrent().getRepeatingString(attr, index);
    }

    @Override
    public IDfTime getRepeatingTime(String attr, int index) throws DfException {
        return getCurrent().getRepeatingTime(attr, index);
    }

    @Override
    public IDfValue getRepeatingValue(String attr, int index)
        throws DfException {
        return getCurrent().getRepeatingValue(attr, index);
    }

    @Override
    public IDfSession getSession() {
        return getCurrent().getSession();
    }

    @Override
    public IDfSessionManager getSessionManager() {
        return getCurrent().getSessionManager();
    }

    @Override
    public String getString(String attr) throws DfException {
        return getCurrent().getString(attr);
    }

    @Override
    public IDfTime getTime(String attr) throws DfException {
        return getCurrent().getTime(attr);
    }

    @Override
    public IDfValue getValue(String attr) throws DfException {
        return getCurrent().getValue(attr);
    }

    @Override
    public IDfValue getValueAt(int index) throws DfException {
        return getCurrent().getValueAt(index);
    }

    @Override
    public int getValueCount(String attr) throws DfException {
        return getCurrent().getValueCount(attr);
    }

    @Override
    public boolean hasAttr(String attr) throws DfException {
        return getCurrent().hasAttr(attr);
    }

    @Override
    public void insertBoolean(String attr, int index, boolean value)
        throws DfException {
        getCurrent().insertBoolean(attr, index, value);
    }

    @Override
    public void insertDouble(String attr, int index, double value)
        throws DfException {
        getCurrent().insertDouble(attr, index, value);
    }

    @Override
    public void insertId(String attr, int index, IDfId value)
        throws DfException {
        getCurrent().insertId(attr, index, value);
    }

    @Override
    public void insertInt(String attr, int index, int value) throws DfException {
        getCurrent().insertInt(attr, index, value);
    }

    @Override
    public void insertString(String attr, int index, String value)
        throws DfException {
        getCurrent().insertString(attr, index, value);
    }

    @Override
    public void insertTime(String attr, int index, IDfTime value)
        throws DfException {
        getCurrent().insertTime(attr, index, value);
    }

    @Override
    public void insertValue(String attr, int index, IDfValue value)
        throws DfException {
        getCurrent().insertValue(attr, index, value);
    }

    @Override
    public boolean isAttrRepeating(String attr) throws DfException {
        return getCurrent().isAttrRepeating(attr);
    }

    @Override
    public boolean isNull(String attr) throws DfException {
        return getCurrent().isNull(attr);
    }

    @Override
    public void remove(String attr, int index) throws DfException {
        getCurrent().remove(attr, index);
    }

    @Override
    public void removeAll(String attr) throws DfException {
        getCurrent().removeAll(attr);
    }

    @Override
    public void setBoolean(String attr, boolean value) throws DfException {
        getCurrent().setBoolean(attr, value);
    }

    @Override
    public void setDouble(String attr, double value) throws DfException {
        getCurrent().setDouble(attr, value);
    }

    @Override
    public void setId(String attr, IDfId value) throws DfException {
        getCurrent().setId(attr, value);
    }

    @Override
    public void setInt(String attr, int value) throws DfException {
        getCurrent().setInt(attr, value);
    }

    @Override
    public void setNull(String attr) throws DfException {
        getCurrent().setNull(attr);
    }

    @Override
    public void setRepeatingBoolean(String attr, int index, boolean value)
        throws DfException {
        getCurrent().setRepeatingBoolean(attr, index, value);
    }

    @Override
    public void setRepeatingDouble(String attr, int index, double value)
        throws DfException {
        getCurrent().setRepeatingDouble(attr, index, value);
    }

    @Override
    public void setRepeatingId(String attr, int index, IDfId value)
        throws DfException {
        getCurrent().setRepeatingId(attr, index, value);
    }

    @Override
    public void setRepeatingInt(String attr, int index, int value)
        throws DfException {
        getCurrent().setRepeatingInt(attr, index, value);
    }

    @Override
    public void setRepeatingString(String attr, int index, String value)
        throws DfException {
        getCurrent().setRepeatingString(attr, index, value);
    }

    @Override
    public void setRepeatingTime(String attr, int index, IDfTime iDfTime)
        throws DfException {
        getCurrent().setRepeatingTime(attr, index, iDfTime);
    }

    @Override
    public void setRepeatingValue(String attr, int index, IDfValue value)
        throws DfException {
        getCurrent().setRepeatingValue(attr, index, value);
    }

    @Override
    public void setSessionManager(IDfSessionManager sessionManager)
        throws DfException {
        getCurrent().setSessionManager(sessionManager);
    }

    @Override
    public void setString(String attr, String value) throws DfException {
        getCurrent().setString(attr, value);
    }

    @Override
    public void setTime(String attr, IDfTime value) throws DfException {
        getCurrent().setTime(attr, value);
    }

    @Override
    public void setValue(String attr, IDfValue value) throws DfException {
        getCurrent().setValue(attr, value);
    }

    @Override
    public void truncate(String attr, int index) throws DfException {
        getCurrent().truncate(attr, index);
    }

}