How to use

FilterDefinition

in

org.hibernate.engine.spi

new FilterDefinition(
    jaxbFilterDefinitionMapping.getName(),
    condition,

private String getCondition(String cond, String name) {
  if ( BinderHelper.isEmptyAnnotationValue( cond ) ) {
    cond = buildingContext.getMetadataCollector().getFilterDefinition( name ).getDefaultFilterCondition();
    if ( StringHelper.isEmpty( cond ) ) {
      throw new AnnotationException(
          "no filter condition found for filter " + name + " in "
              + StringHelper.qualify( propertyHolder.getPath(), propertyName )
      );
    }
  }
  return cond;
}

private static void bindFilterDef(FilterDef defAnn, MetadataBuildingContext context) {
  Map<String, org.hibernate.type.Type> params = new HashMap<>();
  for ( ParamDef param : defAnn.parameters() ) {
    params.put( param.name(), context.getMetadataCollector().getTypeResolver().heuristicType( param.type() ) );
  }
  FilterDefinition def = new FilterDefinition( defAnn.name(), defAnn.defaultCondition(), params );
  LOG.debugf( "Binding filter definition: %s", def.getFilterName() );
  context.getMetadataCollector().addFilterDefinition( def );
}

/**
 * Get the name of this filter.
 *
 * @return This filter's name.
 */
public String getName() {
  return definition.getFilterName();
}

/**
 * Set the named parameter's value for this filter.
 *
 * @param name The parameter's name.
 * @param value The value to be applied.
 * @return This FilterImpl instance (for method chaining).
 * @throws IllegalArgumentException Indicates that either the parameter was undefined or that the type
 * of the passed value did not match the configured type.
 */
public Filter setParameter(String name, Object value) throws IllegalArgumentException {
  // Make sure this is a defined parameter and check the incoming value type
  // TODO: what should be the actual exception type here?
  Type type = definition.getParameterType( name );
  if ( type == null ) {
    throw new IllegalArgumentException( "Undefined filter parameter [" + name + "]" );
  }
  if ( value != null && !type.getReturnedClass().isAssignableFrom( value.getClass() ) ) {
    throw new IllegalArgumentException( "Incorrect type for parameter [" + name + "]" );
  }
  parameters.put( name, value );
  return this;
}

filterDefaultConditionsByName.put( filterDefinition.getFilterName(), filterDefinition.getDefaultFilterCondition() );

  /**
   * Perform validation of the filter state.  This is used to verify the
   * state of the filter after its enablement and before its use.
   *
   * @throws HibernateException If the state is not currently valid.
   */
  public void validate() throws HibernateException {
    // for each of the defined parameters, make sure its value
    // has been set

    for ( final String parameterName : definition.getParameterNames() ) {
      if ( parameters.get( parameterName ) == null ) {
        throw new HibernateException(
            "Filter [" + getName() + "] parameter [" + parameterName + "] value not set"
        );
      }
    }
  }
}

  /**
   * Constructs a number of FilterKey instances, given the currently enabled filters
   *
   * @param enabledFilters The currently enabled filters
   *
   * @return The filter keys, one per enabled filter
   */
  public static Set<FilterKey> createFilterKeys(Map<String,Filter> enabledFilters) {
    if ( enabledFilters.size() == 0 ) {
      return null;
    }
    final Set<FilterKey> result = new HashSet<FilterKey>();
    for ( Filter filter : enabledFilters.values() ) {
      final FilterKey key = new FilterKey(
          filter.getName(),
          ( (FilterImpl) filter ).getParameters(),
          filter.getFilterDefinition().getParameterTypes()
      );
      result.add( key );
    }
    return result;
  }
}

/**
 * Constructs a new FilterImpl.
 *
 * @param configuration The filter's global configuration.
 */
public FilterImpl(FilterDefinition configuration) {
  this.definition = configuration;
  filterName = definition.getFilterName();
}

public Type getFilterParameterType(String filterParameterName) {
  final String[] parsed = parseFilterParameterName( filterParameterName );
  final FilterDefinition filterDef = sessionFactory.getFilterDefinition( parsed[0] );
  if ( filterDef == null ) {
    throw new IllegalArgumentException( "Filter [" + parsed[0] + "] not defined" );
  }
  final 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;
}

