public virtual object Produce(object key, IFunction4 producer, IProcedure4 finalizer
			)
		{
			if (key == null)
			{
				throw new ArgumentNullException();
			}
			if (_am.Remove(key))
			{
				_am.AddFirst(key);
				return _slots[key];
			}
			if (_a1out.Contains(key))
			{
				ReclaimFor(key, producer, finalizer);
				_am.AddFirst(key);
				return _slots[key];
			}
			if (_a1in.Contains(key))
			{
				return _slots[key];
			}
			ReclaimFor(key, producer, finalizer);
			_a1in.AddFirst(key);
			return _slots[key];
		}

		public virtual object Produce(object key, IFunction4 producer, IProcedure4 finalizer
			)
		{
			if (key == null)
			{
				throw new ArgumentNullException();
			}
			if (_am.Remove(key))
			{
				_am.AddFirst(key);
				return _slots[key];
			}
			if (_a1.Remove(key))
			{
				_am.AddFirst(key);
				return _slots[key];
			}
			if (_slots.Count >= _maxSize)
			{
				DiscardPage(finalizer);
			}
			object value = producer.Apply(key);
			_slots[key] = value;
			_a1.AddFirst(key);
			return value;
		}

		public virtual object Produce(object key, IFunction4 producer, IProcedure4 onDiscard
			)
		{
			_calls++;
			IFunction4 delegateProducer = new _IFunction4_26(this, producer);
			return _delegate.Produce(key, delegateProducer, onDiscard);
		}

		public virtual object Produce(object key, IFunction4 producer, IProcedure4 finalizer
			)
		{
			object value = _slots[key];
			if (value == null)
			{
				object newValue = producer.Apply(key);
				if (newValue == null)
				{
					return null;
				}
				if (_slots.Count >= _maxSize)
				{
					object discarded = Sharpen.Collections.Remove(_slots, _lru.RemoveLast());
					if (null != finalizer)
					{
						finalizer.Apply(discarded);
					}
				}
				_slots[key] = newValue;
				_lru.AddFirst(key);
				return newValue;
			}
			_lru.Remove(key);
			// O(N) 
			_lru.AddFirst(key);
			return value;
		}

 public SequentialIdGenerator(IFunction4 findFreeId, int initialValue, int minValidId
     , int maxValidId)
 {
     _findFreeId = findFreeId;
     _minValidId = minValidId;
     _maxValidId = maxValidId;
     InitializeGenerator(initialValue);
 }

 public FunctionApplicationIterator(IEnumerator iterator, IFunction4 function) : base
     (iterator)
 {
     if (null == function)
     {
         throw new ArgumentNullException();
     }
     _function = function;
 }

 /// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception>
 public CachingBin(IBin bin, ICache4 cache, int pageCount, int pageSize) : base(bin
     )
 {
     _onDiscardPage = new _IProcedure4_22(this);
     _producerFromDisk = new _IFunction4_138(this);
     _producerFromPool = new _IFunction4_147(this);
     _pageSize = pageSize;
     _pagePool = new SimpleObjectPool(NewPagePool(pageCount));
     _cache = cache;
     _fileLength = _bin.Length();
 }

			private static object WithContainer(string filename, IFunction4 block)
			{
				IObjectContainer container = Db4oFactory.OpenFile(filename);
				try
				{
					return block.Apply(container);
				}
				finally
				{
					container.Close();
				}
			}

		public virtual object Produce(object key, IFunction4 producer, IProcedure4 finalizer
			)
		{
			if (_am.Remove((((long)key))))
			{
				_am.AddFirst((((long)key)));
				return _slots[((long)key)];
			}
			if (_a1.Remove((((long)key))))
			{
				_am.AddFirst((((long)key)));
				return _slots[((long)key)];
			}
			if (_slots.Count >= _maxSize)
			{
				DiscardPage(finalizer);
			}
			object value = producer.Apply(((long)key));
			_slots[((long)key)] = value;
			_a1.AddFirst((((long)key)));
			return value;
		}

		private void ReclaimFor(object key, IFunction4 producer, IProcedure4 finalizer)
		{
			if (_slots.Count < _maxSize)
			{
				_slots[key] = producer.Apply(key);
				return;
			}
			if (_a1in.Size() > _inSize)
			{
				object lastKey = _a1in.RemoveLast();
				Discard(lastKey, finalizer);
				if (_a1out.IsFull())
				{
					_a1out.RemoveLast();
				}
				_a1out.AddFirst(lastKey);
			}
			else
			{
				object lastKey = _am.RemoveLast();
				Discard(lastKey, finalizer);
			}
			_slots[key] = producer.Apply(key);
		}

		public static IEnumerable Series(object seed, IFunction4 function)
		{
			return new _IEnumerable_356(seed, function);
		}

			public _IEnumerable_253(IEnumerable iterable, IFunction4 function)
			{
				this.iterable = iterable;
				this.function = function;
			}

		public static IEnumerable Map(IEnumerable iterable, IFunction4 function)
		{
			return new _IEnumerable_253(iterable, function);
		}

		private IEnumerator MapPersistentFields(object obj, IFunction4 function)
		{
			return Iterators.Map(IteratePersistentFields(obj), function);
		}

		public virtual ITest Transmogrify(IFunction4 fun)
		{
			return ((ITest)fun.Apply(this));
		}

		private void WithDatabase(string file, IFunction4 function)
		{
			Configure();
			IExtObjectContainer objectContainer = Db4oFactory.OpenFile(file).Ext();
			try
			{
				function.Apply(objectContainer);
			}
			finally
			{
				objectContainer.Close();
			}
			IObjectServer server = Db4oFactory.OpenServer(ClientServerFileName(file), -1);
			server.GrantAccess(Username, Password);
			objectContainer = Db4oFactory.OpenClient("localhost", server.Ext().Port(), Username
				, Password).Ext();
			try
			{
				function.Apply(objectContainer);
			}
			finally
			{
				objectContainer.Close();
				server.Close();
			}
		}

		public ITest Transmogrify(IFunction4 fun) 
		{
			return (ITest) fun.Apply(this);
		}

			public TestPuppet()
			{
				producer = new _IFunction4_50(this);
			}

		private object AsTopLevelStore(IFunction4 block, Transaction trans)
		{
			trans = CheckTransaction(trans);
			object result = AsTopLevelCall(block, trans);
			if (_stackDepth == 0)
			{
				trans.ProcessDeletes();
			}
			return result;
		}

			public _IEnumerable_356(object seed, IFunction4 function)
			{
				this.seed = seed;
				this.function = function;
			}