org.apache.lucene.util.AttributeImpl.reflectWith java code examples

Common ways to obtain AttributeImpl

private void myMethod () {
 AttributeImpl a =Object object;(AttributeImpl) object.clone()
AttributeFactory attributeFactory;Class attClass;attributeFactory.createAttributeInstance(attClass)
ClassValue classValue;Class type;(AttributeImpl) classValue.get(type).invokeExact()
Smart code suggestions by Tabnine
}

/**
 * This method is for introspection of attributes, it should simply
 * add the key/values this AttributeSource holds to the given {@link AttributeReflector}.
 *
 * <p>This method iterates over all Attribute implementations and calls the
 * corresponding {@link AttributeImpl#reflectWith} method.</p>
 *
 * @see AttributeImpl#reflectWith
 */
public final void reflectWith(AttributeReflector reflector) {
 for (State state = getCurrentState(); state != null; state = state.next) {
  state.attribute.reflectWith(reflector);
 }
}

/**
 * This method returns the current attribute values as a string in the following format
 * by calling the {@link #reflectWith(AttributeReflector)} method:
 * 
 * <ul>
 * <li><em>iff {@code prependAttClass=true}:</em> {@code "AttributeClass#key=value,AttributeClass#key=value"}
 * <li><em>iff {@code prependAttClass=false}:</em> {@code "key=value,key=value"}
 * </ul>
 *
 * @see #reflectWith(AttributeReflector)
 */
public final String reflectAsString(final boolean prependAttClass) {
 final StringBuilder buffer = new StringBuilder();
 reflectWith((attClass, key, value) -> {
  if (buffer.length() > 0) {
   buffer.append(',');
  }
  if (prependAttClass) {
   buffer.append(attClass.getName()).append('#');
  }
  buffer.append(key).append('=').append((value == null) ? "null" : value);
 });
 return buffer.toString();
}

/**
 * This method returns the current attribute values as a string in the following format
 * by calling the {@link #reflectWith(AttributeReflector)} method:
 * 
 * <ul>
 * <li><em>iff {@code prependAttClass=true}:</em> {@code "AttributeClass#key=value,AttributeClass#key=value"}
 * <li><em>iff {@code prependAttClass=false}:</em> {@code "key=value,key=value"}
 * </ul>
 *
 * @see #reflectWith(AttributeReflector)
 */
public final String reflectAsString(final boolean prependAttClass) {
 final StringBuilder buffer = new StringBuilder();
 reflectWith(new AttributeReflector() {
  @Override
  public void reflect(Class<? extends Attribute> attClass, String key, Object value) {
   if (buffer.length() > 0) {
    buffer.append(',');
   }
   if (prependAttClass) {
    buffer.append(attClass.getName()).append('#');
   }
   buffer.append(key).append('=').append((value == null) ? "null" : value);
  }
 });
 return buffer.toString();
}

/**
 * This method is for introspection of attributes, it should simply
 * add the key/values this AttributeSource holds to the given {@link AttributeReflector}.
 *
 * <p>This method iterates over all Attribute implementations and calls the
 * corresponding {@link AttributeImpl#reflectWith} method.</p>
 *
 * @see AttributeImpl#reflectWith
 */
public final void reflectWith(AttributeReflector reflector) {
 for (State state = getCurrentState(); state != null; state = state.next) {
  state.attribute.reflectWith(reflector);
 }
}

/**
 * This method is for introspection of attributes, it should simply
 * add the key/values this AttributeSource holds to the given {@link AttributeReflector}.
 *
 * <p>This method iterates over all Attribute implementations and calls the
 * corresponding {@link AttributeImpl#reflectWith} method.</p>
 *
 * @see AttributeImpl#reflectWith
 */
public final void reflectWith(AttributeReflector reflector) {
 for (State state = getCurrentState(); state != null; state = state.next) {
  state.attribute.reflectWith(reflector);
 }
}

/**
 * This method returns the current attribute values as a string in the following format
 * by calling the {@link #reflectWith(AttributeReflector)} method:
 * 
 * <ul>
 * <li><em>iff {@code prependAttClass=true}:</em> {@code "AttributeClass#key=value,AttributeClass#key=value"}
 * <li><em>iff {@code prependAttClass=false}:</em> {@code "key=value,key=value"}
 * </ul>
 *
 * @see #reflectWith(AttributeReflector)
 */
public final String reflectAsString(final boolean prependAttClass) {
 final StringBuilder buffer = new StringBuilder();
 reflectWith(new AttributeReflector() {
  @Override
  public void reflect(Class<? extends Attribute> attClass, String key, Object value) {
   if (buffer.length() > 0) {
    buffer.append(',');
   }
   if (prependAttClass) {
    buffer.append(attClass.getName()).append('#');
   }
   buffer.append(key).append('=').append((value == null) ? "null" : value);
  }
 });
 return buffer.toString();
}

