Examples of org.drools.core.rule.TypeDeclaration$TimestampAccessorSetter

org.drools.core.rule.TypeDeclaration
The type declaration class stores all type's metadata declared in source files.


        // Iterate and for each typedeclr assign it's value if it's not already set
        // We start from the rear as those are the furthest away classes and interfaces
        TypeDeclaration[] tarray = tdecls.toArray( new TypeDeclaration[tdecls.size()] );
        for ( int i = tarray.length - 1; i >= 0; i-- ) {
            TypeDeclaration currentTDecl = tarray[i];
            if ( !isSet( typeDeclaration.getSetMask(),
                         TypeDeclaration.ROLE_BIT ) && isSet( currentTDecl.getSetMask(),
                                                              TypeDeclaration.ROLE_BIT ) ) {
                typeDeclaration.setRole( currentTDecl.getRole() );
            }
            if ( !isSet( typeDeclaration.getSetMask(),
                         TypeDeclaration.FORMAT_BIT ) && isSet( currentTDecl.getSetMask(),
                                                                TypeDeclaration.FORMAT_BIT ) ) {
                typeDeclaration.setFormat( currentTDecl.getFormat() );
            }
            if ( !isSet( typeDeclaration.getSetMask(),
                         TypeDeclaration.TYPESAFE_BIT ) && isSet( currentTDecl.getSetMask(),
                                                                  TypeDeclaration.TYPESAFE_BIT ) ) {
                typeDeclaration.setTypesafe( currentTDecl.isTypesafe() );
            }
        }


        this.cacheTypes.put( cls.getName(),
                             typeDeclaration );

View Full Code Here

        this.cacheTypes.put( cls.getName(),
                             typeDeclaration );
    }


    private TypeDeclaration createTypeDeclarationForBean(Class< ? > cls) {
        TypeDeclaration typeDeclaration = new TypeDeclaration( cls );


        PropertySpecificOption propertySpecificOption = configuration.getOption( PropertySpecificOption.class );
        boolean propertyReactive = propertySpecificOption.isPropSpecific( cls.isAnnotationPresent( PropertyReactive.class ),
                                                                          cls.isAnnotationPresent( ClassReactive.class ) );


        setPropertyReactive( null, typeDeclaration, propertyReactive );


        Role role = cls.getAnnotation( Role.class );
        if ( role != null && role.value() == Role.Type.EVENT) {
            typeDeclaration.setRole(TypeDeclaration.Role.EVENT);
        }


        return typeDeclaration;
    }

View Full Code Here


    public boolean buildTypeDeclarationInterfaces(Class cls,
                                                  Set<TypeDeclaration> tdecls) {
        PackageRegistry pkgReg;


        TypeDeclaration tdecl = this.builtinTypes.get( (cls.getName()) );
        if ( tdecl == null ) {
            pkgReg = this.pkgRegistryMap.get( ClassUtils.getPackage( cls ) );
            if ( pkgReg != null ) {
                tdecl = pkgReg.getPackage().getTypeDeclaration( cls.getSimpleName() );
            }

View Full Code Here

        boolean isSuperClassDeclared = true; //in the same package, or in a previous one


        if ( pack != null ) {


            // look for the supertype declaration in available packages
            TypeDeclaration superTypeDeclaration = pack.getTypeDeclaration( simpleSuperTypeName );


            if ( superTypeDeclaration != null ) {
                ClassDefinition classDef = superTypeDeclaration.getTypeClassDef();
                // inherit fields
                for ( FactField fld : classDef.getFields() ) {
                    TypeFieldDescr inheritedFlDescr = buildInheritedFieldDescrFromDefinition( fld );
                    fieldMap.put( inheritedFlDescr.getFieldName(),
                                  inheritedFlDescr );
                }


                // new classes are already distinguished from tagged external classes
                isSuperClassTagged = !superTypeDeclaration.isNovel();
            } else {
                isSuperClassDeclared = false;
            }


        } else {

View Full Code Here

                    }
                }
            }


            // Go on with the build
            TypeDeclaration type = new TypeDeclaration( typeDescr.getTypeName() );
            if ( typeDescr.getResource() == null ) {
                typeDescr.setResource( resource );
            }
            type.setResource( typeDescr.getResource() );


            TypeDeclaration parent = null;
            if ( !typeDescr.getSuperTypes().isEmpty() ) {
                // parent might have inheritable properties
                PackageRegistry sup = pkgRegistryMap.get( typeDescr.getSuperTypeNamespace() );
                if ( sup != null ) {
                    parent = sup.getPackage().getTypeDeclaration( typeDescr.getSuperTypeName() );
                    if ( parent.getNature() == TypeDeclaration.Nature.DECLARATION && ruleBase != null ) {
                        // trying to find a definition
                        parent = ruleBase.getPackagesMap().get( typeDescr.getSuperTypeNamespace() ).getTypeDeclaration( typeDescr.getSuperTypeName() );
                    }
                }
            }


            // is it a regular fact or an event?
            AnnotationDescr annotationDescr = typeDescr.getAnnotation( TypeDeclaration.Role.ID );
            String role = (annotationDescr != null) ? annotationDescr.getSingleValue() : null;
            if ( role != null ) {
                type.setRole( TypeDeclaration.Role.parseRole( role ) );
            } else if ( parent != null ) {
                type.setRole( parent.getRole() );
            }


            annotationDescr = typeDescr.getAnnotation( TypeDeclaration.ATTR_TYPESAFE );
            String typesafe = (annotationDescr != null) ? annotationDescr.getSingleValue() : null;
            if ( typesafe != null ) {
                type.setTypesafe( Boolean.parseBoolean( typesafe ) );
            } else if ( parent != null ) {
                type.setTypesafe( parent.isTypesafe() );
            }


            // is it a pojo or a template?
            annotationDescr = typeDescr.getAnnotation( TypeDeclaration.Format.ID );
            String format = (annotationDescr != null) ? annotationDescr.getSingleValue() : null;

