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

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

        this.eventSupport.setKnowledgeBase(this);

        this.reteooBuilder = (ReteooBuilder) droolsStream.readObject();

        this.reteooBuilder.setRuleBase(this);

        this.rete = (Rete) droolsStream.readObject();

                os = os.getParentObjectSource();

            }

            otn = (ObjectTypeNode) os;

            for ( factHandleEntry = (ObjectEntry) otnIterator.next(); factHandleEntry != null; factHandleEntry = (ObjectEntry) otnIterator.next() ) {

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

                for ( LeftTuple leftTuple = handle.getFirstLeftTuple(); leftTuple != null; leftTuple = leftTuple.getLeftParentNext() ) {

                    if ( leftTuple.getLeftTupleSink() == sink ) {

        final Rete source = this.kBase.getRete();

        final ClassObjectType cot = new ClassObjectType( object.getClass() );

        final Map<ObjectType, ObjectTypeNode> map = source.getObjectTypeNodes( EntryPointId.DEFAULT );

        final ObjectTypeNode node = map.get( cot );

     

        // All objects of this type that are already there were certainly stated,

        // since this method call happens at the first logical insert, for any given type.

        for ( Object obj = it.next(); obj != null; obj = it.next() ) {

         

            org.drools.core.util.ObjectHashSet.ObjectEntry holder = (org.drools.core.util.ObjectHashSet.ObjectEntry) obj;

   

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

                }

            }

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

            }

        }

    }

    public void visitObjectTypeNode(final ObjectTypeNode node) {

        logger.info( indent() + node );

        checkObjectHashSet( memory );

        this.indent++;

        try {

            final Field field = ObjectSource.class.getDeclaredField( "sink" );

        ObjectTypeNode initialFactNode = ruleBase.getRete().getEntryPointNode( EntryPoint.DEFAULT ).getObjectTypeNodes().get( ClassObjectType.InitialFact_ObjectType );

        // do we write the fact to the objecttypenode memory

        if ( initialFactNode != null ) {

                //context.out.println( "InitialFactMemory true int:" + initialFactNode.getId() );

                stream.writeBoolean( true );

                stream.writeInt( initialFactNode.getId() );

                //context.out.println( "InitialFact RightTuples" );

        final Rete source = this.ruleBase.getRete();

        final ClassObjectType cot = new ClassObjectType( object.getClass() );

        final Map<ObjectType, ObjectTypeNode> map = source.getObjectTypeNodes( EntryPoint.DEFAULT );

        final ObjectTypeNode node = map.get( cot );

     

        // All objects of this type that are already there were certainly stated,

        // since this method call happens at the first logical insert, for any given type.

        for ( Object obj = it.next(); obj != null; obj = it.next() ) {

         

            org.drools.core.util.ObjectHashSet.ObjectEntry holder = (org.drools.core.util.ObjectHashSet.ObjectEntry) obj;

   

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