filterDefaultConditionsByName.put( filterDefinition.getFilterName(), filterDefinition.getDefaultFilterCondition() );

  /**
   * Perform validation of the filter state.  This is used to verify the
   * state of the filter after its enablement and before its use.
   *
   * @throws HibernateException If the state is not currently valid.
   */
  public void validate() throws HibernateException {
    // for each of the defined parameters, make sure its value
    // has been set
    Iterator itr = definition.getParameterNames().iterator();
    while ( itr.hasNext() ) {
      final String parameterName = (String) itr.next();
      if ( parameters.get( parameterName ) == null ) {
        throw new HibernateException(
            "Filter [" + getName() + "] parameter [" + parameterName + "] value not set"
        );
      }
    }
  }
}

  public static Set<FilterKey> createFilterKeys(Map<String,Filter> enabledFilters) {
    if ( enabledFilters.size()==0 ) {
      return null;
    }
    Set<FilterKey> result = new HashSet<FilterKey>();
    for ( Filter filter : enabledFilters.values() ) {
      FilterKey key = new FilterKey(
          filter.getName(),
          ( (FilterImpl) filter ).getParameters(),
          filter.getFilterDefinition().getParameterTypes()
      );
      result.add( key );
    }
    return result;
  }
}

public void afterPropertiesSet() {
  this.filterDefinition =
      new FilterDefinition(this.filterName, this.defaultFilterCondition, this.parameterTypeMap);
}

private static void bindFilterDef(FilterDef defAnn, Mappings mappings) {
  Map<String, org.hibernate.type.Type> params = new HashMap<String, org.hibernate.type.Type>();
  for ( ParamDef param : defAnn.parameters() ) {
    params.put( param.name(), mappings.getTypeResolver().heuristicType( param.type() ) );
  }
  FilterDefinition def = new FilterDefinition( defAnn.name(), defAnn.defaultCondition(), params );
  LOG.debugf( "Binding filter definition: %s", def.getFilterName() );
  mappings.addFilterDefinition( def );
}

@Override
public void addFilterDefinition(FilterDefinition filterDefinition) {
  if ( filterDefinition == null || filterDefinition.getFilterName() == null ) {
    throw new IllegalArgumentException( "Filter definition object or name is null: "  + filterDefinition );
  }
  filterDefinitionMap.put( filterDefinition.getFilterName(), filterDefinition );
}

/**
 * Set the named parameter's value list for this filter.  Used
 * in conjunction with IN-style filter criteria.
 *
 * @param name   The parameter's name.
 * @param values The values to be expanded into an SQL IN list.
 * @return This FilterImpl instance (for method chaining).
 */
public Filter setParameterList(String name, Collection values) throws HibernateException  {
  // Make sure this is a defined parameter and check the incoming value type
  if ( values == null ) {
    throw new IllegalArgumentException( "Collection must be not null!" );
  }
  Type type = definition.getParameterType( name );
  if ( type == null ) {
    throw new HibernateException( "Undefined filter parameter [" + name + "]" );
  }
  if ( !values.isEmpty() ) {
    Class elementClass = values.iterator().next().getClass();
    if ( !type.getReturnedClass().isAssignableFrom( elementClass ) ) {
      throw new HibernateException( "Incorrect type for parameter [" + name + "]" );
    }
  }
  parameters.put( name, values );
  return this;
}

final FilterDefinition filterDefinition = mappingDocument.getMetadataCollector().getFilterDefinition( filterSource.getName() );
if ( filterDefinition != null ) {
  condition = filterDefinition.getDefaultFilterCondition();

  /**
   * Perform validation of the filter state.  This is used to verify the
   * state of the filter after its enablement and before its use.
   *
   * @throws HibernateException If the state is not currently valid.
   */
  public void validate() throws HibernateException {
    // for each of the defined parameters, make sure its value
    // has been set
    Iterator itr = definition.getParameterNames().iterator();
    while ( itr.hasNext() ) {
      final String parameterName = (String) itr.next();
      if ( parameters.get( parameterName ) == null ) {
        throw new HibernateException(
            "Filter [" + getName() + "] parameter [" + parameterName + "] value not set"
        );
      }
    }
  }
}

  public static Set<FilterKey> createFilterKeys(Map<String,Filter> enabledFilters) {
    if ( enabledFilters.size()==0 ) {
      return null;
    }
    Set<FilterKey> result = new HashSet<FilterKey>();
    for ( Filter filter : enabledFilters.values() ) {
      FilterKey key = new FilterKey(
          filter.getName(),
          ( (FilterImpl) filter ).getParameters(),
          filter.getFilterDefinition().getParameterTypes()
      );
      result.add( key );
    }
    return result;
  }
}