public LoadQueryInfluencers() 
{
	  
		this( null, java.util.Collections.EMPTY_MAP, java.util.Collections.EMPTY_SET );
}

 public LoadQueryInfluencers(SessionFactoryImplementor sessionFactory) 
{
		this( sessionFactory, new HashMap(), new HashSet() );
}

 public  void disableFetchProfile(String name) throws UnknownProfileException 
{
		checkFetchProfileName( name );
		enabledFetchProfileNames.remove( name );
}

 public  void disableFilter(String filterName) 
{
		enabledFilters.remove( filterName );
}

 public  void enableFetchProfile(String name) throws UnknownProfileException 
{
		checkFetchProfileName( name );
		enabledFetchProfileNames.add( name );
}

 public Filter enableFilter(String filterName) 
{
		FilterImpl filter = new FilterImpl( sessionFactory.getFilterDefinition( filterName ) );
		enabledFilters.put( filterName, filter );
		return filter;
}

 public Set getEnabledFetchProfileNames() 
{
		return enabledFetchProfileNames;
}

 public Filter getEnabledFilter(String filterName) 
{
		return ( Filter ) enabledFilters.get( filterName );
}

 public Map getEnabledFilters() 
{
		// First, validate all the enabled filters...
		//TODO: this implementation has bad performance
		Iterator itr = enabledFilters.values().iterator();
		while ( itr.hasNext() ) {
			final Filter filter = ( Filter ) itr.next();
			filter.validate();
		}
		return enabledFilters;
}

 public Type getFilterParameterType(String filterParameterName) 
{
		String[] parsed = parseFilterParameterName( filterParameterName );
		FilterDefinition filterDef = sessionFactory.getFilterDefinition( parsed[0] );
		if ( filterDef == null ) {
			throw new IllegalArgumentException( "Filter [" + parsed[0] + "] not defined" );
		}
		Type type = filterDef.getParameterType( parsed[1] );
		if ( type == null ) {
			// this is an internal error of some sort...
			throw new InternalError( "Unable to locate type for filter parameter" );
		}
		return type;
}

 public Object getFilterParameterValue(String filterParameterName) 
{
		String[] parsed = parseFilterParameterName( filterParameterName );
		FilterImpl filter = ( FilterImpl ) enabledFilters.get( parsed[0] );
		if ( filter == null ) {
			throw new IllegalArgumentException( "Filter [" + parsed[0] + "] currently not enabled" );
		}
		return filter.getParameter( parsed[1] );
}

 public String getInternalFetchProfile() 
{
		return internalFetchProfile;
}

 public SessionFactoryImplementor getSessionFactory() 
{
		return sessionFactory;
}

 public boolean hasEnabledFetchProfiles() 
{
		return enabledFetchProfileNames != null && !enabledFetchProfileNames.isEmpty();
}

 public boolean hasEnabledFilters() 
{
		return enabledFilters != null && !enabledFilters.isEmpty();
}

 public boolean isFetchProfileEnabled(String name) throws UnknownProfileException 
{
		checkFetchProfileName( name );
		return enabledFetchProfileNames.contains( name );
}

 public static String[] parseFilterParameterName(String filterParameterName) 
{
		int dot = filterParameterName.indexOf( '." );
		if ( dot < = 0 ) {
			throw new IllegalArgumentException( "Invalid filter-parameter name format" );
		}
		String filterName = filterParameterName.substring( 0, dot );
		String parameterName = filterParameterName.substring( dot + 1 );
		return new String[] { filterName, parameterName };
}

 public  void setInternalFetchProfile(String internalFetchProfile) 
{
		if ( sessionFactory == null ) {
			// thats the signal that this is the immutable, context-less
			// variety
			throw new IllegalStateException( "Cannot modify context-less LoadQueryInfluencers" );
		}
		this.internalFetchProfile = internalFetchProfile;
}