public long getListenedPropertyMask(List<String> settableProperties) {

        long mask = 0L;

        LinkedListEntry entry = (LinkedListEntry) constraints.getFirst();

        while ( entry != null ) {

            entry = (LinkedListEntry) entry.getNext();

            if (constraint instanceof MvelConstraint) {

                mask |= ((MvelConstraint)constraint).getListenedPropertyMask(settableProperties);

            } else {

                return Long.MAX_VALUE;

                Object next = it.next();

                if ( next instanceof Declaration ) {

                    continue;

                }

                for ( int i = 0; i < decl.length; i++ ) {

                    Declaration resolved = resolver.getDeclaration( null,

                                                                    decl[i].getIdentifier() );

                   

                    if ( constraint instanceof VariableConstraint && ((VariableConstraint)constraint).getRestriction() instanceof UnificationRestriction ) {

                        UnificationRestriction restriction = ( UnificationRestriction ) ((VariableConstraint)constraint).getRestriction();

                        if( ClassObjectType.DroolsQuery_ObjectType.isAssignableFrom( resolved.getPattern().getObjectType() ) ) {

                            // if the resolved still points to DroolsQuery, we know this is the first unification pattern, so redeclare it as the visible Declaration

                            Declaration redeclaredDeclr = new Declaration(resolved.getIdentifier(), restriction.getVariableRestriction().getReadAccessor(), pattern, false );

                            pattern.addDeclaration(  redeclaredDeclr );

                        } else if ( resolved.getPattern() != pattern ) {

                            // It's a subsequent unification, so it should be able to use the redeclared Declaration as a normal VariableRestriction.

                            // but only rewrite if the resolved declaration is not for current pattern (this occurs if LogicTransformer is applied twice

                            // to the same tree that has already been rewritten before.

                            ((VariableConstraint)constraint).setRestriction( restriction.getVariableRestriction() );

                        }

                    } else if (constraint instanceof MvelConstraint && ((MvelConstraint)constraint).isUnification()) {

                        if( ClassObjectType.DroolsQuery_ObjectType.isAssignableFrom( resolved.getPattern().getObjectType() ) ) {

                            Declaration redeclaredDeclr = new Declaration(resolved.getIdentifier(), ((MvelConstraint)constraint).getFieldExtractor(), pattern, false );

                            pattern.addDeclaration(redeclaredDeclr);

                        } else {

                            ((MvelConstraint)constraint).unsetUnification();

                        }

                    }

                   

                    if ( resolved != null && resolved != decl[i] && resolved.getPattern() != pattern ) {

                                                       resolved );

                    } else if ( resolved == null ) {

                        // it is probably an implicit declaration, so find the corresponding pattern

                        Pattern old = decl[i].getPattern();

                        Pattern current = resolver.findPatternByIndex( old.getIndex() );

                        if ( current != null && old != current ) {

                            resolved = new Declaration( decl[i].getIdentifier(),

                                                        decl[i].getExtractor(),

                                                        current );

                                                           resolved );

                        }

                    }

                }

            }

            // error was already logged during restriction creation failure

            return;

        }

        if ( restriction instanceof AbstractCompositeRestriction ) {

            constraint = new MultiRestrictionFieldConstraint( extractor,

                                                              restriction );

        } else if ( restriction instanceof LiteralRestriction ) {

            constraint = new LiteralConstraint( extractor,

        String expression = expressionBuilder.toString();

        MVELCompilationUnit compilationUnit = getConstraintBuilder( context ).buildCompilationUnit(context, pattern, expression, mvelCtx.getAliases());

                                                                                             expression,

                                                                                             declarations.toArray(new Declaration[declarations.size()]),

                                                                                             compilationUnit,

                                                                                             IndexUtil.ConstraintType.UNKNOWN,

                                                                                             null, null, false );

        if (restrictionDescr != null) {

            FieldValue field = getFieldValue(context, vtype, restrictionDescr);

            if (field != null) {

                if (constraint != null) {

                    pattern.addConstraint(constraint);

                    return true;

                }

            }

                    ClassObjectType.Activation_ObjectType.isAssignableFrom( pattern.getObjectType()) ||

                    (!((ClassObjectType)pattern.getObjectType()).getClassType().isArray() &&

                    !context.getPackageBuilder().getTypeDeclaration(((ClassObjectType)pattern.getObjectType()).getClassType()).isTypesafe());

            pattern.addConstraint( constraint );

        }

    }

            // error was already logged during restriction creation failure

            return;

        }

        if ( restriction instanceof AbstractCompositeRestriction ) {

            constraint = new MultiRestrictionFieldConstraint( extractor,

                                                              restriction );

        } else if ( restriction instanceof LiteralRestriction ) {

            constraint = new LiteralConstraint( extractor,

            }

        }

        for ( Constraint constr : this.constraints ) {

            // we must update pattern references in cloned declarations

            Declaration[] oldDecl = constr.getRequiredDeclarations();

            for ( int i = 0; i < newDecl.length; i++ ) {

                if ( newDecl[i].getPattern() == this ) {

                    newDecl[i].setPattern( clone );

                    // we still need to call replace because there might be nested declarations to replace

                                                   newDecl[i] );

                }

            }

            clone.addConstraint(constraint);

        if (restrictionDescr != null) {

            FieldValue field = getFieldValue(context, vtype, restrictionDescr);

            if (field != null) {

                if (constraint != null) {

                    pattern.addConstraint(constraint);

                    return true;

                }

            }

                    ClassObjectType.Activation_ObjectType.isAssignableFrom( pattern.getObjectType()) ||

                    (!((ClassObjectType)pattern.getObjectType()).getClassType().isArray() &&

                    !context.getPackageBuilder().getTypeDeclaration(((ClassObjectType)pattern.getObjectType()).getClassType()).isTypesafe());

            pattern.addConstraint( constraint );

        }

    }