}

    private void calculateModificationMask(KnowledgeHelper knowledgeHelper, WithNode node) {

        Class<?> nodeClass = node.getEgressType();

        if (typeDeclaration == null || !typeDeclaration.isPropertyReactive()) {

            modificationMask = Long.MAX_VALUE;

            return;

        }

        private static final Executor executor = ExecutorProviderFactory.getExecutorProvider().getExecutor();

    }

    private void executeJitting(Object object, InternalWorkingMemory workingMemory, LeftTuple leftTuple) {

            return;

        }

        try {

            if (analyzedCondition == null) {

                analyzedCondition = ((MvelConditionEvaluator) conditionEvaluator).getAnalyzedCondition(object, workingMemory, leftTuple);

            }

            conditionEvaluator = ASMConditionEvaluatorJitter.jitEvaluator(expression, analyzedCondition, declarations, classLoader, leftTuple);

        } catch (Throwable t) {

             * If the ruleBase is sequential, after rebuilding or incremental

             * update, do an ordering of the ReteooBuilder

             */

            // FIXME: this same code exists in ReteooRuleBase#newStatelessSession()

            try {

                }

            } finally {

            }

        }

        this.eventSupport.fireKnowledgeBaseUpdated( this.kbase );

        this.listener.debug( "KnowledgeAgent finished rebuilding KnowledgeBase using ChangeSet" );

    }

    }

    public static void writeInitialFactHandleRightTuples(MarshallerWriteContext context) throws IOException {

        ObjectOutputStream stream = context.stream;

        // do we write the fact to the objecttypenode memory

        if ( initialFactNode != null ) {

            ObjectHashSet initialFactMemory = (ObjectHashSet) context.wm.getNodeMemory( initialFactNode );

            if ( initialFactMemory != null && !initialFactMemory.isEmpty() ) {

    public static void writeLeftTuple(LeftTuple leftTuple,

                                      MarshallerWriteContext context,

                                      boolean recurse) throws IOException {

        ObjectOutputStream stream = context.stream;

        InternalWorkingMemory wm = context.wm;

        LeftTupleSink sink = leftTuple.getLeftTupleSink();

        switch ( sink.getType() ) {

    }

    public static ObjectTypeNode attachObjectTypeNode(BuildContext context,

                                                      ObjectType objectType) {

        try {

            InternalWorkingMemory[] wms = context.getWorkingMemories();

            if ( epn == null ) {

                epn = new EntryPointNode( context.getNextId(),

                                          context );

                epn.attach( context );

                for ( InternalWorkingMemory wm : wms ) {

                    wm.updateEntryPointsCache();

                    epn.updateSinkOnAttach( context, wm );

                }

            }

            ObjectTypeNode otn = context.getRuleBase().getConfiguration().getComponentFactory().getNodeFactoryService().buildObjectTypeNode( context.getNextId(),

                                                                                                                                             epn,

                                                                                                                                             objectType,

                                                                                                                                             context );

            long expirationOffset = getExpiratioOffsetForType( context,

                                                               objectType );

            otn.setExpirationOffset( expirationOffset );

            otn.attach( context );

            for ( InternalWorkingMemory wm : wms ) {

                otn.updateSinkOnAttach( context, wm );

            }

            return otn;

        } finally {

        }

    }

    public static void readFactHandles(MarshallerReaderContext context) throws IOException,

                                                                       ClassNotFoundException {

        ObjectInputStream stream = context.stream;

        InternalWorkingMemory wm = context.wm;

        if ( stream.readBoolean() ) {

            InternalFactHandle initialFactHandle = wm.getInitialFactHandle();

            int sinkId = stream.readInt();

            ObjectTypeNode initialFactNode = (ObjectTypeNode) context.sinks.get( sinkId );

            ObjectHashSet initialFactMemory = (ObjectHashSet) context.wm.getNodeMemory( initialFactNode );

            initialFactMemory.add( initialFactHandle );

            readRightTuples( initialFactHandle,

                             context );

        }

        int size = stream.readInt();

        // load the handles

        InternalFactHandle[] handles = new InternalFactHandle[size];

        for ( int i = 0; i < size; i++ ) {

            InternalFactHandle handle = readFactHandle( context );

            context.handles.put( handle.getId(),

                                 handle );

            handles[i] = handle;

            context.wm.getObjectStore().addHandle( handle,

                                                   handle.getObject() );

            readRightTuples( handle,

                             context );

        }

        Map<ObjectType, ObjectTypeNode> objectTypeNodes = node.getObjectTypeNodes();

        // add handles to object type nodes

        for ( InternalFactHandle handle : handles ) {

            Object object = handle.getObject();

    }

    public static Activation readActivation(MarshallerReaderContext context) throws IOException {

        ObjectInputStream stream = context.stream;

        InternalWorkingMemory wm = context.wm;

        long activationNumber = stream.readLong();

        int pos = stream.readInt();

        LeftTuple leftTuple = context.terminalTupleMap.get( pos );

        int salience = stream.readInt();

        //PropagationContext context,

        String pkgName = stream.readUTF();

        String ruleName = stream.readUTF();

        Rule rule = pkg.getRule( ruleName );

        RuleTerminalNode ruleTerminalNode = (RuleTerminalNode) leftTuple.getLeftTupleSink();

        GroupElement subRule = ruleTerminalNode.getSubRule();

    }

    public static void readPropagationContext(MarshallerReaderContext context) throws IOException {

        ObjectInputStream stream = context.stream;

        int type = stream.readInt();

        Rule rule = null;

        if ( stream.readBoolean() ) {

            String pkgName = stream.readUTF();

            String ruleName = stream.readUTF();

            rule = pkg.getRule( ruleName );

        }

        LeftTuple leftTuple = null;

        if ( stream.readBoolean() ) {

             * If the ruleBase is sequential, after rebuilding or incremental

             * update, do an ordering of the ReteooBuilder

             */

            // FIXME: this same code exists in ReteooRuleBase#newStatelessSession()

            try {

                }

            } finally {

            }

        }

        this.eventSupport.fireKnowledgeBaseUpdated( this.kbase );

        this.listener.debug( "KnowledgeAgent finished rebuilding KnowledgeBase using ChangeSet" );

    }