public virtual void EnableTransparentPersistenceSupportFor(IInternalObjectContainer
			 container, IRollbackStrategy rollbackStrategy)
		{
			FlushOnQueryStarted(container);
			_rollbackStrategy = rollbackStrategy;
			_transparentPersistenceIsEnabled = true;
		}

		public void Apply(IInternalObjectContainer container)
		{
#if NET_3_5
			My<LinqQueryMonitor>.Instance.Initialize();
#endif

			IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(container);
			
			PerformanceCounter unoptimizedNativeQueriesPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.UnoptimizedNativeQueriesPerSec, false);
			PerformanceCounter nativeQueriesPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.NativeQueriesPerSec, false);
			container.GetNativeQueryHandler().QueryExecution += delegate(object sender, QueryExecutionEventArgs args)
			{
				if (args.ExecutionKind == QueryExecutionKind.Unoptimized)
					unoptimizedNativeQueriesPerSec.Increment();

				nativeQueriesPerSec.Increment();
			};

			eventRegistry.Closing += delegate
			{
				nativeQueriesPerSec.RemoveInstance();

				nativeQueriesPerSec.Dispose();
				unoptimizedNativeQueriesPerSec.Dispose();

#if NET_3_5
				container.WithEnvironment(delegate
				{
					My<LinqQueryMonitor>.Instance.Dispose();
				});
#endif
			};
		}

		// Nothing to do...
		/// <summary>internal method, public for implementation reasons.</summary>
		/// <remarks>internal method, public for implementation reasons.</remarks>
		public virtual void Apply(IInternalObjectContainer objectContainer)
		{
			if (objectContainer.IsClient)
			{
				throw new InvalidOperationException(GetType().FullName + " should be configured on the server."
					);
			}
			EventRegistryFactory.ForObjectContainer(objectContainer).Committing += new System.EventHandler<Db4objects.Db4o.Events.CommitEventArgs>
				(new _IEventListener4_46(this, objectContainer).OnEvent);
		}

        public void Apply(IInternalObjectContainer container)
        {
            PerformanceCounter storedObjectsPerSec =
                Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ObjectsStoredPerSec, false);
            PerformanceCounter activatedObjectsPerSec =
                Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ObjectsActivatedPerSec, false);
            PerformanceCounter deactivatedObjectsPerSec =
                Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ObjectsDeactivatedPerSec, false);
            IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(container);

            EventHandler<ObjectInfoEventArgs> eventHandler = delegate
                                       {
                                           storedObjectsPerSec.Increment();
                                       };
            eventRegistry.Created += eventHandler;
            eventRegistry.Updated += eventHandler;

            eventRegistry.Activated += delegate
                                           {
                                               activatedObjectsPerSec.Increment();
                                           };
            eventRegistry.Deactivated += delegate
                                             {
                                                 deactivatedObjectsPerSec.Increment();
                                             };

            eventRegistry.Closing += delegate
                                        {
                                            storedObjectsPerSec.Dispose();
                                            activatedObjectsPerSec.Dispose();
                                            deactivatedObjectsPerSec.Dispose();

                                            storedObjectsPerSec.RemoveInstance();
                                        };
            if (container.IsClient)
            {
                return;
            }

            PerformanceCounter deletedObjectsPerSec =
                Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ObjectsDeletedPerSec, false);
            eventRegistry.Deleted += delegate
                                         {
                                             deletedObjectsPerSec.Increment();
                                         };

            eventRegistry.Closing += delegate
            {
                deletedObjectsPerSec.Dispose();
            };



        }

 // Nothing to do...
 /// <summary>
 ///     Configures the just opened ObjectContainer by setting event listeners,
 ///     which will be triggered when activation or de-activation is required.
 /// </summary>
 /// <remarks>
 ///     Configures the just opened ObjectContainer by setting event listeners,
 ///     which will be triggered when activation or de-activation is required.
 /// </remarks>
 /// <param name="container">the ObjectContainer to configure</param>
 /// <seealso cref="TransparentPersistenceSupport.Apply(Db4objects.Db4o.Internal.IInternalObjectContainer)
 /// 	">
 ///     TransparentPersistenceSupport.Apply(Db4objects.Db4o.Internal.IInternalObjectContainer)
 /// </seealso>
 public virtual void Apply(IInternalObjectContainer container)
 {
     if (IsTransparentActivationEnabledOn(container))
     {
         return;
     }
     var provider = new TransparentActivationDepthProviderImpl
         ();
     SetActivationDepthProvider(container, provider);
     var registry = EventRegistryFor(container);
     registry.Instantiated += new _IEventListener4_45(this).OnEvent;
     registry.Created += new _IEventListener4_50(this).OnEvent;
     registry.Closing += new _IEventListener4_56(this).OnEvent;
     var processor = new TADiagnosticProcessor
         (this, container);
     registry.ClassRegistered += new _IEventListener4_67(processor).OnEvent;
 }

        public void Apply(IInternalObjectContainer container)
        {
            if (!(container is LocalObjectContainer) || container.ConfigImpl.IsReadOnly())
            {
                return;
            }
            var localObjectContainer = (LocalObjectContainer) container;
            var freespaceManager = localObjectContainer.FreespaceManager();
            var freespaceListener = new FreespaceListener(localObjectContainer);
            freespaceManager.Traverse(new FreespaceInitializingVisitor(freespaceListener));

            var eventRegistry = EventRegistryFactory.ForObjectContainer(container);
            eventRegistry.Closing += delegate
            {
                freespaceListener.Dispose();
                freespaceManager.Listener(NullFreespaceListener.Instance);
            };

            freespaceManager.Listener(freespaceListener);
        }

		// Nothing to do...
		/// <summary>
		/// Configures the just opened ObjectContainer by setting event listeners,
		/// which will be triggered when activation or de-activation is required.
		/// </summary>
		/// <remarks>
		/// Configures the just opened ObjectContainer by setting event listeners,
		/// which will be triggered when activation or de-activation is required.
		/// </remarks>
		/// <param name="container">the ObjectContainer to configure</param>
		/// <seealso cref="TransparentPersistenceSupport.Apply(Db4objects.Db4o.Internal.IInternalObjectContainer)
		/// 	">TransparentPersistenceSupport.Apply(Db4objects.Db4o.Internal.IInternalObjectContainer)
		/// 	</seealso>
		public virtual void Apply(IInternalObjectContainer container)
		{
			if (IsTransparentActivationEnabledOn(container))
			{
				return;
			}
			TransparentActivationDepthProviderImpl provider = new TransparentActivationDepthProviderImpl
				();
			SetActivationDepthProvider(container, provider);
			IEventRegistry registry = EventRegistryFor(container);
			registry.Instantiated += new System.EventHandler<Db4objects.Db4o.Events.ObjectInfoEventArgs>
				(new _IEventListener4_45(this).OnEvent);
			registry.Created += new System.EventHandler<Db4objects.Db4o.Events.ObjectInfoEventArgs>
				(new _IEventListener4_50(this).OnEvent);
			registry.Closing += new System.EventHandler<Db4objects.Db4o.Events.ObjectContainerEventArgs>
				(new _IEventListener4_56(this).OnEvent);
			TransparentActivationSupport.TADiagnosticProcessor processor = new TransparentActivationSupport.TADiagnosticProcessor
				(this, container);
			registry.ClassRegistered += new System.EventHandler<Db4objects.Db4o.Events.ClassEventArgs>
				(new _IEventListener4_67(processor).OnEvent);
		}

		private void SetActivationDepthProvider(IInternalObjectContainer container, IActivationDepthProvider
			 provider)
		{
			container.ConfigImpl.ActivationDepthProvider(provider);
		}

		internal Db4oSignatureMap(IInternalObjectContainer stream)
		{
			_stream = stream;
			_identities = new Hashtable4();
		}

 public void Apply(IInternalObjectContainer container)
 {
     Assert.IsNotNull(container);
     _container = container;
 }

        public void Apply(IInternalObjectContainer container)
        {

        }

 public static ByteArrayBuffer WriteToBuffer(IInternalObjectContainer container, string
     str)
 {
     var buffer = new ByteArrayBuffer(StringIo(container).Length(str));
     InternalWrite(container, buffer, str);
     return buffer;
 }

		public void ApplyConfigurationItems(IInternalObjectContainer container)
		{
			Hashtable4 items = ConfigurationItems();
			if (items == null)
			{
				return;
			}
			IEnumerator i = items.Iterator();
			while (i.MoveNext())
			{
				IEntry4 entry = (IEntry4)i.Current;
				IConfigurationItem item = (IConfigurationItem)entry.Value();
				item.Apply(container);
			}
		}

		protected static IActivationDepthProvider ActivationProvider(IInternalObjectContainer
			 container)
		{
			return container.ConfigImpl.ActivationDepthProvider();
		}

			public void Apply(IInternalObjectContainer container)
			{
				Assert.AreEqual(ObjectContainerCustomNameTestCase.CustomName, container.ToString(
					));
			}

		public virtual void Apply(IInternalObjectContainer db)
		{
			EventRegistry(db).Updating += new System.EventHandler<Db4objects.Db4o.Events.CancellableObjectEventArgs>
				(new _IEventListener4_19().OnEvent);
		}

		public static bool InCallback(IInternalObjectContainer container)
		{
			if (container.Callbacks() is EventRegistryImpl)
			{
				EventRegistryImpl er = (EventRegistryImpl)container.Callbacks();
				return er._inCallback;
			}
			return false;
		}

		private ITypeHandler4 DetectElementTypeHandler(IInternalObjectContainer container
			, ICollection collection)
		{
			return (ITypeHandler4)container.Handlers.OpenTypeHandler();
		}

		private void FlushOnQueryStarted(IInternalObjectContainer container)
		{
			IEventRegistry registry = EventRegistryFactory.ForObjectContainer(container);
			registry.QueryStarted += new System.EventHandler<Db4objects.Db4o.Events.QueryEventArgs>
				(new _IEventListener4_46(this).OnEvent);
		}

		private void UnbindAll(IInternalObjectContainer container)
		{
			Db4objects.Db4o.Internal.Transaction transaction = container.Transaction;
			// FIXME should that ever happen?
			if (transaction == null)
			{
				return;
			}
			IReferenceSystem referenceSystem = transaction.ReferenceSystem();
			referenceSystem.TraverseReferences(new _IVisitor4_95(this));
		}