Tabnine Logo
FilterDefinition
Code IndexAdd Tabnine to your IDE (free)

How to use
FilterDefinition
in
org.hibernate.engine.spi

Best Java code snippets using org.hibernate.engine.spi.FilterDefinition (Showing top 20 results out of 315)

origin: hibernate/hibernate-orm

new FilterDefinition(
    jaxbFilterDefinitionMapping.getName(),
    condition,
origin: hibernate/hibernate-orm

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;
}
origin: hibernate/hibernate-orm

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 );
}
origin: hibernate/hibernate-orm

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

origin: hibernate/hibernate-orm

/**
 * 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;
}
origin: org.hibernate/com.springsource.org.hibernate

filterDefaultConditionsByName.put( filterDefinition.getFilterName(), filterDefinition.getDefaultFilterCondition() );
origin: hibernate/hibernate-orm

  /**
   * 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"
        );
      }
    }
  }
}
origin: hibernate/hibernate-orm

  /**
   * 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;
  }
}
origin: hibernate/hibernate-orm

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

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;
}
origin: org.hibernate/com.springsource.org.hibernate.core

filterDefaultConditionsByName.put( filterDefinition.getFilterName(), filterDefinition.getDefaultFilterCondition() );
origin: org.hibernate/com.springsource.org.hibernate

  /**
   * 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"
        );
      }
    }
  }
}
origin: org.hibernate/com.springsource.org.hibernate

  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;
  }
}
origin: riotfamily/riot

public void afterPropertiesSet() {
  this.filterDefinition =
      new FilterDefinition(this.filterName, this.defaultFilterCondition, this.parameterTypeMap);
}
origin: org.hibernate/com.springsource.org.hibernate.core

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 );
}
origin: hibernate/hibernate-orm

@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 );
}
origin: hibernate/hibernate-orm

/**
 * 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;
}
origin: hibernate/hibernate-orm

final FilterDefinition filterDefinition = mappingDocument.getMetadataCollector().getFilterDefinition( filterSource.getName() );
if ( filterDefinition != null ) {
  condition = filterDefinition.getDefaultFilterCondition();
origin: org.hibernate/com.springsource.org.hibernate.core

  /**
   * 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"
        );
      }
    }
  }
}
origin: org.hibernate/com.springsource.org.hibernate.core

  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;
  }
}
org.hibernate.engine.spiFilterDefinition

Javadoc

A FilterDefinition defines the global attributes of a dynamic filter. This information includes its name as well as its defined parameters (name and type).

Most used methods

  • <init>
    Construct a new FilterDefinition instance.
  • getDefaultFilterCondition
  • getFilterName
    Get the name of the filter this configuration defines.
  • getParameterNames
    Get a set of the parameters defined by this configuration.
  • getParameterType
    Retrieve the type of the named parameter defined for this filter.
  • getParameterTypes

Popular in Java

  • Reactive rest calls using spring rest template
  • getSharedPreferences (Context)
  • getSystemService (Context)
  • scheduleAtFixedRate (ScheduledExecutorService)
  • FlowLayout (java.awt)
    A flow layout arranges components in a left-to-right flow, much like lines of text in a paragraph. F
  • FileOutputStream (java.io)
    An output stream that writes bytes to a file. If the output file exists, it can be replaced or appen
  • URI (java.net)
    A Uniform Resource Identifier that identifies an abstract or physical resource, as specified by RFC
  • JFrame (javax.swing)
  • JTable (javax.swing)
  • IsNull (org.hamcrest.core)
    Is the value null?
  • Top 17 Plugins for Android Studio
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now