// it is enough to iterate the facts on the concrete object type nodes

                // only, as the facts will always be in their concrete object type nodes

                // even if they were also asserted into higher level OTNs as well

                ObjectTypeNode otn = conf.getConcreteObjectTypeNode();

                for ( ObjectEntry entry = (ObjectEntry) it.next(); entry != null; entry = (ObjectEntry) it.next() ) {

                    InternalFactHandle handle = (InternalFactHandle) entry.getValue();

                    removePropertyChangeListener( handle, false );

                }

            }

        ObjectTypeNode initialFactNode = ruleBase.getRete().getEntryPointNode( EntryPoint.DEFAULT ).getObjectTypeNodes().get( new ClassObjectType( InitialFact.class ) );

        // do we write the fact to the objecttypenode memory

        if ( initialFactNode != null ) {

                stream.writeBoolean( true );

                stream.writeInt( initialFactNode.getId() );

                    context.ruleBase.unlock();

                }

                // ------- END RANT -----

            }

            readRightTuples( initialFactHandle,

                             context );

        }

        while ( context.readShort() == PersisterEnums.ENTRY_POINT) {

            String entryPointId = context.stream.readUTF();

            ObjectTypeConf typeConf = ( (InternalWorkingMemoryEntryPoint) factHandle.getEntryPoint() ).getObjectTypeConfigurationRegistry().getObjectTypeConf( ep,

                                                                                                                                                               object );

            ObjectTypeNode[] cachedNodes = typeConf.getObjectTypeNodes();

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

                         false );

            }

        }

    }

        if ( stream.readBoolean() ) {

            InternalFactHandle initialFactHandle = wm.getInitialFactHandle();

            int sinkId = stream.readInt();

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

            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 );

        }

        EntryPointNode node = ruleBase.getRete().getEntryPointNode( EntryPoint.DEFAULT );

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

        // add handles to object type nodes

        for ( InternalFactHandle handle : handles ) {

            Object object = handle.getObject();

            ClassObjectType objectType = new ClassObjectType( object.getClass() );

            ObjectTypeNode objectTypeNode = objectTypeNodes.get( objectType );

            if (objectTypeNode != null) {

                       false );

            }

        }

        InternalFactHandle handle = wm.getInitialFactHandle();

                                                               this.config.isClassLoaderCacheEnabled() );

        this.pkgs = new HashMap<String, Package>();

        this.processes = new HashMap();

        this.globals = new HashMap<String, Class< ? >>();

        this.classTypeDeclaration = new HashMap<Class< ? >, TypeDeclaration>();

        this.partitionIDs = new ArrayList<RuleBasePartitionId>();

        this.classFieldAccessorCache = new ClassFieldAccessorCache( this.rootClassLoader );

        this.partitionIDs = (List<RuleBasePartitionId>) droolsStream.readObject();

        this.eventSupport = (RuleBaseEventSupport) droolsStream.readObject();

        this.eventSupport.setRuleBase( this );

        if ( !isDrools ) {

            droolsStream.close();

        }

    }

    public void assertObject(final InternalFactHandle factHandle,

                             final PropagationContext context,

                             final InternalWorkingMemory workingMemory) {

        if ( this.objectMemoryEnabled ) {

                        false );

        }

        if ( compiledNetwork != null ) {

            compiledNetwork.assertObject( factHandle,

                                          context,

    public void retractObject(final InternalFactHandle factHandle,

                              final PropagationContext context,

                              final InternalWorkingMemory workingMemory) {

        if ( this.objectMemoryEnabled ) {

        }

        for ( RightTuple rightTuple = factHandle.getFirstRightTuple(); rightTuple != null; rightTuple = (RightTuple) rightTuple.getHandleNext() ) {

            rightTuple.getRightTupleSink().retractRightTuple( rightTuple,

                                                              context,

    public void updateSink(final ObjectSink sink,

                           final PropagationContext context,

                           final InternalWorkingMemory workingMemory) {

        for ( ObjectEntry entry = (ObjectEntry) it.next(); entry != null; entry = (ObjectEntry) it.next() ) {

            sink.assertObject( (InternalFactHandle) entry.getValue(),

                               context,

                               workingMemory );

        }