/**
 * This method returns the current attribute values as a string in the following format
 * by calling the {@link #reflectWith(AttributeReflector)} method:
 * 
 * <ul>
 * <li><em>iff {@code prependAttClass=true}:</em> {@code "AttributeClass#key=value,AttributeClass#key=value"}
 * <li><em>iff {@code prependAttClass=false}:</em> {@code "key=value,key=value"}
 * </ul>
 *
 * @see #reflectWith(AttributeReflector)
 */
public final String reflectAsString(final boolean prependAttClass) {
 final StringBuilder buffer = new StringBuilder();
 reflectWith(new AttributeReflector() {
  @Override
  public void reflect(Class<? extends Attribute> attClass, String key, Object value) {
   if (buffer.length() > 0) {
    buffer.append(',');
   }
   if (prependAttClass) {
    buffer.append(attClass.getName()).append('#');
   }
   buffer.append(key).append('=').append((value == null) ? "null" : value);
  }
 });
 return buffer.toString();
}

/**
 * This method is for introspection of attributes, it should simply
 * add the key/values this AttributeSource holds to the given {@link AttributeReflector}.
 *
 * <p>This method iterates over all Attribute implementations and calls the
 * corresponding {@link AttributeImpl#reflectWith} method.</p>
 *
 * @see AttributeImpl#reflectWith
 */
public final void reflectWith(AttributeReflector reflector) {
 for (State state = getCurrentState(); state != null; state = state.next) {
  state.attribute.reflectWith(reflector);
 }
}

/**
 * This method is for introspection of attributes, it should simply
 * add the key/values this AttributeSource holds to the given {@link AttributeReflector}.
 *
 * <p>This method iterates over all Attribute implementations and calls the
 * corresponding {@link AttributeImpl#reflectWith} method.</p>
 *
 * @see AttributeImpl#reflectWith
 */
public final void reflectWith(AttributeReflector reflector) {
 for (State state = getCurrentState(); state != null; state = state.next) {
  state.attribute.reflectWith(reflector);
 }
}

/**
 * This method returns the current attribute values as a string in the following format
 * by calling the {@link #reflectWith(AttributeReflector)} method:
 * 
 * <ul>
 * <li><em>iff {@code prependAttClass=true}:</em> {@code "AttributeClass#key=value,AttributeClass#key=value"}
 * <li><em>iff {@code prependAttClass=false}:</em> {@code "key=value,key=value"}
 * </ul>
 *
 * @see #reflectWith(AttributeReflector)
 */
public final String reflectAsString(final boolean prependAttClass) {
 final StringBuilder buffer = new StringBuilder();
 reflectWith((attClass, key, value) -> {
  if (buffer.length() > 0) {
   buffer.append(',');
  }
  if (prependAttClass) {
   buffer.append(attClass.getName()).append('#');
  }
  buffer.append(key).append('=').append((value == null) ? "null" : value);
 });
 return buffer.toString();
}

Javadoc

This method is for introspection of attributes, it should simply add the key/values this attribute holds to the given AttributeReflector.

The default implementation calls AttributeReflector#reflect for all non-static fields from the implementing class, using the field name as key and the field value as value. The Attribute class is also determined by reflection. Please note that the default implementation can only handle single-Attribute implementations.

Custom implementations look like this (e.g. for a combined attribute implementation):

 
public void reflectWith(AttributeReflector reflector) { 
reflector.reflect(CharTermAttribute.class, "term", term()); 
reflector.reflect(PositionIncrementAttribute.class, "positionIncrement", getPositionIncrement()); 
}

If you implement this method, make sure that for each invocation, the same set of Attributeinterfaces and keys are passed to AttributeReflector#reflect in the same order, but possibly different values. So don't automatically exclude e.g. null properties!

Popular methods of AttributeImpl

clear
Clears the values in this AttributeImpl and resets it to its default value. If this implementation i
clone
In most cases the clone is, and should be, deep in order to be able to properly capture the state of
copyTo
Copies the values from this Attribute into the passed-in target attribute. The target implementation
end
Clears the values in this AttributeImpl and resets it to its value at the end of the field. If this

Popular in Java

Parsing JSON documents to java classes using gson
onRequestPermissionsResult (Fragment)
notifyDataSetChanged (ArrayAdapter)
startActivity (Activity)
GridBagLayout (java.awt)
The GridBagLayout class is a flexible layout manager that aligns components vertically and horizonta
Rectangle (java.awt)
A Rectangle specifies an area in a coordinate space that is enclosed by the Rectangle object's top-
GregorianCalendar (java.util)
GregorianCalendar is a concrete subclass of Calendarand provides the standard calendar used by most
List (java.util)
An ordered collection (also known as a sequence). The user of this interface has precise control ove
ThreadPoolExecutor (java.util.concurrent)
An ExecutorService that executes each submitted task using one of possibly several pooled threads, n
ServletException (javax.servlet)
Defines a general exception a servlet can throw when it encounters difficulty.
PhpStorm for WordPress

How to use reflectWithmethodin org.apache.lucene.util.AttributeImpl

Best Java code snippets using org.apache.lucene.util.AttributeImpl.reflectWith (Showing top 10 results out of 315)

How to use
reflectWith
method
in
org.apache.lucene.util.AttributeImpl