com.intellij.patterns.ObjectPattern Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of symbol-processing-aa Show documentation
KSP implementation on Kotlin Analysis API
There is a newer version: 2.1.0-Beta1-1.0.25
// Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.patterns;

import com.intellij.openapi.util.Key;
import com.intellij.util.PairProcessor;
import com.intellij.util.ProcessingContext;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

/**
 * @author peter
 */
public abstract class ObjectPattern> implements Cloneable, ElementPattern {
  private InitialPatternCondition myInitialCondition;
  private Object myConditions;

  protected ObjectPattern(@NotNull final InitialPatternCondition condition) {
    myInitialCondition = condition;
    myConditions = null;
  }

  protected ObjectPattern(@NotNull Class aClass) {
    this(new InitialPatternCondition(aClass) {
      @Override
      public boolean accepts(@Nullable final Object o, final ProcessingContext context) {
        return aClass.isInstance(o);
      }
    });
  }

  @Override
  public final boolean accepts(@Nullable Object t) {
    return accepts(t, new ProcessingContext());
  }

  @Override
  @SuppressWarnings("unchecked")
  public boolean accepts(@Nullable final Object o, final ProcessingContext context) {
    if (!myInitialCondition.accepts(o, context)) return false;
    if (myConditions == null) return true;
    if (o == null) return false;

    if (myConditions instanceof PatternCondition) {
      return ((PatternCondition)myConditions).accepts(o, context);
    }

    List> list = (List>)myConditions;
    final int listSize = list.size();
    //noinspection ForLoopReplaceableByForEach
    for (int i = 0; i < listSize; i++) {
      if (!list.get(i).accepts((T)o, context)) return false;
    }
    return true;
  }

  @Override
  @NotNull
  @SuppressWarnings("unchecked")
  public final ElementPatternCondition getCondition() {
    if (myConditions == null) {
      return new ElementPatternCondition<>(myInitialCondition);
    }
    if (myConditions instanceof PatternCondition) {
      PatternCondition singleCondition = (PatternCondition)myConditions;
      return new ElementPatternCondition<>(myInitialCondition, Collections.singletonList(singleCondition));
    }
    return new ElementPatternCondition<>(myInitialCondition, (List)myConditions);
  }

  @NotNull
  public Self andNot(final ElementPattern pattern) {
    ElementPattern not = StandardPatterns.not(pattern);
    return and(not);
  }

  @NotNull
  public Self andOr(ElementPattern @NotNull ... patterns) {
    ElementPattern or = StandardPatterns.or(patterns);
    return and(or);
  }

  @NotNull
  public Self and(final ElementPattern pattern) {
    return with(new PatternConditionPlus("and", pattern) {
      @Override
      public boolean processValues(T t, ProcessingContext context, PairProcessor processor) {
        return processor.process(t, context);
      }
    });
  }

  @NotNull
  public Self equalTo(@NotNull final T o) {
    return with(new ValuePatternCondition("equalTo") {
      @Override
      public boolean accepts(@NotNull final T t, final ProcessingContext context) {
        return t.equals(o);
      }

      @Override
      public Collection getValues() {
        return Collections.singletonList(o);
      }
    });
  }

  @NotNull
  public Self oneOf(final T... values) {
    final Collection list;

    final int length = values.length;
    if (length == 1) {
      list = Collections.singletonList(values[0]);
    }
    else if (length >= 11) {
      list = ContainerUtil.set(values);
    }
    else {
      list = Arrays.asList(values);
    }

    return with(new ValuePatternCondition("oneOf") {

      @Override
      public Collection getValues() {
        return list;
      }

      @Override
      public boolean accepts(@NotNull T t, ProcessingContext context) {
        return list.contains(t);
      }
    });
  }

  @NotNull
  public Self oneOf(final Collection set) {
    return with(new ValuePatternCondition("oneOf") {

      @Override
      public Collection getValues() {
        return set;
      }

      @Override
      public boolean accepts(@NotNull T t, ProcessingContext context) {
        return set.contains(t);
      }
    });
  }

  @NotNull
  public Self isNull() {
    //noinspection Convert2Diamond (would break compilation: IDEA-168317)
    return adapt(new ElementPatternCondition(new InitialPatternCondition(Object.class) {
      @Override
      public boolean accepts(@Nullable final Object o, final ProcessingContext context) {
        return o == null;
      }
    }));
  }

  @NotNull
  public Self notNull() {
    //noinspection Convert2Diamond (would break compilation: IDEA-168317)
    return adapt(new ElementPatternCondition(new InitialPatternCondition(Object.class) {
      @Override
      public boolean accepts(@Nullable final Object o, final ProcessingContext context) {
        return o != null;
      }
    }));
  }

  @NotNull
  public Self save(@NotNull Key key) {
    return with(new PatternCondition("save") {
      @Override
      public boolean accepts(@NotNull final T t, final ProcessingContext context) {
        context.put(key, t);
        return true;
      }
    });
  }

  @NotNull
  public Self save(@NonNls final String key) {
    return with(new PatternCondition("save") {
      @Override
      public boolean accepts(@NotNull final T t, final ProcessingContext context) {
        context.put(key, t);
        return true;
      }
    });
  }

  @NotNull
  public Self with(@NotNull PatternCondition pattern) {
    final ElementPatternCondition condition = getCondition().append(pattern);
    return adapt(condition);
  }

  @NotNull
  private Self adapt(@NotNull ElementPatternCondition condition) {
    try {
      final ObjectPattern s = (ObjectPattern)clone();
      s.myInitialCondition = condition.getInitialCondition();
      List> conditions = condition.getConditions();
      s.myConditions = conditions.isEmpty() ? null : conditions.size() == 1 ? conditions.get(0) : conditions;
      //noinspection unchecked
      return (Self)s;
    }
    catch (CloneNotSupportedException e) {
      throw new RuntimeException(e);
    }
  }

  @NotNull
  public Self without(final PatternCondition pattern) {
    return with(new PatternCondition("without") {
      @Override
      public boolean accepts(@NotNull final T o, final ProcessingContext context) {
        return !pattern.accepts(o, context);
      }
    });
  }

  public String toString() {
    return getCondition().toString();
  }

  public static final class Capture extends ObjectPattern> {
    public Capture(@NotNull Class aClass) {
      super(aClass);
    }

    public Capture(@NotNull InitialPatternCondition condition) {
      super(condition);
    }
  }
}