org.terracotta.context.query.Matcher Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of ehcache Show documentation

Ehcache is an open source, standards-based cache used to boost performance, offload the database and simplify scalability. Ehcache is robust, proven and full-featured and this has made it the most widely-used Java-based cache.

There is a newer version: 2.10.9.2

Show newest version

/*
 * All content copyright Terracotta, Inc., unless otherwise indicated.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.terracotta.context.query;

import java.lang.reflect.Method;

/**
 * A matching object that can be used to filter the node-set in a context query
 * chain.
 * 
 * @param  the enclosing type of the objects that match
 */
public abstract class Matcher {
  
  private Class boundType = (Class) getSafeType(getClass());
   
  private static > Class getSafeType(Class fromClass) {
    for (Class c = fromClass; c != Object.class; c = c.getSuperclass()) {
        for (Method method : c.getDeclaredMethods()) {
            if (method.getName().equals("matchesSafely")
              && method.getParameterTypes().length == 1
              && !method.isSynthetic()) {
                return method.getParameterTypes()[0];
            }
        }
    }
    throw new AssertionError();
  }

  /**
   * Returns true if this object matches successfully.
   * 
   * This method checks for a type match against the erased type of this matcher
   * and then defers to the {@link #matchesSafely(Object)} of this matcher with the
   * type-checked and cast object.
   * 
   * @param object object to be checked
   * @return {@code true} if the object matches
   */
  public final boolean matches(Object object) {
    if (boundType.isAssignableFrom(object.getClass())) {
      return matchesSafely(boundType.cast(object));
    } else {
      return false;
    }
  }
  
  /**
   * Returns {@code true} if the supplied object matches against this matcher.
   * 
   * @param object object to check for a match
   * @return {@code true} on a match
   */
  protected abstract boolean matchesSafely(T object);
}