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;

   

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

            }

        }

    }

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

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

        this.processes = new HashMap<String, Process>();

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

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

        this.partitionIDs = new CopyOnWriteArrayList<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 visitObjectTypeNode(final ObjectTypeNode node) {

        logger.info( indent() + node );

        checkObjectHashSet( memory );

        this.indent++;

        try {

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

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