///<summary>
 ///</summary>
 ///<param name="entityName"></param>
 ///<param name="persistentClass"></param>
 ///<param name="id"></param>
 ///<param name="getIdentifierMethod"></param>
 ///<param name="setIdentifierMethod"></param>
 ///<param name="componentIdType"></param>
 ///<param name="session"></param>
 public LazyInitializer(string entityName, Type persistentClass, object id, MethodInfo getIdentifierMethod,
     MethodInfo setIdentifierMethod, IAbstractComponentType componentIdType,
     ISessionImplementor session)
     : base(entityName, persistentClass, id, getIdentifierMethod,
         setIdentifierMethod, componentIdType, session)
 {
 }

		public CompositeElementPropertyMapping(string[] elementColumns, string[] elementFormulaTemplates,
																					 IAbstractComponentType compositeType, IMapping factory)
		{
			this.compositeType = compositeType;

			InitComponentPropertyPaths(null, compositeType, elementColumns, elementFormulaTemplates, factory);
		}

    public void PostInstantiate(string entityName, Type persistentClass, ISet<Type> interfaces, MethodInfo getIdentifierMethod, MethodInfo setIdentifierMethod, IAbstractComponentType componentIdType)
    {
        _entityName = entityName;
        _persistentClass = persistentClass;
        _interfaces = new Type[interfaces.Count];
        interfaces.CopyTo(_interfaces, 0);
        _getIdentifierMethod = getIdentifierMethod;
        _setIdentifierMethod = setIdentifierMethod;
        _componentIdType = componentIdType;
        _isClassProxy = _interfaces.Length == 1;

        _proxyKey = entityName;

        if( _proxies.Contains(_proxyKey) )
        {
            _proxyType = _proxies[_proxyKey] as Type;
            _log.DebugFormat("Using proxy type '{0}' for persistent class '{1}'", _proxyType.Name, _persistentClass.FullName);
        }
        else
        {
            string message = string.Format("No proxy type found for persistent class '{0}' using proxy key '{1}'", _persistentClass.FullName, _proxyKey);
            _log.Error(message);
            throw new HibernateException(message);
        }
    }

		/// <summary>
		/// Visit a component. Dispatch each property to <see cref="ProcessValues"/>
		/// </summary>
		/// <param name="component"></param>
		/// <param name="componentType"></param>
		/// <returns></returns>
		internal virtual object ProcessComponent(object component, IAbstractComponentType componentType)
		{
			if (component != null)
			{
				ProcessValues(componentType.GetPropertyValues(component, session), componentType.Subtypes);
			}
			return null;
		}

		/// <summary> Constructs a new AbstractEntityTuplizer instance. </summary>
		/// <param name="entityMetamodel">The "interpreted" information relating to the mapped entity. </param>
		/// <param name="mappingInfo">The parsed "raw" mapping data relating to the given entity. </param>
		protected AbstractEntityTuplizer(EntityMetamodel entityMetamodel, PersistentClass mappingInfo)
		{
			this.entityMetamodel = entityMetamodel;

			if (!entityMetamodel.IdentifierProperty.IsVirtual)
			{
				idGetter = BuildPropertyGetter(mappingInfo.IdentifierProperty, mappingInfo);
				idSetter = BuildPropertySetter(mappingInfo.IdentifierProperty, mappingInfo);
			}
			else
			{
				idGetter = null;
				idSetter = null;
			}

			propertySpan = entityMetamodel.PropertySpan;

			getters = new IGetter[propertySpan];
			setters = new ISetter[propertySpan];

			bool foundCustomAccessor = false;
			int i = 0;
			foreach (Mapping.Property property in mappingInfo.PropertyClosureIterator)
			{
				getters[i] = BuildPropertyGetter(property, mappingInfo);
				setters[i] = BuildPropertySetter(property, mappingInfo);
				if (!property.IsBasicPropertyAccessor)
					foundCustomAccessor = true;
				i++;				
			}
			if (log.IsDebugEnabled)
			{
				log.DebugFormat("{0} accessors found for entity: {1}", foundCustomAccessor ? "Custom" : "No custom",
				                mappingInfo.EntityName);
			}
			hasCustomAccessors = foundCustomAccessor;

			//NH-1587
			//instantiator = BuildInstantiator(mappingInfo);

			if (entityMetamodel.IsLazy)
			{
				proxyFactory = BuildProxyFactory(mappingInfo, idGetter, idSetter);
				if (proxyFactory == null)
				{
					entityMetamodel.IsLazy = false;
				}
			}
			else
			{
				proxyFactory = null;
			}

			Mapping.Component mapper = mappingInfo.IdentifierMapper;
			identifierMapperType = mapper == null ? null : (IAbstractComponentType)mapper.Type;
		}

		protected internal BasicLazyInitializer(string entityName, System.Type persistentClass, object id, 
			MethodInfo getIdentifierMethod, MethodInfo setIdentifierMethod, 
			IAbstractComponentType componentIdType, ISessionImplementor session)
			: base(entityName, id, session)
		{
			this.persistentClass = persistentClass;
			this.getIdentifierMethod = getIdentifierMethod;
			this.setIdentifierMethod = setIdentifierMethod;
			this.componentIdType = componentIdType;
			overridesEquals = ReflectHelper.OverridesEquals(persistentClass);
		}

		public virtual void PostInstantiate(string entityName, System.Type persistentClass, ISet<System.Type> interfaces,
		                                    MethodInfo getIdentifierMethod, MethodInfo setIdentifierMethod,
		                                    IAbstractComponentType componentIdType)
		{
			_entityName = entityName;
			_persistentClass = persistentClass;
			_interfaces = new System.Type[interfaces.Count];
			interfaces.CopyTo(_interfaces, 0);
			_getIdentifierMethod = getIdentifierMethod;
			_setIdentifierMethod = setIdentifierMethod;
			_componentIdType = componentIdType;
		}

 public PropertyChangedLazyInitializer(
     string entityName,
     Type persistentClass,
     object id,
     MethodInfo getIdentifierMethod,
     MethodInfo setIdentifierMethod,
     IAbstractComponentType componentIdType,
     ISessionImplementor session,
     bool entityHandlesPropertyChanged)
     : base(entityName, persistentClass, id, getIdentifierMethod, setIdentifierMethod, componentIdType, session)
 {
     _entityHandlesPropertyChanged = entityHandlesPropertyChanged;
 }

		internal override object ProcessComponent(object component, IAbstractComponentType componentType)
		{
			IType[] types = componentType.Subtypes;
			if (component == null)
			{
				ProcessValues(new object[types.Length], types);
			}
			else
			{
				base.ProcessComponent(component, componentType);
			}

			return null;
		}

		public void PostInstantiate(string entityName, System.Type persistentClass, ISet<System.Type> interfaces, MethodInfo getIdentifierMethod, MethodInfo setIdentifierMethod, IAbstractComponentType componentIdType)
		{
			if (persistentClass.IsGenericType) return;

			var interfacesCount = interfaces.Count;
			var ifaces = new System.Type[interfacesCount];
			if (interfacesCount > 0)
				interfaces.CopyTo(ifaces, 0);

			var proxyType = ifaces.Length == 1
								? factory.CreateProxyType(persistentClass, ifaces)
								: factory.CreateProxyType(ifaces[0], ifaces);

			proxies[entityName] = proxyType;
		}

		public virtual void PostInstantiate(string entityName, System.Type persistentClass, ISet<System.Type> interfaces,
																				MethodInfo getIdentifierMethod, MethodInfo setIdentifierMethod,
																				IAbstractComponentType componentIdType)
		{
			EntityName = entityName;
			PersistentClass = persistentClass;
			Interfaces = new System.Type[interfaces.Count];

			if (interfaces.Count > 0)
			{
				interfaces.CopyTo(Interfaces, 0);
			}

			GetIdentifierMethod = getIdentifierMethod;
			SetIdentifierMethod = setIdentifierMethod;
			ComponentIdType = componentIdType;
		}

        public void PostInstantiate(string entityName, Type persistentClass, ISet<Type> interfaces, MethodInfo getIdentifierMethod, MethodInfo setIdentifierMethod, IAbstractComponentType componentIdType)
        {
            if (persistentClass.IsGenericType) return;

            int interfacesCount = interfaces.Count;
            bool isClassProxy = interfacesCount == 1;
            Type[] ifaces = new Type[interfacesCount];
            interfaces.CopyTo(ifaces, 0);

            Type proxyType;
            if (isClassProxy)
            {
                proxyType = _proxyBuilder.CreateClassProxy(persistentClass, ifaces, ProxyGenerationOptions.Default);
            }
            else
            {
                proxyType = _proxyBuilder.CreateInterfaceProxyTypeWithoutTarget(ifaces[0], ifaces, ProxyGenerationOptions.Default);
            }

            _proxies[entityName] = proxyType;
        }

        internal override object ProcessComponent(object component, IAbstractComponentType componentType)
        {
            if (component != null)
            {
                object[] values = componentType.GetPropertyValues(component, Session);
                IType[] types = componentType.Subtypes;
                bool substituteComponent = false;
                for (int i = 0; i < types.Length; i++)
                {
                    System.Object result = ProcessValue(values[i], types[i]);
                    if (result != null)
                    {
                        values[i] = result;
                        substituteComponent = true;
                    }
                }
                if (substituteComponent)
                {
                    componentType.SetPropertyValues(component, values, Session.EntityMode);
                }
            }

            return null;
        }

		protected override object ProcessComponent(object component, IAbstractComponentType componentType)
		{
			if (component == null)
			{
				return null;
			}

			object[] values = componentType.GetPropertyValues(component, Session);
			IType[] types = componentType.Subtypes;
			bool substituteComponent = false;
			for (int i = 0; i < types.Length; i++)
			{
				object result = ProcessValue(values[i], types[i]);
				if (result != null)
				{
					substituteComponent = true;
					values[i] = result;
				}
			}

			if (substituteComponent)
			{
				componentType.SetPropertyValues(component, values);
			}

			return null;
		}

		public void PostInstantiate(string entityName, System.Type persistentClass, ISet<System.Type> interfaces,
																MethodInfo getIdentifierMethod, MethodInfo setIdentifierMethod,
																IAbstractComponentType componentIdType)
		{
			this.entityName = entityName;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="elementColumns"></param>
		/// <param name="compositeType"></param>
		/// <param name="factory"></param>
		public CompositeElementPropertyMapping( string[] elementColumns, IAbstractComponentType compositeType, ISessionFactoryImplementor factory )
		{
			this.compositeType = compositeType;

			InitComponentPropertyPaths( null, compositeType, elementColumns, factory );
		}

		protected void AddComponentTypedValues(string path, object component, IAbstractComponentType type, IList list, ICriteria criteria, ICriteriaQuery criteriaQuery)
		{
			if (component != null)
			{
				string[] propertyNames = type.PropertyNames;
				IType[] subtypes = type.Subtypes;
				object[] values = type.GetPropertyValues(component, GetEntityMode(criteria, criteriaQuery));

				for (int i = 0; i < propertyNames.Length; i++)
				{
					object value = values[i];
					IType subtype = subtypes[i];
					string subpath = StringHelper.Qualify(path, propertyNames[i]);
					if (IsPropertyIncluded(value, subpath, subtype))
					{
						if (subtype.IsComponentType)
						{
							AddComponentTypedValues(subpath, value, (IAbstractComponentType) subtype, list, criteria, criteriaQuery);
						}
						else
						{
							AddPropertyTypedValue(value, subtype, list);
						}
					}
				}
			}
		}

		/// <summary>
		/// For a composite element, add to a list of associations to be fetched by outerjoin
		/// </summary>
		private void WalkCompositeElementTree(IAbstractComponentType compositeType, string[] cols,
			IQueryableCollection persister, string alias, string path, int currentDepth)
		{
			IType[] types = compositeType.Subtypes;
			string[] propertyNames = compositeType.PropertyNames;
			int begin = 0;
			for (int i = 0; i < types.Length; i++)
			{
				int length = types[i].GetColumnSpan(factory);
				string[] lhsColumns = ArrayHelper.Slice(cols, begin, length);

				if (types[i].IsAssociationType)
				{
					IAssociationType associationType = types[i] as IAssociationType;

					// simple, because we can't have a one-to-one or collection
					// (or even a property-ref) in a composite element:
					string[] aliasedLhsColumns = StringHelper.Qualify(alias, lhsColumns);
					string subpath = SubPath(path, propertyNames[i]);
					bool[] propertyNullability = compositeType.PropertyNullability;

					JoinType joinType =
						GetJoinType(associationType, compositeType.GetFetchMode(i), subpath, persister.TableName, lhsColumns,
												propertyNullability == null || propertyNullability[i], currentDepth, compositeType.GetCascadeStyle(i));

					AddAssociationToJoinTreeIfNecessary(associationType, aliasedLhsColumns, alias, subpath, currentDepth, joinType);
				}
				else if (types[i].IsComponentType)
				{
					string subpath = SubPath(path, propertyNames[i]);
					WalkCompositeElementTree((IAbstractComponentType)types[i], lhsColumns, persister, alias, subpath, currentDepth);
				}
				begin += length;
			}
		}

 public DataBindingInterceptor(String EntityName, Type persistentClass, object id, MethodInfo getIdentifierMethod, MethodInfo setIdentifierMethod, IAbstractComponentType aType, ISessionImplementor session)
     : base(EntityName, persistentClass, id, getIdentifierMethod, setIdentifierMethod, aType, session)
 {
 }

		/// <summary> 
		/// Check component nullability. Returns property path that break
		/// nullability or null if none 
		/// </summary>
		/// <param name="value">component properties </param>
		/// <param name="compType">component not-nullable type </param>
		/// <returns> property path </returns>
		private string CheckComponentNullability(object value, IAbstractComponentType compType)
		{
			// will check current level if some of them are not null or sublevels if they exist
			bool[] nullability = compType.PropertyNullability;
			if (nullability != null)
			{
				//do the test
				object[] values = compType.GetPropertyValues(value, session.EntityMode);
				IType[] propertyTypes = compType.Subtypes;
				for (int i = 0; i < values.Length; i++)
				{
					object subvalue = values[i];
					if (!nullability[i] && subvalue == null)
					{
						return compType.PropertyNames[i];
					}
					else if (subvalue != null)
					{
						string breakProperties = CheckSubElementsNullability(propertyTypes[i], subvalue);
						if (breakProperties != null)
						{
							return BuildPropertyPath(compType.PropertyNames[i], breakProperties);
						}
					}
				}
			}
			return null;
		}