View Full Code Here

        if ( type.isValid() ) {
            // prefer definitions where possible
            if ( type.getNature() == TypeDeclaration.Nature.DEFINITION ) {
                pkgRegistry.getPackage().addTypeDeclaration( type );
            } else {
                TypeDeclaration oldType = pkgRegistry.getPackage().getTypeDeclaration( type.getTypeName() );
                if ( oldType == null ) {
                    pkgRegistry.getPackage().addTypeDeclaration( type );
                } else {
                    if ( type.getRole() == TypeDeclaration.Role.EVENT ) {
                        oldType.setRole( TypeDeclaration.Role.EVENT );
                    }
                    if ( type.isPropertyReactive() ) {
                        oldType.setPropertyReactive( true );
                    }
                }
            }
        }

View Full Code Here

        type.setTypeClassDef( def );


        //if is not new, search the already existing declaration and
        //compare them o see if they are at least compatibles
        if ( !type.isNovel() ) {
            TypeDeclaration previousTypeDeclaration = this.pkgRegistryMap.get( typeDescr.getNamespace() ).getPackage().getTypeDeclaration( typeDescr.getTypeName() );


            try {


                if ( !type.getTypeClassDef().getFields().isEmpty() ) {
                    //since the declaration defines one or more fields, it is a DEFINITION

View Full Code Here

                        tempDescr.setNamespace( typeDescr.getNamespace() );
                        tempDescr.setFields( typeDescr.getFields() );
                        tempDescr.setType( target,
                                           typeDescr.getNamespace() );
                        tempDescr.addSuperType( typeDescr.getType() );
                        TypeDeclaration tempDeclr = new TypeDeclaration( target );
                        tempDeclr.setKind( TypeDeclaration.Kind.TRAIT );
                        tempDeclr.setTypesafe( type.isTypesafe() );
                        tempDeclr.setNovel( true );
                        tempDeclr.setTypeClassName( tempDescr.getType().getFullName() );
                        tempDeclr.setResource( type.getResource() );


                        ClassDefinition tempDef = new ClassDefinition( target );
                        tempDef.setClassName( tempDescr.getType().getFullName() );
                        tempDef.setTraitable( false );
                        for ( FieldDefinition fld : def.getFieldsDefinitions() ) {
                            tempDef.addField( fld );
                        }
                        tempDef.setInterfaces( def.getInterfaces() );
                        tempDef.setSuperClass( def.getClassName() );
                        tempDef.setDefinedClass( resolvedType );
                        tempDef.setAbstrakt( true );
                        tempDeclr.setTypeClassDef( tempDef );


                        type.setKind( TypeDeclaration.Kind.CLASS );


                        generateDeclaredBean( tempDescr,
                                              tempDeclr,
                                              pkgRegistry,
                                              tempDef );
                        try {
                            Class< ? > clazz = pkgRegistry.getTypeResolver().resolveType( tempDescr.getType().getFullName() );
                            tempDeclr.setTypeClass( clazz );
                        } catch ( ClassNotFoundException cnfe ) {
                            this.results.add( new TypeDeclarationError( typeDescr,
                                                                        "Internal Trait extension Class '" + target +
                                                                                "' could not be generated correctly'" ) );
                        } finally {

View Full Code Here

            declaredMask = -1L;
            return;
        }
        
        Class objectClass = ((ClassObjectType)objectType).getClassType();        
        TypeDeclaration typeDeclaration = context.getRuleBase().getTypeDeclaration(objectClass);
        if ( typeDeclaration == null || !typeDeclaration.isPropertyReactive() ) {
            // if property specific is not on, then accept all modification propagations
            declaredMask = -1L;
        } else {
            List<String> settableProperties = getSettableProperties(context.getRuleBase(), objectClass);
            declaredMask = calculateDeclaredMask(settableProperties);

View Full Code Here


        init();
    }


    private void init() {
        TypeDeclaration thingType = new TypeDeclaration( Thing.class.getName() );
        thingType.setKind( TypeDeclaration.Kind.TRAIT );
        thingType.setTypeClass( Thing.class );
        ClassDefinition def = new ClassDefinition();
        def.setClassName( thingType.getTypeClass().getName() );
        def.setDefinedClass( Thing.class );
        addTrait( def );


        ClassDefinition individualDef = new ClassDefinition();
        individualDef.setClassName( Entity.class.getName() );

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.drools.core.rule.TypeDeclaration$TimestampAccessorSetter

org.drools.compiler.builder.impl.ClassHierarchyManager

org.drools.compiler.builder.impl.KnowledgeBuilderImpl

org.drools.compiler.builder.impl.KnowledgeBuilderTest

org.drools.compiler.builder.impl.TypeDeclarationBuilder

org.drools.compiler.builder.impl.TypeDeclarationCache

org.drools.compiler.builder.impl.TypeDeclarationConfigurator

org.drools.compiler.builder.impl.TypeDeclarationFactory

org.drools.compiler.builder.impl.TypeDeclarationNameResolver

org.drools.compiler.builder.impl.TypeDeclarationUtils

org.drools.compiler.compiler.PackageBuilder

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.