}            });    }    // Companion method of InternalCallback class    protected abstract Object execute(InternalCallback action) throws StoreException;    protected String getCacheRegion() {        return cacheRegion;    }    protected boolean isCacheable() {        return cacheable;    }    protected Criterion getExpression(final WorkflowQuery query) throws StoreException {        return (Criterion) execute(new InternalCallback() {                public Object doInHibernate(Session session) throws HibernateException {                    int operator = query.getOperator();                    switch (operator) {                    case WorkflowQuery.EQUALS:                        return Expression.eq(getFieldName(query.getField()), query.getValue());                    case WorkflowQuery.NOT_EQUALS:                        return Expression.not(Expression.like(getFieldName(query.getField()), query.getValue()));                    case WorkflowQuery.GT:                        return Expression.gt(getFieldName(query.getField()), query.getValue());                    case WorkflowQuery.LT:                        return Expression.lt(getFieldName(query.getField()), query.getValue());                    default:                        return Expression.eq(getFieldName(query.getField()), query.getValue());                    }                }            });    }    protected void delete(final Object entry) throws StoreException {        execute(new InternalCallback() {                public Object doInHibernate(Session session) throws HibernateException {                    session.delete(entry);                    return null;                }            });    }    // ~ DAO Methods ////////////////////////////////////////////////////////////////    protected HibernateWorkflowEntry loadEntry(final long entryId) throws StoreException {        return (HibernateWorkflowEntry) execute(new InternalCallback() {                public Object doInHibernate(Session session) throws HibernateException {                    return session.load(HibernateWorkflowEntry.class, new Long(entryId));                }            });    }    protected void save(final Object entry) throws StoreException {        execute(new InternalCallback() {                public Object doInHibernate(Session session) throws HibernateException {                    session.save(entry);                    return null;                }            });    }    private String getFieldName(int field) {        switch (field) {        case FieldExpression.ACTION: // actionId            return "actionId";        case FieldExpression.CALLER:            return "caller";        case FieldExpression.FINISH_DATE:            return "finishDate";        case FieldExpression.OWNER:            return "owner";        case FieldExpression.START_DATE:            return "startDate";        case FieldExpression.STEP: // stepId            return "stepId";        case FieldExpression.STATUS:            return "status";        case FieldExpression.STATE:            return "state";        case FieldExpression.NAME:            return "workflowName";        case FieldExpression.DUE_DATE:            return "dueDate";        default:            return "1";        }    }    private Class getQueryClass(com.opensymphony.workflow.query.Expression expr, Collection classesCache) {        if (classesCache == null) {            classesCache = new HashSet();        }        if (expr instanceof FieldExpression) {            FieldExpression fieldExpression = (FieldExpression) expr;            switch (fieldExpression.getContext()) {            case FieldExpression.CURRENT_STEPS:                classesCache.add(HibernateCurrentStep.class);                break;            case FieldExpression.HISTORY_STEPS:                classesCache.add(HibernateHistoryStep.class);                break;            case FieldExpression.ENTRY:                classesCache.add(HibernateWorkflowEntry.class);                break;            default:                throw new QueryNotSupportedException("Query for unsupported context " + fieldExpression.getContext());            }        } else {            NestedExpression nestedExpression = (NestedExpression) expr;            for (int i = 0; i < nestedExpression.getExpressionCount(); i++) {                com.opensymphony.workflow.query.Expression expression = nestedExpression.getExpression(i);                if (expression.isNested()) {                    classesCache.add(getQueryClass(nestedExpression.getExpression(i), classesCache));                } else {                    classesCache.add(getQueryClass(expression, classesCache));                }            }        }        if (classesCache.size() > 1) {            throw new QueryNotSupportedException("Store does not support nested queries of different types (types found:" + classesCache + ")");        }        return (Class) classesCache.iterator().next();    }    private Criterion buildExpression(WorkflowQuery query) throws StoreException {        if (query.getLeft() == null) {            if (query.getRight() == null) {                return getExpression(query); // leaf node            } else {                throw new StoreException("Invalid WorkflowQuery object.  QueryLeft is null but QueryRight is not.");            }        } else {            if (query.getRight() == null) {                throw new StoreException("Invalid WorkflowQuery object.  QueryLeft is not null but QueryRight is.");            }            int operator = query.getOperator();            WorkflowQuery left = query.getLeft();            WorkflowQuery right = query.getRight();            switch (operator) {            case WorkflowQuery.AND:                return Expression.and(buildExpression(left), buildExpression(right));            case WorkflowQuery.OR:                return Expression.or(buildExpression(left), buildExpression(right));            case WorkflowQuery.XOR:                throw new QueryNotSupportedException("XOR Operator in Queries not supported by " + this.getClass().getName());            default:                throw new QueryNotSupportedException("Operator '" + operator + "' is not supported by " + this.getClass().getName());            }        }    }    private Criterion buildNested(NestedExpression nestedExpression) {        Criterion full = null;        for (int i = 0; i < nestedExpression.getExpressionCount(); i++) {            Criterion expr;            com.opensymphony.workflow.query.Expression expression = nestedExpression.getExpression(i);            if (expression.isNested()) {                expr = buildNested((NestedExpression) nestedExpression.getExpression(i));            } else {                FieldExpression sub = (FieldExpression) nestedExpression.getExpression(i);                expr = queryComparison(sub);                if (sub.isNegate()) {                    expr = Expression.not(expr);                }            }            if (full == null) {                full = expr;            } else {                switch (nestedExpression.getExpressionOperator()) {                case NestedExpression.AND:                    full = Expression.and(full, expr);                    break;                case NestedExpression.OR:                    full = Expression.or(full, expr);                }            }        }        return full;    }    private Criterion queryComparison(FieldExpression expression) {        int operator = expression.getOperator();        switch (operator) {        case FieldExpression.EQUALS:            return Expression.eq(getFieldName(expression.getField()), expression.getValue());        case FieldExpression.NOT_EQUALS:            return Expression.not(Expression.like(getFieldName(expression.getField()), expression.getValue()));        case FieldExpression.GT:            return Expression.gt(getFieldName(expression.getField()), expression.getValue());        case FieldExpression.LT:            return Expression.lt(getFieldName(expression.getField()), expression.getValue());        default:            return Expression.eq(getFieldName(expression.getField()), expression.getValue());        }    }    //~ Inner Interfaces ///////////////////////////////////////////////////////    // ~ Internal Interfaces /////////////////////////////////////////////////////    // Template method pattern to delegate implementation of Session     // management to subclasses    protected interface InternalCallback {        public Object doInHibernate(Session session) throws HibernateException, StoreException;    }}