com.google.gerrit.index.SchemaUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gerrit-plugin-api Show documentation
API for Gerrit Plugins
There is a newer version: 3.10.1
// Copyright (C) 2016 The Android Open Source Project
//
// 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 com.google.gerrit.index;

import static com.google.common.base.Preconditions.checkArgument;

import com.google.common.base.CharMatcher;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedMap;
import com.google.common.collect.Iterables;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import org.eclipse.jgit.lib.PersonIdent;

public class SchemaUtil {
  public static  ImmutableSortedMap> schemasFromClass(
      Class schemasClass, Class valueClass) {
    Map> schemas = new HashMap<>();
    for (Field f : schemasClass.getDeclaredFields()) {
      if (Modifier.isStatic(f.getModifiers())
          && Modifier.isFinal(f.getModifiers())
          && Schema.class.isAssignableFrom(f.getType())) {
        ParameterizedType t = (ParameterizedType) f.getGenericType();
        if (t.getActualTypeArguments()[0] == valueClass) {
          try {
            f.setAccessible(true);
            @SuppressWarnings("unchecked")
            Schema schema = (Schema) f.get(null);
            checkArgument(f.getName().startsWith("V"));
            int versionName = Integer.parseInt(f.getName().substring(1));
            checkArgument(
                versionName == schema.getVersion(),
                "Schema version %s does not match its name %s",
                schema.getVersion(),
                f.getName());
            schemas.put(schema.getVersion(), schema);
          } catch (IllegalAccessException e) {
            throw new IllegalArgumentException(e);
          }
        } else {
          throw new IllegalArgumentException(
              "non-" + schemasClass.getSimpleName() + " schema: " + f);
        }
      }
    }
    if (schemas.isEmpty()) {
      throw new ExceptionInInitializerError("no ChangeSchemas found");
    }
    return ImmutableSortedMap.copyOf(schemas);
  }

  @SafeVarargs
  public static  Schema schema(FieldDef... fields) {
    return new Schema.Builder().version(0).add(fields).build();
  }

  @SafeVarargs
  public static  Schema schema(int version, FieldDef... fields) {
    return new Schema.Builder().version(version).add(fields).build();
  }

  public static  Schema schema(int version, ImmutableList> fields) {
    return new Schema.Builder().version(version).add(fields).build();
  }

  @SafeVarargs
  public static  Schema schema(Schema schema, FieldDef... moreFields) {
    return new Schema.Builder().add(schema).add(moreFields).build();
  }

  public static  Schema schema(
      int version,
      ImmutableList> fieldDefs,
      ImmutableList> indexedFields,
      ImmutableList.SearchSpec> searchSpecs) {
    return new Schema.Builder()
        .version(version)
        .add(fieldDefs)
        .addIndexedFields(indexedFields)
        .addSearchSpecs(searchSpecs)
        .build();
  }

  public static  Schema schema(
      Schema schema,
      ImmutableList> fieldDefs,
      ImmutableList> indexedFields,
      ImmutableList.SearchSpec> searchSpecs) {
    return new Schema.Builder()
        .add(schema)
        .add(fieldDefs)
        .addIndexedFields(indexedFields)
        .addSearchSpecs(searchSpecs)
        .build();
  }

  public static  Schema schema(
      ImmutableList> fieldDefs,
      ImmutableList> indexFields,
      ImmutableList.SearchSpec> searchSpecs) {
    return schema(/* version= */ 0, fieldDefs, indexFields, searchSpecs);
  }

  public static Set getPersonParts(PersonIdent person) {
    if (person == null) {
      return ImmutableSet.of();
    }
    return getNameParts(person.getName(), Collections.singleton(person.getEmailAddress()));
  }

  public static Set getNameParts(String name) {
    return getNameParts(name, Collections.emptySet());
  }

  public static Set getNameParts(String name, Iterable emails) {
    Splitter at = Splitter.on('@');
    Splitter s = Splitter.on(CharMatcher.anyOf("@.- /_")).omitEmptyStrings();
    HashSet parts = new HashSet<>();
    for (String email : emails) {
      if (email == null) {
        continue;
      }
      String lowerEmail = email.toLowerCase(Locale.US);
      parts.add(lowerEmail);
      Iterables.addAll(parts, at.split(lowerEmail));
      Iterables.addAll(parts, s.split(lowerEmail));
    }
    if (name != null) {
      Iterables.addAll(parts, s.split(name.toLowerCase(Locale.US)));
    }
    return parts;
  }

  private SchemaUtil() {}
}