index
int64 | repo_id
string | file_path
string | content
string |
|---|---|---|---|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/plan/QuerySet.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.plan;
import ai.grakn.graql.internal.reasoner.query.ReasonerQueryEquivalence;
import ai.grakn.graql.internal.reasoner.query.ReasonerQueryImpl;
import com.google.common.base.Equivalence;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;
/**
*
* <p>
* Helper class for sets of {@link ReasonerQueryImpl} queries with equality comparison {@link ReasonerQueryEquivalence}.
* </p>
*
* @author Kasper Piskorski
*
*/
public class QuerySet extends QueryCollection<Set<ReasonerQueryImpl>, Set<Equivalence.Wrapper<ReasonerQueryImpl>>> {
QuerySet(Collection<ReasonerQueryImpl> queries){
this.collection = new HashSet<>(queries);
this.wrappedCollection = queries.stream().map(q -> equality().wrap(q)).collect(Collectors.toSet());
}
public static QuerySet create(Collection<Equivalence.Wrapper<ReasonerQueryImpl>> queries){
return new QuerySet(queries.stream().map(Equivalence.Wrapper::get).collect(Collectors.toSet()));
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/plan/ResolutionPlan.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.plan;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.Var;
import ai.grakn.graql.admin.Atomic;
import ai.grakn.graql.internal.gremlin.GraqlTraversal;
import ai.grakn.graql.internal.reasoner.atom.Atom;
import ai.grakn.graql.internal.reasoner.atom.AtomicBase;
import ai.grakn.graql.internal.reasoner.atom.predicate.IdPredicate;
import ai.grakn.graql.internal.reasoner.atom.predicate.NeqPredicate;
import ai.grakn.graql.internal.reasoner.query.ReasonerQueryImpl;
import com.google.common.collect.ImmutableList;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;
/**
*
* <p>
* Class defining the resolution plan for a given {@link ReasonerQueryImpl} at an atom level.
* The plan is constructed using the {@link GraqlTraversal} with the aid of {@link GraqlTraversalPlanner}.
* </p>
*
* @author Kasper Piskorski
*
*/
public final class ResolutionPlan {
final private ImmutableList<Atom> plan;
final private ReasonerQueryImpl query;
public ResolutionPlan(ReasonerQueryImpl q){
this.query = q;
this.plan = GraqlTraversalPlanner.plan(query);
validatePlan();
}
@Override
public String toString(){
return plan.stream().map(AtomicBase::toString).collect(Collectors.joining("\n"));
}
/**
* @return corresponding atom plan
*/
public ImmutableList<Atom> plan(){ return plan;}
/**
* @return true if the plan is complete with respect to provided query - contains all selectable atoms
*/
private boolean isComplete(){
return query.selectAtoms().allMatch(plan::contains);
}
/**
* @return true if the plan is valid with respect to provided query - its resolution doesn't lead to any non-ground neq predicates
*/
private boolean isNeqGround(){
Set<NeqPredicate> nonGroundPredicates = new HashSet<>();
Set<Var> mappedVars = this.query.getAtoms(IdPredicate.class).map(Atomic::getVarName).collect(Collectors.toSet());
for(Atom atom : this.plan){
mappedVars.addAll(atom.getVarNames());
atom.getPredicates(NeqPredicate.class)
.forEach(neq -> {
//look for non-local non-ground predicates
if (!mappedVars.containsAll(neq.getVarNames())
&& !atom.getVarNames().containsAll(neq.getVarNames())){
nonGroundPredicates.add(neq);
} else{
//if this is ground for this atom but non-ground for another it is ground
if (nonGroundPredicates.contains(neq)) nonGroundPredicates.remove(neq);
}
});
}
return nonGroundPredicates.isEmpty();
}
private void validatePlan() {
if (!isNeqGround()) {
throw GraqlQueryException.nonGroundNeqPredicate(query);
}
if (!isComplete()){
throw GraqlQueryException.incompleteResolutionPlan(query);
}
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/plan/ResolutionQueryPlan.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.plan;
import ai.grakn.graql.internal.reasoner.atom.Atom;
import ai.grakn.graql.internal.reasoner.query.ReasonerQueries;
import ai.grakn.graql.internal.reasoner.query.ReasonerQueryImpl;
import ai.grakn.kb.internal.EmbeddedGraknTx;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
import java.util.stream.Collectors;
/**
*
* <p>
* Class defining the resolution plan for a given {@link ReasonerQueryImpl} at a query level.
* The plan is constructed using the {@link ResolutionPlan} working at an atom level.
* </p>
*
* @author Kasper Piskorski
*
*/
public class ResolutionQueryPlan {
private final ImmutableList<ReasonerQueryImpl> queryPlan;
public ResolutionQueryPlan(ReasonerQueryImpl query){
this.queryPlan = queryPlan(query);
}
@Override
public String toString(){
return queries().stream()
.map(sq -> sq.toString() + (sq.isRuleResolvable()? "*" : ""))
.collect(Collectors.joining("\n"));
}
public List<ReasonerQueryImpl> queries(){ return queryPlan;}
/**
* compute the query resolution plan - list of queries ordered by their cost as computed by the graql traversal planner
* @return list of prioritised queries
*/
private static ImmutableList<ReasonerQueryImpl> queryPlan(ReasonerQueryImpl query){
ResolutionPlan resolutionPlan = new ResolutionPlan(query);
ImmutableList<Atom> plan = resolutionPlan.plan();
EmbeddedGraknTx<?> tx = query.tx();
LinkedList<Atom> atoms = new LinkedList<>(plan);
List<ReasonerQueryImpl> queries = new LinkedList<>();
List<Atom> nonResolvableAtoms = new ArrayList<>();
while (!atoms.isEmpty()) {
Atom top = atoms.remove();
if (top.isRuleResolvable()) {
if (!nonResolvableAtoms.isEmpty()) {
queries.add(ReasonerQueries.create(nonResolvableAtoms, tx));
nonResolvableAtoms.clear();
}
queries.add(ReasonerQueries.atomic(top));
} else {
nonResolvableAtoms.add(top);
if (atoms.isEmpty()) queries.add(ReasonerQueries.create(nonResolvableAtoms, tx));
}
}
boolean refine = plan.size() != queries.size() && !query.requiresSchema();
return refine? refine(queries) : ImmutableList.copyOf(queries);
}
private static List<ReasonerQueryImpl> prioritise(QueryCollectionBase queries){
return queries.stream()
.sorted(Comparator.comparing(q -> !q.isAtomic()))
.sorted(Comparator.comparing(ReasonerQueryImpl::isRuleResolvable))
.sorted(Comparator.comparing(ReasonerQueryImpl::isBoundlesslyDisconnected))
.collect(Collectors.toCollection(LinkedList::new));
}
private static ImmutableList<ReasonerQueryImpl> refine(List<ReasonerQueryImpl> qs){
return ImmutableList.copyOf(refinePlan(new QueryList(qs)).toCollection());
}
private static QueryList refinePlan(QueryList queries){
QueryList plan = new QueryList();
Stack<ReasonerQueryImpl> queryStack = new Stack<>();
Lists.reverse(prioritise(queries)).forEach(queryStack::push);
while(!plan.containsAll(queries)) {
ReasonerQueryImpl query = queryStack.pop();
QuerySet candidates = queries.getCandidates(query, plan);
if (!candidates.isEmpty() || queries.size() - plan.size() == 1){
plan.add(query);
Lists.reverse(prioritise(candidates)).forEach(queryStack::push);
}
}
return plan;
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/query/QueryAnswers.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.query;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.MultiUnifier;
import ai.grakn.graql.admin.Unifier;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.stream.Stream;
import javax.annotation.Nonnull;
/**
*
* <p>
* Wrapper class for a set of {@link ConceptMap} objects providing higher level facilities.
*
* @author Kasper Piskorski
*
*/
public class QueryAnswers implements Iterable<ConceptMap>{
private final HashSet<ConceptMap> set = new HashSet<>();
@Nonnull
@Override
public Iterator<ConceptMap> iterator() { return set.iterator();}
@Override
public boolean equals(Object obj){
if (obj == this) return true;
if (obj == null || !(obj instanceof QueryAnswers)) return false;
QueryAnswers a2 = (QueryAnswers) obj;
return set.equals(a2.set);
}
@Override
public int hashCode(){return set.hashCode();}
@Override
public String toString(){ return set.toString();}
public Stream<ConceptMap> stream(){ return set.stream();}
public QueryAnswers(){}
public QueryAnswers(ConceptMap ans){ set.add(ans);}
public QueryAnswers(Collection<ConceptMap> ans){ set.addAll(ans); }
private QueryAnswers(QueryAnswers ans){ ans.forEach(set::add);}
public boolean add(ConceptMap a){ return set.add(a);}
public boolean addAll(QueryAnswers ans){ return set.addAll(ans.set);}
public boolean removeAll(QueryAnswers ans){ return set.removeAll(ans.set);}
public boolean contains(ConceptMap a){ return set.contains(a);}
public boolean isEmpty(){ return set.isEmpty();}
/**
* unify the answers by applying unifier to variable set
* @param unifier map of [key: from/value: to] unifiers
* @return unified query answers
*/
public QueryAnswers unify(Unifier unifier){
if (unifier.isEmpty()) return new QueryAnswers(this);
QueryAnswers unifiedAnswers = new QueryAnswers();
this.stream()
.map(a -> a.unify(unifier))
.filter(a -> !a.isEmpty())
.forEach(unifiedAnswers::add);
return unifiedAnswers;
}
/**
* unify the answers by applying multiunifier to variable set
* @param multiUnifier multiunifier to be applied to the query answers
* @return unified query answers
*/
public QueryAnswers unify(MultiUnifier multiUnifier){
QueryAnswers unifiedAnswers = new QueryAnswers();
this.stream()
.flatMap(a -> a.unify(multiUnifier))
.filter(a -> !a.isEmpty())
.forEach(unifiedAnswers::add);
return unifiedAnswers;
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/query/ReasonerAtomicQuery.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.query;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.Atomic;
import ai.grakn.graql.admin.Conjunction;
import ai.grakn.graql.admin.MultiUnifier;
import ai.grakn.graql.admin.ReasonerQuery;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.admin.UnifierComparison;
import ai.grakn.graql.admin.VarPatternAdmin;
import ai.grakn.graql.internal.reasoner.MultiUnifierImpl;
import ai.grakn.graql.internal.reasoner.atom.Atom;
import ai.grakn.graql.internal.reasoner.atom.binary.TypeAtom;
import ai.grakn.graql.internal.reasoner.atom.predicate.NeqPredicate;
import ai.grakn.graql.internal.reasoner.cache.SimpleQueryCache;
import ai.grakn.graql.internal.reasoner.state.AnswerState;
import ai.grakn.graql.internal.reasoner.state.AtomicStateProducer;
import ai.grakn.graql.internal.reasoner.state.QueryStateBase;
import ai.grakn.graql.internal.reasoner.state.ResolutionState;
import ai.grakn.graql.internal.reasoner.utils.Pair;
import ai.grakn.kb.internal.EmbeddedGraknTx;
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
import com.google.common.collect.Iterators;
import com.google.common.collect.Sets;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collections;
import java.util.Iterator;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static ai.grakn.graql.internal.reasoner.utils.ReasonerUtils.typeUnifier;
/**
*
* <p>
* Base reasoner atomic query. An atomic query is a query constrained to having at most one rule-resolvable atom
* together with its accompanying constraints (predicates and types).
* </p>
*
* @author Kasper Piskorski
*
*/
@SuppressFBWarnings("EQ_DOESNT_OVERRIDE_EQUALS")
public class ReasonerAtomicQuery extends ReasonerQueryImpl {
private final Atom atom;
ReasonerAtomicQuery(Conjunction<VarPatternAdmin> pattern, EmbeddedGraknTx<?> tx) {
super(pattern, tx);
this.atom = Iterables.getOnlyElement(selectAtoms()::iterator);
}
ReasonerAtomicQuery(ReasonerQueryImpl query) {
super(query);
this.atom = Iterables.getOnlyElement(selectAtoms()::iterator);
}
ReasonerAtomicQuery(Atom at) {
super(at);
this.atom = Iterables.getOnlyElement(selectAtoms()::iterator);
}
ReasonerAtomicQuery(Set<Atomic> atoms, EmbeddedGraknTx<?> tx){
super(atoms, tx);
this.atom = Iterables.getOnlyElement(selectAtoms()::iterator);
}
@Override
public ReasonerQuery copy(){ return new ReasonerAtomicQuery(this);}
@Override
public ReasonerAtomicQuery withSubstitution(ConceptMap sub){
return new ReasonerAtomicQuery(Sets.union(this.getAtoms(), sub.toPredicates(this)), this.tx());
}
@Override
public ReasonerAtomicQuery inferTypes() {
return new ReasonerAtomicQuery(getAtoms().stream().map(Atomic::inferTypes).collect(Collectors.toSet()), tx());
}
@Override
public ReasonerAtomicQuery positive(){
return new ReasonerAtomicQuery(
getAtoms().stream()
.filter(at -> !(at instanceof NeqPredicate))
.filter(at -> !Sets.intersection(at.getVarNames(), getAtom().getVarNames()).isEmpty())
.collect(Collectors.toSet()),
tx());
}
@Override
public String toString(){
return getAtoms(Atom.class).map(Atomic::toString).collect(Collectors.joining(", "));
}
@Override
public boolean isAtomic(){ return true;}
/**
* @return the atom constituting this atomic query
*/
public Atom getAtom() {
return atom;
}
/**
* @throws IllegalArgumentException if passed a {@link ReasonerQuery} that is not a {@link ReasonerAtomicQuery}.
*/
@Override
public MultiUnifier getMultiUnifier(ReasonerQuery p, UnifierComparison unifierType){
if (p == this) return new MultiUnifierImpl();
Preconditions.checkArgument(p instanceof ReasonerAtomicQuery);
ReasonerAtomicQuery parent = (ReasonerAtomicQuery) p;
MultiUnifier multiUnifier = this.getAtom().getMultiUnifier(parent.getAtom(), unifierType);
Set<TypeAtom> childTypes = this.getAtom().getTypeConstraints().collect(Collectors.toSet());
if (multiUnifier.isEmpty() || childTypes.isEmpty()) return multiUnifier;
//get corresponding type unifiers
Set<TypeAtom> parentTypes = parent.getAtom().getTypeConstraints().collect(Collectors.toSet());
Set<Unifier> unifiers = multiUnifier.unifiers().stream()
.map(unifier -> typeUnifier(childTypes, parentTypes, unifier, unifierType))
.collect(Collectors.toSet());
return new MultiUnifierImpl(unifiers);
}
/**
* materialise this query with the accompanying answer - persist to kb
* @param answer to be materialised
* @return stream of materialised answers
*/
public Stream<ConceptMap> materialise(ConceptMap answer) {
return this.withSubstitution(answer)
.getAtom()
.materialise()
.map(ans -> ans.explain(answer.explanation()));
}
@Override
public ResolutionState subGoal(ConceptMap sub, Unifier u, QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, SimpleQueryCache<ReasonerAtomicQuery> cache){
return new AtomicStateProducer(this, sub, u, parent, subGoals, cache);
}
@Override
protected Stream<ReasonerQueryImpl> getQueryStream(ConceptMap sub){
Atom atom = getAtom();
return atom.getSchemaConcept() == null?
atom.atomOptions(sub).stream().map(ReasonerAtomicQuery::new) :
Stream.of(this);
}
@Override
public Iterator<ResolutionState> queryStateIterator(QueryStateBase parent, Set<ReasonerAtomicQuery> visitedSubGoals, SimpleQueryCache<ReasonerAtomicQuery> cache) {
Pair<Stream<ConceptMap>, MultiUnifier> cacheEntry = cache.getAnswerStreamWithUnifier(this);
Iterator<AnswerState> dbIterator = cacheEntry.getKey()
.map(a -> a.explain(a.explanation().setQuery(this)))
.map(ans -> new AnswerState(ans, parent.getUnifier(), parent))
.iterator();
Iterator<ResolutionState> subGoalIterator;
//if this is ground and exists in the db then do not resolve further
if(visitedSubGoals.contains(this)
|| (this.isGround() && dbIterator.hasNext())){
subGoalIterator = Collections.emptyIterator();
} else {
visitedSubGoals.add(this);
subGoalIterator = cache.ruleCache().getRuleStream(this.getAtom())
.map(rulePair -> rulePair.getKey().subGoal(this.getAtom(), rulePair.getValue(), parent, visitedSubGoals, cache))
.iterator();
}
return Iterators.concat(dbIterator, subGoalIterator);
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/query/ReasonerQueries.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.query;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.Atomic;
import ai.grakn.graql.admin.Conjunction;
import ai.grakn.graql.admin.VarPatternAdmin;
import ai.grakn.graql.internal.reasoner.atom.Atom;
import ai.grakn.kb.internal.EmbeddedGraknTx;
import com.google.common.collect.Iterables;
import java.util.List;
import java.util.Set;
/**
*
* <p>
* Factory for reasoner queries.
* </p>
*
* @author Kasper Piskorski
*
*/
public class ReasonerQueries {
/**
* create a reasoner query from a conjunctive pattern with types inferred
* @param pattern conjunctive pattern defining the query
* @param tx corresponding transaction
* @return reasoner query constructed from provided conjunctive pattern
*/
public static ReasonerQueryImpl create(Conjunction<VarPatternAdmin> pattern, EmbeddedGraknTx<?> tx) {
ReasonerQueryImpl query = new ReasonerQueryImpl(pattern, tx).inferTypes();
return query.isAtomic()?
new ReasonerAtomicQuery(query.getAtoms(), tx) :
query;
}
/**
* create a reasoner query from provided set of atomics
* @param as set of atomics that define the query
* @param tx corresponding transaction
* @return reasoner query defined by the provided set of atomics
*/
public static ReasonerQueryImpl create(Set<Atomic> as, EmbeddedGraknTx<?> tx){
boolean isAtomic = as.stream().filter(Atomic::isSelectable).count() == 1;
return isAtomic?
new ReasonerAtomicQuery(as, tx).inferTypes() :
new ReasonerQueryImpl(as, tx).inferTypes();
}
/**
* create a reasoner query from provided list of atoms
* NB: atom constraints (types and predicates, if any) will be included in the query
* @param as list of atoms that define the query
* @param tx corresponding transaction
* @return reasoner query defined by the provided list of atoms together with their constraints (types and predicates, if any)
*/
public static ReasonerQueryImpl create(List<Atom> as, EmbeddedGraknTx<?> tx){
boolean isAtomic = as.size() == 1;
return isAtomic?
new ReasonerAtomicQuery(Iterables.getOnlyElement(as)).inferTypes() :
new ReasonerQueryImpl(as, tx).inferTypes();
}
/**
* create a reasoner query by combining an existing query and a substitution
* @param q base query for substitution to be attached
* @param sub (partial) substitution
* @return reasoner query with the substitution contained in the query
*/
public static ReasonerQueryImpl create(ReasonerQueryImpl q, ConceptMap sub){
return q.withSubstitution(sub).inferTypes();
}
/**
* @param pattern conjunctive pattern defining the query
* @param tx corresponding transaction
* @return atomic query defined by the provided pattern with inferred types
*/
public static ReasonerAtomicQuery atomic(Conjunction<VarPatternAdmin> pattern, EmbeddedGraknTx<?> tx){
return new ReasonerAtomicQuery(pattern, tx).inferTypes();
}
/**
* create an atomic query from the provided atom
* NB: atom constraints (types and predicates, if any) will be included in the query
* @param atom defining the query
* @return atomic query defined by the provided atom together with its constraints (types and predicates, if any)
*/
public static ReasonerAtomicQuery atomic(Atom atom){
return new ReasonerAtomicQuery(atom).inferTypes();
}
/**
* create an atomic query copy from the provided query with the types inferred
* @param q query to be copied
* @return copied atomic query with inferred types
*/
public static ReasonerAtomicQuery atomic(ReasonerAtomicQuery q){
return new ReasonerAtomicQuery(q).inferTypes();
}
/**
* create an atomic query by combining an existing atomic query and a substitution
* @param q base query for substitution to be attached
* @param sub (partial) substitution
* @return atomic query with the substitution contained in the query
*/
public static ReasonerAtomicQuery atomic(ReasonerAtomicQuery q, ConceptMap sub){
return q.withSubstitution(sub).inferTypes();
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/query/ReasonerQueryEquivalence.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.query;
import ai.grakn.graql.admin.Atomic;
import ai.grakn.graql.admin.ReasonerQuery;
import ai.grakn.graql.internal.reasoner.atom.Atom;
import ai.grakn.graql.internal.reasoner.atom.AtomicEquivalence;
import com.google.common.base.Equivalence;
import java.util.Set;
import java.util.stream.Collectors;
/**
*
* <p>
* Static class defining different equivalence comparisons for reasoner queries ({@link ReasonerQuery}):
*
* - Equality - two queries are equal if they contain the same {@link Atomic}s of which all corresponding pairs are equal.
*
* - Alpha equivalence - two queries are alpha-equivalent if they are equal up to the choice of free variables.
*
* - Structural equivalence - two queries are structurally equivalent if they are equal up to the choice of free variables and partial substitutions (id predicates).
*
* </p>
*
* @author Kasper Piskorski
*
*/
public abstract class ReasonerQueryEquivalence extends Equivalence<ReasonerQuery> {
abstract public AtomicEquivalence atomicEquivalence();
public String name(){ return atomicEquivalence().name();}
private static <B extends Atomic, S extends B> boolean equivalence(ReasonerQuery q1, ReasonerQuery q2, Class<S> atomType, Equivalence<B> equiv) {
//NB: this check is too simple for general queries - variable binding patterns are not recognised
Set<S> atoms = q1.getAtoms(atomType).collect(Collectors.toSet());
Set<S> otherAtoms = q2.getAtoms(atomType).collect(Collectors.toSet());
return AtomicEquivalence.equivalence(atoms, otherAtoms, equiv);
}
private static <B extends Atomic, S extends B> int equivalenceHash(ReasonerQuery q, Class<S> atomType, Equivalence<B> equiv) {
return AtomicEquivalence.equivalenceHash(q.getAtoms(atomType), equiv);
}
public final static ReasonerQueryEquivalence Equality = new ReasonerQueryEquivalence(){
@Override
public AtomicEquivalence atomicEquivalence() { return AtomicEquivalence.Equality; }
@Override
protected boolean doEquivalent(ReasonerQuery q1, ReasonerQuery q2) {
return equivalence(q1, q2, Atomic.class, atomicEquivalence());
}
@Override
protected int doHash(ReasonerQuery q) {
return equivalenceHash(q, Atomic.class, atomicEquivalence());
}
};
public final static ReasonerQueryEquivalence AlphaEquivalence = new ReasonerQueryEquivalence(){
@Override
public AtomicEquivalence atomicEquivalence() { return AtomicEquivalence.AlphaEquivalence; }
@Override
protected boolean doEquivalent(ReasonerQuery q1, ReasonerQuery q2) {
return equivalence(q1, q2, Atomic.class, atomicEquivalence());
}
@Override
protected int doHash(ReasonerQuery q) {
return equivalenceHash(q, Atomic.class, atomicEquivalence());
}
};
public final static ReasonerQueryEquivalence StructuralEquivalence = new ReasonerQueryEquivalence(){
@Override
public AtomicEquivalence atomicEquivalence() { return AtomicEquivalence.StructuralEquivalence; }
@Override
protected boolean doEquivalent(ReasonerQuery q1, ReasonerQuery q2) {
return equivalence(q1, q2, Atom.class, atomicEquivalence());
}
@Override
protected int doHash(ReasonerQuery q) {
return equivalenceHash(q, Atom.class, atomicEquivalence());
}
};
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/query/ReasonerQueryImpl.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.query;
import ai.grakn.concept.Concept;
import ai.grakn.concept.ConceptId;
import ai.grakn.concept.Type;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.GetQuery;
import ai.grakn.graql.Var;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.Atomic;
import ai.grakn.graql.admin.Conjunction;
import ai.grakn.graql.admin.MultiUnifier;
import ai.grakn.graql.admin.PatternAdmin;
import ai.grakn.graql.admin.ReasonerQuery;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.admin.UnifierComparison;
import ai.grakn.graql.admin.VarPatternAdmin;
import ai.grakn.graql.internal.pattern.Patterns;
import ai.grakn.graql.internal.query.answer.ConceptMapImpl;
import ai.grakn.graql.internal.reasoner.ResolutionIterator;
import ai.grakn.graql.internal.reasoner.UnifierType;
import ai.grakn.graql.internal.reasoner.atom.Atom;
import ai.grakn.graql.internal.reasoner.atom.AtomicBase;
import ai.grakn.graql.internal.reasoner.atom.AtomicFactory;
import ai.grakn.graql.internal.reasoner.atom.binary.IsaAtomBase;
import ai.grakn.graql.internal.reasoner.atom.binary.RelationshipAtom;
import ai.grakn.graql.internal.reasoner.atom.binary.IsaAtom;
import ai.grakn.graql.internal.reasoner.atom.predicate.IdPredicate;
import ai.grakn.graql.internal.reasoner.atom.predicate.NeqPredicate;
import ai.grakn.graql.internal.reasoner.cache.SimpleQueryCache;
import ai.grakn.graql.internal.reasoner.explanation.JoinExplanation;
import ai.grakn.graql.internal.reasoner.plan.ResolutionQueryPlan;
import ai.grakn.graql.internal.reasoner.rule.InferenceRule;
import ai.grakn.graql.internal.reasoner.rule.RuleUtils;
import ai.grakn.graql.internal.reasoner.state.AnswerState;
import ai.grakn.graql.internal.reasoner.state.ConjunctiveState;
import ai.grakn.graql.internal.reasoner.state.CumulativeState;
import ai.grakn.graql.internal.reasoner.state.QueryStateBase;
import ai.grakn.graql.internal.reasoner.state.ResolutionState;
import ai.grakn.graql.internal.reasoner.utils.Pair;
import ai.grakn.kb.internal.EmbeddedGraknTx;
import ai.grakn.util.Schema;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterators;
import com.google.common.collect.Sets;
import javax.annotation.Nullable;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static ai.grakn.graql.Graql.var;
/**
*
* <p>
* Base reasoner query providing resolution and atom handling facilities for conjunctive graql queries.
* </p>
*
* @author Kasper Piskorski
*
*/
public class ReasonerQueryImpl implements ReasonerQuery {
private final EmbeddedGraknTx<?> tx;
private final ImmutableSet<Atomic> atomSet;
private ConceptMap substitution = null;
private ImmutableMap<Var, Type> varTypeMap = null;
ReasonerQueryImpl(Conjunction<VarPatternAdmin> pattern, EmbeddedGraknTx<?> tx) {
this.tx = tx;
this.atomSet = ImmutableSet.<Atomic>builder()
.addAll(AtomicFactory.createAtoms(pattern, this).iterator())
.build();
}
ReasonerQueryImpl(Set<Atomic> atoms, EmbeddedGraknTx<?> tx){
this.tx = tx;
this.atomSet = ImmutableSet.<Atomic>builder()
.addAll(atoms.stream().map(at -> at.copy(this)).iterator())
.build();
}
ReasonerQueryImpl(List<Atom> atoms, EmbeddedGraknTx<?> tx){
this.tx = tx;
this.atomSet = ImmutableSet.<Atomic>builder()
.addAll(atoms.stream()
.flatMap(at -> Stream.concat(Stream.of(at), at.getNonSelectableConstraints()))
.map(at -> at.copy(this)).iterator())
.build();
}
ReasonerQueryImpl(Atom atom) {
// TODO: This cast is unsafe - ReasonerQuery should return an EmbeeddedGraknTx
this(Collections.singletonList(atom), (EmbeddedGraknTx<?>) /*TODO anything but this*/ atom.getParentQuery().tx());
}
ReasonerQueryImpl(ReasonerQueryImpl q) {
this.tx = q.tx;
this.atomSet = ImmutableSet.<Atomic>builder()
.addAll(q.getAtoms().stream().map(at -> at.copy(this)).iterator())
.build();
}
@Override
public ReasonerQuery conjunction(ReasonerQuery q) {
return new ReasonerQueryImpl(
Sets.union(getAtoms(), q.getAtoms()),
this.tx()
);
}
/**
* @param sub substitution to be inserted into the query
* @return corresponding query with additional substitution
*/
public ReasonerQueryImpl withSubstitution(ConceptMap sub){
return new ReasonerQueryImpl(Sets.union(this.getAtoms(), sub.toPredicates(this)), this.tx());
}
/**
* @return corresponding reasoner query with inferred types
*/
public ReasonerQueryImpl inferTypes() {
return new ReasonerQueryImpl(getAtoms().stream().map(Atomic::inferTypes).collect(Collectors.toSet()), tx());
}
/**
* @return corresponding positive query (with neq predicates removed)
*/
public ReasonerQueryImpl positive(){
return new ReasonerQueryImpl(getAtoms().stream().filter(at -> !(at instanceof NeqPredicate)).collect(Collectors.toSet()), tx());
}
/**
* @param transform map defining id transform: var -> new id
* @return new query with id predicates transformed according to the transform
*/
public ReasonerQueryImpl transformIds(Map<Var, ConceptId> transform){
Set<Atomic> atoms = this.getAtoms(IdPredicate.class).map(p -> {
ConceptId conceptId = transform.get(p.getVarName());
if (conceptId != null) return IdPredicate.create(p.getVarName(), conceptId, p.getParentQuery());
return p;
}).collect(Collectors.toSet());
getAtoms().stream().filter(at -> !(at instanceof IdPredicate)).forEach(atoms::add);
return new ReasonerQueryImpl(atoms, tx());
}
@Override
public String toString(){
return "{\n\t" +
getAtoms(Atom.class).map(Atomic::toString).collect(Collectors.joining(";\n\t")) +
"\n}";
}
public ReasonerQuery copy() {
return new ReasonerQueryImpl(this);
}
//alpha-equivalence equality
@Override
public boolean equals(Object obj) {
if (obj == null || this.getClass() != obj.getClass()) return false;
if (obj == this) return true;
ReasonerQueryImpl q2 = (ReasonerQueryImpl) obj;
return this.isEquivalent(q2);
}
@Override
public int hashCode() {
return ReasonerQueryEquivalence.AlphaEquivalence.hash(this);
}
/**
* @param q query to be compared with
* @return true if two queries are alpha-equivalent
*/
public boolean isEquivalent(ReasonerQueryImpl q) {
return ReasonerQueryEquivalence.AlphaEquivalence.equivalent(this, q);
}
@Override
public EmbeddedGraknTx<?> tx() {
return tx;
}
@Override
public void checkValid() { getAtoms().forEach(Atomic::checkValid);}
public Conjunction<PatternAdmin> getPattern() {
return Patterns.conjunction(
getAtoms().stream()
.map(Atomic::getCombinedPattern)
.flatMap(p -> p.admin().varPatterns().stream())
.collect(Collectors.toSet())
);
}
@Override
public Set<String> validateOntologically() {
return getAtoms().stream()
.flatMap(at -> at.validateOntologically().stream())
.collect(Collectors.toSet());
}
@Override
public boolean isRuleResolvable() {
return selectAtoms().anyMatch(Atom::isRuleResolvable);
}
/**
* @return true if this query contains disconnected atoms that are unbounded
*/
public boolean isBoundlesslyDisconnected(){
return !isAtomic()
&& selectAtoms()
.filter(at -> !at.isBounded())
.anyMatch(Atom::isDisconnected);
}
/**
* @return true if the query requires direct schema lookups
*/
public boolean requiresSchema(){ return selectAtoms().anyMatch(Atom::requiresSchema);}
/**
* @return true if this query is atomic
*/
public boolean isAtomic() {
return atomSet.stream().filter(Atomic::isSelectable).count() == 1;
}
/**
* @param typedVar variable of interest
* @param parentType to be checked
* @return true if typing the typeVar with type is compatible with role configuration of this query
*/
@Override
public boolean isTypeRoleCompatible(Var typedVar, Type parentType){
if (parentType == null || Schema.MetaSchema.isMetaLabel(parentType.label())) return true;
Set<Type> parentTypes = parentType.subs().collect(Collectors.toSet());
return getAtoms(RelationshipAtom.class)
.filter(ra -> ra.getVarNames().contains(typedVar))
.noneMatch(ra -> ra.getRoleVarMap().entries().stream()
//get roles this type needs to play
.filter(e -> e.getValue().equals(typedVar))
.filter(e -> !Schema.MetaSchema.isMetaLabel(e.getKey().label()))
//check if it can play it
.anyMatch(e -> e.getKey().players().noneMatch(parentTypes::contains)));
}
@Override
public Set<Atomic> getAtoms() { return atomSet;}
@Override
public <T extends Atomic> Stream<T> getAtoms(Class<T> type) {
return getAtoms().stream().filter(type::isInstance).map(type::cast);}
@Override
public Set<Var> getVarNames() {
Set<Var> vars = new HashSet<>();
getAtoms().forEach(atom -> vars.addAll(atom.getVarNames()));
return vars;
}
@Override
public MultiUnifier getMultiUnifier(ReasonerQuery parent) {
return getMultiUnifier(parent, UnifierType.EXACT);
}
@Override
public MultiUnifier getMultiUnifier(ReasonerQuery parent, UnifierComparison unifierType){
throw GraqlQueryException.getUnifierOfNonAtomicQuery();
}
public GetQuery getQuery() {
return tx.graql().infer(false).match(getPattern()).get();
}
private Stream<IsaAtom> inferEntityTypes(ConceptMap sub) {
Set<Var> typedVars = getAtoms(IsaAtomBase.class).map(AtomicBase::getVarName).collect(Collectors.toSet());
return Stream.concat(
getAtoms(IdPredicate.class),
sub.toPredicates(this).stream().map(IdPredicate.class::cast)
)
.filter(p -> !typedVars.contains(p.getVarName()))
.map(p -> new Pair<>(p, tx().<Concept>getConcept(p.getPredicate())))
.filter(p -> Objects.nonNull(p.getValue()))
.filter(p -> p.getValue().isEntity())
.map(p -> IsaAtom.create(p.getKey().getVarName(), var(), p.getValue().asEntity().type(), false,this));
}
private Map<Var, Type> getVarTypeMap(Stream<IsaAtomBase> isas){
HashMap<Var, Type> map = new HashMap<>();
isas
.map(at -> new Pair<>(at.getVarName(), at.getSchemaConcept()))
.filter(p -> Objects.nonNull(p.getValue()))
.filter(p -> p.getValue().isType())
.forEach(p -> {
Var var = p.getKey();
Type newType = p.getValue().asType();
Type type = map.get(var);
if (type == null) map.put(var, newType);
else {
boolean isSubType = type.subs().anyMatch(t -> t.equals(newType));
if (isSubType) map.put(var, newType);
}
});
return map;
}
@Override
public ImmutableMap<Var, Type> getVarTypeMap() {
if (varTypeMap == null) {
this.varTypeMap = getVarTypeMap(new ConceptMapImpl());
}
return varTypeMap;
}
public ImmutableMap<Var, Type> getVarTypeMap(boolean inferTypes) {
Set<IsaAtomBase> isas = getAtoms(IsaAtomBase.class).collect(Collectors.toSet());
return ImmutableMap.copyOf(
getVarTypeMap()
.entrySet().stream()
.filter(e -> inferTypes ||
isas.stream()
.filter(isa -> isa.getVarName().equals(e.getKey()))
.filter(isa -> Objects.nonNull(isa.getSchemaConcept()))
.anyMatch(isa -> isa.getSchemaConcept().equals(e.getValue()))
)
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))
);
}
@Override
public ImmutableMap<Var, Type> getVarTypeMap(ConceptMap sub) {
return ImmutableMap.copyOf(
getVarTypeMap(
Stream.concat(
getAtoms(IsaAtomBase.class),
inferEntityTypes(sub)
)
)
);
}
/**
* @param var variable name
* @return id predicate for the specified var name if any
*/
@Nullable
private IdPredicate getIdPredicate(Var var) {
return getAtoms(IdPredicate.class)
.filter(sub -> sub.getVarName().equals(var))
.findFirst().orElse(null);
}
/**
* returns id transform that would convert this query to a query alpha-equivalent to the query,
* provided they are structurally equivalent
* @param query for which the transform is to be constructed
* @param unifier between this query and provided query
* @return id transform
*/
public Map<Var, ConceptId> idTransform(ReasonerQueryImpl query, Unifier unifier){
Map<Var, ConceptId> transform = new HashMap<>();
this.getAtoms(IdPredicate.class)
.forEach(thisP -> {
Collection<Var> vars = unifier.get(thisP.getVarName());
Var var = !vars.isEmpty()? Iterators.getOnlyElement(vars.iterator()) : thisP.getVarName();
IdPredicate p2 = query.getIdPredicate(var);
if ( p2 != null) transform.put(thisP.getVarName(), p2.getPredicate());
});
return transform;
}
/**
* @return selected atoms
*/
public Stream<Atom> selectAtoms() {
return getAtoms(Atom.class).filter(Atomic::isSelectable);
}
/** Does id predicates -> answer conversion
* @return substitution obtained from all id predicates (including internal) in the query
*/
public ConceptMap getSubstitution(){
if (substitution == null) {
Set<Var> varNames = getVarNames();
Set<IdPredicate> predicates = getAtoms(IsaAtomBase.class)
.map(IsaAtomBase::getTypePredicate)
.filter(Objects::nonNull)
.filter(p -> varNames.contains(p.getVarName()))
.collect(Collectors.toSet());
getAtoms(IdPredicate.class).forEach(predicates::add);
HashMap<Var, Concept> answerMap = new HashMap<>();
predicates.forEach(p -> {
Concept concept = tx().getConcept(p.getPredicate());
if (concept == null) throw GraqlQueryException.idNotFound(p.getPredicate());
answerMap.put(p.getVarName(), concept);
});
substitution = new ConceptMapImpl(answerMap);
}
return substitution;
}
public ConceptMap getRoleSubstitution(){
Map<Var, Concept> roleSub = new HashMap<>();
getAtoms(RelationshipAtom.class)
.flatMap(RelationshipAtom::getRolePredicates)
.forEach(p -> {
Concept concept = tx().getConcept(p.getPredicate());
if (concept == null) throw GraqlQueryException.idNotFound(p.getPredicate());
roleSub.put(p.getVarName(), concept);
});
return new ConceptMapImpl(roleSub);
}
/**
* @return true if this query is a ground query
*/
boolean isGround(){
return getSubstitution().vars().containsAll(getVarNames());
}
/**
* @return true if this query requires atom decomposition
*/
public boolean requiresDecomposition(){
return this.selectAtoms().anyMatch(Atom::requiresDecomposition);
}
/**
* @return rewritten (decomposed) version of the query
*/
public ReasonerQueryImpl rewrite(){
if (!requiresDecomposition()) return this;
return new ReasonerQueryImpl(
this.selectAtoms()
.flatMap(at -> at.rewriteToAtoms().stream())
.collect(Collectors.toList()),
tx()
);
}
@Override
public Stream<ConceptMap> resolve() {
return new ResolutionIterator(this).hasStream();
}
/**
* @param sub partial substitution
* @param u unifier with parent state
* @param parent parent state
* @param subGoals set of visited sub goals
* @param cache query cache
* @return resolution subGoal formed from this query
*/
public ResolutionState subGoal(ConceptMap sub, Unifier u, QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, SimpleQueryCache<ReasonerAtomicQuery> cache){
return new ConjunctiveState(this, sub, u, parent, subGoals, cache);
}
/**
* @param sub partial substitution
* @param u unifier with parent state
* @param parent parent state
* @param subGoals set of visited sub goals
* @param cache query cache
* @return resolution subGoals formed from this query obtained by expanding the inferred types contained in the query
*/
public Stream<ResolutionState> subGoals(ConceptMap sub, Unifier u, QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, SimpleQueryCache<ReasonerAtomicQuery> cache){
return getQueryStream(sub)
.map(q -> q.subGoal(sub, u, parent, subGoals, cache));
}
/**
* @return stream of queries obtained by inserting all inferred possible types (if ambiguous)
*/
Stream<ReasonerQueryImpl> getQueryStream(ConceptMap sub){
return Stream.of(this);
}
/**
* @param parent parent state
* @param subGoals set of visited sub goals
* @param cache query cache
* @return query state iterator (db iter + unifier + state iter) for this query
*/
public Iterator<ResolutionState> queryStateIterator(QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, SimpleQueryCache<ReasonerAtomicQuery> cache){
Iterator<AnswerState> dbIterator;
Iterator<QueryStateBase> subGoalIterator;
if(!this.isRuleResolvable()) {
dbIterator = this.getQuery().stream()
.map(ans -> ans.explain(new JoinExplanation(this, ans)))
.map(ans -> new AnswerState(ans, parent.getUnifier(), parent))
.iterator();
subGoalIterator = Collections.emptyIterator();
} else {
dbIterator = Collections.emptyIterator();
ResolutionQueryPlan queryPlan = new ResolutionQueryPlan(this);
subGoalIterator = Iterators.singletonIterator(new CumulativeState(queryPlan.queries(), new ConceptMapImpl(), parent.getUnifier(), parent, subGoals, cache));
}
return Iterators.concat(dbIterator, subGoalIterator);
}
/**
* reiteration might be required if rule graph contains loops with negative flux
* or there exists a rule which head satisfies body
* @return true if because of the rule graph form, the resolution of this query may require reiteration
*/
public boolean requiresReiteration() {
Set<InferenceRule> dependentRules = RuleUtils.getDependentRules(this);
return RuleUtils.subGraphIsCyclical(dependentRules)
|| RuleUtils.subGraphHasRulesWithHeadSatisfyingBody(dependentRules);
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/rule/InferenceRule.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.rule;
import ai.grakn.concept.Rule;
import ai.grakn.concept.SchemaConcept;
import ai.grakn.graql.Var;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.Atomic;
import ai.grakn.graql.admin.Conjunction;
import ai.grakn.graql.admin.MultiUnifier;
import ai.grakn.graql.admin.PatternAdmin;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.admin.VarPatternAdmin;
import ai.grakn.graql.internal.pattern.Patterns;
import ai.grakn.graql.internal.reasoner.UnifierType;
import ai.grakn.graql.internal.reasoner.atom.Atom;
import ai.grakn.graql.internal.reasoner.atom.binary.RelationshipAtom;
import ai.grakn.graql.internal.reasoner.atom.binary.ResourceAtom;
import ai.grakn.graql.internal.reasoner.atom.binary.TypeAtom;
import ai.grakn.graql.internal.reasoner.atom.predicate.ValuePredicate;
import ai.grakn.graql.internal.reasoner.cache.SimpleQueryCache;
import ai.grakn.graql.internal.reasoner.query.ReasonerAtomicQuery;
import ai.grakn.graql.internal.reasoner.query.ReasonerQueries;
import ai.grakn.graql.internal.reasoner.query.ReasonerQueryImpl;
import ai.grakn.graql.internal.reasoner.state.QueryStateBase;
import ai.grakn.graql.internal.reasoner.state.ResolutionState;
import ai.grakn.graql.internal.reasoner.state.RuleState;
import ai.grakn.graql.internal.reasoner.utils.ReasonerUtils;
import ai.grakn.kb.internal.EmbeddedGraknTx;
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import static java.util.stream.Collectors.toSet;
/**
*
* <p>
* Class providing resolution and higher level facilities for {@link Rule} objects.
* </p>
*
* @author Kasper Piskorski
*
*/
public class InferenceRule {
private final EmbeddedGraknTx<?> tx;
private final Rule rule;
private final ReasonerQueryImpl body;
private final ReasonerAtomicQuery head;
private long priority = Long.MAX_VALUE;
private Boolean requiresMaterialisation = null;
public InferenceRule(Rule rule, EmbeddedGraknTx<?> tx){
this.tx = tx;
this.rule = rule;
//TODO simplify once changes propagated to rule objects
this.body = ReasonerQueries.create(conjunction(rule.when().admin()), tx);
this.head = ReasonerQueries.atomic(conjunction(rule.then().admin()), tx);
}
private InferenceRule(ReasonerAtomicQuery head, ReasonerQueryImpl body, Rule rule, EmbeddedGraknTx<?> tx){
this.tx = tx;
this.rule = rule;
this.head = head;
this.body = body;
}
@Override
public String toString(){
return "\n" + this.body.toString() + "->\n" + this.head.toString() + "[" + resolutionPriority() +"]\n";
}
@Override
public boolean equals(Object obj) {
if (obj == null || this.getClass() != obj.getClass()) return false;
InferenceRule rule = (InferenceRule) obj;
return this.getBody().equals(rule.getBody())
&& this.getHead().equals(rule.getHead());
}
@Override
public int hashCode() {
int hashCode = 1;
hashCode = hashCode * 37 + getBody().hashCode();
hashCode = hashCode * 37 + getHead().hashCode();
return hashCode;
}
/**
* @return the priority with which the rule should be fired
*/
public long resolutionPriority(){
if (priority == Long.MAX_VALUE) {
//NB: only checking locally as checking full tree (getDependentRules) is expensive
priority = -getBody().selectAtoms().flatMap(Atom::getApplicableRules).count();
}
return priority;
}
private Conjunction<VarPatternAdmin> conjunction(PatternAdmin pattern){
Set<VarPatternAdmin> vars = pattern
.getDisjunctiveNormalForm().getPatterns()
.stream().flatMap(p -> p.getPatterns().stream()).collect(toSet());
return Patterns.conjunction(vars);
}
public Rule getRule(){ return rule;}
/**
* @return true if the rule has disconnected head, i.e. head and body do not share any variables
*/
private boolean hasDisconnectedHead(){
return Sets.intersection(body.getVarNames(), head.getVarNames()).isEmpty();
}
/**
* @return true if head satisfies the pattern specified in the body of the rule
*/
boolean headSatisfiesBody(){
Set<Atomic> atoms = new HashSet<>(getHead().getAtoms());
Set<Var> headVars = getHead().getVarNames();
getBody().getAtoms(TypeAtom.class)
.filter(t -> !t.isRelation())
.filter(t -> !Sets.intersection(t.getVarNames(), headVars).isEmpty())
.forEach(atoms::add);
return getBody().isEquivalent(ReasonerQueries.create(atoms, tx));
}
/**
* rule requires materialisation in the context of resolving parent atom
* if parent atom requires materialisation, head atom requires materialisation or if the head contains only fresh variables
*
* @return true if the rule needs to be materialised
*/
public boolean requiresMaterialisation(Atom parentAtom){
if (requiresMaterialisation == null) {
requiresMaterialisation = parentAtom.requiresMaterialisation()
|| getHead().getAtom().requiresMaterialisation()
|| hasDisconnectedHead();
}
return requiresMaterialisation;
}
/**
* @return body of the rule of the form head :- body
*/
public ReasonerQueryImpl getBody(){ return body;}
/**
* @return head of the rule of the form head :- body
*/
public ReasonerAtomicQuery getHead(){ return head;}
/**
* @return reasoner query formed of combining head and body queries
*/
private ReasonerQueryImpl getCombinedQuery(){
Set<Atomic> allAtoms = new HashSet<>();
allAtoms.add(head.getAtom());
allAtoms.addAll(body.getAtoms());
return ReasonerQueries.create(allAtoms, tx);
}
/**
* @return a conclusion atom which parent contains all atoms in the rule
*/
public Atom getRuleConclusionAtom() {
return getCombinedQuery().getAtoms(Atom.class).filter(at -> at.equals(head.getAtom())).findFirst().orElse(null);
}
/**
* @param parentAtom atom containing constraints (parent)
* @param unifier unifier unifying parent with the rule
* @return rule with propagated constraints from parent
*/
private InferenceRule propagateConstraints(Atom parentAtom, Unifier unifier){
if (!parentAtom.isRelation() && !parentAtom.isResource()) return this;
Atom headAtom = head.getAtom();
Set<Atomic> bodyAtoms = new HashSet<>(body.getAtoms());
//transfer value predicates
parentAtom.getPredicates(ValuePredicate.class)
.flatMap(vp -> vp.unify(unifier).stream())
.forEach(bodyAtoms::add);
//if head is a resource merge vps into head
if (headAtom.isResource() && ((ResourceAtom) headAtom).getMultiPredicate().isEmpty()) {
ResourceAtom resourceHead = (ResourceAtom) headAtom;
Set<ValuePredicate> innerVps = parentAtom.getInnerPredicates(ValuePredicate.class)
.flatMap(vp -> vp.unify(unifier).stream())
.peek(bodyAtoms::add)
.collect(toSet());
headAtom = ResourceAtom.create(
headAtom.getPattern(),
headAtom.getPredicateVariable(),
resourceHead.getRelationVariable(),
resourceHead.getTypeId(),
innerVps,
headAtom.getParentQuery()
);
}
Set<TypeAtom> unifiedTypes = parentAtom.getTypeConstraints()
.flatMap(type -> type.unify(unifier).stream())
.collect(toSet());
//set rule body types to sub types of combined query+rule types
Set<TypeAtom> ruleTypes = body.getAtoms(TypeAtom.class).filter(t -> !t.isRelation()).collect(toSet());
Set<TypeAtom> allTypes = Sets.union(unifiedTypes, ruleTypes);
allTypes.stream()
.filter(ta -> {
SchemaConcept schemaConcept = ta.getSchemaConcept();
SchemaConcept subType = allTypes.stream()
.map(Atom::getSchemaConcept)
.filter(Objects::nonNull)
.filter(t -> ReasonerUtils.supers(t).contains(schemaConcept))
.findFirst().orElse(null);
return schemaConcept == null || subType == null;
}).forEach(t -> bodyAtoms.add(t.copy(body)));
return new InferenceRule(
ReasonerQueries.atomic(headAtom),
ReasonerQueries.create(bodyAtoms, tx),
rule,
tx
);
}
private InferenceRule rewriteHeadToRelation(Atom parentAtom){
if (parentAtom.isRelation() && getHead().getAtom().isResource()){
return new InferenceRule(
ReasonerQueries.atomic(getHead().getAtom().toRelationshipAtom()),
ReasonerQueries.create(getBody().getAtoms(), tx),
rule,
tx
);
}
return this;
}
public boolean isAppendRule(){
Atom headAtom = getHead().getAtom();
SchemaConcept headType = headAtom.getSchemaConcept();
if (headType.isRelationshipType()
&& headAtom.getVarName().isUserDefinedName()) {
RelationshipAtom bodyAtom = getBody().getAtoms(RelationshipAtom.class)
.filter(at -> Objects.nonNull(at.getSchemaConcept()))
.filter(at -> at.getSchemaConcept().equals(headType))
.filter(at -> at.getVarName().isUserDefinedName())
.findFirst().orElse(null);
return bodyAtom != null;
}
return false;
}
private InferenceRule rewriteVariables(Atom parentAtom){
if (parentAtom.isUserDefined() || parentAtom.requiresRoleExpansion()) {
ReasonerAtomicQuery rewrittenHead = ReasonerQueries.atomic(head.getAtom().rewriteToUserDefined(parentAtom));
List<Atom> bodyRewrites = new ArrayList<>();
//NB: only rewriting atoms from the same type hierarchy
body.getAtoms(Atom.class)
.map(at ->
ReasonerUtils.areDisjointTypes(at.getSchemaConcept(), head.getAtom().getSchemaConcept()) ?
at : at.rewriteToUserDefined(parentAtom)
)
.forEach(bodyRewrites::add);
ReasonerQueryImpl rewrittenBody = ReasonerQueries.create(bodyRewrites, tx);
return new InferenceRule(rewrittenHead, rewrittenBody, rule, tx);
}
return this;
}
private InferenceRule rewriteBodyAtoms(){
if (getBody().requiresDecomposition()) {
return new InferenceRule(getHead(), getBody().rewrite(), rule, tx);
}
return this;
}
/**
* rewrite the rule to a form with user defined variables
* @param parentAtom reference parent atom
* @return rewritten rule
*/
public InferenceRule rewrite(Atom parentAtom){
return this
.rewriteBodyAtoms()
.rewriteHeadToRelation(parentAtom)
.rewriteVariables(parentAtom);
}
/**
* @param parentAtom atom to which this rule is applied
* @param ruleUnifier unifier with parent state
* @param parent parent state
* @param visitedSubGoals set of visited sub goals
* @param cache query cache
* @return resolution subGoal formed from this rule
*/
public ResolutionState subGoal(Atom parentAtom, Unifier ruleUnifier, QueryStateBase parent, Set<ReasonerAtomicQuery> visitedSubGoals, SimpleQueryCache<ReasonerAtomicQuery> cache){
Unifier ruleUnifierInverse = ruleUnifier.inverse();
//delta' = theta . thetaP . delta
ConceptMap partialSubPrime = parentAtom.getParentQuery()
.getSubstitution()
.unify(ruleUnifierInverse);
return new RuleState(this.propagateConstraints(parentAtom, ruleUnifierInverse), partialSubPrime, ruleUnifier, parent, visitedSubGoals, cache);
}
/**
* @param parentAtom atom to unify the rule with
* @return corresponding unifier
*/
public MultiUnifier getMultiUnifier(Atom parentAtom) {
Atom childAtom = getRuleConclusionAtom();
if (parentAtom.getSchemaConcept() != null){
return childAtom.getMultiUnifier(parentAtom, UnifierType.RULE);
}
//case of match all atom (atom without type)
else{
Atom extendedParent = parentAtom
.addType(childAtom.getSchemaConcept())
.inferTypes();
return childAtom.getMultiUnifier(extendedParent, UnifierType.RULE);
}
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/rule/RuleUtils.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.rule;
import ai.grakn.GraknTx;
import ai.grakn.concept.Rule;
import ai.grakn.concept.SchemaConcept;
import ai.grakn.graql.admin.Atomic;
import ai.grakn.graql.internal.reasoner.atom.Atom;
import ai.grakn.graql.internal.reasoner.atom.AtomicEquivalence;
import ai.grakn.graql.internal.reasoner.query.ReasonerQueryImpl;
import ai.grakn.kb.internal.EmbeddedGraknTx;
import ai.grakn.util.Schema;
import com.google.common.base.Equivalence;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.Stack;
import java.util.stream.Stream;
/**
*
* <p>
* Convenience class providing methods for operating with the rule graph.
* </p>
*
* @author Kasper Piskorski
*
*/
public class RuleUtils {
/**
* @param graph of interest
* @return set of inference rule contained in the graph
*/
public static Stream<Rule> getRules(GraknTx graph) {
return ((EmbeddedGraknTx<?>) graph).ruleCache().getRules();
}
/**
* @param graph of interest
* @return true if at least one inference rule is present in the graph
*/
public static boolean hasRules(GraknTx graph) {
return graph.admin().getMetaRule().subs().anyMatch(rule -> !rule.label().equals(Schema.MetaSchema.RULE.getLabel()));
}
/**
* @param type for which rules containing it in the head are sought
* @param graph of interest
* @return rules containing specified type in the head
*/
public static Stream<Rule> getRulesWithType(SchemaConcept type, boolean direct, GraknTx graph){
return ((EmbeddedGraknTx<?>) graph).ruleCache().getRulesWithType(type, direct);
}
/**
* @param rules set of rules of interest forming a rule subgraph
* @return true if the rule subgraph formed from provided rules contains loops
*/
public static boolean subGraphIsCyclical(Set<InferenceRule> rules){
Iterator<Rule> ruleIterator = rules.stream()
.map(InferenceRule::getRule)
.iterator();
boolean cyclical = false;
while (ruleIterator.hasNext() && !cyclical){
Set<Rule> visitedRules = new HashSet<>();
Stack<Rule> rulesToVisit = new Stack<>();
rulesToVisit.push(ruleIterator.next());
while(!rulesToVisit.isEmpty() && !cyclical) {
Rule rule = rulesToVisit.pop();
if (!visitedRules.contains(rule)){
rule.thenTypes()
.flatMap(SchemaConcept::whenRules)
.forEach(rulesToVisit::add);
visitedRules.add(rule);
} else {
cyclical = true;
}
}
}
return cyclical;
}
/**
* @param rules set of rules of interest forming a rule subgraph
* @return true if the rule subgraph formed from provided rules contains any rule with head satisfying the body pattern
*/
public static boolean subGraphHasRulesWithHeadSatisfyingBody(Set<InferenceRule> rules){
return rules.stream()
.anyMatch(InferenceRule::headSatisfiesBody);
}
/**
* @param query top query
* @return all rules that are reachable from the entry types
*/
public static Set<InferenceRule> getDependentRules(ReasonerQueryImpl query){
final Equivalence<Atomic> equivalence = AtomicEquivalence.AlphaEquivalence;
Set<InferenceRule> rules = new HashSet<>();
Set<Equivalence.Wrapper<Atom>> visitedAtoms = new HashSet<>();
Stack<Equivalence.Wrapper<Atom>> atoms = new Stack<>();
query.selectAtoms().map(equivalence::wrap).forEach(atoms::push);
while(!atoms.isEmpty()) {
Equivalence.Wrapper<Atom> wrappedAtom = atoms.pop();
Atom atom = wrappedAtom.get();
if (!visitedAtoms.contains(wrappedAtom) && atom != null){
atom.getApplicableRules()
.peek(rules::add)
.flatMap(rule -> rule.getBody().selectAtoms())
.map(equivalence::wrap)
.filter(at -> !visitedAtoms.contains(at))
.filter(at -> !atoms.contains(at))
.forEach(atoms::add);
visitedAtoms.add(wrappedAtom);
}
}
return rules;
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/state/AnswerState.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.state;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.internal.reasoner.rule.InferenceRule;
/**
*
* <p>
* Resolution state holding an answer ({@link ConceptMap}) to the parent state.
* </p>
*
* @author Kasper Piskorski
*
*/
public class AnswerState extends ResolutionState {
private final InferenceRule rule;
private final Unifier unifier;
public AnswerState(ConceptMap sub, Unifier u, QueryStateBase parent) {
this(sub, u, parent, null);
}
AnswerState(ConceptMap sub, Unifier u, QueryStateBase parent, InferenceRule rule) {
super(sub, parent);
this.unifier = u;
this.rule = rule;
}
@Override
public boolean isAnswerState(){ return true;}
@Override
public ResolutionState generateSubGoal() {
return getParentState().propagateAnswer(this);
}
InferenceRule getRule(){ return rule;}
Unifier getUnifier(){ return unifier;}
ConceptMap getAnswer(){ return getParentState().consumeAnswer(this);}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/state/AtomicState.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.state;
import ai.grakn.graql.Var;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.internal.query.answer.ConceptMapImpl;
import ai.grakn.graql.internal.reasoner.cache.SimpleQueryCache;
import ai.grakn.graql.internal.reasoner.explanation.RuleExplanation;
import ai.grakn.graql.internal.reasoner.query.ReasonerAtomicQuery;
import ai.grakn.graql.internal.reasoner.query.ReasonerQueries;
import ai.grakn.graql.internal.reasoner.rule.InferenceRule;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Set;
/**
*
* <p>
* Query state corresponding to an atomic query ({@link ReasonerAtomicQuery}) in the resolution tree.
* </p>
*
* @author Kasper Piskorski
*
*/
@SuppressFBWarnings("BC_UNCONFIRMED_CAST_OF_RETURN_VALUE")
class AtomicState extends QueryState<ReasonerAtomicQuery>{
AtomicState(ReasonerAtomicQuery query,
ConceptMap sub,
Unifier u,
QueryStateBase parent,
Set<ReasonerAtomicQuery> subGoals,
SimpleQueryCache<ReasonerAtomicQuery> cache) {
super(ReasonerQueries.atomic(query, sub),
sub,
u,
() -> cache.getAnswerStreamWithUnifier(ReasonerQueries.atomic(query, sub)).getValue().inverse(),
parent,
subGoals,
cache);
}
@Override
ResolutionState propagateAnswer(AnswerState state){
ConceptMap answer = state.getAnswer();
ReasonerAtomicQuery query = getQuery();
if (answer.isEmpty()) return null;
if (state.getRule() != null && query.getAtom().requiresRoleExpansion()){
return new RoleExpansionState(answer, getUnifier(), query.getAtom().getRoleExpansionVariables(), getParentState());
}
return new AnswerState(answer, getUnifier(), getParentState());
}
@Override
ConceptMap consumeAnswer(AnswerState state) {
ConceptMap answer;
ReasonerAtomicQuery query = getQuery();
ConceptMap baseAnswer = state.getSubstitution();
InferenceRule rule = state.getRule();
Unifier unifier = state.getUnifier();
if (rule == null){
answer = baseAnswer.merge(query.getSubstitution());
}
else{
answer = rule.requiresMaterialisation(query.getAtom()) ?
materialisedAnswer(baseAnswer, rule, unifier) :
ruleAnswer(baseAnswer, rule, unifier);
}
return getCache().record(query, answer, getCacheUnifier());
}
private ConceptMap ruleAnswer(ConceptMap baseAnswer, InferenceRule rule, Unifier unifier){
ReasonerAtomicQuery query = getQuery();
ConceptMap answer = baseAnswer
.merge(rule.getHead().getRoleSubstitution())
.unify(unifier);
if (answer.isEmpty()) return answer;
return answer
.merge(query.getSubstitution())
.project(query.getVarNames())
.explain(new RuleExplanation(query, rule));
}
private ConceptMap materialisedAnswer(ConceptMap baseAnswer, InferenceRule rule, Unifier unifier){
ConceptMap answer = baseAnswer;
ReasonerAtomicQuery query = getQuery();
SimpleQueryCache<ReasonerAtomicQuery> cache = getCache();
ReasonerAtomicQuery subbedQuery = ReasonerQueries.atomic(query, answer);
ReasonerAtomicQuery ruleHead = ReasonerQueries.atomic(rule.getHead(), answer);
Set<Var> queryVars = query.getVarNames().size() < ruleHead.getVarNames().size()?
unifier.keySet() :
ruleHead.getVarNames();
boolean queryEquivalentToHead = subbedQuery.isEquivalent(ruleHead);
//check if the specific answer to ruleHead already in cache/db
ConceptMap headAnswer = cache
.getAnswer(ruleHead, answer)
.project(queryVars)
.unify(unifier);
//if not and query different than rule head do the same with the query
ConceptMap queryAnswer = headAnswer.isEmpty() && queryEquivalentToHead?
cache.getAnswer(query, answer) :
new ConceptMapImpl();
//ensure no duplicates created - only materialise answer if it doesn't exist in the db
if (headAnswer.isEmpty()
&& queryAnswer.isEmpty()) {
ConceptMap materialisedSub = ruleHead.materialise(answer).findFirst().orElse(null);
if (!queryEquivalentToHead) cache.record(ruleHead, materialisedSub);
answer = materialisedSub
.project(queryVars)
.unify(unifier);
} else {
answer = headAnswer.isEmpty()? queryAnswer : headAnswer;
}
if (answer.isEmpty()) return answer;
return answer
.merge(query.getSubstitution())
.explain(new RuleExplanation(query, rule));
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/state/AtomicStateProducer.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.state;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.internal.reasoner.atom.predicate.NeqPredicate;
import ai.grakn.graql.internal.reasoner.cache.SimpleQueryCache;
import ai.grakn.graql.internal.reasoner.query.ReasonerAtomicQuery;
import com.google.common.collect.Iterators;
import java.util.Iterator;
import java.util.Set;
/**
*
* <p>
* State producing {@link AtomicState}s:
* - typed {@link AtomicState}s if type inference is required
* - {@link AtomicState} for non-negated non-ambiguous {@link ReasonerAtomicQuery}
* - {@link NeqComplementState} for non-ambiguous {@link ReasonerAtomicQuery} with negation
* </p>
*
* @author Kasper Piskorski
*
*/
public class AtomicStateProducer extends QueryStateBase {
private final Iterator<ResolutionState> subGoalIterator;
public AtomicStateProducer(ReasonerAtomicQuery query, ConceptMap sub, Unifier u, QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, SimpleQueryCache<ReasonerAtomicQuery> cache) {
super(sub, u, parent, subGoals, cache);
if(query.getAtom().getSchemaConcept() == null){
this.subGoalIterator = query.subGoals(sub, u, parent, subGoals, cache).iterator();
} else {
this.subGoalIterator = Iterators.singletonIterator(
query.getAtoms(NeqPredicate.class).findFirst().isPresent() ?
new NeqComplementState(query, sub, u, parent, subGoals, cache) :
new AtomicState(query, sub, u, parent, subGoals, cache)
);
}
}
@Override
public ResolutionState generateSubGoal() {
return subGoalIterator.hasNext() ? subGoalIterator.next() : null;
}
@Override
ResolutionState propagateAnswer(AnswerState state) {
return new AnswerState(state.getSubstitution(), state.getUnifier(), getParentState());
}
@Override
ConceptMap consumeAnswer(AnswerState state) {
return state.getSubstitution();
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/state/ConjunctiveState.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.state;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.MultiUnifier;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.internal.reasoner.MultiUnifierImpl;
import ai.grakn.graql.internal.reasoner.cache.SimpleQueryCache;
import ai.grakn.graql.internal.reasoner.query.ReasonerAtomicQuery;
import ai.grakn.graql.internal.reasoner.query.ReasonerQueries;
import ai.grakn.graql.internal.reasoner.query.ReasonerQueryImpl;
import java.util.Set;
/**
*
* <p>
* Query state corresponding to a conjunctive query ({@link ReasonerQueryImpl}) in the resolution tree.
* </p>
*
* @author Kasper Piskorski
*
*/
public class ConjunctiveState extends QueryState<ReasonerQueryImpl> {
public ConjunctiveState(ReasonerQueryImpl q,
ConceptMap sub,
Unifier u,
QueryStateBase parent,
Set<ReasonerAtomicQuery> visitedSubGoals,
SimpleQueryCache<ReasonerAtomicQuery> cache) {
super(ReasonerQueries.create(q, sub), sub, u, MultiUnifierImpl::new, parent, visitedSubGoals, cache);
}
@Override
MultiUnifier getCacheUnifier() { return new MultiUnifierImpl();}
@Override
ResolutionState propagateAnswer(AnswerState state){
ConceptMap answer = state.getAnswer();
return !answer.isEmpty()? new AnswerState(answer, getUnifier(), getParentState()) : null;
}
@Override
ConceptMap consumeAnswer(AnswerState state) {
return state.getSubstitution();
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/state/CumulativeState.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.state;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.internal.reasoner.cache.SimpleQueryCache;
import ai.grakn.graql.internal.reasoner.query.ReasonerAtomicQuery;
import ai.grakn.graql.internal.reasoner.query.ReasonerQueryImpl;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
/**
*
* <p>
* Query state corresponding to a an intermediate state obtained from decomposing a conjunctive query ({@link ReasonerQueryImpl}) in the resolution tree.
* </p>
*
* @author Kasper Piskorski
*
*/
public class CumulativeState extends QueryStateBase{
private final LinkedList<ReasonerQueryImpl> subQueries;
private final Iterator<ResolutionState> feederStateIterator;
private final ReasonerQueryImpl query;
public CumulativeState(List<ReasonerQueryImpl> qs,
ConceptMap sub,
Unifier u,
QueryStateBase parent,
Set<ReasonerAtomicQuery> subGoals,
SimpleQueryCache<ReasonerAtomicQuery> cache) {
super(sub, u, parent, subGoals, cache);
this.subQueries = new LinkedList<>(qs);
this.query = subQueries.getFirst();
//NB: we need lazy subGoal initialisation here, otherwise they are marked as visited before visit happens
this.feederStateIterator = !subQueries.isEmpty()?
subQueries.removeFirst().subGoals(sub, u, this, subGoals, cache).iterator() :
Collections.emptyIterator();
}
@Override
public String toString(){
return super.toString() + "\n" +
getSubstitution() + "\n" +
query + "\n" +
subQueries.stream().map(ReasonerQueryImpl::toString).collect(Collectors.joining("\n")) + "\n";
}
@Override
public ResolutionState propagateAnswer(AnswerState state) {
ConceptMap answer = getSubstitution().merge(state.getSubstitution(), true);
if (answer.isEmpty()) return null;
if (subQueries.isEmpty()) return new AnswerState(answer, getUnifier(), getParentState());
return new CumulativeState(subQueries, answer, getUnifier(), getParentState(), getVisitedSubGoals(), getCache());
}
@Override
public ResolutionState generateSubGoal(){
return feederStateIterator.hasNext()? feederStateIterator.next() : null;
}
@Override
ConceptMap consumeAnswer(AnswerState state) {
return state.getSubstitution();
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/state/NeqComplementState.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.state;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.internal.reasoner.atom.predicate.NeqPredicate;
import ai.grakn.graql.internal.reasoner.cache.SimpleQueryCache;
import ai.grakn.graql.internal.reasoner.query.ReasonerAtomicQuery;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Set;
import java.util.stream.Collectors;
/**
*
* <p>
* Query state corresponding to an atomic query ({@link ReasonerAtomicQuery}) with neq predicates ({@link NeqPredicate}).
* Defining the answer to the entry query Q as a set B:
*
* B = Ans{R(x1, x2, ..., xn), xj = ..., xi != xj}
*
* We find the answer to the query by finding the complement:
*
* B = A\C,
*
* where
*
* A = Ans{R(x1, x2, ..., xn), xj = ...}
* C = Ans{R(x1, x2, ..., xn), xj = ..., xi = xj}
*
* </p>
*
* @author Kasper Piskorski
*
*/
@SuppressFBWarnings("BC_UNCONFIRMED_CAST_OF_RETURN_VALUE")
public class NeqComplementState extends AtomicState {
private final ResolutionState complementState;
private boolean visited = false;
private final ConceptMap neqPredicateSub;
private final Set<NeqPredicate> neqPredicates;
NeqComplementState(ReasonerAtomicQuery q,
ConceptMap sub,
Unifier u,
QueryStateBase parent,
Set<ReasonerAtomicQuery> subGoals,
SimpleQueryCache<ReasonerAtomicQuery> cache) {
super(q, sub, u, parent, subGoals, cache);
this.neqPredicates = q.getAtoms(NeqPredicate.class).collect(Collectors.toSet());
this.neqPredicateSub = getQuery().getSubstitution().merge(sub)
.project(this.neqPredicates.stream().flatMap(p -> p.getVarNames().stream()).collect(Collectors.toSet()));
complementState = getQuery().positive().subGoal(sub, u, this, subGoals, cache);
}
@Override
public ResolutionState propagateAnswer(AnswerState state) {
ConceptMap fullAnswer = state.getSubstitution().merge(neqPredicateSub);
boolean isNeqSatisfied = neqPredicates.stream()
.allMatch(p -> p.isSatisfied(fullAnswer));
return isNeqSatisfied?
new AnswerState(state.getSubstitution(), getUnifier(), getParentState()) :
null;
}
@Override
public ResolutionState generateSubGoal() {
if (!visited){
visited = true;
return complementState;
}
return null;
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/state/QueryState.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.state;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.MultiUnifier;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.internal.reasoner.cache.SimpleQueryCache;
import ai.grakn.graql.internal.reasoner.query.ReasonerAtomicQuery;
import ai.grakn.graql.internal.reasoner.query.ReasonerQueryImpl;
import java.util.Iterator;
import java.util.Set;
import java.util.function.Supplier;
/**
*
* <p>
* Specialised class for resolution states corresponding to different forms of queries.
* </p>
*
* @param <Q> the type of query that this state is corresponding to
*
* @author Kasper Piskorski
*
*/
public abstract class QueryState<Q extends ReasonerQueryImpl> extends QueryStateBase{
private final Q query;
private final Iterator<ResolutionState> subGoalIterator;
private final Supplier<MultiUnifier> cacheUnifierSupplier;
private MultiUnifier cacheUnifier = null;
QueryState(Q query, ConceptMap sub, Unifier u, Supplier<MultiUnifier> cus, QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, SimpleQueryCache<ReasonerAtomicQuery> cache) {
super(sub, u, parent, subGoals, cache);
this.query = query;
this.subGoalIterator = query.queryStateIterator(this, subGoals, cache);
this.cacheUnifierSupplier = cus;
}
@Override
public String toString(){ return super.toString() + "\n" + getQuery() + "\n"; }
@Override
public ResolutionState generateSubGoal() {
return subGoalIterator.hasNext()? subGoalIterator.next() : null;
}
/**
* @return query corresponding to this query state
*/
Q getQuery(){ return query;}
/**
* @return cache unifier if any
*/
MultiUnifier getCacheUnifier(){
if (cacheUnifier == null) this.cacheUnifier = cacheUnifierSupplier.get();
return cacheUnifier;
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/state/QueryStateBase.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.state;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.internal.reasoner.cache.SimpleQueryCache;
import ai.grakn.graql.internal.reasoner.query.ReasonerAtomicQuery;
import java.util.Set;
/**
*
* <p>
* Base abstract class for resolution states corresponding to different forms of queries.
* </p>
*
* @author Kasper Piskorski
*
*/
public abstract class QueryStateBase extends ResolutionState {
private final Unifier unifier;
private final Set<ReasonerAtomicQuery> visitedSubGoals;
private final SimpleQueryCache<ReasonerAtomicQuery> cache;
QueryStateBase(ConceptMap sub, Unifier u, QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, SimpleQueryCache<ReasonerAtomicQuery> cache) {
super(sub, parent);
this.unifier = u;
this.visitedSubGoals = subGoals;
this.cache = cache;
}
/**
* @return set of already visited subGoals (atomic queries)
*/
Set<ReasonerAtomicQuery> getVisitedSubGoals(){ return visitedSubGoals;}
/**
* @return query cache
*/
SimpleQueryCache<ReasonerAtomicQuery> getCache(){ return cache;}
/**
* @return unifier of this state with parent state
*/
public Unifier getUnifier(){ return unifier;}
/**
* propagates the answer state up the tree and acknowledges (caches) its substitution
* @param state to propagate
* @return new resolution state obtained by propagating the answer up the resolution tree
*/
abstract ResolutionState propagateAnswer(AnswerState state);
/**
* @param state answer state providing the answer
* @return digested (acknowledged and cached) answer
*/
abstract ConceptMap consumeAnswer(AnswerState state);
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/state/ResolutionState.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.state;
import ai.grakn.graql.answer.ConceptMap;
/**
*
* <p>
* Base abstract class for resolution states.
* </p>
*
* @author Kasper Piskorski
*
*/
public abstract class ResolutionState {
private final ConceptMap sub;
private final QueryStateBase parentState;
ResolutionState(ConceptMap sub, QueryStateBase parent){
this.sub = sub;
this.parentState = parent;
}
@Override
public String toString(){ return getClass().getSimpleName() + "@" + Integer.toHexString(hashCode());}
/**
* @return new sub goal generated from this state
*/
public abstract ResolutionState generateSubGoal();
/**
* @return substitution this state has
*/
public ConceptMap getSubstitution(){ return sub;}
/**
* @return true if this resolution state is an answer state
*/
public boolean isAnswerState(){ return false;}
/**
* @return true if this state is a top resolution state
*/
public boolean isTopState(){
return parentState == null;
}
/**
* @return parent state of this state
*/
QueryStateBase getParentState(){ return parentState;}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/state/RoleExpansionState.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.state;
import ai.grakn.concept.Role;
import ai.grakn.graql.Var;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.internal.reasoner.query.ReasonerAtomicQuery;
import java.util.Iterator;
import java.util.Set;
/**
*
* <p>
* Query state produced by {@link AtomicState} when an atomic query {@link ReasonerAtomicQuery} contains {@link Role} variables which may require role hierarchy expansion.
* </p>
*
* @author Kasper Piskorski
*
*/
class RoleExpansionState extends ResolutionState {
private final Iterator<AnswerState> answerStateIterator;
RoleExpansionState(ConceptMap sub, Unifier u, Set<Var> toExpand, QueryStateBase parent) {
super(sub, parent);
this.answerStateIterator = getSubstitution()
.expandHierarchies(toExpand)
.map(ans -> new AnswerState(ans, u, getParentState()))
.iterator();
}
@Override
public ResolutionState generateSubGoal() {
if (!answerStateIterator.hasNext()) return null;
AnswerState state = answerStateIterator.next();
return getParentState() != null? getParentState().propagateAnswer(state) : state;
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/state/RuleState.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.state;
import ai.grakn.graql.answer.ConceptMap;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.internal.reasoner.cache.SimpleQueryCache;
import ai.grakn.graql.internal.reasoner.query.ReasonerAtomicQuery;
import ai.grakn.graql.internal.reasoner.rule.InferenceRule;
import com.google.common.collect.Iterators;
import java.util.Iterator;
import java.util.Set;
/**
*
* <p>
* Resolution state corresponding to a rule application.
* </p>
*
* @author Kasper Piskorski
*
*/
public class RuleState extends QueryStateBase{
private final InferenceRule rule;
private final Iterator<ResolutionState> bodyIterator;
public RuleState(InferenceRule rule, ConceptMap sub, Unifier unifier, QueryStateBase parent, Set<ReasonerAtomicQuery> visitedSubGoals, SimpleQueryCache<ReasonerAtomicQuery> cache) {
super(sub, unifier, parent, visitedSubGoals, cache);
this.bodyIterator = Iterators.singletonIterator(rule.getBody().subGoal(sub, unifier, this, visitedSubGoals, cache));
this.rule = rule;
}
@Override
public String toString(){
return super.toString() + "\n" + rule + "\n";
}
@Override
ResolutionState propagateAnswer(AnswerState state){
ConceptMap answer = state.getAnswer();
return !answer.isEmpty()? new AnswerState(answer, getUnifier(), getParentState(), rule) : null;
}
@Override
public ResolutionState generateSubGoal() {
return bodyIterator.hasNext() ? bodyIterator.next() : null;
}
@Override
ConceptMap consumeAnswer(AnswerState state) {
return state.getSubstitution();
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils/IgnoreHashEquals.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.utils;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.RetentionPolicy.SOURCE;
/**
*
* <p>
* Annotation for ignoring a property in equals/hash auto-value generation.
* NB: It has to be defined in the most specialised class.
* </p>
*
* @author Robert Eggar
*
*/
@Retention(SOURCE)
@Target({METHOD, PARAMETER, FIELD})
public @interface IgnoreHashEquals {
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils/IncludeHashEquals.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.utils;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.RetentionPolicy.SOURCE;
/**
*
* <p>
* Annotation for including a property in equals/hash auto-value generation.
* NB: It has to be defined in the most specialised class.
* </p>
*
* @author Robert Eggar
*
*/
@Retention(SOURCE)
@Target({METHOD, PARAMETER, FIELD})
public @interface IncludeHashEquals {
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils/Pair.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.utils;
import java.util.AbstractMap;
/**
*
* <p>
* Convenience pair class wrapping a SimpleImmutableEntry object.
* </p>
*
* @param <K> key type
* @param <V> value type
*
* @author Kasper Piskorski
*
*/
public class Pair<K, V> {
private final AbstractMap.SimpleImmutableEntry<K, V> data;
public Pair(K key, V value){
data = new AbstractMap.SimpleImmutableEntry<>(key, value);
}
@Override
public int hashCode(){ return data.hashCode();}
@Override
public boolean equals(Object obj){
if (obj == null || this.getClass() != obj.getClass()) return false;
if (obj == this) return true;
Pair p = (Pair) obj;
return data.equals(p.data);
}
public K getKey(){ return data.getKey();}
public V getValue(){ return data.getValue();}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils/ReasonerUtils.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.utils;
import ai.grakn.concept.RelationshipType;
import ai.grakn.concept.Role;
import ai.grakn.concept.SchemaConcept;
import ai.grakn.concept.Type;
import ai.grakn.graql.Var;
import ai.grakn.graql.admin.ReasonerQuery;
import ai.grakn.graql.admin.Unifier;
import ai.grakn.graql.admin.UnifierComparison;
import ai.grakn.graql.admin.VarPatternAdmin;
import ai.grakn.graql.internal.pattern.property.IdProperty;
import ai.grakn.graql.internal.pattern.property.LabelProperty;
import ai.grakn.graql.internal.pattern.property.ValueProperty;
import ai.grakn.graql.internal.reasoner.atom.binary.TypeAtom;
import ai.grakn.graql.internal.reasoner.atom.predicate.IdPredicate;
import ai.grakn.graql.internal.reasoner.atom.predicate.ValuePredicate;
import ai.grakn.graql.internal.reasoner.utils.conversion.RoleConverter;
import ai.grakn.graql.internal.reasoner.utils.conversion.SchemaConceptConverter;
import ai.grakn.graql.internal.reasoner.utils.conversion.TypeConverter;
import ai.grakn.util.Schema;
import com.google.common.base.Equivalence;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Iterables;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiFunction;
import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.stream.Stream;
import static ai.grakn.graql.internal.reasoner.atom.predicate.ValuePredicate.createValueVar;
import static java.util.stream.Collectors.toSet;
/**
*
* <p>
* Utiliy class providing useful functionalities.
* </p>
*
* @author Kasper Piskorski
*
*/
public class ReasonerUtils {
/**
* looks for an appropriate var property with a specified name among the vars and maps it to an IdPredicate,
* covers the case when specified variable name is user defined
* @param typeVariable variable name of interest
* @param vars VarAdmins to look for properties
* @param parent reasoner query the mapped predicate should belong to
* @return mapped IdPredicate
*/
public static IdPredicate getUserDefinedIdPredicate(Var typeVariable, Set<VarPatternAdmin> vars, ReasonerQuery parent){
return vars.stream()
.filter(v -> v.var().equals(typeVariable))
.flatMap(v -> v.hasProperty(LabelProperty.class)?
v.getProperties(LabelProperty.class).map(np -> IdPredicate.create(typeVariable, np.label(), parent)) :
v.getProperties(IdProperty.class).map(np -> IdPredicate.create(typeVariable, np.id(), parent)))
.findFirst().orElse(null);
}
/**
* looks for an appropriate var property with a specified name among the vars and maps it to an IdPredicate,
* covers both the cases when variable is and isn't user defined
* @param typeVariable variable name of interest
* @param typeVar {@link VarPatternAdmin} to look for in case the variable name is not user defined
* @param vars VarAdmins to look for properties
* @param parent reasoner query the mapped predicate should belong to
* @return mapped IdPredicate
*/
@Nullable
public static IdPredicate getIdPredicate(Var typeVariable, VarPatternAdmin typeVar, Set<VarPatternAdmin> vars, ReasonerQuery parent){
IdPredicate predicate = null;
//look for id predicate among vars
if(typeVar.var().isUserDefinedName()) {
predicate = getUserDefinedIdPredicate(typeVariable, vars, parent);
} else {
LabelProperty nameProp = typeVar.getProperty(LabelProperty.class).orElse(null);
if (nameProp != null) predicate = IdPredicate.create(typeVariable, nameProp.label(), parent);
}
return predicate;
}
/**
* looks for appropriate var properties with a specified name among the vars and maps them to ValuePredicates,
* covers both the case when variable is and isn't user defined
* @param valueVariable variable name of interest
* @param valueVar {@link VarPatternAdmin} to look for in case the variable name is not user defined
* @param vars VarAdmins to look for properties
* @param parent reasoner query the mapped predicate should belong to
* @return set of mapped ValuePredicates
*/
public static Set<ValuePredicate> getValuePredicates(Var valueVariable, VarPatternAdmin valueVar, Set<VarPatternAdmin> vars, ReasonerQuery parent){
Set<ValuePredicate> predicates = new HashSet<>();
if(valueVar.var().isUserDefinedName()){
vars.stream()
.filter(v -> v.var().equals(valueVariable))
.flatMap(v -> v.getProperties(ValueProperty.class).map(vp -> ValuePredicate.create(v.var(), vp.predicate(), parent)))
.forEach(predicates::add);
}
//add value atom
else {
valueVar.getProperties(ValueProperty.class)
.forEach(vp -> predicates
.add(ValuePredicate.create(createValueVar(valueVariable, vp.predicate()), parent)));
}
return predicates;
}
/**
* @param schemaConcept input type
* @return set of all non-meta super types of the role
*/
public static Set<SchemaConcept> supers(SchemaConcept schemaConcept){
Set<SchemaConcept> superTypes = new HashSet<>();
SchemaConcept superType = schemaConcept.sup();
while(superType != null && !Schema.MetaSchema.isMetaLabel(superType.label())) {
superTypes.add(superType);
superType = superType.sup();
}
return superTypes;
}
/**
* @param concept which hierarchy should be considered
* @return set of {@link SchemaConcept}s consisting of the provided {@link SchemaConcept} and all its supers including meta
*/
public static Set<SchemaConcept> upstreamHierarchy(SchemaConcept concept){
Set<SchemaConcept> concepts = new HashSet<>();
SchemaConcept superType = concept;
while(superType != null) {
concepts.add(superType);
superType = superType.sup();
}
return concepts;
}
/**
* calculates map intersection by doing an intersection on key sets and accumulating the keys
* @param m1 first operand
* @param m2 second operand
* @param <K> map key type
* @param <V> map value type
* @return map intersection
*/
public static <K, V> Multimap<K, V> multimapIntersection(Multimap<K, V> m1, Multimap<K, V> m2){
Multimap<K, V> intersection = HashMultimap.create();
Sets.SetView<K> keyIntersection = Sets.intersection(m1.keySet(), m2.keySet());
Stream.concat(m1.entries().stream(), m2.entries().stream())
.filter(e -> keyIntersection.contains(e.getKey()))
.forEach(e -> intersection.put(e.getKey(), e.getValue()));
return intersection;
}
/**
* NB: assumes MATCH semantics - all types and their subs are considered
* compute the map of compatible {@link RelationshipType}s for a given set of {@link Type}s
* (intersection of allowed sets of relation types for each entry type) and compatible role types
* @param types for which the set of compatible {@link RelationshipType}s is to be computed
* @param schemaConceptConverter converter between {@link SchemaConcept} and relation type-role entries
* @param <T> type generic
* @return map of compatible {@link RelationshipType}s and their corresponding {@link Role}s
*/
public static <T extends SchemaConcept> Multimap<RelationshipType, Role> compatibleRelationTypesWithRoles(Set<T> types, SchemaConceptConverter<T> schemaConceptConverter) {
Multimap<RelationshipType, Role> compatibleTypes = HashMultimap.create();
if (types.isEmpty()) return compatibleTypes;
Iterator<T> typeIterator = types.iterator();
compatibleTypes.putAll(schemaConceptConverter.toRelationshipMultimap(typeIterator.next()));
while(typeIterator.hasNext() && compatibleTypes.size() > 1) {
compatibleTypes = multimapIntersection(compatibleTypes, schemaConceptConverter.toRelationshipMultimap(typeIterator.next()));
}
return compatibleTypes;
}
/**
* NB: assumes MATCH semantics - all types and their subs are considered
* @param parentRole parent {@link Role}
* @param parentType parent {@link Type}
* @param entryRoles entry set of possible {@link Role}s
* @return set of playable {@link Role}s defined by type-role parent combination, parent role assumed as possible
*/
public static Set<Role> compatibleRoles(Role parentRole, Type parentType, Set<Role> entryRoles) {
Set<Role> compatibleRoles = parentRole != null? Sets.newHashSet(parentRole) : Sets.newHashSet();
if (parentRole != null && !Schema.MetaSchema.isMetaLabel(parentRole.label()) ){
compatibleRoles.addAll(
Sets.intersection(
new RoleConverter().toCompatibleRoles(parentRole).collect(toSet()),
entryRoles
));
} else {
compatibleRoles.addAll(entryRoles);
}
if (parentType != null && !Schema.MetaSchema.isMetaLabel(parentType.label())) {
Set<Role> compatibleRolesFromTypes = new TypeConverter().toCompatibleRoles(parentType).collect(toSet());
//do set intersection meta role
compatibleRoles = compatibleRoles.stream()
.filter(role -> Schema.MetaSchema.isMetaLabel(role.label()) || compatibleRolesFromTypes.contains(role))
.collect(toSet());
//parent role also possible
if (parentRole != null) compatibleRoles.add(parentRole);
}
return compatibleRoles;
}
public static Set<Role> compatibleRoles(Type type, Set<Role> relRoles){
return compatibleRoles(null, type, relRoles);
}
/**
* @param schemaConcepts entry {@link SchemaConcept} set
* @return top non-meta {@link SchemaConcept}s from within the provided set
*/
public static <T extends SchemaConcept> Set<T> top(Set<T> schemaConcepts) {
return schemaConcepts.stream()
.filter(rt -> Sets.intersection(supers(rt), schemaConcepts).isEmpty())
.collect(toSet());
}
/**
* @param schemaConcepts entry {@link SchemaConcept} set
* @return top {@link SchemaConcept}s from within the provided set or meta concept if it exists
*/
public static <T extends SchemaConcept> Set<T> topOrMeta(Set<T> schemaConcepts) {
Set<T> concepts = top(schemaConcepts);
T meta = concepts.stream()
.filter(c -> Schema.MetaSchema.isMetaLabel(c.label()))
.findFirst().orElse(null);
return meta != null ? Collections.singleton(meta) : concepts;
}
/**
* @param childTypes type atoms of child query
* @param parentTypes type atoms of parent query
* @param childParentUnifier unifier to unify child with parent
* @return combined unifier for type atoms
*/
public static Unifier typeUnifier(Set<TypeAtom> childTypes, Set<TypeAtom> parentTypes, Unifier childParentUnifier, UnifierComparison unifierType){
Unifier unifier = childParentUnifier;
for(TypeAtom childType : childTypes){
Var childVarName = childType.getVarName();
Var parentVarName = childParentUnifier.containsKey(childVarName)? Iterables.getOnlyElement(childParentUnifier.get(childVarName)) : childVarName;
//types are unique so getting one is fine
TypeAtom parentType = parentTypes.stream().filter(pt -> pt.getVarName().equals(parentVarName)).findFirst().orElse(null);
if (parentType != null) unifier = unifier.merge(childType.getUnifier(parentType, unifierType));
}
return unifier;
}
/**
* @param parent type
* @param child type
* @return true if child is a subtype of parent
*/
public static boolean typesCompatible(SchemaConcept parent, SchemaConcept child) {
if (parent == null) return true;
if (child == null) return false;
if (Schema.MetaSchema.isMetaLabel(parent.label())) return true;
SchemaConcept superType = child;
while(superType != null && !Schema.MetaSchema.isMetaLabel(superType.label())){
if (superType.equals(parent)) return true;
superType = superType.sup();
}
return false;
}
/** determines disjointness of parent-child types, parent defines the bound on the child
* @param parent {@link SchemaConcept}
* @param child {@link SchemaConcept}
* @return true if types do not belong to the same type hierarchy, also true if parent is null and false if parent non-null and child null
*/
public static boolean areDisjointTypes(SchemaConcept parent, SchemaConcept child) {
return parent != null && child == null || !typesCompatible(parent, child) && !typesCompatible(child, parent);
}
/**
* @param a first operand
* @param b second operand
* @param comparison function on the basis of which the collections shall be compared
* @param <T> collection type
* @return true iff the given collections contain equivalent elements with exactly the same cardinalities.
*/
public static <T> boolean isEquivalentCollection(Collection<T> a, Collection<T> b, BiFunction<T, T, Boolean> comparison) {
return a.size() == b.size()
&& a.stream().allMatch(e -> b.stream().anyMatch(e2 -> comparison.apply(e, e2)))
&& b.stream().allMatch(e -> a.stream().anyMatch(e2 -> comparison.apply(e, e2)));
}
private static <B, S extends B> Map<Equivalence.Wrapper<B>, Integer> getCardinalityMap(Collection<S> coll, Equivalence<B> equiv) {
Map<Equivalence.Wrapper<B>, Integer> count = new HashMap<>();
for (S obj : coll) {
count.merge(equiv.wrap(obj), 1, (a, b) -> a + b);
}
return count;
}
private static <T> int getFreq(T obj, Map<T, Integer> freqMap) {
Integer count = freqMap.get(obj);
return count != null ? count : 0;
}
/**
* @param a first operand
* @param b second operand
* @param equiv equivalence on the basis of which the collections shall be compared
* @param <B> collection base type
* @param <S> collection super type
* @return true iff the given Collections contain equivalent elements with exactly the same cardinalities.
*/
public static <B, S extends B> boolean isEquivalentCollection(Collection<S> a, Collection<S> b, Equivalence<B> equiv) {
if (a.size() != b.size()) {
return false;
} else {
Map<Equivalence.Wrapper<B>, Integer> mapa = getCardinalityMap(a, equiv);
Map<Equivalence.Wrapper<B>, Integer> mapb = getCardinalityMap(b, equiv);
if (mapa.size() != mapb.size()) {
return false;
} else {
Iterator<Equivalence.Wrapper<B>> it = mapa.keySet().iterator();
Equivalence.Wrapper<B> obj;
do {
if (!it.hasNext()) {
return true;
}
obj = it.next();
} while (getFreq(obj, mapa) == getFreq(obj, mapb));
return false;
}
}
}
/**
* @param a subtraction left operand
* @param b subtraction right operand
* @param <T> collection type
* @return new Collection containing a minus a - b.
* The cardinality of each element e in the returned Collection will be the cardinality of e in a minus the cardinality of e in b, or zero, whichever is greater.
*/
public static <T> Collection<T> subtract(Collection<T> a, Collection<T> b){
ArrayList<T> list = new ArrayList<>(a);
b.forEach(list::remove);
return list;
}
/**
*
* @param a union left operand
* @param b union right operand
* @param <T> list type
* @return new list being a union of the two operands
*/
public static <T> List<T> listUnion(List<T> a, List<T> b){
List<T> union = new ArrayList<>(a);
union.addAll(b);
return union;
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils/conversion/AttributeConverter.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.utils.conversion;
import ai.grakn.concept.Attribute;
import ai.grakn.graql.Graql;
import ai.grakn.graql.Pattern;
import ai.grakn.graql.Var;
import ai.grakn.graql.VarPattern;
/**
* <p>
* Class for conversions from {@link Attribute}s.
* </p>
* @author Kasper Piskorski
*/
class AttributeConverter implements ConceptConverter<Attribute> {
public Pattern pattern(Attribute concept) {
Var owner = Graql.var().asUserDefined();
VarPattern resourceVar = Graql.var().asUserDefined().val(concept.value());
return owner
.has(concept.type().label(),resourceVar)
.id(concept.owner().id());
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils/conversion/ConceptConverter.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.utils.conversion;
import ai.grakn.concept.Concept;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.Pattern;
import ai.grakn.util.CommonUtil;
/**
* <p>
* Interface for conversion from {@link Concept}s.
* </p>
* @param <T> {@link Concept} type to convert from
*
* @author Kasper Piskorski
*/
public interface ConceptConverter<T extends Concept> {
static Pattern toPattern(Concept concept) {
if (!concept.isThing()){
throw GraqlQueryException.conceptNotAThing(concept);
}
if (concept.isEntity()) {
return new EntityConverter().pattern(concept.asEntity());
} else if (concept.isRelationship()) {
return new RelationshipConverter().pattern(concept.asRelationship());
} else if (concept.isAttribute()) {
return new AttributeConverter().pattern(concept.asAttribute());
} else {
throw CommonUtil.unreachableStatement("Unrecognised concept " + concept);
}
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils/conversion/EntityConverter.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.utils.conversion;
import ai.grakn.concept.Entity;
import ai.grakn.graql.Graql;
import ai.grakn.graql.Pattern;
import ai.grakn.graql.Var;
/**
* <p>
* Class for conversions from {@link Entity}s.
* </p>
* @author Kasper Piskorski
*/
class EntityConverter implements ConceptConverter<Entity>{
public Pattern pattern(Entity concept) {
Var entityVar = Graql.var().asUserDefined();
return entityVar
.isa(Graql.label(concept.type().label()))
.id(concept.id());
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils/conversion/RelationshipConverter.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.utils.conversion;
import ai.grakn.concept.Relationship;
import ai.grakn.concept.Role;
import ai.grakn.concept.Thing;
import ai.grakn.graql.Graql;
import ai.grakn.graql.Pattern;
import ai.grakn.graql.Var;
import ai.grakn.graql.VarPattern;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
* <p>
* Class for conversions from {@link Relationship}s.
* </p>
* @author Kasper Piskorski
*/
class RelationshipConverter implements ConceptConverter<Relationship> {
public Pattern pattern(Relationship concept) {
VarPattern relationPattern = Graql.var();
Set<Pattern> idPatterns = new HashSet<>();
for (Map.Entry<Role, Set<Thing>> entry : concept.rolePlayersMap().entrySet()) {
for (Thing var : entry.getValue()) {
Var rolePlayer = Graql.var();
relationPattern = relationPattern.rel(Graql.label(entry.getKey().label()), rolePlayer);
idPatterns.add(rolePlayer.asUserDefined().id(var.id()));
}
}
relationPattern = relationPattern.isa(Graql.label(concept.type().label()));
Pattern pattern = relationPattern;
for (Pattern idPattern : idPatterns) {
pattern = pattern.and(idPattern);
}
return pattern;
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils/conversion/RoleConverter.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.utils.conversion;
import ai.grakn.concept.Role;
import java.util.stream.Stream;
/**
* <p>
* Implementation of {@link SchemaConceptConverter} allowing for conversion of role types to compatible types.
* </p>
*
* @author Kasper Piskorski
*/
public class RoleConverter implements SchemaConceptConverter<Role> {
@Override
public Stream<Role> toCompatibleRoles(Role entryRole) {
return entryRole.subs();
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils/conversion/SchemaConceptConverter.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.utils.conversion;
import ai.grakn.concept.RelationshipType;
import ai.grakn.concept.SchemaConcept;
import ai.grakn.concept.Role;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
import java.util.stream.Stream;
/**
* <p>
* Interface for conversion between compatible {@link SchemaConcept}s.
* NB: assumes MATCH semantics - all types and their subs are considered.
* </p>
* @param <T> {@link SchemaConcept} type to convert from
*
* @author Kasper Piskorski
*/
public interface SchemaConceptConverter<T extends SchemaConcept>{
/**
* convert a given type to a map of relation types in which it can play roles
* and the corresponding role types including entity type hierarchy
* @param entryConcept to be converted
* @return map of relation types in which it can play roles and the corresponding role types
*/
default Multimap<RelationshipType, Role> toRelationshipMultimap(T entryConcept){
Multimap<RelationshipType, Role> relationMap = HashMultimap.create();
toCompatibleRoles(entryConcept)
.forEach(role -> role.relationships()
.forEach(rel -> relationMap.put(rel, role)));
return relationMap;
}
/**
* @param entryConcept to be converted
* @return {@link Role}s that are compatible with this {@link SchemaConcept}
*/
Stream<Role> toCompatibleRoles(T entryConcept);
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/reasoner/utils/conversion/TypeConverter.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.reasoner.utils.conversion;
import ai.grakn.concept.Role;
import ai.grakn.concept.Type;
import java.util.stream.Stream;
/**
* <p>
* Basic {@link SchemaConceptConverter} implementation for conversion between compatible types.
* </p>
*
* @author Kasper Piskorski
*/
public class TypeConverter implements SchemaConceptConverter<Type> {
@Override
public Stream<Role> toCompatibleRoles(Type entryType) {
return entryType.subs().flatMap(Type::playing);
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/Scope.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template;
import ai.grakn.graql.Var;
import com.google.common.collect.Sets;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
* Represents a scope (association of name to a value) and corresponds to a block
* in the TemplateVisitor class.
*
* This can also be thought of as a block in Graql Temaplates. I.e. any body of text
* surrounded by {} or the root.
*
* @author alexandraorth
*/
public class Scope {
private final Scope parent;
private final Map<String, Object> values;
private final Set<Var> variablesEncountered;
public Scope(Map<String, Object> data){
this.parent = null;
this.values = data;
this.variablesEncountered = new HashSet<>();
}
public Scope(Scope parent, Map<String, Object> data){
this.parent = parent;
this.values = data;
this.variablesEncountered = Sets.newHashSet(parent.variablesEncountered);
}
/**
* Move up one level to the parent scope
* @return the parent scope
*/
public Scope up() {
return parent;
}
/**
* Retrieve the value of a key from this scope
* @param var key to retrieve
* @return value associated with the provided key
*/
public Object resolve(String var) {
return values.get(var);
}
/**
* Retrieve the data in the current scope
* @return data in this scope
*/
public Map data(){
return this.values;
}
/**
* Check if the variable has been seen before in this scope
* @param variable variable to check the presence of
* @return true if the variable has been seen, false otherwise
*/
boolean hasSeen(Var variable){
return variablesEncountered.contains(variable);
}
/**
* Mark a variable as seen within this scope
* @param variable variable to mark as seen
*/
void markAsSeen(Var variable){
variablesEncountered.add(variable);
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/TemplateParser.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template;
import ai.grakn.exception.GraqlSyntaxException;
import ai.grakn.graql.internal.antlr.GraqlTemplateLexer;
import ai.grakn.graql.internal.antlr.GraqlTemplateParser;
import ai.grakn.graql.internal.parser.GraqlErrorListener;
import ai.grakn.graql.internal.template.macro.BooleanMacro;
import ai.grakn.graql.internal.template.macro.ConcatMacro;
import ai.grakn.graql.internal.template.macro.DateMacro;
import ai.grakn.graql.internal.template.macro.DoubleMacro;
import ai.grakn.graql.internal.template.macro.EqualsMacro;
import ai.grakn.graql.internal.template.macro.IntMacro;
import ai.grakn.graql.internal.template.macro.LongMacro;
import ai.grakn.graql.internal.template.macro.LowerMacro;
import ai.grakn.graql.internal.template.macro.NoescpMacro;
import ai.grakn.graql.internal.template.macro.SplitMacro;
import ai.grakn.graql.internal.template.macro.StringMacro;
import ai.grakn.graql.internal.template.macro.UpperMacro;
import ai.grakn.graql.macro.Macro;
import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTree;
import java.util.HashMap;
import java.util.Map;
/**
* Class for parsing Graql templates and associated data into Graql statements.
*
* @author alexandraorth
*/
public class TemplateParser {
private final Map<String, Macro<?>> macros = new HashMap<>();
/**
* Create a template parser.
*/
private TemplateParser(){}
/**
* Create a template parser.
* @return the created template parser
*/
public static TemplateParser create(){
TemplateParser parser = new TemplateParser();
parser.registerDefaultMacros();
return parser;
}
/**
* Register a macro that can be used in any template parsed by this class.
* @param macro macro that can be called in templates
*/
public void registerMacro(Macro macro){
macros.put(macro.name(), macro);
}
/**
* Parse and resolve a graql template.
* @param templateString a string representing a graql template
* @param data data to use in template
* @return resolved graql query string
*/
public String parseTemplate(String templateString, Map<String, Object> data){
GraqlErrorListener errorListener = GraqlErrorListener.of(templateString);
CommonTokenStream tokens = lexGraqlTemplate(templateString, errorListener);
ParseTree tree = parseGraqlTemplate(tokens, errorListener);
TemplateVisitor visitor = new TemplateVisitor(tokens, data, macros);
return visitor.visit(tree).toString();
}
private CommonTokenStream lexGraqlTemplate(String templateString, GraqlErrorListener errorListener){
ANTLRInputStream inputStream = new ANTLRInputStream(templateString);
GraqlTemplateLexer lexer = new GraqlTemplateLexer(inputStream);
lexer.removeErrorListeners();
lexer.addErrorListener(errorListener);
return new CommonTokenStream(lexer);
}
private ParseTree parseGraqlTemplate(CommonTokenStream tokens, GraqlErrorListener errorListener){
GraqlTemplateParser parser = new GraqlTemplateParser(tokens);
parser.setBuildParseTree(true);
parser.removeErrorListeners();
parser.addErrorListener(errorListener);
ParseTree tree = parser.template();
if(errorListener.hasErrors()){
throw GraqlSyntaxException.create(errorListener.toString());
}
return tree;
}
/**
* Register the default macros that can be used by the visitor
*/
private void registerDefaultMacros(){
registerMacro(new NoescpMacro());
registerMacro(new IntMacro());
registerMacro(new DoubleMacro());
registerMacro(new EqualsMacro());
registerMacro(new StringMacro());
registerMacro(new LongMacro());
registerMacro(new DateMacro());
registerMacro(new LowerMacro());
registerMacro(new UpperMacro());
registerMacro(new BooleanMacro());
registerMacro(new SplitMacro());
registerMacro(new ConcatMacro());
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/TemplateVisitor.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template;
import ai.grakn.exception.GraqlSyntaxException;
import ai.grakn.graql.Var;
import ai.grakn.graql.internal.antlr.GraqlTemplateBaseVisitor;
import ai.grakn.graql.internal.antlr.GraqlTemplateParser;
import ai.grakn.graql.macro.Macro;
import ai.grakn.util.StringUtil;
import com.google.common.collect.ImmutableMap;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.tree.TerminalNode;
import javax.annotation.Nullable;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import static ai.grakn.graql.Graql.var;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;
/**
* ANTLR visitor class for parsing a template
*
* @author alexandraorth
*/
public class TemplateVisitor extends GraqlTemplateBaseVisitor {
private final CommonTokenStream tokens;
private final Map<String, Object> originalContext;
private final Map<String, Macro<?>> macros;
private final Map<Var, Integer> iteration = new HashMap<>();
private Scope scope;
public TemplateVisitor(CommonTokenStream tokens, Map<String, Object> context, Map<String, Macro<?>> macros){
this.tokens = tokens;
this.macros = macros;
this.scope = new Scope(context);
this.originalContext = context;
}
@Override
public String visitTemplate(GraqlTemplateParser.TemplateContext ctx) {
return visitBlockContents(ctx.blockContents());
}
@Override
public String visitBlock(GraqlTemplateParser.BlockContext ctx) {
return visitBlockContents(ctx.blockContents());
}
@Override
public String visitBlockContents(GraqlTemplateParser.BlockContentsContext ctx) {
return (String) visitChildren(ctx);
}
@Nullable
@Override
public Object visitForInStatement(GraqlTemplateParser.ForInStatementContext ctx) {
String var = ctx.ID().getText();
return runForLoop((object) -> ImmutableMap.of(var, object), ctx.list(), ctx.block());
}
@Nullable
@Override
public Object visitForEachStatement(GraqlTemplateParser.ForEachStatementContext ctx) {
return runForLoop((object) -> {
if(!(object instanceof Map)) throw GraqlSyntaxException.parsingIncorrectValueType(object, Map.class, scope.data());
return (Map) object;
}, ctx.list(), ctx.block());
}
@Nullable
private Object runForLoop(Function<Object, Map> contextSupplier, GraqlTemplateParser.ListContext listCtx, GraqlTemplateParser.BlockContext block) {
List list = this.visitList(listCtx);
Object returnValue = null;
for (Object object:list) {
scope = new Scope(scope, contextSupplier.apply(object));
returnValue = aggregateResult(returnValue, this.visit(block));
scope = scope.up();
}
return returnValue;
}
@Override
public String visitIfStatement(GraqlTemplateParser.IfStatementContext ctx){
if(this.visitBool(ctx.ifPartial().bool())){
return this.visitBlock(ctx.ifPartial().block());
}
for(GraqlTemplateParser.ElseIfPartialContext elseIf:ctx.elseIfPartial()){
if(this.visitBool(elseIf.bool())){
return this.visitBlock(elseIf.block());
}
}
if(ctx.elsePartial() != null){
return this.visitBlock(ctx.elsePartial().block());
}
return "";
}
@Override
public Boolean visitGroupExpression(GraqlTemplateParser.GroupExpressionContext ctx){
return this.visitBool(ctx.bool());
}
@Override
public Boolean visitOrExpression(GraqlTemplateParser.OrExpressionContext ctx) {
boolean lValue = this.visitBool(ctx.bool(0));
boolean rValue = this.visitBool(ctx.bool(1));
return lValue || rValue;
}
@Override
public Boolean visitAndExpression(GraqlTemplateParser.AndExpressionContext ctx) {
boolean lValue = this.visitBool(ctx.bool(0));
boolean rValue = this.visitBool(ctx.bool(1));
return lValue && rValue;
}
@Override
public Boolean visitNotExpression(GraqlTemplateParser.NotExpressionContext ctx) {
return !this.visitBool(ctx.bool());
}
@Nullable
@Override
public Boolean visitBooleanExpression(GraqlTemplateParser.BooleanExpressionContext ctx) {
return this.visitUntypedExpression(ctx.untypedExpression(), Boolean.class);
}
@Override
public Boolean visitBooleanConstant(GraqlTemplateParser.BooleanConstantContext ctx) {
return Boolean.parseBoolean(ctx.getText());
}
@Nullable
@Override
public String visitString(GraqlTemplateParser.StringContext ctx){
if(ctx.STRING() != null) {
return ctx.getText().substring(1, ctx.getText().length() - 1);
} else {
return this.visitUntypedExpression(ctx.untypedExpression(), String.class);
}
}
@Nullable
@Override
public Number visitNumber(GraqlTemplateParser.NumberContext ctx){
if(ctx.int_() != null){
return this.visitInt_(ctx.int_());
} else if(ctx.double_() != null) {
return this.visitDouble_(ctx.double_());
} else {
return this.visitUntypedExpression(ctx.untypedExpression(), Number.class);
}
}
@Nullable
@Override
public Integer visitInt_(GraqlTemplateParser.Int_Context ctx) {
if(ctx.INT() != null){
return Integer.parseInt(ctx.getText());
} else {
return this.visitUntypedExpression(ctx.untypedExpression(), Integer.class);
}
}
@Nullable
@Override
public Double visitDouble_(GraqlTemplateParser.Double_Context ctx) {
if(ctx.DOUBLE() != null){
return Double.parseDouble(ctx.getText());
} else {
return this.visitUntypedExpression(ctx.untypedExpression(), Double.class);
}
}
@Nullable
@Override
public Object visitNil(GraqlTemplateParser.NilContext ctx) {
return null;
}
@Nullable
@Override
public List visitList(GraqlTemplateParser.ListContext ctx){
return this.visitUntypedExpression(ctx.untypedExpression(), List.class);
}
@Nullable
@Override
public Object visitExpression(GraqlTemplateParser.ExpressionContext ctx){
if(ctx.untypedExpression() != null){
return this.visitUntypedExpression(ctx.untypedExpression(), Object.class);
} else if(ctx.BOOLEAN() != null) {
return Boolean.parseBoolean(ctx.getText());
} else {
return this.visit(ctx.children.get(0));
}
}
private Boolean visitBool(GraqlTemplateParser.BoolContext ctx){
return (Boolean) this.visit(ctx);
}
@Override
public Boolean visitEqExpression(GraqlTemplateParser.EqExpressionContext ctx) {
Object lValue = this.visit(ctx.expression(0));
Object rValue = this.visit(ctx.expression(1));
return Objects.equals(lValue, rValue);
}
@Override
public Boolean visitNotEqExpression(GraqlTemplateParser.NotEqExpressionContext ctx) {
Object lValue = this.visit(ctx.expression(0));
Object rValue = this.visit(ctx.expression(1));
return !Objects.equals(lValue, rValue);
}
@Override
public Boolean visitGreaterExpression(GraqlTemplateParser.GreaterExpressionContext ctx) {
Number lNumber = this.visitNumber(ctx.number(0));
Number rNumber = this.visitNumber(ctx.number(1));
return lNumber.doubleValue() > rNumber.doubleValue();
}
@Override
public Boolean visitGreaterEqExpression(GraqlTemplateParser.GreaterEqExpressionContext ctx) {
Number lNumber = this.visitNumber(ctx.number(0));
Number rNumber = this.visitNumber(ctx.number(1));
return lNumber.doubleValue() >= rNumber.doubleValue();
}
@Override
public Boolean visitLessExpression(GraqlTemplateParser.LessExpressionContext ctx) {
Number lNumber = this.visitNumber(ctx.number(0));
Number rNumber = this.visitNumber(ctx.number(1));
return lNumber.doubleValue() < rNumber.doubleValue();
}
@Override
public Boolean visitLessEqExpression(GraqlTemplateParser.LessEqExpressionContext ctx) {
Number lNumber = this.visitNumber(ctx.number(0));
Number rNumber = this.visitNumber(ctx.number(1));
return lNumber.doubleValue() <= rNumber.doubleValue();
}
@Override
public Var visitVarResolved(GraqlTemplateParser.VarResolvedContext ctx) {
Object value = null;
for(GraqlTemplateParser.UntypedExpressionContext c:ctx.untypedExpression()){
value = aggregateResult(value, this.visitUntypedExpression(c, Object.class));
}
if(value == null) throw GraqlSyntaxException.parsingTemplateMissingKey(ctx.getText(), originalContext);
String valueAsVar = value.toString().replaceAll("[^a-zA-Z0-9_]", "-");
return var(valueAsVar);
}
@Override
public String visitVarLiteral(GraqlTemplateParser.VarLiteralContext ctx){
Var var = var(ctx.getText().substring(1));
if(!scope.hasSeen(var)){
scope.markAsSeen(var);
iteration.compute(var, (k, v) -> v == null ? 0 : v + 1);
}
return ctx.getText() + iteration.get(var);
}
@Override
public String visitTerminal(TerminalNode node){
int index = node.getSymbol().getTokenIndex();
String lws = tokens.getHiddenTokensToLeft(index) != null ? tokens.getHiddenTokensToLeft(index).stream().map(Token::getText).collect(joining()) : "";
String rws = tokens.getHiddenTokensToRight(index) != null ? tokens.getHiddenTokensToRight(index).stream().map(Token::getText).collect(joining()) : "";
return lws + node.getText() + rws;
}
@Override
public String visitEscapedExpression(GraqlTemplateParser.EscapedExpressionContext ctx) {
Object resolved = visitUntypedExpression(ctx.untypedExpression(), Object.class);
if(resolved == null) throw GraqlSyntaxException.parsingTemplateMissingKey(ctx.getText(), originalContext);
return StringUtil.valueToString(resolved);
}
@Override
public Object visitMacroExpression(GraqlTemplateParser.MacroExpressionContext ctx){
String macro = ctx.ID_MACRO().getText().substring(1).toLowerCase(Locale.getDefault());
List<Object> values = ctx.expression().stream().map(this::visit).collect(toList());
return macros.get(macro).apply(values);
}
@Override
public String visitId(GraqlTemplateParser.IdContext ctx) {
if (ctx.ID() != null){
return ctx.ID().getText();
} else {
String string = ctx.STRING().getText();
return string.substring(1, string.length() - 1);
}
}
@Nullable
@Override
public Object visitIdExpression(GraqlTemplateParser.IdExpressionContext ctx) {
Object object = scope.resolve(this.visitId(ctx.id()));
for(GraqlTemplateParser.AccessorContext accessor:ctx.accessor()) {
if (object instanceof Map || object instanceof List) {
object = ((Function<Object, Object>) this.visit(accessor)).apply(object);
} else {
object = null;
}
}
return object;
}
@Override
public Function<Map, Object> visitMapAccessor(GraqlTemplateParser.MapAccessorContext ctx) {
return (map) -> map.get(this.visitId(ctx.id()));
}
@Override
public Function<List, Object> visitListAccessor(GraqlTemplateParser.ListAccessorContext ctx) {
return (list) -> {
int index = this.visitInt_(ctx.int_());
if (index >= list.size() || index < 0) {
throw GraqlSyntaxException.create("Index [" + index + "] out of bounds for list " + list);
}
return list.get(index);
};
}
@Nullable
private <T> T visitUntypedExpression(GraqlTemplateParser.UntypedExpressionContext ctx, Class<T> clazz) {
Object object = this.visit(ctx);
if(object == null){
return null;
} else if(!clazz.isInstance(object)){
throw GraqlSyntaxException.parsingIncorrectValueType(object, clazz, scope.data());
}
return clazz.cast(object);
}
@Nullable
@Override
protected Object aggregateResult(@Nullable Object aggregate, @Nullable Object nextResult) {
if(nextResult == null){
return aggregate;
}
if(aggregate == null){
return nextResult;
}
return aggregate.toString() + nextResult.toString();
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/AbstractNumericMacro.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.macro.Macro;
import java.util.List;
/**
* <p>
* {@link Number} parsing {@link Macro}
* </p>
*
* <p>
* Represents the base {@link Macro} exclusively used for {@link Number}s, such as {@link LongMacro} and
* {@link IntMacro}
* </p>
*
* @param <T> A number which inherits from the {@link Number} class
*
* @author Filipe Peliz Pinto Teixeira
*/
public abstract class AbstractNumericMacro<T extends Number> implements Macro<Number>{
private static final int numberArguments = 1;
@Override
public Number apply(List<Object> values) {
if(values.size() != numberArguments){
throw GraqlQueryException.wrongNumberOfMacroArguments(this, values);
}
String value = values.get(0).toString();
try {
return convertNumeric(value);
} catch (NumberFormatException e){
throw GraqlQueryException.wrongMacroArgumentType(this, value);
}
}
abstract T convertNumeric(String value);
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/BooleanMacro.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.macro.Macro;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.List;
import java.util.Locale;
/**
* <p>
* Templating function that will convert the given value into a boolean (true/false). Only accepts one argument.
*
* Usage:
* {@literal @}boolean(<value>)
* </p>
* @author alexandraorth
*/
public class BooleanMacro implements Macro<Boolean> {
private static final Collection<String> allowedBooleanValues = ImmutableSet.of("true", "false");
private static final int numberArguments = 1;
@Override
public Boolean apply(List<Object> values) {
if(values.size() != numberArguments){
throw GraqlQueryException.wrongNumberOfMacroArguments(this, values);
}
String booleanValue = values.get(0).toString().toLowerCase(Locale.getDefault());
if(!allowedBooleanValues.contains(booleanValue)){
throw GraqlQueryException.wrongMacroArgumentType(this, booleanValue);
}
return Boolean.parseBoolean(booleanValue);
}
@Override
public String name() {
return "boolean";
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/ConcatMacro.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.macro.Macro;
import java.util.List;
import static java.util.stream.Collectors.joining;
/**
* <p>
* Concatenate all of the given values to a string. Accepts at least two arguments.
*
* Usage:
* {@literal @}concat(<value1>, <value2>)
* </p>
* @author alexandraorth
*/
public class ConcatMacro implements Macro<String> {
@Override
public String apply(List<Object> values) {
if(values.size() < 2){
throw GraqlQueryException.wrongNumberOfMacroArguments(this, values);
}
return values.stream().map(Object::toString).collect(joining());
}
@Override
public String name() {
return "concat";
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/DateMacro.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.macro.Macro;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.TemporalAccessor;
import java.util.List;
/**
* <p>
* Parse the given value (arg1) using the format (arg2).
* Returns a String with the value of the date parsed into {@link DateTimeFormatter#ISO_LOCAL_DATE_TIME} which
* is the date format that Graql accepts.
*
* Usage:
* {@literal @}date("01/30/2017", "mm/dd/yyyy")
* </p>
*
* @author alexandraorth
*/
public class DateMacro implements Macro<Unescaped<String>> {
@Override
public Unescaped<String> apply(List<Object> values) {
if(values.size() != 2){
throw GraqlQueryException.wrongNumberOfMacroArguments(this, values);
}
String originalDate = values.get(0).toString();
String originalFormat = values.get(1).toString();
return Unescaped.of(convertDateFormat(originalDate, originalFormat));
}
@Override
public String name() {
return "date";
}
private String convertDateFormat(String originalDate, String originalFormat){
originalFormat = removeQuotes(originalFormat);
try {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(originalFormat);
TemporalAccessor parsedDate = formatter.parseBest(
originalDate, LocalDateTime::from, LocalDate::from, LocalTime::from);
return extractLocalDateTime(parsedDate).format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
} catch (IllegalArgumentException e){
throw GraqlQueryException.cannotParseDateFormat(originalFormat);
} catch (DateTimeParseException e){
throw GraqlQueryException.cannotParseDateString(originalDate, originalFormat, e);
}
}
/**
* Extract a {@link LocalDateTime} object from a {@link TemporalAccessor}.
* If the given date is a {@link LocalDate}, sets the response to the start of that day.
* If the given date is a {@link LocalTime}, sets the response to the current day.
*
* @param parsedDate The parsed date to convert.
* @return A {@link LocalDateTime} object containing a formatted date.
*/
private LocalDateTime extractLocalDateTime(TemporalAccessor parsedDate){
if(parsedDate instanceof LocalDate){
return ((LocalDate) parsedDate).atStartOfDay();
} else if(parsedDate instanceof LocalTime){
return ((LocalTime) parsedDate).atDate(LocalDate.now());
} else {
return LocalDateTime.from(parsedDate);
}
}
private String removeQuotes(String str){
return str.replace("\"", "");
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/DoubleMacro.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
/**
* <p>
* Convert the given value into a boolean (true/false). Only accepts one argument.
*
* Usage:
* {@literal @}boolean(<value>)
* {@literal @}boolean("true")
* </p>
*
* @author alexandraorth
*/
public class DoubleMacro extends AbstractNumericMacro<Double> {
@Override
Double convertNumeric(String value) {
return Double.parseDouble(value);
}
@Override
public String name(){
return "double";
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/EqualsMacro.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.macro.Macro;
import java.util.List;
/**
* <p>
* Compares the given values. The result is true if all of the values are equal. Accepts at least two arguments.
*
* Usage:
* {@literal @}equals(<value>, null)
* {@literal @}equals(<value1>, "this")
* {@literal @}equals(<value1>, <value2>, <value3>)
* </p>
*
* @author alexandraorth
*/
public class EqualsMacro implements Macro<Boolean> {
@Override
public Boolean apply(List<Object> values) {
if(values.size() < 2){
throw GraqlQueryException.wrongNumberOfMacroArguments(this, values);
}
Object first = values.get(0);
return values.stream().allMatch(first::equals);
}
@Override
public String name() {
return "equals";
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/IntMacro.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
/**
* <p>
* Convert the given value into an integer. Only accepts one argument.
*
* Usage:
* {@literal @}int(<value>)
* </p>
*
* @author alexandraorth
*/
public class IntMacro extends AbstractNumericMacro<Integer> {
@Override
Integer convertNumeric(String value) {
return Integer.parseInt(value);
}
@Override
public String name(){
return "int";
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/LongMacro.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
/**
* <p>
* Convert the given value into a long. Only accepts one argument.
*
* Usage:
* {@literal @}long(<value>)
* </p>
*
* @author alexandraorth
*/
public class LongMacro extends AbstractNumericMacro<Long> {
@Override
Long convertNumeric(String value) {
return Long.parseLong(value);
}
@Override
public String name() {
return "long";
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/LowerMacro.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.macro.Macro;
import java.util.List;
import java.util.Locale;
/**
* <p>
* Convert the given value into an lower case string. Only accepts one argument.
*
* Usage:
* {@literal @}lower(<value>)
* </p>
*
* @author alexandraorth
*/
public class LowerMacro implements Macro<String> {
private static final int numberArguments = 1;
@Override
public String apply(List<Object> values) {
if(values.size() != numberArguments){
throw GraqlQueryException.wrongNumberOfMacroArguments(this, values);
}
return values.get(0).toString().toLowerCase(Locale.getDefault());
}
@Override
public String name() {
return "lower";
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/NoescpMacro.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.macro.Macro;
import java.util.List;
/**
* <p>
* Convert the given value into an unescaped. Only accepts one argument.
*
* Usage:
* {@literal @}noescp(<value>)
* </p>
*
* @author alexandraorth
*/
public class NoescpMacro implements Macro<Unescaped> {
private static final int numberArguments = 1;
@Override
public Unescaped apply(List<Object> values) {
if(values.size() != numberArguments){
throw GraqlQueryException.wrongNumberOfMacroArguments(this, values);
}
return Unescaped.of(values.get(0).toString());
}
@Override
public String name(){
return "noescp";
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/SplitMacro.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.macro.Macro;
import java.util.Arrays;
import java.util.List;
/**
* <p>
* Templating function that splits the given value based on the given character. Accepts exactly two arguments.
*
* Usage:
* {@literal @}split(<value>, ",")
* {@literal @}split(<value>, "-")
* {@literal @}split(<value>, "and")
* </p>
*
* @author alexandraorth
*/
public class SplitMacro implements Macro<List<String>> {
private static final int numberArguments = 2;
@Override
public List<String> apply(List<Object> values) {
if(values.size() != numberArguments){
throw GraqlQueryException.wrongNumberOfMacroArguments(this, values);
}
String valueToSplit = values.get(0).toString();
String splitString = values.get(1).toString();
return Arrays.asList(valueToSplit.split(splitString));
}
@Override
public String name() {
return "split";
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/StringMacro.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.macro.Macro;
import java.util.List;
/**
* <p>
* Convert the given value into a quoted string. Only accepts one argument.
*
* Usage:
* {@literal @}string(<value>)
* </p>
* @author alexandraorth
*/
public class StringMacro implements Macro<String> {
private static final int numberArguments = 1;
@Override
public String apply(List<Object> values) {
if(values.size() != numberArguments){
throw GraqlQueryException.wrongNumberOfMacroArguments(this, values);
}
return values.get(0).toString();
}
@Override
public String name() {
return "string";
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/Unescaped.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
/**
* Class representing a object that should not be escaped by the templator.
*
* @param <T> The type of the object that will not be escaped
* @author alexandraorth
*/
public class Unescaped<T> {
private final T unescaped;
private Unescaped(T string){
this.unescaped = string;
}
public static Unescaped of(Object object){
return new Unescaped(object);
}
@Override
public String toString() {
return unescaped.toString();
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/template/macro/UpperMacro.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.template.macro;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.macro.Macro;
import java.util.List;
import java.util.Locale;
/**
* <p>
* Convert the given value into an upper case string. Only accepts one argument.
*
* Usage:
* {@literal @}upper(<value)
* </p>
*
* @author alexandraorth
*/
public class UpperMacro implements Macro<String> {
private static final int numberArguments = 1;
@Override
public String apply(List<Object> values) {
if(values.size() != numberArguments){
throw GraqlQueryException.wrongNumberOfMacroArguments(this, values);
}
return values.get(0).toString().toUpperCase(Locale.getDefault());
}
@Override
public String name() {
return "upper";
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/util/ANSI.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.util;
/**
* Includes ANSI unicode commands for different colours
*
* @author Felix Chapman
*/
@SuppressWarnings("unused")
public class ANSI {
private ANSI() {
}
private static final String RESET = "\u001B[0m";
public static final String BLACK = "\u001B[30m";
public static final String RED = "\u001B[31m";
public static final String GREEN = "\u001B[32m";
public static final String YELLOW = "\u001B[33m";
public static final String BLUE = "\u001B[34m";
public static final String PURPLE = "\u001B[35m";
public static final String CYAN = "\u001B[36m";
public static final String WHITE = "\u001B[37m";
/**
* @param string the string to set the color on
* @param color the color to set on the string
* @return a new string with the color set
*/
public static String color(String string, String color) {
return color + string + RESET;
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/util/AdminConverter.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.util;
import ai.grakn.graql.Pattern;
import ai.grakn.graql.VarPattern;
import ai.grakn.graql.admin.PatternAdmin;
import ai.grakn.graql.admin.VarPatternAdmin;
import java.util.Collection;
import static java.util.stream.Collectors.toList;
/**
* Helper methods for converting classes to admin equivalents
*
* @author Felix Chapman
*/
public class AdminConverter {
/**
* @param patterns a collection of patterns to change to admin
* @return a collection of Pattern.Admin from the given patterns
*/
public static Collection<PatternAdmin> getPatternAdmins(Collection<? extends Pattern> patterns) {
return patterns.stream().map(Pattern::admin).collect(toList());
}
/**
* @param patterns a collection of vars to change to admin
* @return a collection of {@link VarPatternAdmin} from the given patterns
*/
public static Collection<VarPatternAdmin> getVarAdmins(Collection<? extends VarPattern> patterns) {
return patterns.stream().map(VarPattern::admin).collect(toList());
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/util/Partition.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.util;
import com.google.common.collect.Maps;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
/**
* Union-Find Data Structure
*
* @param <V> the type of the values stored
* @author Sam Thomson
* @author Jason Liu
*/
public class Partition<V> {
private final Map<V, V> parents;
private final Map<V, Integer> ranks;
private Partition(Map<V, V> parents, Map<V, Integer> ranks) {
this.parents = parents;
this.ranks = ranks;
}
/**
* Constructs a new partition of singletons
*/
public static <T> Partition<T> singletons(Collection<T> nodes) {
final Map<T, T> parents = Maps.newHashMap();
final Map<T, Integer> ranks = Maps.newHashMap();
for (T node : nodes) {
parents.put(node, node); // each node is its own head
ranks.put(node, 0); // every node has depth 0 to start
}
return new Partition<T>(parents, ranks);
}
/**
* Find the representative for the given item
*/
public V componentOf(V i) {
final V parent = parents.getOrDefault(i, i);
if (parent.equals(i)) {
return i;
} else {
// collapse, so next lookup is O(1)
parents.put(i, componentOf(parent));
}
return parents.get(i);
}
/**
* Merges the given components and returns the representative of the new component
*/
public V merge(V a, V b) {
final V aHead = componentOf(a);
final V bHead = componentOf(b);
if (aHead.equals(bHead)) return aHead;
// add the shorter tree underneath the taller tree
final int aRank = ranks.getOrDefault(aHead, 0);
final int bRank = ranks.getOrDefault(bHead, 0);
if (aRank > bRank) {
parents.put(bHead, aHead);
return aHead;
} else if (bRank > aRank) {
parents.put(aHead, bHead);
return bHead;
} else {
// whoops, the tree got taller
parents.put(bHead, aHead);
ranks.put(aHead, aRank + 1);
return aHead;
}
}
/**
* Determines whether the two items are in the same component or not
*/
public boolean sameComponent(V a, V b) {
return componentOf(a).equals(componentOf(b));
}
public Set<V> getNodes() {
return parents.keySet();
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/util/PrimitiveNumberComparator.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.util;
import java.util.Comparator;
/**
* A Comparator class to compare the 2 numbers only if they have the same primitive type.
*/
public class PrimitiveNumberComparator implements Comparator<Number> {
@Override
public int compare(Number a, Number b) {
if (((Object) a).getClass().equals(((Object) b).getClass()) && a instanceof Comparable) {
return ((Comparable) a).compareTo(b);
}
throw new RuntimeException("Invalid attempt to compare non-comparable primitive type of Numbers in Aggregate function");
}
}
|
0
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal
|
java-sources/ai/grakn/grakn-graql/1.4.3/ai/grakn/graql/internal/util/StringConverter.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.internal.util;
import ai.grakn.concept.ConceptId;
import ai.grakn.concept.Label;
import ai.grakn.graql.internal.antlr.GraqlLexer;
import ai.grakn.util.StringUtil;
import com.google.common.collect.ImmutableSet;
import javax.annotation.Nullable;
import java.util.HashSet;
import java.util.stream.Stream;
import static ai.grakn.util.CommonUtil.toImmutableSet;
/**
* Class for converting Graql strings, used in the parser and for toString methods
*
* @author Felix Chapman
*/
public class StringConverter {
private static final ImmutableSet<String> ALLOWED_ID_KEYWORDS = ImmutableSet.of(
"min", "max", "median", "mean", "std", "sum", "count", "path", "cluster", "degrees", "members", "persist"
);
public static final ImmutableSet<String> GRAQL_KEYWORDS = getKeywords().collect(toImmutableSet());
private StringConverter() {}
/**
* @param id an ID of a concept
* @return
* The id of the concept correctly escaped in graql.
* If the ID doesn't begin with a number and is only comprised of alphanumeric characters, underscores and dashes,
* then it will be returned as-is, otherwise it will be quoted and escaped.
*/
public static String idToString(ConceptId id) {
return escapeLabelOrId(id.getValue());
}
@Nullable
public static String nullableIdToString(@Nullable ConceptId id) {
return id != null ? escapeLabelOrId(id.getValue()) : null;
}
/**
* @param label a label of a type
* @return
* The label of the type correctly escaped in graql.
* If the label doesn't begin with a number and is only comprised of alphanumeric characters, underscores and dashes,
* then it will be returned as-is, otherwise it will be quoted and escaped.
*/
public static String typeLabelToString(Label label) {
return escapeLabelOrId(label.getValue());
}
private static String escapeLabelOrId(String value) {
if (value.matches("^[a-zA-Z_][a-zA-Z0-9_-]*$") && !GRAQL_KEYWORDS.contains(value)) {
return value;
} else {
return StringUtil.quoteString(value);
}
}
/**
* @return all Graql keywords
*/
private static Stream<String> getKeywords() {
HashSet<String> keywords = new HashSet<>();
for (int i = 1; GraqlLexer.VOCABULARY.getLiteralName(i) != null; i ++) {
String name = GraqlLexer.VOCABULARY.getLiteralName(i);
keywords.add(name.replaceAll("'", ""));
}
return keywords.stream().filter(keyword -> !ALLOWED_ID_KEYWORDS.contains(keyword));
}
}
|
0
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql/shell/BatchLoader.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.shell;
import ai.grakn.Keyspace;
import ai.grakn.batch.BatchExecutorClient;
import ai.grakn.batch.GraknClient;
import ai.grakn.graql.Graql;
import ai.grakn.util.SimpleURI;
import com.google.common.base.Charsets;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.Reader;
import java.nio.file.Path;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Class for sending batch load requests from the {@link GraqlShell}.
*
* @author Felix Chapman
*/
final class BatchLoader {
private static final int DEFAULT_MAX_RETRY = 1;
static void sendBatchRequest(
SimpleURI uri, Keyspace keyspace, Path graqlPath, PrintStream sout, PrintStream serr
) throws IOException {
AtomicInteger queriesExecuted = new AtomicInteger(0);
try (FileInputStream inputStream = new FileInputStream(graqlPath.toFile());
Reader queryReader = new InputStreamReader(inputStream, Charsets.UTF_8);
BatchExecutorClient batchExecutorClient = loaderClient(uri)
) {
batchExecutorClient.onNext(queryResponse -> queriesExecuted.incrementAndGet());
batchExecutorClient.onError(e -> e.printStackTrace(serr));
Graql.parser().parseReader(queryReader).forEach(query -> batchExecutorClient.add(query, keyspace));
}
sout.println("Statements executed: " + queriesExecuted.get());
}
private static BatchExecutorClient loaderClient(SimpleURI uri) {
return BatchExecutorClient.newBuilder()
.threadPoolCoreSize(Runtime.getRuntime().availableProcessors() * 8)
.taskClient(GraknClient.of(uri))
.maxRetries(DEFAULT_MAX_RETRY)
.build();
}
}
|
0
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql/shell/ExternalEditor.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.shell;
import com.google.common.base.StandardSystemProperty;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Map;
import java.util.Optional;
/**
* Represents an external editor that a user can execute from the console for editing queries.
*
* @author Felix Chapman
*/
final class ExternalEditor {
private static final String DEFAULT_EDITOR = "vim";
private static final String TEMP_FILENAME = "/graql-tmp.gql";
private final String editor;
private final File tempFile;
private ExternalEditor(String editor, File tempFile) {
this.editor = editor;
this.tempFile = tempFile;
}
// The result of createNewFile indicates if the file already existed, but that doesn't matter
@SuppressWarnings("ResultOfMethodCallIgnored")
@SuppressFBWarnings("RV_RETURN_VALUE_IGNORED_BAD_PRACTICE")
public static ExternalEditor create() throws IOException {
// Get preferred editor
Map<String, String> env = System.getenv();
String editor = Optional.ofNullable(env.get("EDITOR")).orElse(DEFAULT_EDITOR);
File tempFile = new File(StandardSystemProperty.JAVA_IO_TMPDIR.value() + TEMP_FILENAME);
tempFile.createNewFile();
return new ExternalEditor(editor, tempFile);
}
/**
* load the user's preferred editor to edit a query
*
* @return the string written to the editor
*/
public String execute() throws IOException, InterruptedException {
// Run the editor, pipe input into and out of tty so we can provide the input/output to the editor via Graql
ProcessBuilder builder = new ProcessBuilder(
"/bin/bash",
"-c",
editor + " </dev/tty >/dev/tty " + tempFile.getAbsolutePath()
);
// Wait for user to finish editing
builder.start().waitFor();
return String.join("\n", Files.readAllLines(tempFile.toPath()));
}
}
|
0
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql/shell/GraqlCompleter.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.shell;
import ai.grakn.GraknSession;
import ai.grakn.GraknTxType;
import ai.grakn.concept.Label;
import ai.grakn.concept.SchemaConcept;
import ai.grakn.graql.Autocomplete;
import ai.grakn.kb.admin.GraknAdmin;
import com.google.common.collect.ImmutableSet;
import jline.console.completer.Completer;
import java.util.List;
import java.util.Set;
import java.util.stream.Stream;
import static ai.grakn.util.CommonUtil.toImmutableSet;
/**
* An autocompleter for Graql.
* Provides a default 'complete' method that will filter results to only those that pass the Graql lexer
*
* @author Felix Chapman
*/
public class GraqlCompleter implements Completer {
private final ImmutableSet<Label> labels;
private GraqlCompleter(ImmutableSet<Label> labels) {
this.labels = labels;
}
public static GraqlCompleter create(GraknSession session) {
ImmutableSet<Label> labels;
try (GraknAdmin tx = session.transaction(GraknTxType.READ).admin()) {
Stream<SchemaConcept> metaConcepts =
Stream.of(tx.getMetaConcept(), tx.getMetaRole(), tx.getMetaRule()).flatMap(SchemaConcept::subs);
labels = metaConcepts.map(SchemaConcept::label).collect(toImmutableSet());
}
return new GraqlCompleter(labels);
}
@Override
public int complete(String buffer, int cursor, List<CharSequence> candidates) {
Set<String> labelValues = labels.stream().map(Label::getValue).collect(toImmutableSet());
Autocomplete autocomplete = Autocomplete.create(labelValues, buffer, cursor);
candidates.addAll(autocomplete.getCandidates());
return autocomplete.getCursorPosition();
}
}
|
0
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql/shell/GraqlConsole.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.shell;
import ai.grakn.Keyspace;
import ai.grakn.client.Grakn;
import ai.grakn.util.CommonUtil;
import ai.grakn.util.ErrorMessage;
import ai.grakn.util.GraknVersion;
import ai.grakn.util.SimpleURI;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import io.grpc.Status;
import jline.console.ConsoleReader;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.file.Path;
import java.util.List;
import static ai.grakn.graql.shell.GraqlShell.loadQuery;
/**
*
* Graql console class that executes actions associated to options, if any option is set
* otherwise instantiates a GraqlShell
*
* @author marcoscoppetta
*/
public class GraqlConsole {
public static boolean start(
GraqlShellOptions options, String historyFile, Grakn client,
PrintStream sout, PrintStream serr
) throws InterruptedException, IOException {
List<String> queries = null;
// ------- Check option ------------------------
String query = options.getQuery();
// This is a best-effort guess as to whether the user has made a mistake, without parsing the query
if (query != null) {
queries = ImmutableList.of(query);
if (!query.contains("$") && query.trim().startsWith("match")) {
serr.println(ErrorMessage.NO_VARIABLE_IN_QUERY.getMessage());
}
}
// ------- Check option ------------------------
// Print usage message if requested or if invalid arguments provided
if (options.displayHelp()) {
options.printUsage(sout);
return true;
}
// ------- Check option ------------------------
if (options.displayVersion()) {
sout.println(GraknVersion.VERSION);
return true;
}
// ------- Check option ------------------------
Path path = options.getBatchLoadPath();
if (path != null) {
Keyspace keyspace = options.getKeyspace();
SimpleURI location = options.getUri();
SimpleURI httpUri = location != null ? location : Grakn.DEFAULT_HTTP_URI;
try {
BatchLoader.sendBatchRequest(httpUri, keyspace, path, sout, serr);
} catch (Exception e) {
sout.println("Batch failed \n" + CommonUtil.simplifyExceptionMessage(e));
return false;
}
return true;
}
// -------- If no option set we start GraqlShell ----------
OutputFormat outputFormat = options.getOutputFormat();
boolean infer = options.shouldInfer();
ConsoleReader console = new ConsoleReader(System.in, sout);
Keyspace keyspace = options.getKeyspace();
try (GraqlShell shell = new GraqlShell(historyFile, client, keyspace, console, serr, outputFormat, infer)) {
List<Path> filePaths = options.getFiles();
if (filePaths != null) {
queries = loadQueries(filePaths);
}
// Start shell
shell.start(queries);
return !shell.errorOccurred();
} catch (RuntimeException e) {
if (e.getMessage().startsWith(Status.Code.UNAVAILABLE.name())) {
serr.println(ErrorMessage.COULD_NOT_CONNECT.getMessage());
} else {
serr.println(e.getMessage());
}
return false;
}
}
private static List<String> loadQueries(Iterable<Path> filePaths) throws IOException {
List<String> queries = Lists.newArrayList();
for (Path filePath : filePaths) {
queries.add(loadQuery(filePath));
}
return queries;
}
}
|
0
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql/shell/GraqlShell.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.shell;
import ai.grakn.GraknSession;
import ai.grakn.GraknTx;
import ai.grakn.GraknTxType;
import ai.grakn.Keyspace;
import ai.grakn.client.Grakn;
import ai.grakn.concept.AttributeType;
import ai.grakn.graql.Query;
import ai.grakn.graql.answer.Answer;
import ai.grakn.graql.internal.printer.Printer;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import jline.console.ConsoleReader;
import jline.console.completer.AggregateCompleter;
import javax.annotation.Nullable;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.stream.Stream;
import static ai.grakn.util.CommonUtil.toImmutableSet;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toSet;
import static org.apache.commons.lang.StringEscapeUtils.unescapeJavaScript;
/**
* A Graql REPL shell that can be run from the command line
*
* @author Felix Chapman
*/
public class GraqlShell implements AutoCloseable {
private static final String PROMPT = ">>> ";
private static final String EDIT_COMMAND = "edit";
private static final String COMMIT_COMMAND = "commit";
private static final String ROLLBACK_COMMAND = "rollback";
private static final String LOAD_COMMAND = "load";
private static final String DISPLAY_COMMAND = "display";
private static final String CLEAR_COMMAND = "clear";
private static final String EXIT_COMMAND = "exit";
private static final String LICENSE_COMMAND = "license";
private static final String CLEAN_COMMAND = "clean";
private boolean errorOccurred = false;
/**
* Array of available commands in shell
*/
public static final ImmutableList<String> COMMANDS = ImmutableList.of(
EDIT_COMMAND, COMMIT_COMMAND, ROLLBACK_COMMAND, LOAD_COMMAND, DISPLAY_COMMAND, CLEAR_COMMAND, EXIT_COMMAND,
LICENSE_COMMAND, CLEAN_COMMAND
);
private final Keyspace keyspace;
private final OutputFormat outputFormat;
private final boolean infer;
private ConsoleReader console;
private final PrintStream serr;
private final HistoryFile historyFile;
private final Grakn client;
private final GraknSession session;
private GraknTx tx;
private Set<AttributeType<?>> displayAttributes = ImmutableSet.of();
private final GraqlCompleter graqlCompleter;
private final ExternalEditor editor = ExternalEditor.create();
public static String loadQuery(Path filePath) throws IOException {
List<String> lines = Files.readAllLines(filePath, StandardCharsets.UTF_8);
return lines.stream().collect(joining("\n"));
}
/**
* Create a new Graql shell
*/
public GraqlShell(
String historyFilename, Grakn client, Keyspace keyspace, ConsoleReader console, PrintStream serr,
OutputFormat outputFormat, boolean infer
) throws IOException {
this.keyspace = keyspace;
this.outputFormat = outputFormat;
this.infer = infer;
this.console = console;
this.client = client;
this.session = client.session(keyspace);
this.serr = serr;
this.graqlCompleter = GraqlCompleter.create(session);
this.historyFile = HistoryFile.create(console, historyFilename);
tx = client.session(keyspace).transaction(GraknTxType.WRITE);
}
public void start(@Nullable List<String> queryStrings) throws IOException, InterruptedException {
try {
if (queryStrings != null) {
for (String queryString : queryStrings) {
executeQuery(queryString);
commit();
}
} else {
executeRepl();
}
} finally {
console.flush();
}
}
/**
* Run a Read-Evaluate-Print loop until the input terminates
*/
private void executeRepl() throws IOException, InterruptedException {
License.printLicensePrompt(console);
// Disable JLine feature when seeing a '!', which is used in our queries
console.setExpandEvents(false);
console.setPrompt(PROMPT);
// Add all autocompleters
console.addCompleter(new AggregateCompleter(graqlCompleter, new ShellCommandCompleter()));
String queryString;
java.util.regex.Pattern commandPattern = java.util.regex.Pattern.compile("\\s*(.*?)\\s*;?");
while ((queryString = console.readLine()) != null) {
Matcher matcher = commandPattern.matcher(queryString);
if (matcher.matches()) {
switch (matcher.group(1)) {
case EDIT_COMMAND:
executeQuery(editor.execute());
continue;
case COMMIT_COMMAND:
commit();
continue;
case ROLLBACK_COMMAND:
rollback();
continue;
case CLEAN_COMMAND:
clean();
continue;
case CLEAR_COMMAND:
console.clearScreen();
continue;
case LICENSE_COMMAND:
License.printLicense(console);
continue;
case EXIT_COMMAND:
return;
case "":
// Ignore empty command
continue;
}
}
// Load from a file if load command used
if (queryString.startsWith(LOAD_COMMAND + " ")) {
String pathString = queryString.substring(LOAD_COMMAND.length() + 1);
Path path = Paths.get(unescapeJavaScript(pathString));
try {
queryString = loadQuery(path);
} catch (IOException e) {
serr.println(e.toString());
errorOccurred = true;
continue;
}
}
// Set the resources to display
if (queryString.startsWith(DISPLAY_COMMAND + " ")) {
int endIndex;
if (queryString.endsWith(";")) {
endIndex = queryString.length() - 1;
} else {
endIndex = queryString.length();
}
String[] arguments = queryString.substring(DISPLAY_COMMAND.length() + 1, endIndex).split(",");
Set<String> resources = Stream.of(arguments).map(String::trim).collect(toSet());
setDisplayOptions(resources);
continue;
}
executeQuery(queryString);
}
}
private void executeQuery(String queryString) throws IOException {
Printer<?> printer = outputFormat.getPrinter(displayAttributes);
handleGraknExceptions(() -> {
Stream<Query<Answer>> queries = tx
.graql()
.infer(infer)
.parser()
.parseList(queryString);
Stream<String> results = queries.flatMap(query -> printer.toStream(query.stream()));
results.forEach(result -> {
try {
console.println(result);
} catch (IOException e) {
e.printStackTrace();
}
});
});
// Flush the console so the output is all displayed before the next command
console.flush();
}
private void setDisplayOptions(Set<String> displayOptions) {
displayAttributes = displayOptions.stream().map(tx::getAttributeType).collect(toImmutableSet());
}
private void commit() throws IOException {
handleGraknExceptions(() -> tx.commit());
reopenTx();
}
private void rollback() throws IOException {
handleGraknExceptions(() -> tx.close());
reopenTx();
}
private void clean() throws IOException {
// Get user confirmation to clean graph
console.println("Are you sure? This will clean ALL data in the current keyspace and immediately commit.");
console.println("Type 'confirm' to continue.");
String line = console.readLine();
if (line != null && line.equals("confirm")) {
console.println("Cleaning...");
client.keyspaces().delete(keyspace);
reopenTx();
} else {
console.println("Cancelling clean.");
}
}
private void handleGraknExceptions(RunnableThrowsIO runnable) throws IOException {
try {
runnable.run();
} catch (RuntimeException e) {
serr.println(e.getMessage());
errorOccurred = true;
reopenTx();
}
}
private interface RunnableThrowsIO {
void run() throws IOException;
}
private void reopenTx() {
if (!tx.isClosed()) tx.close();
tx = session.transaction(GraknTxType.WRITE);
}
public boolean errorOccurred() {
return errorOccurred;
}
@Override
public final void close() throws IOException {
tx.close();
session.close();
historyFile.close();
}
}
|
0
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql/shell/GraqlShellOptions.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.shell;
import ai.grakn.Keyspace;
import ai.grakn.util.SimpleURI;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import javax.annotation.Nullable;
import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.nio.charset.Charset;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.stream.Stream;
import static ai.grakn.util.CommonUtil.toImmutableList;
/**
* Wrapper for parsing command-line options for Graql shell
*
* @author Felix Chapman
*/
public class GraqlShellOptions {
public static final Keyspace DEFAULT_KEYSPACE = Keyspace.of("grakn");
private static final String KEYSPACE = "k";
private static final String EXECUTE = "e";
private static final String FILE = "f";
private static final String URI = "r";
private static final String BATCH = "b";
private static final String OUTPUT = "o";
private static final String NO_INFER = "n";
private static final String HELP = "h";
private static final String VERSION = "v";
private final Options options;
private final CommandLine cmd;
private GraqlShellOptions(Options options, CommandLine cmd) {
this.options = options;
this.cmd = cmd;
}
private static Options defaultOptions() {
Options options = new Options();
options.addOption(KEYSPACE, "keyspace", true, "keyspace of the graph");
options.addOption(EXECUTE, "execute", true, "query to execute");
options.addOption(FILE, "file", true, "graql file path to execute");
options.addOption(URI, "uri", true, "uri to factory to engine");
options.addOption(BATCH, "batch", true, "graql file path to batch load");
options.addOption(OUTPUT, "output", true, "output format for results");
options.addOption(NO_INFER, "no_infer", false, "do not perform inference on results");
options.addOption(HELP, "help", false, "print usage message");
options.addOption(VERSION, "version", false, "print version");
return options;
}
public static GraqlShellOptions create(String[] args) throws ParseException {
return create(args, new Options());
}
public static GraqlShellOptions create(String[] args, Options additionalOptions) throws ParseException {
Options options = defaultOptions();
for (Option option : additionalOptions.getOptions()) {
options.addOption(option);
}
CommandLineParser parser = new DefaultParser();
CommandLine cmd = parser.parse(options, args);
return new GraqlShellOptions(options, cmd);
}
public CommandLine cmd() {
return cmd;
}
public void printUsage(PrintStream sout) {
HelpFormatter helpFormatter = new HelpFormatter();
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(sout, Charset.defaultCharset());
PrintWriter printWriter = new PrintWriter(new BufferedWriter(outputStreamWriter));
int width = helpFormatter.getWidth();
int leftPadding = helpFormatter.getLeftPadding();
int descPadding = helpFormatter.getDescPadding();
helpFormatter.printHelp(printWriter, width, "graql console", null, options, leftPadding, descPadding, null);
printWriter.flush();
}
@Nullable
public Path getBatchLoadPath() {
String path = cmd.getOptionValue(BATCH);
return path != null ? Paths.get(path) : null;
}
public boolean shouldInfer() {
return !cmd.hasOption(NO_INFER);
}
public OutputFormat getOutputFormat() {
String format = cmd.getOptionValue(OUTPUT);
return format != null ? OutputFormat.get(format) : OutputFormat.DEFAULT;
}
@Nullable
public SimpleURI getUri() {
String uri = cmd.getOptionValue(URI);
return uri != null ? new SimpleURI(uri) : null;
}
public boolean displayVersion() {
return cmd.hasOption(VERSION);
}
public boolean displayHelp() {
return cmd.hasOption(HELP) || !cmd.getArgList().isEmpty();
}
public Keyspace getKeyspace() {
String keyspace = cmd.getOptionValue(KEYSPACE);
return keyspace != null ? Keyspace.of(keyspace) : DEFAULT_KEYSPACE;
}
@Nullable
public List<Path> getFiles() {
String[] paths = cmd.getOptionValues(FILE);
return paths != null ? Stream.of(paths).map(Paths::get).collect(toImmutableList()) : null;
}
@Nullable
public String getQuery() {
return cmd.getOptionValue(EXECUTE);
}
}
|
0
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql/shell/HistoryFile.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.shell;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import jline.console.ConsoleReader;
import jline.console.history.FileHistory;
import java.io.File;
import java.io.IOException;
/**
* Represents the history file used in {@link GraqlShell}. Will flush to disk when closed.
*
* @author Felix Chapman
*/
final class HistoryFile implements AutoCloseable {
private final FileHistory jlineHistory;
private HistoryFile(FileHistory jlineHistory) {
this.jlineHistory = jlineHistory;
}
// The result of createNewFile indicates if the file already existed, but that doesn't matter
@SuppressWarnings("ResultOfMethodCallIgnored")
@SuppressFBWarnings("RV_RETURN_VALUE_IGNORED_BAD_PRACTICE")
public static HistoryFile create(ConsoleReader consoleReader, String historyFilename) throws IOException {
// Create history file
File historyFile = new File(historyFilename);
historyFile.createNewFile();
FileHistory jlineHistory = new FileHistory(historyFile);
consoleReader.setHistory(jlineHistory);
// Make sure history is saved on shutdown
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
try {
jlineHistory.flush();
} catch (IOException e) {
throw new RuntimeException(e);
}
}));
return new HistoryFile(jlineHistory);
}
@Override
public void close() throws IOException {
jlineHistory.flush();
}
}
|
0
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql/shell/License.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.shell;
import jline.console.ConsoleReader;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
/**
* Handles printing the license for {@link GraqlShell}.
*
* @author Felix Chapman
*/
public class License {
private static final String LICENSE_PROMPT = "\n" +
"Grakn Copyright (C) 2018 Grakn Labs Limited \n" +
"This is free software, and you are welcome to redistribute it \n" +
"under certain conditions; type 'license' for details.\n";
private static final String LICENSE_LOCATION = "LICENSE";
public License() {
}
static void printLicensePrompt(ConsoleReader console) throws IOException {
console.print(LICENSE_PROMPT);
}
static void printLicense(ConsoleReader console) throws IOException {
StringBuilder result = new StringBuilder("");
//Get file from resources folder
ClassLoader classloader = Thread.currentThread().getContextClassLoader();
InputStream is = classloader.getResourceAsStream(LICENSE_LOCATION);
Scanner scanner = new Scanner(is, StandardCharsets.UTF_8.name());
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
result.append(line).append("\n");
}
result.append("\n");
scanner.close();
console.println(result.toString());
}
}
|
0
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql/shell/OutputFormat.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.shell;
import ai.grakn.concept.AttributeType;
import ai.grakn.graql.internal.printer.Printer;
import java.util.Set;
/**
* Valid output formats for the Graql shell
*
* @author Grakn Warriors
*/
public abstract class OutputFormat {
abstract Printer<?> getPrinter(Set<AttributeType<?>> displayAttributes);
static final OutputFormat DEFAULT = new OutputFormat.Graql();
public static OutputFormat get(String name) {
switch (name) {
case "json":
return new OutputFormat.JSON();
case "graql":
default:
return new OutputFormat.Graql();
}
}
static class JSON extends OutputFormat {
@Override
Printer<?> getPrinter(Set<AttributeType<?>> displayAttributes) {
return Printer.jsonPrinter();
}
}
static class Graql extends OutputFormat {
@Override
Printer<?> getPrinter(Set<AttributeType<?>> displayAttributes) {
AttributeType<?>[] array = displayAttributes.toArray(new AttributeType[displayAttributes.size()]);
return Printer.stringPrinter(true, array);
}
}
}
|
0
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql
|
java-sources/ai/grakn/grakn-graql-shell/1.4.3/ai/grakn/graql/shell/ShellCommandCompleter.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.graql.shell;
import jline.console.completer.Completer;
import java.util.List;
/**
* Completer that complete Graql shell commands
*
* @author Felix Chapman
*/
public class ShellCommandCompleter implements Completer {
@Override
public int complete(String buffer, int cursor, List<CharSequence> candidates) {
GraqlShell.COMMANDS.stream()
.filter(command -> command.startsWith(buffer))
.forEach(candidates::add);
return 0;
}
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/grpc/AutoValue_RolePlayer.java
|
package ai.grakn.grpc;
import ai.grakn.concept.Role;
import ai.grakn.concept.Thing;
import javax.annotation.Generated;
@Generated("com.google.auto.value.processor.AutoValueProcessor")
final class AutoValue_RolePlayer extends RolePlayer {
private final Role role;
private final Thing player;
AutoValue_RolePlayer(
Role role,
Thing player) {
if (role == null) {
throw new NullPointerException("Null role");
}
this.role = role;
if (player == null) {
throw new NullPointerException("Null player");
}
this.player = player;
}
@Override
public Role role() {
return role;
}
@Override
public Thing player() {
return player;
}
@Override
public String toString() {
return "RolePlayer{"
+ "role=" + role + ", "
+ "player=" + player
+ "}";
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (o instanceof RolePlayer) {
RolePlayer that = (RolePlayer) o;
return (this.role.equals(that.role()))
&& (this.player.equals(that.player()));
}
return false;
}
@Override
public int hashCode() {
int h = 1;
h *= 1000003;
h ^= this.role.hashCode();
h *= 1000003;
h ^= this.player.hashCode();
return h;
}
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/grpc/AutoValue_TxGrpcCommunicator_Response.java
|
package ai.grakn.grpc;
import ai.grakn.rpc.generated.GrpcGrakn;
import io.grpc.StatusRuntimeException;
import javax.annotation.Generated;
import javax.annotation.Nullable;
@Generated("com.google.auto.value.processor.AutoValueProcessor")
final class AutoValue_TxGrpcCommunicator_Response extends TxGrpcCommunicator.Response {
private final GrpcGrakn.TxResponse nullableOk;
private final StatusRuntimeException nullableError;
AutoValue_TxGrpcCommunicator_Response(
@Nullable GrpcGrakn.TxResponse nullableOk,
@Nullable StatusRuntimeException nullableError) {
this.nullableOk = nullableOk;
this.nullableError = nullableError;
}
@Nullable
@Override
GrpcGrakn.TxResponse nullableOk() {
return nullableOk;
}
@Nullable
@Override
StatusRuntimeException nullableError() {
return nullableError;
}
@Override
public String toString() {
return "Response{"
+ "nullableOk=" + nullableOk + ", "
+ "nullableError=" + nullableError
+ "}";
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (o instanceof TxGrpcCommunicator.Response) {
TxGrpcCommunicator.Response that = (TxGrpcCommunicator.Response) o;
return ((this.nullableOk == null) ? (that.nullableOk() == null) : this.nullableOk.equals(that.nullableOk()))
&& ((this.nullableError == null) ? (that.nullableError() == null) : this.nullableError.equals(that.nullableError()));
}
return false;
}
@Override
public int hashCode() {
int h = 1;
h *= 1000003;
h ^= (nullableOk == null) ? 0 : this.nullableOk.hashCode();
h *= 1000003;
h ^= (nullableError == null) ? 0 : this.nullableError.hashCode();
return h;
}
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/grpc/ConceptMethod.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016-2018 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Grakn is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Grakn. If not, see <http://www.gnu.org/licenses/gpl.txt>.
*/
package ai.grakn.grpc;
import ai.grakn.concept.Concept;
import ai.grakn.rpc.generated.GrpcConcept;
import ai.grakn.rpc.generated.GrpcConcept.ConceptResponse;
import ai.grakn.rpc.generated.GrpcGrakn.TxResponse;
import com.google.common.base.Preconditions;
import javax.annotation.Nullable;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
/**
* Wrapper for describing methods on {@link Concept}s that can be executed over gRPC.
*
* <p>
* This unifies client and server behaviour for each possible method on a concept.
* </p>
*
* <p>
* This class maps one-to-one with the gRPC message {@link ai.grakn.rpc.generated.GrpcConcept.ConceptMethod}.
* </p>
*
* @param <T> The type of the concept method return value.
* @author Felix Chapman
*/
public final class ConceptMethod<T> {
// This is the method that is used to create the request on the client-side
private final Consumer<GrpcConcept.ConceptMethod.Builder> responseSetter;
// This method is used to extract the value from a Concept
private final Function<Concept, T> function;
// This describes the type of the response, including information about how to extract it from a gRPC message on the
// client side and how to create a gRPC message containing it on the server side
private final ConceptResponseType<T> responseType;
private ConceptMethod(
Consumer<GrpcConcept.ConceptMethod.Builder> responseSetter,
Function<Concept, T> function,
ConceptResponseType<T> responseType
) {
this.responseSetter = responseSetter;
this.function = function;
this.responseType = responseType;
}
public TxResponse createTxResponse(GrpcIterators iterators, T value) {
ConceptResponse.Builder conceptResponse = ConceptResponse.newBuilder();
set(conceptResponse, iterators, value);
return TxResponse.newBuilder().setConceptResponse(conceptResponse.build()).build();
}
public TxResponse run(GrpcIterators iterators, Concept concept) {
return createTxResponse(iterators, function.apply(concept));
}
@Nullable
public T get(GrpcConceptConverter conceptConverter, GrpcClient client, TxResponse txResponse) {
ConceptResponse conceptResponse = txResponse.getConceptResponse();
return responseType.get(conceptConverter, client, conceptResponse);
}
public void set(ConceptResponse.Builder builder, GrpcIterators iterators, T value) {
responseType.set(builder, iterators, value);
}
public GrpcConcept.ConceptMethod toGrpc() {
GrpcConcept.ConceptMethod.Builder builder = GrpcConcept.ConceptMethod.newBuilder();
responseSetter.accept(builder);
return builder.build();
}
static <T> Builder<T> builder(ConceptResponseType<T> responseType) {
return new Builder<>(responseType);
}
/**
* Builder for {@link ConceptMethod}
*/
static class Builder<T> {
@Nullable
private Consumer<GrpcConcept.ConceptMethod.Builder> requestSetter;
@Nullable
private Function<Concept, T> function;
private final ConceptResponseType<T> responseType;
private Builder(ConceptResponseType<T> responseType) {
this.responseType = responseType;
}
Builder<T> requestSetter(Consumer<GrpcConcept.ConceptMethod.Builder> requestSetter) {
this.requestSetter = requestSetter;
return this;
}
Builder<T> requestSetterUnit(BiConsumer<GrpcConcept.ConceptMethod.Builder, GrpcConcept.Unit> requestSetter) {
this.requestSetter = builder -> requestSetter.accept(builder, GrpcConcept.Unit.getDefaultInstance());
return this;
}
public Builder<T> function(Function<Concept, T> function) {
this.function = function;
return this;
}
public Builder<T> functionVoid(Consumer<Concept> function) {
this.function = concept -> {
function.accept(concept);
return null;
};
return this;
}
public ConceptMethod<T> build() {
Preconditions.checkNotNull(requestSetter);
Preconditions.checkNotNull(function);
return new ConceptMethod<>(requestSetter, function, responseType);
}
}
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/grpc/ConceptMethods.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016-2018 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Grakn is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Grakn. If not, see <http://www.gnu.org/licenses/gpl.txt>.
*/
package ai.grakn.grpc;
import ai.grakn.concept.Attribute;
import ai.grakn.concept.AttributeType;
import ai.grakn.concept.Concept;
import ai.grakn.concept.Label;
import ai.grakn.concept.Role;
import ai.grakn.concept.SchemaConcept;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.graql.Pattern;
import ai.grakn.rpc.generated.GrpcConcept;
import java.util.Optional;
import java.util.stream.Stream;
import static ai.grakn.grpc.GrpcUtil.convert;
import static ai.grakn.grpc.GrpcUtil.convertValue;
/**
* Static class providing all possible {@link ConceptMethod}s.
*
* @author Felix Chapman
*/
public class ConceptMethods {
// These constants are simply ConceptMethods that don't have parameters (e.g. getters).
// You could make them zero-argument functions if you want!
public static final ConceptMethod<Object> GET_VALUE = ConceptMethod.builder(ConceptResponseType.ATTRIBUTE_VALUE)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetValue)
.function(val -> val.asAttribute().getValue())
.build();
public static final ConceptMethod<Optional<AttributeType.DataType<?>>> GET_DATA_TYPE_OF_TYPE =
ConceptMethod.builder(ConceptResponseType.OPTIONAL_DATA_TYPE)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetDataTypeOfType)
.function(val -> Optional.ofNullable(val.asAttributeType().getDataType()))
.build();
public static final ConceptMethod<AttributeType.DataType<?>> GET_DATA_TYPE_OF_ATTRIBUTE =
ConceptMethod.builder(ConceptResponseType.DATA_TYPE)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetDataTypeOfAttribute)
.function(val -> val.asAttribute().dataType())
.build();
public static final ConceptMethod<Label> GET_LABEL = ConceptMethod.builder(ConceptResponseType.LABEL)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetLabel)
.function(concept -> concept.asSchemaConcept().getLabel())
.build();
public static final ConceptMethod<Boolean> IS_IMPLICIT = ConceptMethod.builder(ConceptResponseType.BOOL)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setIsImplicit)
.function(concept -> concept.asSchemaConcept().isImplicit())
.build();
public static final ConceptMethod<Boolean> IS_INFERRED = ConceptMethod.builder(ConceptResponseType.BOOL)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setIsInferred)
.function(concept -> concept.asThing().isInferred())
.build();
public static final ConceptMethod<Boolean> IS_ABSTRACT = ConceptMethod.builder(ConceptResponseType.BOOL)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setIsAbstract)
.function(concept -> concept.asType().isAbstract())
.build();
public static final ConceptMethod<Optional<Pattern>> GET_WHEN = ConceptMethod.builder(ConceptResponseType.OPTIONAL_PATTERN)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetWhen)
.function(concept -> Optional.ofNullable(concept.asRule().getWhen()))
.build();
public static final ConceptMethod<Optional<Pattern>> GET_THEN = ConceptMethod.builder(ConceptResponseType.OPTIONAL_PATTERN)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetThen)
.function(concept -> Optional.ofNullable(concept.asRule().getThen()))
.build();
public static final ConceptMethod<Optional<String>> GET_REGEX = ConceptMethod.builder(ConceptResponseType.OPTIONAL_REGEX)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetRegex)
.function(concept -> Optional.ofNullable(concept.asAttributeType().getRegex()))
.build();
public static final ConceptMethod<Stream<? extends RolePlayer>> GET_ROLE_PLAYERS =
ConceptMethod.builder(ConceptResponseType.ROLE_PLAYERS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetRolePlayers)
.function(concept -> {
Stream.Builder<RolePlayer> rolePlayers = Stream.builder();
concept.asRelationship().allRolePlayers().forEach((role, players) -> {
players.forEach(player -> {
rolePlayers.add(RolePlayer.create(role, player));
});
});
return rolePlayers.build();
})
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_ATTRIBUTE_TYPES =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetAttributeTypes)
.function(concept -> concept.asType().attributes())
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_KEY_TYPES =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetKeyTypes)
.function(concept -> concept.asType().keys())
.build();
public static final ConceptMethod<Concept> GET_DIRECT_TYPE =
ConceptMethod.builder(ConceptResponseType.CONCEPT)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetDirectType)
.function(concept -> concept.asThing().type())
.build();
public static final ConceptMethod<Optional<Concept>> GET_DIRECT_SUPER =
ConceptMethod.builder(ConceptResponseType.OPTIONAL_CONCEPT)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetDirectSuperConcept)
.function(concept -> Optional.ofNullable(concept.asSchemaConcept().sup()))
.build();
public static final ConceptMethod<Void> DELETE =
ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setDelete)
.functionVoid(Concept::delete)
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_SUPER_CONCEPTS =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetSuperConcepts)
.function(concept -> concept.asSchemaConcept().sups())
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_SUB_CONCEPTS =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetSubConcepts)
.function(concept -> concept.asSchemaConcept().subs())
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_ATTRIBUTES =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetAttributes)
.function(concept -> concept.asThing().attributes())
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_KEYS =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetKeys)
.function(concept -> concept.asThing().keys())
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_ROLES_PLAYED_BY_TYPE =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetRolesPlayedByType)
.function(concept -> concept.asType().plays())
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_INSTANCES =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetInstances)
.function(concept -> concept.asType().instances())
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_ROLES_PLAYED_BY_THING =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetRolesPlayedByThing)
.function(concept -> concept.asThing().plays())
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_RELATIONSHIPS =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetRelationships)
.function(concept -> concept.asThing().relationships())
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_RELATIONSHIP_TYPES_THAT_RELATE_ROLE =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetRelationshipTypesThatRelateRole)
.function(concept -> concept.asRole().relationshipTypes())
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_TYPES_THAT_PLAY_ROLE =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetTypesThatPlayRole)
.function(concept -> concept.asRole().playedByTypes())
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_RELATED_ROLES =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetRelatedRoles)
.function(concept -> concept.asRelationshipType().relates())
.build();
public static final ConceptMethod<Stream<? extends Concept>> GET_OWNERS =
ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setGetOwners)
.function(concept -> concept.asAttribute().ownerInstances())
.build();
public static final ConceptMethod<Concept> ADD_ENTITY =
ConceptMethod.builder(ConceptResponseType.CONCEPT)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setAddEntity)
.function(concept -> concept.asEntityType().addEntity())
.build();
public static final ConceptMethod<Concept> ADD_RELATIONSHIP =
ConceptMethod.builder(ConceptResponseType.CONCEPT)
.requestSetterUnit(GrpcConcept.ConceptMethod.Builder::setAddRelationship)
.function(concept -> concept.asRelationshipType().addRelationship())
.build();
public static ConceptMethod<Void> setLabel(Label label) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setSetLabel(convert(label)))
.functionVoid(concept -> concept.asSchemaConcept().setLabel(label))
.build();
}
public static ConceptMethod<Void> setAbstract(boolean isAbstract) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setSetAbstract(isAbstract))
.functionVoid(concept -> concept.asType().setAbstract(isAbstract))
.build();
}
public static ConceptMethod<Void> setRegex(Optional<String> regex) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setSetRegex(GrpcUtil.convertRegex(regex)))
.functionVoid(concept -> concept.asAttributeType().setRegex(regex.orElse(null)))
.build();
}
public static ConceptMethod<Void> setAttributeType(AttributeType<?> attributeType) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setSetAttributeType(convert(attributeType)))
.functionVoid(concept -> concept.asType().attribute(attributeType))
.build();
}
public static ConceptMethod<Void> unsetAttributeType(AttributeType<?> attributeType) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setUnsetAttributeType(convert(attributeType)))
.functionVoid(concept -> concept.asType().deleteAttribute(attributeType))
.build();
}
public static ConceptMethod<Void> setKeyType(AttributeType<?> attributeType) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setSetKeyType(convert(attributeType)))
.functionVoid(concept -> concept.asType().key(attributeType))
.build();
}
public static ConceptMethod<Void> unsetKeyType(AttributeType<?> attributeType) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setUnsetKeyType(convert(attributeType)))
.functionVoid(concept -> concept.asType().deleteKey(attributeType))
.build();
}
public static ConceptMethod<Void> setDirectSuperConcept(SchemaConcept schemaConcept) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setSetDirectSuperConcept(convert(schemaConcept)))
.functionVoid(concept -> setSuper(concept.asSchemaConcept(), schemaConcept))
.build();
}
public static ConceptMethod<Void> removeRolePlayer(RolePlayer rolePlayer) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setUnsetRolePlayer(convert(rolePlayer)))
.functionVoid(concept -> {
concept.asRelationship().removeRolePlayer(rolePlayer.role(), rolePlayer.player());
})
.build();
}
public static ConceptMethod<Optional<Concept>> getAttribute(Object value) {
return ConceptMethod.builder(ConceptResponseType.OPTIONAL_CONCEPT)
.requestSetter(builder -> builder.setGetAttribute(convertValue(value)))
.function(concept -> Optional.ofNullable(concept.asAttributeType().getAttribute(value)))
.build();
}
public static ConceptMethod<Stream<? extends Concept>> getAttributesByTypes(AttributeType<?>... attributeTypes) {
return ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetter(builder -> builder.setGetAttributesByTypes(convert(Stream.of(attributeTypes))))
.function(concept -> concept.asThing().attributes(attributeTypes))
.build();
}
public static ConceptMethod<Concept> setAttribute(Attribute<?> attribute) {
return ConceptMethod.builder(ConceptResponseType.CONCEPT)
.requestSetter(builder -> builder.setSetAttribute(convert(attribute)))
.function(concept -> concept.asThing().attributeRelationship(attribute))
.build();
}
public static ConceptMethod<Void> unsetAttribute(Attribute<?> attribute) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setUnsetAttribute(convert(attribute)))
.functionVoid(concept -> concept.asThing().deleteAttribute(attribute))
.build();
}
public static ConceptMethod<Stream<? extends Concept>> getKeysByTypes(AttributeType<?>... attributeTypes) {
return ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetter(builder -> builder.setGetKeysByTypes(convert(Stream.of(attributeTypes))))
.function(concept -> concept.asThing().keys(attributeTypes))
.build();
}
public static ConceptMethod<Void> setRolePlayedByType(Role role) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setSetRolePlayedByType(convert(role)))
.functionVoid(concept -> concept.asType().plays(role))
.build();
}
public static ConceptMethod<Void> unsetRolePlayedByType(Role role) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setUnsetRolePlayedByType(convert(role)))
.functionVoid(concept -> concept.asType().deletePlays(role))
.build();
}
public static ConceptMethod<Stream<? extends Concept>> getRolePlayersByRoles(Role... roles) {
return ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetter(builder -> builder.setGetRolePlayersByRoles(convert(Stream.of(roles))))
.function(concept -> concept.asRelationship().rolePlayers(roles))
.build();
}
public static ConceptMethod<Void> setRolePlayer(RolePlayer rolePlayer) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setSetRolePlayer(convert(rolePlayer)))
.functionVoid(concept -> concept.asRelationship().addRolePlayer(rolePlayer.role(), rolePlayer.player()))
.build();
}
public static ConceptMethod<Stream<? extends Concept>> getRelationshipsByRoles(Role... roles) {
return ConceptMethod.builder(ConceptResponseType.CONCEPTS)
.requestSetter(builder -> builder.setGetRelationshipsByRoles(convert(Stream.of(roles))))
.function(concept -> concept.asThing().relationships(roles))
.build();
}
public static ConceptMethod<Void> setRelatedRole(Role role) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setSetRelatedRole(convert(role)))
.functionVoid(concept -> concept.asRelationshipType().relates(role))
.build();
}
public static ConceptMethod<Void> unsetRelatedRole(Role role) {
return ConceptMethod.builder(ConceptResponseType.UNIT)
.requestSetter(builder -> builder.setUnsetRelatedRole(convert(role)))
.functionVoid(concept -> concept.asRelationshipType().deleteRelates(role))
.build();
}
public static ConceptMethod<Concept> putAttribute(Object value) {
return ConceptMethod.builder(ConceptResponseType.CONCEPT)
.requestSetter(builder -> builder.setPutAttribute(convertValue(value)))
.function(concept -> concept.asAttributeType().putAttribute(value))
.build();
}
public static ConceptMethod<?> fromGrpc(GrpcConceptConverter converter, GrpcConcept.ConceptMethod conceptMethod) {
Role[] roles;
switch (conceptMethod.getConceptMethodCase()) {
case GETVALUE:
return GET_VALUE;
case GETDATATYPEOFTYPE:
return GET_DATA_TYPE_OF_TYPE;
case GETDATATYPEOFATTRIBUTE:
return GET_DATA_TYPE_OF_ATTRIBUTE;
case GETLABEL:
return GET_LABEL;
case SETLABEL:
return setLabel(convert(conceptMethod.getSetLabel()));
case ISIMPLICIT:
return IS_IMPLICIT;
case ISINFERRED:
return IS_INFERRED;
case ISABSTRACT:
return IS_ABSTRACT;
case GETWHEN:
return GET_WHEN;
case GETTHEN:
return GET_THEN;
case GETREGEX:
return GET_REGEX;
case GETROLEPLAYERS:
return GET_ROLE_PLAYERS;
case GETATTRIBUTETYPES:
return GET_ATTRIBUTE_TYPES;
case SETATTRIBUTETYPE:
return setAttributeType(converter.convert(conceptMethod.getSetAttributeType()).asAttributeType());
case UNSETATTRIBUTETYPE:
return unsetAttributeType(converter.convert(conceptMethod.getUnsetAttributeType()).asAttributeType());
case GETKEYTYPES:
return GET_KEY_TYPES;
case GETDIRECTTYPE:
return GET_DIRECT_TYPE;
case GETDIRECTSUPERCONCEPT:
return GET_DIRECT_SUPER;
case SETDIRECTSUPERCONCEPT:
GrpcConcept.Concept setDirectSuperConcept = conceptMethod.getSetDirectSuperConcept();
SchemaConcept schemaConcept = converter.convert(setDirectSuperConcept).asSchemaConcept();
return setDirectSuperConcept(schemaConcept);
case UNSETROLEPLAYER:
return removeRolePlayer(converter.convert(conceptMethod.getUnsetRolePlayer()));
case DELETE:
return DELETE;
case GETATTRIBUTE:
return getAttribute(convert(conceptMethod.getGetAttribute()));
case GETOWNERS:
return GET_OWNERS;
case GETTYPESTHATPLAYROLE:
return GET_TYPES_THAT_PLAY_ROLE;
case GETROLESPLAYEDBYTYPE:
return GET_ROLES_PLAYED_BY_TYPE;
case GETINSTANCES:
return GET_INSTANCES;
case GETRELATEDROLES:
return GET_RELATED_ROLES;
case GETATTRIBUTES:
return GET_ATTRIBUTES;
case GETSUPERCONCEPTS:
return GET_SUPER_CONCEPTS;
case GETRELATIONSHIPTYPESTHATRELATEROLE:
return GET_RELATIONSHIP_TYPES_THAT_RELATE_ROLE;
case GETATTRIBUTESBYTYPES:
GrpcConcept.Concepts getAttributeTypes = conceptMethod.getGetAttributesByTypes();
AttributeType<?>[] attributeTypes = convert(converter, getAttributeTypes).toArray(AttributeType[]::new);
return getAttributesByTypes(attributeTypes);
case GETRELATIONSHIPS:
return GET_RELATIONSHIPS;
case GETSUBCONCEPTS:
return GET_SUB_CONCEPTS;
case GETRELATIONSHIPSBYROLES:
roles = convert(converter, conceptMethod.getGetRelationshipsByRoles()).toArray(Role[]::new);
return getRelationshipsByRoles(roles);
case GETROLESPLAYEDBYTHING:
return GET_ROLES_PLAYED_BY_THING;
case GETKEYS:
return GET_KEYS;
case GETKEYSBYTYPES:
GrpcConcept.Concepts getKeyTypes = conceptMethod.getGetAttributesByTypes();
AttributeType<?>[] keyTypes = convert(converter, getKeyTypes).toArray(AttributeType[]::new);
return getKeysByTypes(keyTypes);
case GETROLEPLAYERSBYROLES:
roles = convert(converter, conceptMethod.getGetRolePlayersByRoles()).toArray(Role[]::new);
return getRolePlayersByRoles(roles);
case SETKEYTYPE:
return setKeyType(converter.convert(conceptMethod.getSetKeyType()).asAttributeType());
case UNSETKEYTYPE:
return unsetKeyType(converter.convert(conceptMethod.getUnsetKeyType()).asAttributeType());
case SETABSTRACT:
return setAbstract(conceptMethod.getSetAbstract());
case SETROLEPLAYEDBYTYPE:
return setRolePlayedByType(converter.convert(conceptMethod.getSetRolePlayedByType()).asRole());
case UNSETROLEPLAYEDBYTYPE:
return unsetRolePlayedByType(converter.convert(conceptMethod.getUnsetRolePlayedByType()).asRole());
case ADDENTITY:
return ADD_ENTITY;
case SETRELATEDROLE:
return setRelatedRole(converter.convert(conceptMethod.getSetRelatedRole()).asRole());
case UNSETRELATEDROLE:
return unsetRelatedRole(converter.convert(conceptMethod.getUnsetRelatedRole()).asRole());
case PUTATTRIBUTE:
return putAttribute(convert(conceptMethod.getPutAttribute()));
case SETREGEX:
return setRegex(convert(conceptMethod.getSetRegex()));
case SETATTRIBUTE:
return setAttribute(converter.convert(conceptMethod.getSetAttribute()).asAttribute());
case UNSETATTRIBUTE:
return unsetAttribute(converter.convert(conceptMethod.getUnsetAttribute()).asAttribute());
case ADDRELATIONSHIP:
return ADD_RELATIONSHIP;
case SETROLEPLAYER:
return setRolePlayer(converter.convert(conceptMethod.getSetRolePlayer()));
default:
case CONCEPTMETHOD_NOT_SET:
throw new IllegalArgumentException("Unrecognised " + conceptMethod);
}
}
// TODO: This was copied from ConceptBuilder
/**
* Make the second argument the super of the first argument
*
* @throws GraqlQueryException if the types are different, or setting the super to be a meta-type
*/
private static void setSuper(SchemaConcept subConcept, SchemaConcept superConcept) {
if (superConcept.isEntityType()) {
subConcept.asEntityType().sup(superConcept.asEntityType());
} else if (superConcept.isRelationshipType()) {
subConcept.asRelationshipType().sup(superConcept.asRelationshipType());
} else if (superConcept.isRole()) {
subConcept.asRole().sup(superConcept.asRole());
} else if (superConcept.isAttributeType()) {
subConcept.asAttributeType().sup(superConcept.asAttributeType());
} else if (superConcept.isRule()) {
subConcept.asRule().sup(superConcept.asRule());
} else {
throw GraqlQueryException.insertMetaType(subConcept.getLabel(), superConcept);
}
}
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/grpc/ConceptResponseType.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016-2018 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Grakn is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Grakn. If not, see <http://www.gnu.org/licenses/gpl.txt>.
*/
package ai.grakn.grpc;
import ai.grakn.concept.AttributeType;
import ai.grakn.concept.Concept;
import ai.grakn.concept.Label;
import ai.grakn.graql.Pattern;
import ai.grakn.rpc.generated.GrpcConcept;
import ai.grakn.rpc.generated.GrpcConcept.ConceptResponse;
import ai.grakn.rpc.generated.GrpcGrakn.TxResponse;
import ai.grakn.rpc.generated.GrpcIterator.IteratorId;
import org.apache.tinkerpop.gremlin.util.function.TriConsumer;
import org.apache.tinkerpop.gremlin.util.function.TriFunction;
import javax.annotation.Nullable;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
/**
* Wrapper around the different types of responses to {@link ConceptMethod}s applied on {@link Concept}s.
*
* @author Felix Chapman
*/
abstract class ConceptResponseType<T> {
public static final ConceptResponseType<Boolean> BOOL =
ConceptResponseType.create(ConceptResponse::getBool, ConceptResponse.Builder::setBool);
public static final ConceptResponseType<Optional<Pattern>> OPTIONAL_PATTERN = ConceptResponseType.create(
response -> GrpcUtil.convert(response.getOptionalPattern()),
(builder, val) -> builder.setOptionalPattern(GrpcUtil.convert(val))
);
public static final ConceptResponseType<Concept> CONCEPT = ConceptResponseType.create(
(converter, response) -> converter.convert(response.getConcept()),
(builder, val) -> builder.setConcept(GrpcUtil.convert(val))
);
public static final ConceptResponseType<Optional<Concept>> OPTIONAL_CONCEPT = ConceptResponseType.create(
(converter, response) -> converter.convert(response.getOptionalConcept()),
(builder, val) -> builder.setOptionalConcept(GrpcUtil.convertOptionalConcept(val))
);
public static final ConceptResponseType<Stream<? extends Concept>> CONCEPTS =
ConceptResponseType.createStreamable(
(converter, response) -> converter.convert(response.getConcept()),
GrpcUtil::conceptResponse
);
public static final ConceptResponseType<Stream<? extends RolePlayer>> ROLE_PLAYERS =
ConceptResponseType.createStreamable(
(converter, response) -> converter.convert(response.getRolePlayer()),
GrpcUtil::rolePlayerResponse
);
public static final ConceptResponseType<AttributeType.DataType<?>> DATA_TYPE = ConceptResponseType.create(
response -> GrpcUtil.convert(response.getDataType()),
(builder, val) -> builder.setDataType(GrpcUtil.convert(val))
);
public static final ConceptResponseType<Optional<AttributeType.DataType<?>>> OPTIONAL_DATA_TYPE =
ConceptResponseType.create(
response -> GrpcUtil.convert(response.getOptionalDataType()),
(builder, val) -> builder.setOptionalDataType(GrpcUtil.convertOptionalDataType(val))
);
public static final ConceptResponseType<Object> ATTRIBUTE_VALUE = ConceptResponseType.create(
response -> GrpcUtil.convert(response.getAttributeValue()),
(builder, val) -> builder.setAttributeValue(GrpcUtil.convertValue(val))
);
public static final ConceptResponseType<Label> LABEL = ConceptResponseType.create(
response -> GrpcUtil.convert(response.getLabel()),
(builder, val) -> builder.setLabel(GrpcUtil.convert(val))
);
public static final ConceptResponseType<String> STRING =
ConceptResponseType.create(ConceptResponse::getString, ConceptResponse.Builder::setString);
public static final ConceptResponseType<Void> UNIT = ConceptResponseType.create(
response -> null,
(builder, val) -> builder.setUnit(GrpcConcept.Unit.getDefaultInstance())
);
public static final ConceptResponseType<Optional<String>> OPTIONAL_REGEX = ConceptResponseType.create(
response -> GrpcUtil.convert(response.getOptionalRegex()),
(builder, val) -> builder.setOptionalRegex(GrpcUtil.convertRegex(val))
);
@Nullable
public abstract T get(GrpcConceptConverter converter, GrpcClient client, ConceptResponse conceptResponse);
public abstract void set(ConceptResponse.Builder builder, GrpcIterators iterators, @Nullable T value);
public static <T> ConceptResponseType<T> create(
Function<ConceptResponse, T> getter,
BiConsumer<ConceptResponse.Builder, T> setter
) {
return create((converter, response) -> getter.apply(response), setter);
}
public static <T> ConceptResponseType<T> create(
BiFunction<GrpcConceptConverter, ConceptResponse, T> getter,
BiConsumer<ConceptResponse.Builder, T> setter
) {
return create(
(converter, client, response) -> getter.apply(converter, response),
(builder, iterators, val) -> setter.accept(builder, val)
);
}
public static <T> ConceptResponseType<Stream<? extends T>> createStreamable(
BiFunction<GrpcConceptConverter, TxResponse, T> getter,
Function<T, TxResponse> setter
) {
return create(
(converter, client, response) -> {
IteratorId iteratorId = response.getIteratorId();
Iterable<T> iterable = () -> new GraknGrpcIterator<T>(client, iteratorId) {
@Override
protected T getNextFromResponse(TxResponse response) {
return getter.apply(converter, response);
}
};
return StreamSupport.stream(iterable.spliterator(), false);
},
(builder, iterators, val) -> {
Stream<TxResponse> responses = val.map(setter);
IteratorId iteratorId = iterators.add(responses.iterator());
builder.setIteratorId(iteratorId);
}
);
}
public static <T> ConceptResponseType<T> create(
TriFunction<GrpcConceptConverter, GrpcClient, ConceptResponse, T> getter,
TriConsumer<ConceptResponse.Builder, GrpcIterators, T> setter
) {
return new ConceptResponseType<T>() {
@Override
public T get(GrpcConceptConverter converter, GrpcClient client, ConceptResponse conceptResponse) {
return getter.apply(converter, client, conceptResponse);
}
@Override
public void set(ConceptResponse.Builder builder, GrpcIterators iterators, @Nullable T value) {
setter.accept(builder, iterators, value);
}
};
}
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/grpc/GraknGrpcIterator.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016-2018 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Grakn is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Grakn. If not, see <http://www.gnu.org/licenses/gpl.txt>.
*/
package ai.grakn.grpc;
import ai.grakn.rpc.generated.GrpcGrakn;
import ai.grakn.rpc.generated.GrpcGrakn.Done;
import ai.grakn.util.CommonUtil;
import com.google.common.collect.AbstractIterator;
import static ai.grakn.rpc.generated.GrpcIterator.IteratorId;
import static ai.grakn.rpc.generated.GrpcIterator.Next;
/**
* A client-side iterator over gRPC messages. Will send {@link Next} messages until it receives a {@link Done} message.
*
* @author Felix Chapman
*/
abstract class GraknGrpcIterator<T> extends AbstractIterator<T> {
private final IteratorId iteratorId;
private GrpcClient grpcClient;
public GraknGrpcIterator(GrpcClient grpcClient, IteratorId iteratorId) {
this.iteratorId = iteratorId;
this.grpcClient = grpcClient;
}
@Override
protected final T computeNext() {
GrpcGrakn.TxResponse response = grpcClient.next(iteratorId);
switch (response.getResponseCase()) {
case DONE:
return endOfData();
case RESPONSE_NOT_SET:
throw CommonUtil.unreachableStatement("Unexpected " + response);
default:
return getNextFromResponse(response);
}
}
protected abstract T getNextFromResponse(GrpcGrakn.TxResponse response);
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/grpc/GrpcClient.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016-2018 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Grakn is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Grakn. If not, see <http://www.gnu.org/licenses/gpl.txt>.
*/
package ai.grakn.grpc;
import ai.grakn.concept.AttributeType;
import ai.grakn.concept.Concept;
import ai.grakn.concept.ConceptId;
import ai.grakn.concept.Label;
import ai.grakn.graql.Graql;
import ai.grakn.graql.Pattern;
import ai.grakn.graql.Query;
import ai.grakn.graql.Var;
import ai.grakn.graql.admin.Answer;
import ai.grakn.graql.internal.query.QueryAnswer;
import ai.grakn.grpc.GrpcUtil.ErrorType;
import ai.grakn.grpc.TxGrpcCommunicator.Response;
import ai.grakn.rpc.generated.GraknGrpc;
import ai.grakn.rpc.generated.GrpcGrakn;
import ai.grakn.rpc.generated.GrpcGrakn.TxRequest;
import ai.grakn.rpc.generated.GrpcGrakn.TxResponse;
import ai.grakn.rpc.generated.GrpcIterator.IteratorId;
import ai.grakn.util.CommonUtil;
import com.google.common.collect.ImmutableMap;
import io.grpc.Metadata;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import mjson.Json;
import javax.annotation.Nullable;
import java.util.Collections;
import java.util.Iterator;
import java.util.Optional;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
/**
* Communicates with a Grakn gRPC server, translating requests and responses to and from their gRPC representations.
*
* <p>
* This class is a light abstraction layer over gRPC - it understands how the sequence of calls should execute and
* how to translate gRPC objects into Java objects and back.
* </p>
*
* @author Felix Chapman
*/
public class GrpcClient implements AutoCloseable {
private final GrpcConceptConverter conceptConverter;
private final TxGrpcCommunicator communicator;
private GrpcClient(GrpcConceptConverter conceptConverter, TxGrpcCommunicator communicator) {
this.conceptConverter = conceptConverter;
this.communicator = communicator;
}
public static GrpcClient create(GrpcConceptConverter conceptConverter, GraknGrpc.GraknStub stub) {
TxGrpcCommunicator observer = TxGrpcCommunicator.create(stub);
return new GrpcClient(conceptConverter, observer);
}
public void open(TxRequest openRequest) {
communicator.send(openRequest);
responseOrThrow();
}
public Iterator<Object> execQuery(Query<?> query) {
communicator.send(GrpcUtil.execQueryRequest(query.toString(), query.inferring()));
TxResponse txResponse = responseOrThrow();
switch (txResponse.getResponseCase()) {
case QUERYRESULT:
return Collections.singleton(convert(txResponse.getQueryResult())).iterator();
case DONE:
return Collections.emptyIterator();
case ITERATORID:
IteratorId iteratorId = txResponse.getIteratorId();
return new GraknGrpcIterator<Object>(this, iteratorId) {
@Override
protected Object getNextFromResponse(TxResponse response) {
return convert(response.getQueryResult());
}
};
default:
throw CommonUtil.unreachableStatement("Unexpected " + txResponse);
}
}
public void commit() {
communicator.send(GrpcUtil.commitRequest());
responseOrThrow();
}
public TxResponse next(IteratorId iteratorId) {
communicator.send(GrpcUtil.nextRequest(iteratorId));
return responseOrThrow();
}
@Nullable
public <T> T runConceptMethod(ConceptId id, ConceptMethod<T> conceptMethod) {
communicator.send(GrpcUtil.runConceptMethodRequest(id, conceptMethod));
return conceptMethod.get(conceptConverter, this, responseOrThrow());
}
public Optional<Concept> getConcept(ConceptId id) {
communicator.send(GrpcUtil.getConceptRequest(id));
return conceptConverter.convert(responseOrThrow().getOptionalConcept());
}
public Optional<Concept> getSchemaConcept(Label label) {
communicator.send(GrpcUtil.getSchemaConceptRequest(label));
return conceptConverter.convert(responseOrThrow().getOptionalConcept());
}
public Stream<? extends Concept> getAttributesByValue(Object value) {
communicator.send(GrpcUtil.getAttributesByValueRequest(value));
IteratorId iteratorId = responseOrThrow().getIteratorId();
Iterable<Concept> iterable = () -> new GraknGrpcIterator<Concept>(this, iteratorId) {
@Override
protected Concept getNextFromResponse(TxResponse response) {
return conceptConverter.convert(response.getConcept());
}
};
return StreamSupport.stream(iterable.spliterator(), false);
}
public Concept putEntityType(Label label) {
communicator.send(GrpcUtil.putEntityTypeRequest(label));
return conceptConverter.convert(responseOrThrow().getConcept());
}
public Concept putRelationshipType(Label label) {
communicator.send(GrpcUtil.putRelationshipTypeRequest(label));
return conceptConverter.convert(responseOrThrow().getConcept());
}
public Concept putAttributeType(Label label, AttributeType.DataType<?> dataType) {
communicator.send(GrpcUtil.putAttributeTypeRequest(label, dataType));
return conceptConverter.convert(responseOrThrow().getConcept());
}
public Concept putRole(Label label) {
communicator.send(GrpcUtil.putRoleRequest(label));
return conceptConverter.convert(responseOrThrow().getConcept());
}
public Concept putRule(Label label, Pattern when, Pattern then) {
communicator.send(GrpcUtil.putRuleRequest(label, when, then));
return conceptConverter.convert(responseOrThrow().getConcept());
}
@Override
public void close() {
communicator.close();
}
public boolean isClosed(){
return communicator.isClosed();
}
private TxResponse responseOrThrow() {
Response response;
try {
response = communicator.receive();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
// This is called from classes like RemoteGraknTx, that impl methods which do not throw InterruptedException
// Therefore, we have to wrap it in a RuntimeException.
throw new RuntimeException(e);
}
switch (response.type()) {
case OK:
return response.ok();
case ERROR:
throw convertStatusRuntimeException(response.error());
case COMPLETED:
default:
throw CommonUtil.unreachableStatement("Unexpected response " + response);
}
}
private static RuntimeException convertStatusRuntimeException(StatusRuntimeException error) {
Status status = error.getStatus();
Metadata trailers = error.getTrailers();
ErrorType errorType = trailers.get(ErrorType.KEY);
if (errorType != null) {
String message = status.getDescription();
return errorType.toException(message);
} else {
return error;
}
}
private Object convert(GrpcGrakn.QueryResult queryResult) {
switch (queryResult.getQueryResultCase()) {
case ANSWER:
return convert(queryResult.getAnswer());
case OTHERRESULT:
return Json.read(queryResult.getOtherResult()).getValue();
default:
case QUERYRESULT_NOT_SET:
throw new IllegalArgumentException("Unexpected " + queryResult);
}
}
private Answer convert(GrpcGrakn.Answer answer) {
ImmutableMap.Builder<Var, Concept> map = ImmutableMap.builder();
answer.getAnswerMap().forEach((grpcVar, grpcConcept) -> {
map.put(Graql.var(grpcVar), conceptConverter.convert(grpcConcept));
});
return new QueryAnswer(map.build());
}
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/grpc/GrpcConceptConverter.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016-2018 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Grakn is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Grakn. If not, see <http://www.gnu.org/licenses/gpl.txt>.
*/
package ai.grakn.grpc;
import ai.grakn.concept.Concept;
import ai.grakn.rpc.generated.GrpcConcept;
import ai.grakn.rpc.generated.GrpcConcept.OptionalConcept;
import java.util.Optional;
/**
* @author Felix Chapman
*/
public interface GrpcConceptConverter {
Concept convert(GrpcConcept.Concept concept);
default Optional<Concept> convert(OptionalConcept concept) {
switch (concept.getValueCase()) {
case PRESENT:
return Optional.of(convert(concept.getPresent()));
case ABSENT:
return Optional.empty();
default:
case VALUE_NOT_SET:
throw new IllegalArgumentException("Unrecognised " + concept);
}
}
default RolePlayer convert(GrpcConcept.RolePlayer rolePlayer) {
return RolePlayer.create(convert(rolePlayer.getRole()).asRole(), convert(rolePlayer.getPlayer()).asThing());
}
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/grpc/GrpcIterators.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016-2018 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Grakn is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Grakn. If not, see <http://www.gnu.org/licenses/gpl.txt>.
*/
package ai.grakn.grpc;
import ai.grakn.rpc.generated.GrpcGrakn.Done;
import ai.grakn.rpc.generated.GrpcGrakn.TxResponse;
import ai.grakn.rpc.generated.GrpcIterator.IteratorId;
import java.util.Iterator;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Contains a mutable map of iterators of {@link TxResponse}s for gRPC. These iterators are used for returning
* lazy, streaming responses such as for Graql query results.
*
* @author Felix Chapman
*/
public class GrpcIterators {
private final AtomicInteger iteratorIdCounter = new AtomicInteger();
private final Map<IteratorId, Iterator<TxResponse>> iterators = new ConcurrentHashMap<>();
private GrpcIterators() {
}
public static GrpcIterators create() {
return new GrpcIterators();
}
/**
* Register a new iterator and return the ID of the iterator
*/
public IteratorId add(Iterator<TxResponse> iterator) {
IteratorId iteratorId = IteratorId.newBuilder().setId(iteratorIdCounter.getAndIncrement()).build();
iterators.put(iteratorId, iterator);
return iteratorId;
}
/**
* Return the next response from an iterator. Will return a {@link Done} response if the iterator is exhausted.
*/
public Optional<TxResponse> next(IteratorId iteratorId) {
return Optional.ofNullable(iterators.get(iteratorId)).map(iterator -> {
TxResponse response;
if (iterator.hasNext()) {
response = iterator.next();
} else {
response = GrpcUtil.doneResponse();
stop(iteratorId);
}
return response;
});
}
/**
* Stop an iterator
*/
public void stop(IteratorId iteratorId) {
iterators.remove(iteratorId);
}
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/grpc/GrpcOpenRequestExecutor.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016-2018 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Grakn is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Grakn. If not, see <http://www.gnu.org/licenses/gpl.txt>.
*/
package ai.grakn.grpc;
import ai.grakn.kb.internal.EmbeddedGraknTx;
import ai.grakn.rpc.generated.GrpcGrakn.Open;
/**
* Interface implemented by classes that handle gRPC Open requests
*
* @author marcoscoppetta
*/
public interface GrpcOpenRequestExecutor {
EmbeddedGraknTx<?> execute(Open open);
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/grpc/GrpcUtil.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016-2018 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Grakn is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Grakn. If not, see <http://www.gnu.org/licenses/gpl.txt>.
*/
package ai.grakn.grpc;
import ai.grakn.GraknTxType;
import ai.grakn.Keyspace;
import ai.grakn.concept.AttributeType;
import ai.grakn.concept.Concept;
import ai.grakn.concept.ConceptId;
import ai.grakn.concept.Label;
import ai.grakn.concept.Role;
import ai.grakn.concept.Thing;
import ai.grakn.exception.GraknBackendException;
import ai.grakn.exception.GraknException;
import ai.grakn.exception.GraknServerException;
import ai.grakn.exception.GraknTxOperationException;
import ai.grakn.exception.GraqlQueryException;
import ai.grakn.exception.GraqlSyntaxException;
import ai.grakn.exception.InvalidKBException;
import ai.grakn.exception.PropertyNotUniqueException;
import ai.grakn.exception.TemporaryWriteException;
import ai.grakn.graql.Graql;
import ai.grakn.graql.Pattern;
import ai.grakn.graql.Query;
import ai.grakn.rpc.generated.GrpcConcept;
import ai.grakn.rpc.generated.GrpcConcept.AttributeValue;
import ai.grakn.rpc.generated.GrpcConcept.Concepts;
import ai.grakn.rpc.generated.GrpcConcept.OptionalConcept;
import ai.grakn.rpc.generated.GrpcConcept.OptionalDataType;
import ai.grakn.rpc.generated.GrpcConcept.OptionalPattern;
import ai.grakn.rpc.generated.GrpcConcept.OptionalRegex;
import ai.grakn.rpc.generated.GrpcConcept.RolePlayers;
import ai.grakn.rpc.generated.GrpcGrakn;
import ai.grakn.rpc.generated.GrpcGrakn.Commit;
import ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest;
import ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse;
import ai.grakn.rpc.generated.GrpcGrakn.Done;
import ai.grakn.rpc.generated.GrpcGrakn.ExecQuery;
import ai.grakn.rpc.generated.GrpcGrakn.Infer;
import ai.grakn.rpc.generated.GrpcGrakn.Open;
import ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType;
import ai.grakn.rpc.generated.GrpcGrakn.PutRule;
import ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod;
import ai.grakn.rpc.generated.GrpcGrakn.TxRequest;
import ai.grakn.rpc.generated.GrpcGrakn.TxResponse;
import ai.grakn.rpc.generated.GrpcGrakn.TxType;
import ai.grakn.rpc.generated.GrpcIterator.IteratorId;
import ai.grakn.rpc.generated.GrpcIterator.Next;
import ai.grakn.rpc.generated.GrpcIterator.Stop;
import ai.grakn.util.CommonUtil;
import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.Multimaps;
import io.grpc.Metadata;
import io.grpc.Metadata.AsciiMarshaller;
import javax.annotation.Nullable;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Stream;
import static java.util.stream.Collectors.toList;
/**
* @author Felix Chapman
*/
public class GrpcUtil {
private static final GrpcConcept.Unit UNIT = GrpcConcept.Unit.getDefaultInstance();
static class UnknownGraknException extends GraknException {
private static final long serialVersionUID = 4354432748314041017L;
UnknownGraknException(String error) {
super(error);
}
public static UnknownGraknException create(String message) {
return new UnknownGraknException(message);
}
}
/**
* Enumeration of all sub-classes of {@link GraknException} that can be thrown during gRPC calls.
*/
public enum ErrorType {
// TODO: it's likely some of these will NEVER be thrown normally, so shouldn't be here
GRAQL_QUERY_EXCEPTION(GraqlQueryException::create),
GRAQL_SYNTAX_EXCEPTION(GraqlSyntaxException::create),
GRAKN_TX_OPERATION_EXCEPTION(GraknTxOperationException::create),
TEMPORARY_WRITE_EXCEPTION(TemporaryWriteException::create),
GRAKN_SERVER_EXCEPTION(GraknServerException::create),
PROPERTY_NOT_UNIQUE_EXCEPTION(PropertyNotUniqueException::create),
INVALID_KB_EXCEPTION(InvalidKBException::create),
GRAKN_BACKEND_EXCEPTION(GraknBackendException::create),
UNKNOWN(UnknownGraknException::create);
// Enums are meant to be serializable, but functions can't be serialized
private transient final Function<String, GraknException> converter;
ErrorType(Function<String, GraknException> converter) {
this.converter = converter;
}
public final GraknException toException(String message) {
return converter.apply(message);
}
private static final AsciiMarshaller<ErrorType> ERROR_TYPE_ASCII_MARSHALLER = new AsciiMarshaller<ErrorType>() {
@Override
public String toAsciiString(ErrorType value) {
return value.name();
}
@Override
public ErrorType parseAsciiString(String serialized) {
return ErrorType.valueOf(serialized);
}
};
public static final Metadata.Key<ErrorType> KEY = Metadata.Key.of("ErrorType", ERROR_TYPE_ASCII_MARSHALLER);
}
public static TxRequest openRequest(Keyspace keyspace, GraknTxType txType) {
Open.Builder open = Open.newBuilder().setKeyspace(convert(keyspace)).setTxType(convert(txType));
return TxRequest.newBuilder().setOpen(open).build();
}
public static TxRequest commitRequest() {
return TxRequest.newBuilder().setCommit(Commit.getDefaultInstance()).build();
}
public static TxRequest execQueryRequest(Query<?> query) {
return execQueryRequest(query.toString(), query.inferring());
}
public static TxRequest execQueryRequest(String queryString, @Nullable Boolean infer) {
GrpcGrakn.Query query = GrpcGrakn.Query.newBuilder().setValue(queryString).build();
ExecQuery.Builder execQueryRequest = ExecQuery.newBuilder().setQuery(query);
if (infer != null) {
execQueryRequest.setInfer(Infer.newBuilder().setValue(infer));
}
return TxRequest.newBuilder().setExecQuery(execQueryRequest).build();
}
public static TxRequest nextRequest(IteratorId iteratorId) {
return TxRequest.newBuilder().setNext(Next.newBuilder().setIteratorId(iteratorId).build()).build();
}
public static TxRequest stopRequest(IteratorId iteratorId) {
return TxRequest.newBuilder().setStop(Stop.newBuilder().setIteratorId(iteratorId).build()).build();
}
public static TxRequest runConceptMethodRequest(ConceptId id, ConceptMethod<?> conceptMethod) {
RunConceptMethod runConceptMethod = RunConceptMethod.newBuilder()
.setId(convert(id))
.setConceptMethod(conceptMethod.toGrpc())
.build();
return TxRequest.newBuilder().setRunConceptMethod(runConceptMethod).build();
}
public static TxRequest getConceptRequest(ConceptId id) {
return TxRequest.newBuilder().setGetConcept(convert(id)).build();
}
public static TxRequest getSchemaConceptRequest(Label label) {
return TxRequest.newBuilder().setGetSchemaConcept(convert(label)).build();
}
public static TxRequest getAttributesByValueRequest(Object value) {
return TxRequest.newBuilder().setGetAttributesByValue(convertValue(value)).build();
}
public static TxRequest putEntityTypeRequest(Label label) {
return TxRequest.newBuilder().setPutEntityType(convert(label)).build();
}
public static TxRequest putRelationshipTypeRequest(Label label) {
return TxRequest.newBuilder().setPutRelationshipType(convert(label)).build();
}
public static TxRequest putAttributeTypeRequest(Label label, AttributeType.DataType<?> dataType) {
PutAttributeType putAttributeType =
PutAttributeType.newBuilder().setLabel(convert(label)).setDataType(convert(dataType)).build();
return TxRequest.newBuilder().setPutAttributeType(putAttributeType).build();
}
public static TxRequest putRoleRequest(Label label) {
return TxRequest.newBuilder().setPutRole(convert(label)).build();
}
public static TxRequest putRuleRequest(Label label, Pattern when, Pattern then) {
PutRule putRule =
PutRule.newBuilder().setLabel(convert(label)).setWhen(convert(when)).setThen(convert(then)).build();
return TxRequest.newBuilder().setPutRule(putRule).build();
}
public static TxResponse doneResponse() {
return TxResponse.newBuilder().setDone(Done.getDefaultInstance()).build();
}
public static TxResponse iteratorResponse(IteratorId iteratorId) {
return TxResponse.newBuilder().setIteratorId(iteratorId).build();
}
public static TxResponse conceptResponse(Concept concept) {
return TxResponse.newBuilder().setConcept(convert(concept)).build();
}
public static TxResponse optionalConceptResponse(Optional<Concept> concept) {
return TxResponse.newBuilder().setOptionalConcept(convertOptionalConcept(concept)).build();
}
public static TxResponse rolePlayerResponse(RolePlayer rolePlayer) {
return TxResponse.newBuilder().setRolePlayer(convert(rolePlayer)).build();
}
public static DeleteRequest deleteRequest(Open open) {
return DeleteRequest.newBuilder().setOpen(open).build();
}
public static DeleteResponse deleteResponse() {
return DeleteResponse.getDefaultInstance();
}
public static Keyspace getKeyspace(Open open) {
return convert(open.getKeyspace());
}
public static GraknTxType getTxType(Open open) {
return convert(open.getTxType());
}
public static ConceptId getConceptId(RunConceptMethod runConceptMethodRequest) {
return convert(runConceptMethodRequest.getId());
}
public static GrpcConcept.Concept convert(Concept concept) {
return GrpcConcept.Concept.newBuilder()
.setId(GrpcConcept.ConceptId.newBuilder().setValue(concept.getId().getValue()).build())
.setBaseType(getBaseType(concept))
.build();
}
public static OptionalConcept convertOptionalConcept(Optional<Concept> concept) {
OptionalConcept.Builder builder = OptionalConcept.newBuilder();
return concept.map(GrpcUtil::convert).map(builder::setPresent).orElseGet(() -> builder.setAbsent(UNIT)).build();
}
public static Concepts convert(Stream<? extends Concept> concepts) {
Concepts.Builder grpcConcepts = Concepts.newBuilder();
grpcConcepts.addAllConcept(concepts.map(GrpcUtil::convert).collect(toList()));
return grpcConcepts.build();
}
public static Stream<? extends Concept> convert(GrpcConceptConverter conceptConverter, Concepts concepts) {
return concepts.getConceptList().stream().map(conceptConverter::convert);
}
public static GraknTxType convert(TxType txType) {
switch (txType) {
case Read:
return GraknTxType.READ;
case Write:
return GraknTxType.WRITE;
case Batch:
return GraknTxType.BATCH;
default:
case UNRECOGNIZED:
throw new IllegalArgumentException("Unrecognised " + txType);
}
}
private static TxType convert(GraknTxType txType) {
switch (txType) {
case READ:
return TxType.Read;
case WRITE:
return TxType.Write;
case BATCH:
return TxType.Batch;
default:
throw CommonUtil.unreachableStatement("Unrecognised " + txType);
}
}
private static Keyspace convert(GrpcGrakn.Keyspace keyspace) {
return Keyspace.of(keyspace.getValue());
}
public static GrpcGrakn.Keyspace convert(Keyspace keyspace) {
return GrpcGrakn.Keyspace.newBuilder().setValue(keyspace.getValue()).build();
}
private static GrpcConcept.ConceptId convert(ConceptId id) {
return GrpcConcept.ConceptId.newBuilder().setValue(id.getValue()).build();
}
public static ConceptId convert(GrpcConcept.ConceptId id) {
return ConceptId.of(id.getValue());
}
static GrpcConcept.Label convert(Label label) {
return GrpcConcept.Label.newBuilder().setValue(label.getValue()).build();
}
public static Label convert(GrpcConcept.Label label) {
return Label.of(label.getValue());
}
public static Object convert(AttributeValue value) {
switch (value.getValueCase()) {
case STRING:
return value.getString();
case BOOLEAN:
return value.getBoolean();
case INTEGER:
return value.getInteger();
case LONG:
return value.getLong();
case FLOAT:
return value.getFloat();
case DOUBLE:
return value.getDouble();
case DATE:
return value.getDate();
default:
case VALUE_NOT_SET:
throw new IllegalArgumentException("Unrecognised " + value);
}
}
static AttributeValue convertValue(Object value) {
AttributeValue.Builder builder = AttributeValue.newBuilder();
if (value instanceof String) {
builder.setString((String) value);
} else if (value instanceof Boolean) {
builder.setBoolean((boolean) value);
} else if (value instanceof Integer) {
builder.setInteger((int) value);
} else if (value instanceof Long) {
builder.setLong((long) value);
} else if (value instanceof Float) {
builder.setFloat((float) value);
} else if (value instanceof Double) {
builder.setDouble((double) value);
} else if (value instanceof LocalDateTime) {
builder.setDate(((LocalDateTime) value).atZone(ZoneId.of("Z")).toInstant().toEpochMilli());
} else {
throw CommonUtil.unreachableStatement("Unrecognised " + value);
}
return builder.build();
}
public static AttributeType.DataType<?> convert(GrpcConcept.DataType dataType) {
switch (dataType) {
case String:
return AttributeType.DataType.STRING;
case Boolean:
return AttributeType.DataType.BOOLEAN;
case Integer:
return AttributeType.DataType.INTEGER;
case Long:
return AttributeType.DataType.LONG;
case Float:
return AttributeType.DataType.FLOAT;
case Double:
return AttributeType.DataType.DOUBLE;
case Date:
return AttributeType.DataType.DATE;
default:
case UNRECOGNIZED:
throw new IllegalArgumentException("Unrecognised " + dataType);
}
}
public static GrpcConcept.DataType convert(AttributeType.DataType<?> dataType) {
if (dataType.equals(AttributeType.DataType.STRING)) {
return GrpcConcept.DataType.String;
} else if (dataType.equals(AttributeType.DataType.BOOLEAN)) {
return GrpcConcept.DataType.Boolean;
} else if (dataType.equals(AttributeType.DataType.INTEGER)) {
return GrpcConcept.DataType.Integer;
} else if (dataType.equals(AttributeType.DataType.LONG)) {
return GrpcConcept.DataType.Long;
} else if (dataType.equals(AttributeType.DataType.FLOAT)) {
return GrpcConcept.DataType.Float;
} else if (dataType.equals(AttributeType.DataType.DOUBLE)) {
return GrpcConcept.DataType.Double;
} else if (dataType.equals(AttributeType.DataType.DATE)) {
return GrpcConcept.DataType.Date;
} else {
throw CommonUtil.unreachableStatement("Unrecognised " + dataType);
}
}
public static OptionalDataType convertOptionalDataType(Optional<AttributeType.DataType<?>> dataType) {
OptionalDataType.Builder builder = OptionalDataType.newBuilder();
return dataType.map(GrpcUtil::convert).map(builder::setPresent).orElseGet(() -> builder.setAbsent(UNIT)).build();
}
public static Optional<AttributeType.DataType<?>> convert(OptionalDataType dataType) {
switch (dataType.getValueCase()) {
case PRESENT:
return Optional.of(convert(dataType.getPresent()));
case ABSENT:
case VALUE_NOT_SET:
default:
return Optional.empty();
}
}
public static GrpcConcept.BaseType getBaseType(Concept concept) {
if (concept.isEntityType()) {
return GrpcConcept.BaseType.EntityType;
} else if (concept.isRelationshipType()) {
return GrpcConcept.BaseType.RelationshipType;
} else if (concept.isAttributeType()) {
return GrpcConcept.BaseType.AttributeType;
} else if (concept.isEntity()) {
return GrpcConcept.BaseType.Entity;
} else if (concept.isRelationship()) {
return GrpcConcept.BaseType.Relationship;
} else if (concept.isAttribute()) {
return GrpcConcept.BaseType.Attribute;
} else if (concept.isRole()) {
return GrpcConcept.BaseType.Role;
} else if (concept.isRule()) {
return GrpcConcept.BaseType.Rule;
} else if (concept.isType()) {
return GrpcConcept.BaseType.MetaType;
} else {
throw CommonUtil.unreachableStatement("Unrecognised concept " + concept);
}
}
public static GrpcConcept.Pattern convert(Pattern pattern) {
return GrpcConcept.Pattern.newBuilder().setValue(pattern.toString()).build();
}
public static Pattern convert(GrpcConcept.Pattern pattern ) {
return Graql.parser().parsePattern(pattern.getValue());
}
public static OptionalPattern convert(Optional<Pattern> pattern) {
OptionalPattern.Builder builder = OptionalPattern.newBuilder();
return pattern.map(GrpcUtil::convert).map(builder::setPresent).orElseGet(() -> builder.setAbsent(UNIT)).build();
}
@Nullable
public static Optional<Pattern> convert(OptionalPattern pattern) {
switch (pattern.getValueCase()) {
case PRESENT:
return Optional.of(convert(pattern.getPresent()));
case ABSENT:
return Optional.empty();
case VALUE_NOT_SET:
default:
throw CommonUtil.unreachableStatement("Unrecognised " + pattern);
}
}
public static Map<Role, Set<Thing>> convert(GrpcConceptConverter converter, RolePlayers allRolePlayers) {
ImmutableSetMultimap.Builder<Role, Thing> map = ImmutableSetMultimap.builder();
for (GrpcConcept.RolePlayer rolePlayer : allRolePlayers.getRolePlayerList()) {
Role role = converter.convert(rolePlayer.getRole()).asRole();
Thing player = converter.convert(rolePlayer.getPlayer()).asThing();
map.put(role, player);
}
return Multimaps.asMap(map.build());
}
public static RolePlayers convert(Map<Role, Set<Thing>> rolePlayers) {
RolePlayers.Builder builder = RolePlayers.newBuilder();
rolePlayers.forEach((role, players) -> {
players.forEach(player -> {
builder.addRolePlayer(convert(RolePlayer.create(role, player)));
});
});
return builder.build();
}
public static GrpcConcept.RolePlayer convert(RolePlayer rolePlayer) {
return GrpcConcept.RolePlayer.newBuilder()
.setRole(convert(rolePlayer.role()))
.setPlayer(convert(rolePlayer.player()))
.build();
}
public static OptionalRegex convertRegex(Optional<String> regex) {
OptionalRegex.Builder builder = OptionalRegex.newBuilder();
return regex.map(builder::setPresent).orElseGet(() -> builder.setAbsent(UNIT)).build();
}
public static Optional<String> convert(OptionalRegex regex) {
switch (regex.getValueCase()) {
case PRESENT:
return Optional.of(regex.getPresent());
case ABSENT:
case VALUE_NOT_SET:
default:
return Optional.empty();
}
}
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/grpc/RolePlayer.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016-2018 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Grakn is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Grakn. If not, see <http://www.gnu.org/licenses/gpl.txt>.
*/
package ai.grakn.grpc;
import ai.grakn.concept.Role;
import ai.grakn.concept.Thing;
import com.google.auto.value.AutoValue;
/**
* @author Felix Chapman
*/
@AutoValue
public abstract class RolePlayer {
public abstract Role role();
public abstract Thing player();
public static RolePlayer create(Role role, Thing player) {
return new AutoValue_RolePlayer(role, player);
}
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/grpc/TxGrpcCommunicator.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016-2018 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Grakn is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Grakn. If not, see <http://www.gnu.org/licenses/gpl.txt>.
*/
package ai.grakn.grpc;
import ai.grakn.exception.GraknTxOperationException;
import ai.grakn.rpc.generated.GraknGrpc;
import ai.grakn.rpc.generated.GrpcGrakn.TxRequest;
import ai.grakn.rpc.generated.GrpcGrakn.TxResponse;
import com.google.auto.value.AutoValue;
import com.google.common.base.Preconditions;
import io.grpc.StatusRuntimeException;
import io.grpc.stub.StreamObserver;
import javax.annotation.Nullable;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Wrapper for making Tx calls to a gRPC server - handles sending a stream of {@link TxRequest}s and receiving a
* stream of {@link TxResponse}s.
*
* A request is sent with the {@link #send(TxRequest)}} method, and you can block for a response with the
* {@link #receive()} method.
*
* <pre>
* {@code
*
* try (TxGrpcCommunicator tx = TxGrpcCommunicator.create(stub) {
* tx.send(openMessage);
* TxResponse doneMessage = tx.receive().ok();
* tx.send(commitMessage);
* StatusRuntimeException validationError = tx.receive.error();
* }
* }
* </pre>
*
* @author Felix Chapman
*/
public class TxGrpcCommunicator implements AutoCloseable {
private final StreamObserver<TxRequest> requests;
private final QueueingObserver responses;
private TxGrpcCommunicator(StreamObserver<TxRequest> requests, QueueingObserver responses) {
this.requests = requests;
this.responses = responses;
}
public static TxGrpcCommunicator create(GraknGrpc.GraknStub stub) {
QueueingObserver responseListener = new QueueingObserver();
StreamObserver<TxRequest> requestSender = stub.tx(responseListener);
return new TxGrpcCommunicator(requestSender, responseListener);
}
/**
* Send a request and return immediately.
*
* This method is non-blocking - it returns immediately.
*/
public void send(TxRequest request) {
if (responses.terminated.get()) {
throw GraknTxOperationException.transactionClosed(null, "The gRPC connection closed");
}
requests.onNext(request);
}
/**
* Block until a response is returned.
*/
public Response receive() throws InterruptedException {
Response response = responses.poll();
if (response.type() != Response.Type.OK) {
close();
}
return response;
}
@Override
public void close() {
try{
requests.onCompleted();
} catch (IllegalStateException e) {
//IGNORED
//This is needed to handle the fact that:
//1. Commits can lead to transaction closures and
//2. Error can lead to connection closures but the transaction may stay open
//When this occurs a "half-closed" state is thrown which we can safely ignore
}
responses.close();
}
public boolean isClosed(){
return responses.terminated.get();
}
/**
* A {@link StreamObserver} that stores all responses in a blocking queue.
*
* A response can be polled with the {@link #poll()} method.
*/
private static class QueueingObserver implements StreamObserver<TxResponse>, AutoCloseable {
private final BlockingQueue<Response> queue = new LinkedBlockingDeque<>();
private final AtomicBoolean terminated = new AtomicBoolean(false);
@Override
public void onNext(TxResponse value) {
queue.add(Response.ok(value));
}
@Override
public void onError(Throwable throwable) {
terminated.set(true);
assert throwable instanceof StatusRuntimeException : "The server only yields these exceptions";
queue.add(Response.error((StatusRuntimeException) throwable));
}
@Override
public void onCompleted() {
terminated.set(true);
queue.add(Response.completed());
}
Response poll() throws InterruptedException {
// First check for a response without blocking
Response response = queue.poll();
if (response != null) {
return response;
}
// Only after checking for existing messages, we check if the connection was already terminated, so we don't
// block for a response forever
if (terminated.get()) {
throw GraknTxOperationException.transactionClosed(null, "The gRPC connection closed");
}
// Block for a response (because we are confident there are no responses and the connection has not closed)
return queue.take();
}
@Override
public void close() {
while (!terminated.get()) {
try {
poll();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
}
/**
* A response from the gRPC server, that may be a successful response {@link #ok(TxResponse), an error
* {@link #error(StatusRuntimeException)}} or a "completed" message {@link #completed()}.
*/
@AutoValue
public abstract static class Response {
abstract @Nullable TxResponse nullableOk();
abstract @Nullable StatusRuntimeException nullableError();
public final Type type() {
if (nullableOk() != null) {
return Type.OK;
} else if (nullableError() != null) {
return Type.ERROR;
} else {
return Type.COMPLETED;
}
}
/**
* Enum indicating the type of {@link Response}.
*/
public enum Type {
OK, ERROR, COMPLETED;
}
/**
* If this is a successful response, retrieve it.
*
* @throws IllegalStateException if this is not a successful response
*/
public final TxResponse ok() {
TxResponse response = nullableOk();
if (response == null) {
throw new IllegalStateException("Expected successful response not found: " + toString());
} else {
return response;
}
}
/**
* If this is an error, retrieve it.
*
* @throws IllegalStateException if this is not an error
*/
public final StatusRuntimeException error() {
StatusRuntimeException throwable = nullableError();
if (throwable == null) {
throw new IllegalStateException("Expected error not found: " + toString());
} else {
return throwable;
}
}
private static Response create(@Nullable TxResponse response, @Nullable StatusRuntimeException error) {
Preconditions.checkArgument(response == null || error == null);
return new AutoValue_TxGrpcCommunicator_Response(response, error);
}
static Response completed() {
return create(null, null);
}
static Response error(StatusRuntimeException error) {
return create(null, error);
}
static Response ok(TxResponse response) {
return create(response, null);
}
}
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/rpc
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/rpc/generated/GraknGrpc.java
|
package ai.grakn.rpc.generated;
import static io.grpc.stub.ClientCalls.asyncUnaryCall;
import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ClientCalls.blockingUnaryCall;
import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
import static io.grpc.stub.ClientCalls.futureUnaryCall;
import static io.grpc.MethodDescriptor.generateFullMethodName;
import static io.grpc.stub.ServerCalls.asyncUnaryCall;
import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
/**
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 1.2.0)",
comments = "Source: grakn.proto")
public final class GraknGrpc {
private GraknGrpc() {}
public static final String SERVICE_NAME = "ai.grakn.rpc.generated.Grakn";
// Static method descriptors that strictly reflect the proto.
@io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
public static final io.grpc.MethodDescriptor<ai.grakn.rpc.generated.GrpcGrakn.TxRequest,
ai.grakn.rpc.generated.GrpcGrakn.TxResponse> METHOD_TX =
io.grpc.MethodDescriptor.create(
io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
generateFullMethodName(
"ai.grakn.rpc.generated.Grakn", "Tx"),
io.grpc.protobuf.ProtoUtils.marshaller(ai.grakn.rpc.generated.GrpcGrakn.TxRequest.getDefaultInstance()),
io.grpc.protobuf.ProtoUtils.marshaller(ai.grakn.rpc.generated.GrpcGrakn.TxResponse.getDefaultInstance()));
@io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
public static final io.grpc.MethodDescriptor<ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest,
ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse> METHOD_DELETE =
io.grpc.MethodDescriptor.create(
io.grpc.MethodDescriptor.MethodType.UNARY,
generateFullMethodName(
"ai.grakn.rpc.generated.Grakn", "Delete"),
io.grpc.protobuf.ProtoUtils.marshaller(ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest.getDefaultInstance()),
io.grpc.protobuf.ProtoUtils.marshaller(ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse.getDefaultInstance()));
/**
* Creates a new async stub that supports all call types for the service
*/
public static GraknStub newStub(io.grpc.Channel channel) {
return new GraknStub(channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static GraknBlockingStub newBlockingStub(
io.grpc.Channel channel) {
return new GraknBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
*/
public static GraknFutureStub newFutureStub(
io.grpc.Channel channel) {
return new GraknFutureStub(channel);
}
/**
*/
public static abstract class GraknImplBase implements io.grpc.BindableService {
/**
* <pre>
*Represents a full transaction. The stream of `TxRequest`s must begin with a `Open` message.
*When the call is completed, the transaction will always be closed, with or without a `Commit` message.
* </pre>
*/
public io.grpc.stub.StreamObserver<ai.grakn.rpc.generated.GrpcGrakn.TxRequest> tx(
io.grpc.stub.StreamObserver<ai.grakn.rpc.generated.GrpcGrakn.TxResponse> responseObserver) {
return asyncUnimplementedStreamingCall(METHOD_TX, responseObserver);
}
/**
* <pre>
*Delete a keyspace.
* </pre>
*/
public void delete(ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest request,
io.grpc.stub.StreamObserver<ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse> responseObserver) {
asyncUnimplementedUnaryCall(METHOD_DELETE, responseObserver);
}
@java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
.addMethod(
METHOD_TX,
asyncBidiStreamingCall(
new MethodHandlers<
ai.grakn.rpc.generated.GrpcGrakn.TxRequest,
ai.grakn.rpc.generated.GrpcGrakn.TxResponse>(
this, METHODID_TX)))
.addMethod(
METHOD_DELETE,
asyncUnaryCall(
new MethodHandlers<
ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest,
ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse>(
this, METHODID_DELETE)))
.build();
}
}
/**
*/
public static final class GraknStub extends io.grpc.stub.AbstractStub<GraknStub> {
private GraknStub(io.grpc.Channel channel) {
super(channel);
}
private GraknStub(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected GraknStub build(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
return new GraknStub(channel, callOptions);
}
/**
* <pre>
*Represents a full transaction. The stream of `TxRequest`s must begin with a `Open` message.
*When the call is completed, the transaction will always be closed, with or without a `Commit` message.
* </pre>
*/
public io.grpc.stub.StreamObserver<ai.grakn.rpc.generated.GrpcGrakn.TxRequest> tx(
io.grpc.stub.StreamObserver<ai.grakn.rpc.generated.GrpcGrakn.TxResponse> responseObserver) {
return asyncBidiStreamingCall(
getChannel().newCall(METHOD_TX, getCallOptions()), responseObserver);
}
/**
* <pre>
*Delete a keyspace.
* </pre>
*/
public void delete(ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest request,
io.grpc.stub.StreamObserver<ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse> responseObserver) {
asyncUnaryCall(
getChannel().newCall(METHOD_DELETE, getCallOptions()), request, responseObserver);
}
}
/**
*/
public static final class GraknBlockingStub extends io.grpc.stub.AbstractStub<GraknBlockingStub> {
private GraknBlockingStub(io.grpc.Channel channel) {
super(channel);
}
private GraknBlockingStub(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected GraknBlockingStub build(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
return new GraknBlockingStub(channel, callOptions);
}
/**
* <pre>
*Delete a keyspace.
* </pre>
*/
public ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse delete(ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest request) {
return blockingUnaryCall(
getChannel(), METHOD_DELETE, getCallOptions(), request);
}
}
/**
*/
public static final class GraknFutureStub extends io.grpc.stub.AbstractStub<GraknFutureStub> {
private GraknFutureStub(io.grpc.Channel channel) {
super(channel);
}
private GraknFutureStub(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected GraknFutureStub build(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
return new GraknFutureStub(channel, callOptions);
}
/**
* <pre>
*Delete a keyspace.
* </pre>
*/
public com.google.common.util.concurrent.ListenableFuture<ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse> delete(
ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest request) {
return futureUnaryCall(
getChannel().newCall(METHOD_DELETE, getCallOptions()), request);
}
}
private static final int METHODID_DELETE = 0;
private static final int METHODID_TX = 1;
private static final class MethodHandlers<Req, Resp> implements
io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
private final GraknImplBase serviceImpl;
private final int methodId;
MethodHandlers(GraknImplBase serviceImpl, int methodId) {
this.serviceImpl = serviceImpl;
this.methodId = methodId;
}
@java.lang.Override
@java.lang.SuppressWarnings("unchecked")
public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
switch (methodId) {
case METHODID_DELETE:
serviceImpl.delete((ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest) request,
(io.grpc.stub.StreamObserver<ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse>) responseObserver);
break;
default:
throw new AssertionError();
}
}
@java.lang.Override
@java.lang.SuppressWarnings("unchecked")
public io.grpc.stub.StreamObserver<Req> invoke(
io.grpc.stub.StreamObserver<Resp> responseObserver) {
switch (methodId) {
case METHODID_TX:
return (io.grpc.stub.StreamObserver<Req>) serviceImpl.tx(
(io.grpc.stub.StreamObserver<ai.grakn.rpc.generated.GrpcGrakn.TxResponse>) responseObserver);
default:
throw new AssertionError();
}
}
}
private static final class GraknDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
@java.lang.Override
public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.getDescriptor();
}
}
private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
public static io.grpc.ServiceDescriptor getServiceDescriptor() {
io.grpc.ServiceDescriptor result = serviceDescriptor;
if (result == null) {
synchronized (GraknGrpc.class) {
result = serviceDescriptor;
if (result == null) {
serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
.setSchemaDescriptor(new GraknDescriptorSupplier())
.addMethod(METHOD_TX)
.addMethod(METHOD_DELETE)
.build();
}
}
}
return result;
}
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/rpc
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/rpc/generated/GrpcConcept.java
|
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: concept.proto
package ai.grakn.rpc.generated;
public final class GrpcConcept {
private GrpcConcept() {}
public static void registerAllExtensions(
com.google.protobuf.ExtensionRegistryLite registry) {
}
public static void registerAllExtensions(
com.google.protobuf.ExtensionRegistry registry) {
registerAllExtensions(
(com.google.protobuf.ExtensionRegistryLite) registry);
}
/**
* Protobuf enum {@code ai.grakn.rpc.generated.BaseType}
*/
public enum BaseType
implements com.google.protobuf.ProtocolMessageEnum {
/**
* <code>Entity = 0;</code>
*/
Entity(0),
/**
* <code>Relationship = 1;</code>
*/
Relationship(1),
/**
* <code>Attribute = 2;</code>
*/
Attribute(2),
/**
* <code>EntityType = 3;</code>
*/
EntityType(3),
/**
* <code>RelationshipType = 4;</code>
*/
RelationshipType(4),
/**
* <code>AttributeType = 5;</code>
*/
AttributeType(5),
/**
* <code>Role = 6;</code>
*/
Role(6),
/**
* <code>Rule = 7;</code>
*/
Rule(7),
/**
* <pre>
* This represents the top-level meta type only
* </pre>
*
* <code>MetaType = 8;</code>
*/
MetaType(8),
UNRECOGNIZED(-1),
;
/**
* <code>Entity = 0;</code>
*/
public static final int Entity_VALUE = 0;
/**
* <code>Relationship = 1;</code>
*/
public static final int Relationship_VALUE = 1;
/**
* <code>Attribute = 2;</code>
*/
public static final int Attribute_VALUE = 2;
/**
* <code>EntityType = 3;</code>
*/
public static final int EntityType_VALUE = 3;
/**
* <code>RelationshipType = 4;</code>
*/
public static final int RelationshipType_VALUE = 4;
/**
* <code>AttributeType = 5;</code>
*/
public static final int AttributeType_VALUE = 5;
/**
* <code>Role = 6;</code>
*/
public static final int Role_VALUE = 6;
/**
* <code>Rule = 7;</code>
*/
public static final int Rule_VALUE = 7;
/**
* <pre>
* This represents the top-level meta type only
* </pre>
*
* <code>MetaType = 8;</code>
*/
public static final int MetaType_VALUE = 8;
public final int getNumber() {
if (this == UNRECOGNIZED) {
throw new java.lang.IllegalArgumentException(
"Can't get the number of an unknown enum value.");
}
return value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static BaseType valueOf(int value) {
return forNumber(value);
}
public static BaseType forNumber(int value) {
switch (value) {
case 0: return Entity;
case 1: return Relationship;
case 2: return Attribute;
case 3: return EntityType;
case 4: return RelationshipType;
case 5: return AttributeType;
case 6: return Role;
case 7: return Rule;
case 8: return MetaType;
default: return null;
}
}
public static com.google.protobuf.Internal.EnumLiteMap<BaseType>
internalGetValueMap() {
return internalValueMap;
}
private static final com.google.protobuf.Internal.EnumLiteMap<
BaseType> internalValueMap =
new com.google.protobuf.Internal.EnumLiteMap<BaseType>() {
public BaseType findValueByNumber(int number) {
return BaseType.forNumber(number);
}
};
public final com.google.protobuf.Descriptors.EnumValueDescriptor
getValueDescriptor() {
return getDescriptor().getValues().get(ordinal());
}
public final com.google.protobuf.Descriptors.EnumDescriptor
getDescriptorForType() {
return getDescriptor();
}
public static final com.google.protobuf.Descriptors.EnumDescriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.getDescriptor().getEnumTypes().get(0);
}
private static final BaseType[] VALUES = values();
public static BaseType valueOf(
com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
if (desc.getType() != getDescriptor()) {
throw new java.lang.IllegalArgumentException(
"EnumValueDescriptor is not for this type.");
}
if (desc.getIndex() == -1) {
return UNRECOGNIZED;
}
return VALUES[desc.getIndex()];
}
private final int value;
private BaseType(int value) {
this.value = value;
}
// @@protoc_insertion_point(enum_scope:ai.grakn.rpc.generated.BaseType)
}
/**
* Protobuf enum {@code ai.grakn.rpc.generated.DataType}
*/
public enum DataType
implements com.google.protobuf.ProtocolMessageEnum {
/**
* <code>String = 0;</code>
*/
String(0),
/**
* <code>Boolean = 1;</code>
*/
Boolean(1),
/**
* <code>Integer = 2;</code>
*/
Integer(2),
/**
* <code>Long = 3;</code>
*/
Long(3),
/**
* <code>Float = 4;</code>
*/
Float(4),
/**
* <code>Double = 5;</code>
*/
Double(5),
/**
* <code>Date = 6;</code>
*/
Date(6),
UNRECOGNIZED(-1),
;
/**
* <code>String = 0;</code>
*/
public static final int String_VALUE = 0;
/**
* <code>Boolean = 1;</code>
*/
public static final int Boolean_VALUE = 1;
/**
* <code>Integer = 2;</code>
*/
public static final int Integer_VALUE = 2;
/**
* <code>Long = 3;</code>
*/
public static final int Long_VALUE = 3;
/**
* <code>Float = 4;</code>
*/
public static final int Float_VALUE = 4;
/**
* <code>Double = 5;</code>
*/
public static final int Double_VALUE = 5;
/**
* <code>Date = 6;</code>
*/
public static final int Date_VALUE = 6;
public final int getNumber() {
if (this == UNRECOGNIZED) {
throw new java.lang.IllegalArgumentException(
"Can't get the number of an unknown enum value.");
}
return value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static DataType valueOf(int value) {
return forNumber(value);
}
public static DataType forNumber(int value) {
switch (value) {
case 0: return String;
case 1: return Boolean;
case 2: return Integer;
case 3: return Long;
case 4: return Float;
case 5: return Double;
case 6: return Date;
default: return null;
}
}
public static com.google.protobuf.Internal.EnumLiteMap<DataType>
internalGetValueMap() {
return internalValueMap;
}
private static final com.google.protobuf.Internal.EnumLiteMap<
DataType> internalValueMap =
new com.google.protobuf.Internal.EnumLiteMap<DataType>() {
public DataType findValueByNumber(int number) {
return DataType.forNumber(number);
}
};
public final com.google.protobuf.Descriptors.EnumValueDescriptor
getValueDescriptor() {
return getDescriptor().getValues().get(ordinal());
}
public final com.google.protobuf.Descriptors.EnumDescriptor
getDescriptorForType() {
return getDescriptor();
}
public static final com.google.protobuf.Descriptors.EnumDescriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.getDescriptor().getEnumTypes().get(1);
}
private static final DataType[] VALUES = values();
public static DataType valueOf(
com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
if (desc.getType() != getDescriptor()) {
throw new java.lang.IllegalArgumentException(
"EnumValueDescriptor is not for this type.");
}
if (desc.getIndex() == -1) {
return UNRECOGNIZED;
}
return VALUES[desc.getIndex()];
}
private final int value;
private DataType(int value) {
this.value = value;
}
// @@protoc_insertion_point(enum_scope:ai.grakn.rpc.generated.DataType)
}
public interface ConceptOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Concept)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
boolean hasId();
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptId getId();
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder getIdOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.BaseType baseType = 2;</code>
*/
int getBaseTypeValue();
/**
* <code>optional .ai.grakn.rpc.generated.BaseType baseType = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.BaseType getBaseType();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.Concept}
*/
public static final class Concept extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Concept)
ConceptOrBuilder {
// Use Concept.newBuilder() to construct.
private Concept(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Concept() {
baseType_ = 0;
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Concept(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder subBuilder = null;
if (id_ != null) {
subBuilder = id_.toBuilder();
}
id_ = input.readMessage(ai.grakn.rpc.generated.GrpcConcept.ConceptId.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(id_);
id_ = subBuilder.buildPartial();
}
break;
}
case 16: {
int rawValue = input.readEnum();
baseType_ = rawValue;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Concept_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Concept_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.Concept.class, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder.class);
}
public static final int ID_FIELD_NUMBER = 1;
private ai.grakn.rpc.generated.GrpcConcept.ConceptId id_;
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public boolean hasId() {
return id_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptId getId() {
return id_ == null ? ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance() : id_;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder getIdOrBuilder() {
return getId();
}
public static final int BASETYPE_FIELD_NUMBER = 2;
private int baseType_;
/**
* <code>optional .ai.grakn.rpc.generated.BaseType baseType = 2;</code>
*/
public int getBaseTypeValue() {
return baseType_;
}
/**
* <code>optional .ai.grakn.rpc.generated.BaseType baseType = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.BaseType getBaseType() {
ai.grakn.rpc.generated.GrpcConcept.BaseType result = ai.grakn.rpc.generated.GrpcConcept.BaseType.valueOf(baseType_);
return result == null ? ai.grakn.rpc.generated.GrpcConcept.BaseType.UNRECOGNIZED : result;
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (id_ != null) {
output.writeMessage(1, getId());
}
if (baseType_ != ai.grakn.rpc.generated.GrpcConcept.BaseType.Entity.getNumber()) {
output.writeEnum(2, baseType_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (id_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, getId());
}
if (baseType_ != ai.grakn.rpc.generated.GrpcConcept.BaseType.Entity.getNumber()) {
size += com.google.protobuf.CodedOutputStream
.computeEnumSize(2, baseType_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.Concept)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.Concept other = (ai.grakn.rpc.generated.GrpcConcept.Concept) obj;
boolean result = true;
result = result && (hasId() == other.hasId());
if (hasId()) {
result = result && getId()
.equals(other.getId());
}
result = result && baseType_ == other.baseType_;
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
if (hasId()) {
hash = (37 * hash) + ID_FIELD_NUMBER;
hash = (53 * hash) + getId().hashCode();
}
hash = (37 * hash) + BASETYPE_FIELD_NUMBER;
hash = (53 * hash) + baseType_;
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.Concept parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concept parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concept parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concept parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concept parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concept parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concept parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concept parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concept parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concept parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.Concept prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.Concept}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Concept)
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Concept_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Concept_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.Concept.class, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
if (idBuilder_ == null) {
id_ = null;
} else {
id_ = null;
idBuilder_ = null;
}
baseType_ = 0;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Concept_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.Concept getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.Concept build() {
ai.grakn.rpc.generated.GrpcConcept.Concept result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.Concept buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.Concept result = new ai.grakn.rpc.generated.GrpcConcept.Concept(this);
if (idBuilder_ == null) {
result.id_ = id_;
} else {
result.id_ = idBuilder_.build();
}
result.baseType_ = baseType_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.Concept) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.Concept other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) return this;
if (other.hasId()) {
mergeId(other.getId());
}
if (other.baseType_ != 0) {
setBaseTypeValue(other.getBaseTypeValue());
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.Concept parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.Concept) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private ai.grakn.rpc.generated.GrpcConcept.ConceptId id_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptId, ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder> idBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public boolean hasId() {
return idBuilder_ != null || id_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptId getId() {
if (idBuilder_ == null) {
return id_ == null ? ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance() : id_;
} else {
return idBuilder_.getMessage();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public Builder setId(ai.grakn.rpc.generated.GrpcConcept.ConceptId value) {
if (idBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
id_ = value;
onChanged();
} else {
idBuilder_.setMessage(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public Builder setId(
ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder builderForValue) {
if (idBuilder_ == null) {
id_ = builderForValue.build();
onChanged();
} else {
idBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public Builder mergeId(ai.grakn.rpc.generated.GrpcConcept.ConceptId value) {
if (idBuilder_ == null) {
if (id_ != null) {
id_ =
ai.grakn.rpc.generated.GrpcConcept.ConceptId.newBuilder(id_).mergeFrom(value).buildPartial();
} else {
id_ = value;
}
onChanged();
} else {
idBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public Builder clearId() {
if (idBuilder_ == null) {
id_ = null;
onChanged();
} else {
id_ = null;
idBuilder_ = null;
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder getIdBuilder() {
onChanged();
return getIdFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder getIdOrBuilder() {
if (idBuilder_ != null) {
return idBuilder_.getMessageOrBuilder();
} else {
return id_ == null ?
ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance() : id_;
}
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptId, ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder>
getIdFieldBuilder() {
if (idBuilder_ == null) {
idBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptId, ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder>(
getId(),
getParentForChildren(),
isClean());
id_ = null;
}
return idBuilder_;
}
private int baseType_ = 0;
/**
* <code>optional .ai.grakn.rpc.generated.BaseType baseType = 2;</code>
*/
public int getBaseTypeValue() {
return baseType_;
}
/**
* <code>optional .ai.grakn.rpc.generated.BaseType baseType = 2;</code>
*/
public Builder setBaseTypeValue(int value) {
baseType_ = value;
onChanged();
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.BaseType baseType = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.BaseType getBaseType() {
ai.grakn.rpc.generated.GrpcConcept.BaseType result = ai.grakn.rpc.generated.GrpcConcept.BaseType.valueOf(baseType_);
return result == null ? ai.grakn.rpc.generated.GrpcConcept.BaseType.UNRECOGNIZED : result;
}
/**
* <code>optional .ai.grakn.rpc.generated.BaseType baseType = 2;</code>
*/
public Builder setBaseType(ai.grakn.rpc.generated.GrpcConcept.BaseType value) {
if (value == null) {
throw new NullPointerException();
}
baseType_ = value.getNumber();
onChanged();
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.BaseType baseType = 2;</code>
*/
public Builder clearBaseType() {
baseType_ = 0;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Concept)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Concept)
private static final ai.grakn.rpc.generated.GrpcConcept.Concept DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.Concept();
}
public static ai.grakn.rpc.generated.GrpcConcept.Concept getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Concept>
PARSER = new com.google.protobuf.AbstractParser<Concept>() {
public Concept parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Concept(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Concept> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Concept> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.Concept getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface ConceptIdOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.ConceptId)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional string value = 1;</code>
*/
java.lang.String getValue();
/**
* <code>optional string value = 1;</code>
*/
com.google.protobuf.ByteString
getValueBytes();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.ConceptId}
*/
public static final class ConceptId extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.ConceptId)
ConceptIdOrBuilder {
// Use ConceptId.newBuilder() to construct.
private ConceptId(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private ConceptId() {
value_ = "";
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private ConceptId(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
value_ = s;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptId_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptId_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.ConceptId.class, ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder.class);
}
public static final int VALUE_FIELD_NUMBER = 1;
private volatile java.lang.Object value_;
/**
* <code>optional string value = 1;</code>
*/
public java.lang.String getValue() {
java.lang.Object ref = value_;
if (ref instanceof java.lang.String) {
return (java.lang.String) ref;
} else {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
value_ = s;
return s;
}
}
/**
* <code>optional string value = 1;</code>
*/
public com.google.protobuf.ByteString
getValueBytes() {
java.lang.Object ref = value_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
value_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (!getValueBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, value_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (!getValueBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, value_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.ConceptId)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.ConceptId other = (ai.grakn.rpc.generated.GrpcConcept.ConceptId) obj;
boolean result = true;
result = result && getValue()
.equals(other.getValue());
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
hash = (37 * hash) + VALUE_FIELD_NUMBER;
hash = (53 * hash) + getValue().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptId parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptId parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptId parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptId parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptId parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptId parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptId parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptId parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptId parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptId parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.ConceptId prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.ConceptId}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.ConceptId)
ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptId_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptId_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.ConceptId.class, ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.ConceptId.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
value_ = "";
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptId_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.ConceptId getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.ConceptId build() {
ai.grakn.rpc.generated.GrpcConcept.ConceptId result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.ConceptId buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.ConceptId result = new ai.grakn.rpc.generated.GrpcConcept.ConceptId(this);
result.value_ = value_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.ConceptId) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.ConceptId)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.ConceptId other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance()) return this;
if (!other.getValue().isEmpty()) {
value_ = other.value_;
onChanged();
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.ConceptId parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.ConceptId) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private java.lang.Object value_ = "";
/**
* <code>optional string value = 1;</code>
*/
public java.lang.String getValue() {
java.lang.Object ref = value_;
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
value_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <code>optional string value = 1;</code>
*/
public com.google.protobuf.ByteString
getValueBytes() {
java.lang.Object ref = value_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
value_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <code>optional string value = 1;</code>
*/
public Builder setValue(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
return this;
}
/**
* <code>optional string value = 1;</code>
*/
public Builder clearValue() {
value_ = getDefaultInstance().getValue();
onChanged();
return this;
}
/**
* <code>optional string value = 1;</code>
*/
public Builder setValueBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
value_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.ConceptId)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.ConceptId)
private static final ai.grakn.rpc.generated.GrpcConcept.ConceptId DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.ConceptId();
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptId getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<ConceptId>
PARSER = new com.google.protobuf.AbstractParser<ConceptId>() {
public ConceptId parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new ConceptId(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<ConceptId> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<ConceptId> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.ConceptId getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface ConceptMethodOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.ConceptMethod)
com.google.protobuf.MessageOrBuilder {
/**
* <pre>
* Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit delete = 16;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getDelete();
/**
* <pre>
* Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit delete = 16;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getDeleteOrBuilder();
/**
* <pre>
* Schema concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getLabel = 3;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetLabel();
/**
* <pre>
* Schema concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getLabel = 3;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetLabelOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label setLabel = 18;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Label getSetLabel();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label setLabel = 18;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getSetLabelOrBuilder();
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isImplicit = 4;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getIsImplicit();
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isImplicit = 4;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getIsImplicitOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSubConcepts = 19;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetSubConcepts();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSubConcepts = 19;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetSubConceptsOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSuperConcepts = 53;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetSuperConcepts();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSuperConcepts = 53;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetSuperConceptsOrBuilder();
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectSuperConcept = 14;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetDirectSuperConcept();
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectSuperConcept = 14;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetDirectSuperConceptOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setDirectSuperConcept = 17;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getSetDirectSuperConcept();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setDirectSuperConcept = 17;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetDirectSuperConceptOrBuilder();
/**
* <pre>
* Rule
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getWhen = 7;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetWhen();
/**
* <pre>
* Rule
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getWhen = 7;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetWhenOrBuilder();
/**
* <pre>
* returns OptionalPattern
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getThen = 8;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetThen();
/**
* <pre>
* returns OptionalPattern
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getThen = 8;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetThenOrBuilder();
/**
* <pre>
* Role
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationshipTypesThatRelateRole = 20;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetRelationshipTypesThatRelateRole();
/**
* <pre>
* Role
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationshipTypesThatRelateRole = 20;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRelationshipTypesThatRelateRoleOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getTypesThatPlayRole = 21;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetTypesThatPlayRole();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getTypesThatPlayRole = 21;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetTypesThatPlayRoleOrBuilder();
/**
* <pre>
* Type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getInstances = 30;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetInstances();
/**
* <pre>
* Type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getInstances = 30;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetInstancesOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributeTypes = 11;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetAttributeTypes();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributeTypes = 11;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetAttributeTypesOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.Concept setAttributeType = 25;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getSetAttributeType();
/**
* <code>optional .ai.grakn.rpc.generated.Concept setAttributeType = 25;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetAttributeTypeOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttributeType = 26;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetAttributeType();
/**
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttributeType = 26;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetAttributeTypeOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeyTypes = 12;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetKeyTypes();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeyTypes = 12;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetKeyTypesOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setKeyType = 27;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getSetKeyType();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setKeyType = 27;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetKeyTypeOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetKeyType = 28;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetKeyType();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetKeyType = 28;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetKeyTypeOrBuilder();
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isAbstract = 6;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getIsAbstract();
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isAbstract = 6;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getIsAbstractOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional bool setAbstract = 22;</code>
*/
boolean getSetAbstract();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByType = 29;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetRolesPlayedByType();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByType = 29;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRolesPlayedByTypeOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRolePlayedByType = 23;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getSetRolePlayedByType();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRolePlayedByType = 23;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetRolePlayedByTypeOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRolePlayedByType = 24;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetRolePlayedByType();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRolePlayedByType = 24;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetRolePlayedByTypeOrBuilder();
/**
* <pre>
* Entity type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addEntity = 34;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getAddEntity();
/**
* <pre>
* Entity type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addEntity = 34;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAddEntityOrBuilder();
/**
* <pre>
* Relationship type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelatedRoles = 36;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetRelatedRoles();
/**
* <pre>
* Relationship type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelatedRoles = 36;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRelatedRolesOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRelatedRole = 37;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getSetRelatedRole();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRelatedRole = 37;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetRelatedRoleOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRelatedRole = 38;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetRelatedRole();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRelatedRole = 38;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetRelatedRoleOrBuilder();
/**
* <pre>
* Attribute type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue putAttribute = 32;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.AttributeValue getPutAttribute();
/**
* <pre>
* Attribute type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue putAttribute = 32;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder getPutAttributeOrBuilder();
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttribute = 33;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.AttributeValue getGetAttribute();
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttribute = 33;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder getGetAttributeOrBuilder();
/**
* <pre>
* returns OptionalDataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfType = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetDataTypeOfType();
/**
* <pre>
* returns OptionalDataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfType = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetDataTypeOfTypeOrBuilder();
/**
* <pre>
* returns DataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfAttribute = 54;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetDataTypeOfAttribute();
/**
* <pre>
* returns DataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfAttribute = 54;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetDataTypeOfAttributeOrBuilder();
/**
* <pre>
* returns OptionalRegex
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRegex = 9;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetRegex();
/**
* <pre>
* returns OptionalRegex
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRegex = 9;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRegexOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.OptionalRegex setRegex = 31;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex getSetRegex();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.OptionalRegex setRegex = 31;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.OptionalRegexOrBuilder getSetRegexOrBuilder();
/**
* <pre>
* Thing
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isInferred = 5;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getIsInferred();
/**
* <pre>
* Thing
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isInferred = 5;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getIsInferredOrBuilder();
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectType = 13;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetDirectType();
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectType = 13;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetDirectTypeOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationships = 39;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetRelationships();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationships = 39;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRelationshipsOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRelationshipsByRoles = 48;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concepts getGetRelationshipsByRoles();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRelationshipsByRoles = 48;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder getGetRelationshipsByRolesOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByThing = 40;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetRolesPlayedByThing();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByThing = 40;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRolesPlayedByThingOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributes = 41;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetAttributes();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributes = 41;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetAttributesOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getAttributesByTypes = 49;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concepts getGetAttributesByTypes();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getAttributesByTypes = 49;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder getGetAttributesByTypesOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeys = 42;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetKeys();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeys = 42;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetKeysOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getKeysByTypes = 50;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concepts getGetKeysByTypes();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getKeysByTypes = 50;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder getGetKeysByTypesOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setAttribute = 43;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getSetAttribute();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setAttribute = 43;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetAttributeOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttribute = 44;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetAttribute();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttribute = 44;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetAttributeOrBuilder();
/**
* <pre>
* Relationship
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addRelationship = 35;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getAddRelationship();
/**
* <pre>
* Relationship
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addRelationship = 35;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAddRelationshipOrBuilder();
/**
* <pre>
* returns IteratorId of RolePlayer
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolePlayers = 10;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetRolePlayers();
/**
* <pre>
* returns IteratorId of RolePlayer
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolePlayers = 10;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRolePlayersOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRolePlayersByRoles = 51;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concepts getGetRolePlayersByRoles();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRolePlayersByRoles = 51;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder getGetRolePlayersByRolesOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer setRolePlayer = 46;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.RolePlayer getSetRolePlayer();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer setRolePlayer = 46;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder getSetRolePlayerOrBuilder();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer unsetRolePlayer = 15;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.RolePlayer getUnsetRolePlayer();
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer unsetRolePlayer = 15;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder getUnsetRolePlayerOrBuilder();
/**
* <pre>
* Attribute
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getValue = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetValue();
/**
* <pre>
* Attribute
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getValue = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetValueOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getOwners = 47;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getGetOwners();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getOwners = 47;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetOwnersOrBuilder();
public ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.ConceptMethodCase getConceptMethodCase();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.ConceptMethod}
*/
public static final class ConceptMethod extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.ConceptMethod)
ConceptMethodOrBuilder {
// Use ConceptMethod.newBuilder() to construct.
private ConceptMethod(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private ConceptMethod() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private ConceptMethod(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
int mutable_bitField1_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 1) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 1;
break;
}
case 18: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 2) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 2;
break;
}
case 26: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 3) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 3;
break;
}
case 34: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 4) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 4;
break;
}
case 42: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 5) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 5;
break;
}
case 50: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 6) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 6;
break;
}
case 58: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 7) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 7;
break;
}
case 66: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 8) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 8;
break;
}
case 74: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 9) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 9;
break;
}
case 82: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 10) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 10;
break;
}
case 90: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 11) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 11;
break;
}
case 98: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 12) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 12;
break;
}
case 106: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 13) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 13;
break;
}
case 114: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 14) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 14;
break;
}
case 122: {
ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder subBuilder = null;
if (conceptMethodCase_ == 15) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.RolePlayer.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 15;
break;
}
case 130: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 16) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 16;
break;
}
case 138: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (conceptMethodCase_ == 17) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 17;
break;
}
case 146: {
ai.grakn.rpc.generated.GrpcConcept.Label.Builder subBuilder = null;
if (conceptMethodCase_ == 18) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Label) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Label.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Label) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 18;
break;
}
case 154: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 19) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 19;
break;
}
case 162: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 20) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 20;
break;
}
case 170: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 21) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 21;
break;
}
case 176: {
conceptMethodCase_ = 22;
conceptMethod_ = input.readBool();
break;
}
case 186: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (conceptMethodCase_ == 23) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 23;
break;
}
case 194: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (conceptMethodCase_ == 24) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 24;
break;
}
case 202: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (conceptMethodCase_ == 25) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 25;
break;
}
case 210: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (conceptMethodCase_ == 26) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 26;
break;
}
case 218: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (conceptMethodCase_ == 27) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 27;
break;
}
case 226: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (conceptMethodCase_ == 28) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 28;
break;
}
case 234: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 29) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 29;
break;
}
case 242: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 30) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 30;
break;
}
case 250: {
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder subBuilder = null;
if (conceptMethodCase_ == 31) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 31;
break;
}
case 258: {
ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder subBuilder = null;
if (conceptMethodCase_ == 32) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.AttributeValue.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 32;
break;
}
case 266: {
ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder subBuilder = null;
if (conceptMethodCase_ == 33) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.AttributeValue.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 33;
break;
}
case 274: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 34) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 34;
break;
}
case 282: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 35) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 35;
break;
}
case 290: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 36) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 36;
break;
}
case 298: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (conceptMethodCase_ == 37) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 37;
break;
}
case 306: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (conceptMethodCase_ == 38) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 38;
break;
}
case 314: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 39) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 39;
break;
}
case 322: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 40) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 40;
break;
}
case 330: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 41) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 41;
break;
}
case 338: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 42) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 42;
break;
}
case 346: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (conceptMethodCase_ == 43) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 43;
break;
}
case 354: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (conceptMethodCase_ == 44) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 44;
break;
}
case 370: {
ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder subBuilder = null;
if (conceptMethodCase_ == 46) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.RolePlayer.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 46;
break;
}
case 378: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 47) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 47;
break;
}
case 386: {
ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder subBuilder = null;
if (conceptMethodCase_ == 48) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concepts.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 48;
break;
}
case 394: {
ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder subBuilder = null;
if (conceptMethodCase_ == 49) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concepts.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 49;
break;
}
case 402: {
ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder subBuilder = null;
if (conceptMethodCase_ == 50) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concepts.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 50;
break;
}
case 410: {
ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder subBuilder = null;
if (conceptMethodCase_ == 51) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concepts.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 51;
break;
}
case 426: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 53) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 53;
break;
}
case 434: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (conceptMethodCase_ == 54) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_).toBuilder();
}
conceptMethod_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
conceptMethodCase_ = 54;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptMethod_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptMethod_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.class, ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.Builder.class);
}
private int conceptMethodCase_ = 0;
private java.lang.Object conceptMethod_;
public enum ConceptMethodCase
implements com.google.protobuf.Internal.EnumLite {
DELETE(16),
GETLABEL(3),
SETLABEL(18),
ISIMPLICIT(4),
GETSUBCONCEPTS(19),
GETSUPERCONCEPTS(53),
GETDIRECTSUPERCONCEPT(14),
SETDIRECTSUPERCONCEPT(17),
GETWHEN(7),
GETTHEN(8),
GETRELATIONSHIPTYPESTHATRELATEROLE(20),
GETTYPESTHATPLAYROLE(21),
GETINSTANCES(30),
GETATTRIBUTETYPES(11),
SETATTRIBUTETYPE(25),
UNSETATTRIBUTETYPE(26),
GETKEYTYPES(12),
SETKEYTYPE(27),
UNSETKEYTYPE(28),
ISABSTRACT(6),
SETABSTRACT(22),
GETROLESPLAYEDBYTYPE(29),
SETROLEPLAYEDBYTYPE(23),
UNSETROLEPLAYEDBYTYPE(24),
ADDENTITY(34),
GETRELATEDROLES(36),
SETRELATEDROLE(37),
UNSETRELATEDROLE(38),
PUTATTRIBUTE(32),
GETATTRIBUTE(33),
GETDATATYPEOFTYPE(2),
GETDATATYPEOFATTRIBUTE(54),
GETREGEX(9),
SETREGEX(31),
ISINFERRED(5),
GETDIRECTTYPE(13),
GETRELATIONSHIPS(39),
GETRELATIONSHIPSBYROLES(48),
GETROLESPLAYEDBYTHING(40),
GETATTRIBUTES(41),
GETATTRIBUTESBYTYPES(49),
GETKEYS(42),
GETKEYSBYTYPES(50),
SETATTRIBUTE(43),
UNSETATTRIBUTE(44),
ADDRELATIONSHIP(35),
GETROLEPLAYERS(10),
GETROLEPLAYERSBYROLES(51),
SETROLEPLAYER(46),
UNSETROLEPLAYER(15),
GETVALUE(1),
GETOWNERS(47),
CONCEPTMETHOD_NOT_SET(0);
private final int value;
private ConceptMethodCase(int value) {
this.value = value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static ConceptMethodCase valueOf(int value) {
return forNumber(value);
}
public static ConceptMethodCase forNumber(int value) {
switch (value) {
case 16: return DELETE;
case 3: return GETLABEL;
case 18: return SETLABEL;
case 4: return ISIMPLICIT;
case 19: return GETSUBCONCEPTS;
case 53: return GETSUPERCONCEPTS;
case 14: return GETDIRECTSUPERCONCEPT;
case 17: return SETDIRECTSUPERCONCEPT;
case 7: return GETWHEN;
case 8: return GETTHEN;
case 20: return GETRELATIONSHIPTYPESTHATRELATEROLE;
case 21: return GETTYPESTHATPLAYROLE;
case 30: return GETINSTANCES;
case 11: return GETATTRIBUTETYPES;
case 25: return SETATTRIBUTETYPE;
case 26: return UNSETATTRIBUTETYPE;
case 12: return GETKEYTYPES;
case 27: return SETKEYTYPE;
case 28: return UNSETKEYTYPE;
case 6: return ISABSTRACT;
case 22: return SETABSTRACT;
case 29: return GETROLESPLAYEDBYTYPE;
case 23: return SETROLEPLAYEDBYTYPE;
case 24: return UNSETROLEPLAYEDBYTYPE;
case 34: return ADDENTITY;
case 36: return GETRELATEDROLES;
case 37: return SETRELATEDROLE;
case 38: return UNSETRELATEDROLE;
case 32: return PUTATTRIBUTE;
case 33: return GETATTRIBUTE;
case 2: return GETDATATYPEOFTYPE;
case 54: return GETDATATYPEOFATTRIBUTE;
case 9: return GETREGEX;
case 31: return SETREGEX;
case 5: return ISINFERRED;
case 13: return GETDIRECTTYPE;
case 39: return GETRELATIONSHIPS;
case 48: return GETRELATIONSHIPSBYROLES;
case 40: return GETROLESPLAYEDBYTHING;
case 41: return GETATTRIBUTES;
case 49: return GETATTRIBUTESBYTYPES;
case 42: return GETKEYS;
case 50: return GETKEYSBYTYPES;
case 43: return SETATTRIBUTE;
case 44: return UNSETATTRIBUTE;
case 35: return ADDRELATIONSHIP;
case 10: return GETROLEPLAYERS;
case 51: return GETROLEPLAYERSBYROLES;
case 46: return SETROLEPLAYER;
case 15: return UNSETROLEPLAYER;
case 1: return GETVALUE;
case 47: return GETOWNERS;
case 0: return CONCEPTMETHOD_NOT_SET;
default: return null;
}
}
public int getNumber() {
return this.value;
}
};
public ConceptMethodCase
getConceptMethodCase() {
return ConceptMethodCase.forNumber(
conceptMethodCase_);
}
public static final int DELETE_FIELD_NUMBER = 16;
/**
* <pre>
* Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit delete = 16;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getDelete() {
if (conceptMethodCase_ == 16) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit delete = 16;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getDeleteOrBuilder() {
if (conceptMethodCase_ == 16) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETLABEL_FIELD_NUMBER = 3;
/**
* <pre>
* Schema concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getLabel = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetLabel() {
if (conceptMethodCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* Schema concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getLabel = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetLabelOrBuilder() {
if (conceptMethodCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int SETLABEL_FIELD_NUMBER = 18;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label setLabel = 18;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getSetLabel() {
if (conceptMethodCase_ == 18) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label setLabel = 18;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getSetLabelOrBuilder() {
if (conceptMethodCase_ == 18) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
public static final int ISIMPLICIT_FIELD_NUMBER = 4;
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isImplicit = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getIsImplicit() {
if (conceptMethodCase_ == 4) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isImplicit = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getIsImplicitOrBuilder() {
if (conceptMethodCase_ == 4) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETSUBCONCEPTS_FIELD_NUMBER = 19;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSubConcepts = 19;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetSubConcepts() {
if (conceptMethodCase_ == 19) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSubConcepts = 19;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetSubConceptsOrBuilder() {
if (conceptMethodCase_ == 19) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETSUPERCONCEPTS_FIELD_NUMBER = 53;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSuperConcepts = 53;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetSuperConcepts() {
if (conceptMethodCase_ == 53) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSuperConcepts = 53;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetSuperConceptsOrBuilder() {
if (conceptMethodCase_ == 53) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETDIRECTSUPERCONCEPT_FIELD_NUMBER = 14;
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectSuperConcept = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetDirectSuperConcept() {
if (conceptMethodCase_ == 14) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectSuperConcept = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetDirectSuperConceptOrBuilder() {
if (conceptMethodCase_ == 14) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int SETDIRECTSUPERCONCEPT_FIELD_NUMBER = 17;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setDirectSuperConcept = 17;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getSetDirectSuperConcept() {
if (conceptMethodCase_ == 17) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setDirectSuperConcept = 17;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetDirectSuperConceptOrBuilder() {
if (conceptMethodCase_ == 17) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int GETWHEN_FIELD_NUMBER = 7;
/**
* <pre>
* Rule
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getWhen = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetWhen() {
if (conceptMethodCase_ == 7) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* Rule
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getWhen = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetWhenOrBuilder() {
if (conceptMethodCase_ == 7) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETTHEN_FIELD_NUMBER = 8;
/**
* <pre>
* returns OptionalPattern
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getThen = 8;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetThen() {
if (conceptMethodCase_ == 8) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns OptionalPattern
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getThen = 8;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetThenOrBuilder() {
if (conceptMethodCase_ == 8) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETRELATIONSHIPTYPESTHATRELATEROLE_FIELD_NUMBER = 20;
/**
* <pre>
* Role
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationshipTypesThatRelateRole = 20;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRelationshipTypesThatRelateRole() {
if (conceptMethodCase_ == 20) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* Role
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationshipTypesThatRelateRole = 20;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRelationshipTypesThatRelateRoleOrBuilder() {
if (conceptMethodCase_ == 20) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETTYPESTHATPLAYROLE_FIELD_NUMBER = 21;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getTypesThatPlayRole = 21;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetTypesThatPlayRole() {
if (conceptMethodCase_ == 21) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getTypesThatPlayRole = 21;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetTypesThatPlayRoleOrBuilder() {
if (conceptMethodCase_ == 21) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETINSTANCES_FIELD_NUMBER = 30;
/**
* <pre>
* Type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getInstances = 30;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetInstances() {
if (conceptMethodCase_ == 30) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* Type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getInstances = 30;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetInstancesOrBuilder() {
if (conceptMethodCase_ == 30) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETATTRIBUTETYPES_FIELD_NUMBER = 11;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributeTypes = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetAttributeTypes() {
if (conceptMethodCase_ == 11) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributeTypes = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetAttributeTypesOrBuilder() {
if (conceptMethodCase_ == 11) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int SETATTRIBUTETYPE_FIELD_NUMBER = 25;
/**
* <code>optional .ai.grakn.rpc.generated.Concept setAttributeType = 25;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getSetAttributeType() {
if (conceptMethodCase_ == 25) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept setAttributeType = 25;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetAttributeTypeOrBuilder() {
if (conceptMethodCase_ == 25) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int UNSETATTRIBUTETYPE_FIELD_NUMBER = 26;
/**
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttributeType = 26;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetAttributeType() {
if (conceptMethodCase_ == 26) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttributeType = 26;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetAttributeTypeOrBuilder() {
if (conceptMethodCase_ == 26) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int GETKEYTYPES_FIELD_NUMBER = 12;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeyTypes = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetKeyTypes() {
if (conceptMethodCase_ == 12) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeyTypes = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetKeyTypesOrBuilder() {
if (conceptMethodCase_ == 12) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int SETKEYTYPE_FIELD_NUMBER = 27;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setKeyType = 27;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getSetKeyType() {
if (conceptMethodCase_ == 27) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setKeyType = 27;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetKeyTypeOrBuilder() {
if (conceptMethodCase_ == 27) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int UNSETKEYTYPE_FIELD_NUMBER = 28;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetKeyType = 28;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetKeyType() {
if (conceptMethodCase_ == 28) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetKeyType = 28;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetKeyTypeOrBuilder() {
if (conceptMethodCase_ == 28) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int ISABSTRACT_FIELD_NUMBER = 6;
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isAbstract = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getIsAbstract() {
if (conceptMethodCase_ == 6) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isAbstract = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getIsAbstractOrBuilder() {
if (conceptMethodCase_ == 6) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int SETABSTRACT_FIELD_NUMBER = 22;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional bool setAbstract = 22;</code>
*/
public boolean getSetAbstract() {
if (conceptMethodCase_ == 22) {
return (java.lang.Boolean) conceptMethod_;
}
return false;
}
public static final int GETROLESPLAYEDBYTYPE_FIELD_NUMBER = 29;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByType = 29;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRolesPlayedByType() {
if (conceptMethodCase_ == 29) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByType = 29;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRolesPlayedByTypeOrBuilder() {
if (conceptMethodCase_ == 29) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int SETROLEPLAYEDBYTYPE_FIELD_NUMBER = 23;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRolePlayedByType = 23;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getSetRolePlayedByType() {
if (conceptMethodCase_ == 23) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRolePlayedByType = 23;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetRolePlayedByTypeOrBuilder() {
if (conceptMethodCase_ == 23) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int UNSETROLEPLAYEDBYTYPE_FIELD_NUMBER = 24;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRolePlayedByType = 24;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetRolePlayedByType() {
if (conceptMethodCase_ == 24) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRolePlayedByType = 24;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetRolePlayedByTypeOrBuilder() {
if (conceptMethodCase_ == 24) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int ADDENTITY_FIELD_NUMBER = 34;
/**
* <pre>
* Entity type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addEntity = 34;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getAddEntity() {
if (conceptMethodCase_ == 34) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* Entity type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addEntity = 34;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAddEntityOrBuilder() {
if (conceptMethodCase_ == 34) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETRELATEDROLES_FIELD_NUMBER = 36;
/**
* <pre>
* Relationship type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelatedRoles = 36;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRelatedRoles() {
if (conceptMethodCase_ == 36) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* Relationship type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelatedRoles = 36;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRelatedRolesOrBuilder() {
if (conceptMethodCase_ == 36) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int SETRELATEDROLE_FIELD_NUMBER = 37;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRelatedRole = 37;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getSetRelatedRole() {
if (conceptMethodCase_ == 37) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRelatedRole = 37;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetRelatedRoleOrBuilder() {
if (conceptMethodCase_ == 37) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int UNSETRELATEDROLE_FIELD_NUMBER = 38;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRelatedRole = 38;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetRelatedRole() {
if (conceptMethodCase_ == 38) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRelatedRole = 38;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetRelatedRoleOrBuilder() {
if (conceptMethodCase_ == 38) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int PUTATTRIBUTE_FIELD_NUMBER = 32;
/**
* <pre>
* Attribute type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue putAttribute = 32;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue getPutAttribute() {
if (conceptMethodCase_ == 32) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
/**
* <pre>
* Attribute type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue putAttribute = 32;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder getPutAttributeOrBuilder() {
if (conceptMethodCase_ == 32) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
public static final int GETATTRIBUTE_FIELD_NUMBER = 33;
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttribute = 33;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue getGetAttribute() {
if (conceptMethodCase_ == 33) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttribute = 33;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder getGetAttributeOrBuilder() {
if (conceptMethodCase_ == 33) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
public static final int GETDATATYPEOFTYPE_FIELD_NUMBER = 2;
/**
* <pre>
* returns OptionalDataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfType = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetDataTypeOfType() {
if (conceptMethodCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns OptionalDataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfType = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetDataTypeOfTypeOrBuilder() {
if (conceptMethodCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETDATATYPEOFATTRIBUTE_FIELD_NUMBER = 54;
/**
* <pre>
* returns DataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfAttribute = 54;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetDataTypeOfAttribute() {
if (conceptMethodCase_ == 54) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns DataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfAttribute = 54;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetDataTypeOfAttributeOrBuilder() {
if (conceptMethodCase_ == 54) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETREGEX_FIELD_NUMBER = 9;
/**
* <pre>
* returns OptionalRegex
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRegex = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRegex() {
if (conceptMethodCase_ == 9) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns OptionalRegex
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRegex = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRegexOrBuilder() {
if (conceptMethodCase_ == 9) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int SETREGEX_FIELD_NUMBER = 31;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.OptionalRegex setRegex = 31;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegex getSetRegex() {
if (conceptMethodCase_ == 31) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.OptionalRegex setRegex = 31;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegexOrBuilder getSetRegexOrBuilder() {
if (conceptMethodCase_ == 31) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance();
}
public static final int ISINFERRED_FIELD_NUMBER = 5;
/**
* <pre>
* Thing
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isInferred = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getIsInferred() {
if (conceptMethodCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* Thing
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isInferred = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getIsInferredOrBuilder() {
if (conceptMethodCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETDIRECTTYPE_FIELD_NUMBER = 13;
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectType = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetDirectType() {
if (conceptMethodCase_ == 13) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectType = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetDirectTypeOrBuilder() {
if (conceptMethodCase_ == 13) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETRELATIONSHIPS_FIELD_NUMBER = 39;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationships = 39;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRelationships() {
if (conceptMethodCase_ == 39) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationships = 39;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRelationshipsOrBuilder() {
if (conceptMethodCase_ == 39) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETRELATIONSHIPSBYROLES_FIELD_NUMBER = 48;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRelationshipsByRoles = 48;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concepts getGetRelationshipsByRoles() {
if (conceptMethodCase_ == 48) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRelationshipsByRoles = 48;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder getGetRelationshipsByRolesOrBuilder() {
if (conceptMethodCase_ == 48) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
public static final int GETROLESPLAYEDBYTHING_FIELD_NUMBER = 40;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByThing = 40;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRolesPlayedByThing() {
if (conceptMethodCase_ == 40) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByThing = 40;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRolesPlayedByThingOrBuilder() {
if (conceptMethodCase_ == 40) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETATTRIBUTES_FIELD_NUMBER = 41;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributes = 41;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetAttributes() {
if (conceptMethodCase_ == 41) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributes = 41;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetAttributesOrBuilder() {
if (conceptMethodCase_ == 41) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETATTRIBUTESBYTYPES_FIELD_NUMBER = 49;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getAttributesByTypes = 49;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concepts getGetAttributesByTypes() {
if (conceptMethodCase_ == 49) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getAttributesByTypes = 49;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder getGetAttributesByTypesOrBuilder() {
if (conceptMethodCase_ == 49) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
public static final int GETKEYS_FIELD_NUMBER = 42;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeys = 42;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetKeys() {
if (conceptMethodCase_ == 42) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeys = 42;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetKeysOrBuilder() {
if (conceptMethodCase_ == 42) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETKEYSBYTYPES_FIELD_NUMBER = 50;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getKeysByTypes = 50;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concepts getGetKeysByTypes() {
if (conceptMethodCase_ == 50) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getKeysByTypes = 50;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder getGetKeysByTypesOrBuilder() {
if (conceptMethodCase_ == 50) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
public static final int SETATTRIBUTE_FIELD_NUMBER = 43;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setAttribute = 43;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getSetAttribute() {
if (conceptMethodCase_ == 43) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setAttribute = 43;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetAttributeOrBuilder() {
if (conceptMethodCase_ == 43) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int UNSETATTRIBUTE_FIELD_NUMBER = 44;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttribute = 44;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetAttribute() {
if (conceptMethodCase_ == 44) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttribute = 44;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetAttributeOrBuilder() {
if (conceptMethodCase_ == 44) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int ADDRELATIONSHIP_FIELD_NUMBER = 35;
/**
* <pre>
* Relationship
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addRelationship = 35;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getAddRelationship() {
if (conceptMethodCase_ == 35) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* Relationship
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addRelationship = 35;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAddRelationshipOrBuilder() {
if (conceptMethodCase_ == 35) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETROLEPLAYERS_FIELD_NUMBER = 10;
/**
* <pre>
* returns IteratorId of RolePlayer
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolePlayers = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRolePlayers() {
if (conceptMethodCase_ == 10) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of RolePlayer
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolePlayers = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRolePlayersOrBuilder() {
if (conceptMethodCase_ == 10) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETROLEPLAYERSBYROLES_FIELD_NUMBER = 51;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRolePlayersByRoles = 51;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concepts getGetRolePlayersByRoles() {
if (conceptMethodCase_ == 51) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRolePlayersByRoles = 51;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder getGetRolePlayersByRolesOrBuilder() {
if (conceptMethodCase_ == 51) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
public static final int SETROLEPLAYER_FIELD_NUMBER = 46;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer setRolePlayer = 46;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer getSetRolePlayer() {
if (conceptMethodCase_ == 46) {
return (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer setRolePlayer = 46;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder getSetRolePlayerOrBuilder() {
if (conceptMethodCase_ == 46) {
return (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
public static final int UNSETROLEPLAYER_FIELD_NUMBER = 15;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer unsetRolePlayer = 15;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer getUnsetRolePlayer() {
if (conceptMethodCase_ == 15) {
return (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer unsetRolePlayer = 15;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder getUnsetRolePlayerOrBuilder() {
if (conceptMethodCase_ == 15) {
return (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
public static final int GETVALUE_FIELD_NUMBER = 1;
/**
* <pre>
* Attribute
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getValue = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetValue() {
if (conceptMethodCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* Attribute
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getValue = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetValueOrBuilder() {
if (conceptMethodCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int GETOWNERS_FIELD_NUMBER = 47;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getOwners = 47;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetOwners() {
if (conceptMethodCase_ == 47) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getOwners = 47;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetOwnersOrBuilder() {
if (conceptMethodCase_ == 47) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (conceptMethodCase_ == 1) {
output.writeMessage(1, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 2) {
output.writeMessage(2, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 3) {
output.writeMessage(3, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 4) {
output.writeMessage(4, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 5) {
output.writeMessage(5, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 6) {
output.writeMessage(6, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 7) {
output.writeMessage(7, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 8) {
output.writeMessage(8, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 9) {
output.writeMessage(9, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 10) {
output.writeMessage(10, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 11) {
output.writeMessage(11, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 12) {
output.writeMessage(12, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 13) {
output.writeMessage(13, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 14) {
output.writeMessage(14, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 15) {
output.writeMessage(15, (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_);
}
if (conceptMethodCase_ == 16) {
output.writeMessage(16, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 17) {
output.writeMessage(17, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 18) {
output.writeMessage(18, (ai.grakn.rpc.generated.GrpcConcept.Label) conceptMethod_);
}
if (conceptMethodCase_ == 19) {
output.writeMessage(19, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 20) {
output.writeMessage(20, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 21) {
output.writeMessage(21, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 22) {
output.writeBool(
22, (boolean)((java.lang.Boolean) conceptMethod_));
}
if (conceptMethodCase_ == 23) {
output.writeMessage(23, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 24) {
output.writeMessage(24, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 25) {
output.writeMessage(25, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 26) {
output.writeMessage(26, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 27) {
output.writeMessage(27, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 28) {
output.writeMessage(28, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 29) {
output.writeMessage(29, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 30) {
output.writeMessage(30, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 31) {
output.writeMessage(31, (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) conceptMethod_);
}
if (conceptMethodCase_ == 32) {
output.writeMessage(32, (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_);
}
if (conceptMethodCase_ == 33) {
output.writeMessage(33, (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_);
}
if (conceptMethodCase_ == 34) {
output.writeMessage(34, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 35) {
output.writeMessage(35, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 36) {
output.writeMessage(36, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 37) {
output.writeMessage(37, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 38) {
output.writeMessage(38, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 39) {
output.writeMessage(39, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 40) {
output.writeMessage(40, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 41) {
output.writeMessage(41, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 42) {
output.writeMessage(42, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 43) {
output.writeMessage(43, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 44) {
output.writeMessage(44, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 46) {
output.writeMessage(46, (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_);
}
if (conceptMethodCase_ == 47) {
output.writeMessage(47, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 48) {
output.writeMessage(48, (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_);
}
if (conceptMethodCase_ == 49) {
output.writeMessage(49, (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_);
}
if (conceptMethodCase_ == 50) {
output.writeMessage(50, (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_);
}
if (conceptMethodCase_ == 51) {
output.writeMessage(51, (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_);
}
if (conceptMethodCase_ == 53) {
output.writeMessage(53, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 54) {
output.writeMessage(54, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (conceptMethodCase_ == 1) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 2) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(2, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 3) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(3, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 4) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(4, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 5) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(5, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 6) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(6, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 7) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(7, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 8) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(8, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 9) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(9, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 10) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(10, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 11) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(11, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 12) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(12, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 13) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(13, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 14) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(14, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 15) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(15, (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_);
}
if (conceptMethodCase_ == 16) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(16, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 17) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(17, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 18) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(18, (ai.grakn.rpc.generated.GrpcConcept.Label) conceptMethod_);
}
if (conceptMethodCase_ == 19) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(19, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 20) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(20, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 21) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(21, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 22) {
size += com.google.protobuf.CodedOutputStream
.computeBoolSize(
22, (boolean)((java.lang.Boolean) conceptMethod_));
}
if (conceptMethodCase_ == 23) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(23, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 24) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(24, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 25) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(25, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 26) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(26, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 27) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(27, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 28) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(28, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 29) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(29, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 30) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(30, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 31) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(31, (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) conceptMethod_);
}
if (conceptMethodCase_ == 32) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(32, (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_);
}
if (conceptMethodCase_ == 33) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(33, (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_);
}
if (conceptMethodCase_ == 34) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(34, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 35) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(35, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 36) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(36, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 37) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(37, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 38) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(38, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 39) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(39, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 40) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(40, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 41) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(41, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 42) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(42, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 43) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(43, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 44) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(44, (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_);
}
if (conceptMethodCase_ == 46) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(46, (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_);
}
if (conceptMethodCase_ == 47) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(47, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 48) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(48, (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_);
}
if (conceptMethodCase_ == 49) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(49, (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_);
}
if (conceptMethodCase_ == 50) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(50, (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_);
}
if (conceptMethodCase_ == 51) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(51, (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_);
}
if (conceptMethodCase_ == 53) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(53, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
if (conceptMethodCase_ == 54) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(54, (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.ConceptMethod)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod other = (ai.grakn.rpc.generated.GrpcConcept.ConceptMethod) obj;
boolean result = true;
result = result && getConceptMethodCase().equals(
other.getConceptMethodCase());
if (!result) return false;
switch (conceptMethodCase_) {
case 16:
result = result && getDelete()
.equals(other.getDelete());
break;
case 3:
result = result && getGetLabel()
.equals(other.getGetLabel());
break;
case 18:
result = result && getSetLabel()
.equals(other.getSetLabel());
break;
case 4:
result = result && getIsImplicit()
.equals(other.getIsImplicit());
break;
case 19:
result = result && getGetSubConcepts()
.equals(other.getGetSubConcepts());
break;
case 53:
result = result && getGetSuperConcepts()
.equals(other.getGetSuperConcepts());
break;
case 14:
result = result && getGetDirectSuperConcept()
.equals(other.getGetDirectSuperConcept());
break;
case 17:
result = result && getSetDirectSuperConcept()
.equals(other.getSetDirectSuperConcept());
break;
case 7:
result = result && getGetWhen()
.equals(other.getGetWhen());
break;
case 8:
result = result && getGetThen()
.equals(other.getGetThen());
break;
case 20:
result = result && getGetRelationshipTypesThatRelateRole()
.equals(other.getGetRelationshipTypesThatRelateRole());
break;
case 21:
result = result && getGetTypesThatPlayRole()
.equals(other.getGetTypesThatPlayRole());
break;
case 30:
result = result && getGetInstances()
.equals(other.getGetInstances());
break;
case 11:
result = result && getGetAttributeTypes()
.equals(other.getGetAttributeTypes());
break;
case 25:
result = result && getSetAttributeType()
.equals(other.getSetAttributeType());
break;
case 26:
result = result && getUnsetAttributeType()
.equals(other.getUnsetAttributeType());
break;
case 12:
result = result && getGetKeyTypes()
.equals(other.getGetKeyTypes());
break;
case 27:
result = result && getSetKeyType()
.equals(other.getSetKeyType());
break;
case 28:
result = result && getUnsetKeyType()
.equals(other.getUnsetKeyType());
break;
case 6:
result = result && getIsAbstract()
.equals(other.getIsAbstract());
break;
case 22:
result = result && (getSetAbstract()
== other.getSetAbstract());
break;
case 29:
result = result && getGetRolesPlayedByType()
.equals(other.getGetRolesPlayedByType());
break;
case 23:
result = result && getSetRolePlayedByType()
.equals(other.getSetRolePlayedByType());
break;
case 24:
result = result && getUnsetRolePlayedByType()
.equals(other.getUnsetRolePlayedByType());
break;
case 34:
result = result && getAddEntity()
.equals(other.getAddEntity());
break;
case 36:
result = result && getGetRelatedRoles()
.equals(other.getGetRelatedRoles());
break;
case 37:
result = result && getSetRelatedRole()
.equals(other.getSetRelatedRole());
break;
case 38:
result = result && getUnsetRelatedRole()
.equals(other.getUnsetRelatedRole());
break;
case 32:
result = result && getPutAttribute()
.equals(other.getPutAttribute());
break;
case 33:
result = result && getGetAttribute()
.equals(other.getGetAttribute());
break;
case 2:
result = result && getGetDataTypeOfType()
.equals(other.getGetDataTypeOfType());
break;
case 54:
result = result && getGetDataTypeOfAttribute()
.equals(other.getGetDataTypeOfAttribute());
break;
case 9:
result = result && getGetRegex()
.equals(other.getGetRegex());
break;
case 31:
result = result && getSetRegex()
.equals(other.getSetRegex());
break;
case 5:
result = result && getIsInferred()
.equals(other.getIsInferred());
break;
case 13:
result = result && getGetDirectType()
.equals(other.getGetDirectType());
break;
case 39:
result = result && getGetRelationships()
.equals(other.getGetRelationships());
break;
case 48:
result = result && getGetRelationshipsByRoles()
.equals(other.getGetRelationshipsByRoles());
break;
case 40:
result = result && getGetRolesPlayedByThing()
.equals(other.getGetRolesPlayedByThing());
break;
case 41:
result = result && getGetAttributes()
.equals(other.getGetAttributes());
break;
case 49:
result = result && getGetAttributesByTypes()
.equals(other.getGetAttributesByTypes());
break;
case 42:
result = result && getGetKeys()
.equals(other.getGetKeys());
break;
case 50:
result = result && getGetKeysByTypes()
.equals(other.getGetKeysByTypes());
break;
case 43:
result = result && getSetAttribute()
.equals(other.getSetAttribute());
break;
case 44:
result = result && getUnsetAttribute()
.equals(other.getUnsetAttribute());
break;
case 35:
result = result && getAddRelationship()
.equals(other.getAddRelationship());
break;
case 10:
result = result && getGetRolePlayers()
.equals(other.getGetRolePlayers());
break;
case 51:
result = result && getGetRolePlayersByRoles()
.equals(other.getGetRolePlayersByRoles());
break;
case 46:
result = result && getSetRolePlayer()
.equals(other.getSetRolePlayer());
break;
case 15:
result = result && getUnsetRolePlayer()
.equals(other.getUnsetRolePlayer());
break;
case 1:
result = result && getGetValue()
.equals(other.getGetValue());
break;
case 47:
result = result && getGetOwners()
.equals(other.getGetOwners());
break;
case 0:
default:
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
switch (conceptMethodCase_) {
case 16:
hash = (37 * hash) + DELETE_FIELD_NUMBER;
hash = (53 * hash) + getDelete().hashCode();
break;
case 3:
hash = (37 * hash) + GETLABEL_FIELD_NUMBER;
hash = (53 * hash) + getGetLabel().hashCode();
break;
case 18:
hash = (37 * hash) + SETLABEL_FIELD_NUMBER;
hash = (53 * hash) + getSetLabel().hashCode();
break;
case 4:
hash = (37 * hash) + ISIMPLICIT_FIELD_NUMBER;
hash = (53 * hash) + getIsImplicit().hashCode();
break;
case 19:
hash = (37 * hash) + GETSUBCONCEPTS_FIELD_NUMBER;
hash = (53 * hash) + getGetSubConcepts().hashCode();
break;
case 53:
hash = (37 * hash) + GETSUPERCONCEPTS_FIELD_NUMBER;
hash = (53 * hash) + getGetSuperConcepts().hashCode();
break;
case 14:
hash = (37 * hash) + GETDIRECTSUPERCONCEPT_FIELD_NUMBER;
hash = (53 * hash) + getGetDirectSuperConcept().hashCode();
break;
case 17:
hash = (37 * hash) + SETDIRECTSUPERCONCEPT_FIELD_NUMBER;
hash = (53 * hash) + getSetDirectSuperConcept().hashCode();
break;
case 7:
hash = (37 * hash) + GETWHEN_FIELD_NUMBER;
hash = (53 * hash) + getGetWhen().hashCode();
break;
case 8:
hash = (37 * hash) + GETTHEN_FIELD_NUMBER;
hash = (53 * hash) + getGetThen().hashCode();
break;
case 20:
hash = (37 * hash) + GETRELATIONSHIPTYPESTHATRELATEROLE_FIELD_NUMBER;
hash = (53 * hash) + getGetRelationshipTypesThatRelateRole().hashCode();
break;
case 21:
hash = (37 * hash) + GETTYPESTHATPLAYROLE_FIELD_NUMBER;
hash = (53 * hash) + getGetTypesThatPlayRole().hashCode();
break;
case 30:
hash = (37 * hash) + GETINSTANCES_FIELD_NUMBER;
hash = (53 * hash) + getGetInstances().hashCode();
break;
case 11:
hash = (37 * hash) + GETATTRIBUTETYPES_FIELD_NUMBER;
hash = (53 * hash) + getGetAttributeTypes().hashCode();
break;
case 25:
hash = (37 * hash) + SETATTRIBUTETYPE_FIELD_NUMBER;
hash = (53 * hash) + getSetAttributeType().hashCode();
break;
case 26:
hash = (37 * hash) + UNSETATTRIBUTETYPE_FIELD_NUMBER;
hash = (53 * hash) + getUnsetAttributeType().hashCode();
break;
case 12:
hash = (37 * hash) + GETKEYTYPES_FIELD_NUMBER;
hash = (53 * hash) + getGetKeyTypes().hashCode();
break;
case 27:
hash = (37 * hash) + SETKEYTYPE_FIELD_NUMBER;
hash = (53 * hash) + getSetKeyType().hashCode();
break;
case 28:
hash = (37 * hash) + UNSETKEYTYPE_FIELD_NUMBER;
hash = (53 * hash) + getUnsetKeyType().hashCode();
break;
case 6:
hash = (37 * hash) + ISABSTRACT_FIELD_NUMBER;
hash = (53 * hash) + getIsAbstract().hashCode();
break;
case 22:
hash = (37 * hash) + SETABSTRACT_FIELD_NUMBER;
hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
getSetAbstract());
break;
case 29:
hash = (37 * hash) + GETROLESPLAYEDBYTYPE_FIELD_NUMBER;
hash = (53 * hash) + getGetRolesPlayedByType().hashCode();
break;
case 23:
hash = (37 * hash) + SETROLEPLAYEDBYTYPE_FIELD_NUMBER;
hash = (53 * hash) + getSetRolePlayedByType().hashCode();
break;
case 24:
hash = (37 * hash) + UNSETROLEPLAYEDBYTYPE_FIELD_NUMBER;
hash = (53 * hash) + getUnsetRolePlayedByType().hashCode();
break;
case 34:
hash = (37 * hash) + ADDENTITY_FIELD_NUMBER;
hash = (53 * hash) + getAddEntity().hashCode();
break;
case 36:
hash = (37 * hash) + GETRELATEDROLES_FIELD_NUMBER;
hash = (53 * hash) + getGetRelatedRoles().hashCode();
break;
case 37:
hash = (37 * hash) + SETRELATEDROLE_FIELD_NUMBER;
hash = (53 * hash) + getSetRelatedRole().hashCode();
break;
case 38:
hash = (37 * hash) + UNSETRELATEDROLE_FIELD_NUMBER;
hash = (53 * hash) + getUnsetRelatedRole().hashCode();
break;
case 32:
hash = (37 * hash) + PUTATTRIBUTE_FIELD_NUMBER;
hash = (53 * hash) + getPutAttribute().hashCode();
break;
case 33:
hash = (37 * hash) + GETATTRIBUTE_FIELD_NUMBER;
hash = (53 * hash) + getGetAttribute().hashCode();
break;
case 2:
hash = (37 * hash) + GETDATATYPEOFTYPE_FIELD_NUMBER;
hash = (53 * hash) + getGetDataTypeOfType().hashCode();
break;
case 54:
hash = (37 * hash) + GETDATATYPEOFATTRIBUTE_FIELD_NUMBER;
hash = (53 * hash) + getGetDataTypeOfAttribute().hashCode();
break;
case 9:
hash = (37 * hash) + GETREGEX_FIELD_NUMBER;
hash = (53 * hash) + getGetRegex().hashCode();
break;
case 31:
hash = (37 * hash) + SETREGEX_FIELD_NUMBER;
hash = (53 * hash) + getSetRegex().hashCode();
break;
case 5:
hash = (37 * hash) + ISINFERRED_FIELD_NUMBER;
hash = (53 * hash) + getIsInferred().hashCode();
break;
case 13:
hash = (37 * hash) + GETDIRECTTYPE_FIELD_NUMBER;
hash = (53 * hash) + getGetDirectType().hashCode();
break;
case 39:
hash = (37 * hash) + GETRELATIONSHIPS_FIELD_NUMBER;
hash = (53 * hash) + getGetRelationships().hashCode();
break;
case 48:
hash = (37 * hash) + GETRELATIONSHIPSBYROLES_FIELD_NUMBER;
hash = (53 * hash) + getGetRelationshipsByRoles().hashCode();
break;
case 40:
hash = (37 * hash) + GETROLESPLAYEDBYTHING_FIELD_NUMBER;
hash = (53 * hash) + getGetRolesPlayedByThing().hashCode();
break;
case 41:
hash = (37 * hash) + GETATTRIBUTES_FIELD_NUMBER;
hash = (53 * hash) + getGetAttributes().hashCode();
break;
case 49:
hash = (37 * hash) + GETATTRIBUTESBYTYPES_FIELD_NUMBER;
hash = (53 * hash) + getGetAttributesByTypes().hashCode();
break;
case 42:
hash = (37 * hash) + GETKEYS_FIELD_NUMBER;
hash = (53 * hash) + getGetKeys().hashCode();
break;
case 50:
hash = (37 * hash) + GETKEYSBYTYPES_FIELD_NUMBER;
hash = (53 * hash) + getGetKeysByTypes().hashCode();
break;
case 43:
hash = (37 * hash) + SETATTRIBUTE_FIELD_NUMBER;
hash = (53 * hash) + getSetAttribute().hashCode();
break;
case 44:
hash = (37 * hash) + UNSETATTRIBUTE_FIELD_NUMBER;
hash = (53 * hash) + getUnsetAttribute().hashCode();
break;
case 35:
hash = (37 * hash) + ADDRELATIONSHIP_FIELD_NUMBER;
hash = (53 * hash) + getAddRelationship().hashCode();
break;
case 10:
hash = (37 * hash) + GETROLEPLAYERS_FIELD_NUMBER;
hash = (53 * hash) + getGetRolePlayers().hashCode();
break;
case 51:
hash = (37 * hash) + GETROLEPLAYERSBYROLES_FIELD_NUMBER;
hash = (53 * hash) + getGetRolePlayersByRoles().hashCode();
break;
case 46:
hash = (37 * hash) + SETROLEPLAYER_FIELD_NUMBER;
hash = (53 * hash) + getSetRolePlayer().hashCode();
break;
case 15:
hash = (37 * hash) + UNSETROLEPLAYER_FIELD_NUMBER;
hash = (53 * hash) + getUnsetRolePlayer().hashCode();
break;
case 1:
hash = (37 * hash) + GETVALUE_FIELD_NUMBER;
hash = (53 * hash) + getGetValue().hashCode();
break;
case 47:
hash = (37 * hash) + GETOWNERS_FIELD_NUMBER;
hash = (53 * hash) + getGetOwners().hashCode();
break;
case 0:
default:
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptMethod parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptMethod parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptMethod parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptMethod parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptMethod parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptMethod parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptMethod parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptMethod parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptMethod parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptMethod parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.ConceptMethod prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.ConceptMethod}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.ConceptMethod)
ai.grakn.rpc.generated.GrpcConcept.ConceptMethodOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptMethod_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptMethod_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.class, ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
conceptMethodCase_ = 0;
conceptMethod_ = null;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptMethod_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.ConceptMethod getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.ConceptMethod build() {
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.ConceptMethod buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod result = new ai.grakn.rpc.generated.GrpcConcept.ConceptMethod(this);
if (conceptMethodCase_ == 16) {
if (deleteBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = deleteBuilder_.build();
}
}
if (conceptMethodCase_ == 3) {
if (getLabelBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getLabelBuilder_.build();
}
}
if (conceptMethodCase_ == 18) {
if (setLabelBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = setLabelBuilder_.build();
}
}
if (conceptMethodCase_ == 4) {
if (isImplicitBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = isImplicitBuilder_.build();
}
}
if (conceptMethodCase_ == 19) {
if (getSubConceptsBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getSubConceptsBuilder_.build();
}
}
if (conceptMethodCase_ == 53) {
if (getSuperConceptsBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getSuperConceptsBuilder_.build();
}
}
if (conceptMethodCase_ == 14) {
if (getDirectSuperConceptBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getDirectSuperConceptBuilder_.build();
}
}
if (conceptMethodCase_ == 17) {
if (setDirectSuperConceptBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = setDirectSuperConceptBuilder_.build();
}
}
if (conceptMethodCase_ == 7) {
if (getWhenBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getWhenBuilder_.build();
}
}
if (conceptMethodCase_ == 8) {
if (getThenBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getThenBuilder_.build();
}
}
if (conceptMethodCase_ == 20) {
if (getRelationshipTypesThatRelateRoleBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getRelationshipTypesThatRelateRoleBuilder_.build();
}
}
if (conceptMethodCase_ == 21) {
if (getTypesThatPlayRoleBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getTypesThatPlayRoleBuilder_.build();
}
}
if (conceptMethodCase_ == 30) {
if (getInstancesBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getInstancesBuilder_.build();
}
}
if (conceptMethodCase_ == 11) {
if (getAttributeTypesBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getAttributeTypesBuilder_.build();
}
}
if (conceptMethodCase_ == 25) {
if (setAttributeTypeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = setAttributeTypeBuilder_.build();
}
}
if (conceptMethodCase_ == 26) {
if (unsetAttributeTypeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = unsetAttributeTypeBuilder_.build();
}
}
if (conceptMethodCase_ == 12) {
if (getKeyTypesBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getKeyTypesBuilder_.build();
}
}
if (conceptMethodCase_ == 27) {
if (setKeyTypeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = setKeyTypeBuilder_.build();
}
}
if (conceptMethodCase_ == 28) {
if (unsetKeyTypeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = unsetKeyTypeBuilder_.build();
}
}
if (conceptMethodCase_ == 6) {
if (isAbstractBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = isAbstractBuilder_.build();
}
}
if (conceptMethodCase_ == 22) {
result.conceptMethod_ = conceptMethod_;
}
if (conceptMethodCase_ == 29) {
if (getRolesPlayedByTypeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getRolesPlayedByTypeBuilder_.build();
}
}
if (conceptMethodCase_ == 23) {
if (setRolePlayedByTypeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = setRolePlayedByTypeBuilder_.build();
}
}
if (conceptMethodCase_ == 24) {
if (unsetRolePlayedByTypeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = unsetRolePlayedByTypeBuilder_.build();
}
}
if (conceptMethodCase_ == 34) {
if (addEntityBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = addEntityBuilder_.build();
}
}
if (conceptMethodCase_ == 36) {
if (getRelatedRolesBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getRelatedRolesBuilder_.build();
}
}
if (conceptMethodCase_ == 37) {
if (setRelatedRoleBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = setRelatedRoleBuilder_.build();
}
}
if (conceptMethodCase_ == 38) {
if (unsetRelatedRoleBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = unsetRelatedRoleBuilder_.build();
}
}
if (conceptMethodCase_ == 32) {
if (putAttributeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = putAttributeBuilder_.build();
}
}
if (conceptMethodCase_ == 33) {
if (getAttributeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getAttributeBuilder_.build();
}
}
if (conceptMethodCase_ == 2) {
if (getDataTypeOfTypeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getDataTypeOfTypeBuilder_.build();
}
}
if (conceptMethodCase_ == 54) {
if (getDataTypeOfAttributeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getDataTypeOfAttributeBuilder_.build();
}
}
if (conceptMethodCase_ == 9) {
if (getRegexBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getRegexBuilder_.build();
}
}
if (conceptMethodCase_ == 31) {
if (setRegexBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = setRegexBuilder_.build();
}
}
if (conceptMethodCase_ == 5) {
if (isInferredBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = isInferredBuilder_.build();
}
}
if (conceptMethodCase_ == 13) {
if (getDirectTypeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getDirectTypeBuilder_.build();
}
}
if (conceptMethodCase_ == 39) {
if (getRelationshipsBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getRelationshipsBuilder_.build();
}
}
if (conceptMethodCase_ == 48) {
if (getRelationshipsByRolesBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getRelationshipsByRolesBuilder_.build();
}
}
if (conceptMethodCase_ == 40) {
if (getRolesPlayedByThingBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getRolesPlayedByThingBuilder_.build();
}
}
if (conceptMethodCase_ == 41) {
if (getAttributesBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getAttributesBuilder_.build();
}
}
if (conceptMethodCase_ == 49) {
if (getAttributesByTypesBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getAttributesByTypesBuilder_.build();
}
}
if (conceptMethodCase_ == 42) {
if (getKeysBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getKeysBuilder_.build();
}
}
if (conceptMethodCase_ == 50) {
if (getKeysByTypesBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getKeysByTypesBuilder_.build();
}
}
if (conceptMethodCase_ == 43) {
if (setAttributeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = setAttributeBuilder_.build();
}
}
if (conceptMethodCase_ == 44) {
if (unsetAttributeBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = unsetAttributeBuilder_.build();
}
}
if (conceptMethodCase_ == 35) {
if (addRelationshipBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = addRelationshipBuilder_.build();
}
}
if (conceptMethodCase_ == 10) {
if (getRolePlayersBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getRolePlayersBuilder_.build();
}
}
if (conceptMethodCase_ == 51) {
if (getRolePlayersByRolesBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getRolePlayersByRolesBuilder_.build();
}
}
if (conceptMethodCase_ == 46) {
if (setRolePlayerBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = setRolePlayerBuilder_.build();
}
}
if (conceptMethodCase_ == 15) {
if (unsetRolePlayerBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = unsetRolePlayerBuilder_.build();
}
}
if (conceptMethodCase_ == 1) {
if (getValueBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getValueBuilder_.build();
}
}
if (conceptMethodCase_ == 47) {
if (getOwnersBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = getOwnersBuilder_.build();
}
}
result.conceptMethodCase_ = conceptMethodCase_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.ConceptMethod) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.ConceptMethod)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.ConceptMethod other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.getDefaultInstance()) return this;
switch (other.getConceptMethodCase()) {
case DELETE: {
mergeDelete(other.getDelete());
break;
}
case GETLABEL: {
mergeGetLabel(other.getGetLabel());
break;
}
case SETLABEL: {
mergeSetLabel(other.getSetLabel());
break;
}
case ISIMPLICIT: {
mergeIsImplicit(other.getIsImplicit());
break;
}
case GETSUBCONCEPTS: {
mergeGetSubConcepts(other.getGetSubConcepts());
break;
}
case GETSUPERCONCEPTS: {
mergeGetSuperConcepts(other.getGetSuperConcepts());
break;
}
case GETDIRECTSUPERCONCEPT: {
mergeGetDirectSuperConcept(other.getGetDirectSuperConcept());
break;
}
case SETDIRECTSUPERCONCEPT: {
mergeSetDirectSuperConcept(other.getSetDirectSuperConcept());
break;
}
case GETWHEN: {
mergeGetWhen(other.getGetWhen());
break;
}
case GETTHEN: {
mergeGetThen(other.getGetThen());
break;
}
case GETRELATIONSHIPTYPESTHATRELATEROLE: {
mergeGetRelationshipTypesThatRelateRole(other.getGetRelationshipTypesThatRelateRole());
break;
}
case GETTYPESTHATPLAYROLE: {
mergeGetTypesThatPlayRole(other.getGetTypesThatPlayRole());
break;
}
case GETINSTANCES: {
mergeGetInstances(other.getGetInstances());
break;
}
case GETATTRIBUTETYPES: {
mergeGetAttributeTypes(other.getGetAttributeTypes());
break;
}
case SETATTRIBUTETYPE: {
mergeSetAttributeType(other.getSetAttributeType());
break;
}
case UNSETATTRIBUTETYPE: {
mergeUnsetAttributeType(other.getUnsetAttributeType());
break;
}
case GETKEYTYPES: {
mergeGetKeyTypes(other.getGetKeyTypes());
break;
}
case SETKEYTYPE: {
mergeSetKeyType(other.getSetKeyType());
break;
}
case UNSETKEYTYPE: {
mergeUnsetKeyType(other.getUnsetKeyType());
break;
}
case ISABSTRACT: {
mergeIsAbstract(other.getIsAbstract());
break;
}
case SETABSTRACT: {
setSetAbstract(other.getSetAbstract());
break;
}
case GETROLESPLAYEDBYTYPE: {
mergeGetRolesPlayedByType(other.getGetRolesPlayedByType());
break;
}
case SETROLEPLAYEDBYTYPE: {
mergeSetRolePlayedByType(other.getSetRolePlayedByType());
break;
}
case UNSETROLEPLAYEDBYTYPE: {
mergeUnsetRolePlayedByType(other.getUnsetRolePlayedByType());
break;
}
case ADDENTITY: {
mergeAddEntity(other.getAddEntity());
break;
}
case GETRELATEDROLES: {
mergeGetRelatedRoles(other.getGetRelatedRoles());
break;
}
case SETRELATEDROLE: {
mergeSetRelatedRole(other.getSetRelatedRole());
break;
}
case UNSETRELATEDROLE: {
mergeUnsetRelatedRole(other.getUnsetRelatedRole());
break;
}
case PUTATTRIBUTE: {
mergePutAttribute(other.getPutAttribute());
break;
}
case GETATTRIBUTE: {
mergeGetAttribute(other.getGetAttribute());
break;
}
case GETDATATYPEOFTYPE: {
mergeGetDataTypeOfType(other.getGetDataTypeOfType());
break;
}
case GETDATATYPEOFATTRIBUTE: {
mergeGetDataTypeOfAttribute(other.getGetDataTypeOfAttribute());
break;
}
case GETREGEX: {
mergeGetRegex(other.getGetRegex());
break;
}
case SETREGEX: {
mergeSetRegex(other.getSetRegex());
break;
}
case ISINFERRED: {
mergeIsInferred(other.getIsInferred());
break;
}
case GETDIRECTTYPE: {
mergeGetDirectType(other.getGetDirectType());
break;
}
case GETRELATIONSHIPS: {
mergeGetRelationships(other.getGetRelationships());
break;
}
case GETRELATIONSHIPSBYROLES: {
mergeGetRelationshipsByRoles(other.getGetRelationshipsByRoles());
break;
}
case GETROLESPLAYEDBYTHING: {
mergeGetRolesPlayedByThing(other.getGetRolesPlayedByThing());
break;
}
case GETATTRIBUTES: {
mergeGetAttributes(other.getGetAttributes());
break;
}
case GETATTRIBUTESBYTYPES: {
mergeGetAttributesByTypes(other.getGetAttributesByTypes());
break;
}
case GETKEYS: {
mergeGetKeys(other.getGetKeys());
break;
}
case GETKEYSBYTYPES: {
mergeGetKeysByTypes(other.getGetKeysByTypes());
break;
}
case SETATTRIBUTE: {
mergeSetAttribute(other.getSetAttribute());
break;
}
case UNSETATTRIBUTE: {
mergeUnsetAttribute(other.getUnsetAttribute());
break;
}
case ADDRELATIONSHIP: {
mergeAddRelationship(other.getAddRelationship());
break;
}
case GETROLEPLAYERS: {
mergeGetRolePlayers(other.getGetRolePlayers());
break;
}
case GETROLEPLAYERSBYROLES: {
mergeGetRolePlayersByRoles(other.getGetRolePlayersByRoles());
break;
}
case SETROLEPLAYER: {
mergeSetRolePlayer(other.getSetRolePlayer());
break;
}
case UNSETROLEPLAYER: {
mergeUnsetRolePlayer(other.getUnsetRolePlayer());
break;
}
case GETVALUE: {
mergeGetValue(other.getGetValue());
break;
}
case GETOWNERS: {
mergeGetOwners(other.getGetOwners());
break;
}
case CONCEPTMETHOD_NOT_SET: {
break;
}
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.ConceptMethod) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int conceptMethodCase_ = 0;
private java.lang.Object conceptMethod_;
public ConceptMethodCase
getConceptMethodCase() {
return ConceptMethodCase.forNumber(
conceptMethodCase_);
}
public Builder clearConceptMethod() {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> deleteBuilder_;
/**
* <pre>
* Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit delete = 16;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getDelete() {
if (deleteBuilder_ == null) {
if (conceptMethodCase_ == 16) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 16) {
return deleteBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit delete = 16;</code>
*/
public Builder setDelete(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (deleteBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
deleteBuilder_.setMessage(value);
}
conceptMethodCase_ = 16;
return this;
}
/**
* <pre>
* Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit delete = 16;</code>
*/
public Builder setDelete(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (deleteBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
deleteBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 16;
return this;
}
/**
* <pre>
* Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit delete = 16;</code>
*/
public Builder mergeDelete(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (deleteBuilder_ == null) {
if (conceptMethodCase_ == 16 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 16) {
deleteBuilder_.mergeFrom(value);
}
deleteBuilder_.setMessage(value);
}
conceptMethodCase_ = 16;
return this;
}
/**
* <pre>
* Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit delete = 16;</code>
*/
public Builder clearDelete() {
if (deleteBuilder_ == null) {
if (conceptMethodCase_ == 16) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 16) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
deleteBuilder_.clear();
}
return this;
}
/**
* <pre>
* Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit delete = 16;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getDeleteBuilder() {
return getDeleteFieldBuilder().getBuilder();
}
/**
* <pre>
* Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit delete = 16;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getDeleteOrBuilder() {
if ((conceptMethodCase_ == 16) && (deleteBuilder_ != null)) {
return deleteBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 16) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit delete = 16;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getDeleteFieldBuilder() {
if (deleteBuilder_ == null) {
if (!(conceptMethodCase_ == 16)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
deleteBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 16;
onChanged();;
return deleteBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getLabelBuilder_;
/**
* <pre>
* Schema concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getLabel = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetLabel() {
if (getLabelBuilder_ == null) {
if (conceptMethodCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 3) {
return getLabelBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Schema concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getLabel = 3;</code>
*/
public Builder setGetLabel(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getLabelBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getLabelBuilder_.setMessage(value);
}
conceptMethodCase_ = 3;
return this;
}
/**
* <pre>
* Schema concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getLabel = 3;</code>
*/
public Builder setGetLabel(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getLabelBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getLabelBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 3;
return this;
}
/**
* <pre>
* Schema concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getLabel = 3;</code>
*/
public Builder mergeGetLabel(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getLabelBuilder_ == null) {
if (conceptMethodCase_ == 3 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 3) {
getLabelBuilder_.mergeFrom(value);
}
getLabelBuilder_.setMessage(value);
}
conceptMethodCase_ = 3;
return this;
}
/**
* <pre>
* Schema concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getLabel = 3;</code>
*/
public Builder clearGetLabel() {
if (getLabelBuilder_ == null) {
if (conceptMethodCase_ == 3) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 3) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getLabelBuilder_.clear();
}
return this;
}
/**
* <pre>
* Schema concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getLabel = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetLabelBuilder() {
return getGetLabelFieldBuilder().getBuilder();
}
/**
* <pre>
* Schema concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getLabel = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetLabelOrBuilder() {
if ((conceptMethodCase_ == 3) && (getLabelBuilder_ != null)) {
return getLabelBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Schema concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getLabel = 3;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetLabelFieldBuilder() {
if (getLabelBuilder_ == null) {
if (!(conceptMethodCase_ == 3)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getLabelBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 3;
onChanged();;
return getLabelBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder> setLabelBuilder_;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label setLabel = 18;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getSetLabel() {
if (setLabelBuilder_ == null) {
if (conceptMethodCase_ == 18) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
} else {
if (conceptMethodCase_ == 18) {
return setLabelBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label setLabel = 18;</code>
*/
public Builder setSetLabel(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (setLabelBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
setLabelBuilder_.setMessage(value);
}
conceptMethodCase_ = 18;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label setLabel = 18;</code>
*/
public Builder setSetLabel(
ai.grakn.rpc.generated.GrpcConcept.Label.Builder builderForValue) {
if (setLabelBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
setLabelBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 18;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label setLabel = 18;</code>
*/
public Builder mergeSetLabel(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (setLabelBuilder_ == null) {
if (conceptMethodCase_ == 18 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Label.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Label) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 18) {
setLabelBuilder_.mergeFrom(value);
}
setLabelBuilder_.setMessage(value);
}
conceptMethodCase_ = 18;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label setLabel = 18;</code>
*/
public Builder clearSetLabel() {
if (setLabelBuilder_ == null) {
if (conceptMethodCase_ == 18) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 18) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
setLabelBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label setLabel = 18;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label.Builder getSetLabelBuilder() {
return getSetLabelFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label setLabel = 18;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getSetLabelOrBuilder() {
if ((conceptMethodCase_ == 18) && (setLabelBuilder_ != null)) {
return setLabelBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 18) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label setLabel = 18;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>
getSetLabelFieldBuilder() {
if (setLabelBuilder_ == null) {
if (!(conceptMethodCase_ == 18)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
setLabelBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Label) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 18;
onChanged();;
return setLabelBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> isImplicitBuilder_;
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isImplicit = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getIsImplicit() {
if (isImplicitBuilder_ == null) {
if (conceptMethodCase_ == 4) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 4) {
return isImplicitBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isImplicit = 4;</code>
*/
public Builder setIsImplicit(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (isImplicitBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
isImplicitBuilder_.setMessage(value);
}
conceptMethodCase_ = 4;
return this;
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isImplicit = 4;</code>
*/
public Builder setIsImplicit(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (isImplicitBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
isImplicitBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 4;
return this;
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isImplicit = 4;</code>
*/
public Builder mergeIsImplicit(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (isImplicitBuilder_ == null) {
if (conceptMethodCase_ == 4 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 4) {
isImplicitBuilder_.mergeFrom(value);
}
isImplicitBuilder_.setMessage(value);
}
conceptMethodCase_ = 4;
return this;
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isImplicit = 4;</code>
*/
public Builder clearIsImplicit() {
if (isImplicitBuilder_ == null) {
if (conceptMethodCase_ == 4) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 4) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
isImplicitBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isImplicit = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getIsImplicitBuilder() {
return getIsImplicitFieldBuilder().getBuilder();
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isImplicit = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getIsImplicitOrBuilder() {
if ((conceptMethodCase_ == 4) && (isImplicitBuilder_ != null)) {
return isImplicitBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 4) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isImplicit = 4;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getIsImplicitFieldBuilder() {
if (isImplicitBuilder_ == null) {
if (!(conceptMethodCase_ == 4)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
isImplicitBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 4;
onChanged();;
return isImplicitBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getSubConceptsBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSubConcepts = 19;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetSubConcepts() {
if (getSubConceptsBuilder_ == null) {
if (conceptMethodCase_ == 19) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 19) {
return getSubConceptsBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSubConcepts = 19;</code>
*/
public Builder setGetSubConcepts(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getSubConceptsBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getSubConceptsBuilder_.setMessage(value);
}
conceptMethodCase_ = 19;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSubConcepts = 19;</code>
*/
public Builder setGetSubConcepts(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getSubConceptsBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getSubConceptsBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 19;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSubConcepts = 19;</code>
*/
public Builder mergeGetSubConcepts(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getSubConceptsBuilder_ == null) {
if (conceptMethodCase_ == 19 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 19) {
getSubConceptsBuilder_.mergeFrom(value);
}
getSubConceptsBuilder_.setMessage(value);
}
conceptMethodCase_ = 19;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSubConcepts = 19;</code>
*/
public Builder clearGetSubConcepts() {
if (getSubConceptsBuilder_ == null) {
if (conceptMethodCase_ == 19) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 19) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getSubConceptsBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSubConcepts = 19;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetSubConceptsBuilder() {
return getGetSubConceptsFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSubConcepts = 19;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetSubConceptsOrBuilder() {
if ((conceptMethodCase_ == 19) && (getSubConceptsBuilder_ != null)) {
return getSubConceptsBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 19) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSubConcepts = 19;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetSubConceptsFieldBuilder() {
if (getSubConceptsBuilder_ == null) {
if (!(conceptMethodCase_ == 19)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getSubConceptsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 19;
onChanged();;
return getSubConceptsBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getSuperConceptsBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSuperConcepts = 53;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetSuperConcepts() {
if (getSuperConceptsBuilder_ == null) {
if (conceptMethodCase_ == 53) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 53) {
return getSuperConceptsBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSuperConcepts = 53;</code>
*/
public Builder setGetSuperConcepts(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getSuperConceptsBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getSuperConceptsBuilder_.setMessage(value);
}
conceptMethodCase_ = 53;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSuperConcepts = 53;</code>
*/
public Builder setGetSuperConcepts(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getSuperConceptsBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getSuperConceptsBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 53;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSuperConcepts = 53;</code>
*/
public Builder mergeGetSuperConcepts(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getSuperConceptsBuilder_ == null) {
if (conceptMethodCase_ == 53 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 53) {
getSuperConceptsBuilder_.mergeFrom(value);
}
getSuperConceptsBuilder_.setMessage(value);
}
conceptMethodCase_ = 53;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSuperConcepts = 53;</code>
*/
public Builder clearGetSuperConcepts() {
if (getSuperConceptsBuilder_ == null) {
if (conceptMethodCase_ == 53) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 53) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getSuperConceptsBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSuperConcepts = 53;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetSuperConceptsBuilder() {
return getGetSuperConceptsFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSuperConcepts = 53;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetSuperConceptsOrBuilder() {
if ((conceptMethodCase_ == 53) && (getSuperConceptsBuilder_ != null)) {
return getSuperConceptsBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 53) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getSuperConcepts = 53;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetSuperConceptsFieldBuilder() {
if (getSuperConceptsBuilder_ == null) {
if (!(conceptMethodCase_ == 53)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getSuperConceptsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 53;
onChanged();;
return getSuperConceptsBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getDirectSuperConceptBuilder_;
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectSuperConcept = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetDirectSuperConcept() {
if (getDirectSuperConceptBuilder_ == null) {
if (conceptMethodCase_ == 14) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 14) {
return getDirectSuperConceptBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectSuperConcept = 14;</code>
*/
public Builder setGetDirectSuperConcept(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getDirectSuperConceptBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getDirectSuperConceptBuilder_.setMessage(value);
}
conceptMethodCase_ = 14;
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectSuperConcept = 14;</code>
*/
public Builder setGetDirectSuperConcept(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getDirectSuperConceptBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getDirectSuperConceptBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 14;
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectSuperConcept = 14;</code>
*/
public Builder mergeGetDirectSuperConcept(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getDirectSuperConceptBuilder_ == null) {
if (conceptMethodCase_ == 14 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 14) {
getDirectSuperConceptBuilder_.mergeFrom(value);
}
getDirectSuperConceptBuilder_.setMessage(value);
}
conceptMethodCase_ = 14;
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectSuperConcept = 14;</code>
*/
public Builder clearGetDirectSuperConcept() {
if (getDirectSuperConceptBuilder_ == null) {
if (conceptMethodCase_ == 14) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 14) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getDirectSuperConceptBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectSuperConcept = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetDirectSuperConceptBuilder() {
return getGetDirectSuperConceptFieldBuilder().getBuilder();
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectSuperConcept = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetDirectSuperConceptOrBuilder() {
if ((conceptMethodCase_ == 14) && (getDirectSuperConceptBuilder_ != null)) {
return getDirectSuperConceptBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 14) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectSuperConcept = 14;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetDirectSuperConceptFieldBuilder() {
if (getDirectSuperConceptBuilder_ == null) {
if (!(conceptMethodCase_ == 14)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getDirectSuperConceptBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 14;
onChanged();;
return getDirectSuperConceptBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> setDirectSuperConceptBuilder_;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setDirectSuperConcept = 17;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getSetDirectSuperConcept() {
if (setDirectSuperConceptBuilder_ == null) {
if (conceptMethodCase_ == 17) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (conceptMethodCase_ == 17) {
return setDirectSuperConceptBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setDirectSuperConcept = 17;</code>
*/
public Builder setSetDirectSuperConcept(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (setDirectSuperConceptBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
setDirectSuperConceptBuilder_.setMessage(value);
}
conceptMethodCase_ = 17;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setDirectSuperConcept = 17;</code>
*/
public Builder setSetDirectSuperConcept(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (setDirectSuperConceptBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
setDirectSuperConceptBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 17;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setDirectSuperConcept = 17;</code>
*/
public Builder mergeSetDirectSuperConcept(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (setDirectSuperConceptBuilder_ == null) {
if (conceptMethodCase_ == 17 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 17) {
setDirectSuperConceptBuilder_.mergeFrom(value);
}
setDirectSuperConceptBuilder_.setMessage(value);
}
conceptMethodCase_ = 17;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setDirectSuperConcept = 17;</code>
*/
public Builder clearSetDirectSuperConcept() {
if (setDirectSuperConceptBuilder_ == null) {
if (conceptMethodCase_ == 17) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 17) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
setDirectSuperConceptBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setDirectSuperConcept = 17;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getSetDirectSuperConceptBuilder() {
return getSetDirectSuperConceptFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setDirectSuperConcept = 17;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetDirectSuperConceptOrBuilder() {
if ((conceptMethodCase_ == 17) && (setDirectSuperConceptBuilder_ != null)) {
return setDirectSuperConceptBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 17) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setDirectSuperConcept = 17;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getSetDirectSuperConceptFieldBuilder() {
if (setDirectSuperConceptBuilder_ == null) {
if (!(conceptMethodCase_ == 17)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
setDirectSuperConceptBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 17;
onChanged();;
return setDirectSuperConceptBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getWhenBuilder_;
/**
* <pre>
* Rule
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getWhen = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetWhen() {
if (getWhenBuilder_ == null) {
if (conceptMethodCase_ == 7) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 7) {
return getWhenBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Rule
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getWhen = 7;</code>
*/
public Builder setGetWhen(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getWhenBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getWhenBuilder_.setMessage(value);
}
conceptMethodCase_ = 7;
return this;
}
/**
* <pre>
* Rule
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getWhen = 7;</code>
*/
public Builder setGetWhen(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getWhenBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getWhenBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 7;
return this;
}
/**
* <pre>
* Rule
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getWhen = 7;</code>
*/
public Builder mergeGetWhen(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getWhenBuilder_ == null) {
if (conceptMethodCase_ == 7 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 7) {
getWhenBuilder_.mergeFrom(value);
}
getWhenBuilder_.setMessage(value);
}
conceptMethodCase_ = 7;
return this;
}
/**
* <pre>
* Rule
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getWhen = 7;</code>
*/
public Builder clearGetWhen() {
if (getWhenBuilder_ == null) {
if (conceptMethodCase_ == 7) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 7) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getWhenBuilder_.clear();
}
return this;
}
/**
* <pre>
* Rule
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getWhen = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetWhenBuilder() {
return getGetWhenFieldBuilder().getBuilder();
}
/**
* <pre>
* Rule
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getWhen = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetWhenOrBuilder() {
if ((conceptMethodCase_ == 7) && (getWhenBuilder_ != null)) {
return getWhenBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 7) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Rule
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getWhen = 7;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetWhenFieldBuilder() {
if (getWhenBuilder_ == null) {
if (!(conceptMethodCase_ == 7)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getWhenBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 7;
onChanged();;
return getWhenBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getThenBuilder_;
/**
* <pre>
* returns OptionalPattern
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getThen = 8;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetThen() {
if (getThenBuilder_ == null) {
if (conceptMethodCase_ == 8) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 8) {
return getThenBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalPattern
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getThen = 8;</code>
*/
public Builder setGetThen(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getThenBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getThenBuilder_.setMessage(value);
}
conceptMethodCase_ = 8;
return this;
}
/**
* <pre>
* returns OptionalPattern
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getThen = 8;</code>
*/
public Builder setGetThen(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getThenBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getThenBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 8;
return this;
}
/**
* <pre>
* returns OptionalPattern
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getThen = 8;</code>
*/
public Builder mergeGetThen(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getThenBuilder_ == null) {
if (conceptMethodCase_ == 8 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 8) {
getThenBuilder_.mergeFrom(value);
}
getThenBuilder_.setMessage(value);
}
conceptMethodCase_ = 8;
return this;
}
/**
* <pre>
* returns OptionalPattern
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getThen = 8;</code>
*/
public Builder clearGetThen() {
if (getThenBuilder_ == null) {
if (conceptMethodCase_ == 8) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 8) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getThenBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns OptionalPattern
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getThen = 8;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetThenBuilder() {
return getGetThenFieldBuilder().getBuilder();
}
/**
* <pre>
* returns OptionalPattern
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getThen = 8;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetThenOrBuilder() {
if ((conceptMethodCase_ == 8) && (getThenBuilder_ != null)) {
return getThenBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 8) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalPattern
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getThen = 8;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetThenFieldBuilder() {
if (getThenBuilder_ == null) {
if (!(conceptMethodCase_ == 8)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getThenBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 8;
onChanged();;
return getThenBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getRelationshipTypesThatRelateRoleBuilder_;
/**
* <pre>
* Role
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationshipTypesThatRelateRole = 20;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRelationshipTypesThatRelateRole() {
if (getRelationshipTypesThatRelateRoleBuilder_ == null) {
if (conceptMethodCase_ == 20) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 20) {
return getRelationshipTypesThatRelateRoleBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Role
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationshipTypesThatRelateRole = 20;</code>
*/
public Builder setGetRelationshipTypesThatRelateRole(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRelationshipTypesThatRelateRoleBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getRelationshipTypesThatRelateRoleBuilder_.setMessage(value);
}
conceptMethodCase_ = 20;
return this;
}
/**
* <pre>
* Role
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationshipTypesThatRelateRole = 20;</code>
*/
public Builder setGetRelationshipTypesThatRelateRole(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getRelationshipTypesThatRelateRoleBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getRelationshipTypesThatRelateRoleBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 20;
return this;
}
/**
* <pre>
* Role
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationshipTypesThatRelateRole = 20;</code>
*/
public Builder mergeGetRelationshipTypesThatRelateRole(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRelationshipTypesThatRelateRoleBuilder_ == null) {
if (conceptMethodCase_ == 20 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 20) {
getRelationshipTypesThatRelateRoleBuilder_.mergeFrom(value);
}
getRelationshipTypesThatRelateRoleBuilder_.setMessage(value);
}
conceptMethodCase_ = 20;
return this;
}
/**
* <pre>
* Role
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationshipTypesThatRelateRole = 20;</code>
*/
public Builder clearGetRelationshipTypesThatRelateRole() {
if (getRelationshipTypesThatRelateRoleBuilder_ == null) {
if (conceptMethodCase_ == 20) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 20) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getRelationshipTypesThatRelateRoleBuilder_.clear();
}
return this;
}
/**
* <pre>
* Role
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationshipTypesThatRelateRole = 20;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetRelationshipTypesThatRelateRoleBuilder() {
return getGetRelationshipTypesThatRelateRoleFieldBuilder().getBuilder();
}
/**
* <pre>
* Role
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationshipTypesThatRelateRole = 20;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRelationshipTypesThatRelateRoleOrBuilder() {
if ((conceptMethodCase_ == 20) && (getRelationshipTypesThatRelateRoleBuilder_ != null)) {
return getRelationshipTypesThatRelateRoleBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 20) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Role
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationshipTypesThatRelateRole = 20;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetRelationshipTypesThatRelateRoleFieldBuilder() {
if (getRelationshipTypesThatRelateRoleBuilder_ == null) {
if (!(conceptMethodCase_ == 20)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getRelationshipTypesThatRelateRoleBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 20;
onChanged();;
return getRelationshipTypesThatRelateRoleBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getTypesThatPlayRoleBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getTypesThatPlayRole = 21;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetTypesThatPlayRole() {
if (getTypesThatPlayRoleBuilder_ == null) {
if (conceptMethodCase_ == 21) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 21) {
return getTypesThatPlayRoleBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getTypesThatPlayRole = 21;</code>
*/
public Builder setGetTypesThatPlayRole(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getTypesThatPlayRoleBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getTypesThatPlayRoleBuilder_.setMessage(value);
}
conceptMethodCase_ = 21;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getTypesThatPlayRole = 21;</code>
*/
public Builder setGetTypesThatPlayRole(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getTypesThatPlayRoleBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getTypesThatPlayRoleBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 21;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getTypesThatPlayRole = 21;</code>
*/
public Builder mergeGetTypesThatPlayRole(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getTypesThatPlayRoleBuilder_ == null) {
if (conceptMethodCase_ == 21 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 21) {
getTypesThatPlayRoleBuilder_.mergeFrom(value);
}
getTypesThatPlayRoleBuilder_.setMessage(value);
}
conceptMethodCase_ = 21;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getTypesThatPlayRole = 21;</code>
*/
public Builder clearGetTypesThatPlayRole() {
if (getTypesThatPlayRoleBuilder_ == null) {
if (conceptMethodCase_ == 21) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 21) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getTypesThatPlayRoleBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getTypesThatPlayRole = 21;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetTypesThatPlayRoleBuilder() {
return getGetTypesThatPlayRoleFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getTypesThatPlayRole = 21;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetTypesThatPlayRoleOrBuilder() {
if ((conceptMethodCase_ == 21) && (getTypesThatPlayRoleBuilder_ != null)) {
return getTypesThatPlayRoleBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 21) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getTypesThatPlayRole = 21;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetTypesThatPlayRoleFieldBuilder() {
if (getTypesThatPlayRoleBuilder_ == null) {
if (!(conceptMethodCase_ == 21)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getTypesThatPlayRoleBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 21;
onChanged();;
return getTypesThatPlayRoleBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getInstancesBuilder_;
/**
* <pre>
* Type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getInstances = 30;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetInstances() {
if (getInstancesBuilder_ == null) {
if (conceptMethodCase_ == 30) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 30) {
return getInstancesBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getInstances = 30;</code>
*/
public Builder setGetInstances(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getInstancesBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getInstancesBuilder_.setMessage(value);
}
conceptMethodCase_ = 30;
return this;
}
/**
* <pre>
* Type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getInstances = 30;</code>
*/
public Builder setGetInstances(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getInstancesBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getInstancesBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 30;
return this;
}
/**
* <pre>
* Type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getInstances = 30;</code>
*/
public Builder mergeGetInstances(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getInstancesBuilder_ == null) {
if (conceptMethodCase_ == 30 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 30) {
getInstancesBuilder_.mergeFrom(value);
}
getInstancesBuilder_.setMessage(value);
}
conceptMethodCase_ = 30;
return this;
}
/**
* <pre>
* Type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getInstances = 30;</code>
*/
public Builder clearGetInstances() {
if (getInstancesBuilder_ == null) {
if (conceptMethodCase_ == 30) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 30) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getInstancesBuilder_.clear();
}
return this;
}
/**
* <pre>
* Type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getInstances = 30;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetInstancesBuilder() {
return getGetInstancesFieldBuilder().getBuilder();
}
/**
* <pre>
* Type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getInstances = 30;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetInstancesOrBuilder() {
if ((conceptMethodCase_ == 30) && (getInstancesBuilder_ != null)) {
return getInstancesBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 30) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getInstances = 30;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetInstancesFieldBuilder() {
if (getInstancesBuilder_ == null) {
if (!(conceptMethodCase_ == 30)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getInstancesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 30;
onChanged();;
return getInstancesBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getAttributeTypesBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributeTypes = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetAttributeTypes() {
if (getAttributeTypesBuilder_ == null) {
if (conceptMethodCase_ == 11) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 11) {
return getAttributeTypesBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributeTypes = 11;</code>
*/
public Builder setGetAttributeTypes(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getAttributeTypesBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getAttributeTypesBuilder_.setMessage(value);
}
conceptMethodCase_ = 11;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributeTypes = 11;</code>
*/
public Builder setGetAttributeTypes(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getAttributeTypesBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getAttributeTypesBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 11;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributeTypes = 11;</code>
*/
public Builder mergeGetAttributeTypes(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getAttributeTypesBuilder_ == null) {
if (conceptMethodCase_ == 11 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 11) {
getAttributeTypesBuilder_.mergeFrom(value);
}
getAttributeTypesBuilder_.setMessage(value);
}
conceptMethodCase_ = 11;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributeTypes = 11;</code>
*/
public Builder clearGetAttributeTypes() {
if (getAttributeTypesBuilder_ == null) {
if (conceptMethodCase_ == 11) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 11) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getAttributeTypesBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributeTypes = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetAttributeTypesBuilder() {
return getGetAttributeTypesFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributeTypes = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetAttributeTypesOrBuilder() {
if ((conceptMethodCase_ == 11) && (getAttributeTypesBuilder_ != null)) {
return getAttributeTypesBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 11) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributeTypes = 11;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetAttributeTypesFieldBuilder() {
if (getAttributeTypesBuilder_ == null) {
if (!(conceptMethodCase_ == 11)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getAttributeTypesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 11;
onChanged();;
return getAttributeTypesBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> setAttributeTypeBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Concept setAttributeType = 25;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getSetAttributeType() {
if (setAttributeTypeBuilder_ == null) {
if (conceptMethodCase_ == 25) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (conceptMethodCase_ == 25) {
return setAttributeTypeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept setAttributeType = 25;</code>
*/
public Builder setSetAttributeType(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (setAttributeTypeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
setAttributeTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 25;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept setAttributeType = 25;</code>
*/
public Builder setSetAttributeType(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (setAttributeTypeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
setAttributeTypeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 25;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept setAttributeType = 25;</code>
*/
public Builder mergeSetAttributeType(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (setAttributeTypeBuilder_ == null) {
if (conceptMethodCase_ == 25 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 25) {
setAttributeTypeBuilder_.mergeFrom(value);
}
setAttributeTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 25;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept setAttributeType = 25;</code>
*/
public Builder clearSetAttributeType() {
if (setAttributeTypeBuilder_ == null) {
if (conceptMethodCase_ == 25) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 25) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
setAttributeTypeBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept setAttributeType = 25;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getSetAttributeTypeBuilder() {
return getSetAttributeTypeFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept setAttributeType = 25;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetAttributeTypeOrBuilder() {
if ((conceptMethodCase_ == 25) && (setAttributeTypeBuilder_ != null)) {
return setAttributeTypeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 25) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept setAttributeType = 25;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getSetAttributeTypeFieldBuilder() {
if (setAttributeTypeBuilder_ == null) {
if (!(conceptMethodCase_ == 25)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
setAttributeTypeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 25;
onChanged();;
return setAttributeTypeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> unsetAttributeTypeBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttributeType = 26;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetAttributeType() {
if (unsetAttributeTypeBuilder_ == null) {
if (conceptMethodCase_ == 26) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (conceptMethodCase_ == 26) {
return unsetAttributeTypeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttributeType = 26;</code>
*/
public Builder setUnsetAttributeType(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (unsetAttributeTypeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
unsetAttributeTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 26;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttributeType = 26;</code>
*/
public Builder setUnsetAttributeType(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (unsetAttributeTypeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
unsetAttributeTypeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 26;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttributeType = 26;</code>
*/
public Builder mergeUnsetAttributeType(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (unsetAttributeTypeBuilder_ == null) {
if (conceptMethodCase_ == 26 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 26) {
unsetAttributeTypeBuilder_.mergeFrom(value);
}
unsetAttributeTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 26;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttributeType = 26;</code>
*/
public Builder clearUnsetAttributeType() {
if (unsetAttributeTypeBuilder_ == null) {
if (conceptMethodCase_ == 26) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 26) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
unsetAttributeTypeBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttributeType = 26;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getUnsetAttributeTypeBuilder() {
return getUnsetAttributeTypeFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttributeType = 26;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetAttributeTypeOrBuilder() {
if ((conceptMethodCase_ == 26) && (unsetAttributeTypeBuilder_ != null)) {
return unsetAttributeTypeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 26) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttributeType = 26;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getUnsetAttributeTypeFieldBuilder() {
if (unsetAttributeTypeBuilder_ == null) {
if (!(conceptMethodCase_ == 26)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
unsetAttributeTypeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 26;
onChanged();;
return unsetAttributeTypeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getKeyTypesBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeyTypes = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetKeyTypes() {
if (getKeyTypesBuilder_ == null) {
if (conceptMethodCase_ == 12) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 12) {
return getKeyTypesBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeyTypes = 12;</code>
*/
public Builder setGetKeyTypes(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getKeyTypesBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getKeyTypesBuilder_.setMessage(value);
}
conceptMethodCase_ = 12;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeyTypes = 12;</code>
*/
public Builder setGetKeyTypes(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getKeyTypesBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getKeyTypesBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 12;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeyTypes = 12;</code>
*/
public Builder mergeGetKeyTypes(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getKeyTypesBuilder_ == null) {
if (conceptMethodCase_ == 12 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 12) {
getKeyTypesBuilder_.mergeFrom(value);
}
getKeyTypesBuilder_.setMessage(value);
}
conceptMethodCase_ = 12;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeyTypes = 12;</code>
*/
public Builder clearGetKeyTypes() {
if (getKeyTypesBuilder_ == null) {
if (conceptMethodCase_ == 12) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 12) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getKeyTypesBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeyTypes = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetKeyTypesBuilder() {
return getGetKeyTypesFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeyTypes = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetKeyTypesOrBuilder() {
if ((conceptMethodCase_ == 12) && (getKeyTypesBuilder_ != null)) {
return getKeyTypesBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 12) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeyTypes = 12;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetKeyTypesFieldBuilder() {
if (getKeyTypesBuilder_ == null) {
if (!(conceptMethodCase_ == 12)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getKeyTypesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 12;
onChanged();;
return getKeyTypesBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> setKeyTypeBuilder_;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setKeyType = 27;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getSetKeyType() {
if (setKeyTypeBuilder_ == null) {
if (conceptMethodCase_ == 27) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (conceptMethodCase_ == 27) {
return setKeyTypeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setKeyType = 27;</code>
*/
public Builder setSetKeyType(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (setKeyTypeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
setKeyTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 27;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setKeyType = 27;</code>
*/
public Builder setSetKeyType(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (setKeyTypeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
setKeyTypeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 27;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setKeyType = 27;</code>
*/
public Builder mergeSetKeyType(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (setKeyTypeBuilder_ == null) {
if (conceptMethodCase_ == 27 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 27) {
setKeyTypeBuilder_.mergeFrom(value);
}
setKeyTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 27;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setKeyType = 27;</code>
*/
public Builder clearSetKeyType() {
if (setKeyTypeBuilder_ == null) {
if (conceptMethodCase_ == 27) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 27) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
setKeyTypeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setKeyType = 27;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getSetKeyTypeBuilder() {
return getSetKeyTypeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setKeyType = 27;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetKeyTypeOrBuilder() {
if ((conceptMethodCase_ == 27) && (setKeyTypeBuilder_ != null)) {
return setKeyTypeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 27) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setKeyType = 27;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getSetKeyTypeFieldBuilder() {
if (setKeyTypeBuilder_ == null) {
if (!(conceptMethodCase_ == 27)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
setKeyTypeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 27;
onChanged();;
return setKeyTypeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> unsetKeyTypeBuilder_;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetKeyType = 28;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetKeyType() {
if (unsetKeyTypeBuilder_ == null) {
if (conceptMethodCase_ == 28) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (conceptMethodCase_ == 28) {
return unsetKeyTypeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetKeyType = 28;</code>
*/
public Builder setUnsetKeyType(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (unsetKeyTypeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
unsetKeyTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 28;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetKeyType = 28;</code>
*/
public Builder setUnsetKeyType(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (unsetKeyTypeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
unsetKeyTypeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 28;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetKeyType = 28;</code>
*/
public Builder mergeUnsetKeyType(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (unsetKeyTypeBuilder_ == null) {
if (conceptMethodCase_ == 28 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 28) {
unsetKeyTypeBuilder_.mergeFrom(value);
}
unsetKeyTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 28;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetKeyType = 28;</code>
*/
public Builder clearUnsetKeyType() {
if (unsetKeyTypeBuilder_ == null) {
if (conceptMethodCase_ == 28) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 28) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
unsetKeyTypeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetKeyType = 28;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getUnsetKeyTypeBuilder() {
return getUnsetKeyTypeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetKeyType = 28;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetKeyTypeOrBuilder() {
if ((conceptMethodCase_ == 28) && (unsetKeyTypeBuilder_ != null)) {
return unsetKeyTypeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 28) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetKeyType = 28;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getUnsetKeyTypeFieldBuilder() {
if (unsetKeyTypeBuilder_ == null) {
if (!(conceptMethodCase_ == 28)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
unsetKeyTypeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 28;
onChanged();;
return unsetKeyTypeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> isAbstractBuilder_;
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isAbstract = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getIsAbstract() {
if (isAbstractBuilder_ == null) {
if (conceptMethodCase_ == 6) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 6) {
return isAbstractBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isAbstract = 6;</code>
*/
public Builder setIsAbstract(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (isAbstractBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
isAbstractBuilder_.setMessage(value);
}
conceptMethodCase_ = 6;
return this;
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isAbstract = 6;</code>
*/
public Builder setIsAbstract(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (isAbstractBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
isAbstractBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 6;
return this;
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isAbstract = 6;</code>
*/
public Builder mergeIsAbstract(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (isAbstractBuilder_ == null) {
if (conceptMethodCase_ == 6 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 6) {
isAbstractBuilder_.mergeFrom(value);
}
isAbstractBuilder_.setMessage(value);
}
conceptMethodCase_ = 6;
return this;
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isAbstract = 6;</code>
*/
public Builder clearIsAbstract() {
if (isAbstractBuilder_ == null) {
if (conceptMethodCase_ == 6) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 6) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
isAbstractBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isAbstract = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getIsAbstractBuilder() {
return getIsAbstractFieldBuilder().getBuilder();
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isAbstract = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getIsAbstractOrBuilder() {
if ((conceptMethodCase_ == 6) && (isAbstractBuilder_ != null)) {
return isAbstractBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 6) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns bool
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isAbstract = 6;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getIsAbstractFieldBuilder() {
if (isAbstractBuilder_ == null) {
if (!(conceptMethodCase_ == 6)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
isAbstractBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 6;
onChanged();;
return isAbstractBuilder_;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional bool setAbstract = 22;</code>
*/
public boolean getSetAbstract() {
if (conceptMethodCase_ == 22) {
return (java.lang.Boolean) conceptMethod_;
}
return false;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional bool setAbstract = 22;</code>
*/
public Builder setSetAbstract(boolean value) {
conceptMethodCase_ = 22;
conceptMethod_ = value;
onChanged();
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional bool setAbstract = 22;</code>
*/
public Builder clearSetAbstract() {
if (conceptMethodCase_ == 22) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getRolesPlayedByTypeBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByType = 29;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRolesPlayedByType() {
if (getRolesPlayedByTypeBuilder_ == null) {
if (conceptMethodCase_ == 29) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 29) {
return getRolesPlayedByTypeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByType = 29;</code>
*/
public Builder setGetRolesPlayedByType(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRolesPlayedByTypeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getRolesPlayedByTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 29;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByType = 29;</code>
*/
public Builder setGetRolesPlayedByType(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getRolesPlayedByTypeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getRolesPlayedByTypeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 29;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByType = 29;</code>
*/
public Builder mergeGetRolesPlayedByType(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRolesPlayedByTypeBuilder_ == null) {
if (conceptMethodCase_ == 29 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 29) {
getRolesPlayedByTypeBuilder_.mergeFrom(value);
}
getRolesPlayedByTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 29;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByType = 29;</code>
*/
public Builder clearGetRolesPlayedByType() {
if (getRolesPlayedByTypeBuilder_ == null) {
if (conceptMethodCase_ == 29) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 29) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getRolesPlayedByTypeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByType = 29;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetRolesPlayedByTypeBuilder() {
return getGetRolesPlayedByTypeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByType = 29;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRolesPlayedByTypeOrBuilder() {
if ((conceptMethodCase_ == 29) && (getRolesPlayedByTypeBuilder_ != null)) {
return getRolesPlayedByTypeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 29) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByType = 29;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetRolesPlayedByTypeFieldBuilder() {
if (getRolesPlayedByTypeBuilder_ == null) {
if (!(conceptMethodCase_ == 29)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getRolesPlayedByTypeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 29;
onChanged();;
return getRolesPlayedByTypeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> setRolePlayedByTypeBuilder_;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRolePlayedByType = 23;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getSetRolePlayedByType() {
if (setRolePlayedByTypeBuilder_ == null) {
if (conceptMethodCase_ == 23) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (conceptMethodCase_ == 23) {
return setRolePlayedByTypeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRolePlayedByType = 23;</code>
*/
public Builder setSetRolePlayedByType(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (setRolePlayedByTypeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
setRolePlayedByTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 23;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRolePlayedByType = 23;</code>
*/
public Builder setSetRolePlayedByType(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (setRolePlayedByTypeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
setRolePlayedByTypeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 23;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRolePlayedByType = 23;</code>
*/
public Builder mergeSetRolePlayedByType(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (setRolePlayedByTypeBuilder_ == null) {
if (conceptMethodCase_ == 23 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 23) {
setRolePlayedByTypeBuilder_.mergeFrom(value);
}
setRolePlayedByTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 23;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRolePlayedByType = 23;</code>
*/
public Builder clearSetRolePlayedByType() {
if (setRolePlayedByTypeBuilder_ == null) {
if (conceptMethodCase_ == 23) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 23) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
setRolePlayedByTypeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRolePlayedByType = 23;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getSetRolePlayedByTypeBuilder() {
return getSetRolePlayedByTypeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRolePlayedByType = 23;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetRolePlayedByTypeOrBuilder() {
if ((conceptMethodCase_ == 23) && (setRolePlayedByTypeBuilder_ != null)) {
return setRolePlayedByTypeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 23) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRolePlayedByType = 23;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getSetRolePlayedByTypeFieldBuilder() {
if (setRolePlayedByTypeBuilder_ == null) {
if (!(conceptMethodCase_ == 23)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
setRolePlayedByTypeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 23;
onChanged();;
return setRolePlayedByTypeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> unsetRolePlayedByTypeBuilder_;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRolePlayedByType = 24;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetRolePlayedByType() {
if (unsetRolePlayedByTypeBuilder_ == null) {
if (conceptMethodCase_ == 24) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (conceptMethodCase_ == 24) {
return unsetRolePlayedByTypeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRolePlayedByType = 24;</code>
*/
public Builder setUnsetRolePlayedByType(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (unsetRolePlayedByTypeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
unsetRolePlayedByTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 24;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRolePlayedByType = 24;</code>
*/
public Builder setUnsetRolePlayedByType(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (unsetRolePlayedByTypeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
unsetRolePlayedByTypeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 24;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRolePlayedByType = 24;</code>
*/
public Builder mergeUnsetRolePlayedByType(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (unsetRolePlayedByTypeBuilder_ == null) {
if (conceptMethodCase_ == 24 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 24) {
unsetRolePlayedByTypeBuilder_.mergeFrom(value);
}
unsetRolePlayedByTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 24;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRolePlayedByType = 24;</code>
*/
public Builder clearUnsetRolePlayedByType() {
if (unsetRolePlayedByTypeBuilder_ == null) {
if (conceptMethodCase_ == 24) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 24) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
unsetRolePlayedByTypeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRolePlayedByType = 24;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getUnsetRolePlayedByTypeBuilder() {
return getUnsetRolePlayedByTypeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRolePlayedByType = 24;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetRolePlayedByTypeOrBuilder() {
if ((conceptMethodCase_ == 24) && (unsetRolePlayedByTypeBuilder_ != null)) {
return unsetRolePlayedByTypeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 24) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRolePlayedByType = 24;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getUnsetRolePlayedByTypeFieldBuilder() {
if (unsetRolePlayedByTypeBuilder_ == null) {
if (!(conceptMethodCase_ == 24)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
unsetRolePlayedByTypeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 24;
onChanged();;
return unsetRolePlayedByTypeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> addEntityBuilder_;
/**
* <pre>
* Entity type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addEntity = 34;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getAddEntity() {
if (addEntityBuilder_ == null) {
if (conceptMethodCase_ == 34) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 34) {
return addEntityBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Entity type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addEntity = 34;</code>
*/
public Builder setAddEntity(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (addEntityBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
addEntityBuilder_.setMessage(value);
}
conceptMethodCase_ = 34;
return this;
}
/**
* <pre>
* Entity type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addEntity = 34;</code>
*/
public Builder setAddEntity(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (addEntityBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
addEntityBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 34;
return this;
}
/**
* <pre>
* Entity type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addEntity = 34;</code>
*/
public Builder mergeAddEntity(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (addEntityBuilder_ == null) {
if (conceptMethodCase_ == 34 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 34) {
addEntityBuilder_.mergeFrom(value);
}
addEntityBuilder_.setMessage(value);
}
conceptMethodCase_ = 34;
return this;
}
/**
* <pre>
* Entity type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addEntity = 34;</code>
*/
public Builder clearAddEntity() {
if (addEntityBuilder_ == null) {
if (conceptMethodCase_ == 34) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 34) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
addEntityBuilder_.clear();
}
return this;
}
/**
* <pre>
* Entity type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addEntity = 34;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getAddEntityBuilder() {
return getAddEntityFieldBuilder().getBuilder();
}
/**
* <pre>
* Entity type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addEntity = 34;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAddEntityOrBuilder() {
if ((conceptMethodCase_ == 34) && (addEntityBuilder_ != null)) {
return addEntityBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 34) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Entity type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addEntity = 34;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getAddEntityFieldBuilder() {
if (addEntityBuilder_ == null) {
if (!(conceptMethodCase_ == 34)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
addEntityBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 34;
onChanged();;
return addEntityBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getRelatedRolesBuilder_;
/**
* <pre>
* Relationship type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelatedRoles = 36;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRelatedRoles() {
if (getRelatedRolesBuilder_ == null) {
if (conceptMethodCase_ == 36) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 36) {
return getRelatedRolesBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Relationship type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelatedRoles = 36;</code>
*/
public Builder setGetRelatedRoles(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRelatedRolesBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getRelatedRolesBuilder_.setMessage(value);
}
conceptMethodCase_ = 36;
return this;
}
/**
* <pre>
* Relationship type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelatedRoles = 36;</code>
*/
public Builder setGetRelatedRoles(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getRelatedRolesBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getRelatedRolesBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 36;
return this;
}
/**
* <pre>
* Relationship type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelatedRoles = 36;</code>
*/
public Builder mergeGetRelatedRoles(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRelatedRolesBuilder_ == null) {
if (conceptMethodCase_ == 36 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 36) {
getRelatedRolesBuilder_.mergeFrom(value);
}
getRelatedRolesBuilder_.setMessage(value);
}
conceptMethodCase_ = 36;
return this;
}
/**
* <pre>
* Relationship type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelatedRoles = 36;</code>
*/
public Builder clearGetRelatedRoles() {
if (getRelatedRolesBuilder_ == null) {
if (conceptMethodCase_ == 36) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 36) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getRelatedRolesBuilder_.clear();
}
return this;
}
/**
* <pre>
* Relationship type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelatedRoles = 36;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetRelatedRolesBuilder() {
return getGetRelatedRolesFieldBuilder().getBuilder();
}
/**
* <pre>
* Relationship type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelatedRoles = 36;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRelatedRolesOrBuilder() {
if ((conceptMethodCase_ == 36) && (getRelatedRolesBuilder_ != null)) {
return getRelatedRolesBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 36) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Relationship type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelatedRoles = 36;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetRelatedRolesFieldBuilder() {
if (getRelatedRolesBuilder_ == null) {
if (!(conceptMethodCase_ == 36)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getRelatedRolesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 36;
onChanged();;
return getRelatedRolesBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> setRelatedRoleBuilder_;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRelatedRole = 37;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getSetRelatedRole() {
if (setRelatedRoleBuilder_ == null) {
if (conceptMethodCase_ == 37) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (conceptMethodCase_ == 37) {
return setRelatedRoleBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRelatedRole = 37;</code>
*/
public Builder setSetRelatedRole(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (setRelatedRoleBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
setRelatedRoleBuilder_.setMessage(value);
}
conceptMethodCase_ = 37;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRelatedRole = 37;</code>
*/
public Builder setSetRelatedRole(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (setRelatedRoleBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
setRelatedRoleBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 37;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRelatedRole = 37;</code>
*/
public Builder mergeSetRelatedRole(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (setRelatedRoleBuilder_ == null) {
if (conceptMethodCase_ == 37 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 37) {
setRelatedRoleBuilder_.mergeFrom(value);
}
setRelatedRoleBuilder_.setMessage(value);
}
conceptMethodCase_ = 37;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRelatedRole = 37;</code>
*/
public Builder clearSetRelatedRole() {
if (setRelatedRoleBuilder_ == null) {
if (conceptMethodCase_ == 37) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 37) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
setRelatedRoleBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRelatedRole = 37;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getSetRelatedRoleBuilder() {
return getSetRelatedRoleFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRelatedRole = 37;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetRelatedRoleOrBuilder() {
if ((conceptMethodCase_ == 37) && (setRelatedRoleBuilder_ != null)) {
return setRelatedRoleBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 37) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setRelatedRole = 37;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getSetRelatedRoleFieldBuilder() {
if (setRelatedRoleBuilder_ == null) {
if (!(conceptMethodCase_ == 37)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
setRelatedRoleBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 37;
onChanged();;
return setRelatedRoleBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> unsetRelatedRoleBuilder_;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRelatedRole = 38;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetRelatedRole() {
if (unsetRelatedRoleBuilder_ == null) {
if (conceptMethodCase_ == 38) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (conceptMethodCase_ == 38) {
return unsetRelatedRoleBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRelatedRole = 38;</code>
*/
public Builder setUnsetRelatedRole(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (unsetRelatedRoleBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
unsetRelatedRoleBuilder_.setMessage(value);
}
conceptMethodCase_ = 38;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRelatedRole = 38;</code>
*/
public Builder setUnsetRelatedRole(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (unsetRelatedRoleBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
unsetRelatedRoleBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 38;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRelatedRole = 38;</code>
*/
public Builder mergeUnsetRelatedRole(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (unsetRelatedRoleBuilder_ == null) {
if (conceptMethodCase_ == 38 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 38) {
unsetRelatedRoleBuilder_.mergeFrom(value);
}
unsetRelatedRoleBuilder_.setMessage(value);
}
conceptMethodCase_ = 38;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRelatedRole = 38;</code>
*/
public Builder clearUnsetRelatedRole() {
if (unsetRelatedRoleBuilder_ == null) {
if (conceptMethodCase_ == 38) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 38) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
unsetRelatedRoleBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRelatedRole = 38;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getUnsetRelatedRoleBuilder() {
return getUnsetRelatedRoleFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRelatedRole = 38;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetRelatedRoleOrBuilder() {
if ((conceptMethodCase_ == 38) && (unsetRelatedRoleBuilder_ != null)) {
return unsetRelatedRoleBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 38) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetRelatedRole = 38;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getUnsetRelatedRoleFieldBuilder() {
if (unsetRelatedRoleBuilder_ == null) {
if (!(conceptMethodCase_ == 38)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
unsetRelatedRoleBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 38;
onChanged();;
return unsetRelatedRoleBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.AttributeValue, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder, ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder> putAttributeBuilder_;
/**
* <pre>
* Attribute type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue putAttribute = 32;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue getPutAttribute() {
if (putAttributeBuilder_ == null) {
if (conceptMethodCase_ == 32) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
} else {
if (conceptMethodCase_ == 32) {
return putAttributeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
}
/**
* <pre>
* Attribute type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue putAttribute = 32;</code>
*/
public Builder setPutAttribute(ai.grakn.rpc.generated.GrpcConcept.AttributeValue value) {
if (putAttributeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
putAttributeBuilder_.setMessage(value);
}
conceptMethodCase_ = 32;
return this;
}
/**
* <pre>
* Attribute type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue putAttribute = 32;</code>
*/
public Builder setPutAttribute(
ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder builderForValue) {
if (putAttributeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
putAttributeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 32;
return this;
}
/**
* <pre>
* Attribute type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue putAttribute = 32;</code>
*/
public Builder mergePutAttribute(ai.grakn.rpc.generated.GrpcConcept.AttributeValue value) {
if (putAttributeBuilder_ == null) {
if (conceptMethodCase_ == 32 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.AttributeValue.newBuilder((ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 32) {
putAttributeBuilder_.mergeFrom(value);
}
putAttributeBuilder_.setMessage(value);
}
conceptMethodCase_ = 32;
return this;
}
/**
* <pre>
* Attribute type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue putAttribute = 32;</code>
*/
public Builder clearPutAttribute() {
if (putAttributeBuilder_ == null) {
if (conceptMethodCase_ == 32) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 32) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
putAttributeBuilder_.clear();
}
return this;
}
/**
* <pre>
* Attribute type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue putAttribute = 32;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder getPutAttributeBuilder() {
return getPutAttributeFieldBuilder().getBuilder();
}
/**
* <pre>
* Attribute type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue putAttribute = 32;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder getPutAttributeOrBuilder() {
if ((conceptMethodCase_ == 32) && (putAttributeBuilder_ != null)) {
return putAttributeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 32) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
}
/**
* <pre>
* Attribute type
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue putAttribute = 32;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.AttributeValue, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder, ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder>
getPutAttributeFieldBuilder() {
if (putAttributeBuilder_ == null) {
if (!(conceptMethodCase_ == 32)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
putAttributeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.AttributeValue, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder, ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 32;
onChanged();;
return putAttributeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.AttributeValue, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder, ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder> getAttributeBuilder_;
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttribute = 33;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue getGetAttribute() {
if (getAttributeBuilder_ == null) {
if (conceptMethodCase_ == 33) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
} else {
if (conceptMethodCase_ == 33) {
return getAttributeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttribute = 33;</code>
*/
public Builder setGetAttribute(ai.grakn.rpc.generated.GrpcConcept.AttributeValue value) {
if (getAttributeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getAttributeBuilder_.setMessage(value);
}
conceptMethodCase_ = 33;
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttribute = 33;</code>
*/
public Builder setGetAttribute(
ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder builderForValue) {
if (getAttributeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getAttributeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 33;
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttribute = 33;</code>
*/
public Builder mergeGetAttribute(ai.grakn.rpc.generated.GrpcConcept.AttributeValue value) {
if (getAttributeBuilder_ == null) {
if (conceptMethodCase_ == 33 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.AttributeValue.newBuilder((ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 33) {
getAttributeBuilder_.mergeFrom(value);
}
getAttributeBuilder_.setMessage(value);
}
conceptMethodCase_ = 33;
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttribute = 33;</code>
*/
public Builder clearGetAttribute() {
if (getAttributeBuilder_ == null) {
if (conceptMethodCase_ == 33) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 33) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getAttributeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttribute = 33;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder getGetAttributeBuilder() {
return getGetAttributeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttribute = 33;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder getGetAttributeOrBuilder() {
if ((conceptMethodCase_ == 33) && (getAttributeBuilder_ != null)) {
return getAttributeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 33) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttribute = 33;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.AttributeValue, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder, ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder>
getGetAttributeFieldBuilder() {
if (getAttributeBuilder_ == null) {
if (!(conceptMethodCase_ == 33)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
getAttributeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.AttributeValue, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder, ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.AttributeValue) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 33;
onChanged();;
return getAttributeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getDataTypeOfTypeBuilder_;
/**
* <pre>
* returns OptionalDataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfType = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetDataTypeOfType() {
if (getDataTypeOfTypeBuilder_ == null) {
if (conceptMethodCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 2) {
return getDataTypeOfTypeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalDataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfType = 2;</code>
*/
public Builder setGetDataTypeOfType(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getDataTypeOfTypeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getDataTypeOfTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 2;
return this;
}
/**
* <pre>
* returns OptionalDataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfType = 2;</code>
*/
public Builder setGetDataTypeOfType(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getDataTypeOfTypeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getDataTypeOfTypeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 2;
return this;
}
/**
* <pre>
* returns OptionalDataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfType = 2;</code>
*/
public Builder mergeGetDataTypeOfType(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getDataTypeOfTypeBuilder_ == null) {
if (conceptMethodCase_ == 2 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 2) {
getDataTypeOfTypeBuilder_.mergeFrom(value);
}
getDataTypeOfTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 2;
return this;
}
/**
* <pre>
* returns OptionalDataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfType = 2;</code>
*/
public Builder clearGetDataTypeOfType() {
if (getDataTypeOfTypeBuilder_ == null) {
if (conceptMethodCase_ == 2) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 2) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getDataTypeOfTypeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns OptionalDataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfType = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetDataTypeOfTypeBuilder() {
return getGetDataTypeOfTypeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns OptionalDataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfType = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetDataTypeOfTypeOrBuilder() {
if ((conceptMethodCase_ == 2) && (getDataTypeOfTypeBuilder_ != null)) {
return getDataTypeOfTypeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalDataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfType = 2;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetDataTypeOfTypeFieldBuilder() {
if (getDataTypeOfTypeBuilder_ == null) {
if (!(conceptMethodCase_ == 2)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getDataTypeOfTypeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 2;
onChanged();;
return getDataTypeOfTypeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getDataTypeOfAttributeBuilder_;
/**
* <pre>
* returns DataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfAttribute = 54;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetDataTypeOfAttribute() {
if (getDataTypeOfAttributeBuilder_ == null) {
if (conceptMethodCase_ == 54) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 54) {
return getDataTypeOfAttributeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns DataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfAttribute = 54;</code>
*/
public Builder setGetDataTypeOfAttribute(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getDataTypeOfAttributeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getDataTypeOfAttributeBuilder_.setMessage(value);
}
conceptMethodCase_ = 54;
return this;
}
/**
* <pre>
* returns DataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfAttribute = 54;</code>
*/
public Builder setGetDataTypeOfAttribute(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getDataTypeOfAttributeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getDataTypeOfAttributeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 54;
return this;
}
/**
* <pre>
* returns DataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfAttribute = 54;</code>
*/
public Builder mergeGetDataTypeOfAttribute(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getDataTypeOfAttributeBuilder_ == null) {
if (conceptMethodCase_ == 54 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 54) {
getDataTypeOfAttributeBuilder_.mergeFrom(value);
}
getDataTypeOfAttributeBuilder_.setMessage(value);
}
conceptMethodCase_ = 54;
return this;
}
/**
* <pre>
* returns DataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfAttribute = 54;</code>
*/
public Builder clearGetDataTypeOfAttribute() {
if (getDataTypeOfAttributeBuilder_ == null) {
if (conceptMethodCase_ == 54) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 54) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getDataTypeOfAttributeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns DataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfAttribute = 54;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetDataTypeOfAttributeBuilder() {
return getGetDataTypeOfAttributeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns DataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfAttribute = 54;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetDataTypeOfAttributeOrBuilder() {
if ((conceptMethodCase_ == 54) && (getDataTypeOfAttributeBuilder_ != null)) {
return getDataTypeOfAttributeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 54) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns DataType
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDataTypeOfAttribute = 54;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetDataTypeOfAttributeFieldBuilder() {
if (getDataTypeOfAttributeBuilder_ == null) {
if (!(conceptMethodCase_ == 54)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getDataTypeOfAttributeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 54;
onChanged();;
return getDataTypeOfAttributeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getRegexBuilder_;
/**
* <pre>
* returns OptionalRegex
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRegex = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRegex() {
if (getRegexBuilder_ == null) {
if (conceptMethodCase_ == 9) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 9) {
return getRegexBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalRegex
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRegex = 9;</code>
*/
public Builder setGetRegex(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRegexBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getRegexBuilder_.setMessage(value);
}
conceptMethodCase_ = 9;
return this;
}
/**
* <pre>
* returns OptionalRegex
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRegex = 9;</code>
*/
public Builder setGetRegex(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getRegexBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getRegexBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 9;
return this;
}
/**
* <pre>
* returns OptionalRegex
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRegex = 9;</code>
*/
public Builder mergeGetRegex(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRegexBuilder_ == null) {
if (conceptMethodCase_ == 9 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 9) {
getRegexBuilder_.mergeFrom(value);
}
getRegexBuilder_.setMessage(value);
}
conceptMethodCase_ = 9;
return this;
}
/**
* <pre>
* returns OptionalRegex
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRegex = 9;</code>
*/
public Builder clearGetRegex() {
if (getRegexBuilder_ == null) {
if (conceptMethodCase_ == 9) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 9) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getRegexBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns OptionalRegex
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRegex = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetRegexBuilder() {
return getGetRegexFieldBuilder().getBuilder();
}
/**
* <pre>
* returns OptionalRegex
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRegex = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRegexOrBuilder() {
if ((conceptMethodCase_ == 9) && (getRegexBuilder_ != null)) {
return getRegexBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 9) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalRegex
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRegex = 9;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetRegexFieldBuilder() {
if (getRegexBuilder_ == null) {
if (!(conceptMethodCase_ == 9)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getRegexBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 9;
onChanged();;
return getRegexBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex, ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalRegexOrBuilder> setRegexBuilder_;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.OptionalRegex setRegex = 31;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegex getSetRegex() {
if (setRegexBuilder_ == null) {
if (conceptMethodCase_ == 31) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance();
} else {
if (conceptMethodCase_ == 31) {
return setRegexBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.OptionalRegex setRegex = 31;</code>
*/
public Builder setSetRegex(ai.grakn.rpc.generated.GrpcConcept.OptionalRegex value) {
if (setRegexBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
setRegexBuilder_.setMessage(value);
}
conceptMethodCase_ = 31;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.OptionalRegex setRegex = 31;</code>
*/
public Builder setSetRegex(
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder builderForValue) {
if (setRegexBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
setRegexBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 31;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.OptionalRegex setRegex = 31;</code>
*/
public Builder mergeSetRegex(ai.grakn.rpc.generated.GrpcConcept.OptionalRegex value) {
if (setRegexBuilder_ == null) {
if (conceptMethodCase_ == 31 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.newBuilder((ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 31) {
setRegexBuilder_.mergeFrom(value);
}
setRegexBuilder_.setMessage(value);
}
conceptMethodCase_ = 31;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.OptionalRegex setRegex = 31;</code>
*/
public Builder clearSetRegex() {
if (setRegexBuilder_ == null) {
if (conceptMethodCase_ == 31) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 31) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
setRegexBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.OptionalRegex setRegex = 31;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder getSetRegexBuilder() {
return getSetRegexFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.OptionalRegex setRegex = 31;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegexOrBuilder getSetRegexOrBuilder() {
if ((conceptMethodCase_ == 31) && (setRegexBuilder_ != null)) {
return setRegexBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 31) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.OptionalRegex setRegex = 31;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex, ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalRegexOrBuilder>
getSetRegexFieldBuilder() {
if (setRegexBuilder_ == null) {
if (!(conceptMethodCase_ == 31)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance();
}
setRegexBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex, ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalRegexOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 31;
onChanged();;
return setRegexBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> isInferredBuilder_;
/**
* <pre>
* Thing
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isInferred = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getIsInferred() {
if (isInferredBuilder_ == null) {
if (conceptMethodCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 5) {
return isInferredBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Thing
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isInferred = 5;</code>
*/
public Builder setIsInferred(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (isInferredBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
isInferredBuilder_.setMessage(value);
}
conceptMethodCase_ = 5;
return this;
}
/**
* <pre>
* Thing
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isInferred = 5;</code>
*/
public Builder setIsInferred(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (isInferredBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
isInferredBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 5;
return this;
}
/**
* <pre>
* Thing
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isInferred = 5;</code>
*/
public Builder mergeIsInferred(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (isInferredBuilder_ == null) {
if (conceptMethodCase_ == 5 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 5) {
isInferredBuilder_.mergeFrom(value);
}
isInferredBuilder_.setMessage(value);
}
conceptMethodCase_ = 5;
return this;
}
/**
* <pre>
* Thing
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isInferred = 5;</code>
*/
public Builder clearIsInferred() {
if (isInferredBuilder_ == null) {
if (conceptMethodCase_ == 5) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 5) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
isInferredBuilder_.clear();
}
return this;
}
/**
* <pre>
* Thing
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isInferred = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getIsInferredBuilder() {
return getIsInferredFieldBuilder().getBuilder();
}
/**
* <pre>
* Thing
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isInferred = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getIsInferredOrBuilder() {
if ((conceptMethodCase_ == 5) && (isInferredBuilder_ != null)) {
return isInferredBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Thing
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit isInferred = 5;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getIsInferredFieldBuilder() {
if (isInferredBuilder_ == null) {
if (!(conceptMethodCase_ == 5)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
isInferredBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 5;
onChanged();;
return isInferredBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getDirectTypeBuilder_;
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectType = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetDirectType() {
if (getDirectTypeBuilder_ == null) {
if (conceptMethodCase_ == 13) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 13) {
return getDirectTypeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectType = 13;</code>
*/
public Builder setGetDirectType(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getDirectTypeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getDirectTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 13;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectType = 13;</code>
*/
public Builder setGetDirectType(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getDirectTypeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getDirectTypeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 13;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectType = 13;</code>
*/
public Builder mergeGetDirectType(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getDirectTypeBuilder_ == null) {
if (conceptMethodCase_ == 13 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 13) {
getDirectTypeBuilder_.mergeFrom(value);
}
getDirectTypeBuilder_.setMessage(value);
}
conceptMethodCase_ = 13;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectType = 13;</code>
*/
public Builder clearGetDirectType() {
if (getDirectTypeBuilder_ == null) {
if (conceptMethodCase_ == 13) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 13) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getDirectTypeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectType = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetDirectTypeBuilder() {
return getGetDirectTypeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectType = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetDirectTypeOrBuilder() {
if ((conceptMethodCase_ == 13) && (getDirectTypeBuilder_ != null)) {
return getDirectTypeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 13) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getDirectType = 13;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetDirectTypeFieldBuilder() {
if (getDirectTypeBuilder_ == null) {
if (!(conceptMethodCase_ == 13)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getDirectTypeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 13;
onChanged();;
return getDirectTypeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getRelationshipsBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationships = 39;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRelationships() {
if (getRelationshipsBuilder_ == null) {
if (conceptMethodCase_ == 39) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 39) {
return getRelationshipsBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationships = 39;</code>
*/
public Builder setGetRelationships(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRelationshipsBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getRelationshipsBuilder_.setMessage(value);
}
conceptMethodCase_ = 39;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationships = 39;</code>
*/
public Builder setGetRelationships(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getRelationshipsBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getRelationshipsBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 39;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationships = 39;</code>
*/
public Builder mergeGetRelationships(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRelationshipsBuilder_ == null) {
if (conceptMethodCase_ == 39 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 39) {
getRelationshipsBuilder_.mergeFrom(value);
}
getRelationshipsBuilder_.setMessage(value);
}
conceptMethodCase_ = 39;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationships = 39;</code>
*/
public Builder clearGetRelationships() {
if (getRelationshipsBuilder_ == null) {
if (conceptMethodCase_ == 39) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 39) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getRelationshipsBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationships = 39;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetRelationshipsBuilder() {
return getGetRelationshipsFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationships = 39;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRelationshipsOrBuilder() {
if ((conceptMethodCase_ == 39) && (getRelationshipsBuilder_ != null)) {
return getRelationshipsBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 39) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRelationships = 39;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetRelationshipsFieldBuilder() {
if (getRelationshipsBuilder_ == null) {
if (!(conceptMethodCase_ == 39)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getRelationshipsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 39;
onChanged();;
return getRelationshipsBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concepts, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder> getRelationshipsByRolesBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRelationshipsByRoles = 48;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concepts getGetRelationshipsByRoles() {
if (getRelationshipsByRolesBuilder_ == null) {
if (conceptMethodCase_ == 48) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
} else {
if (conceptMethodCase_ == 48) {
return getRelationshipsByRolesBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRelationshipsByRoles = 48;</code>
*/
public Builder setGetRelationshipsByRoles(ai.grakn.rpc.generated.GrpcConcept.Concepts value) {
if (getRelationshipsByRolesBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getRelationshipsByRolesBuilder_.setMessage(value);
}
conceptMethodCase_ = 48;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRelationshipsByRoles = 48;</code>
*/
public Builder setGetRelationshipsByRoles(
ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder builderForValue) {
if (getRelationshipsByRolesBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getRelationshipsByRolesBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 48;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRelationshipsByRoles = 48;</code>
*/
public Builder mergeGetRelationshipsByRoles(ai.grakn.rpc.generated.GrpcConcept.Concepts value) {
if (getRelationshipsByRolesBuilder_ == null) {
if (conceptMethodCase_ == 48 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concepts.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 48) {
getRelationshipsByRolesBuilder_.mergeFrom(value);
}
getRelationshipsByRolesBuilder_.setMessage(value);
}
conceptMethodCase_ = 48;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRelationshipsByRoles = 48;</code>
*/
public Builder clearGetRelationshipsByRoles() {
if (getRelationshipsByRolesBuilder_ == null) {
if (conceptMethodCase_ == 48) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 48) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getRelationshipsByRolesBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRelationshipsByRoles = 48;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder getGetRelationshipsByRolesBuilder() {
return getGetRelationshipsByRolesFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRelationshipsByRoles = 48;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder getGetRelationshipsByRolesOrBuilder() {
if ((conceptMethodCase_ == 48) && (getRelationshipsByRolesBuilder_ != null)) {
return getRelationshipsByRolesBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 48) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRelationshipsByRoles = 48;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concepts, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder>
getGetRelationshipsByRolesFieldBuilder() {
if (getRelationshipsByRolesBuilder_ == null) {
if (!(conceptMethodCase_ == 48)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
getRelationshipsByRolesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concepts, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 48;
onChanged();;
return getRelationshipsByRolesBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getRolesPlayedByThingBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByThing = 40;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRolesPlayedByThing() {
if (getRolesPlayedByThingBuilder_ == null) {
if (conceptMethodCase_ == 40) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 40) {
return getRolesPlayedByThingBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByThing = 40;</code>
*/
public Builder setGetRolesPlayedByThing(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRolesPlayedByThingBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getRolesPlayedByThingBuilder_.setMessage(value);
}
conceptMethodCase_ = 40;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByThing = 40;</code>
*/
public Builder setGetRolesPlayedByThing(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getRolesPlayedByThingBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getRolesPlayedByThingBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 40;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByThing = 40;</code>
*/
public Builder mergeGetRolesPlayedByThing(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRolesPlayedByThingBuilder_ == null) {
if (conceptMethodCase_ == 40 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 40) {
getRolesPlayedByThingBuilder_.mergeFrom(value);
}
getRolesPlayedByThingBuilder_.setMessage(value);
}
conceptMethodCase_ = 40;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByThing = 40;</code>
*/
public Builder clearGetRolesPlayedByThing() {
if (getRolesPlayedByThingBuilder_ == null) {
if (conceptMethodCase_ == 40) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 40) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getRolesPlayedByThingBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByThing = 40;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetRolesPlayedByThingBuilder() {
return getGetRolesPlayedByThingFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByThing = 40;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRolesPlayedByThingOrBuilder() {
if ((conceptMethodCase_ == 40) && (getRolesPlayedByThingBuilder_ != null)) {
return getRolesPlayedByThingBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 40) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolesPlayedByThing = 40;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetRolesPlayedByThingFieldBuilder() {
if (getRolesPlayedByThingBuilder_ == null) {
if (!(conceptMethodCase_ == 40)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getRolesPlayedByThingBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 40;
onChanged();;
return getRolesPlayedByThingBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getAttributesBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributes = 41;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetAttributes() {
if (getAttributesBuilder_ == null) {
if (conceptMethodCase_ == 41) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 41) {
return getAttributesBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributes = 41;</code>
*/
public Builder setGetAttributes(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getAttributesBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getAttributesBuilder_.setMessage(value);
}
conceptMethodCase_ = 41;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributes = 41;</code>
*/
public Builder setGetAttributes(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getAttributesBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getAttributesBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 41;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributes = 41;</code>
*/
public Builder mergeGetAttributes(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getAttributesBuilder_ == null) {
if (conceptMethodCase_ == 41 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 41) {
getAttributesBuilder_.mergeFrom(value);
}
getAttributesBuilder_.setMessage(value);
}
conceptMethodCase_ = 41;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributes = 41;</code>
*/
public Builder clearGetAttributes() {
if (getAttributesBuilder_ == null) {
if (conceptMethodCase_ == 41) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 41) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getAttributesBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributes = 41;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetAttributesBuilder() {
return getGetAttributesFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributes = 41;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetAttributesOrBuilder() {
if ((conceptMethodCase_ == 41) && (getAttributesBuilder_ != null)) {
return getAttributesBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 41) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getAttributes = 41;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetAttributesFieldBuilder() {
if (getAttributesBuilder_ == null) {
if (!(conceptMethodCase_ == 41)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getAttributesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 41;
onChanged();;
return getAttributesBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concepts, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder> getAttributesByTypesBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getAttributesByTypes = 49;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concepts getGetAttributesByTypes() {
if (getAttributesByTypesBuilder_ == null) {
if (conceptMethodCase_ == 49) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
} else {
if (conceptMethodCase_ == 49) {
return getAttributesByTypesBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getAttributesByTypes = 49;</code>
*/
public Builder setGetAttributesByTypes(ai.grakn.rpc.generated.GrpcConcept.Concepts value) {
if (getAttributesByTypesBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getAttributesByTypesBuilder_.setMessage(value);
}
conceptMethodCase_ = 49;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getAttributesByTypes = 49;</code>
*/
public Builder setGetAttributesByTypes(
ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder builderForValue) {
if (getAttributesByTypesBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getAttributesByTypesBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 49;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getAttributesByTypes = 49;</code>
*/
public Builder mergeGetAttributesByTypes(ai.grakn.rpc.generated.GrpcConcept.Concepts value) {
if (getAttributesByTypesBuilder_ == null) {
if (conceptMethodCase_ == 49 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concepts.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 49) {
getAttributesByTypesBuilder_.mergeFrom(value);
}
getAttributesByTypesBuilder_.setMessage(value);
}
conceptMethodCase_ = 49;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getAttributesByTypes = 49;</code>
*/
public Builder clearGetAttributesByTypes() {
if (getAttributesByTypesBuilder_ == null) {
if (conceptMethodCase_ == 49) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 49) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getAttributesByTypesBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getAttributesByTypes = 49;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder getGetAttributesByTypesBuilder() {
return getGetAttributesByTypesFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getAttributesByTypes = 49;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder getGetAttributesByTypesOrBuilder() {
if ((conceptMethodCase_ == 49) && (getAttributesByTypesBuilder_ != null)) {
return getAttributesByTypesBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 49) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getAttributesByTypes = 49;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concepts, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder>
getGetAttributesByTypesFieldBuilder() {
if (getAttributesByTypesBuilder_ == null) {
if (!(conceptMethodCase_ == 49)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
getAttributesByTypesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concepts, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 49;
onChanged();;
return getAttributesByTypesBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getKeysBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeys = 42;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetKeys() {
if (getKeysBuilder_ == null) {
if (conceptMethodCase_ == 42) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 42) {
return getKeysBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeys = 42;</code>
*/
public Builder setGetKeys(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getKeysBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getKeysBuilder_.setMessage(value);
}
conceptMethodCase_ = 42;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeys = 42;</code>
*/
public Builder setGetKeys(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getKeysBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getKeysBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 42;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeys = 42;</code>
*/
public Builder mergeGetKeys(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getKeysBuilder_ == null) {
if (conceptMethodCase_ == 42 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 42) {
getKeysBuilder_.mergeFrom(value);
}
getKeysBuilder_.setMessage(value);
}
conceptMethodCase_ = 42;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeys = 42;</code>
*/
public Builder clearGetKeys() {
if (getKeysBuilder_ == null) {
if (conceptMethodCase_ == 42) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 42) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getKeysBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeys = 42;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetKeysBuilder() {
return getGetKeysFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeys = 42;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetKeysOrBuilder() {
if ((conceptMethodCase_ == 42) && (getKeysBuilder_ != null)) {
return getKeysBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 42) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getKeys = 42;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetKeysFieldBuilder() {
if (getKeysBuilder_ == null) {
if (!(conceptMethodCase_ == 42)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getKeysBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 42;
onChanged();;
return getKeysBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concepts, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder> getKeysByTypesBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getKeysByTypes = 50;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concepts getGetKeysByTypes() {
if (getKeysByTypesBuilder_ == null) {
if (conceptMethodCase_ == 50) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
} else {
if (conceptMethodCase_ == 50) {
return getKeysByTypesBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getKeysByTypes = 50;</code>
*/
public Builder setGetKeysByTypes(ai.grakn.rpc.generated.GrpcConcept.Concepts value) {
if (getKeysByTypesBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getKeysByTypesBuilder_.setMessage(value);
}
conceptMethodCase_ = 50;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getKeysByTypes = 50;</code>
*/
public Builder setGetKeysByTypes(
ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder builderForValue) {
if (getKeysByTypesBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getKeysByTypesBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 50;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getKeysByTypes = 50;</code>
*/
public Builder mergeGetKeysByTypes(ai.grakn.rpc.generated.GrpcConcept.Concepts value) {
if (getKeysByTypesBuilder_ == null) {
if (conceptMethodCase_ == 50 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concepts.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 50) {
getKeysByTypesBuilder_.mergeFrom(value);
}
getKeysByTypesBuilder_.setMessage(value);
}
conceptMethodCase_ = 50;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getKeysByTypes = 50;</code>
*/
public Builder clearGetKeysByTypes() {
if (getKeysByTypesBuilder_ == null) {
if (conceptMethodCase_ == 50) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 50) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getKeysByTypesBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getKeysByTypes = 50;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder getGetKeysByTypesBuilder() {
return getGetKeysByTypesFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getKeysByTypes = 50;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder getGetKeysByTypesOrBuilder() {
if ((conceptMethodCase_ == 50) && (getKeysByTypesBuilder_ != null)) {
return getKeysByTypesBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 50) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getKeysByTypes = 50;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concepts, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder>
getGetKeysByTypesFieldBuilder() {
if (getKeysByTypesBuilder_ == null) {
if (!(conceptMethodCase_ == 50)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
getKeysByTypesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concepts, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 50;
onChanged();;
return getKeysByTypesBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> setAttributeBuilder_;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setAttribute = 43;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getSetAttribute() {
if (setAttributeBuilder_ == null) {
if (conceptMethodCase_ == 43) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (conceptMethodCase_ == 43) {
return setAttributeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setAttribute = 43;</code>
*/
public Builder setSetAttribute(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (setAttributeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
setAttributeBuilder_.setMessage(value);
}
conceptMethodCase_ = 43;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setAttribute = 43;</code>
*/
public Builder setSetAttribute(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (setAttributeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
setAttributeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 43;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setAttribute = 43;</code>
*/
public Builder mergeSetAttribute(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (setAttributeBuilder_ == null) {
if (conceptMethodCase_ == 43 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 43) {
setAttributeBuilder_.mergeFrom(value);
}
setAttributeBuilder_.setMessage(value);
}
conceptMethodCase_ = 43;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setAttribute = 43;</code>
*/
public Builder clearSetAttribute() {
if (setAttributeBuilder_ == null) {
if (conceptMethodCase_ == 43) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 43) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
setAttributeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setAttribute = 43;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getSetAttributeBuilder() {
return getSetAttributeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setAttribute = 43;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getSetAttributeOrBuilder() {
if ((conceptMethodCase_ == 43) && (setAttributeBuilder_ != null)) {
return setAttributeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 43) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept setAttribute = 43;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getSetAttributeFieldBuilder() {
if (setAttributeBuilder_ == null) {
if (!(conceptMethodCase_ == 43)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
setAttributeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 43;
onChanged();;
return setAttributeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> unsetAttributeBuilder_;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttribute = 44;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getUnsetAttribute() {
if (unsetAttributeBuilder_ == null) {
if (conceptMethodCase_ == 44) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (conceptMethodCase_ == 44) {
return unsetAttributeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttribute = 44;</code>
*/
public Builder setUnsetAttribute(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (unsetAttributeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
unsetAttributeBuilder_.setMessage(value);
}
conceptMethodCase_ = 44;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttribute = 44;</code>
*/
public Builder setUnsetAttribute(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (unsetAttributeBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
unsetAttributeBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 44;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttribute = 44;</code>
*/
public Builder mergeUnsetAttribute(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (unsetAttributeBuilder_ == null) {
if (conceptMethodCase_ == 44 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 44) {
unsetAttributeBuilder_.mergeFrom(value);
}
unsetAttributeBuilder_.setMessage(value);
}
conceptMethodCase_ = 44;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttribute = 44;</code>
*/
public Builder clearUnsetAttribute() {
if (unsetAttributeBuilder_ == null) {
if (conceptMethodCase_ == 44) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 44) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
unsetAttributeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttribute = 44;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getUnsetAttributeBuilder() {
return getUnsetAttributeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttribute = 44;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getUnsetAttributeOrBuilder() {
if ((conceptMethodCase_ == 44) && (unsetAttributeBuilder_ != null)) {
return unsetAttributeBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 44) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concept unsetAttribute = 44;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getUnsetAttributeFieldBuilder() {
if (unsetAttributeBuilder_ == null) {
if (!(conceptMethodCase_ == 44)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
unsetAttributeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 44;
onChanged();;
return unsetAttributeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> addRelationshipBuilder_;
/**
* <pre>
* Relationship
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addRelationship = 35;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getAddRelationship() {
if (addRelationshipBuilder_ == null) {
if (conceptMethodCase_ == 35) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 35) {
return addRelationshipBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Relationship
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addRelationship = 35;</code>
*/
public Builder setAddRelationship(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (addRelationshipBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
addRelationshipBuilder_.setMessage(value);
}
conceptMethodCase_ = 35;
return this;
}
/**
* <pre>
* Relationship
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addRelationship = 35;</code>
*/
public Builder setAddRelationship(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (addRelationshipBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
addRelationshipBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 35;
return this;
}
/**
* <pre>
* Relationship
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addRelationship = 35;</code>
*/
public Builder mergeAddRelationship(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (addRelationshipBuilder_ == null) {
if (conceptMethodCase_ == 35 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 35) {
addRelationshipBuilder_.mergeFrom(value);
}
addRelationshipBuilder_.setMessage(value);
}
conceptMethodCase_ = 35;
return this;
}
/**
* <pre>
* Relationship
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addRelationship = 35;</code>
*/
public Builder clearAddRelationship() {
if (addRelationshipBuilder_ == null) {
if (conceptMethodCase_ == 35) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 35) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
addRelationshipBuilder_.clear();
}
return this;
}
/**
* <pre>
* Relationship
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addRelationship = 35;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getAddRelationshipBuilder() {
return getAddRelationshipFieldBuilder().getBuilder();
}
/**
* <pre>
* Relationship
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addRelationship = 35;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAddRelationshipOrBuilder() {
if ((conceptMethodCase_ == 35) && (addRelationshipBuilder_ != null)) {
return addRelationshipBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 35) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Relationship
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit addRelationship = 35;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getAddRelationshipFieldBuilder() {
if (addRelationshipBuilder_ == null) {
if (!(conceptMethodCase_ == 35)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
addRelationshipBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 35;
onChanged();;
return addRelationshipBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getRolePlayersBuilder_;
/**
* <pre>
* returns IteratorId of RolePlayer
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolePlayers = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetRolePlayers() {
if (getRolePlayersBuilder_ == null) {
if (conceptMethodCase_ == 10) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 10) {
return getRolePlayersBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of RolePlayer
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolePlayers = 10;</code>
*/
public Builder setGetRolePlayers(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRolePlayersBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getRolePlayersBuilder_.setMessage(value);
}
conceptMethodCase_ = 10;
return this;
}
/**
* <pre>
* returns IteratorId of RolePlayer
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolePlayers = 10;</code>
*/
public Builder setGetRolePlayers(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getRolePlayersBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getRolePlayersBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 10;
return this;
}
/**
* <pre>
* returns IteratorId of RolePlayer
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolePlayers = 10;</code>
*/
public Builder mergeGetRolePlayers(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getRolePlayersBuilder_ == null) {
if (conceptMethodCase_ == 10 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 10) {
getRolePlayersBuilder_.mergeFrom(value);
}
getRolePlayersBuilder_.setMessage(value);
}
conceptMethodCase_ = 10;
return this;
}
/**
* <pre>
* returns IteratorId of RolePlayer
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolePlayers = 10;</code>
*/
public Builder clearGetRolePlayers() {
if (getRolePlayersBuilder_ == null) {
if (conceptMethodCase_ == 10) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 10) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getRolePlayersBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of RolePlayer
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolePlayers = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetRolePlayersBuilder() {
return getGetRolePlayersFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of RolePlayer
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolePlayers = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetRolePlayersOrBuilder() {
if ((conceptMethodCase_ == 10) && (getRolePlayersBuilder_ != null)) {
return getRolePlayersBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 10) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of RolePlayer
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getRolePlayers = 10;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetRolePlayersFieldBuilder() {
if (getRolePlayersBuilder_ == null) {
if (!(conceptMethodCase_ == 10)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getRolePlayersBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 10;
onChanged();;
return getRolePlayersBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concepts, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder> getRolePlayersByRolesBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRolePlayersByRoles = 51;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concepts getGetRolePlayersByRoles() {
if (getRolePlayersByRolesBuilder_ == null) {
if (conceptMethodCase_ == 51) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
} else {
if (conceptMethodCase_ == 51) {
return getRolePlayersByRolesBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRolePlayersByRoles = 51;</code>
*/
public Builder setGetRolePlayersByRoles(ai.grakn.rpc.generated.GrpcConcept.Concepts value) {
if (getRolePlayersByRolesBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getRolePlayersByRolesBuilder_.setMessage(value);
}
conceptMethodCase_ = 51;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRolePlayersByRoles = 51;</code>
*/
public Builder setGetRolePlayersByRoles(
ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder builderForValue) {
if (getRolePlayersByRolesBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getRolePlayersByRolesBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 51;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRolePlayersByRoles = 51;</code>
*/
public Builder mergeGetRolePlayersByRoles(ai.grakn.rpc.generated.GrpcConcept.Concepts value) {
if (getRolePlayersByRolesBuilder_ == null) {
if (conceptMethodCase_ == 51 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concepts.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 51) {
getRolePlayersByRolesBuilder_.mergeFrom(value);
}
getRolePlayersByRolesBuilder_.setMessage(value);
}
conceptMethodCase_ = 51;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRolePlayersByRoles = 51;</code>
*/
public Builder clearGetRolePlayersByRoles() {
if (getRolePlayersByRolesBuilder_ == null) {
if (conceptMethodCase_ == 51) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 51) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getRolePlayersByRolesBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRolePlayersByRoles = 51;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder getGetRolePlayersByRolesBuilder() {
return getGetRolePlayersByRolesFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRolePlayersByRoles = 51;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder getGetRolePlayersByRolesOrBuilder() {
if ((conceptMethodCase_ == 51) && (getRolePlayersByRolesBuilder_ != null)) {
return getRolePlayersByRolesBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 51) {
return (ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Concepts getRolePlayersByRoles = 51;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concepts, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder>
getGetRolePlayersByRolesFieldBuilder() {
if (getRolePlayersByRolesBuilder_ == null) {
if (!(conceptMethodCase_ == 51)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
getRolePlayersByRolesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concepts, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concepts) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 51;
onChanged();;
return getRolePlayersByRolesBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.RolePlayer, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder, ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder> setRolePlayerBuilder_;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer setRolePlayer = 46;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer getSetRolePlayer() {
if (setRolePlayerBuilder_ == null) {
if (conceptMethodCase_ == 46) {
return (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
} else {
if (conceptMethodCase_ == 46) {
return setRolePlayerBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer setRolePlayer = 46;</code>
*/
public Builder setSetRolePlayer(ai.grakn.rpc.generated.GrpcConcept.RolePlayer value) {
if (setRolePlayerBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
setRolePlayerBuilder_.setMessage(value);
}
conceptMethodCase_ = 46;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer setRolePlayer = 46;</code>
*/
public Builder setSetRolePlayer(
ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder builderForValue) {
if (setRolePlayerBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
setRolePlayerBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 46;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer setRolePlayer = 46;</code>
*/
public Builder mergeSetRolePlayer(ai.grakn.rpc.generated.GrpcConcept.RolePlayer value) {
if (setRolePlayerBuilder_ == null) {
if (conceptMethodCase_ == 46 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.RolePlayer.newBuilder((ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 46) {
setRolePlayerBuilder_.mergeFrom(value);
}
setRolePlayerBuilder_.setMessage(value);
}
conceptMethodCase_ = 46;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer setRolePlayer = 46;</code>
*/
public Builder clearSetRolePlayer() {
if (setRolePlayerBuilder_ == null) {
if (conceptMethodCase_ == 46) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 46) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
setRolePlayerBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer setRolePlayer = 46;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder getSetRolePlayerBuilder() {
return getSetRolePlayerFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer setRolePlayer = 46;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder getSetRolePlayerOrBuilder() {
if ((conceptMethodCase_ == 46) && (setRolePlayerBuilder_ != null)) {
return setRolePlayerBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 46) {
return (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer setRolePlayer = 46;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.RolePlayer, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder, ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder>
getSetRolePlayerFieldBuilder() {
if (setRolePlayerBuilder_ == null) {
if (!(conceptMethodCase_ == 46)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
setRolePlayerBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.RolePlayer, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder, ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 46;
onChanged();;
return setRolePlayerBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.RolePlayer, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder, ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder> unsetRolePlayerBuilder_;
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer unsetRolePlayer = 15;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer getUnsetRolePlayer() {
if (unsetRolePlayerBuilder_ == null) {
if (conceptMethodCase_ == 15) {
return (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
} else {
if (conceptMethodCase_ == 15) {
return unsetRolePlayerBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer unsetRolePlayer = 15;</code>
*/
public Builder setUnsetRolePlayer(ai.grakn.rpc.generated.GrpcConcept.RolePlayer value) {
if (unsetRolePlayerBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
unsetRolePlayerBuilder_.setMessage(value);
}
conceptMethodCase_ = 15;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer unsetRolePlayer = 15;</code>
*/
public Builder setUnsetRolePlayer(
ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder builderForValue) {
if (unsetRolePlayerBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
unsetRolePlayerBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 15;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer unsetRolePlayer = 15;</code>
*/
public Builder mergeUnsetRolePlayer(ai.grakn.rpc.generated.GrpcConcept.RolePlayer value) {
if (unsetRolePlayerBuilder_ == null) {
if (conceptMethodCase_ == 15 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.RolePlayer.newBuilder((ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 15) {
unsetRolePlayerBuilder_.mergeFrom(value);
}
unsetRolePlayerBuilder_.setMessage(value);
}
conceptMethodCase_ = 15;
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer unsetRolePlayer = 15;</code>
*/
public Builder clearUnsetRolePlayer() {
if (unsetRolePlayerBuilder_ == null) {
if (conceptMethodCase_ == 15) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 15) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
unsetRolePlayerBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer unsetRolePlayer = 15;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder getUnsetRolePlayerBuilder() {
return getUnsetRolePlayerFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer unsetRolePlayer = 15;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder getUnsetRolePlayerOrBuilder() {
if ((conceptMethodCase_ == 15) && (unsetRolePlayerBuilder_ != null)) {
return unsetRolePlayerBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 15) {
return (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
}
/**
* <pre>
* returns Unit
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RolePlayer unsetRolePlayer = 15;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.RolePlayer, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder, ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder>
getUnsetRolePlayerFieldBuilder() {
if (unsetRolePlayerBuilder_ == null) {
if (!(conceptMethodCase_ == 15)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
unsetRolePlayerBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.RolePlayer, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder, ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.RolePlayer) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 15;
onChanged();;
return unsetRolePlayerBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getValueBuilder_;
/**
* <pre>
* Attribute
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getValue = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetValue() {
if (getValueBuilder_ == null) {
if (conceptMethodCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 1) {
return getValueBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Attribute
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getValue = 1;</code>
*/
public Builder setGetValue(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getValueBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getValueBuilder_.setMessage(value);
}
conceptMethodCase_ = 1;
return this;
}
/**
* <pre>
* Attribute
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getValue = 1;</code>
*/
public Builder setGetValue(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getValueBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getValueBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 1;
return this;
}
/**
* <pre>
* Attribute
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getValue = 1;</code>
*/
public Builder mergeGetValue(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getValueBuilder_ == null) {
if (conceptMethodCase_ == 1 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 1) {
getValueBuilder_.mergeFrom(value);
}
getValueBuilder_.setMessage(value);
}
conceptMethodCase_ = 1;
return this;
}
/**
* <pre>
* Attribute
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getValue = 1;</code>
*/
public Builder clearGetValue() {
if (getValueBuilder_ == null) {
if (conceptMethodCase_ == 1) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 1) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getValueBuilder_.clear();
}
return this;
}
/**
* <pre>
* Attribute
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getValue = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetValueBuilder() {
return getGetValueFieldBuilder().getBuilder();
}
/**
* <pre>
* Attribute
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getValue = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetValueOrBuilder() {
if ((conceptMethodCase_ == 1) && (getValueBuilder_ != null)) {
return getValueBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* Attribute
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getValue = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetValueFieldBuilder() {
if (getValueBuilder_ == null) {
if (!(conceptMethodCase_ == 1)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getValueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 1;
onChanged();;
return getValueBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> getOwnersBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getOwners = 47;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getGetOwners() {
if (getOwnersBuilder_ == null) {
if (conceptMethodCase_ == 47) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (conceptMethodCase_ == 47) {
return getOwnersBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getOwners = 47;</code>
*/
public Builder setGetOwners(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getOwnersBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
getOwnersBuilder_.setMessage(value);
}
conceptMethodCase_ = 47;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getOwners = 47;</code>
*/
public Builder setGetOwners(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (getOwnersBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
getOwnersBuilder_.setMessage(builderForValue.build());
}
conceptMethodCase_ = 47;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getOwners = 47;</code>
*/
public Builder mergeGetOwners(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (getOwnersBuilder_ == null) {
if (conceptMethodCase_ == 47 &&
conceptMethod_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_)
.mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
if (conceptMethodCase_ == 47) {
getOwnersBuilder_.mergeFrom(value);
}
getOwnersBuilder_.setMessage(value);
}
conceptMethodCase_ = 47;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getOwners = 47;</code>
*/
public Builder clearGetOwners() {
if (getOwnersBuilder_ == null) {
if (conceptMethodCase_ == 47) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
onChanged();
}
} else {
if (conceptMethodCase_ == 47) {
conceptMethodCase_ = 0;
conceptMethod_ = null;
}
getOwnersBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getOwners = 47;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getGetOwnersBuilder() {
return getGetOwnersFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getOwners = 47;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getGetOwnersOrBuilder() {
if ((conceptMethodCase_ == 47) && (getOwnersBuilder_ != null)) {
return getOwnersBuilder_.getMessageOrBuilder();
} else {
if (conceptMethodCase_ == 47) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Unit getOwners = 47;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getGetOwnersFieldBuilder() {
if (getOwnersBuilder_ == null) {
if (!(conceptMethodCase_ == 47)) {
conceptMethod_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
getOwnersBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) conceptMethod_,
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
conceptMethodCase_ = 47;
onChanged();;
return getOwnersBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.ConceptMethod)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.ConceptMethod)
private static final ai.grakn.rpc.generated.GrpcConcept.ConceptMethod DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.ConceptMethod();
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptMethod getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<ConceptMethod>
PARSER = new com.google.protobuf.AbstractParser<ConceptMethod>() {
public ConceptMethod parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new ConceptMethod(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<ConceptMethod> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<ConceptMethod> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.ConceptMethod getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface UnitOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Unit)
com.google.protobuf.MessageOrBuilder {
}
/**
* <pre>
* Represents a message with no information
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Unit}
*/
public static final class Unit extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Unit)
UnitOrBuilder {
// Use Unit.newBuilder() to construct.
private Unit(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Unit() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Unit(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Unit_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Unit_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.Unit.class, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder.class);
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.Unit)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.Unit other = (ai.grakn.rpc.generated.GrpcConcept.Unit) obj;
boolean result = true;
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.Unit parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.Unit parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Unit parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.Unit parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Unit parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Unit parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Unit parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Unit parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Unit parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Unit parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.Unit prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* <pre>
* Represents a message with no information
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Unit}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Unit)
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Unit_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Unit_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.Unit.class, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Unit_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.Unit getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.Unit build() {
ai.grakn.rpc.generated.GrpcConcept.Unit result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.Unit buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.Unit result = new ai.grakn.rpc.generated.GrpcConcept.Unit(this);
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.Unit) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.Unit other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) return this;
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.Unit parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.Unit) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Unit)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Unit)
private static final ai.grakn.rpc.generated.GrpcConcept.Unit DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.Unit();
}
public static ai.grakn.rpc.generated.GrpcConcept.Unit getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Unit>
PARSER = new com.google.protobuf.AbstractParser<Unit>() {
public Unit parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Unit(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Unit> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Unit> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.Unit getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface ConceptResponseOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.ConceptResponse)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.AttributeValue attributeValue = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.AttributeValue getAttributeValue();
/**
* <code>optional .ai.grakn.rpc.generated.AttributeValue attributeValue = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder getAttributeValueOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
int getDataTypeValue();
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.DataType getDataType();
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 3;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Label getLabel();
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 3;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getLabelOrBuilder();
/**
* <code>optional bool bool = 4;</code>
*/
boolean getBool();
/**
* <code>optional .ai.grakn.rpc.generated.OptionalPattern optionalPattern = 5;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.OptionalPattern getOptionalPattern();
/**
* <code>optional .ai.grakn.rpc.generated.OptionalPattern optionalPattern = 5;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.OptionalPatternOrBuilder getOptionalPatternOrBuilder();
/**
* <code>optional string string = 6;</code>
*/
java.lang.String getString();
/**
* <code>optional string string = 6;</code>
*/
com.google.protobuf.ByteString
getStringBytes();
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 9;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getConcept();
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 9;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getConceptOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.Unit unit = 10;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getUnit();
/**
* <code>optional .ai.grakn.rpc.generated.Unit unit = 10;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getUnitOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.OptionalRegex optionalRegex = 11;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex getOptionalRegex();
/**
* <code>optional .ai.grakn.rpc.generated.OptionalRegex optionalRegex = 11;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.OptionalRegexOrBuilder getOptionalRegexOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 12;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept getOptionalConcept();
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 12;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.OptionalConceptOrBuilder getOptionalConceptOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.OptionalDataType optionalDataType = 13;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.OptionalDataType getOptionalDataType();
/**
* <code>optional .ai.grakn.rpc.generated.OptionalDataType optionalDataType = 13;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.OptionalDataTypeOrBuilder getOptionalDataTypeOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 14;</code>
*/
ai.grakn.rpc.generated.GrpcIterator.IteratorId getIteratorId();
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 14;</code>
*/
ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder getIteratorIdOrBuilder();
public ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.ValueCase getValueCase();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.ConceptResponse}
*/
public static final class ConceptResponse extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.ConceptResponse)
ConceptResponseOrBuilder {
// Use ConceptResponse.newBuilder() to construct.
private ConceptResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private ConceptResponse() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private ConceptResponse(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder subBuilder = null;
if (valueCase_ == 1) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.AttributeValue) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.AttributeValue.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.AttributeValue) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 1;
break;
}
case 16: {
int rawValue = input.readEnum();
valueCase_ = 2;
value_ = rawValue;
break;
}
case 26: {
ai.grakn.rpc.generated.GrpcConcept.Label.Builder subBuilder = null;
if (valueCase_ == 3) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Label) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Label.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Label) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 3;
break;
}
case 32: {
valueCase_ = 4;
value_ = input.readBool();
break;
}
case 42: {
ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.Builder subBuilder = null;
if (valueCase_ == 5) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.OptionalPattern) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.OptionalPattern) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 5;
break;
}
case 50: {
java.lang.String s = input.readStringRequireUtf8();
valueCase_ = 6;
value_ = s;
break;
}
case 74: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (valueCase_ == 9) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 9;
break;
}
case 82: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (valueCase_ == 10) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 10;
break;
}
case 90: {
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder subBuilder = null;
if (valueCase_ == 11) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 11;
break;
}
case 98: {
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder subBuilder = null;
if (valueCase_ == 12) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 12;
break;
}
case 106: {
ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.Builder subBuilder = null;
if (valueCase_ == 13) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.OptionalDataType) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.OptionalDataType) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 13;
break;
}
case 114: {
ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder subBuilder = null;
if (valueCase_ == 14) {
subBuilder = ((ai.grakn.rpc.generated.GrpcIterator.IteratorId) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcIterator.IteratorId.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcIterator.IteratorId) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 14;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptResponse_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptResponse_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.class, ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.Builder.class);
}
private int valueCase_ = 0;
private java.lang.Object value_;
public enum ValueCase
implements com.google.protobuf.Internal.EnumLite {
ATTRIBUTEVALUE(1),
DATATYPE(2),
LABEL(3),
BOOL(4),
OPTIONALPATTERN(5),
STRING(6),
CONCEPT(9),
UNIT(10),
OPTIONALREGEX(11),
OPTIONALCONCEPT(12),
OPTIONALDATATYPE(13),
ITERATORID(14),
VALUE_NOT_SET(0);
private final int value;
private ValueCase(int value) {
this.value = value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static ValueCase valueOf(int value) {
return forNumber(value);
}
public static ValueCase forNumber(int value) {
switch (value) {
case 1: return ATTRIBUTEVALUE;
case 2: return DATATYPE;
case 3: return LABEL;
case 4: return BOOL;
case 5: return OPTIONALPATTERN;
case 6: return STRING;
case 9: return CONCEPT;
case 10: return UNIT;
case 11: return OPTIONALREGEX;
case 12: return OPTIONALCONCEPT;
case 13: return OPTIONALDATATYPE;
case 14: return ITERATORID;
case 0: return VALUE_NOT_SET;
default: return null;
}
}
public int getNumber() {
return this.value;
}
};
public ValueCase
getValueCase() {
return ValueCase.forNumber(
valueCase_);
}
public static final int ATTRIBUTEVALUE_FIELD_NUMBER = 1;
/**
* <code>optional .ai.grakn.rpc.generated.AttributeValue attributeValue = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue getAttributeValue() {
if (valueCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.AttributeValue attributeValue = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder getAttributeValueOrBuilder() {
if (valueCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
public static final int DATATYPE_FIELD_NUMBER = 2;
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public int getDataTypeValue() {
if (valueCase_ == 2) {
return (java.lang.Integer) value_;
}
return 0;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.DataType getDataType() {
if (valueCase_ == 2) {
ai.grakn.rpc.generated.GrpcConcept.DataType result = ai.grakn.rpc.generated.GrpcConcept.DataType.valueOf(
(java.lang.Integer) value_);
return result == null ? ai.grakn.rpc.generated.GrpcConcept.DataType.UNRECOGNIZED : result;
}
return ai.grakn.rpc.generated.GrpcConcept.DataType.String;
}
public static final int LABEL_FIELD_NUMBER = 3;
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getLabel() {
if (valueCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getLabelOrBuilder() {
if (valueCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
public static final int BOOL_FIELD_NUMBER = 4;
/**
* <code>optional bool bool = 4;</code>
*/
public boolean getBool() {
if (valueCase_ == 4) {
return (java.lang.Boolean) value_;
}
return false;
}
public static final int OPTIONALPATTERN_FIELD_NUMBER = 5;
/**
* <code>optional .ai.grakn.rpc.generated.OptionalPattern optionalPattern = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalPattern getOptionalPattern() {
if (valueCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalPattern) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalPattern optionalPattern = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalPatternOrBuilder getOptionalPatternOrBuilder() {
if (valueCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalPattern) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.getDefaultInstance();
}
public static final int STRING_FIELD_NUMBER = 6;
/**
* <code>optional string string = 6;</code>
*/
public java.lang.String getString() {
java.lang.Object ref = "";
if (valueCase_ == 6) {
ref = value_;
}
if (ref instanceof java.lang.String) {
return (java.lang.String) ref;
} else {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
if (valueCase_ == 6) {
value_ = s;
}
return s;
}
}
/**
* <code>optional string string = 6;</code>
*/
public com.google.protobuf.ByteString
getStringBytes() {
java.lang.Object ref = "";
if (valueCase_ == 6) {
ref = value_;
}
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
if (valueCase_ == 6) {
value_ = b;
}
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
public static final int CONCEPT_FIELD_NUMBER = 9;
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getConcept() {
if (valueCase_ == 9) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getConceptOrBuilder() {
if (valueCase_ == 9) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int UNIT_FIELD_NUMBER = 10;
/**
* <code>optional .ai.grakn.rpc.generated.Unit unit = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getUnit() {
if (valueCase_ == 10) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit unit = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getUnitOrBuilder() {
if (valueCase_ == 10) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
public static final int OPTIONALREGEX_FIELD_NUMBER = 11;
/**
* <code>optional .ai.grakn.rpc.generated.OptionalRegex optionalRegex = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegex getOptionalRegex() {
if (valueCase_ == 11) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalRegex optionalRegex = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegexOrBuilder getOptionalRegexOrBuilder() {
if (valueCase_ == 11) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance();
}
public static final int OPTIONALCONCEPT_FIELD_NUMBER = 12;
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalConcept getOptionalConcept() {
if (valueCase_ == 12) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalConceptOrBuilder getOptionalConceptOrBuilder() {
if (valueCase_ == 12) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance();
}
public static final int OPTIONALDATATYPE_FIELD_NUMBER = 13;
/**
* <code>optional .ai.grakn.rpc.generated.OptionalDataType optionalDataType = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalDataType getOptionalDataType() {
if (valueCase_ == 13) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalDataType) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalDataType optionalDataType = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalDataTypeOrBuilder getOptionalDataTypeOrBuilder() {
if (valueCase_ == 13) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalDataType) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.getDefaultInstance();
}
public static final int ITERATORID_FIELD_NUMBER = 14;
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorId getIteratorId() {
if (valueCase_ == 14) {
return (ai.grakn.rpc.generated.GrpcIterator.IteratorId) value_;
}
return ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder getIteratorIdOrBuilder() {
if (valueCase_ == 14) {
return (ai.grakn.rpc.generated.GrpcIterator.IteratorId) value_;
}
return ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (valueCase_ == 1) {
output.writeMessage(1, (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) value_);
}
if (valueCase_ == 2) {
output.writeEnum(2, ((java.lang.Integer) value_));
}
if (valueCase_ == 3) {
output.writeMessage(3, (ai.grakn.rpc.generated.GrpcConcept.Label) value_);
}
if (valueCase_ == 4) {
output.writeBool(
4, (boolean)((java.lang.Boolean) value_));
}
if (valueCase_ == 5) {
output.writeMessage(5, (ai.grakn.rpc.generated.GrpcConcept.OptionalPattern) value_);
}
if (valueCase_ == 6) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 6, value_);
}
if (valueCase_ == 9) {
output.writeMessage(9, (ai.grakn.rpc.generated.GrpcConcept.Concept) value_);
}
if (valueCase_ == 10) {
output.writeMessage(10, (ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
}
if (valueCase_ == 11) {
output.writeMessage(11, (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) value_);
}
if (valueCase_ == 12) {
output.writeMessage(12, (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) value_);
}
if (valueCase_ == 13) {
output.writeMessage(13, (ai.grakn.rpc.generated.GrpcConcept.OptionalDataType) value_);
}
if (valueCase_ == 14) {
output.writeMessage(14, (ai.grakn.rpc.generated.GrpcIterator.IteratorId) value_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (valueCase_ == 1) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) value_);
}
if (valueCase_ == 2) {
size += com.google.protobuf.CodedOutputStream
.computeEnumSize(2, ((java.lang.Integer) value_));
}
if (valueCase_ == 3) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(3, (ai.grakn.rpc.generated.GrpcConcept.Label) value_);
}
if (valueCase_ == 4) {
size += com.google.protobuf.CodedOutputStream
.computeBoolSize(
4, (boolean)((java.lang.Boolean) value_));
}
if (valueCase_ == 5) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(5, (ai.grakn.rpc.generated.GrpcConcept.OptionalPattern) value_);
}
if (valueCase_ == 6) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(6, value_);
}
if (valueCase_ == 9) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(9, (ai.grakn.rpc.generated.GrpcConcept.Concept) value_);
}
if (valueCase_ == 10) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(10, (ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
}
if (valueCase_ == 11) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(11, (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) value_);
}
if (valueCase_ == 12) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(12, (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) value_);
}
if (valueCase_ == 13) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(13, (ai.grakn.rpc.generated.GrpcConcept.OptionalDataType) value_);
}
if (valueCase_ == 14) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(14, (ai.grakn.rpc.generated.GrpcIterator.IteratorId) value_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.ConceptResponse)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.ConceptResponse other = (ai.grakn.rpc.generated.GrpcConcept.ConceptResponse) obj;
boolean result = true;
result = result && getValueCase().equals(
other.getValueCase());
if (!result) return false;
switch (valueCase_) {
case 1:
result = result && getAttributeValue()
.equals(other.getAttributeValue());
break;
case 2:
result = result && getDataTypeValue()
== other.getDataTypeValue();
break;
case 3:
result = result && getLabel()
.equals(other.getLabel());
break;
case 4:
result = result && (getBool()
== other.getBool());
break;
case 5:
result = result && getOptionalPattern()
.equals(other.getOptionalPattern());
break;
case 6:
result = result && getString()
.equals(other.getString());
break;
case 9:
result = result && getConcept()
.equals(other.getConcept());
break;
case 10:
result = result && getUnit()
.equals(other.getUnit());
break;
case 11:
result = result && getOptionalRegex()
.equals(other.getOptionalRegex());
break;
case 12:
result = result && getOptionalConcept()
.equals(other.getOptionalConcept());
break;
case 13:
result = result && getOptionalDataType()
.equals(other.getOptionalDataType());
break;
case 14:
result = result && getIteratorId()
.equals(other.getIteratorId());
break;
case 0:
default:
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
switch (valueCase_) {
case 1:
hash = (37 * hash) + ATTRIBUTEVALUE_FIELD_NUMBER;
hash = (53 * hash) + getAttributeValue().hashCode();
break;
case 2:
hash = (37 * hash) + DATATYPE_FIELD_NUMBER;
hash = (53 * hash) + getDataTypeValue();
break;
case 3:
hash = (37 * hash) + LABEL_FIELD_NUMBER;
hash = (53 * hash) + getLabel().hashCode();
break;
case 4:
hash = (37 * hash) + BOOL_FIELD_NUMBER;
hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
getBool());
break;
case 5:
hash = (37 * hash) + OPTIONALPATTERN_FIELD_NUMBER;
hash = (53 * hash) + getOptionalPattern().hashCode();
break;
case 6:
hash = (37 * hash) + STRING_FIELD_NUMBER;
hash = (53 * hash) + getString().hashCode();
break;
case 9:
hash = (37 * hash) + CONCEPT_FIELD_NUMBER;
hash = (53 * hash) + getConcept().hashCode();
break;
case 10:
hash = (37 * hash) + UNIT_FIELD_NUMBER;
hash = (53 * hash) + getUnit().hashCode();
break;
case 11:
hash = (37 * hash) + OPTIONALREGEX_FIELD_NUMBER;
hash = (53 * hash) + getOptionalRegex().hashCode();
break;
case 12:
hash = (37 * hash) + OPTIONALCONCEPT_FIELD_NUMBER;
hash = (53 * hash) + getOptionalConcept().hashCode();
break;
case 13:
hash = (37 * hash) + OPTIONALDATATYPE_FIELD_NUMBER;
hash = (53 * hash) + getOptionalDataType().hashCode();
break;
case 14:
hash = (37 * hash) + ITERATORID_FIELD_NUMBER;
hash = (53 * hash) + getIteratorId().hashCode();
break;
case 0:
default:
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptResponse parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptResponse parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptResponse parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptResponse parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptResponse parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptResponse parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptResponse parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptResponse parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptResponse parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptResponse parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.ConceptResponse prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.ConceptResponse}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.ConceptResponse)
ai.grakn.rpc.generated.GrpcConcept.ConceptResponseOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptResponse_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptResponse_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.class, ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
valueCase_ = 0;
value_ = null;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_ConceptResponse_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.ConceptResponse getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.ConceptResponse build() {
ai.grakn.rpc.generated.GrpcConcept.ConceptResponse result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.ConceptResponse buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.ConceptResponse result = new ai.grakn.rpc.generated.GrpcConcept.ConceptResponse(this);
if (valueCase_ == 1) {
if (attributeValueBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = attributeValueBuilder_.build();
}
}
if (valueCase_ == 2) {
result.value_ = value_;
}
if (valueCase_ == 3) {
if (labelBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = labelBuilder_.build();
}
}
if (valueCase_ == 4) {
result.value_ = value_;
}
if (valueCase_ == 5) {
if (optionalPatternBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = optionalPatternBuilder_.build();
}
}
if (valueCase_ == 6) {
result.value_ = value_;
}
if (valueCase_ == 9) {
if (conceptBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = conceptBuilder_.build();
}
}
if (valueCase_ == 10) {
if (unitBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = unitBuilder_.build();
}
}
if (valueCase_ == 11) {
if (optionalRegexBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = optionalRegexBuilder_.build();
}
}
if (valueCase_ == 12) {
if (optionalConceptBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = optionalConceptBuilder_.build();
}
}
if (valueCase_ == 13) {
if (optionalDataTypeBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = optionalDataTypeBuilder_.build();
}
}
if (valueCase_ == 14) {
if (iteratorIdBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = iteratorIdBuilder_.build();
}
}
result.valueCase_ = valueCase_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.ConceptResponse) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.ConceptResponse)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.ConceptResponse other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.getDefaultInstance()) return this;
switch (other.getValueCase()) {
case ATTRIBUTEVALUE: {
mergeAttributeValue(other.getAttributeValue());
break;
}
case DATATYPE: {
setDataTypeValue(other.getDataTypeValue());
break;
}
case LABEL: {
mergeLabel(other.getLabel());
break;
}
case BOOL: {
setBool(other.getBool());
break;
}
case OPTIONALPATTERN: {
mergeOptionalPattern(other.getOptionalPattern());
break;
}
case STRING: {
valueCase_ = 6;
value_ = other.value_;
onChanged();
break;
}
case CONCEPT: {
mergeConcept(other.getConcept());
break;
}
case UNIT: {
mergeUnit(other.getUnit());
break;
}
case OPTIONALREGEX: {
mergeOptionalRegex(other.getOptionalRegex());
break;
}
case OPTIONALCONCEPT: {
mergeOptionalConcept(other.getOptionalConcept());
break;
}
case OPTIONALDATATYPE: {
mergeOptionalDataType(other.getOptionalDataType());
break;
}
case ITERATORID: {
mergeIteratorId(other.getIteratorId());
break;
}
case VALUE_NOT_SET: {
break;
}
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.ConceptResponse parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.ConceptResponse) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int valueCase_ = 0;
private java.lang.Object value_;
public ValueCase
getValueCase() {
return ValueCase.forNumber(
valueCase_);
}
public Builder clearValue() {
valueCase_ = 0;
value_ = null;
onChanged();
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.AttributeValue, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder, ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder> attributeValueBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.AttributeValue attributeValue = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue getAttributeValue() {
if (attributeValueBuilder_ == null) {
if (valueCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
} else {
if (valueCase_ == 1) {
return attributeValueBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.AttributeValue attributeValue = 1;</code>
*/
public Builder setAttributeValue(ai.grakn.rpc.generated.GrpcConcept.AttributeValue value) {
if (attributeValueBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
attributeValueBuilder_.setMessage(value);
}
valueCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.AttributeValue attributeValue = 1;</code>
*/
public Builder setAttributeValue(
ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder builderForValue) {
if (attributeValueBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
attributeValueBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.AttributeValue attributeValue = 1;</code>
*/
public Builder mergeAttributeValue(ai.grakn.rpc.generated.GrpcConcept.AttributeValue value) {
if (attributeValueBuilder_ == null) {
if (valueCase_ == 1 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.AttributeValue.newBuilder((ai.grakn.rpc.generated.GrpcConcept.AttributeValue) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 1) {
attributeValueBuilder_.mergeFrom(value);
}
attributeValueBuilder_.setMessage(value);
}
valueCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.AttributeValue attributeValue = 1;</code>
*/
public Builder clearAttributeValue() {
if (attributeValueBuilder_ == null) {
if (valueCase_ == 1) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 1) {
valueCase_ = 0;
value_ = null;
}
attributeValueBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.AttributeValue attributeValue = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder getAttributeValueBuilder() {
return getAttributeValueFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.AttributeValue attributeValue = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder getAttributeValueOrBuilder() {
if ((valueCase_ == 1) && (attributeValueBuilder_ != null)) {
return attributeValueBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.AttributeValue attributeValue = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.AttributeValue, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder, ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder>
getAttributeValueFieldBuilder() {
if (attributeValueBuilder_ == null) {
if (!(valueCase_ == 1)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
attributeValueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.AttributeValue, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder, ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.AttributeValue) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 1;
onChanged();;
return attributeValueBuilder_;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public int getDataTypeValue() {
if (valueCase_ == 2) {
return ((java.lang.Integer) value_).intValue();
}
return 0;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public Builder setDataTypeValue(int value) {
valueCase_ = 2;
value_ = value;
onChanged();
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.DataType getDataType() {
if (valueCase_ == 2) {
ai.grakn.rpc.generated.GrpcConcept.DataType result = ai.grakn.rpc.generated.GrpcConcept.DataType.valueOf(
(java.lang.Integer) value_);
return result == null ? ai.grakn.rpc.generated.GrpcConcept.DataType.UNRECOGNIZED : result;
}
return ai.grakn.rpc.generated.GrpcConcept.DataType.String;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public Builder setDataType(ai.grakn.rpc.generated.GrpcConcept.DataType value) {
if (value == null) {
throw new NullPointerException();
}
valueCase_ = 2;
value_ = value.getNumber();
onChanged();
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public Builder clearDataType() {
if (valueCase_ == 2) {
valueCase_ = 0;
value_ = null;
onChanged();
}
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder> labelBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getLabel() {
if (labelBuilder_ == null) {
if (valueCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
} else {
if (valueCase_ == 3) {
return labelBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 3;</code>
*/
public Builder setLabel(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (labelBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
labelBuilder_.setMessage(value);
}
valueCase_ = 3;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 3;</code>
*/
public Builder setLabel(
ai.grakn.rpc.generated.GrpcConcept.Label.Builder builderForValue) {
if (labelBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
labelBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 3;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 3;</code>
*/
public Builder mergeLabel(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (labelBuilder_ == null) {
if (valueCase_ == 3 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Label.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Label) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 3) {
labelBuilder_.mergeFrom(value);
}
labelBuilder_.setMessage(value);
}
valueCase_ = 3;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 3;</code>
*/
public Builder clearLabel() {
if (labelBuilder_ == null) {
if (valueCase_ == 3) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 3) {
valueCase_ = 0;
value_ = null;
}
labelBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label.Builder getLabelBuilder() {
return getLabelFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getLabelOrBuilder() {
if ((valueCase_ == 3) && (labelBuilder_ != null)) {
return labelBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 3;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>
getLabelFieldBuilder() {
if (labelBuilder_ == null) {
if (!(valueCase_ == 3)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
labelBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Label) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 3;
onChanged();;
return labelBuilder_;
}
/**
* <code>optional bool bool = 4;</code>
*/
public boolean getBool() {
if (valueCase_ == 4) {
return (java.lang.Boolean) value_;
}
return false;
}
/**
* <code>optional bool bool = 4;</code>
*/
public Builder setBool(boolean value) {
valueCase_ = 4;
value_ = value;
onChanged();
return this;
}
/**
* <code>optional bool bool = 4;</code>
*/
public Builder clearBool() {
if (valueCase_ == 4) {
valueCase_ = 0;
value_ = null;
onChanged();
}
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalPattern, ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalPatternOrBuilder> optionalPatternBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.OptionalPattern optionalPattern = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalPattern getOptionalPattern() {
if (optionalPatternBuilder_ == null) {
if (valueCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalPattern) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.getDefaultInstance();
} else {
if (valueCase_ == 5) {
return optionalPatternBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalPattern optionalPattern = 5;</code>
*/
public Builder setOptionalPattern(ai.grakn.rpc.generated.GrpcConcept.OptionalPattern value) {
if (optionalPatternBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
optionalPatternBuilder_.setMessage(value);
}
valueCase_ = 5;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalPattern optionalPattern = 5;</code>
*/
public Builder setOptionalPattern(
ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.Builder builderForValue) {
if (optionalPatternBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
optionalPatternBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 5;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalPattern optionalPattern = 5;</code>
*/
public Builder mergeOptionalPattern(ai.grakn.rpc.generated.GrpcConcept.OptionalPattern value) {
if (optionalPatternBuilder_ == null) {
if (valueCase_ == 5 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.newBuilder((ai.grakn.rpc.generated.GrpcConcept.OptionalPattern) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 5) {
optionalPatternBuilder_.mergeFrom(value);
}
optionalPatternBuilder_.setMessage(value);
}
valueCase_ = 5;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalPattern optionalPattern = 5;</code>
*/
public Builder clearOptionalPattern() {
if (optionalPatternBuilder_ == null) {
if (valueCase_ == 5) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 5) {
valueCase_ = 0;
value_ = null;
}
optionalPatternBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalPattern optionalPattern = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.Builder getOptionalPatternBuilder() {
return getOptionalPatternFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalPattern optionalPattern = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalPatternOrBuilder getOptionalPatternOrBuilder() {
if ((valueCase_ == 5) && (optionalPatternBuilder_ != null)) {
return optionalPatternBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalPattern) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalPattern optionalPattern = 5;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalPattern, ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalPatternOrBuilder>
getOptionalPatternFieldBuilder() {
if (optionalPatternBuilder_ == null) {
if (!(valueCase_ == 5)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.getDefaultInstance();
}
optionalPatternBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalPattern, ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalPatternOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.OptionalPattern) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 5;
onChanged();;
return optionalPatternBuilder_;
}
/**
* <code>optional string string = 6;</code>
*/
public java.lang.String getString() {
java.lang.Object ref = "";
if (valueCase_ == 6) {
ref = value_;
}
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
if (valueCase_ == 6) {
value_ = s;
}
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <code>optional string string = 6;</code>
*/
public com.google.protobuf.ByteString
getStringBytes() {
java.lang.Object ref = "";
if (valueCase_ == 6) {
ref = value_;
}
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
if (valueCase_ == 6) {
value_ = b;
}
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <code>optional string string = 6;</code>
*/
public Builder setString(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
valueCase_ = 6;
value_ = value;
onChanged();
return this;
}
/**
* <code>optional string string = 6;</code>
*/
public Builder clearString() {
if (valueCase_ == 6) {
valueCase_ = 0;
value_ = null;
onChanged();
}
return this;
}
/**
* <code>optional string string = 6;</code>
*/
public Builder setStringBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
valueCase_ = 6;
value_ = value;
onChanged();
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> conceptBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getConcept() {
if (conceptBuilder_ == null) {
if (valueCase_ == 9) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (valueCase_ == 9) {
return conceptBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 9;</code>
*/
public Builder setConcept(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (conceptBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
conceptBuilder_.setMessage(value);
}
valueCase_ = 9;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 9;</code>
*/
public Builder setConcept(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (conceptBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
conceptBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 9;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 9;</code>
*/
public Builder mergeConcept(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (conceptBuilder_ == null) {
if (valueCase_ == 9 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 9) {
conceptBuilder_.mergeFrom(value);
}
conceptBuilder_.setMessage(value);
}
valueCase_ = 9;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 9;</code>
*/
public Builder clearConcept() {
if (conceptBuilder_ == null) {
if (valueCase_ == 9) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 9) {
valueCase_ = 0;
value_ = null;
}
conceptBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getConceptBuilder() {
return getConceptFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getConceptOrBuilder() {
if ((valueCase_ == 9) && (conceptBuilder_ != null)) {
return conceptBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 9) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 9;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getConceptFieldBuilder() {
if (conceptBuilder_ == null) {
if (!(valueCase_ == 9)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
conceptBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 9;
onChanged();;
return conceptBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> unitBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Unit unit = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getUnit() {
if (unitBuilder_ == null) {
if (valueCase_ == 10) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (valueCase_ == 10) {
return unitBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit unit = 10;</code>
*/
public Builder setUnit(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (unitBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
unitBuilder_.setMessage(value);
}
valueCase_ = 10;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit unit = 10;</code>
*/
public Builder setUnit(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (unitBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
unitBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 10;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit unit = 10;</code>
*/
public Builder mergeUnit(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (unitBuilder_ == null) {
if (valueCase_ == 10 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 10) {
unitBuilder_.mergeFrom(value);
}
unitBuilder_.setMessage(value);
}
valueCase_ = 10;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit unit = 10;</code>
*/
public Builder clearUnit() {
if (unitBuilder_ == null) {
if (valueCase_ == 10) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 10) {
valueCase_ = 0;
value_ = null;
}
unitBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit unit = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getUnitBuilder() {
return getUnitFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit unit = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getUnitOrBuilder() {
if ((valueCase_ == 10) && (unitBuilder_ != null)) {
return unitBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 10) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit unit = 10;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getUnitFieldBuilder() {
if (unitBuilder_ == null) {
if (!(valueCase_ == 10)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
unitBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 10;
onChanged();;
return unitBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex, ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalRegexOrBuilder> optionalRegexBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.OptionalRegex optionalRegex = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegex getOptionalRegex() {
if (optionalRegexBuilder_ == null) {
if (valueCase_ == 11) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance();
} else {
if (valueCase_ == 11) {
return optionalRegexBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalRegex optionalRegex = 11;</code>
*/
public Builder setOptionalRegex(ai.grakn.rpc.generated.GrpcConcept.OptionalRegex value) {
if (optionalRegexBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
optionalRegexBuilder_.setMessage(value);
}
valueCase_ = 11;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalRegex optionalRegex = 11;</code>
*/
public Builder setOptionalRegex(
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder builderForValue) {
if (optionalRegexBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
optionalRegexBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 11;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalRegex optionalRegex = 11;</code>
*/
public Builder mergeOptionalRegex(ai.grakn.rpc.generated.GrpcConcept.OptionalRegex value) {
if (optionalRegexBuilder_ == null) {
if (valueCase_ == 11 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.newBuilder((ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 11) {
optionalRegexBuilder_.mergeFrom(value);
}
optionalRegexBuilder_.setMessage(value);
}
valueCase_ = 11;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalRegex optionalRegex = 11;</code>
*/
public Builder clearOptionalRegex() {
if (optionalRegexBuilder_ == null) {
if (valueCase_ == 11) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 11) {
valueCase_ = 0;
value_ = null;
}
optionalRegexBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalRegex optionalRegex = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder getOptionalRegexBuilder() {
return getOptionalRegexFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalRegex optionalRegex = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegexOrBuilder getOptionalRegexOrBuilder() {
if ((valueCase_ == 11) && (optionalRegexBuilder_ != null)) {
return optionalRegexBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 11) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalRegex optionalRegex = 11;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex, ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalRegexOrBuilder>
getOptionalRegexFieldBuilder() {
if (optionalRegexBuilder_ == null) {
if (!(valueCase_ == 11)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance();
}
optionalRegexBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex, ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalRegexOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 11;
onChanged();;
return optionalRegexBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept, ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalConceptOrBuilder> optionalConceptBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalConcept getOptionalConcept() {
if (optionalConceptBuilder_ == null) {
if (valueCase_ == 12) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance();
} else {
if (valueCase_ == 12) {
return optionalConceptBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 12;</code>
*/
public Builder setOptionalConcept(ai.grakn.rpc.generated.GrpcConcept.OptionalConcept value) {
if (optionalConceptBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
optionalConceptBuilder_.setMessage(value);
}
valueCase_ = 12;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 12;</code>
*/
public Builder setOptionalConcept(
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder builderForValue) {
if (optionalConceptBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
optionalConceptBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 12;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 12;</code>
*/
public Builder mergeOptionalConcept(ai.grakn.rpc.generated.GrpcConcept.OptionalConcept value) {
if (optionalConceptBuilder_ == null) {
if (valueCase_ == 12 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 12) {
optionalConceptBuilder_.mergeFrom(value);
}
optionalConceptBuilder_.setMessage(value);
}
valueCase_ = 12;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 12;</code>
*/
public Builder clearOptionalConcept() {
if (optionalConceptBuilder_ == null) {
if (valueCase_ == 12) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 12) {
valueCase_ = 0;
value_ = null;
}
optionalConceptBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder getOptionalConceptBuilder() {
return getOptionalConceptFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalConceptOrBuilder getOptionalConceptOrBuilder() {
if ((valueCase_ == 12) && (optionalConceptBuilder_ != null)) {
return optionalConceptBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 12) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 12;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept, ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalConceptOrBuilder>
getOptionalConceptFieldBuilder() {
if (optionalConceptBuilder_ == null) {
if (!(valueCase_ == 12)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance();
}
optionalConceptBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept, ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 12;
onChanged();;
return optionalConceptBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalDataType, ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalDataTypeOrBuilder> optionalDataTypeBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.OptionalDataType optionalDataType = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalDataType getOptionalDataType() {
if (optionalDataTypeBuilder_ == null) {
if (valueCase_ == 13) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalDataType) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.getDefaultInstance();
} else {
if (valueCase_ == 13) {
return optionalDataTypeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalDataType optionalDataType = 13;</code>
*/
public Builder setOptionalDataType(ai.grakn.rpc.generated.GrpcConcept.OptionalDataType value) {
if (optionalDataTypeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
optionalDataTypeBuilder_.setMessage(value);
}
valueCase_ = 13;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalDataType optionalDataType = 13;</code>
*/
public Builder setOptionalDataType(
ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.Builder builderForValue) {
if (optionalDataTypeBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
optionalDataTypeBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 13;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalDataType optionalDataType = 13;</code>
*/
public Builder mergeOptionalDataType(ai.grakn.rpc.generated.GrpcConcept.OptionalDataType value) {
if (optionalDataTypeBuilder_ == null) {
if (valueCase_ == 13 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.newBuilder((ai.grakn.rpc.generated.GrpcConcept.OptionalDataType) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 13) {
optionalDataTypeBuilder_.mergeFrom(value);
}
optionalDataTypeBuilder_.setMessage(value);
}
valueCase_ = 13;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalDataType optionalDataType = 13;</code>
*/
public Builder clearOptionalDataType() {
if (optionalDataTypeBuilder_ == null) {
if (valueCase_ == 13) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 13) {
valueCase_ = 0;
value_ = null;
}
optionalDataTypeBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalDataType optionalDataType = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.Builder getOptionalDataTypeBuilder() {
return getOptionalDataTypeFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalDataType optionalDataType = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalDataTypeOrBuilder getOptionalDataTypeOrBuilder() {
if ((valueCase_ == 13) && (optionalDataTypeBuilder_ != null)) {
return optionalDataTypeBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 13) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalDataType) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalDataType optionalDataType = 13;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalDataType, ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalDataTypeOrBuilder>
getOptionalDataTypeFieldBuilder() {
if (optionalDataTypeBuilder_ == null) {
if (!(valueCase_ == 13)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.getDefaultInstance();
}
optionalDataTypeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalDataType, ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalDataTypeOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.OptionalDataType) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 13;
onChanged();;
return optionalDataTypeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.IteratorId, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder, ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder> iteratorIdBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorId getIteratorId() {
if (iteratorIdBuilder_ == null) {
if (valueCase_ == 14) {
return (ai.grakn.rpc.generated.GrpcIterator.IteratorId) value_;
}
return ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance();
} else {
if (valueCase_ == 14) {
return iteratorIdBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 14;</code>
*/
public Builder setIteratorId(ai.grakn.rpc.generated.GrpcIterator.IteratorId value) {
if (iteratorIdBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
iteratorIdBuilder_.setMessage(value);
}
valueCase_ = 14;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 14;</code>
*/
public Builder setIteratorId(
ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder builderForValue) {
if (iteratorIdBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
iteratorIdBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 14;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 14;</code>
*/
public Builder mergeIteratorId(ai.grakn.rpc.generated.GrpcIterator.IteratorId value) {
if (iteratorIdBuilder_ == null) {
if (valueCase_ == 14 &&
value_ != ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcIterator.IteratorId.newBuilder((ai.grakn.rpc.generated.GrpcIterator.IteratorId) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 14) {
iteratorIdBuilder_.mergeFrom(value);
}
iteratorIdBuilder_.setMessage(value);
}
valueCase_ = 14;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 14;</code>
*/
public Builder clearIteratorId() {
if (iteratorIdBuilder_ == null) {
if (valueCase_ == 14) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 14) {
valueCase_ = 0;
value_ = null;
}
iteratorIdBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder getIteratorIdBuilder() {
return getIteratorIdFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder getIteratorIdOrBuilder() {
if ((valueCase_ == 14) && (iteratorIdBuilder_ != null)) {
return iteratorIdBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 14) {
return (ai.grakn.rpc.generated.GrpcIterator.IteratorId) value_;
}
return ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 14;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.IteratorId, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder, ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder>
getIteratorIdFieldBuilder() {
if (iteratorIdBuilder_ == null) {
if (!(valueCase_ == 14)) {
value_ = ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance();
}
iteratorIdBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.IteratorId, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder, ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder>(
(ai.grakn.rpc.generated.GrpcIterator.IteratorId) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 14;
onChanged();;
return iteratorIdBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.ConceptResponse)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.ConceptResponse)
private static final ai.grakn.rpc.generated.GrpcConcept.ConceptResponse DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.ConceptResponse();
}
public static ai.grakn.rpc.generated.GrpcConcept.ConceptResponse getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<ConceptResponse>
PARSER = new com.google.protobuf.AbstractParser<ConceptResponse>() {
public ConceptResponse parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new ConceptResponse(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<ConceptResponse> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<ConceptResponse> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.ConceptResponse getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface AttributeValueOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.AttributeValue)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional string string = 1;</code>
*/
java.lang.String getString();
/**
* <code>optional string string = 1;</code>
*/
com.google.protobuf.ByteString
getStringBytes();
/**
* <code>optional bool boolean = 2;</code>
*/
boolean getBoolean();
/**
* <code>optional int32 integer = 3;</code>
*/
int getInteger();
/**
* <code>optional int64 long = 4;</code>
*/
long getLong();
/**
* <code>optional float float = 5;</code>
*/
float getFloat();
/**
* <code>optional double double = 6;</code>
*/
double getDouble();
/**
* <pre>
* time since epoch in milliseconds
* </pre>
*
* <code>optional int64 date = 7;</code>
*/
long getDate();
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue.ValueCase getValueCase();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.AttributeValue}
*/
public static final class AttributeValue extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.AttributeValue)
AttributeValueOrBuilder {
// Use AttributeValue.newBuilder() to construct.
private AttributeValue(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private AttributeValue() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private AttributeValue(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
valueCase_ = 1;
value_ = s;
break;
}
case 16: {
valueCase_ = 2;
value_ = input.readBool();
break;
}
case 24: {
valueCase_ = 3;
value_ = input.readInt32();
break;
}
case 32: {
valueCase_ = 4;
value_ = input.readInt64();
break;
}
case 45: {
valueCase_ = 5;
value_ = input.readFloat();
break;
}
case 49: {
valueCase_ = 6;
value_ = input.readDouble();
break;
}
case 56: {
valueCase_ = 7;
value_ = input.readInt64();
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_AttributeValue_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_AttributeValue_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.AttributeValue.class, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder.class);
}
private int valueCase_ = 0;
private java.lang.Object value_;
public enum ValueCase
implements com.google.protobuf.Internal.EnumLite {
STRING(1),
BOOLEAN(2),
INTEGER(3),
LONG(4),
FLOAT(5),
DOUBLE(6),
DATE(7),
VALUE_NOT_SET(0);
private final int value;
private ValueCase(int value) {
this.value = value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static ValueCase valueOf(int value) {
return forNumber(value);
}
public static ValueCase forNumber(int value) {
switch (value) {
case 1: return STRING;
case 2: return BOOLEAN;
case 3: return INTEGER;
case 4: return LONG;
case 5: return FLOAT;
case 6: return DOUBLE;
case 7: return DATE;
case 0: return VALUE_NOT_SET;
default: return null;
}
}
public int getNumber() {
return this.value;
}
};
public ValueCase
getValueCase() {
return ValueCase.forNumber(
valueCase_);
}
public static final int STRING_FIELD_NUMBER = 1;
/**
* <code>optional string string = 1;</code>
*/
public java.lang.String getString() {
java.lang.Object ref = "";
if (valueCase_ == 1) {
ref = value_;
}
if (ref instanceof java.lang.String) {
return (java.lang.String) ref;
} else {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
if (valueCase_ == 1) {
value_ = s;
}
return s;
}
}
/**
* <code>optional string string = 1;</code>
*/
public com.google.protobuf.ByteString
getStringBytes() {
java.lang.Object ref = "";
if (valueCase_ == 1) {
ref = value_;
}
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
if (valueCase_ == 1) {
value_ = b;
}
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
public static final int BOOLEAN_FIELD_NUMBER = 2;
/**
* <code>optional bool boolean = 2;</code>
*/
public boolean getBoolean() {
if (valueCase_ == 2) {
return (java.lang.Boolean) value_;
}
return false;
}
public static final int INTEGER_FIELD_NUMBER = 3;
/**
* <code>optional int32 integer = 3;</code>
*/
public int getInteger() {
if (valueCase_ == 3) {
return (java.lang.Integer) value_;
}
return 0;
}
public static final int LONG_FIELD_NUMBER = 4;
/**
* <code>optional int64 long = 4;</code>
*/
public long getLong() {
if (valueCase_ == 4) {
return (java.lang.Long) value_;
}
return 0L;
}
public static final int FLOAT_FIELD_NUMBER = 5;
/**
* <code>optional float float = 5;</code>
*/
public float getFloat() {
if (valueCase_ == 5) {
return (java.lang.Float) value_;
}
return 0F;
}
public static final int DOUBLE_FIELD_NUMBER = 6;
/**
* <code>optional double double = 6;</code>
*/
public double getDouble() {
if (valueCase_ == 6) {
return (java.lang.Double) value_;
}
return 0D;
}
public static final int DATE_FIELD_NUMBER = 7;
/**
* <pre>
* time since epoch in milliseconds
* </pre>
*
* <code>optional int64 date = 7;</code>
*/
public long getDate() {
if (valueCase_ == 7) {
return (java.lang.Long) value_;
}
return 0L;
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (valueCase_ == 1) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, value_);
}
if (valueCase_ == 2) {
output.writeBool(
2, (boolean)((java.lang.Boolean) value_));
}
if (valueCase_ == 3) {
output.writeInt32(
3, (int)((java.lang.Integer) value_));
}
if (valueCase_ == 4) {
output.writeInt64(
4, (long)((java.lang.Long) value_));
}
if (valueCase_ == 5) {
output.writeFloat(
5, (float)((java.lang.Float) value_));
}
if (valueCase_ == 6) {
output.writeDouble(
6, (double)((java.lang.Double) value_));
}
if (valueCase_ == 7) {
output.writeInt64(
7, (long)((java.lang.Long) value_));
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (valueCase_ == 1) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, value_);
}
if (valueCase_ == 2) {
size += com.google.protobuf.CodedOutputStream
.computeBoolSize(
2, (boolean)((java.lang.Boolean) value_));
}
if (valueCase_ == 3) {
size += com.google.protobuf.CodedOutputStream
.computeInt32Size(
3, (int)((java.lang.Integer) value_));
}
if (valueCase_ == 4) {
size += com.google.protobuf.CodedOutputStream
.computeInt64Size(
4, (long)((java.lang.Long) value_));
}
if (valueCase_ == 5) {
size += com.google.protobuf.CodedOutputStream
.computeFloatSize(
5, (float)((java.lang.Float) value_));
}
if (valueCase_ == 6) {
size += com.google.protobuf.CodedOutputStream
.computeDoubleSize(
6, (double)((java.lang.Double) value_));
}
if (valueCase_ == 7) {
size += com.google.protobuf.CodedOutputStream
.computeInt64Size(
7, (long)((java.lang.Long) value_));
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.AttributeValue)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.AttributeValue other = (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) obj;
boolean result = true;
result = result && getValueCase().equals(
other.getValueCase());
if (!result) return false;
switch (valueCase_) {
case 1:
result = result && getString()
.equals(other.getString());
break;
case 2:
result = result && (getBoolean()
== other.getBoolean());
break;
case 3:
result = result && (getInteger()
== other.getInteger());
break;
case 4:
result = result && (getLong()
== other.getLong());
break;
case 5:
result = result && (
java.lang.Float.floatToIntBits(getFloat())
== java.lang.Float.floatToIntBits(
other.getFloat()));
break;
case 6:
result = result && (
java.lang.Double.doubleToLongBits(getDouble())
== java.lang.Double.doubleToLongBits(
other.getDouble()));
break;
case 7:
result = result && (getDate()
== other.getDate());
break;
case 0:
default:
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
switch (valueCase_) {
case 1:
hash = (37 * hash) + STRING_FIELD_NUMBER;
hash = (53 * hash) + getString().hashCode();
break;
case 2:
hash = (37 * hash) + BOOLEAN_FIELD_NUMBER;
hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
getBoolean());
break;
case 3:
hash = (37 * hash) + INTEGER_FIELD_NUMBER;
hash = (53 * hash) + getInteger();
break;
case 4:
hash = (37 * hash) + LONG_FIELD_NUMBER;
hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
getLong());
break;
case 5:
hash = (37 * hash) + FLOAT_FIELD_NUMBER;
hash = (53 * hash) + java.lang.Float.floatToIntBits(
getFloat());
break;
case 6:
hash = (37 * hash) + DOUBLE_FIELD_NUMBER;
hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
java.lang.Double.doubleToLongBits(getDouble()));
break;
case 7:
hash = (37 * hash) + DATE_FIELD_NUMBER;
hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
getDate());
break;
case 0:
default:
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.AttributeValue parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.AttributeValue parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.AttributeValue parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.AttributeValue parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.AttributeValue parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.AttributeValue parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.AttributeValue parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.AttributeValue parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.AttributeValue parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.AttributeValue parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.AttributeValue prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.AttributeValue}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.AttributeValue)
ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_AttributeValue_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_AttributeValue_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.AttributeValue.class, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.AttributeValue.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
valueCase_ = 0;
value_ = null;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_AttributeValue_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue build() {
ai.grakn.rpc.generated.GrpcConcept.AttributeValue result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.AttributeValue result = new ai.grakn.rpc.generated.GrpcConcept.AttributeValue(this);
if (valueCase_ == 1) {
result.value_ = value_;
}
if (valueCase_ == 2) {
result.value_ = value_;
}
if (valueCase_ == 3) {
result.value_ = value_;
}
if (valueCase_ == 4) {
result.value_ = value_;
}
if (valueCase_ == 5) {
result.value_ = value_;
}
if (valueCase_ == 6) {
result.value_ = value_;
}
if (valueCase_ == 7) {
result.value_ = value_;
}
result.valueCase_ = valueCase_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.AttributeValue) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.AttributeValue)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.AttributeValue other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance()) return this;
switch (other.getValueCase()) {
case STRING: {
valueCase_ = 1;
value_ = other.value_;
onChanged();
break;
}
case BOOLEAN: {
setBoolean(other.getBoolean());
break;
}
case INTEGER: {
setInteger(other.getInteger());
break;
}
case LONG: {
setLong(other.getLong());
break;
}
case FLOAT: {
setFloat(other.getFloat());
break;
}
case DOUBLE: {
setDouble(other.getDouble());
break;
}
case DATE: {
setDate(other.getDate());
break;
}
case VALUE_NOT_SET: {
break;
}
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.AttributeValue parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int valueCase_ = 0;
private java.lang.Object value_;
public ValueCase
getValueCase() {
return ValueCase.forNumber(
valueCase_);
}
public Builder clearValue() {
valueCase_ = 0;
value_ = null;
onChanged();
return this;
}
/**
* <code>optional string string = 1;</code>
*/
public java.lang.String getString() {
java.lang.Object ref = "";
if (valueCase_ == 1) {
ref = value_;
}
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
if (valueCase_ == 1) {
value_ = s;
}
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <code>optional string string = 1;</code>
*/
public com.google.protobuf.ByteString
getStringBytes() {
java.lang.Object ref = "";
if (valueCase_ == 1) {
ref = value_;
}
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
if (valueCase_ == 1) {
value_ = b;
}
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <code>optional string string = 1;</code>
*/
public Builder setString(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
valueCase_ = 1;
value_ = value;
onChanged();
return this;
}
/**
* <code>optional string string = 1;</code>
*/
public Builder clearString() {
if (valueCase_ == 1) {
valueCase_ = 0;
value_ = null;
onChanged();
}
return this;
}
/**
* <code>optional string string = 1;</code>
*/
public Builder setStringBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
valueCase_ = 1;
value_ = value;
onChanged();
return this;
}
/**
* <code>optional bool boolean = 2;</code>
*/
public boolean getBoolean() {
if (valueCase_ == 2) {
return (java.lang.Boolean) value_;
}
return false;
}
/**
* <code>optional bool boolean = 2;</code>
*/
public Builder setBoolean(boolean value) {
valueCase_ = 2;
value_ = value;
onChanged();
return this;
}
/**
* <code>optional bool boolean = 2;</code>
*/
public Builder clearBoolean() {
if (valueCase_ == 2) {
valueCase_ = 0;
value_ = null;
onChanged();
}
return this;
}
/**
* <code>optional int32 integer = 3;</code>
*/
public int getInteger() {
if (valueCase_ == 3) {
return (java.lang.Integer) value_;
}
return 0;
}
/**
* <code>optional int32 integer = 3;</code>
*/
public Builder setInteger(int value) {
valueCase_ = 3;
value_ = value;
onChanged();
return this;
}
/**
* <code>optional int32 integer = 3;</code>
*/
public Builder clearInteger() {
if (valueCase_ == 3) {
valueCase_ = 0;
value_ = null;
onChanged();
}
return this;
}
/**
* <code>optional int64 long = 4;</code>
*/
public long getLong() {
if (valueCase_ == 4) {
return (java.lang.Long) value_;
}
return 0L;
}
/**
* <code>optional int64 long = 4;</code>
*/
public Builder setLong(long value) {
valueCase_ = 4;
value_ = value;
onChanged();
return this;
}
/**
* <code>optional int64 long = 4;</code>
*/
public Builder clearLong() {
if (valueCase_ == 4) {
valueCase_ = 0;
value_ = null;
onChanged();
}
return this;
}
/**
* <code>optional float float = 5;</code>
*/
public float getFloat() {
if (valueCase_ == 5) {
return (java.lang.Float) value_;
}
return 0F;
}
/**
* <code>optional float float = 5;</code>
*/
public Builder setFloat(float value) {
valueCase_ = 5;
value_ = value;
onChanged();
return this;
}
/**
* <code>optional float float = 5;</code>
*/
public Builder clearFloat() {
if (valueCase_ == 5) {
valueCase_ = 0;
value_ = null;
onChanged();
}
return this;
}
/**
* <code>optional double double = 6;</code>
*/
public double getDouble() {
if (valueCase_ == 6) {
return (java.lang.Double) value_;
}
return 0D;
}
/**
* <code>optional double double = 6;</code>
*/
public Builder setDouble(double value) {
valueCase_ = 6;
value_ = value;
onChanged();
return this;
}
/**
* <code>optional double double = 6;</code>
*/
public Builder clearDouble() {
if (valueCase_ == 6) {
valueCase_ = 0;
value_ = null;
onChanged();
}
return this;
}
/**
* <pre>
* time since epoch in milliseconds
* </pre>
*
* <code>optional int64 date = 7;</code>
*/
public long getDate() {
if (valueCase_ == 7) {
return (java.lang.Long) value_;
}
return 0L;
}
/**
* <pre>
* time since epoch in milliseconds
* </pre>
*
* <code>optional int64 date = 7;</code>
*/
public Builder setDate(long value) {
valueCase_ = 7;
value_ = value;
onChanged();
return this;
}
/**
* <pre>
* time since epoch in milliseconds
* </pre>
*
* <code>optional int64 date = 7;</code>
*/
public Builder clearDate() {
if (valueCase_ == 7) {
valueCase_ = 0;
value_ = null;
onChanged();
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.AttributeValue)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.AttributeValue)
private static final ai.grakn.rpc.generated.GrpcConcept.AttributeValue DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.AttributeValue();
}
public static ai.grakn.rpc.generated.GrpcConcept.AttributeValue getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<AttributeValue>
PARSER = new com.google.protobuf.AbstractParser<AttributeValue>() {
public AttributeValue parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new AttributeValue(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<AttributeValue> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<AttributeValue> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface LabelOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Label)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional string value = 1;</code>
*/
java.lang.String getValue();
/**
* <code>optional string value = 1;</code>
*/
com.google.protobuf.ByteString
getValueBytes();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.Label}
*/
public static final class Label extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Label)
LabelOrBuilder {
// Use Label.newBuilder() to construct.
private Label(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Label() {
value_ = "";
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Label(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
value_ = s;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Label_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Label_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.Label.class, ai.grakn.rpc.generated.GrpcConcept.Label.Builder.class);
}
public static final int VALUE_FIELD_NUMBER = 1;
private volatile java.lang.Object value_;
/**
* <code>optional string value = 1;</code>
*/
public java.lang.String getValue() {
java.lang.Object ref = value_;
if (ref instanceof java.lang.String) {
return (java.lang.String) ref;
} else {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
value_ = s;
return s;
}
}
/**
* <code>optional string value = 1;</code>
*/
public com.google.protobuf.ByteString
getValueBytes() {
java.lang.Object ref = value_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
value_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (!getValueBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, value_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (!getValueBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, value_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.Label)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.Label other = (ai.grakn.rpc.generated.GrpcConcept.Label) obj;
boolean result = true;
result = result && getValue()
.equals(other.getValue());
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
hash = (37 * hash) + VALUE_FIELD_NUMBER;
hash = (53 * hash) + getValue().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.Label parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.Label parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Label parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.Label parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Label parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Label parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Label parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Label parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Label parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Label parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.Label prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.Label}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Label)
ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Label_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Label_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.Label.class, ai.grakn.rpc.generated.GrpcConcept.Label.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.Label.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
value_ = "";
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Label_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.Label getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.Label build() {
ai.grakn.rpc.generated.GrpcConcept.Label result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.Label buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.Label result = new ai.grakn.rpc.generated.GrpcConcept.Label(this);
result.value_ = value_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.Label) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Label)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.Label other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance()) return this;
if (!other.getValue().isEmpty()) {
value_ = other.value_;
onChanged();
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.Label parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.Label) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private java.lang.Object value_ = "";
/**
* <code>optional string value = 1;</code>
*/
public java.lang.String getValue() {
java.lang.Object ref = value_;
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
value_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <code>optional string value = 1;</code>
*/
public com.google.protobuf.ByteString
getValueBytes() {
java.lang.Object ref = value_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
value_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <code>optional string value = 1;</code>
*/
public Builder setValue(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
return this;
}
/**
* <code>optional string value = 1;</code>
*/
public Builder clearValue() {
value_ = getDefaultInstance().getValue();
onChanged();
return this;
}
/**
* <code>optional string value = 1;</code>
*/
public Builder setValueBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
value_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Label)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Label)
private static final ai.grakn.rpc.generated.GrpcConcept.Label DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.Label();
}
public static ai.grakn.rpc.generated.GrpcConcept.Label getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Label>
PARSER = new com.google.protobuf.AbstractParser<Label>() {
public Label parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Label(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Label> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Label> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.Label getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface RolePlayersOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.RolePlayers)
com.google.protobuf.MessageOrBuilder {
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
java.util.List<ai.grakn.rpc.generated.GrpcConcept.RolePlayer>
getRolePlayerList();
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.RolePlayer getRolePlayer(int index);
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
int getRolePlayerCount();
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
java.util.List<? extends ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder>
getRolePlayerOrBuilderList();
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder getRolePlayerOrBuilder(
int index);
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.RolePlayers}
*/
public static final class RolePlayers extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.RolePlayers)
RolePlayersOrBuilder {
// Use RolePlayers.newBuilder() to construct.
private RolePlayers(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private RolePlayers() {
rolePlayer_ = java.util.Collections.emptyList();
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private RolePlayers(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
rolePlayer_ = new java.util.ArrayList<ai.grakn.rpc.generated.GrpcConcept.RolePlayer>();
mutable_bitField0_ |= 0x00000001;
}
rolePlayer_.add(
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.RolePlayer.parser(), extensionRegistry));
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
rolePlayer_ = java.util.Collections.unmodifiableList(rolePlayer_);
}
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_RolePlayers_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_RolePlayers_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.RolePlayers.class, ai.grakn.rpc.generated.GrpcConcept.RolePlayers.Builder.class);
}
public static final int ROLEPLAYER_FIELD_NUMBER = 1;
private java.util.List<ai.grakn.rpc.generated.GrpcConcept.RolePlayer> rolePlayer_;
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public java.util.List<ai.grakn.rpc.generated.GrpcConcept.RolePlayer> getRolePlayerList() {
return rolePlayer_;
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public java.util.List<? extends ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder>
getRolePlayerOrBuilderList() {
return rolePlayer_;
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public int getRolePlayerCount() {
return rolePlayer_.size();
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer getRolePlayer(int index) {
return rolePlayer_.get(index);
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder getRolePlayerOrBuilder(
int index) {
return rolePlayer_.get(index);
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
for (int i = 0; i < rolePlayer_.size(); i++) {
output.writeMessage(1, rolePlayer_.get(i));
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
for (int i = 0; i < rolePlayer_.size(); i++) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, rolePlayer_.get(i));
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.RolePlayers)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.RolePlayers other = (ai.grakn.rpc.generated.GrpcConcept.RolePlayers) obj;
boolean result = true;
result = result && getRolePlayerList()
.equals(other.getRolePlayerList());
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
if (getRolePlayerCount() > 0) {
hash = (37 * hash) + ROLEPLAYER_FIELD_NUMBER;
hash = (53 * hash) + getRolePlayerList().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayers parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayers parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayers parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayers parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayers parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayers parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayers parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayers parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayers parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayers parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.RolePlayers prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.RolePlayers}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.RolePlayers)
ai.grakn.rpc.generated.GrpcConcept.RolePlayersOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_RolePlayers_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_RolePlayers_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.RolePlayers.class, ai.grakn.rpc.generated.GrpcConcept.RolePlayers.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.RolePlayers.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
getRolePlayerFieldBuilder();
}
}
public Builder clear() {
super.clear();
if (rolePlayerBuilder_ == null) {
rolePlayer_ = java.util.Collections.emptyList();
bitField0_ = (bitField0_ & ~0x00000001);
} else {
rolePlayerBuilder_.clear();
}
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_RolePlayers_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.RolePlayers getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.RolePlayers.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.RolePlayers build() {
ai.grakn.rpc.generated.GrpcConcept.RolePlayers result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.RolePlayers buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.RolePlayers result = new ai.grakn.rpc.generated.GrpcConcept.RolePlayers(this);
int from_bitField0_ = bitField0_;
if (rolePlayerBuilder_ == null) {
if (((bitField0_ & 0x00000001) == 0x00000001)) {
rolePlayer_ = java.util.Collections.unmodifiableList(rolePlayer_);
bitField0_ = (bitField0_ & ~0x00000001);
}
result.rolePlayer_ = rolePlayer_;
} else {
result.rolePlayer_ = rolePlayerBuilder_.build();
}
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.RolePlayers) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.RolePlayers)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.RolePlayers other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.RolePlayers.getDefaultInstance()) return this;
if (rolePlayerBuilder_ == null) {
if (!other.rolePlayer_.isEmpty()) {
if (rolePlayer_.isEmpty()) {
rolePlayer_ = other.rolePlayer_;
bitField0_ = (bitField0_ & ~0x00000001);
} else {
ensureRolePlayerIsMutable();
rolePlayer_.addAll(other.rolePlayer_);
}
onChanged();
}
} else {
if (!other.rolePlayer_.isEmpty()) {
if (rolePlayerBuilder_.isEmpty()) {
rolePlayerBuilder_.dispose();
rolePlayerBuilder_ = null;
rolePlayer_ = other.rolePlayer_;
bitField0_ = (bitField0_ & ~0x00000001);
rolePlayerBuilder_ =
com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
getRolePlayerFieldBuilder() : null;
} else {
rolePlayerBuilder_.addAllMessages(other.rolePlayer_);
}
}
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.RolePlayers parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.RolePlayers) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int bitField0_;
private java.util.List<ai.grakn.rpc.generated.GrpcConcept.RolePlayer> rolePlayer_ =
java.util.Collections.emptyList();
private void ensureRolePlayerIsMutable() {
if (!((bitField0_ & 0x00000001) == 0x00000001)) {
rolePlayer_ = new java.util.ArrayList<ai.grakn.rpc.generated.GrpcConcept.RolePlayer>(rolePlayer_);
bitField0_ |= 0x00000001;
}
}
private com.google.protobuf.RepeatedFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.RolePlayer, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder, ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder> rolePlayerBuilder_;
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public java.util.List<ai.grakn.rpc.generated.GrpcConcept.RolePlayer> getRolePlayerList() {
if (rolePlayerBuilder_ == null) {
return java.util.Collections.unmodifiableList(rolePlayer_);
} else {
return rolePlayerBuilder_.getMessageList();
}
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public int getRolePlayerCount() {
if (rolePlayerBuilder_ == null) {
return rolePlayer_.size();
} else {
return rolePlayerBuilder_.getCount();
}
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer getRolePlayer(int index) {
if (rolePlayerBuilder_ == null) {
return rolePlayer_.get(index);
} else {
return rolePlayerBuilder_.getMessage(index);
}
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public Builder setRolePlayer(
int index, ai.grakn.rpc.generated.GrpcConcept.RolePlayer value) {
if (rolePlayerBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
ensureRolePlayerIsMutable();
rolePlayer_.set(index, value);
onChanged();
} else {
rolePlayerBuilder_.setMessage(index, value);
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public Builder setRolePlayer(
int index, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder builderForValue) {
if (rolePlayerBuilder_ == null) {
ensureRolePlayerIsMutable();
rolePlayer_.set(index, builderForValue.build());
onChanged();
} else {
rolePlayerBuilder_.setMessage(index, builderForValue.build());
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public Builder addRolePlayer(ai.grakn.rpc.generated.GrpcConcept.RolePlayer value) {
if (rolePlayerBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
ensureRolePlayerIsMutable();
rolePlayer_.add(value);
onChanged();
} else {
rolePlayerBuilder_.addMessage(value);
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public Builder addRolePlayer(
int index, ai.grakn.rpc.generated.GrpcConcept.RolePlayer value) {
if (rolePlayerBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
ensureRolePlayerIsMutable();
rolePlayer_.add(index, value);
onChanged();
} else {
rolePlayerBuilder_.addMessage(index, value);
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public Builder addRolePlayer(
ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder builderForValue) {
if (rolePlayerBuilder_ == null) {
ensureRolePlayerIsMutable();
rolePlayer_.add(builderForValue.build());
onChanged();
} else {
rolePlayerBuilder_.addMessage(builderForValue.build());
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public Builder addRolePlayer(
int index, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder builderForValue) {
if (rolePlayerBuilder_ == null) {
ensureRolePlayerIsMutable();
rolePlayer_.add(index, builderForValue.build());
onChanged();
} else {
rolePlayerBuilder_.addMessage(index, builderForValue.build());
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public Builder addAllRolePlayer(
java.lang.Iterable<? extends ai.grakn.rpc.generated.GrpcConcept.RolePlayer> values) {
if (rolePlayerBuilder_ == null) {
ensureRolePlayerIsMutable();
com.google.protobuf.AbstractMessageLite.Builder.addAll(
values, rolePlayer_);
onChanged();
} else {
rolePlayerBuilder_.addAllMessages(values);
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public Builder clearRolePlayer() {
if (rolePlayerBuilder_ == null) {
rolePlayer_ = java.util.Collections.emptyList();
bitField0_ = (bitField0_ & ~0x00000001);
onChanged();
} else {
rolePlayerBuilder_.clear();
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public Builder removeRolePlayer(int index) {
if (rolePlayerBuilder_ == null) {
ensureRolePlayerIsMutable();
rolePlayer_.remove(index);
onChanged();
} else {
rolePlayerBuilder_.remove(index);
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder getRolePlayerBuilder(
int index) {
return getRolePlayerFieldBuilder().getBuilder(index);
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder getRolePlayerOrBuilder(
int index) {
if (rolePlayerBuilder_ == null) {
return rolePlayer_.get(index); } else {
return rolePlayerBuilder_.getMessageOrBuilder(index);
}
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public java.util.List<? extends ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder>
getRolePlayerOrBuilderList() {
if (rolePlayerBuilder_ != null) {
return rolePlayerBuilder_.getMessageOrBuilderList();
} else {
return java.util.Collections.unmodifiableList(rolePlayer_);
}
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder addRolePlayerBuilder() {
return getRolePlayerFieldBuilder().addBuilder(
ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance());
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder addRolePlayerBuilder(
int index) {
return getRolePlayerFieldBuilder().addBuilder(
index, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance());
}
/**
* <code>repeated .ai.grakn.rpc.generated.RolePlayer rolePlayer = 1;</code>
*/
public java.util.List<ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder>
getRolePlayerBuilderList() {
return getRolePlayerFieldBuilder().getBuilderList();
}
private com.google.protobuf.RepeatedFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.RolePlayer, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder, ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder>
getRolePlayerFieldBuilder() {
if (rolePlayerBuilder_ == null) {
rolePlayerBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.RolePlayer, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder, ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder>(
rolePlayer_,
((bitField0_ & 0x00000001) == 0x00000001),
getParentForChildren(),
isClean());
rolePlayer_ = null;
}
return rolePlayerBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.RolePlayers)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.RolePlayers)
private static final ai.grakn.rpc.generated.GrpcConcept.RolePlayers DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.RolePlayers();
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayers getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<RolePlayers>
PARSER = new com.google.protobuf.AbstractParser<RolePlayers>() {
public RolePlayers parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new RolePlayers(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<RolePlayers> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<RolePlayers> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.RolePlayers getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface RolePlayerOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.RolePlayer)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
boolean hasRole();
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getRole();
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getRoleOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
boolean hasPlayer();
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getPlayer();
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getPlayerOrBuilder();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.RolePlayer}
*/
public static final class RolePlayer extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.RolePlayer)
RolePlayerOrBuilder {
// Use RolePlayer.newBuilder() to construct.
private RolePlayer(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private RolePlayer() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private RolePlayer(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (role_ != null) {
subBuilder = role_.toBuilder();
}
role_ = input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(role_);
role_ = subBuilder.buildPartial();
}
break;
}
case 18: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (player_ != null) {
subBuilder = player_.toBuilder();
}
player_ = input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(player_);
player_ = subBuilder.buildPartial();
}
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_RolePlayer_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_RolePlayer_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.RolePlayer.class, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder.class);
}
public static final int ROLE_FIELD_NUMBER = 1;
private ai.grakn.rpc.generated.GrpcConcept.Concept role_;
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
public boolean hasRole() {
return role_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getRole() {
return role_ == null ? ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance() : role_;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getRoleOrBuilder() {
return getRole();
}
public static final int PLAYER_FIELD_NUMBER = 2;
private ai.grakn.rpc.generated.GrpcConcept.Concept player_;
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
public boolean hasPlayer() {
return player_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getPlayer() {
return player_ == null ? ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance() : player_;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getPlayerOrBuilder() {
return getPlayer();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (role_ != null) {
output.writeMessage(1, getRole());
}
if (player_ != null) {
output.writeMessage(2, getPlayer());
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (role_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, getRole());
}
if (player_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(2, getPlayer());
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.RolePlayer)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.RolePlayer other = (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) obj;
boolean result = true;
result = result && (hasRole() == other.hasRole());
if (hasRole()) {
result = result && getRole()
.equals(other.getRole());
}
result = result && (hasPlayer() == other.hasPlayer());
if (hasPlayer()) {
result = result && getPlayer()
.equals(other.getPlayer());
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
if (hasRole()) {
hash = (37 * hash) + ROLE_FIELD_NUMBER;
hash = (53 * hash) + getRole().hashCode();
}
if (hasPlayer()) {
hash = (37 * hash) + PLAYER_FIELD_NUMBER;
hash = (53 * hash) + getPlayer().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayer parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayer parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayer parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayer parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayer parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayer parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayer parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayer parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayer parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayer parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.RolePlayer prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.RolePlayer}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.RolePlayer)
ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_RolePlayer_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_RolePlayer_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.RolePlayer.class, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.RolePlayer.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
if (roleBuilder_ == null) {
role_ = null;
} else {
role_ = null;
roleBuilder_ = null;
}
if (playerBuilder_ == null) {
player_ = null;
} else {
player_ = null;
playerBuilder_ = null;
}
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_RolePlayer_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer build() {
ai.grakn.rpc.generated.GrpcConcept.RolePlayer result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.RolePlayer result = new ai.grakn.rpc.generated.GrpcConcept.RolePlayer(this);
if (roleBuilder_ == null) {
result.role_ = role_;
} else {
result.role_ = roleBuilder_.build();
}
if (playerBuilder_ == null) {
result.player_ = player_;
} else {
result.player_ = playerBuilder_.build();
}
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.RolePlayer) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.RolePlayer)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.RolePlayer other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance()) return this;
if (other.hasRole()) {
mergeRole(other.getRole());
}
if (other.hasPlayer()) {
mergePlayer(other.getPlayer());
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.RolePlayer parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private ai.grakn.rpc.generated.GrpcConcept.Concept role_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> roleBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
public boolean hasRole() {
return roleBuilder_ != null || role_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getRole() {
if (roleBuilder_ == null) {
return role_ == null ? ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance() : role_;
} else {
return roleBuilder_.getMessage();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
public Builder setRole(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (roleBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
role_ = value;
onChanged();
} else {
roleBuilder_.setMessage(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
public Builder setRole(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (roleBuilder_ == null) {
role_ = builderForValue.build();
onChanged();
} else {
roleBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
public Builder mergeRole(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (roleBuilder_ == null) {
if (role_ != null) {
role_ =
ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder(role_).mergeFrom(value).buildPartial();
} else {
role_ = value;
}
onChanged();
} else {
roleBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
public Builder clearRole() {
if (roleBuilder_ == null) {
role_ = null;
onChanged();
} else {
role_ = null;
roleBuilder_ = null;
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getRoleBuilder() {
onChanged();
return getRoleFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getRoleOrBuilder() {
if (roleBuilder_ != null) {
return roleBuilder_.getMessageOrBuilder();
} else {
return role_ == null ?
ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance() : role_;
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept role = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getRoleFieldBuilder() {
if (roleBuilder_ == null) {
roleBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
getRole(),
getParentForChildren(),
isClean());
role_ = null;
}
return roleBuilder_;
}
private ai.grakn.rpc.generated.GrpcConcept.Concept player_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> playerBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
public boolean hasPlayer() {
return playerBuilder_ != null || player_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getPlayer() {
if (playerBuilder_ == null) {
return player_ == null ? ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance() : player_;
} else {
return playerBuilder_.getMessage();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
public Builder setPlayer(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (playerBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
player_ = value;
onChanged();
} else {
playerBuilder_.setMessage(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
public Builder setPlayer(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (playerBuilder_ == null) {
player_ = builderForValue.build();
onChanged();
} else {
playerBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
public Builder mergePlayer(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (playerBuilder_ == null) {
if (player_ != null) {
player_ =
ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder(player_).mergeFrom(value).buildPartial();
} else {
player_ = value;
}
onChanged();
} else {
playerBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
public Builder clearPlayer() {
if (playerBuilder_ == null) {
player_ = null;
onChanged();
} else {
player_ = null;
playerBuilder_ = null;
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getPlayerBuilder() {
onChanged();
return getPlayerFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getPlayerOrBuilder() {
if (playerBuilder_ != null) {
return playerBuilder_.getMessageOrBuilder();
} else {
return player_ == null ?
ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance() : player_;
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept player = 2;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getPlayerFieldBuilder() {
if (playerBuilder_ == null) {
playerBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
getPlayer(),
getParentForChildren(),
isClean());
player_ = null;
}
return playerBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.RolePlayer)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.RolePlayer)
private static final ai.grakn.rpc.generated.GrpcConcept.RolePlayer DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.RolePlayer();
}
public static ai.grakn.rpc.generated.GrpcConcept.RolePlayer getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<RolePlayer>
PARSER = new com.google.protobuf.AbstractParser<RolePlayer>() {
public RolePlayer parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new RolePlayer(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<RolePlayer> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<RolePlayer> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface ConceptsOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Concepts)
com.google.protobuf.MessageOrBuilder {
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
java.util.List<ai.grakn.rpc.generated.GrpcConcept.Concept>
getConceptList();
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getConcept(int index);
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
int getConceptCount();
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
java.util.List<? extends ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getConceptOrBuilderList();
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getConceptOrBuilder(
int index);
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.Concepts}
*/
public static final class Concepts extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Concepts)
ConceptsOrBuilder {
// Use Concepts.newBuilder() to construct.
private Concepts(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Concepts() {
concept_ = java.util.Collections.emptyList();
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Concepts(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
concept_ = new java.util.ArrayList<ai.grakn.rpc.generated.GrpcConcept.Concept>();
mutable_bitField0_ |= 0x00000001;
}
concept_.add(
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry));
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
concept_ = java.util.Collections.unmodifiableList(concept_);
}
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Concepts_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Concepts_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.Concepts.class, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder.class);
}
public static final int CONCEPT_FIELD_NUMBER = 1;
private java.util.List<ai.grakn.rpc.generated.GrpcConcept.Concept> concept_;
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public java.util.List<ai.grakn.rpc.generated.GrpcConcept.Concept> getConceptList() {
return concept_;
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public java.util.List<? extends ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getConceptOrBuilderList() {
return concept_;
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public int getConceptCount() {
return concept_.size();
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getConcept(int index) {
return concept_.get(index);
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getConceptOrBuilder(
int index) {
return concept_.get(index);
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
for (int i = 0; i < concept_.size(); i++) {
output.writeMessage(1, concept_.get(i));
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
for (int i = 0; i < concept_.size(); i++) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, concept_.get(i));
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.Concepts)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.Concepts other = (ai.grakn.rpc.generated.GrpcConcept.Concepts) obj;
boolean result = true;
result = result && getConceptList()
.equals(other.getConceptList());
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
if (getConceptCount() > 0) {
hash = (37 * hash) + CONCEPT_FIELD_NUMBER;
hash = (53 * hash) + getConceptList().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.Concepts parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concepts parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concepts parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concepts parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concepts parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concepts parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concepts parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concepts parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concepts parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Concepts parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.Concepts prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.Concepts}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Concepts)
ai.grakn.rpc.generated.GrpcConcept.ConceptsOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Concepts_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Concepts_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.Concepts.class, ai.grakn.rpc.generated.GrpcConcept.Concepts.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.Concepts.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
getConceptFieldBuilder();
}
}
public Builder clear() {
super.clear();
if (conceptBuilder_ == null) {
concept_ = java.util.Collections.emptyList();
bitField0_ = (bitField0_ & ~0x00000001);
} else {
conceptBuilder_.clear();
}
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Concepts_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.Concepts getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.Concepts build() {
ai.grakn.rpc.generated.GrpcConcept.Concepts result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.Concepts buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.Concepts result = new ai.grakn.rpc.generated.GrpcConcept.Concepts(this);
int from_bitField0_ = bitField0_;
if (conceptBuilder_ == null) {
if (((bitField0_ & 0x00000001) == 0x00000001)) {
concept_ = java.util.Collections.unmodifiableList(concept_);
bitField0_ = (bitField0_ & ~0x00000001);
}
result.concept_ = concept_;
} else {
result.concept_ = conceptBuilder_.build();
}
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.Concepts) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concepts)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.Concepts other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.Concepts.getDefaultInstance()) return this;
if (conceptBuilder_ == null) {
if (!other.concept_.isEmpty()) {
if (concept_.isEmpty()) {
concept_ = other.concept_;
bitField0_ = (bitField0_ & ~0x00000001);
} else {
ensureConceptIsMutable();
concept_.addAll(other.concept_);
}
onChanged();
}
} else {
if (!other.concept_.isEmpty()) {
if (conceptBuilder_.isEmpty()) {
conceptBuilder_.dispose();
conceptBuilder_ = null;
concept_ = other.concept_;
bitField0_ = (bitField0_ & ~0x00000001);
conceptBuilder_ =
com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
getConceptFieldBuilder() : null;
} else {
conceptBuilder_.addAllMessages(other.concept_);
}
}
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.Concepts parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.Concepts) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int bitField0_;
private java.util.List<ai.grakn.rpc.generated.GrpcConcept.Concept> concept_ =
java.util.Collections.emptyList();
private void ensureConceptIsMutable() {
if (!((bitField0_ & 0x00000001) == 0x00000001)) {
concept_ = new java.util.ArrayList<ai.grakn.rpc.generated.GrpcConcept.Concept>(concept_);
bitField0_ |= 0x00000001;
}
}
private com.google.protobuf.RepeatedFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> conceptBuilder_;
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public java.util.List<ai.grakn.rpc.generated.GrpcConcept.Concept> getConceptList() {
if (conceptBuilder_ == null) {
return java.util.Collections.unmodifiableList(concept_);
} else {
return conceptBuilder_.getMessageList();
}
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public int getConceptCount() {
if (conceptBuilder_ == null) {
return concept_.size();
} else {
return conceptBuilder_.getCount();
}
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getConcept(int index) {
if (conceptBuilder_ == null) {
return concept_.get(index);
} else {
return conceptBuilder_.getMessage(index);
}
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public Builder setConcept(
int index, ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (conceptBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
ensureConceptIsMutable();
concept_.set(index, value);
onChanged();
} else {
conceptBuilder_.setMessage(index, value);
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public Builder setConcept(
int index, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (conceptBuilder_ == null) {
ensureConceptIsMutable();
concept_.set(index, builderForValue.build());
onChanged();
} else {
conceptBuilder_.setMessage(index, builderForValue.build());
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public Builder addConcept(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (conceptBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
ensureConceptIsMutable();
concept_.add(value);
onChanged();
} else {
conceptBuilder_.addMessage(value);
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public Builder addConcept(
int index, ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (conceptBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
ensureConceptIsMutable();
concept_.add(index, value);
onChanged();
} else {
conceptBuilder_.addMessage(index, value);
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public Builder addConcept(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (conceptBuilder_ == null) {
ensureConceptIsMutable();
concept_.add(builderForValue.build());
onChanged();
} else {
conceptBuilder_.addMessage(builderForValue.build());
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public Builder addConcept(
int index, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (conceptBuilder_ == null) {
ensureConceptIsMutable();
concept_.add(index, builderForValue.build());
onChanged();
} else {
conceptBuilder_.addMessage(index, builderForValue.build());
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public Builder addAllConcept(
java.lang.Iterable<? extends ai.grakn.rpc.generated.GrpcConcept.Concept> values) {
if (conceptBuilder_ == null) {
ensureConceptIsMutable();
com.google.protobuf.AbstractMessageLite.Builder.addAll(
values, concept_);
onChanged();
} else {
conceptBuilder_.addAllMessages(values);
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public Builder clearConcept() {
if (conceptBuilder_ == null) {
concept_ = java.util.Collections.emptyList();
bitField0_ = (bitField0_ & ~0x00000001);
onChanged();
} else {
conceptBuilder_.clear();
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public Builder removeConcept(int index) {
if (conceptBuilder_ == null) {
ensureConceptIsMutable();
concept_.remove(index);
onChanged();
} else {
conceptBuilder_.remove(index);
}
return this;
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getConceptBuilder(
int index) {
return getConceptFieldBuilder().getBuilder(index);
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getConceptOrBuilder(
int index) {
if (conceptBuilder_ == null) {
return concept_.get(index); } else {
return conceptBuilder_.getMessageOrBuilder(index);
}
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public java.util.List<? extends ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getConceptOrBuilderList() {
if (conceptBuilder_ != null) {
return conceptBuilder_.getMessageOrBuilderList();
} else {
return java.util.Collections.unmodifiableList(concept_);
}
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder addConceptBuilder() {
return getConceptFieldBuilder().addBuilder(
ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance());
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder addConceptBuilder(
int index) {
return getConceptFieldBuilder().addBuilder(
index, ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance());
}
/**
* <code>repeated .ai.grakn.rpc.generated.Concept concept = 1;</code>
*/
public java.util.List<ai.grakn.rpc.generated.GrpcConcept.Concept.Builder>
getConceptBuilderList() {
return getConceptFieldBuilder().getBuilderList();
}
private com.google.protobuf.RepeatedFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getConceptFieldBuilder() {
if (conceptBuilder_ == null) {
conceptBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
concept_,
((bitField0_ & 0x00000001) == 0x00000001),
getParentForChildren(),
isClean());
concept_ = null;
}
return conceptBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Concepts)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Concepts)
private static final ai.grakn.rpc.generated.GrpcConcept.Concepts DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.Concepts();
}
public static ai.grakn.rpc.generated.GrpcConcept.Concepts getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Concepts>
PARSER = new com.google.protobuf.AbstractParser<Concepts>() {
public Concepts parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Concepts(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Concepts> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Concepts> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.Concepts getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface OptionalConceptOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.OptionalConcept)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.Concept present = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getPresent();
/**
* <code>optional .ai.grakn.rpc.generated.Concept present = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getPresentOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getAbsent();
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAbsentOrBuilder();
public ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.ValueCase getValueCase();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.OptionalConcept}
*/
public static final class OptionalConcept extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.OptionalConcept)
OptionalConceptOrBuilder {
// Use OptionalConcept.newBuilder() to construct.
private OptionalConcept(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private OptionalConcept() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private OptionalConcept(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (valueCase_ == 1) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 1;
break;
}
case 18: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (valueCase_ == 2) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 2;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalConcept_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalConcept_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.class, ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder.class);
}
private int valueCase_ = 0;
private java.lang.Object value_;
public enum ValueCase
implements com.google.protobuf.Internal.EnumLite {
PRESENT(1),
ABSENT(2),
VALUE_NOT_SET(0);
private final int value;
private ValueCase(int value) {
this.value = value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static ValueCase valueOf(int value) {
return forNumber(value);
}
public static ValueCase forNumber(int value) {
switch (value) {
case 1: return PRESENT;
case 2: return ABSENT;
case 0: return VALUE_NOT_SET;
default: return null;
}
}
public int getNumber() {
return this.value;
}
};
public ValueCase
getValueCase() {
return ValueCase.forNumber(
valueCase_);
}
public static final int PRESENT_FIELD_NUMBER = 1;
/**
* <code>optional .ai.grakn.rpc.generated.Concept present = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getPresent() {
if (valueCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept present = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getPresentOrBuilder() {
if (valueCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int ABSENT_FIELD_NUMBER = 2;
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getAbsent() {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAbsentOrBuilder() {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (valueCase_ == 1) {
output.writeMessage(1, (ai.grakn.rpc.generated.GrpcConcept.Concept) value_);
}
if (valueCase_ == 2) {
output.writeMessage(2, (ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (valueCase_ == 1) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, (ai.grakn.rpc.generated.GrpcConcept.Concept) value_);
}
if (valueCase_ == 2) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(2, (ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.OptionalConcept)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept other = (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) obj;
boolean result = true;
result = result && getValueCase().equals(
other.getValueCase());
if (!result) return false;
switch (valueCase_) {
case 1:
result = result && getPresent()
.equals(other.getPresent());
break;
case 2:
result = result && getAbsent()
.equals(other.getAbsent());
break;
case 0:
default:
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
switch (valueCase_) {
case 1:
hash = (37 * hash) + PRESENT_FIELD_NUMBER;
hash = (53 * hash) + getPresent().hashCode();
break;
case 2:
hash = (37 * hash) + ABSENT_FIELD_NUMBER;
hash = (53 * hash) + getAbsent().hashCode();
break;
case 0:
default:
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalConcept parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalConcept parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalConcept parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalConcept parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalConcept parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalConcept parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalConcept parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalConcept parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalConcept parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalConcept parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.OptionalConcept prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.OptionalConcept}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.OptionalConcept)
ai.grakn.rpc.generated.GrpcConcept.OptionalConceptOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalConcept_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalConcept_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.class, ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
valueCase_ = 0;
value_ = null;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalConcept_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalConcept getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalConcept build() {
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalConcept buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept result = new ai.grakn.rpc.generated.GrpcConcept.OptionalConcept(this);
if (valueCase_ == 1) {
if (presentBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = presentBuilder_.build();
}
}
if (valueCase_ == 2) {
if (absentBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = absentBuilder_.build();
}
}
result.valueCase_ = valueCase_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.OptionalConcept)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.OptionalConcept other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance()) return this;
switch (other.getValueCase()) {
case PRESENT: {
mergePresent(other.getPresent());
break;
}
case ABSENT: {
mergeAbsent(other.getAbsent());
break;
}
case VALUE_NOT_SET: {
break;
}
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int valueCase_ = 0;
private java.lang.Object value_;
public ValueCase
getValueCase() {
return ValueCase.forNumber(
valueCase_);
}
public Builder clearValue() {
valueCase_ = 0;
value_ = null;
onChanged();
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> presentBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Concept present = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getPresent() {
if (presentBuilder_ == null) {
if (valueCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (valueCase_ == 1) {
return presentBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept present = 1;</code>
*/
public Builder setPresent(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (presentBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
presentBuilder_.setMessage(value);
}
valueCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept present = 1;</code>
*/
public Builder setPresent(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (presentBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
presentBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept present = 1;</code>
*/
public Builder mergePresent(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (presentBuilder_ == null) {
if (valueCase_ == 1 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 1) {
presentBuilder_.mergeFrom(value);
}
presentBuilder_.setMessage(value);
}
valueCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept present = 1;</code>
*/
public Builder clearPresent() {
if (presentBuilder_ == null) {
if (valueCase_ == 1) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 1) {
valueCase_ = 0;
value_ = null;
}
presentBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept present = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getPresentBuilder() {
return getPresentFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept present = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getPresentOrBuilder() {
if ((valueCase_ == 1) && (presentBuilder_ != null)) {
return presentBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept present = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getPresentFieldBuilder() {
if (presentBuilder_ == null) {
if (!(valueCase_ == 1)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
presentBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 1;
onChanged();;
return presentBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> absentBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getAbsent() {
if (absentBuilder_ == null) {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (valueCase_ == 2) {
return absentBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder setAbsent(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (absentBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
absentBuilder_.setMessage(value);
}
valueCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder setAbsent(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (absentBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
absentBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder mergeAbsent(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (absentBuilder_ == null) {
if (valueCase_ == 2 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 2) {
absentBuilder_.mergeFrom(value);
}
absentBuilder_.setMessage(value);
}
valueCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder clearAbsent() {
if (absentBuilder_ == null) {
if (valueCase_ == 2) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 2) {
valueCase_ = 0;
value_ = null;
}
absentBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getAbsentBuilder() {
return getAbsentFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAbsentOrBuilder() {
if ((valueCase_ == 2) && (absentBuilder_ != null)) {
return absentBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getAbsentFieldBuilder() {
if (absentBuilder_ == null) {
if (!(valueCase_ == 2)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
absentBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 2;
onChanged();;
return absentBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.OptionalConcept)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.OptionalConcept)
private static final ai.grakn.rpc.generated.GrpcConcept.OptionalConcept DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.OptionalConcept();
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalConcept getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<OptionalConcept>
PARSER = new com.google.protobuf.AbstractParser<OptionalConcept>() {
public OptionalConcept parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new OptionalConcept(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<OptionalConcept> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<OptionalConcept> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalConcept getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface OptionalRegexOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.OptionalRegex)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional string present = 1;</code>
*/
java.lang.String getPresent();
/**
* <code>optional string present = 1;</code>
*/
com.google.protobuf.ByteString
getPresentBytes();
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getAbsent();
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAbsentOrBuilder();
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.ValueCase getValueCase();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.OptionalRegex}
*/
public static final class OptionalRegex extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.OptionalRegex)
OptionalRegexOrBuilder {
// Use OptionalRegex.newBuilder() to construct.
private OptionalRegex(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private OptionalRegex() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private OptionalRegex(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
valueCase_ = 1;
value_ = s;
break;
}
case 18: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (valueCase_ == 2) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 2;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalRegex_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalRegex_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.class, ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder.class);
}
private int valueCase_ = 0;
private java.lang.Object value_;
public enum ValueCase
implements com.google.protobuf.Internal.EnumLite {
PRESENT(1),
ABSENT(2),
VALUE_NOT_SET(0);
private final int value;
private ValueCase(int value) {
this.value = value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static ValueCase valueOf(int value) {
return forNumber(value);
}
public static ValueCase forNumber(int value) {
switch (value) {
case 1: return PRESENT;
case 2: return ABSENT;
case 0: return VALUE_NOT_SET;
default: return null;
}
}
public int getNumber() {
return this.value;
}
};
public ValueCase
getValueCase() {
return ValueCase.forNumber(
valueCase_);
}
public static final int PRESENT_FIELD_NUMBER = 1;
/**
* <code>optional string present = 1;</code>
*/
public java.lang.String getPresent() {
java.lang.Object ref = "";
if (valueCase_ == 1) {
ref = value_;
}
if (ref instanceof java.lang.String) {
return (java.lang.String) ref;
} else {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
if (valueCase_ == 1) {
value_ = s;
}
return s;
}
}
/**
* <code>optional string present = 1;</code>
*/
public com.google.protobuf.ByteString
getPresentBytes() {
java.lang.Object ref = "";
if (valueCase_ == 1) {
ref = value_;
}
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
if (valueCase_ == 1) {
value_ = b;
}
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
public static final int ABSENT_FIELD_NUMBER = 2;
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getAbsent() {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAbsentOrBuilder() {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (valueCase_ == 1) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, value_);
}
if (valueCase_ == 2) {
output.writeMessage(2, (ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (valueCase_ == 1) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, value_);
}
if (valueCase_ == 2) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(2, (ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.OptionalRegex)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex other = (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) obj;
boolean result = true;
result = result && getValueCase().equals(
other.getValueCase());
if (!result) return false;
switch (valueCase_) {
case 1:
result = result && getPresent()
.equals(other.getPresent());
break;
case 2:
result = result && getAbsent()
.equals(other.getAbsent());
break;
case 0:
default:
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
switch (valueCase_) {
case 1:
hash = (37 * hash) + PRESENT_FIELD_NUMBER;
hash = (53 * hash) + getPresent().hashCode();
break;
case 2:
hash = (37 * hash) + ABSENT_FIELD_NUMBER;
hash = (53 * hash) + getAbsent().hashCode();
break;
case 0:
default:
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalRegex parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalRegex parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalRegex parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalRegex parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalRegex parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalRegex parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalRegex parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalRegex parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalRegex parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalRegex parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.OptionalRegex prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.OptionalRegex}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.OptionalRegex)
ai.grakn.rpc.generated.GrpcConcept.OptionalRegexOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalRegex_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalRegex_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.class, ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
valueCase_ = 0;
value_ = null;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalRegex_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegex getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegex build() {
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegex buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex result = new ai.grakn.rpc.generated.GrpcConcept.OptionalRegex(this);
if (valueCase_ == 1) {
result.value_ = value_;
}
if (valueCase_ == 2) {
if (absentBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = absentBuilder_.build();
}
}
result.valueCase_ = valueCase_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.OptionalRegex)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.OptionalRegex other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.OptionalRegex.getDefaultInstance()) return this;
switch (other.getValueCase()) {
case PRESENT: {
valueCase_ = 1;
value_ = other.value_;
onChanged();
break;
}
case ABSENT: {
mergeAbsent(other.getAbsent());
break;
}
case VALUE_NOT_SET: {
break;
}
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.OptionalRegex parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.OptionalRegex) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int valueCase_ = 0;
private java.lang.Object value_;
public ValueCase
getValueCase() {
return ValueCase.forNumber(
valueCase_);
}
public Builder clearValue() {
valueCase_ = 0;
value_ = null;
onChanged();
return this;
}
/**
* <code>optional string present = 1;</code>
*/
public java.lang.String getPresent() {
java.lang.Object ref = "";
if (valueCase_ == 1) {
ref = value_;
}
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
if (valueCase_ == 1) {
value_ = s;
}
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <code>optional string present = 1;</code>
*/
public com.google.protobuf.ByteString
getPresentBytes() {
java.lang.Object ref = "";
if (valueCase_ == 1) {
ref = value_;
}
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
if (valueCase_ == 1) {
value_ = b;
}
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <code>optional string present = 1;</code>
*/
public Builder setPresent(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
valueCase_ = 1;
value_ = value;
onChanged();
return this;
}
/**
* <code>optional string present = 1;</code>
*/
public Builder clearPresent() {
if (valueCase_ == 1) {
valueCase_ = 0;
value_ = null;
onChanged();
}
return this;
}
/**
* <code>optional string present = 1;</code>
*/
public Builder setPresentBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
valueCase_ = 1;
value_ = value;
onChanged();
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> absentBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getAbsent() {
if (absentBuilder_ == null) {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (valueCase_ == 2) {
return absentBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder setAbsent(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (absentBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
absentBuilder_.setMessage(value);
}
valueCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder setAbsent(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (absentBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
absentBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder mergeAbsent(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (absentBuilder_ == null) {
if (valueCase_ == 2 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 2) {
absentBuilder_.mergeFrom(value);
}
absentBuilder_.setMessage(value);
}
valueCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder clearAbsent() {
if (absentBuilder_ == null) {
if (valueCase_ == 2) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 2) {
valueCase_ = 0;
value_ = null;
}
absentBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getAbsentBuilder() {
return getAbsentFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAbsentOrBuilder() {
if ((valueCase_ == 2) && (absentBuilder_ != null)) {
return absentBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getAbsentFieldBuilder() {
if (absentBuilder_ == null) {
if (!(valueCase_ == 2)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
absentBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 2;
onChanged();;
return absentBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.OptionalRegex)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.OptionalRegex)
private static final ai.grakn.rpc.generated.GrpcConcept.OptionalRegex DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.OptionalRegex();
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalRegex getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<OptionalRegex>
PARSER = new com.google.protobuf.AbstractParser<OptionalRegex>() {
public OptionalRegex parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new OptionalRegex(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<OptionalRegex> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<OptionalRegex> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalRegex getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface PatternOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Pattern)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional string value = 1;</code>
*/
java.lang.String getValue();
/**
* <code>optional string value = 1;</code>
*/
com.google.protobuf.ByteString
getValueBytes();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.Pattern}
*/
public static final class Pattern extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Pattern)
PatternOrBuilder {
// Use Pattern.newBuilder() to construct.
private Pattern(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Pattern() {
value_ = "";
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Pattern(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
value_ = s;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Pattern_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Pattern_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.Pattern.class, ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder.class);
}
public static final int VALUE_FIELD_NUMBER = 1;
private volatile java.lang.Object value_;
/**
* <code>optional string value = 1;</code>
*/
public java.lang.String getValue() {
java.lang.Object ref = value_;
if (ref instanceof java.lang.String) {
return (java.lang.String) ref;
} else {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
value_ = s;
return s;
}
}
/**
* <code>optional string value = 1;</code>
*/
public com.google.protobuf.ByteString
getValueBytes() {
java.lang.Object ref = value_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
value_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (!getValueBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, value_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (!getValueBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, value_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.Pattern)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.Pattern other = (ai.grakn.rpc.generated.GrpcConcept.Pattern) obj;
boolean result = true;
result = result && getValue()
.equals(other.getValue());
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
hash = (37 * hash) + VALUE_FIELD_NUMBER;
hash = (53 * hash) + getValue().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.Pattern parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.Pattern parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Pattern parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.Pattern parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Pattern parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Pattern parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Pattern parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Pattern parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.Pattern parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.Pattern parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.Pattern prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.Pattern}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Pattern)
ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Pattern_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Pattern_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.Pattern.class, ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.Pattern.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
value_ = "";
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_Pattern_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.Pattern getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.Pattern build() {
ai.grakn.rpc.generated.GrpcConcept.Pattern result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.Pattern buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.Pattern result = new ai.grakn.rpc.generated.GrpcConcept.Pattern(this);
result.value_ = value_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.Pattern) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Pattern)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.Pattern other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance()) return this;
if (!other.getValue().isEmpty()) {
value_ = other.value_;
onChanged();
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.Pattern parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.Pattern) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private java.lang.Object value_ = "";
/**
* <code>optional string value = 1;</code>
*/
public java.lang.String getValue() {
java.lang.Object ref = value_;
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
value_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <code>optional string value = 1;</code>
*/
public com.google.protobuf.ByteString
getValueBytes() {
java.lang.Object ref = value_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
value_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <code>optional string value = 1;</code>
*/
public Builder setValue(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
return this;
}
/**
* <code>optional string value = 1;</code>
*/
public Builder clearValue() {
value_ = getDefaultInstance().getValue();
onChanged();
return this;
}
/**
* <code>optional string value = 1;</code>
*/
public Builder setValueBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
value_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Pattern)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Pattern)
private static final ai.grakn.rpc.generated.GrpcConcept.Pattern DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.Pattern();
}
public static ai.grakn.rpc.generated.GrpcConcept.Pattern getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Pattern>
PARSER = new com.google.protobuf.AbstractParser<Pattern>() {
public Pattern parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Pattern(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Pattern> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Pattern> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.Pattern getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface OptionalPatternOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.OptionalPattern)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.Pattern present = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Pattern getPresent();
/**
* <code>optional .ai.grakn.rpc.generated.Pattern present = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder getPresentOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getAbsent();
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAbsentOrBuilder();
public ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.ValueCase getValueCase();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.OptionalPattern}
*/
public static final class OptionalPattern extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.OptionalPattern)
OptionalPatternOrBuilder {
// Use OptionalPattern.newBuilder() to construct.
private OptionalPattern(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private OptionalPattern() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private OptionalPattern(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder subBuilder = null;
if (valueCase_ == 1) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Pattern) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Pattern.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Pattern) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 1;
break;
}
case 18: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (valueCase_ == 2) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 2;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalPattern_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalPattern_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.class, ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.Builder.class);
}
private int valueCase_ = 0;
private java.lang.Object value_;
public enum ValueCase
implements com.google.protobuf.Internal.EnumLite {
PRESENT(1),
ABSENT(2),
VALUE_NOT_SET(0);
private final int value;
private ValueCase(int value) {
this.value = value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static ValueCase valueOf(int value) {
return forNumber(value);
}
public static ValueCase forNumber(int value) {
switch (value) {
case 1: return PRESENT;
case 2: return ABSENT;
case 0: return VALUE_NOT_SET;
default: return null;
}
}
public int getNumber() {
return this.value;
}
};
public ValueCase
getValueCase() {
return ValueCase.forNumber(
valueCase_);
}
public static final int PRESENT_FIELD_NUMBER = 1;
/**
* <code>optional .ai.grakn.rpc.generated.Pattern present = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Pattern getPresent() {
if (valueCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.Pattern) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern present = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder getPresentOrBuilder() {
if (valueCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.Pattern) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance();
}
public static final int ABSENT_FIELD_NUMBER = 2;
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getAbsent() {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAbsentOrBuilder() {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (valueCase_ == 1) {
output.writeMessage(1, (ai.grakn.rpc.generated.GrpcConcept.Pattern) value_);
}
if (valueCase_ == 2) {
output.writeMessage(2, (ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (valueCase_ == 1) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, (ai.grakn.rpc.generated.GrpcConcept.Pattern) value_);
}
if (valueCase_ == 2) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(2, (ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.OptionalPattern)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.OptionalPattern other = (ai.grakn.rpc.generated.GrpcConcept.OptionalPattern) obj;
boolean result = true;
result = result && getValueCase().equals(
other.getValueCase());
if (!result) return false;
switch (valueCase_) {
case 1:
result = result && getPresent()
.equals(other.getPresent());
break;
case 2:
result = result && getAbsent()
.equals(other.getAbsent());
break;
case 0:
default:
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
switch (valueCase_) {
case 1:
hash = (37 * hash) + PRESENT_FIELD_NUMBER;
hash = (53 * hash) + getPresent().hashCode();
break;
case 2:
hash = (37 * hash) + ABSENT_FIELD_NUMBER;
hash = (53 * hash) + getAbsent().hashCode();
break;
case 0:
default:
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalPattern parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalPattern parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalPattern parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalPattern parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalPattern parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalPattern parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalPattern parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalPattern parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalPattern parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalPattern parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.OptionalPattern prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.OptionalPattern}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.OptionalPattern)
ai.grakn.rpc.generated.GrpcConcept.OptionalPatternOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalPattern_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalPattern_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.class, ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
valueCase_ = 0;
value_ = null;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalPattern_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalPattern getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalPattern build() {
ai.grakn.rpc.generated.GrpcConcept.OptionalPattern result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalPattern buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.OptionalPattern result = new ai.grakn.rpc.generated.GrpcConcept.OptionalPattern(this);
if (valueCase_ == 1) {
if (presentBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = presentBuilder_.build();
}
}
if (valueCase_ == 2) {
if (absentBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = absentBuilder_.build();
}
}
result.valueCase_ = valueCase_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.OptionalPattern) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.OptionalPattern)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.OptionalPattern other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.OptionalPattern.getDefaultInstance()) return this;
switch (other.getValueCase()) {
case PRESENT: {
mergePresent(other.getPresent());
break;
}
case ABSENT: {
mergeAbsent(other.getAbsent());
break;
}
case VALUE_NOT_SET: {
break;
}
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.OptionalPattern parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.OptionalPattern) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int valueCase_ = 0;
private java.lang.Object value_;
public ValueCase
getValueCase() {
return ValueCase.forNumber(
valueCase_);
}
public Builder clearValue() {
valueCase_ = 0;
value_ = null;
onChanged();
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Pattern, ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder, ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder> presentBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Pattern present = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Pattern getPresent() {
if (presentBuilder_ == null) {
if (valueCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.Pattern) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance();
} else {
if (valueCase_ == 1) {
return presentBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern present = 1;</code>
*/
public Builder setPresent(ai.grakn.rpc.generated.GrpcConcept.Pattern value) {
if (presentBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
presentBuilder_.setMessage(value);
}
valueCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern present = 1;</code>
*/
public Builder setPresent(
ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder builderForValue) {
if (presentBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
presentBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern present = 1;</code>
*/
public Builder mergePresent(ai.grakn.rpc.generated.GrpcConcept.Pattern value) {
if (presentBuilder_ == null) {
if (valueCase_ == 1 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Pattern.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Pattern) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 1) {
presentBuilder_.mergeFrom(value);
}
presentBuilder_.setMessage(value);
}
valueCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern present = 1;</code>
*/
public Builder clearPresent() {
if (presentBuilder_ == null) {
if (valueCase_ == 1) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 1) {
valueCase_ = 0;
value_ = null;
}
presentBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern present = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder getPresentBuilder() {
return getPresentFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern present = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder getPresentOrBuilder() {
if ((valueCase_ == 1) && (presentBuilder_ != null)) {
return presentBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcConcept.Pattern) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern present = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Pattern, ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder, ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder>
getPresentFieldBuilder() {
if (presentBuilder_ == null) {
if (!(valueCase_ == 1)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance();
}
presentBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Pattern, ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder, ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Pattern) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 1;
onChanged();;
return presentBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> absentBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getAbsent() {
if (absentBuilder_ == null) {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (valueCase_ == 2) {
return absentBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder setAbsent(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (absentBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
absentBuilder_.setMessage(value);
}
valueCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder setAbsent(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (absentBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
absentBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder mergeAbsent(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (absentBuilder_ == null) {
if (valueCase_ == 2 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 2) {
absentBuilder_.mergeFrom(value);
}
absentBuilder_.setMessage(value);
}
valueCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder clearAbsent() {
if (absentBuilder_ == null) {
if (valueCase_ == 2) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 2) {
valueCase_ = 0;
value_ = null;
}
absentBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getAbsentBuilder() {
return getAbsentFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAbsentOrBuilder() {
if ((valueCase_ == 2) && (absentBuilder_ != null)) {
return absentBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getAbsentFieldBuilder() {
if (absentBuilder_ == null) {
if (!(valueCase_ == 2)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
absentBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 2;
onChanged();;
return absentBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.OptionalPattern)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.OptionalPattern)
private static final ai.grakn.rpc.generated.GrpcConcept.OptionalPattern DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.OptionalPattern();
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalPattern getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<OptionalPattern>
PARSER = new com.google.protobuf.AbstractParser<OptionalPattern>() {
public OptionalPattern parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new OptionalPattern(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<OptionalPattern> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<OptionalPattern> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalPattern getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface OptionalDataTypeOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.OptionalDataType)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.DataType present = 1;</code>
*/
int getPresentValue();
/**
* <code>optional .ai.grakn.rpc.generated.DataType present = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.DataType getPresent();
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Unit getAbsent();
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAbsentOrBuilder();
public ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.ValueCase getValueCase();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.OptionalDataType}
*/
public static final class OptionalDataType extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.OptionalDataType)
OptionalDataTypeOrBuilder {
// Use OptionalDataType.newBuilder() to construct.
private OptionalDataType(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private OptionalDataType() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private OptionalDataType(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 8: {
int rawValue = input.readEnum();
valueCase_ = 1;
value_ = rawValue;
break;
}
case 18: {
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder subBuilder = null;
if (valueCase_ == 2) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Unit) value_).toBuilder();
}
value_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Unit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
value_ = subBuilder.buildPartial();
}
valueCase_ = 2;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalDataType_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalDataType_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.class, ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.Builder.class);
}
private int valueCase_ = 0;
private java.lang.Object value_;
public enum ValueCase
implements com.google.protobuf.Internal.EnumLite {
PRESENT(1),
ABSENT(2),
VALUE_NOT_SET(0);
private final int value;
private ValueCase(int value) {
this.value = value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static ValueCase valueOf(int value) {
return forNumber(value);
}
public static ValueCase forNumber(int value) {
switch (value) {
case 1: return PRESENT;
case 2: return ABSENT;
case 0: return VALUE_NOT_SET;
default: return null;
}
}
public int getNumber() {
return this.value;
}
};
public ValueCase
getValueCase() {
return ValueCase.forNumber(
valueCase_);
}
public static final int PRESENT_FIELD_NUMBER = 1;
/**
* <code>optional .ai.grakn.rpc.generated.DataType present = 1;</code>
*/
public int getPresentValue() {
if (valueCase_ == 1) {
return (java.lang.Integer) value_;
}
return 0;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType present = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.DataType getPresent() {
if (valueCase_ == 1) {
ai.grakn.rpc.generated.GrpcConcept.DataType result = ai.grakn.rpc.generated.GrpcConcept.DataType.valueOf(
(java.lang.Integer) value_);
return result == null ? ai.grakn.rpc.generated.GrpcConcept.DataType.UNRECOGNIZED : result;
}
return ai.grakn.rpc.generated.GrpcConcept.DataType.String;
}
public static final int ABSENT_FIELD_NUMBER = 2;
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getAbsent() {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAbsentOrBuilder() {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (valueCase_ == 1) {
output.writeEnum(1, ((java.lang.Integer) value_));
}
if (valueCase_ == 2) {
output.writeMessage(2, (ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (valueCase_ == 1) {
size += com.google.protobuf.CodedOutputStream
.computeEnumSize(1, ((java.lang.Integer) value_));
}
if (valueCase_ == 2) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(2, (ai.grakn.rpc.generated.GrpcConcept.Unit) value_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcConcept.OptionalDataType)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcConcept.OptionalDataType other = (ai.grakn.rpc.generated.GrpcConcept.OptionalDataType) obj;
boolean result = true;
result = result && getValueCase().equals(
other.getValueCase());
if (!result) return false;
switch (valueCase_) {
case 1:
result = result && getPresentValue()
== other.getPresentValue();
break;
case 2:
result = result && getAbsent()
.equals(other.getAbsent());
break;
case 0:
default:
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
switch (valueCase_) {
case 1:
hash = (37 * hash) + PRESENT_FIELD_NUMBER;
hash = (53 * hash) + getPresentValue();
break;
case 2:
hash = (37 * hash) + ABSENT_FIELD_NUMBER;
hash = (53 * hash) + getAbsent().hashCode();
break;
case 0:
default:
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalDataType parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalDataType parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalDataType parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalDataType parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalDataType parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalDataType parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalDataType parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalDataType parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalDataType parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalDataType parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcConcept.OptionalDataType prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.OptionalDataType}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.OptionalDataType)
ai.grakn.rpc.generated.GrpcConcept.OptionalDataTypeOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalDataType_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalDataType_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.class, ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
valueCase_ = 0;
value_ = null;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcConcept.internal_static_ai_grakn_rpc_generated_OptionalDataType_descriptor;
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalDataType getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalDataType build() {
ai.grakn.rpc.generated.GrpcConcept.OptionalDataType result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalDataType buildPartial() {
ai.grakn.rpc.generated.GrpcConcept.OptionalDataType result = new ai.grakn.rpc.generated.GrpcConcept.OptionalDataType(this);
if (valueCase_ == 1) {
result.value_ = value_;
}
if (valueCase_ == 2) {
if (absentBuilder_ == null) {
result.value_ = value_;
} else {
result.value_ = absentBuilder_.build();
}
}
result.valueCase_ = valueCase_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcConcept.OptionalDataType) {
return mergeFrom((ai.grakn.rpc.generated.GrpcConcept.OptionalDataType)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcConcept.OptionalDataType other) {
if (other == ai.grakn.rpc.generated.GrpcConcept.OptionalDataType.getDefaultInstance()) return this;
switch (other.getValueCase()) {
case PRESENT: {
setPresentValue(other.getPresentValue());
break;
}
case ABSENT: {
mergeAbsent(other.getAbsent());
break;
}
case VALUE_NOT_SET: {
break;
}
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcConcept.OptionalDataType parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcConcept.OptionalDataType) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int valueCase_ = 0;
private java.lang.Object value_;
public ValueCase
getValueCase() {
return ValueCase.forNumber(
valueCase_);
}
public Builder clearValue() {
valueCase_ = 0;
value_ = null;
onChanged();
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType present = 1;</code>
*/
public int getPresentValue() {
if (valueCase_ == 1) {
return ((java.lang.Integer) value_).intValue();
}
return 0;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType present = 1;</code>
*/
public Builder setPresentValue(int value) {
valueCase_ = 1;
value_ = value;
onChanged();
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType present = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.DataType getPresent() {
if (valueCase_ == 1) {
ai.grakn.rpc.generated.GrpcConcept.DataType result = ai.grakn.rpc.generated.GrpcConcept.DataType.valueOf(
(java.lang.Integer) value_);
return result == null ? ai.grakn.rpc.generated.GrpcConcept.DataType.UNRECOGNIZED : result;
}
return ai.grakn.rpc.generated.GrpcConcept.DataType.String;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType present = 1;</code>
*/
public Builder setPresent(ai.grakn.rpc.generated.GrpcConcept.DataType value) {
if (value == null) {
throw new NullPointerException();
}
valueCase_ = 1;
value_ = value.getNumber();
onChanged();
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType present = 1;</code>
*/
public Builder clearPresent() {
if (valueCase_ == 1) {
valueCase_ = 0;
value_ = null;
onChanged();
}
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder> absentBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit getAbsent() {
if (absentBuilder_ == null) {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
} else {
if (valueCase_ == 2) {
return absentBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder setAbsent(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (absentBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
} else {
absentBuilder_.setMessage(value);
}
valueCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder setAbsent(
ai.grakn.rpc.generated.GrpcConcept.Unit.Builder builderForValue) {
if (absentBuilder_ == null) {
value_ = builderForValue.build();
onChanged();
} else {
absentBuilder_.setMessage(builderForValue.build());
}
valueCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder mergeAbsent(ai.grakn.rpc.generated.GrpcConcept.Unit value) {
if (absentBuilder_ == null) {
if (valueCase_ == 2 &&
value_ != ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance()) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Unit.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Unit) value_)
.mergeFrom(value).buildPartial();
} else {
value_ = value;
}
onChanged();
} else {
if (valueCase_ == 2) {
absentBuilder_.mergeFrom(value);
}
absentBuilder_.setMessage(value);
}
valueCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public Builder clearAbsent() {
if (absentBuilder_ == null) {
if (valueCase_ == 2) {
valueCase_ = 0;
value_ = null;
onChanged();
}
} else {
if (valueCase_ == 2) {
valueCase_ = 0;
value_ = null;
}
absentBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Unit.Builder getAbsentBuilder() {
return getAbsentFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder getAbsentOrBuilder() {
if ((valueCase_ == 2) && (absentBuilder_ != null)) {
return absentBuilder_.getMessageOrBuilder();
} else {
if (valueCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcConcept.Unit) value_;
}
return ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Unit absent = 2;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>
getAbsentFieldBuilder() {
if (absentBuilder_ == null) {
if (!(valueCase_ == 2)) {
value_ = ai.grakn.rpc.generated.GrpcConcept.Unit.getDefaultInstance();
}
absentBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Unit, ai.grakn.rpc.generated.GrpcConcept.Unit.Builder, ai.grakn.rpc.generated.GrpcConcept.UnitOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Unit) value_,
getParentForChildren(),
isClean());
value_ = null;
}
valueCase_ = 2;
onChanged();;
return absentBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.OptionalDataType)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.OptionalDataType)
private static final ai.grakn.rpc.generated.GrpcConcept.OptionalDataType DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcConcept.OptionalDataType();
}
public static ai.grakn.rpc.generated.GrpcConcept.OptionalDataType getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<OptionalDataType>
PARSER = new com.google.protobuf.AbstractParser<OptionalDataType>() {
public OptionalDataType parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new OptionalDataType(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<OptionalDataType> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<OptionalDataType> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcConcept.OptionalDataType getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Concept_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Concept_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_ConceptId_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_ConceptId_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_ConceptMethod_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_ConceptMethod_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Unit_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Unit_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_ConceptResponse_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_ConceptResponse_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_AttributeValue_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_AttributeValue_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Label_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Label_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_RolePlayers_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_RolePlayers_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_RolePlayer_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_RolePlayer_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Concepts_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Concepts_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_OptionalConcept_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_OptionalConcept_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_OptionalRegex_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_OptionalRegex_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Pattern_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Pattern_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_OptionalPattern_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_OptionalPattern_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_OptionalDataType_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_OptionalDataType_fieldAccessorTable;
public static com.google.protobuf.Descriptors.FileDescriptor
getDescriptor() {
return descriptor;
}
private static com.google.protobuf.Descriptors.FileDescriptor
descriptor;
static {
java.lang.String[] descriptorData = {
"\n\rconcept.proto\022\026ai.grakn.rpc.generated\032" +
"\016iterator.proto\"l\n\007Concept\022-\n\002id\030\001 \001(\0132!" +
".ai.grakn.rpc.generated.ConceptId\0222\n\010bas" +
"eType\030\002 \001(\0162 .ai.grakn.rpc.generated.Bas" +
"eType\"\032\n\tConceptId\022\r\n\005value\030\001 \001(\t\"\311\027\n\rCo" +
"nceptMethod\022.\n\006delete\030\020 \001(\0132\034.ai.grakn.r" +
"pc.generated.UnitH\000\0220\n\010getLabel\030\003 \001(\0132\034." +
"ai.grakn.rpc.generated.UnitH\000\0221\n\010setLabe" +
"l\030\022 \001(\0132\035.ai.grakn.rpc.generated.LabelH\000" +
"\0222\n\nisImplicit\030\004 \001(\0132\034.ai.grakn.rpc.gene",
"rated.UnitH\000\0226\n\016getSubConcepts\030\023 \001(\0132\034.a" +
"i.grakn.rpc.generated.UnitH\000\0228\n\020getSuper" +
"Concepts\0305 \001(\0132\034.ai.grakn.rpc.generated." +
"UnitH\000\022=\n\025getDirectSuperConcept\030\016 \001(\0132\034." +
"ai.grakn.rpc.generated.UnitH\000\022@\n\025setDire" +
"ctSuperConcept\030\021 \001(\0132\037.ai.grakn.rpc.gene" +
"rated.ConceptH\000\022/\n\007getWhen\030\007 \001(\0132\034.ai.gr" +
"akn.rpc.generated.UnitH\000\022/\n\007getThen\030\010 \001(" +
"\0132\034.ai.grakn.rpc.generated.UnitH\000\022J\n\"get" +
"RelationshipTypesThatRelateRole\030\024 \001(\0132\034.",
"ai.grakn.rpc.generated.UnitH\000\022<\n\024getType" +
"sThatPlayRole\030\025 \001(\0132\034.ai.grakn.rpc.gener" +
"ated.UnitH\000\0224\n\014getInstances\030\036 \001(\0132\034.ai.g" +
"rakn.rpc.generated.UnitH\000\0229\n\021getAttribut" +
"eTypes\030\013 \001(\0132\034.ai.grakn.rpc.generated.Un" +
"itH\000\022;\n\020setAttributeType\030\031 \001(\0132\037.ai.grak" +
"n.rpc.generated.ConceptH\000\022=\n\022unsetAttrib" +
"uteType\030\032 \001(\0132\037.ai.grakn.rpc.generated.C" +
"onceptH\000\0223\n\013getKeyTypes\030\014 \001(\0132\034.ai.grakn" +
".rpc.generated.UnitH\000\0225\n\nsetKeyType\030\033 \001(",
"\0132\037.ai.grakn.rpc.generated.ConceptH\000\0227\n\014" +
"unsetKeyType\030\034 \001(\0132\037.ai.grakn.rpc.genera" +
"ted.ConceptH\000\0222\n\nisAbstract\030\006 \001(\0132\034.ai.g" +
"rakn.rpc.generated.UnitH\000\022\025\n\013setAbstract" +
"\030\026 \001(\010H\000\022<\n\024getRolesPlayedByType\030\035 \001(\0132\034" +
".ai.grakn.rpc.generated.UnitH\000\022>\n\023setRol" +
"ePlayedByType\030\027 \001(\0132\037.ai.grakn.rpc.gener" +
"ated.ConceptH\000\022@\n\025unsetRolePlayedByType\030" +
"\030 \001(\0132\037.ai.grakn.rpc.generated.ConceptH\000" +
"\0221\n\taddEntity\030\" \001(\0132\034.ai.grakn.rpc.gener",
"ated.UnitH\000\0227\n\017getRelatedRoles\030$ \001(\0132\034.a" +
"i.grakn.rpc.generated.UnitH\000\0229\n\016setRelat" +
"edRole\030% \001(\0132\037.ai.grakn.rpc.generated.Co" +
"nceptH\000\022;\n\020unsetRelatedRole\030& \001(\0132\037.ai.g" +
"rakn.rpc.generated.ConceptH\000\022>\n\014putAttri" +
"bute\030 \001(\0132&.ai.grakn.rpc.generated.Attr" +
"ibuteValueH\000\022>\n\014getAttribute\030! \001(\0132&.ai." +
"grakn.rpc.generated.AttributeValueH\000\0229\n\021" +
"getDataTypeOfType\030\002 \001(\0132\034.ai.grakn.rpc.g" +
"enerated.UnitH\000\022>\n\026getDataTypeOfAttribut",
"e\0306 \001(\0132\034.ai.grakn.rpc.generated.UnitH\000\022" +
"0\n\010getRegex\030\t \001(\0132\034.ai.grakn.rpc.generat" +
"ed.UnitH\000\0229\n\010setRegex\030\037 \001(\0132%.ai.grakn.r" +
"pc.generated.OptionalRegexH\000\0222\n\nisInferr" +
"ed\030\005 \001(\0132\034.ai.grakn.rpc.generated.UnitH\000" +
"\0225\n\rgetDirectType\030\r \001(\0132\034.ai.grakn.rpc.g" +
"enerated.UnitH\000\0228\n\020getRelationships\030\' \001(" +
"\0132\034.ai.grakn.rpc.generated.UnitH\000\022C\n\027get" +
"RelationshipsByRoles\0300 \001(\0132 .ai.grakn.rp" +
"c.generated.ConceptsH\000\022=\n\025getRolesPlayed",
"ByThing\030( \001(\0132\034.ai.grakn.rpc.generated.U" +
"nitH\000\0225\n\rgetAttributes\030) \001(\0132\034.ai.grakn." +
"rpc.generated.UnitH\000\022@\n\024getAttributesByT" +
"ypes\0301 \001(\0132 .ai.grakn.rpc.generated.Conc" +
"eptsH\000\022/\n\007getKeys\030* \001(\0132\034.ai.grakn.rpc.g" +
"enerated.UnitH\000\022:\n\016getKeysByTypes\0302 \001(\0132" +
" .ai.grakn.rpc.generated.ConceptsH\000\0227\n\014s" +
"etAttribute\030+ \001(\0132\037.ai.grakn.rpc.generat" +
"ed.ConceptH\000\0229\n\016unsetAttribute\030, \001(\0132\037.a" +
"i.grakn.rpc.generated.ConceptH\000\0227\n\017addRe",
"lationship\030# \001(\0132\034.ai.grakn.rpc.generate" +
"d.UnitH\000\0226\n\016getRolePlayers\030\n \001(\0132\034.ai.gr" +
"akn.rpc.generated.UnitH\000\022A\n\025getRolePlaye" +
"rsByRoles\0303 \001(\0132 .ai.grakn.rpc.generated" +
".ConceptsH\000\022;\n\rsetRolePlayer\030. \001(\0132\".ai." +
"grakn.rpc.generated.RolePlayerH\000\022=\n\017unse" +
"tRolePlayer\030\017 \001(\0132\".ai.grakn.rpc.generat" +
"ed.RolePlayerH\000\0220\n\010getValue\030\001 \001(\0132\034.ai.g" +
"rakn.rpc.generated.UnitH\000\0221\n\tgetOwners\030/" +
" \001(\0132\034.ai.grakn.rpc.generated.UnitH\000B\017\n\r",
"conceptMethod\"\006\n\004Unit\"\216\005\n\017ConceptRespons" +
"e\022@\n\016attributeValue\030\001 \001(\0132&.ai.grakn.rpc" +
".generated.AttributeValueH\000\0224\n\010dataType\030" +
"\002 \001(\0162 .ai.grakn.rpc.generated.DataTypeH" +
"\000\022.\n\005label\030\003 \001(\0132\035.ai.grakn.rpc.generate" +
"d.LabelH\000\022\016\n\004bool\030\004 \001(\010H\000\022B\n\017optionalPat" +
"tern\030\005 \001(\0132\'.ai.grakn.rpc.generated.Opti" +
"onalPatternH\000\022\020\n\006string\030\006 \001(\tH\000\0222\n\007conce" +
"pt\030\t \001(\0132\037.ai.grakn.rpc.generated.Concep" +
"tH\000\022,\n\004unit\030\n \001(\0132\034.ai.grakn.rpc.generat",
"ed.UnitH\000\022>\n\roptionalRegex\030\013 \001(\0132%.ai.gr" +
"akn.rpc.generated.OptionalRegexH\000\022B\n\017opt" +
"ionalConcept\030\014 \001(\0132\'.ai.grakn.rpc.genera" +
"ted.OptionalConceptH\000\022D\n\020optionalDataTyp" +
"e\030\r \001(\0132(.ai.grakn.rpc.generated.Optiona" +
"lDataTypeH\000\0228\n\niteratorId\030\016 \001(\0132\".ai.gra" +
"kn.rpc.generated.IteratorIdH\000B\007\n\005value\"\224" +
"\001\n\016AttributeValue\022\020\n\006string\030\001 \001(\tH\000\022\021\n\007b" +
"oolean\030\002 \001(\010H\000\022\021\n\007integer\030\003 \001(\005H\000\022\016\n\004lon" +
"g\030\004 \001(\003H\000\022\017\n\005float\030\005 \001(\002H\000\022\020\n\006double\030\006 \001",
"(\001H\000\022\016\n\004date\030\007 \001(\003H\000B\007\n\005value\"\026\n\005Label\022\r" +
"\n\005value\030\001 \001(\t\"E\n\013RolePlayers\0226\n\nrolePlay" +
"er\030\001 \003(\0132\".ai.grakn.rpc.generated.RolePl" +
"ayer\"l\n\nRolePlayer\022-\n\004role\030\001 \001(\0132\037.ai.gr" +
"akn.rpc.generated.Concept\022/\n\006player\030\002 \001(" +
"\0132\037.ai.grakn.rpc.generated.Concept\"<\n\010Co" +
"ncepts\0220\n\007concept\030\001 \003(\0132\037.ai.grakn.rpc.g" +
"enerated.Concept\"~\n\017OptionalConcept\0222\n\007p" +
"resent\030\001 \001(\0132\037.ai.grakn.rpc.generated.Co" +
"nceptH\000\022.\n\006absent\030\002 \001(\0132\034.ai.grakn.rpc.g",
"enerated.UnitH\000B\007\n\005value\"[\n\rOptionalRege" +
"x\022\021\n\007present\030\001 \001(\tH\000\022.\n\006absent\030\002 \001(\0132\034.a" +
"i.grakn.rpc.generated.UnitH\000B\007\n\005value\"\030\n" +
"\007Pattern\022\r\n\005value\030\001 \001(\t\"~\n\017OptionalPatte" +
"rn\0222\n\007present\030\001 \001(\0132\037.ai.grakn.rpc.gener" +
"ated.PatternH\000\022.\n\006absent\030\002 \001(\0132\034.ai.grak" +
"n.rpc.generated.UnitH\000B\007\n\005value\"\200\001\n\020Opti" +
"onalDataType\0223\n\007present\030\001 \001(\0162 .ai.grakn" +
".rpc.generated.DataTypeH\000\022.\n\006absent\030\002 \001(" +
"\0132\034.ai.grakn.rpc.generated.UnitH\000B\007\n\005val",
"ue*\222\001\n\010BaseType\022\n\n\006Entity\020\000\022\020\n\014Relations" +
"hip\020\001\022\r\n\tAttribute\020\002\022\016\n\nEntityType\020\003\022\024\n\020" +
"RelationshipType\020\004\022\021\n\rAttributeType\020\005\022\010\n" +
"\004Role\020\006\022\010\n\004Rule\020\007\022\014\n\010MetaType\020\010*[\n\010DataT" +
"ype\022\n\n\006String\020\000\022\013\n\007Boolean\020\001\022\013\n\007Integer\020" +
"\002\022\010\n\004Long\020\003\022\t\n\005Float\020\004\022\n\n\006Double\020\005\022\010\n\004Da" +
"te\020\006B\rB\013GrpcConceptb\006proto3"
};
com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
new com.google.protobuf.Descriptors.FileDescriptor. InternalDescriptorAssigner() {
public com.google.protobuf.ExtensionRegistry assignDescriptors(
com.google.protobuf.Descriptors.FileDescriptor root) {
descriptor = root;
return null;
}
};
com.google.protobuf.Descriptors.FileDescriptor
.internalBuildGeneratedFileFrom(descriptorData,
new com.google.protobuf.Descriptors.FileDescriptor[] {
ai.grakn.rpc.generated.GrpcIterator.getDescriptor(),
}, assigner);
internal_static_ai_grakn_rpc_generated_Concept_descriptor =
getDescriptor().getMessageTypes().get(0);
internal_static_ai_grakn_rpc_generated_Concept_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Concept_descriptor,
new java.lang.String[] { "Id", "BaseType", });
internal_static_ai_grakn_rpc_generated_ConceptId_descriptor =
getDescriptor().getMessageTypes().get(1);
internal_static_ai_grakn_rpc_generated_ConceptId_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_ConceptId_descriptor,
new java.lang.String[] { "Value", });
internal_static_ai_grakn_rpc_generated_ConceptMethod_descriptor =
getDescriptor().getMessageTypes().get(2);
internal_static_ai_grakn_rpc_generated_ConceptMethod_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_ConceptMethod_descriptor,
new java.lang.String[] { "Delete", "GetLabel", "SetLabel", "IsImplicit", "GetSubConcepts", "GetSuperConcepts", "GetDirectSuperConcept", "SetDirectSuperConcept", "GetWhen", "GetThen", "GetRelationshipTypesThatRelateRole", "GetTypesThatPlayRole", "GetInstances", "GetAttributeTypes", "SetAttributeType", "UnsetAttributeType", "GetKeyTypes", "SetKeyType", "UnsetKeyType", "IsAbstract", "SetAbstract", "GetRolesPlayedByType", "SetRolePlayedByType", "UnsetRolePlayedByType", "AddEntity", "GetRelatedRoles", "SetRelatedRole", "UnsetRelatedRole", "PutAttribute", "GetAttribute", "GetDataTypeOfType", "GetDataTypeOfAttribute", "GetRegex", "SetRegex", "IsInferred", "GetDirectType", "GetRelationships", "GetRelationshipsByRoles", "GetRolesPlayedByThing", "GetAttributes", "GetAttributesByTypes", "GetKeys", "GetKeysByTypes", "SetAttribute", "UnsetAttribute", "AddRelationship", "GetRolePlayers", "GetRolePlayersByRoles", "SetRolePlayer", "UnsetRolePlayer", "GetValue", "GetOwners", "ConceptMethod", });
internal_static_ai_grakn_rpc_generated_Unit_descriptor =
getDescriptor().getMessageTypes().get(3);
internal_static_ai_grakn_rpc_generated_Unit_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Unit_descriptor,
new java.lang.String[] { });
internal_static_ai_grakn_rpc_generated_ConceptResponse_descriptor =
getDescriptor().getMessageTypes().get(4);
internal_static_ai_grakn_rpc_generated_ConceptResponse_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_ConceptResponse_descriptor,
new java.lang.String[] { "AttributeValue", "DataType", "Label", "Bool", "OptionalPattern", "String", "Concept", "Unit", "OptionalRegex", "OptionalConcept", "OptionalDataType", "IteratorId", "Value", });
internal_static_ai_grakn_rpc_generated_AttributeValue_descriptor =
getDescriptor().getMessageTypes().get(5);
internal_static_ai_grakn_rpc_generated_AttributeValue_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_AttributeValue_descriptor,
new java.lang.String[] { "String", "Boolean", "Integer", "Long", "Float", "Double", "Date", "Value", });
internal_static_ai_grakn_rpc_generated_Label_descriptor =
getDescriptor().getMessageTypes().get(6);
internal_static_ai_grakn_rpc_generated_Label_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Label_descriptor,
new java.lang.String[] { "Value", });
internal_static_ai_grakn_rpc_generated_RolePlayers_descriptor =
getDescriptor().getMessageTypes().get(7);
internal_static_ai_grakn_rpc_generated_RolePlayers_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_RolePlayers_descriptor,
new java.lang.String[] { "RolePlayer", });
internal_static_ai_grakn_rpc_generated_RolePlayer_descriptor =
getDescriptor().getMessageTypes().get(8);
internal_static_ai_grakn_rpc_generated_RolePlayer_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_RolePlayer_descriptor,
new java.lang.String[] { "Role", "Player", });
internal_static_ai_grakn_rpc_generated_Concepts_descriptor =
getDescriptor().getMessageTypes().get(9);
internal_static_ai_grakn_rpc_generated_Concepts_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Concepts_descriptor,
new java.lang.String[] { "Concept", });
internal_static_ai_grakn_rpc_generated_OptionalConcept_descriptor =
getDescriptor().getMessageTypes().get(10);
internal_static_ai_grakn_rpc_generated_OptionalConcept_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_OptionalConcept_descriptor,
new java.lang.String[] { "Present", "Absent", "Value", });
internal_static_ai_grakn_rpc_generated_OptionalRegex_descriptor =
getDescriptor().getMessageTypes().get(11);
internal_static_ai_grakn_rpc_generated_OptionalRegex_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_OptionalRegex_descriptor,
new java.lang.String[] { "Present", "Absent", "Value", });
internal_static_ai_grakn_rpc_generated_Pattern_descriptor =
getDescriptor().getMessageTypes().get(12);
internal_static_ai_grakn_rpc_generated_Pattern_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Pattern_descriptor,
new java.lang.String[] { "Value", });
internal_static_ai_grakn_rpc_generated_OptionalPattern_descriptor =
getDescriptor().getMessageTypes().get(13);
internal_static_ai_grakn_rpc_generated_OptionalPattern_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_OptionalPattern_descriptor,
new java.lang.String[] { "Present", "Absent", "Value", });
internal_static_ai_grakn_rpc_generated_OptionalDataType_descriptor =
getDescriptor().getMessageTypes().get(14);
internal_static_ai_grakn_rpc_generated_OptionalDataType_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_OptionalDataType_descriptor,
new java.lang.String[] { "Present", "Absent", "Value", });
ai.grakn.rpc.generated.GrpcIterator.getDescriptor();
}
// @@protoc_insertion_point(outer_class_scope)
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/rpc
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/rpc/generated/GrpcGrakn.java
|
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: grakn.proto
package ai.grakn.rpc.generated;
public final class GrpcGrakn {
private GrpcGrakn() {}
public static void registerAllExtensions(
com.google.protobuf.ExtensionRegistryLite registry) {
}
public static void registerAllExtensions(
com.google.protobuf.ExtensionRegistry registry) {
registerAllExtensions(
(com.google.protobuf.ExtensionRegistryLite) registry);
}
/**
* Protobuf enum {@code ai.grakn.rpc.generated.TxType}
*/
public enum TxType
implements com.google.protobuf.ProtocolMessageEnum {
/**
* <code>Read = 0;</code>
*/
Read(0),
/**
* <code>Write = 1;</code>
*/
Write(1),
/**
* <code>Batch = 2;</code>
*/
Batch(2),
UNRECOGNIZED(-1),
;
/**
* <code>Read = 0;</code>
*/
public static final int Read_VALUE = 0;
/**
* <code>Write = 1;</code>
*/
public static final int Write_VALUE = 1;
/**
* <code>Batch = 2;</code>
*/
public static final int Batch_VALUE = 2;
public final int getNumber() {
if (this == UNRECOGNIZED) {
throw new java.lang.IllegalArgumentException(
"Can't get the number of an unknown enum value.");
}
return value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static TxType valueOf(int value) {
return forNumber(value);
}
public static TxType forNumber(int value) {
switch (value) {
case 0: return Read;
case 1: return Write;
case 2: return Batch;
default: return null;
}
}
public static com.google.protobuf.Internal.EnumLiteMap<TxType>
internalGetValueMap() {
return internalValueMap;
}
private static final com.google.protobuf.Internal.EnumLiteMap<
TxType> internalValueMap =
new com.google.protobuf.Internal.EnumLiteMap<TxType>() {
public TxType findValueByNumber(int number) {
return TxType.forNumber(number);
}
};
public final com.google.protobuf.Descriptors.EnumValueDescriptor
getValueDescriptor() {
return getDescriptor().getValues().get(ordinal());
}
public final com.google.protobuf.Descriptors.EnumDescriptor
getDescriptorForType() {
return getDescriptor();
}
public static final com.google.protobuf.Descriptors.EnumDescriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.getDescriptor().getEnumTypes().get(0);
}
private static final TxType[] VALUES = values();
public static TxType valueOf(
com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
if (desc.getType() != getDescriptor()) {
throw new java.lang.IllegalArgumentException(
"EnumValueDescriptor is not for this type.");
}
if (desc.getIndex() == -1) {
return UNRECOGNIZED;
}
return VALUES[desc.getIndex()];
}
private final int value;
private TxType(int value) {
this.value = value;
}
// @@protoc_insertion_point(enum_scope:ai.grakn.rpc.generated.TxType)
}
public interface TxRequestOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.TxRequest)
com.google.protobuf.MessageOrBuilder {
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.Open getOpen();
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.OpenOrBuilder getOpenOrBuilder();
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Commit commit = 2;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.Commit getCommit();
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Commit commit = 2;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.CommitOrBuilder getCommitOrBuilder();
/**
* <pre>
* returns QueryResult, Done, or IteratorId of QueryResult
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ExecQuery execQuery = 3;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.ExecQuery getExecQuery();
/**
* <pre>
* returns QueryResult, Done, or IteratorId of QueryResult
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ExecQuery execQuery = 3;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.ExecQueryOrBuilder getExecQueryOrBuilder();
/**
* <pre>
* returns QueryResult or Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Next next = 4;</code>
*/
ai.grakn.rpc.generated.GrpcIterator.Next getNext();
/**
* <pre>
* returns QueryResult or Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Next next = 4;</code>
*/
ai.grakn.rpc.generated.GrpcIterator.NextOrBuilder getNextOrBuilder();
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Stop stop = 5;</code>
*/
ai.grakn.rpc.generated.GrpcIterator.Stop getStop();
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Stop stop = 5;</code>
*/
ai.grakn.rpc.generated.GrpcIterator.StopOrBuilder getStopOrBuilder();
/**
* <pre>
* returns ConceptResponse
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RunConceptMethod runConceptMethod = 6;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod getRunConceptMethod();
/**
* <pre>
* returns ConceptResponse
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RunConceptMethod runConceptMethod = 6;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethodOrBuilder getRunConceptMethodOrBuilder();
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ConceptId getConcept = 7;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptId getGetConcept();
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ConceptId getConcept = 7;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder getGetConceptOrBuilder();
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label getSchemaConcept = 8;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Label getGetSchemaConcept();
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label getSchemaConcept = 8;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getGetSchemaConceptOrBuilder();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttributesByValue = 9;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.AttributeValue getGetAttributesByValue();
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttributesByValue = 9;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder getGetAttributesByValueOrBuilder();
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putEntityType = 10;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Label getPutEntityType();
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putEntityType = 10;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getPutEntityTypeOrBuilder();
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRelationshipType = 11;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Label getPutRelationshipType();
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRelationshipType = 11;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getPutRelationshipTypeOrBuilder();
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutAttributeType putAttributeType = 12;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType getPutAttributeType();
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutAttributeType putAttributeType = 12;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeTypeOrBuilder getPutAttributeTypeOrBuilder();
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRole = 13;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Label getPutRole();
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRole = 13;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getPutRoleOrBuilder();
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutRule putRule = 14;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.PutRule getPutRule();
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutRule putRule = 14;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.PutRuleOrBuilder getPutRuleOrBuilder();
public ai.grakn.rpc.generated.GrpcGrakn.TxRequest.RequestCase getRequestCase();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.TxRequest}
*/
public static final class TxRequest extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.TxRequest)
TxRequestOrBuilder {
// Use TxRequest.newBuilder() to construct.
private TxRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private TxRequest() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private TxRequest(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcGrakn.Open.Builder subBuilder = null;
if (requestCase_ == 1) {
subBuilder = ((ai.grakn.rpc.generated.GrpcGrakn.Open) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcGrakn.Open.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.Open) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 1;
break;
}
case 18: {
ai.grakn.rpc.generated.GrpcGrakn.Commit.Builder subBuilder = null;
if (requestCase_ == 2) {
subBuilder = ((ai.grakn.rpc.generated.GrpcGrakn.Commit) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcGrakn.Commit.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.Commit) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 2;
break;
}
case 26: {
ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.Builder subBuilder = null;
if (requestCase_ == 3) {
subBuilder = ((ai.grakn.rpc.generated.GrpcGrakn.ExecQuery) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.ExecQuery) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 3;
break;
}
case 34: {
ai.grakn.rpc.generated.GrpcIterator.Next.Builder subBuilder = null;
if (requestCase_ == 4) {
subBuilder = ((ai.grakn.rpc.generated.GrpcIterator.Next) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcIterator.Next.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcIterator.Next) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 4;
break;
}
case 42: {
ai.grakn.rpc.generated.GrpcIterator.Stop.Builder subBuilder = null;
if (requestCase_ == 5) {
subBuilder = ((ai.grakn.rpc.generated.GrpcIterator.Stop) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcIterator.Stop.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcIterator.Stop) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 5;
break;
}
case 50: {
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.Builder subBuilder = null;
if (requestCase_ == 6) {
subBuilder = ((ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 6;
break;
}
case 58: {
ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder subBuilder = null;
if (requestCase_ == 7) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.ConceptId) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.ConceptId.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.ConceptId) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 7;
break;
}
case 66: {
ai.grakn.rpc.generated.GrpcConcept.Label.Builder subBuilder = null;
if (requestCase_ == 8) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Label) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Label.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Label) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 8;
break;
}
case 74: {
ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder subBuilder = null;
if (requestCase_ == 9) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.AttributeValue) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.AttributeValue.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.AttributeValue) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 9;
break;
}
case 82: {
ai.grakn.rpc.generated.GrpcConcept.Label.Builder subBuilder = null;
if (requestCase_ == 10) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Label) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Label.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Label) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 10;
break;
}
case 90: {
ai.grakn.rpc.generated.GrpcConcept.Label.Builder subBuilder = null;
if (requestCase_ == 11) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Label) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Label.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Label) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 11;
break;
}
case 98: {
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.Builder subBuilder = null;
if (requestCase_ == 12) {
subBuilder = ((ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 12;
break;
}
case 106: {
ai.grakn.rpc.generated.GrpcConcept.Label.Builder subBuilder = null;
if (requestCase_ == 13) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Label) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Label.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Label) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 13;
break;
}
case 114: {
ai.grakn.rpc.generated.GrpcGrakn.PutRule.Builder subBuilder = null;
if (requestCase_ == 14) {
subBuilder = ((ai.grakn.rpc.generated.GrpcGrakn.PutRule) request_).toBuilder();
}
request_ =
input.readMessage(ai.grakn.rpc.generated.GrpcGrakn.PutRule.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.PutRule) request_);
request_ = subBuilder.buildPartial();
}
requestCase_ = 14;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_TxRequest_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_TxRequest_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.TxRequest.class, ai.grakn.rpc.generated.GrpcGrakn.TxRequest.Builder.class);
}
private int requestCase_ = 0;
private java.lang.Object request_;
public enum RequestCase
implements com.google.protobuf.Internal.EnumLite {
OPEN(1),
COMMIT(2),
EXECQUERY(3),
NEXT(4),
STOP(5),
RUNCONCEPTMETHOD(6),
GETCONCEPT(7),
GETSCHEMACONCEPT(8),
GETATTRIBUTESBYVALUE(9),
PUTENTITYTYPE(10),
PUTRELATIONSHIPTYPE(11),
PUTATTRIBUTETYPE(12),
PUTROLE(13),
PUTRULE(14),
REQUEST_NOT_SET(0);
private final int value;
private RequestCase(int value) {
this.value = value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static RequestCase valueOf(int value) {
return forNumber(value);
}
public static RequestCase forNumber(int value) {
switch (value) {
case 1: return OPEN;
case 2: return COMMIT;
case 3: return EXECQUERY;
case 4: return NEXT;
case 5: return STOP;
case 6: return RUNCONCEPTMETHOD;
case 7: return GETCONCEPT;
case 8: return GETSCHEMACONCEPT;
case 9: return GETATTRIBUTESBYVALUE;
case 10: return PUTENTITYTYPE;
case 11: return PUTRELATIONSHIPTYPE;
case 12: return PUTATTRIBUTETYPE;
case 13: return PUTROLE;
case 14: return PUTRULE;
case 0: return REQUEST_NOT_SET;
default: return null;
}
}
public int getNumber() {
return this.value;
}
};
public RequestCase
getRequestCase() {
return RequestCase.forNumber(
requestCase_);
}
public static final int OPEN_FIELD_NUMBER = 1;
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Open getOpen() {
if (requestCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcGrakn.Open) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Open.getDefaultInstance();
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.OpenOrBuilder getOpenOrBuilder() {
if (requestCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcGrakn.Open) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Open.getDefaultInstance();
}
public static final int COMMIT_FIELD_NUMBER = 2;
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Commit commit = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Commit getCommit() {
if (requestCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcGrakn.Commit) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Commit.getDefaultInstance();
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Commit commit = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.CommitOrBuilder getCommitOrBuilder() {
if (requestCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcGrakn.Commit) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Commit.getDefaultInstance();
}
public static final int EXECQUERY_FIELD_NUMBER = 3;
/**
* <pre>
* returns QueryResult, Done, or IteratorId of QueryResult
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ExecQuery execQuery = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.ExecQuery getExecQuery() {
if (requestCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcGrakn.ExecQuery) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.getDefaultInstance();
}
/**
* <pre>
* returns QueryResult, Done, or IteratorId of QueryResult
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ExecQuery execQuery = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.ExecQueryOrBuilder getExecQueryOrBuilder() {
if (requestCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcGrakn.ExecQuery) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.getDefaultInstance();
}
public static final int NEXT_FIELD_NUMBER = 4;
/**
* <pre>
* returns QueryResult or Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Next next = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.Next getNext() {
if (requestCase_ == 4) {
return (ai.grakn.rpc.generated.GrpcIterator.Next) request_;
}
return ai.grakn.rpc.generated.GrpcIterator.Next.getDefaultInstance();
}
/**
* <pre>
* returns QueryResult or Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Next next = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.NextOrBuilder getNextOrBuilder() {
if (requestCase_ == 4) {
return (ai.grakn.rpc.generated.GrpcIterator.Next) request_;
}
return ai.grakn.rpc.generated.GrpcIterator.Next.getDefaultInstance();
}
public static final int STOP_FIELD_NUMBER = 5;
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Stop stop = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.Stop getStop() {
if (requestCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcIterator.Stop) request_;
}
return ai.grakn.rpc.generated.GrpcIterator.Stop.getDefaultInstance();
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Stop stop = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.StopOrBuilder getStopOrBuilder() {
if (requestCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcIterator.Stop) request_;
}
return ai.grakn.rpc.generated.GrpcIterator.Stop.getDefaultInstance();
}
public static final int RUNCONCEPTMETHOD_FIELD_NUMBER = 6;
/**
* <pre>
* returns ConceptResponse
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RunConceptMethod runConceptMethod = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod getRunConceptMethod() {
if (requestCase_ == 6) {
return (ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.getDefaultInstance();
}
/**
* <pre>
* returns ConceptResponse
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RunConceptMethod runConceptMethod = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethodOrBuilder getRunConceptMethodOrBuilder() {
if (requestCase_ == 6) {
return (ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.getDefaultInstance();
}
public static final int GETCONCEPT_FIELD_NUMBER = 7;
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ConceptId getConcept = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptId getGetConcept() {
if (requestCase_ == 7) {
return (ai.grakn.rpc.generated.GrpcConcept.ConceptId) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance();
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ConceptId getConcept = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder getGetConceptOrBuilder() {
if (requestCase_ == 7) {
return (ai.grakn.rpc.generated.GrpcConcept.ConceptId) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance();
}
public static final int GETSCHEMACONCEPT_FIELD_NUMBER = 8;
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label getSchemaConcept = 8;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getGetSchemaConcept() {
if (requestCase_ == 8) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label getSchemaConcept = 8;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getGetSchemaConceptOrBuilder() {
if (requestCase_ == 8) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
public static final int GETATTRIBUTESBYVALUE_FIELD_NUMBER = 9;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttributesByValue = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue getGetAttributesByValue() {
if (requestCase_ == 9) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttributesByValue = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder getGetAttributesByValueOrBuilder() {
if (requestCase_ == 9) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
public static final int PUTENTITYTYPE_FIELD_NUMBER = 10;
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putEntityType = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getPutEntityType() {
if (requestCase_ == 10) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putEntityType = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getPutEntityTypeOrBuilder() {
if (requestCase_ == 10) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
public static final int PUTRELATIONSHIPTYPE_FIELD_NUMBER = 11;
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRelationshipType = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getPutRelationshipType() {
if (requestCase_ == 11) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRelationshipType = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getPutRelationshipTypeOrBuilder() {
if (requestCase_ == 11) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
public static final int PUTATTRIBUTETYPE_FIELD_NUMBER = 12;
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutAttributeType putAttributeType = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType getPutAttributeType() {
if (requestCase_ == 12) {
return (ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.getDefaultInstance();
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutAttributeType putAttributeType = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.PutAttributeTypeOrBuilder getPutAttributeTypeOrBuilder() {
if (requestCase_ == 12) {
return (ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.getDefaultInstance();
}
public static final int PUTROLE_FIELD_NUMBER = 13;
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRole = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getPutRole() {
if (requestCase_ == 13) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRole = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getPutRoleOrBuilder() {
if (requestCase_ == 13) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
public static final int PUTRULE_FIELD_NUMBER = 14;
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutRule putRule = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.PutRule getPutRule() {
if (requestCase_ == 14) {
return (ai.grakn.rpc.generated.GrpcGrakn.PutRule) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.PutRule.getDefaultInstance();
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutRule putRule = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.PutRuleOrBuilder getPutRuleOrBuilder() {
if (requestCase_ == 14) {
return (ai.grakn.rpc.generated.GrpcGrakn.PutRule) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.PutRule.getDefaultInstance();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (requestCase_ == 1) {
output.writeMessage(1, (ai.grakn.rpc.generated.GrpcGrakn.Open) request_);
}
if (requestCase_ == 2) {
output.writeMessage(2, (ai.grakn.rpc.generated.GrpcGrakn.Commit) request_);
}
if (requestCase_ == 3) {
output.writeMessage(3, (ai.grakn.rpc.generated.GrpcGrakn.ExecQuery) request_);
}
if (requestCase_ == 4) {
output.writeMessage(4, (ai.grakn.rpc.generated.GrpcIterator.Next) request_);
}
if (requestCase_ == 5) {
output.writeMessage(5, (ai.grakn.rpc.generated.GrpcIterator.Stop) request_);
}
if (requestCase_ == 6) {
output.writeMessage(6, (ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod) request_);
}
if (requestCase_ == 7) {
output.writeMessage(7, (ai.grakn.rpc.generated.GrpcConcept.ConceptId) request_);
}
if (requestCase_ == 8) {
output.writeMessage(8, (ai.grakn.rpc.generated.GrpcConcept.Label) request_);
}
if (requestCase_ == 9) {
output.writeMessage(9, (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) request_);
}
if (requestCase_ == 10) {
output.writeMessage(10, (ai.grakn.rpc.generated.GrpcConcept.Label) request_);
}
if (requestCase_ == 11) {
output.writeMessage(11, (ai.grakn.rpc.generated.GrpcConcept.Label) request_);
}
if (requestCase_ == 12) {
output.writeMessage(12, (ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType) request_);
}
if (requestCase_ == 13) {
output.writeMessage(13, (ai.grakn.rpc.generated.GrpcConcept.Label) request_);
}
if (requestCase_ == 14) {
output.writeMessage(14, (ai.grakn.rpc.generated.GrpcGrakn.PutRule) request_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (requestCase_ == 1) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, (ai.grakn.rpc.generated.GrpcGrakn.Open) request_);
}
if (requestCase_ == 2) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(2, (ai.grakn.rpc.generated.GrpcGrakn.Commit) request_);
}
if (requestCase_ == 3) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(3, (ai.grakn.rpc.generated.GrpcGrakn.ExecQuery) request_);
}
if (requestCase_ == 4) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(4, (ai.grakn.rpc.generated.GrpcIterator.Next) request_);
}
if (requestCase_ == 5) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(5, (ai.grakn.rpc.generated.GrpcIterator.Stop) request_);
}
if (requestCase_ == 6) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(6, (ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod) request_);
}
if (requestCase_ == 7) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(7, (ai.grakn.rpc.generated.GrpcConcept.ConceptId) request_);
}
if (requestCase_ == 8) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(8, (ai.grakn.rpc.generated.GrpcConcept.Label) request_);
}
if (requestCase_ == 9) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(9, (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) request_);
}
if (requestCase_ == 10) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(10, (ai.grakn.rpc.generated.GrpcConcept.Label) request_);
}
if (requestCase_ == 11) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(11, (ai.grakn.rpc.generated.GrpcConcept.Label) request_);
}
if (requestCase_ == 12) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(12, (ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType) request_);
}
if (requestCase_ == 13) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(13, (ai.grakn.rpc.generated.GrpcConcept.Label) request_);
}
if (requestCase_ == 14) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(14, (ai.grakn.rpc.generated.GrpcGrakn.PutRule) request_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.TxRequest)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.TxRequest other = (ai.grakn.rpc.generated.GrpcGrakn.TxRequest) obj;
boolean result = true;
result = result && getRequestCase().equals(
other.getRequestCase());
if (!result) return false;
switch (requestCase_) {
case 1:
result = result && getOpen()
.equals(other.getOpen());
break;
case 2:
result = result && getCommit()
.equals(other.getCommit());
break;
case 3:
result = result && getExecQuery()
.equals(other.getExecQuery());
break;
case 4:
result = result && getNext()
.equals(other.getNext());
break;
case 5:
result = result && getStop()
.equals(other.getStop());
break;
case 6:
result = result && getRunConceptMethod()
.equals(other.getRunConceptMethod());
break;
case 7:
result = result && getGetConcept()
.equals(other.getGetConcept());
break;
case 8:
result = result && getGetSchemaConcept()
.equals(other.getGetSchemaConcept());
break;
case 9:
result = result && getGetAttributesByValue()
.equals(other.getGetAttributesByValue());
break;
case 10:
result = result && getPutEntityType()
.equals(other.getPutEntityType());
break;
case 11:
result = result && getPutRelationshipType()
.equals(other.getPutRelationshipType());
break;
case 12:
result = result && getPutAttributeType()
.equals(other.getPutAttributeType());
break;
case 13:
result = result && getPutRole()
.equals(other.getPutRole());
break;
case 14:
result = result && getPutRule()
.equals(other.getPutRule());
break;
case 0:
default:
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
switch (requestCase_) {
case 1:
hash = (37 * hash) + OPEN_FIELD_NUMBER;
hash = (53 * hash) + getOpen().hashCode();
break;
case 2:
hash = (37 * hash) + COMMIT_FIELD_NUMBER;
hash = (53 * hash) + getCommit().hashCode();
break;
case 3:
hash = (37 * hash) + EXECQUERY_FIELD_NUMBER;
hash = (53 * hash) + getExecQuery().hashCode();
break;
case 4:
hash = (37 * hash) + NEXT_FIELD_NUMBER;
hash = (53 * hash) + getNext().hashCode();
break;
case 5:
hash = (37 * hash) + STOP_FIELD_NUMBER;
hash = (53 * hash) + getStop().hashCode();
break;
case 6:
hash = (37 * hash) + RUNCONCEPTMETHOD_FIELD_NUMBER;
hash = (53 * hash) + getRunConceptMethod().hashCode();
break;
case 7:
hash = (37 * hash) + GETCONCEPT_FIELD_NUMBER;
hash = (53 * hash) + getGetConcept().hashCode();
break;
case 8:
hash = (37 * hash) + GETSCHEMACONCEPT_FIELD_NUMBER;
hash = (53 * hash) + getGetSchemaConcept().hashCode();
break;
case 9:
hash = (37 * hash) + GETATTRIBUTESBYVALUE_FIELD_NUMBER;
hash = (53 * hash) + getGetAttributesByValue().hashCode();
break;
case 10:
hash = (37 * hash) + PUTENTITYTYPE_FIELD_NUMBER;
hash = (53 * hash) + getPutEntityType().hashCode();
break;
case 11:
hash = (37 * hash) + PUTRELATIONSHIPTYPE_FIELD_NUMBER;
hash = (53 * hash) + getPutRelationshipType().hashCode();
break;
case 12:
hash = (37 * hash) + PUTATTRIBUTETYPE_FIELD_NUMBER;
hash = (53 * hash) + getPutAttributeType().hashCode();
break;
case 13:
hash = (37 * hash) + PUTROLE_FIELD_NUMBER;
hash = (53 * hash) + getPutRole().hashCode();
break;
case 14:
hash = (37 * hash) + PUTRULE_FIELD_NUMBER;
hash = (53 * hash) + getPutRule().hashCode();
break;
case 0:
default:
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxRequest parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxRequest parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxRequest parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxRequest parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxRequest parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxRequest parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxRequest parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxRequest parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxRequest parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxRequest parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.TxRequest prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.TxRequest}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.TxRequest)
ai.grakn.rpc.generated.GrpcGrakn.TxRequestOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_TxRequest_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_TxRequest_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.TxRequest.class, ai.grakn.rpc.generated.GrpcGrakn.TxRequest.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.TxRequest.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
requestCase_ = 0;
request_ = null;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_TxRequest_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.TxRequest getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.TxRequest.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.TxRequest build() {
ai.grakn.rpc.generated.GrpcGrakn.TxRequest result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.TxRequest buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.TxRequest result = new ai.grakn.rpc.generated.GrpcGrakn.TxRequest(this);
if (requestCase_ == 1) {
if (openBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = openBuilder_.build();
}
}
if (requestCase_ == 2) {
if (commitBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = commitBuilder_.build();
}
}
if (requestCase_ == 3) {
if (execQueryBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = execQueryBuilder_.build();
}
}
if (requestCase_ == 4) {
if (nextBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = nextBuilder_.build();
}
}
if (requestCase_ == 5) {
if (stopBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = stopBuilder_.build();
}
}
if (requestCase_ == 6) {
if (runConceptMethodBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = runConceptMethodBuilder_.build();
}
}
if (requestCase_ == 7) {
if (getConceptBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = getConceptBuilder_.build();
}
}
if (requestCase_ == 8) {
if (getSchemaConceptBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = getSchemaConceptBuilder_.build();
}
}
if (requestCase_ == 9) {
if (getAttributesByValueBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = getAttributesByValueBuilder_.build();
}
}
if (requestCase_ == 10) {
if (putEntityTypeBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = putEntityTypeBuilder_.build();
}
}
if (requestCase_ == 11) {
if (putRelationshipTypeBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = putRelationshipTypeBuilder_.build();
}
}
if (requestCase_ == 12) {
if (putAttributeTypeBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = putAttributeTypeBuilder_.build();
}
}
if (requestCase_ == 13) {
if (putRoleBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = putRoleBuilder_.build();
}
}
if (requestCase_ == 14) {
if (putRuleBuilder_ == null) {
result.request_ = request_;
} else {
result.request_ = putRuleBuilder_.build();
}
}
result.requestCase_ = requestCase_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.TxRequest) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.TxRequest)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.TxRequest other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.TxRequest.getDefaultInstance()) return this;
switch (other.getRequestCase()) {
case OPEN: {
mergeOpen(other.getOpen());
break;
}
case COMMIT: {
mergeCommit(other.getCommit());
break;
}
case EXECQUERY: {
mergeExecQuery(other.getExecQuery());
break;
}
case NEXT: {
mergeNext(other.getNext());
break;
}
case STOP: {
mergeStop(other.getStop());
break;
}
case RUNCONCEPTMETHOD: {
mergeRunConceptMethod(other.getRunConceptMethod());
break;
}
case GETCONCEPT: {
mergeGetConcept(other.getGetConcept());
break;
}
case GETSCHEMACONCEPT: {
mergeGetSchemaConcept(other.getGetSchemaConcept());
break;
}
case GETATTRIBUTESBYVALUE: {
mergeGetAttributesByValue(other.getGetAttributesByValue());
break;
}
case PUTENTITYTYPE: {
mergePutEntityType(other.getPutEntityType());
break;
}
case PUTRELATIONSHIPTYPE: {
mergePutRelationshipType(other.getPutRelationshipType());
break;
}
case PUTATTRIBUTETYPE: {
mergePutAttributeType(other.getPutAttributeType());
break;
}
case PUTROLE: {
mergePutRole(other.getPutRole());
break;
}
case PUTRULE: {
mergePutRule(other.getPutRule());
break;
}
case REQUEST_NOT_SET: {
break;
}
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.TxRequest parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.TxRequest) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int requestCase_ = 0;
private java.lang.Object request_;
public RequestCase
getRequestCase() {
return RequestCase.forNumber(
requestCase_);
}
public Builder clearRequest() {
requestCase_ = 0;
request_ = null;
onChanged();
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Open, ai.grakn.rpc.generated.GrpcGrakn.Open.Builder, ai.grakn.rpc.generated.GrpcGrakn.OpenOrBuilder> openBuilder_;
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Open getOpen() {
if (openBuilder_ == null) {
if (requestCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcGrakn.Open) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Open.getDefaultInstance();
} else {
if (requestCase_ == 1) {
return openBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcGrakn.Open.getDefaultInstance();
}
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public Builder setOpen(ai.grakn.rpc.generated.GrpcGrakn.Open value) {
if (openBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
openBuilder_.setMessage(value);
}
requestCase_ = 1;
return this;
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public Builder setOpen(
ai.grakn.rpc.generated.GrpcGrakn.Open.Builder builderForValue) {
if (openBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
openBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 1;
return this;
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public Builder mergeOpen(ai.grakn.rpc.generated.GrpcGrakn.Open value) {
if (openBuilder_ == null) {
if (requestCase_ == 1 &&
request_ != ai.grakn.rpc.generated.GrpcGrakn.Open.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcGrakn.Open.newBuilder((ai.grakn.rpc.generated.GrpcGrakn.Open) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 1) {
openBuilder_.mergeFrom(value);
}
openBuilder_.setMessage(value);
}
requestCase_ = 1;
return this;
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public Builder clearOpen() {
if (openBuilder_ == null) {
if (requestCase_ == 1) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 1) {
requestCase_ = 0;
request_ = null;
}
openBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Open.Builder getOpenBuilder() {
return getOpenFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.OpenOrBuilder getOpenOrBuilder() {
if ((requestCase_ == 1) && (openBuilder_ != null)) {
return openBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcGrakn.Open) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Open.getDefaultInstance();
}
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Open, ai.grakn.rpc.generated.GrpcGrakn.Open.Builder, ai.grakn.rpc.generated.GrpcGrakn.OpenOrBuilder>
getOpenFieldBuilder() {
if (openBuilder_ == null) {
if (!(requestCase_ == 1)) {
request_ = ai.grakn.rpc.generated.GrpcGrakn.Open.getDefaultInstance();
}
openBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Open, ai.grakn.rpc.generated.GrpcGrakn.Open.Builder, ai.grakn.rpc.generated.GrpcGrakn.OpenOrBuilder>(
(ai.grakn.rpc.generated.GrpcGrakn.Open) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 1;
onChanged();;
return openBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Commit, ai.grakn.rpc.generated.GrpcGrakn.Commit.Builder, ai.grakn.rpc.generated.GrpcGrakn.CommitOrBuilder> commitBuilder_;
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Commit commit = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Commit getCommit() {
if (commitBuilder_ == null) {
if (requestCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcGrakn.Commit) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Commit.getDefaultInstance();
} else {
if (requestCase_ == 2) {
return commitBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcGrakn.Commit.getDefaultInstance();
}
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Commit commit = 2;</code>
*/
public Builder setCommit(ai.grakn.rpc.generated.GrpcGrakn.Commit value) {
if (commitBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
commitBuilder_.setMessage(value);
}
requestCase_ = 2;
return this;
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Commit commit = 2;</code>
*/
public Builder setCommit(
ai.grakn.rpc.generated.GrpcGrakn.Commit.Builder builderForValue) {
if (commitBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
commitBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 2;
return this;
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Commit commit = 2;</code>
*/
public Builder mergeCommit(ai.grakn.rpc.generated.GrpcGrakn.Commit value) {
if (commitBuilder_ == null) {
if (requestCase_ == 2 &&
request_ != ai.grakn.rpc.generated.GrpcGrakn.Commit.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcGrakn.Commit.newBuilder((ai.grakn.rpc.generated.GrpcGrakn.Commit) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 2) {
commitBuilder_.mergeFrom(value);
}
commitBuilder_.setMessage(value);
}
requestCase_ = 2;
return this;
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Commit commit = 2;</code>
*/
public Builder clearCommit() {
if (commitBuilder_ == null) {
if (requestCase_ == 2) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 2) {
requestCase_ = 0;
request_ = null;
}
commitBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Commit commit = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Commit.Builder getCommitBuilder() {
return getCommitFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Commit commit = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.CommitOrBuilder getCommitOrBuilder() {
if ((requestCase_ == 2) && (commitBuilder_ != null)) {
return commitBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcGrakn.Commit) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Commit.getDefaultInstance();
}
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Commit commit = 2;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Commit, ai.grakn.rpc.generated.GrpcGrakn.Commit.Builder, ai.grakn.rpc.generated.GrpcGrakn.CommitOrBuilder>
getCommitFieldBuilder() {
if (commitBuilder_ == null) {
if (!(requestCase_ == 2)) {
request_ = ai.grakn.rpc.generated.GrpcGrakn.Commit.getDefaultInstance();
}
commitBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Commit, ai.grakn.rpc.generated.GrpcGrakn.Commit.Builder, ai.grakn.rpc.generated.GrpcGrakn.CommitOrBuilder>(
(ai.grakn.rpc.generated.GrpcGrakn.Commit) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 2;
onChanged();;
return commitBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.ExecQuery, ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.Builder, ai.grakn.rpc.generated.GrpcGrakn.ExecQueryOrBuilder> execQueryBuilder_;
/**
* <pre>
* returns QueryResult, Done, or IteratorId of QueryResult
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ExecQuery execQuery = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.ExecQuery getExecQuery() {
if (execQueryBuilder_ == null) {
if (requestCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcGrakn.ExecQuery) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.getDefaultInstance();
} else {
if (requestCase_ == 3) {
return execQueryBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.getDefaultInstance();
}
}
/**
* <pre>
* returns QueryResult, Done, or IteratorId of QueryResult
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ExecQuery execQuery = 3;</code>
*/
public Builder setExecQuery(ai.grakn.rpc.generated.GrpcGrakn.ExecQuery value) {
if (execQueryBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
execQueryBuilder_.setMessage(value);
}
requestCase_ = 3;
return this;
}
/**
* <pre>
* returns QueryResult, Done, or IteratorId of QueryResult
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ExecQuery execQuery = 3;</code>
*/
public Builder setExecQuery(
ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.Builder builderForValue) {
if (execQueryBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
execQueryBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 3;
return this;
}
/**
* <pre>
* returns QueryResult, Done, or IteratorId of QueryResult
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ExecQuery execQuery = 3;</code>
*/
public Builder mergeExecQuery(ai.grakn.rpc.generated.GrpcGrakn.ExecQuery value) {
if (execQueryBuilder_ == null) {
if (requestCase_ == 3 &&
request_ != ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.newBuilder((ai.grakn.rpc.generated.GrpcGrakn.ExecQuery) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 3) {
execQueryBuilder_.mergeFrom(value);
}
execQueryBuilder_.setMessage(value);
}
requestCase_ = 3;
return this;
}
/**
* <pre>
* returns QueryResult, Done, or IteratorId of QueryResult
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ExecQuery execQuery = 3;</code>
*/
public Builder clearExecQuery() {
if (execQueryBuilder_ == null) {
if (requestCase_ == 3) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 3) {
requestCase_ = 0;
request_ = null;
}
execQueryBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns QueryResult, Done, or IteratorId of QueryResult
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ExecQuery execQuery = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.Builder getExecQueryBuilder() {
return getExecQueryFieldBuilder().getBuilder();
}
/**
* <pre>
* returns QueryResult, Done, or IteratorId of QueryResult
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ExecQuery execQuery = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.ExecQueryOrBuilder getExecQueryOrBuilder() {
if ((requestCase_ == 3) && (execQueryBuilder_ != null)) {
return execQueryBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcGrakn.ExecQuery) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.getDefaultInstance();
}
}
/**
* <pre>
* returns QueryResult, Done, or IteratorId of QueryResult
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ExecQuery execQuery = 3;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.ExecQuery, ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.Builder, ai.grakn.rpc.generated.GrpcGrakn.ExecQueryOrBuilder>
getExecQueryFieldBuilder() {
if (execQueryBuilder_ == null) {
if (!(requestCase_ == 3)) {
request_ = ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.getDefaultInstance();
}
execQueryBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.ExecQuery, ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.Builder, ai.grakn.rpc.generated.GrpcGrakn.ExecQueryOrBuilder>(
(ai.grakn.rpc.generated.GrpcGrakn.ExecQuery) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 3;
onChanged();;
return execQueryBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.Next, ai.grakn.rpc.generated.GrpcIterator.Next.Builder, ai.grakn.rpc.generated.GrpcIterator.NextOrBuilder> nextBuilder_;
/**
* <pre>
* returns QueryResult or Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Next next = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.Next getNext() {
if (nextBuilder_ == null) {
if (requestCase_ == 4) {
return (ai.grakn.rpc.generated.GrpcIterator.Next) request_;
}
return ai.grakn.rpc.generated.GrpcIterator.Next.getDefaultInstance();
} else {
if (requestCase_ == 4) {
return nextBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcIterator.Next.getDefaultInstance();
}
}
/**
* <pre>
* returns QueryResult or Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Next next = 4;</code>
*/
public Builder setNext(ai.grakn.rpc.generated.GrpcIterator.Next value) {
if (nextBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
nextBuilder_.setMessage(value);
}
requestCase_ = 4;
return this;
}
/**
* <pre>
* returns QueryResult or Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Next next = 4;</code>
*/
public Builder setNext(
ai.grakn.rpc.generated.GrpcIterator.Next.Builder builderForValue) {
if (nextBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
nextBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 4;
return this;
}
/**
* <pre>
* returns QueryResult or Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Next next = 4;</code>
*/
public Builder mergeNext(ai.grakn.rpc.generated.GrpcIterator.Next value) {
if (nextBuilder_ == null) {
if (requestCase_ == 4 &&
request_ != ai.grakn.rpc.generated.GrpcIterator.Next.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcIterator.Next.newBuilder((ai.grakn.rpc.generated.GrpcIterator.Next) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 4) {
nextBuilder_.mergeFrom(value);
}
nextBuilder_.setMessage(value);
}
requestCase_ = 4;
return this;
}
/**
* <pre>
* returns QueryResult or Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Next next = 4;</code>
*/
public Builder clearNext() {
if (nextBuilder_ == null) {
if (requestCase_ == 4) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 4) {
requestCase_ = 0;
request_ = null;
}
nextBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns QueryResult or Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Next next = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.Next.Builder getNextBuilder() {
return getNextFieldBuilder().getBuilder();
}
/**
* <pre>
* returns QueryResult or Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Next next = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.NextOrBuilder getNextOrBuilder() {
if ((requestCase_ == 4) && (nextBuilder_ != null)) {
return nextBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 4) {
return (ai.grakn.rpc.generated.GrpcIterator.Next) request_;
}
return ai.grakn.rpc.generated.GrpcIterator.Next.getDefaultInstance();
}
}
/**
* <pre>
* returns QueryResult or Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Next next = 4;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.Next, ai.grakn.rpc.generated.GrpcIterator.Next.Builder, ai.grakn.rpc.generated.GrpcIterator.NextOrBuilder>
getNextFieldBuilder() {
if (nextBuilder_ == null) {
if (!(requestCase_ == 4)) {
request_ = ai.grakn.rpc.generated.GrpcIterator.Next.getDefaultInstance();
}
nextBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.Next, ai.grakn.rpc.generated.GrpcIterator.Next.Builder, ai.grakn.rpc.generated.GrpcIterator.NextOrBuilder>(
(ai.grakn.rpc.generated.GrpcIterator.Next) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 4;
onChanged();;
return nextBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.Stop, ai.grakn.rpc.generated.GrpcIterator.Stop.Builder, ai.grakn.rpc.generated.GrpcIterator.StopOrBuilder> stopBuilder_;
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Stop stop = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.Stop getStop() {
if (stopBuilder_ == null) {
if (requestCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcIterator.Stop) request_;
}
return ai.grakn.rpc.generated.GrpcIterator.Stop.getDefaultInstance();
} else {
if (requestCase_ == 5) {
return stopBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcIterator.Stop.getDefaultInstance();
}
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Stop stop = 5;</code>
*/
public Builder setStop(ai.grakn.rpc.generated.GrpcIterator.Stop value) {
if (stopBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
stopBuilder_.setMessage(value);
}
requestCase_ = 5;
return this;
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Stop stop = 5;</code>
*/
public Builder setStop(
ai.grakn.rpc.generated.GrpcIterator.Stop.Builder builderForValue) {
if (stopBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
stopBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 5;
return this;
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Stop stop = 5;</code>
*/
public Builder mergeStop(ai.grakn.rpc.generated.GrpcIterator.Stop value) {
if (stopBuilder_ == null) {
if (requestCase_ == 5 &&
request_ != ai.grakn.rpc.generated.GrpcIterator.Stop.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcIterator.Stop.newBuilder((ai.grakn.rpc.generated.GrpcIterator.Stop) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 5) {
stopBuilder_.mergeFrom(value);
}
stopBuilder_.setMessage(value);
}
requestCase_ = 5;
return this;
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Stop stop = 5;</code>
*/
public Builder clearStop() {
if (stopBuilder_ == null) {
if (requestCase_ == 5) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 5) {
requestCase_ = 0;
request_ = null;
}
stopBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Stop stop = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.Stop.Builder getStopBuilder() {
return getStopFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Stop stop = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.StopOrBuilder getStopOrBuilder() {
if ((requestCase_ == 5) && (stopBuilder_ != null)) {
return stopBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcIterator.Stop) request_;
}
return ai.grakn.rpc.generated.GrpcIterator.Stop.getDefaultInstance();
}
}
/**
* <pre>
* returns Done
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Stop stop = 5;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.Stop, ai.grakn.rpc.generated.GrpcIterator.Stop.Builder, ai.grakn.rpc.generated.GrpcIterator.StopOrBuilder>
getStopFieldBuilder() {
if (stopBuilder_ == null) {
if (!(requestCase_ == 5)) {
request_ = ai.grakn.rpc.generated.GrpcIterator.Stop.getDefaultInstance();
}
stopBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.Stop, ai.grakn.rpc.generated.GrpcIterator.Stop.Builder, ai.grakn.rpc.generated.GrpcIterator.StopOrBuilder>(
(ai.grakn.rpc.generated.GrpcIterator.Stop) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 5;
onChanged();;
return stopBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod, ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.Builder, ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethodOrBuilder> runConceptMethodBuilder_;
/**
* <pre>
* returns ConceptResponse
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RunConceptMethod runConceptMethod = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod getRunConceptMethod() {
if (runConceptMethodBuilder_ == null) {
if (requestCase_ == 6) {
return (ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.getDefaultInstance();
} else {
if (requestCase_ == 6) {
return runConceptMethodBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.getDefaultInstance();
}
}
/**
* <pre>
* returns ConceptResponse
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RunConceptMethod runConceptMethod = 6;</code>
*/
public Builder setRunConceptMethod(ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod value) {
if (runConceptMethodBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
runConceptMethodBuilder_.setMessage(value);
}
requestCase_ = 6;
return this;
}
/**
* <pre>
* returns ConceptResponse
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RunConceptMethod runConceptMethod = 6;</code>
*/
public Builder setRunConceptMethod(
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.Builder builderForValue) {
if (runConceptMethodBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
runConceptMethodBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 6;
return this;
}
/**
* <pre>
* returns ConceptResponse
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RunConceptMethod runConceptMethod = 6;</code>
*/
public Builder mergeRunConceptMethod(ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod value) {
if (runConceptMethodBuilder_ == null) {
if (requestCase_ == 6 &&
request_ != ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.newBuilder((ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 6) {
runConceptMethodBuilder_.mergeFrom(value);
}
runConceptMethodBuilder_.setMessage(value);
}
requestCase_ = 6;
return this;
}
/**
* <pre>
* returns ConceptResponse
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RunConceptMethod runConceptMethod = 6;</code>
*/
public Builder clearRunConceptMethod() {
if (runConceptMethodBuilder_ == null) {
if (requestCase_ == 6) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 6) {
requestCase_ = 0;
request_ = null;
}
runConceptMethodBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns ConceptResponse
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RunConceptMethod runConceptMethod = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.Builder getRunConceptMethodBuilder() {
return getRunConceptMethodFieldBuilder().getBuilder();
}
/**
* <pre>
* returns ConceptResponse
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RunConceptMethod runConceptMethod = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethodOrBuilder getRunConceptMethodOrBuilder() {
if ((requestCase_ == 6) && (runConceptMethodBuilder_ != null)) {
return runConceptMethodBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 6) {
return (ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.getDefaultInstance();
}
}
/**
* <pre>
* returns ConceptResponse
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.RunConceptMethod runConceptMethod = 6;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod, ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.Builder, ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethodOrBuilder>
getRunConceptMethodFieldBuilder() {
if (runConceptMethodBuilder_ == null) {
if (!(requestCase_ == 6)) {
request_ = ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.getDefaultInstance();
}
runConceptMethodBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod, ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.Builder, ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethodOrBuilder>(
(ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 6;
onChanged();;
return runConceptMethodBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptId, ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder> getConceptBuilder_;
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ConceptId getConcept = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptId getGetConcept() {
if (getConceptBuilder_ == null) {
if (requestCase_ == 7) {
return (ai.grakn.rpc.generated.GrpcConcept.ConceptId) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance();
} else {
if (requestCase_ == 7) {
return getConceptBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ConceptId getConcept = 7;</code>
*/
public Builder setGetConcept(ai.grakn.rpc.generated.GrpcConcept.ConceptId value) {
if (getConceptBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
getConceptBuilder_.setMessage(value);
}
requestCase_ = 7;
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ConceptId getConcept = 7;</code>
*/
public Builder setGetConcept(
ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder builderForValue) {
if (getConceptBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
getConceptBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 7;
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ConceptId getConcept = 7;</code>
*/
public Builder mergeGetConcept(ai.grakn.rpc.generated.GrpcConcept.ConceptId value) {
if (getConceptBuilder_ == null) {
if (requestCase_ == 7 &&
request_ != ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcConcept.ConceptId.newBuilder((ai.grakn.rpc.generated.GrpcConcept.ConceptId) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 7) {
getConceptBuilder_.mergeFrom(value);
}
getConceptBuilder_.setMessage(value);
}
requestCase_ = 7;
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ConceptId getConcept = 7;</code>
*/
public Builder clearGetConcept() {
if (getConceptBuilder_ == null) {
if (requestCase_ == 7) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 7) {
requestCase_ = 0;
request_ = null;
}
getConceptBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ConceptId getConcept = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder getGetConceptBuilder() {
return getGetConceptFieldBuilder().getBuilder();
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ConceptId getConcept = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder getGetConceptOrBuilder() {
if ((requestCase_ == 7) && (getConceptBuilder_ != null)) {
return getConceptBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 7) {
return (ai.grakn.rpc.generated.GrpcConcept.ConceptId) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.ConceptId getConcept = 7;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptId, ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder>
getGetConceptFieldBuilder() {
if (getConceptBuilder_ == null) {
if (!(requestCase_ == 7)) {
request_ = ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance();
}
getConceptBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptId, ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.ConceptId) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 7;
onChanged();;
return getConceptBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder> getSchemaConceptBuilder_;
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label getSchemaConcept = 8;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getGetSchemaConcept() {
if (getSchemaConceptBuilder_ == null) {
if (requestCase_ == 8) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
} else {
if (requestCase_ == 8) {
return getSchemaConceptBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label getSchemaConcept = 8;</code>
*/
public Builder setGetSchemaConcept(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (getSchemaConceptBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
getSchemaConceptBuilder_.setMessage(value);
}
requestCase_ = 8;
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label getSchemaConcept = 8;</code>
*/
public Builder setGetSchemaConcept(
ai.grakn.rpc.generated.GrpcConcept.Label.Builder builderForValue) {
if (getSchemaConceptBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
getSchemaConceptBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 8;
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label getSchemaConcept = 8;</code>
*/
public Builder mergeGetSchemaConcept(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (getSchemaConceptBuilder_ == null) {
if (requestCase_ == 8 &&
request_ != ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcConcept.Label.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Label) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 8) {
getSchemaConceptBuilder_.mergeFrom(value);
}
getSchemaConceptBuilder_.setMessage(value);
}
requestCase_ = 8;
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label getSchemaConcept = 8;</code>
*/
public Builder clearGetSchemaConcept() {
if (getSchemaConceptBuilder_ == null) {
if (requestCase_ == 8) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 8) {
requestCase_ = 0;
request_ = null;
}
getSchemaConceptBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label getSchemaConcept = 8;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label.Builder getGetSchemaConceptBuilder() {
return getGetSchemaConceptFieldBuilder().getBuilder();
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label getSchemaConcept = 8;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getGetSchemaConceptOrBuilder() {
if ((requestCase_ == 8) && (getSchemaConceptBuilder_ != null)) {
return getSchemaConceptBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 8) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
}
/**
* <pre>
* returns OptionalConcept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label getSchemaConcept = 8;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>
getGetSchemaConceptFieldBuilder() {
if (getSchemaConceptBuilder_ == null) {
if (!(requestCase_ == 8)) {
request_ = ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
getSchemaConceptBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Label) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 8;
onChanged();;
return getSchemaConceptBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.AttributeValue, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder, ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder> getAttributesByValueBuilder_;
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttributesByValue = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue getGetAttributesByValue() {
if (getAttributesByValueBuilder_ == null) {
if (requestCase_ == 9) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
} else {
if (requestCase_ == 9) {
return getAttributesByValueBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttributesByValue = 9;</code>
*/
public Builder setGetAttributesByValue(ai.grakn.rpc.generated.GrpcConcept.AttributeValue value) {
if (getAttributesByValueBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
getAttributesByValueBuilder_.setMessage(value);
}
requestCase_ = 9;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttributesByValue = 9;</code>
*/
public Builder setGetAttributesByValue(
ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder builderForValue) {
if (getAttributesByValueBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
getAttributesByValueBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 9;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttributesByValue = 9;</code>
*/
public Builder mergeGetAttributesByValue(ai.grakn.rpc.generated.GrpcConcept.AttributeValue value) {
if (getAttributesByValueBuilder_ == null) {
if (requestCase_ == 9 &&
request_ != ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcConcept.AttributeValue.newBuilder((ai.grakn.rpc.generated.GrpcConcept.AttributeValue) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 9) {
getAttributesByValueBuilder_.mergeFrom(value);
}
getAttributesByValueBuilder_.setMessage(value);
}
requestCase_ = 9;
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttributesByValue = 9;</code>
*/
public Builder clearGetAttributesByValue() {
if (getAttributesByValueBuilder_ == null) {
if (requestCase_ == 9) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 9) {
requestCase_ = 0;
request_ = null;
}
getAttributesByValueBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttributesByValue = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder getGetAttributesByValueBuilder() {
return getGetAttributesByValueFieldBuilder().getBuilder();
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttributesByValue = 9;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder getGetAttributesByValueOrBuilder() {
if ((requestCase_ == 9) && (getAttributesByValueBuilder_ != null)) {
return getAttributesByValueBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 9) {
return (ai.grakn.rpc.generated.GrpcConcept.AttributeValue) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
}
/**
* <pre>
* returns IteratorId of Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.AttributeValue getAttributesByValue = 9;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.AttributeValue, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder, ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder>
getGetAttributesByValueFieldBuilder() {
if (getAttributesByValueBuilder_ == null) {
if (!(requestCase_ == 9)) {
request_ = ai.grakn.rpc.generated.GrpcConcept.AttributeValue.getDefaultInstance();
}
getAttributesByValueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.AttributeValue, ai.grakn.rpc.generated.GrpcConcept.AttributeValue.Builder, ai.grakn.rpc.generated.GrpcConcept.AttributeValueOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.AttributeValue) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 9;
onChanged();;
return getAttributesByValueBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder> putEntityTypeBuilder_;
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putEntityType = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getPutEntityType() {
if (putEntityTypeBuilder_ == null) {
if (requestCase_ == 10) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
} else {
if (requestCase_ == 10) {
return putEntityTypeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putEntityType = 10;</code>
*/
public Builder setPutEntityType(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (putEntityTypeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
putEntityTypeBuilder_.setMessage(value);
}
requestCase_ = 10;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putEntityType = 10;</code>
*/
public Builder setPutEntityType(
ai.grakn.rpc.generated.GrpcConcept.Label.Builder builderForValue) {
if (putEntityTypeBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
putEntityTypeBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 10;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putEntityType = 10;</code>
*/
public Builder mergePutEntityType(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (putEntityTypeBuilder_ == null) {
if (requestCase_ == 10 &&
request_ != ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcConcept.Label.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Label) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 10) {
putEntityTypeBuilder_.mergeFrom(value);
}
putEntityTypeBuilder_.setMessage(value);
}
requestCase_ = 10;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putEntityType = 10;</code>
*/
public Builder clearPutEntityType() {
if (putEntityTypeBuilder_ == null) {
if (requestCase_ == 10) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 10) {
requestCase_ = 0;
request_ = null;
}
putEntityTypeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putEntityType = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label.Builder getPutEntityTypeBuilder() {
return getPutEntityTypeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putEntityType = 10;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getPutEntityTypeOrBuilder() {
if ((requestCase_ == 10) && (putEntityTypeBuilder_ != null)) {
return putEntityTypeBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 10) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putEntityType = 10;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>
getPutEntityTypeFieldBuilder() {
if (putEntityTypeBuilder_ == null) {
if (!(requestCase_ == 10)) {
request_ = ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
putEntityTypeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Label) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 10;
onChanged();;
return putEntityTypeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder> putRelationshipTypeBuilder_;
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRelationshipType = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getPutRelationshipType() {
if (putRelationshipTypeBuilder_ == null) {
if (requestCase_ == 11) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
} else {
if (requestCase_ == 11) {
return putRelationshipTypeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRelationshipType = 11;</code>
*/
public Builder setPutRelationshipType(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (putRelationshipTypeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
putRelationshipTypeBuilder_.setMessage(value);
}
requestCase_ = 11;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRelationshipType = 11;</code>
*/
public Builder setPutRelationshipType(
ai.grakn.rpc.generated.GrpcConcept.Label.Builder builderForValue) {
if (putRelationshipTypeBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
putRelationshipTypeBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 11;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRelationshipType = 11;</code>
*/
public Builder mergePutRelationshipType(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (putRelationshipTypeBuilder_ == null) {
if (requestCase_ == 11 &&
request_ != ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcConcept.Label.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Label) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 11) {
putRelationshipTypeBuilder_.mergeFrom(value);
}
putRelationshipTypeBuilder_.setMessage(value);
}
requestCase_ = 11;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRelationshipType = 11;</code>
*/
public Builder clearPutRelationshipType() {
if (putRelationshipTypeBuilder_ == null) {
if (requestCase_ == 11) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 11) {
requestCase_ = 0;
request_ = null;
}
putRelationshipTypeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRelationshipType = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label.Builder getPutRelationshipTypeBuilder() {
return getPutRelationshipTypeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRelationshipType = 11;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getPutRelationshipTypeOrBuilder() {
if ((requestCase_ == 11) && (putRelationshipTypeBuilder_ != null)) {
return putRelationshipTypeBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 11) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRelationshipType = 11;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>
getPutRelationshipTypeFieldBuilder() {
if (putRelationshipTypeBuilder_ == null) {
if (!(requestCase_ == 11)) {
request_ = ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
putRelationshipTypeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Label) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 11;
onChanged();;
return putRelationshipTypeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType, ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.Builder, ai.grakn.rpc.generated.GrpcGrakn.PutAttributeTypeOrBuilder> putAttributeTypeBuilder_;
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutAttributeType putAttributeType = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType getPutAttributeType() {
if (putAttributeTypeBuilder_ == null) {
if (requestCase_ == 12) {
return (ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.getDefaultInstance();
} else {
if (requestCase_ == 12) {
return putAttributeTypeBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.getDefaultInstance();
}
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutAttributeType putAttributeType = 12;</code>
*/
public Builder setPutAttributeType(ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType value) {
if (putAttributeTypeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
putAttributeTypeBuilder_.setMessage(value);
}
requestCase_ = 12;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutAttributeType putAttributeType = 12;</code>
*/
public Builder setPutAttributeType(
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.Builder builderForValue) {
if (putAttributeTypeBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
putAttributeTypeBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 12;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutAttributeType putAttributeType = 12;</code>
*/
public Builder mergePutAttributeType(ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType value) {
if (putAttributeTypeBuilder_ == null) {
if (requestCase_ == 12 &&
request_ != ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.newBuilder((ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 12) {
putAttributeTypeBuilder_.mergeFrom(value);
}
putAttributeTypeBuilder_.setMessage(value);
}
requestCase_ = 12;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutAttributeType putAttributeType = 12;</code>
*/
public Builder clearPutAttributeType() {
if (putAttributeTypeBuilder_ == null) {
if (requestCase_ == 12) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 12) {
requestCase_ = 0;
request_ = null;
}
putAttributeTypeBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutAttributeType putAttributeType = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.Builder getPutAttributeTypeBuilder() {
return getPutAttributeTypeFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutAttributeType putAttributeType = 12;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.PutAttributeTypeOrBuilder getPutAttributeTypeOrBuilder() {
if ((requestCase_ == 12) && (putAttributeTypeBuilder_ != null)) {
return putAttributeTypeBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 12) {
return (ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.getDefaultInstance();
}
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutAttributeType putAttributeType = 12;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType, ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.Builder, ai.grakn.rpc.generated.GrpcGrakn.PutAttributeTypeOrBuilder>
getPutAttributeTypeFieldBuilder() {
if (putAttributeTypeBuilder_ == null) {
if (!(requestCase_ == 12)) {
request_ = ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.getDefaultInstance();
}
putAttributeTypeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType, ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.Builder, ai.grakn.rpc.generated.GrpcGrakn.PutAttributeTypeOrBuilder>(
(ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 12;
onChanged();;
return putAttributeTypeBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder> putRoleBuilder_;
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRole = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getPutRole() {
if (putRoleBuilder_ == null) {
if (requestCase_ == 13) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
} else {
if (requestCase_ == 13) {
return putRoleBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRole = 13;</code>
*/
public Builder setPutRole(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (putRoleBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
putRoleBuilder_.setMessage(value);
}
requestCase_ = 13;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRole = 13;</code>
*/
public Builder setPutRole(
ai.grakn.rpc.generated.GrpcConcept.Label.Builder builderForValue) {
if (putRoleBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
putRoleBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 13;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRole = 13;</code>
*/
public Builder mergePutRole(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (putRoleBuilder_ == null) {
if (requestCase_ == 13 &&
request_ != ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcConcept.Label.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Label) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 13) {
putRoleBuilder_.mergeFrom(value);
}
putRoleBuilder_.setMessage(value);
}
requestCase_ = 13;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRole = 13;</code>
*/
public Builder clearPutRole() {
if (putRoleBuilder_ == null) {
if (requestCase_ == 13) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 13) {
requestCase_ = 0;
request_ = null;
}
putRoleBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRole = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label.Builder getPutRoleBuilder() {
return getPutRoleFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRole = 13;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getPutRoleOrBuilder() {
if ((requestCase_ == 13) && (putRoleBuilder_ != null)) {
return putRoleBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 13) {
return (ai.grakn.rpc.generated.GrpcConcept.Label) request_;
}
return ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Label putRole = 13;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>
getPutRoleFieldBuilder() {
if (putRoleBuilder_ == null) {
if (!(requestCase_ == 13)) {
request_ = ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance();
}
putRoleBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Label) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 13;
onChanged();;
return putRoleBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.PutRule, ai.grakn.rpc.generated.GrpcGrakn.PutRule.Builder, ai.grakn.rpc.generated.GrpcGrakn.PutRuleOrBuilder> putRuleBuilder_;
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutRule putRule = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.PutRule getPutRule() {
if (putRuleBuilder_ == null) {
if (requestCase_ == 14) {
return (ai.grakn.rpc.generated.GrpcGrakn.PutRule) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.PutRule.getDefaultInstance();
} else {
if (requestCase_ == 14) {
return putRuleBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcGrakn.PutRule.getDefaultInstance();
}
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutRule putRule = 14;</code>
*/
public Builder setPutRule(ai.grakn.rpc.generated.GrpcGrakn.PutRule value) {
if (putRuleBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
request_ = value;
onChanged();
} else {
putRuleBuilder_.setMessage(value);
}
requestCase_ = 14;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutRule putRule = 14;</code>
*/
public Builder setPutRule(
ai.grakn.rpc.generated.GrpcGrakn.PutRule.Builder builderForValue) {
if (putRuleBuilder_ == null) {
request_ = builderForValue.build();
onChanged();
} else {
putRuleBuilder_.setMessage(builderForValue.build());
}
requestCase_ = 14;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutRule putRule = 14;</code>
*/
public Builder mergePutRule(ai.grakn.rpc.generated.GrpcGrakn.PutRule value) {
if (putRuleBuilder_ == null) {
if (requestCase_ == 14 &&
request_ != ai.grakn.rpc.generated.GrpcGrakn.PutRule.getDefaultInstance()) {
request_ = ai.grakn.rpc.generated.GrpcGrakn.PutRule.newBuilder((ai.grakn.rpc.generated.GrpcGrakn.PutRule) request_)
.mergeFrom(value).buildPartial();
} else {
request_ = value;
}
onChanged();
} else {
if (requestCase_ == 14) {
putRuleBuilder_.mergeFrom(value);
}
putRuleBuilder_.setMessage(value);
}
requestCase_ = 14;
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutRule putRule = 14;</code>
*/
public Builder clearPutRule() {
if (putRuleBuilder_ == null) {
if (requestCase_ == 14) {
requestCase_ = 0;
request_ = null;
onChanged();
}
} else {
if (requestCase_ == 14) {
requestCase_ = 0;
request_ = null;
}
putRuleBuilder_.clear();
}
return this;
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutRule putRule = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.PutRule.Builder getPutRuleBuilder() {
return getPutRuleFieldBuilder().getBuilder();
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutRule putRule = 14;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.PutRuleOrBuilder getPutRuleOrBuilder() {
if ((requestCase_ == 14) && (putRuleBuilder_ != null)) {
return putRuleBuilder_.getMessageOrBuilder();
} else {
if (requestCase_ == 14) {
return (ai.grakn.rpc.generated.GrpcGrakn.PutRule) request_;
}
return ai.grakn.rpc.generated.GrpcGrakn.PutRule.getDefaultInstance();
}
}
/**
* <pre>
* returns Concept
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.PutRule putRule = 14;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.PutRule, ai.grakn.rpc.generated.GrpcGrakn.PutRule.Builder, ai.grakn.rpc.generated.GrpcGrakn.PutRuleOrBuilder>
getPutRuleFieldBuilder() {
if (putRuleBuilder_ == null) {
if (!(requestCase_ == 14)) {
request_ = ai.grakn.rpc.generated.GrpcGrakn.PutRule.getDefaultInstance();
}
putRuleBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.PutRule, ai.grakn.rpc.generated.GrpcGrakn.PutRule.Builder, ai.grakn.rpc.generated.GrpcGrakn.PutRuleOrBuilder>(
(ai.grakn.rpc.generated.GrpcGrakn.PutRule) request_,
getParentForChildren(),
isClean());
request_ = null;
}
requestCase_ = 14;
onChanged();;
return putRuleBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.TxRequest)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.TxRequest)
private static final ai.grakn.rpc.generated.GrpcGrakn.TxRequest DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.TxRequest();
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxRequest getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<TxRequest>
PARSER = new com.google.protobuf.AbstractParser<TxRequest>() {
public TxRequest parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new TxRequest(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<TxRequest> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<TxRequest> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.TxRequest getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface DeleteRequestOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.DeleteRequest)
com.google.protobuf.MessageOrBuilder {
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
boolean hasOpen();
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.Open getOpen();
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.OpenOrBuilder getOpenOrBuilder();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.DeleteRequest}
*/
public static final class DeleteRequest extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.DeleteRequest)
DeleteRequestOrBuilder {
// Use DeleteRequest.newBuilder() to construct.
private DeleteRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private DeleteRequest() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private DeleteRequest(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcGrakn.Open.Builder subBuilder = null;
if (open_ != null) {
subBuilder = open_.toBuilder();
}
open_ = input.readMessage(ai.grakn.rpc.generated.GrpcGrakn.Open.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(open_);
open_ = subBuilder.buildPartial();
}
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_DeleteRequest_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_DeleteRequest_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest.class, ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest.Builder.class);
}
public static final int OPEN_FIELD_NUMBER = 1;
private ai.grakn.rpc.generated.GrpcGrakn.Open open_;
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public boolean hasOpen() {
return open_ != null;
}
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Open getOpen() {
return open_ == null ? ai.grakn.rpc.generated.GrpcGrakn.Open.getDefaultInstance() : open_;
}
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.OpenOrBuilder getOpenOrBuilder() {
return getOpen();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (open_ != null) {
output.writeMessage(1, getOpen());
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (open_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, getOpen());
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest other = (ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest) obj;
boolean result = true;
result = result && (hasOpen() == other.hasOpen());
if (hasOpen()) {
result = result && getOpen()
.equals(other.getOpen());
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
if (hasOpen()) {
hash = (37 * hash) + OPEN_FIELD_NUMBER;
hash = (53 * hash) + getOpen().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.DeleteRequest}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.DeleteRequest)
ai.grakn.rpc.generated.GrpcGrakn.DeleteRequestOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_DeleteRequest_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_DeleteRequest_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest.class, ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
if (openBuilder_ == null) {
open_ = null;
} else {
open_ = null;
openBuilder_ = null;
}
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_DeleteRequest_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest build() {
ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest result = new ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest(this);
if (openBuilder_ == null) {
result.open_ = open_;
} else {
result.open_ = openBuilder_.build();
}
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest.getDefaultInstance()) return this;
if (other.hasOpen()) {
mergeOpen(other.getOpen());
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private ai.grakn.rpc.generated.GrpcGrakn.Open open_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Open, ai.grakn.rpc.generated.GrpcGrakn.Open.Builder, ai.grakn.rpc.generated.GrpcGrakn.OpenOrBuilder> openBuilder_;
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public boolean hasOpen() {
return openBuilder_ != null || open_ != null;
}
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Open getOpen() {
if (openBuilder_ == null) {
return open_ == null ? ai.grakn.rpc.generated.GrpcGrakn.Open.getDefaultInstance() : open_;
} else {
return openBuilder_.getMessage();
}
}
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public Builder setOpen(ai.grakn.rpc.generated.GrpcGrakn.Open value) {
if (openBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
open_ = value;
onChanged();
} else {
openBuilder_.setMessage(value);
}
return this;
}
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public Builder setOpen(
ai.grakn.rpc.generated.GrpcGrakn.Open.Builder builderForValue) {
if (openBuilder_ == null) {
open_ = builderForValue.build();
onChanged();
} else {
openBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public Builder mergeOpen(ai.grakn.rpc.generated.GrpcGrakn.Open value) {
if (openBuilder_ == null) {
if (open_ != null) {
open_ =
ai.grakn.rpc.generated.GrpcGrakn.Open.newBuilder(open_).mergeFrom(value).buildPartial();
} else {
open_ = value;
}
onChanged();
} else {
openBuilder_.mergeFrom(value);
}
return this;
}
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public Builder clearOpen() {
if (openBuilder_ == null) {
open_ = null;
onChanged();
} else {
open_ = null;
openBuilder_ = null;
}
return this;
}
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Open.Builder getOpenBuilder() {
onChanged();
return getOpenFieldBuilder().getBuilder();
}
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.OpenOrBuilder getOpenOrBuilder() {
if (openBuilder_ != null) {
return openBuilder_.getMessageOrBuilder();
} else {
return open_ == null ?
ai.grakn.rpc.generated.GrpcGrakn.Open.getDefaultInstance() : open_;
}
}
/**
* <pre>
* This open request describes how to open the transaction in order to delete the keyspace
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Open open = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Open, ai.grakn.rpc.generated.GrpcGrakn.Open.Builder, ai.grakn.rpc.generated.GrpcGrakn.OpenOrBuilder>
getOpenFieldBuilder() {
if (openBuilder_ == null) {
openBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Open, ai.grakn.rpc.generated.GrpcGrakn.Open.Builder, ai.grakn.rpc.generated.GrpcGrakn.OpenOrBuilder>(
getOpen(),
getParentForChildren(),
isClean());
open_ = null;
}
return openBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.DeleteRequest)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.DeleteRequest)
private static final ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest();
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<DeleteRequest>
PARSER = new com.google.protobuf.AbstractParser<DeleteRequest>() {
public DeleteRequest parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new DeleteRequest(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<DeleteRequest> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<DeleteRequest> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.DeleteRequest getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface DeleteResponseOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.DeleteResponse)
com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.DeleteResponse}
*/
public static final class DeleteResponse extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.DeleteResponse)
DeleteResponseOrBuilder {
// Use DeleteResponse.newBuilder() to construct.
private DeleteResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private DeleteResponse() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private DeleteResponse(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_DeleteResponse_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_DeleteResponse_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse.class, ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse.Builder.class);
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse other = (ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse) obj;
boolean result = true;
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.DeleteResponse}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.DeleteResponse)
ai.grakn.rpc.generated.GrpcGrakn.DeleteResponseOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_DeleteResponse_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_DeleteResponse_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse.class, ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_DeleteResponse_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse build() {
ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse result = new ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse(this);
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse.getDefaultInstance()) return this;
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.DeleteResponse)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.DeleteResponse)
private static final ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse();
}
public static ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<DeleteResponse>
PARSER = new com.google.protobuf.AbstractParser<DeleteResponse>() {
public DeleteResponse parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new DeleteResponse(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<DeleteResponse> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<DeleteResponse> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.DeleteResponse getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface OpenOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Open)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
boolean hasKeyspace();
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.Keyspace getKeyspace();
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.KeyspaceOrBuilder getKeyspaceOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.TxType txType = 2;</code>
*/
int getTxTypeValue();
/**
* <code>optional .ai.grakn.rpc.generated.TxType txType = 2;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.TxType getTxType();
/**
* <pre>
* Fields ignored in the open-source version.
* </pre>
*
* <code>optional string username = 3;</code>
*/
java.lang.String getUsername();
/**
* <pre>
* Fields ignored in the open-source version.
* </pre>
*
* <code>optional string username = 3;</code>
*/
com.google.protobuf.ByteString
getUsernameBytes();
/**
* <code>optional string password = 4;</code>
*/
java.lang.String getPassword();
/**
* <code>optional string password = 4;</code>
*/
com.google.protobuf.ByteString
getPasswordBytes();
}
/**
* <pre>
*Open a transaction on a keyspace. This must be the first message sent.
*After this message, the server will send a `Done` message and then accept a command message.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Open}
*/
public static final class Open extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Open)
OpenOrBuilder {
// Use Open.newBuilder() to construct.
private Open(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Open() {
txType_ = 0;
username_ = "";
password_ = "";
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Open(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcGrakn.Keyspace.Builder subBuilder = null;
if (keyspace_ != null) {
subBuilder = keyspace_.toBuilder();
}
keyspace_ = input.readMessage(ai.grakn.rpc.generated.GrpcGrakn.Keyspace.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(keyspace_);
keyspace_ = subBuilder.buildPartial();
}
break;
}
case 16: {
int rawValue = input.readEnum();
txType_ = rawValue;
break;
}
case 26: {
java.lang.String s = input.readStringRequireUtf8();
username_ = s;
break;
}
case 34: {
java.lang.String s = input.readStringRequireUtf8();
password_ = s;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Open_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Open_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Open.class, ai.grakn.rpc.generated.GrpcGrakn.Open.Builder.class);
}
public static final int KEYSPACE_FIELD_NUMBER = 1;
private ai.grakn.rpc.generated.GrpcGrakn.Keyspace keyspace_;
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
public boolean hasKeyspace() {
return keyspace_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Keyspace getKeyspace() {
return keyspace_ == null ? ai.grakn.rpc.generated.GrpcGrakn.Keyspace.getDefaultInstance() : keyspace_;
}
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.KeyspaceOrBuilder getKeyspaceOrBuilder() {
return getKeyspace();
}
public static final int TXTYPE_FIELD_NUMBER = 2;
private int txType_;
/**
* <code>optional .ai.grakn.rpc.generated.TxType txType = 2;</code>
*/
public int getTxTypeValue() {
return txType_;
}
/**
* <code>optional .ai.grakn.rpc.generated.TxType txType = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.TxType getTxType() {
ai.grakn.rpc.generated.GrpcGrakn.TxType result = ai.grakn.rpc.generated.GrpcGrakn.TxType.valueOf(txType_);
return result == null ? ai.grakn.rpc.generated.GrpcGrakn.TxType.UNRECOGNIZED : result;
}
public static final int USERNAME_FIELD_NUMBER = 3;
private volatile java.lang.Object username_;
/**
* <pre>
* Fields ignored in the open-source version.
* </pre>
*
* <code>optional string username = 3;</code>
*/
public java.lang.String getUsername() {
java.lang.Object ref = username_;
if (ref instanceof java.lang.String) {
return (java.lang.String) ref;
} else {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
username_ = s;
return s;
}
}
/**
* <pre>
* Fields ignored in the open-source version.
* </pre>
*
* <code>optional string username = 3;</code>
*/
public com.google.protobuf.ByteString
getUsernameBytes() {
java.lang.Object ref = username_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
username_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
public static final int PASSWORD_FIELD_NUMBER = 4;
private volatile java.lang.Object password_;
/**
* <code>optional string password = 4;</code>
*/
public java.lang.String getPassword() {
java.lang.Object ref = password_;
if (ref instanceof java.lang.String) {
return (java.lang.String) ref;
} else {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
password_ = s;
return s;
}
}
/**
* <code>optional string password = 4;</code>
*/
public com.google.protobuf.ByteString
getPasswordBytes() {
java.lang.Object ref = password_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
password_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (keyspace_ != null) {
output.writeMessage(1, getKeyspace());
}
if (txType_ != ai.grakn.rpc.generated.GrpcGrakn.TxType.Read.getNumber()) {
output.writeEnum(2, txType_);
}
if (!getUsernameBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 3, username_);
}
if (!getPasswordBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 4, password_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (keyspace_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, getKeyspace());
}
if (txType_ != ai.grakn.rpc.generated.GrpcGrakn.TxType.Read.getNumber()) {
size += com.google.protobuf.CodedOutputStream
.computeEnumSize(2, txType_);
}
if (!getUsernameBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, username_);
}
if (!getPasswordBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, password_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.Open)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.Open other = (ai.grakn.rpc.generated.GrpcGrakn.Open) obj;
boolean result = true;
result = result && (hasKeyspace() == other.hasKeyspace());
if (hasKeyspace()) {
result = result && getKeyspace()
.equals(other.getKeyspace());
}
result = result && txType_ == other.txType_;
result = result && getUsername()
.equals(other.getUsername());
result = result && getPassword()
.equals(other.getPassword());
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
if (hasKeyspace()) {
hash = (37 * hash) + KEYSPACE_FIELD_NUMBER;
hash = (53 * hash) + getKeyspace().hashCode();
}
hash = (37 * hash) + TXTYPE_FIELD_NUMBER;
hash = (53 * hash) + txType_;
hash = (37 * hash) + USERNAME_FIELD_NUMBER;
hash = (53 * hash) + getUsername().hashCode();
hash = (37 * hash) + PASSWORD_FIELD_NUMBER;
hash = (53 * hash) + getPassword().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.Open parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Open parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Open parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Open parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Open parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Open parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Open parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Open parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Open parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Open parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.Open prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* <pre>
*Open a transaction on a keyspace. This must be the first message sent.
*After this message, the server will send a `Done` message and then accept a command message.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Open}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Open)
ai.grakn.rpc.generated.GrpcGrakn.OpenOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Open_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Open_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Open.class, ai.grakn.rpc.generated.GrpcGrakn.Open.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.Open.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
if (keyspaceBuilder_ == null) {
keyspace_ = null;
} else {
keyspace_ = null;
keyspaceBuilder_ = null;
}
txType_ = 0;
username_ = "";
password_ = "";
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Open_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.Open getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.Open.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.Open build() {
ai.grakn.rpc.generated.GrpcGrakn.Open result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.Open buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.Open result = new ai.grakn.rpc.generated.GrpcGrakn.Open(this);
if (keyspaceBuilder_ == null) {
result.keyspace_ = keyspace_;
} else {
result.keyspace_ = keyspaceBuilder_.build();
}
result.txType_ = txType_;
result.username_ = username_;
result.password_ = password_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.Open) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.Open)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.Open other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.Open.getDefaultInstance()) return this;
if (other.hasKeyspace()) {
mergeKeyspace(other.getKeyspace());
}
if (other.txType_ != 0) {
setTxTypeValue(other.getTxTypeValue());
}
if (!other.getUsername().isEmpty()) {
username_ = other.username_;
onChanged();
}
if (!other.getPassword().isEmpty()) {
password_ = other.password_;
onChanged();
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.Open parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.Open) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private ai.grakn.rpc.generated.GrpcGrakn.Keyspace keyspace_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Keyspace, ai.grakn.rpc.generated.GrpcGrakn.Keyspace.Builder, ai.grakn.rpc.generated.GrpcGrakn.KeyspaceOrBuilder> keyspaceBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
public boolean hasKeyspace() {
return keyspaceBuilder_ != null || keyspace_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Keyspace getKeyspace() {
if (keyspaceBuilder_ == null) {
return keyspace_ == null ? ai.grakn.rpc.generated.GrpcGrakn.Keyspace.getDefaultInstance() : keyspace_;
} else {
return keyspaceBuilder_.getMessage();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
public Builder setKeyspace(ai.grakn.rpc.generated.GrpcGrakn.Keyspace value) {
if (keyspaceBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
keyspace_ = value;
onChanged();
} else {
keyspaceBuilder_.setMessage(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
public Builder setKeyspace(
ai.grakn.rpc.generated.GrpcGrakn.Keyspace.Builder builderForValue) {
if (keyspaceBuilder_ == null) {
keyspace_ = builderForValue.build();
onChanged();
} else {
keyspaceBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
public Builder mergeKeyspace(ai.grakn.rpc.generated.GrpcGrakn.Keyspace value) {
if (keyspaceBuilder_ == null) {
if (keyspace_ != null) {
keyspace_ =
ai.grakn.rpc.generated.GrpcGrakn.Keyspace.newBuilder(keyspace_).mergeFrom(value).buildPartial();
} else {
keyspace_ = value;
}
onChanged();
} else {
keyspaceBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
public Builder clearKeyspace() {
if (keyspaceBuilder_ == null) {
keyspace_ = null;
onChanged();
} else {
keyspace_ = null;
keyspaceBuilder_ = null;
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Keyspace.Builder getKeyspaceBuilder() {
onChanged();
return getKeyspaceFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.KeyspaceOrBuilder getKeyspaceOrBuilder() {
if (keyspaceBuilder_ != null) {
return keyspaceBuilder_.getMessageOrBuilder();
} else {
return keyspace_ == null ?
ai.grakn.rpc.generated.GrpcGrakn.Keyspace.getDefaultInstance() : keyspace_;
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Keyspace keyspace = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Keyspace, ai.grakn.rpc.generated.GrpcGrakn.Keyspace.Builder, ai.grakn.rpc.generated.GrpcGrakn.KeyspaceOrBuilder>
getKeyspaceFieldBuilder() {
if (keyspaceBuilder_ == null) {
keyspaceBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Keyspace, ai.grakn.rpc.generated.GrpcGrakn.Keyspace.Builder, ai.grakn.rpc.generated.GrpcGrakn.KeyspaceOrBuilder>(
getKeyspace(),
getParentForChildren(),
isClean());
keyspace_ = null;
}
return keyspaceBuilder_;
}
private int txType_ = 0;
/**
* <code>optional .ai.grakn.rpc.generated.TxType txType = 2;</code>
*/
public int getTxTypeValue() {
return txType_;
}
/**
* <code>optional .ai.grakn.rpc.generated.TxType txType = 2;</code>
*/
public Builder setTxTypeValue(int value) {
txType_ = value;
onChanged();
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.TxType txType = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.TxType getTxType() {
ai.grakn.rpc.generated.GrpcGrakn.TxType result = ai.grakn.rpc.generated.GrpcGrakn.TxType.valueOf(txType_);
return result == null ? ai.grakn.rpc.generated.GrpcGrakn.TxType.UNRECOGNIZED : result;
}
/**
* <code>optional .ai.grakn.rpc.generated.TxType txType = 2;</code>
*/
public Builder setTxType(ai.grakn.rpc.generated.GrpcGrakn.TxType value) {
if (value == null) {
throw new NullPointerException();
}
txType_ = value.getNumber();
onChanged();
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.TxType txType = 2;</code>
*/
public Builder clearTxType() {
txType_ = 0;
onChanged();
return this;
}
private java.lang.Object username_ = "";
/**
* <pre>
* Fields ignored in the open-source version.
* </pre>
*
* <code>optional string username = 3;</code>
*/
public java.lang.String getUsername() {
java.lang.Object ref = username_;
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
username_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <pre>
* Fields ignored in the open-source version.
* </pre>
*
* <code>optional string username = 3;</code>
*/
public com.google.protobuf.ByteString
getUsernameBytes() {
java.lang.Object ref = username_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
username_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <pre>
* Fields ignored in the open-source version.
* </pre>
*
* <code>optional string username = 3;</code>
*/
public Builder setUsername(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
username_ = value;
onChanged();
return this;
}
/**
* <pre>
* Fields ignored in the open-source version.
* </pre>
*
* <code>optional string username = 3;</code>
*/
public Builder clearUsername() {
username_ = getDefaultInstance().getUsername();
onChanged();
return this;
}
/**
* <pre>
* Fields ignored in the open-source version.
* </pre>
*
* <code>optional string username = 3;</code>
*/
public Builder setUsernameBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
username_ = value;
onChanged();
return this;
}
private java.lang.Object password_ = "";
/**
* <code>optional string password = 4;</code>
*/
public java.lang.String getPassword() {
java.lang.Object ref = password_;
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
password_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <code>optional string password = 4;</code>
*/
public com.google.protobuf.ByteString
getPasswordBytes() {
java.lang.Object ref = password_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
password_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <code>optional string password = 4;</code>
*/
public Builder setPassword(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
password_ = value;
onChanged();
return this;
}
/**
* <code>optional string password = 4;</code>
*/
public Builder clearPassword() {
password_ = getDefaultInstance().getPassword();
onChanged();
return this;
}
/**
* <code>optional string password = 4;</code>
*/
public Builder setPasswordBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
password_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Open)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Open)
private static final ai.grakn.rpc.generated.GrpcGrakn.Open DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.Open();
}
public static ai.grakn.rpc.generated.GrpcGrakn.Open getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Open>
PARSER = new com.google.protobuf.AbstractParser<Open>() {
public Open parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Open(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Open> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Open> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.Open getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface CommitOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Commit)
com.google.protobuf.MessageOrBuilder {
}
/**
* <pre>
*Command to commit a transaction.
*After this message, the server will send a `Done` message and then accept a command message.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Commit}
*/
public static final class Commit extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Commit)
CommitOrBuilder {
// Use Commit.newBuilder() to construct.
private Commit(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Commit() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Commit(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Commit_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Commit_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Commit.class, ai.grakn.rpc.generated.GrpcGrakn.Commit.Builder.class);
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.Commit)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.Commit other = (ai.grakn.rpc.generated.GrpcGrakn.Commit) obj;
boolean result = true;
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.Commit parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Commit parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Commit parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Commit parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Commit parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Commit parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Commit parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Commit parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Commit parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Commit parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.Commit prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* <pre>
*Command to commit a transaction.
*After this message, the server will send a `Done` message and then accept a command message.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Commit}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Commit)
ai.grakn.rpc.generated.GrpcGrakn.CommitOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Commit_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Commit_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Commit.class, ai.grakn.rpc.generated.GrpcGrakn.Commit.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.Commit.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Commit_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.Commit getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.Commit.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.Commit build() {
ai.grakn.rpc.generated.GrpcGrakn.Commit result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.Commit buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.Commit result = new ai.grakn.rpc.generated.GrpcGrakn.Commit(this);
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.Commit) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.Commit)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.Commit other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.Commit.getDefaultInstance()) return this;
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.Commit parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.Commit) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Commit)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Commit)
private static final ai.grakn.rpc.generated.GrpcGrakn.Commit DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.Commit();
}
public static ai.grakn.rpc.generated.GrpcGrakn.Commit getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Commit>
PARSER = new com.google.protobuf.AbstractParser<Commit>() {
public Commit parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Commit(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Commit> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Commit> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.Commit getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface ExecQueryOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.ExecQuery)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
boolean hasQuery();
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.Query getQuery();
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.QueryOrBuilder getQueryOrBuilder();
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
boolean hasInfer();
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.Infer getInfer();
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.InferOrBuilder getInferOrBuilder();
}
/**
* <pre>
*Command to start executing a query.
*After this message, the server will send an `Iterator` message and then accept a command message.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.ExecQuery}
*/
public static final class ExecQuery extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.ExecQuery)
ExecQueryOrBuilder {
// Use ExecQuery.newBuilder() to construct.
private ExecQuery(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private ExecQuery() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private ExecQuery(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcGrakn.Query.Builder subBuilder = null;
if (query_ != null) {
subBuilder = query_.toBuilder();
}
query_ = input.readMessage(ai.grakn.rpc.generated.GrpcGrakn.Query.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(query_);
query_ = subBuilder.buildPartial();
}
break;
}
case 18: {
ai.grakn.rpc.generated.GrpcGrakn.Infer.Builder subBuilder = null;
if (infer_ != null) {
subBuilder = infer_.toBuilder();
}
infer_ = input.readMessage(ai.grakn.rpc.generated.GrpcGrakn.Infer.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(infer_);
infer_ = subBuilder.buildPartial();
}
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_ExecQuery_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_ExecQuery_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.class, ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.Builder.class);
}
public static final int QUERY_FIELD_NUMBER = 1;
private ai.grakn.rpc.generated.GrpcGrakn.Query query_;
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
public boolean hasQuery() {
return query_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Query getQuery() {
return query_ == null ? ai.grakn.rpc.generated.GrpcGrakn.Query.getDefaultInstance() : query_;
}
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.QueryOrBuilder getQueryOrBuilder() {
return getQuery();
}
public static final int INFER_FIELD_NUMBER = 2;
private ai.grakn.rpc.generated.GrpcGrakn.Infer infer_;
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
public boolean hasInfer() {
return infer_ != null;
}
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Infer getInfer() {
return infer_ == null ? ai.grakn.rpc.generated.GrpcGrakn.Infer.getDefaultInstance() : infer_;
}
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.InferOrBuilder getInferOrBuilder() {
return getInfer();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (query_ != null) {
output.writeMessage(1, getQuery());
}
if (infer_ != null) {
output.writeMessage(2, getInfer());
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (query_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, getQuery());
}
if (infer_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(2, getInfer());
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.ExecQuery)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.ExecQuery other = (ai.grakn.rpc.generated.GrpcGrakn.ExecQuery) obj;
boolean result = true;
result = result && (hasQuery() == other.hasQuery());
if (hasQuery()) {
result = result && getQuery()
.equals(other.getQuery());
}
result = result && (hasInfer() == other.hasInfer());
if (hasInfer()) {
result = result && getInfer()
.equals(other.getInfer());
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
if (hasQuery()) {
hash = (37 * hash) + QUERY_FIELD_NUMBER;
hash = (53 * hash) + getQuery().hashCode();
}
if (hasInfer()) {
hash = (37 * hash) + INFER_FIELD_NUMBER;
hash = (53 * hash) + getInfer().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.ExecQuery parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.ExecQuery parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.ExecQuery parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.ExecQuery parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.ExecQuery parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.ExecQuery parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.ExecQuery parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.ExecQuery parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.ExecQuery parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.ExecQuery parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.ExecQuery prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* <pre>
*Command to start executing a query.
*After this message, the server will send an `Iterator` message and then accept a command message.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.ExecQuery}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.ExecQuery)
ai.grakn.rpc.generated.GrpcGrakn.ExecQueryOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_ExecQuery_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_ExecQuery_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.class, ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
if (queryBuilder_ == null) {
query_ = null;
} else {
query_ = null;
queryBuilder_ = null;
}
if (inferBuilder_ == null) {
infer_ = null;
} else {
infer_ = null;
inferBuilder_ = null;
}
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_ExecQuery_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.ExecQuery getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.ExecQuery build() {
ai.grakn.rpc.generated.GrpcGrakn.ExecQuery result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.ExecQuery buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.ExecQuery result = new ai.grakn.rpc.generated.GrpcGrakn.ExecQuery(this);
if (queryBuilder_ == null) {
result.query_ = query_;
} else {
result.query_ = queryBuilder_.build();
}
if (inferBuilder_ == null) {
result.infer_ = infer_;
} else {
result.infer_ = inferBuilder_.build();
}
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.ExecQuery) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.ExecQuery)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.ExecQuery other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.ExecQuery.getDefaultInstance()) return this;
if (other.hasQuery()) {
mergeQuery(other.getQuery());
}
if (other.hasInfer()) {
mergeInfer(other.getInfer());
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.ExecQuery parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.ExecQuery) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private ai.grakn.rpc.generated.GrpcGrakn.Query query_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Query, ai.grakn.rpc.generated.GrpcGrakn.Query.Builder, ai.grakn.rpc.generated.GrpcGrakn.QueryOrBuilder> queryBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
public boolean hasQuery() {
return queryBuilder_ != null || query_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Query getQuery() {
if (queryBuilder_ == null) {
return query_ == null ? ai.grakn.rpc.generated.GrpcGrakn.Query.getDefaultInstance() : query_;
} else {
return queryBuilder_.getMessage();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
public Builder setQuery(ai.grakn.rpc.generated.GrpcGrakn.Query value) {
if (queryBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
query_ = value;
onChanged();
} else {
queryBuilder_.setMessage(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
public Builder setQuery(
ai.grakn.rpc.generated.GrpcGrakn.Query.Builder builderForValue) {
if (queryBuilder_ == null) {
query_ = builderForValue.build();
onChanged();
} else {
queryBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
public Builder mergeQuery(ai.grakn.rpc.generated.GrpcGrakn.Query value) {
if (queryBuilder_ == null) {
if (query_ != null) {
query_ =
ai.grakn.rpc.generated.GrpcGrakn.Query.newBuilder(query_).mergeFrom(value).buildPartial();
} else {
query_ = value;
}
onChanged();
} else {
queryBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
public Builder clearQuery() {
if (queryBuilder_ == null) {
query_ = null;
onChanged();
} else {
query_ = null;
queryBuilder_ = null;
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Query.Builder getQueryBuilder() {
onChanged();
return getQueryFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.QueryOrBuilder getQueryOrBuilder() {
if (queryBuilder_ != null) {
return queryBuilder_.getMessageOrBuilder();
} else {
return query_ == null ?
ai.grakn.rpc.generated.GrpcGrakn.Query.getDefaultInstance() : query_;
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Query query = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Query, ai.grakn.rpc.generated.GrpcGrakn.Query.Builder, ai.grakn.rpc.generated.GrpcGrakn.QueryOrBuilder>
getQueryFieldBuilder() {
if (queryBuilder_ == null) {
queryBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Query, ai.grakn.rpc.generated.GrpcGrakn.Query.Builder, ai.grakn.rpc.generated.GrpcGrakn.QueryOrBuilder>(
getQuery(),
getParentForChildren(),
isClean());
query_ = null;
}
return queryBuilder_;
}
private ai.grakn.rpc.generated.GrpcGrakn.Infer infer_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Infer, ai.grakn.rpc.generated.GrpcGrakn.Infer.Builder, ai.grakn.rpc.generated.GrpcGrakn.InferOrBuilder> inferBuilder_;
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
public boolean hasInfer() {
return inferBuilder_ != null || infer_ != null;
}
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Infer getInfer() {
if (inferBuilder_ == null) {
return infer_ == null ? ai.grakn.rpc.generated.GrpcGrakn.Infer.getDefaultInstance() : infer_;
} else {
return inferBuilder_.getMessage();
}
}
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
public Builder setInfer(ai.grakn.rpc.generated.GrpcGrakn.Infer value) {
if (inferBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
infer_ = value;
onChanged();
} else {
inferBuilder_.setMessage(value);
}
return this;
}
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
public Builder setInfer(
ai.grakn.rpc.generated.GrpcGrakn.Infer.Builder builderForValue) {
if (inferBuilder_ == null) {
infer_ = builderForValue.build();
onChanged();
} else {
inferBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
public Builder mergeInfer(ai.grakn.rpc.generated.GrpcGrakn.Infer value) {
if (inferBuilder_ == null) {
if (infer_ != null) {
infer_ =
ai.grakn.rpc.generated.GrpcGrakn.Infer.newBuilder(infer_).mergeFrom(value).buildPartial();
} else {
infer_ = value;
}
onChanged();
} else {
inferBuilder_.mergeFrom(value);
}
return this;
}
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
public Builder clearInfer() {
if (inferBuilder_ == null) {
infer_ = null;
onChanged();
} else {
infer_ = null;
inferBuilder_ = null;
}
return this;
}
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Infer.Builder getInferBuilder() {
onChanged();
return getInferFieldBuilder().getBuilder();
}
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.InferOrBuilder getInferOrBuilder() {
if (inferBuilder_ != null) {
return inferBuilder_.getMessageOrBuilder();
} else {
return infer_ == null ?
ai.grakn.rpc.generated.GrpcGrakn.Infer.getDefaultInstance() : infer_;
}
}
/**
* <pre>
* If this is not present, leave at server default.
* </pre>
*
* <code>optional .ai.grakn.rpc.generated.Infer infer = 2;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Infer, ai.grakn.rpc.generated.GrpcGrakn.Infer.Builder, ai.grakn.rpc.generated.GrpcGrakn.InferOrBuilder>
getInferFieldBuilder() {
if (inferBuilder_ == null) {
inferBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Infer, ai.grakn.rpc.generated.GrpcGrakn.Infer.Builder, ai.grakn.rpc.generated.GrpcGrakn.InferOrBuilder>(
getInfer(),
getParentForChildren(),
isClean());
infer_ = null;
}
return inferBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.ExecQuery)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.ExecQuery)
private static final ai.grakn.rpc.generated.GrpcGrakn.ExecQuery DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.ExecQuery();
}
public static ai.grakn.rpc.generated.GrpcGrakn.ExecQuery getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<ExecQuery>
PARSER = new com.google.protobuf.AbstractParser<ExecQuery>() {
public ExecQuery parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new ExecQuery(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<ExecQuery> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<ExecQuery> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.ExecQuery getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface RunConceptMethodOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.RunConceptMethod)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
boolean hasId();
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptId getId();
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder getIdOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
boolean hasConceptMethod();
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod getConceptMethod();
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptMethodOrBuilder getConceptMethodOrBuilder();
}
/**
* <pre>
*Run a concept method on a concept.
*After this message, the server will send a `ConceptResponse` message and then accept a command message.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.RunConceptMethod}
*/
public static final class RunConceptMethod extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.RunConceptMethod)
RunConceptMethodOrBuilder {
// Use RunConceptMethod.newBuilder() to construct.
private RunConceptMethod(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private RunConceptMethod() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private RunConceptMethod(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder subBuilder = null;
if (id_ != null) {
subBuilder = id_.toBuilder();
}
id_ = input.readMessage(ai.grakn.rpc.generated.GrpcConcept.ConceptId.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(id_);
id_ = subBuilder.buildPartial();
}
break;
}
case 18: {
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.Builder subBuilder = null;
if (conceptMethod_ != null) {
subBuilder = conceptMethod_.toBuilder();
}
conceptMethod_ = input.readMessage(ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(conceptMethod_);
conceptMethod_ = subBuilder.buildPartial();
}
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_RunConceptMethod_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_RunConceptMethod_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.class, ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.Builder.class);
}
public static final int ID_FIELD_NUMBER = 1;
private ai.grakn.rpc.generated.GrpcConcept.ConceptId id_;
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public boolean hasId() {
return id_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptId getId() {
return id_ == null ? ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance() : id_;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder getIdOrBuilder() {
return getId();
}
public static final int CONCEPTMETHOD_FIELD_NUMBER = 2;
private ai.grakn.rpc.generated.GrpcConcept.ConceptMethod conceptMethod_;
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
public boolean hasConceptMethod() {
return conceptMethod_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptMethod getConceptMethod() {
return conceptMethod_ == null ? ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.getDefaultInstance() : conceptMethod_;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptMethodOrBuilder getConceptMethodOrBuilder() {
return getConceptMethod();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (id_ != null) {
output.writeMessage(1, getId());
}
if (conceptMethod_ != null) {
output.writeMessage(2, getConceptMethod());
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (id_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, getId());
}
if (conceptMethod_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(2, getConceptMethod());
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod other = (ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod) obj;
boolean result = true;
result = result && (hasId() == other.hasId());
if (hasId()) {
result = result && getId()
.equals(other.getId());
}
result = result && (hasConceptMethod() == other.hasConceptMethod());
if (hasConceptMethod()) {
result = result && getConceptMethod()
.equals(other.getConceptMethod());
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
if (hasId()) {
hash = (37 * hash) + ID_FIELD_NUMBER;
hash = (53 * hash) + getId().hashCode();
}
if (hasConceptMethod()) {
hash = (37 * hash) + CONCEPTMETHOD_FIELD_NUMBER;
hash = (53 * hash) + getConceptMethod().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* <pre>
*Run a concept method on a concept.
*After this message, the server will send a `ConceptResponse` message and then accept a command message.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.RunConceptMethod}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.RunConceptMethod)
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethodOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_RunConceptMethod_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_RunConceptMethod_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.class, ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
if (idBuilder_ == null) {
id_ = null;
} else {
id_ = null;
idBuilder_ = null;
}
if (conceptMethodBuilder_ == null) {
conceptMethod_ = null;
} else {
conceptMethod_ = null;
conceptMethodBuilder_ = null;
}
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_RunConceptMethod_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod build() {
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod result = new ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod(this);
if (idBuilder_ == null) {
result.id_ = id_;
} else {
result.id_ = idBuilder_.build();
}
if (conceptMethodBuilder_ == null) {
result.conceptMethod_ = conceptMethod_;
} else {
result.conceptMethod_ = conceptMethodBuilder_.build();
}
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod.getDefaultInstance()) return this;
if (other.hasId()) {
mergeId(other.getId());
}
if (other.hasConceptMethod()) {
mergeConceptMethod(other.getConceptMethod());
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private ai.grakn.rpc.generated.GrpcConcept.ConceptId id_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptId, ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder> idBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public boolean hasId() {
return idBuilder_ != null || id_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptId getId() {
if (idBuilder_ == null) {
return id_ == null ? ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance() : id_;
} else {
return idBuilder_.getMessage();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public Builder setId(ai.grakn.rpc.generated.GrpcConcept.ConceptId value) {
if (idBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
id_ = value;
onChanged();
} else {
idBuilder_.setMessage(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public Builder setId(
ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder builderForValue) {
if (idBuilder_ == null) {
id_ = builderForValue.build();
onChanged();
} else {
idBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public Builder mergeId(ai.grakn.rpc.generated.GrpcConcept.ConceptId value) {
if (idBuilder_ == null) {
if (id_ != null) {
id_ =
ai.grakn.rpc.generated.GrpcConcept.ConceptId.newBuilder(id_).mergeFrom(value).buildPartial();
} else {
id_ = value;
}
onChanged();
} else {
idBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public Builder clearId() {
if (idBuilder_ == null) {
id_ = null;
onChanged();
} else {
id_ = null;
idBuilder_ = null;
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder getIdBuilder() {
onChanged();
return getIdFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder getIdOrBuilder() {
if (idBuilder_ != null) {
return idBuilder_.getMessageOrBuilder();
} else {
return id_ == null ?
ai.grakn.rpc.generated.GrpcConcept.ConceptId.getDefaultInstance() : id_;
}
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptId id = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptId, ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder>
getIdFieldBuilder() {
if (idBuilder_ == null) {
idBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptId, ai.grakn.rpc.generated.GrpcConcept.ConceptId.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptIdOrBuilder>(
getId(),
getParentForChildren(),
isClean());
id_ = null;
}
return idBuilder_;
}
private ai.grakn.rpc.generated.GrpcConcept.ConceptMethod conceptMethod_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod, ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptMethodOrBuilder> conceptMethodBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
public boolean hasConceptMethod() {
return conceptMethodBuilder_ != null || conceptMethod_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptMethod getConceptMethod() {
if (conceptMethodBuilder_ == null) {
return conceptMethod_ == null ? ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.getDefaultInstance() : conceptMethod_;
} else {
return conceptMethodBuilder_.getMessage();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
public Builder setConceptMethod(ai.grakn.rpc.generated.GrpcConcept.ConceptMethod value) {
if (conceptMethodBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
conceptMethod_ = value;
onChanged();
} else {
conceptMethodBuilder_.setMessage(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
public Builder setConceptMethod(
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.Builder builderForValue) {
if (conceptMethodBuilder_ == null) {
conceptMethod_ = builderForValue.build();
onChanged();
} else {
conceptMethodBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
public Builder mergeConceptMethod(ai.grakn.rpc.generated.GrpcConcept.ConceptMethod value) {
if (conceptMethodBuilder_ == null) {
if (conceptMethod_ != null) {
conceptMethod_ =
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.newBuilder(conceptMethod_).mergeFrom(value).buildPartial();
} else {
conceptMethod_ = value;
}
onChanged();
} else {
conceptMethodBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
public Builder clearConceptMethod() {
if (conceptMethodBuilder_ == null) {
conceptMethod_ = null;
onChanged();
} else {
conceptMethod_ = null;
conceptMethodBuilder_ = null;
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.Builder getConceptMethodBuilder() {
onChanged();
return getConceptMethodFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptMethodOrBuilder getConceptMethodOrBuilder() {
if (conceptMethodBuilder_ != null) {
return conceptMethodBuilder_.getMessageOrBuilder();
} else {
return conceptMethod_ == null ?
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.getDefaultInstance() : conceptMethod_;
}
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptMethod conceptMethod = 2;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod, ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptMethodOrBuilder>
getConceptMethodFieldBuilder() {
if (conceptMethodBuilder_ == null) {
conceptMethodBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptMethod, ai.grakn.rpc.generated.GrpcConcept.ConceptMethod.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptMethodOrBuilder>(
getConceptMethod(),
getParentForChildren(),
isClean());
conceptMethod_ = null;
}
return conceptMethodBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.RunConceptMethod)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.RunConceptMethod)
private static final ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod();
}
public static ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<RunConceptMethod>
PARSER = new com.google.protobuf.AbstractParser<RunConceptMethod>() {
public RunConceptMethod parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new RunConceptMethod(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<RunConceptMethod> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<RunConceptMethod> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.RunConceptMethod getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface PutAttributeTypeOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.PutAttributeType)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
boolean hasLabel();
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Label getLabel();
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getLabelOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
int getDataTypeValue();
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.DataType getDataType();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.PutAttributeType}
*/
public static final class PutAttributeType extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.PutAttributeType)
PutAttributeTypeOrBuilder {
// Use PutAttributeType.newBuilder() to construct.
private PutAttributeType(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private PutAttributeType() {
dataType_ = 0;
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private PutAttributeType(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcConcept.Label.Builder subBuilder = null;
if (label_ != null) {
subBuilder = label_.toBuilder();
}
label_ = input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Label.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(label_);
label_ = subBuilder.buildPartial();
}
break;
}
case 16: {
int rawValue = input.readEnum();
dataType_ = rawValue;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_PutAttributeType_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_PutAttributeType_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.class, ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.Builder.class);
}
public static final int LABEL_FIELD_NUMBER = 1;
private ai.grakn.rpc.generated.GrpcConcept.Label label_;
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public boolean hasLabel() {
return label_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getLabel() {
return label_ == null ? ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance() : label_;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getLabelOrBuilder() {
return getLabel();
}
public static final int DATATYPE_FIELD_NUMBER = 2;
private int dataType_;
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public int getDataTypeValue() {
return dataType_;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.DataType getDataType() {
ai.grakn.rpc.generated.GrpcConcept.DataType result = ai.grakn.rpc.generated.GrpcConcept.DataType.valueOf(dataType_);
return result == null ? ai.grakn.rpc.generated.GrpcConcept.DataType.UNRECOGNIZED : result;
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (label_ != null) {
output.writeMessage(1, getLabel());
}
if (dataType_ != ai.grakn.rpc.generated.GrpcConcept.DataType.String.getNumber()) {
output.writeEnum(2, dataType_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (label_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, getLabel());
}
if (dataType_ != ai.grakn.rpc.generated.GrpcConcept.DataType.String.getNumber()) {
size += com.google.protobuf.CodedOutputStream
.computeEnumSize(2, dataType_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType other = (ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType) obj;
boolean result = true;
result = result && (hasLabel() == other.hasLabel());
if (hasLabel()) {
result = result && getLabel()
.equals(other.getLabel());
}
result = result && dataType_ == other.dataType_;
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
if (hasLabel()) {
hash = (37 * hash) + LABEL_FIELD_NUMBER;
hash = (53 * hash) + getLabel().hashCode();
}
hash = (37 * hash) + DATATYPE_FIELD_NUMBER;
hash = (53 * hash) + dataType_;
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.PutAttributeType}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.PutAttributeType)
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeTypeOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_PutAttributeType_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_PutAttributeType_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.class, ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
if (labelBuilder_ == null) {
label_ = null;
} else {
label_ = null;
labelBuilder_ = null;
}
dataType_ = 0;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_PutAttributeType_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType build() {
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType result = new ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType(this);
if (labelBuilder_ == null) {
result.label_ = label_;
} else {
result.label_ = labelBuilder_.build();
}
result.dataType_ = dataType_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType.getDefaultInstance()) return this;
if (other.hasLabel()) {
mergeLabel(other.getLabel());
}
if (other.dataType_ != 0) {
setDataTypeValue(other.getDataTypeValue());
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private ai.grakn.rpc.generated.GrpcConcept.Label label_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder> labelBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public boolean hasLabel() {
return labelBuilder_ != null || label_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getLabel() {
if (labelBuilder_ == null) {
return label_ == null ? ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance() : label_;
} else {
return labelBuilder_.getMessage();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public Builder setLabel(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (labelBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
label_ = value;
onChanged();
} else {
labelBuilder_.setMessage(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public Builder setLabel(
ai.grakn.rpc.generated.GrpcConcept.Label.Builder builderForValue) {
if (labelBuilder_ == null) {
label_ = builderForValue.build();
onChanged();
} else {
labelBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public Builder mergeLabel(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (labelBuilder_ == null) {
if (label_ != null) {
label_ =
ai.grakn.rpc.generated.GrpcConcept.Label.newBuilder(label_).mergeFrom(value).buildPartial();
} else {
label_ = value;
}
onChanged();
} else {
labelBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public Builder clearLabel() {
if (labelBuilder_ == null) {
label_ = null;
onChanged();
} else {
label_ = null;
labelBuilder_ = null;
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label.Builder getLabelBuilder() {
onChanged();
return getLabelFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getLabelOrBuilder() {
if (labelBuilder_ != null) {
return labelBuilder_.getMessageOrBuilder();
} else {
return label_ == null ?
ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance() : label_;
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>
getLabelFieldBuilder() {
if (labelBuilder_ == null) {
labelBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>(
getLabel(),
getParentForChildren(),
isClean());
label_ = null;
}
return labelBuilder_;
}
private int dataType_ = 0;
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public int getDataTypeValue() {
return dataType_;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public Builder setDataTypeValue(int value) {
dataType_ = value;
onChanged();
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.DataType getDataType() {
ai.grakn.rpc.generated.GrpcConcept.DataType result = ai.grakn.rpc.generated.GrpcConcept.DataType.valueOf(dataType_);
return result == null ? ai.grakn.rpc.generated.GrpcConcept.DataType.UNRECOGNIZED : result;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public Builder setDataType(ai.grakn.rpc.generated.GrpcConcept.DataType value) {
if (value == null) {
throw new NullPointerException();
}
dataType_ = value.getNumber();
onChanged();
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.DataType dataType = 2;</code>
*/
public Builder clearDataType() {
dataType_ = 0;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.PutAttributeType)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.PutAttributeType)
private static final ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType();
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<PutAttributeType>
PARSER = new com.google.protobuf.AbstractParser<PutAttributeType>() {
public PutAttributeType parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new PutAttributeType(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<PutAttributeType> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<PutAttributeType> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.PutAttributeType getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface PutRuleOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.PutRule)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
boolean hasLabel();
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Label getLabel();
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getLabelOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
boolean hasWhen();
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Pattern getWhen();
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder getWhenOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
boolean hasThen();
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Pattern getThen();
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder getThenOrBuilder();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.PutRule}
*/
public static final class PutRule extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.PutRule)
PutRuleOrBuilder {
// Use PutRule.newBuilder() to construct.
private PutRule(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private PutRule() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private PutRule(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcConcept.Label.Builder subBuilder = null;
if (label_ != null) {
subBuilder = label_.toBuilder();
}
label_ = input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Label.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(label_);
label_ = subBuilder.buildPartial();
}
break;
}
case 18: {
ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder subBuilder = null;
if (when_ != null) {
subBuilder = when_.toBuilder();
}
when_ = input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Pattern.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(when_);
when_ = subBuilder.buildPartial();
}
break;
}
case 26: {
ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder subBuilder = null;
if (then_ != null) {
subBuilder = then_.toBuilder();
}
then_ = input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Pattern.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(then_);
then_ = subBuilder.buildPartial();
}
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_PutRule_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_PutRule_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.PutRule.class, ai.grakn.rpc.generated.GrpcGrakn.PutRule.Builder.class);
}
public static final int LABEL_FIELD_NUMBER = 1;
private ai.grakn.rpc.generated.GrpcConcept.Label label_;
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public boolean hasLabel() {
return label_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getLabel() {
return label_ == null ? ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance() : label_;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getLabelOrBuilder() {
return getLabel();
}
public static final int WHEN_FIELD_NUMBER = 2;
private ai.grakn.rpc.generated.GrpcConcept.Pattern when_;
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
public boolean hasWhen() {
return when_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Pattern getWhen() {
return when_ == null ? ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance() : when_;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder getWhenOrBuilder() {
return getWhen();
}
public static final int THEN_FIELD_NUMBER = 3;
private ai.grakn.rpc.generated.GrpcConcept.Pattern then_;
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
public boolean hasThen() {
return then_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Pattern getThen() {
return then_ == null ? ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance() : then_;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder getThenOrBuilder() {
return getThen();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (label_ != null) {
output.writeMessage(1, getLabel());
}
if (when_ != null) {
output.writeMessage(2, getWhen());
}
if (then_ != null) {
output.writeMessage(3, getThen());
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (label_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, getLabel());
}
if (when_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(2, getWhen());
}
if (then_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(3, getThen());
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.PutRule)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.PutRule other = (ai.grakn.rpc.generated.GrpcGrakn.PutRule) obj;
boolean result = true;
result = result && (hasLabel() == other.hasLabel());
if (hasLabel()) {
result = result && getLabel()
.equals(other.getLabel());
}
result = result && (hasWhen() == other.hasWhen());
if (hasWhen()) {
result = result && getWhen()
.equals(other.getWhen());
}
result = result && (hasThen() == other.hasThen());
if (hasThen()) {
result = result && getThen()
.equals(other.getThen());
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
if (hasLabel()) {
hash = (37 * hash) + LABEL_FIELD_NUMBER;
hash = (53 * hash) + getLabel().hashCode();
}
if (hasWhen()) {
hash = (37 * hash) + WHEN_FIELD_NUMBER;
hash = (53 * hash) + getWhen().hashCode();
}
if (hasThen()) {
hash = (37 * hash) + THEN_FIELD_NUMBER;
hash = (53 * hash) + getThen().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutRule parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutRule parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutRule parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutRule parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutRule parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutRule parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutRule parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutRule parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutRule parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutRule parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.PutRule prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.PutRule}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.PutRule)
ai.grakn.rpc.generated.GrpcGrakn.PutRuleOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_PutRule_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_PutRule_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.PutRule.class, ai.grakn.rpc.generated.GrpcGrakn.PutRule.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.PutRule.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
if (labelBuilder_ == null) {
label_ = null;
} else {
label_ = null;
labelBuilder_ = null;
}
if (whenBuilder_ == null) {
when_ = null;
} else {
when_ = null;
whenBuilder_ = null;
}
if (thenBuilder_ == null) {
then_ = null;
} else {
then_ = null;
thenBuilder_ = null;
}
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_PutRule_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.PutRule getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.PutRule.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.PutRule build() {
ai.grakn.rpc.generated.GrpcGrakn.PutRule result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.PutRule buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.PutRule result = new ai.grakn.rpc.generated.GrpcGrakn.PutRule(this);
if (labelBuilder_ == null) {
result.label_ = label_;
} else {
result.label_ = labelBuilder_.build();
}
if (whenBuilder_ == null) {
result.when_ = when_;
} else {
result.when_ = whenBuilder_.build();
}
if (thenBuilder_ == null) {
result.then_ = then_;
} else {
result.then_ = thenBuilder_.build();
}
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.PutRule) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.PutRule)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.PutRule other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.PutRule.getDefaultInstance()) return this;
if (other.hasLabel()) {
mergeLabel(other.getLabel());
}
if (other.hasWhen()) {
mergeWhen(other.getWhen());
}
if (other.hasThen()) {
mergeThen(other.getThen());
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.PutRule parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.PutRule) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private ai.grakn.rpc.generated.GrpcConcept.Label label_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder> labelBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public boolean hasLabel() {
return labelBuilder_ != null || label_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label getLabel() {
if (labelBuilder_ == null) {
return label_ == null ? ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance() : label_;
} else {
return labelBuilder_.getMessage();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public Builder setLabel(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (labelBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
label_ = value;
onChanged();
} else {
labelBuilder_.setMessage(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public Builder setLabel(
ai.grakn.rpc.generated.GrpcConcept.Label.Builder builderForValue) {
if (labelBuilder_ == null) {
label_ = builderForValue.build();
onChanged();
} else {
labelBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public Builder mergeLabel(ai.grakn.rpc.generated.GrpcConcept.Label value) {
if (labelBuilder_ == null) {
if (label_ != null) {
label_ =
ai.grakn.rpc.generated.GrpcConcept.Label.newBuilder(label_).mergeFrom(value).buildPartial();
} else {
label_ = value;
}
onChanged();
} else {
labelBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public Builder clearLabel() {
if (labelBuilder_ == null) {
label_ = null;
onChanged();
} else {
label_ = null;
labelBuilder_ = null;
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Label.Builder getLabelBuilder() {
onChanged();
return getLabelFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder getLabelOrBuilder() {
if (labelBuilder_ != null) {
return labelBuilder_.getMessageOrBuilder();
} else {
return label_ == null ?
ai.grakn.rpc.generated.GrpcConcept.Label.getDefaultInstance() : label_;
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Label label = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>
getLabelFieldBuilder() {
if (labelBuilder_ == null) {
labelBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Label, ai.grakn.rpc.generated.GrpcConcept.Label.Builder, ai.grakn.rpc.generated.GrpcConcept.LabelOrBuilder>(
getLabel(),
getParentForChildren(),
isClean());
label_ = null;
}
return labelBuilder_;
}
private ai.grakn.rpc.generated.GrpcConcept.Pattern when_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Pattern, ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder, ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder> whenBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
public boolean hasWhen() {
return whenBuilder_ != null || when_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Pattern getWhen() {
if (whenBuilder_ == null) {
return when_ == null ? ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance() : when_;
} else {
return whenBuilder_.getMessage();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
public Builder setWhen(ai.grakn.rpc.generated.GrpcConcept.Pattern value) {
if (whenBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
when_ = value;
onChanged();
} else {
whenBuilder_.setMessage(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
public Builder setWhen(
ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder builderForValue) {
if (whenBuilder_ == null) {
when_ = builderForValue.build();
onChanged();
} else {
whenBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
public Builder mergeWhen(ai.grakn.rpc.generated.GrpcConcept.Pattern value) {
if (whenBuilder_ == null) {
if (when_ != null) {
when_ =
ai.grakn.rpc.generated.GrpcConcept.Pattern.newBuilder(when_).mergeFrom(value).buildPartial();
} else {
when_ = value;
}
onChanged();
} else {
whenBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
public Builder clearWhen() {
if (whenBuilder_ == null) {
when_ = null;
onChanged();
} else {
when_ = null;
whenBuilder_ = null;
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder getWhenBuilder() {
onChanged();
return getWhenFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder getWhenOrBuilder() {
if (whenBuilder_ != null) {
return whenBuilder_.getMessageOrBuilder();
} else {
return when_ == null ?
ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance() : when_;
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern when = 2;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Pattern, ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder, ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder>
getWhenFieldBuilder() {
if (whenBuilder_ == null) {
whenBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Pattern, ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder, ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder>(
getWhen(),
getParentForChildren(),
isClean());
when_ = null;
}
return whenBuilder_;
}
private ai.grakn.rpc.generated.GrpcConcept.Pattern then_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Pattern, ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder, ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder> thenBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
public boolean hasThen() {
return thenBuilder_ != null || then_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Pattern getThen() {
if (thenBuilder_ == null) {
return then_ == null ? ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance() : then_;
} else {
return thenBuilder_.getMessage();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
public Builder setThen(ai.grakn.rpc.generated.GrpcConcept.Pattern value) {
if (thenBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
then_ = value;
onChanged();
} else {
thenBuilder_.setMessage(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
public Builder setThen(
ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder builderForValue) {
if (thenBuilder_ == null) {
then_ = builderForValue.build();
onChanged();
} else {
thenBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
public Builder mergeThen(ai.grakn.rpc.generated.GrpcConcept.Pattern value) {
if (thenBuilder_ == null) {
if (then_ != null) {
then_ =
ai.grakn.rpc.generated.GrpcConcept.Pattern.newBuilder(then_).mergeFrom(value).buildPartial();
} else {
then_ = value;
}
onChanged();
} else {
thenBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
public Builder clearThen() {
if (thenBuilder_ == null) {
then_ = null;
onChanged();
} else {
then_ = null;
thenBuilder_ = null;
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder getThenBuilder() {
onChanged();
return getThenFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder getThenOrBuilder() {
if (thenBuilder_ != null) {
return thenBuilder_.getMessageOrBuilder();
} else {
return then_ == null ?
ai.grakn.rpc.generated.GrpcConcept.Pattern.getDefaultInstance() : then_;
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Pattern then = 3;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Pattern, ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder, ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder>
getThenFieldBuilder() {
if (thenBuilder_ == null) {
thenBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Pattern, ai.grakn.rpc.generated.GrpcConcept.Pattern.Builder, ai.grakn.rpc.generated.GrpcConcept.PatternOrBuilder>(
getThen(),
getParentForChildren(),
isClean());
then_ = null;
}
return thenBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.PutRule)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.PutRule)
private static final ai.grakn.rpc.generated.GrpcGrakn.PutRule DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.PutRule();
}
public static ai.grakn.rpc.generated.GrpcGrakn.PutRule getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<PutRule>
PARSER = new com.google.protobuf.AbstractParser<PutRule>() {
public PutRule parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new PutRule(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<PutRule> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<PutRule> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.PutRule getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface InferOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Infer)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional bool value = 1;</code>
*/
boolean getValue();
}
/**
* <pre>
*Toggle inference for this query.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Infer}
*/
public static final class Infer extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Infer)
InferOrBuilder {
// Use Infer.newBuilder() to construct.
private Infer(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Infer() {
value_ = false;
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Infer(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 8: {
value_ = input.readBool();
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Infer_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Infer_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Infer.class, ai.grakn.rpc.generated.GrpcGrakn.Infer.Builder.class);
}
public static final int VALUE_FIELD_NUMBER = 1;
private boolean value_;
/**
* <code>optional bool value = 1;</code>
*/
public boolean getValue() {
return value_;
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (value_ != false) {
output.writeBool(1, value_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (value_ != false) {
size += com.google.protobuf.CodedOutputStream
.computeBoolSize(1, value_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.Infer)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.Infer other = (ai.grakn.rpc.generated.GrpcGrakn.Infer) obj;
boolean result = true;
result = result && (getValue()
== other.getValue());
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
hash = (37 * hash) + VALUE_FIELD_NUMBER;
hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
getValue());
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.Infer parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Infer parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Infer parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Infer parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Infer parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Infer parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Infer parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Infer parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Infer parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Infer parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.Infer prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* <pre>
*Toggle inference for this query.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Infer}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Infer)
ai.grakn.rpc.generated.GrpcGrakn.InferOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Infer_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Infer_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Infer.class, ai.grakn.rpc.generated.GrpcGrakn.Infer.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.Infer.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
value_ = false;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Infer_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.Infer getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.Infer.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.Infer build() {
ai.grakn.rpc.generated.GrpcGrakn.Infer result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.Infer buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.Infer result = new ai.grakn.rpc.generated.GrpcGrakn.Infer(this);
result.value_ = value_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.Infer) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.Infer)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.Infer other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.Infer.getDefaultInstance()) return this;
if (other.getValue() != false) {
setValue(other.getValue());
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.Infer parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.Infer) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private boolean value_ ;
/**
* <code>optional bool value = 1;</code>
*/
public boolean getValue() {
return value_;
}
/**
* <code>optional bool value = 1;</code>
*/
public Builder setValue(boolean value) {
value_ = value;
onChanged();
return this;
}
/**
* <code>optional bool value = 1;</code>
*/
public Builder clearValue() {
value_ = false;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Infer)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Infer)
private static final ai.grakn.rpc.generated.GrpcGrakn.Infer DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.Infer();
}
public static ai.grakn.rpc.generated.GrpcGrakn.Infer getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Infer>
PARSER = new com.google.protobuf.AbstractParser<Infer>() {
public Infer parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Infer(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Infer> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Infer> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.Infer getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface TxResponseOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.TxResponse)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.QueryResult queryResult = 1;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.QueryResult getQueryResult();
/**
* <code>optional .ai.grakn.rpc.generated.QueryResult queryResult = 1;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.QueryResultOrBuilder getQueryResultOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.Done done = 2;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.Done getDone();
/**
* <code>optional .ai.grakn.rpc.generated.Done done = 2;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.DoneOrBuilder getDoneOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.ConceptResponse conceptResponse = 3;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptResponse getConceptResponse();
/**
* <code>optional .ai.grakn.rpc.generated.ConceptResponse conceptResponse = 3;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptResponseOrBuilder getConceptResponseOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 4;</code>
*/
ai.grakn.rpc.generated.GrpcIterator.IteratorId getIteratorId();
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 4;</code>
*/
ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder getIteratorIdOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 5;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getConcept();
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 5;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getConceptOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 6;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept getOptionalConcept();
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 6;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.OptionalConceptOrBuilder getOptionalConceptOrBuilder();
/**
* <code>optional .ai.grakn.rpc.generated.RolePlayer rolePlayer = 7;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.RolePlayer getRolePlayer();
/**
* <code>optional .ai.grakn.rpc.generated.RolePlayer rolePlayer = 7;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder getRolePlayerOrBuilder();
public ai.grakn.rpc.generated.GrpcGrakn.TxResponse.ResponseCase getResponseCase();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.TxResponse}
*/
public static final class TxResponse extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.TxResponse)
TxResponseOrBuilder {
// Use TxResponse.newBuilder() to construct.
private TxResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private TxResponse() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private TxResponse(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcGrakn.QueryResult.Builder subBuilder = null;
if (responseCase_ == 1) {
subBuilder = ((ai.grakn.rpc.generated.GrpcGrakn.QueryResult) response_).toBuilder();
}
response_ =
input.readMessage(ai.grakn.rpc.generated.GrpcGrakn.QueryResult.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.QueryResult) response_);
response_ = subBuilder.buildPartial();
}
responseCase_ = 1;
break;
}
case 18: {
ai.grakn.rpc.generated.GrpcGrakn.Done.Builder subBuilder = null;
if (responseCase_ == 2) {
subBuilder = ((ai.grakn.rpc.generated.GrpcGrakn.Done) response_).toBuilder();
}
response_ =
input.readMessage(ai.grakn.rpc.generated.GrpcGrakn.Done.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.Done) response_);
response_ = subBuilder.buildPartial();
}
responseCase_ = 2;
break;
}
case 26: {
ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.Builder subBuilder = null;
if (responseCase_ == 3) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.ConceptResponse) response_).toBuilder();
}
response_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.ConceptResponse) response_);
response_ = subBuilder.buildPartial();
}
responseCase_ = 3;
break;
}
case 34: {
ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder subBuilder = null;
if (responseCase_ == 4) {
subBuilder = ((ai.grakn.rpc.generated.GrpcIterator.IteratorId) response_).toBuilder();
}
response_ =
input.readMessage(ai.grakn.rpc.generated.GrpcIterator.IteratorId.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcIterator.IteratorId) response_);
response_ = subBuilder.buildPartial();
}
responseCase_ = 4;
break;
}
case 42: {
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder subBuilder = null;
if (responseCase_ == 5) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.Concept) response_).toBuilder();
}
response_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.Concept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.Concept) response_);
response_ = subBuilder.buildPartial();
}
responseCase_ = 5;
break;
}
case 50: {
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder subBuilder = null;
if (responseCase_ == 6) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) response_).toBuilder();
}
response_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) response_);
response_ = subBuilder.buildPartial();
}
responseCase_ = 6;
break;
}
case 58: {
ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder subBuilder = null;
if (responseCase_ == 7) {
subBuilder = ((ai.grakn.rpc.generated.GrpcConcept.RolePlayer) response_).toBuilder();
}
response_ =
input.readMessage(ai.grakn.rpc.generated.GrpcConcept.RolePlayer.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcConcept.RolePlayer) response_);
response_ = subBuilder.buildPartial();
}
responseCase_ = 7;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_TxResponse_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_TxResponse_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.TxResponse.class, ai.grakn.rpc.generated.GrpcGrakn.TxResponse.Builder.class);
}
private int responseCase_ = 0;
private java.lang.Object response_;
public enum ResponseCase
implements com.google.protobuf.Internal.EnumLite {
QUERYRESULT(1),
DONE(2),
CONCEPTRESPONSE(3),
ITERATORID(4),
CONCEPT(5),
OPTIONALCONCEPT(6),
ROLEPLAYER(7),
RESPONSE_NOT_SET(0);
private final int value;
private ResponseCase(int value) {
this.value = value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static ResponseCase valueOf(int value) {
return forNumber(value);
}
public static ResponseCase forNumber(int value) {
switch (value) {
case 1: return QUERYRESULT;
case 2: return DONE;
case 3: return CONCEPTRESPONSE;
case 4: return ITERATORID;
case 5: return CONCEPT;
case 6: return OPTIONALCONCEPT;
case 7: return ROLEPLAYER;
case 0: return RESPONSE_NOT_SET;
default: return null;
}
}
public int getNumber() {
return this.value;
}
};
public ResponseCase
getResponseCase() {
return ResponseCase.forNumber(
responseCase_);
}
public static final int QUERYRESULT_FIELD_NUMBER = 1;
/**
* <code>optional .ai.grakn.rpc.generated.QueryResult queryResult = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.QueryResult getQueryResult() {
if (responseCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcGrakn.QueryResult) response_;
}
return ai.grakn.rpc.generated.GrpcGrakn.QueryResult.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.QueryResult queryResult = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.QueryResultOrBuilder getQueryResultOrBuilder() {
if (responseCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcGrakn.QueryResult) response_;
}
return ai.grakn.rpc.generated.GrpcGrakn.QueryResult.getDefaultInstance();
}
public static final int DONE_FIELD_NUMBER = 2;
/**
* <code>optional .ai.grakn.rpc.generated.Done done = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Done getDone() {
if (responseCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcGrakn.Done) response_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Done.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Done done = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.DoneOrBuilder getDoneOrBuilder() {
if (responseCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcGrakn.Done) response_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Done.getDefaultInstance();
}
public static final int CONCEPTRESPONSE_FIELD_NUMBER = 3;
/**
* <code>optional .ai.grakn.rpc.generated.ConceptResponse conceptResponse = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptResponse getConceptResponse() {
if (responseCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcConcept.ConceptResponse) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptResponse conceptResponse = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptResponseOrBuilder getConceptResponseOrBuilder() {
if (responseCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcConcept.ConceptResponse) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.getDefaultInstance();
}
public static final int ITERATORID_FIELD_NUMBER = 4;
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorId getIteratorId() {
if (responseCase_ == 4) {
return (ai.grakn.rpc.generated.GrpcIterator.IteratorId) response_;
}
return ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder getIteratorIdOrBuilder() {
if (responseCase_ == 4) {
return (ai.grakn.rpc.generated.GrpcIterator.IteratorId) response_;
}
return ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance();
}
public static final int CONCEPT_FIELD_NUMBER = 5;
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getConcept() {
if (responseCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getConceptOrBuilder() {
if (responseCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
public static final int OPTIONALCONCEPT_FIELD_NUMBER = 6;
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalConcept getOptionalConcept() {
if (responseCase_ == 6) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalConceptOrBuilder getOptionalConceptOrBuilder() {
if (responseCase_ == 6) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance();
}
public static final int ROLEPLAYER_FIELD_NUMBER = 7;
/**
* <code>optional .ai.grakn.rpc.generated.RolePlayer rolePlayer = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer getRolePlayer() {
if (responseCase_ == 7) {
return (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.RolePlayer rolePlayer = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder getRolePlayerOrBuilder() {
if (responseCase_ == 7) {
return (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (responseCase_ == 1) {
output.writeMessage(1, (ai.grakn.rpc.generated.GrpcGrakn.QueryResult) response_);
}
if (responseCase_ == 2) {
output.writeMessage(2, (ai.grakn.rpc.generated.GrpcGrakn.Done) response_);
}
if (responseCase_ == 3) {
output.writeMessage(3, (ai.grakn.rpc.generated.GrpcConcept.ConceptResponse) response_);
}
if (responseCase_ == 4) {
output.writeMessage(4, (ai.grakn.rpc.generated.GrpcIterator.IteratorId) response_);
}
if (responseCase_ == 5) {
output.writeMessage(5, (ai.grakn.rpc.generated.GrpcConcept.Concept) response_);
}
if (responseCase_ == 6) {
output.writeMessage(6, (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) response_);
}
if (responseCase_ == 7) {
output.writeMessage(7, (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) response_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (responseCase_ == 1) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, (ai.grakn.rpc.generated.GrpcGrakn.QueryResult) response_);
}
if (responseCase_ == 2) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(2, (ai.grakn.rpc.generated.GrpcGrakn.Done) response_);
}
if (responseCase_ == 3) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(3, (ai.grakn.rpc.generated.GrpcConcept.ConceptResponse) response_);
}
if (responseCase_ == 4) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(4, (ai.grakn.rpc.generated.GrpcIterator.IteratorId) response_);
}
if (responseCase_ == 5) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(5, (ai.grakn.rpc.generated.GrpcConcept.Concept) response_);
}
if (responseCase_ == 6) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(6, (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) response_);
}
if (responseCase_ == 7) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(7, (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) response_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.TxResponse)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.TxResponse other = (ai.grakn.rpc.generated.GrpcGrakn.TxResponse) obj;
boolean result = true;
result = result && getResponseCase().equals(
other.getResponseCase());
if (!result) return false;
switch (responseCase_) {
case 1:
result = result && getQueryResult()
.equals(other.getQueryResult());
break;
case 2:
result = result && getDone()
.equals(other.getDone());
break;
case 3:
result = result && getConceptResponse()
.equals(other.getConceptResponse());
break;
case 4:
result = result && getIteratorId()
.equals(other.getIteratorId());
break;
case 5:
result = result && getConcept()
.equals(other.getConcept());
break;
case 6:
result = result && getOptionalConcept()
.equals(other.getOptionalConcept());
break;
case 7:
result = result && getRolePlayer()
.equals(other.getRolePlayer());
break;
case 0:
default:
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
switch (responseCase_) {
case 1:
hash = (37 * hash) + QUERYRESULT_FIELD_NUMBER;
hash = (53 * hash) + getQueryResult().hashCode();
break;
case 2:
hash = (37 * hash) + DONE_FIELD_NUMBER;
hash = (53 * hash) + getDone().hashCode();
break;
case 3:
hash = (37 * hash) + CONCEPTRESPONSE_FIELD_NUMBER;
hash = (53 * hash) + getConceptResponse().hashCode();
break;
case 4:
hash = (37 * hash) + ITERATORID_FIELD_NUMBER;
hash = (53 * hash) + getIteratorId().hashCode();
break;
case 5:
hash = (37 * hash) + CONCEPT_FIELD_NUMBER;
hash = (53 * hash) + getConcept().hashCode();
break;
case 6:
hash = (37 * hash) + OPTIONALCONCEPT_FIELD_NUMBER;
hash = (53 * hash) + getOptionalConcept().hashCode();
break;
case 7:
hash = (37 * hash) + ROLEPLAYER_FIELD_NUMBER;
hash = (53 * hash) + getRolePlayer().hashCode();
break;
case 0:
default:
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxResponse parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxResponse parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxResponse parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxResponse parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxResponse parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxResponse parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxResponse parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxResponse parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxResponse parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxResponse parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.TxResponse prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.TxResponse}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.TxResponse)
ai.grakn.rpc.generated.GrpcGrakn.TxResponseOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_TxResponse_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_TxResponse_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.TxResponse.class, ai.grakn.rpc.generated.GrpcGrakn.TxResponse.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.TxResponse.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
responseCase_ = 0;
response_ = null;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_TxResponse_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.TxResponse getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.TxResponse.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.TxResponse build() {
ai.grakn.rpc.generated.GrpcGrakn.TxResponse result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.TxResponse buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.TxResponse result = new ai.grakn.rpc.generated.GrpcGrakn.TxResponse(this);
if (responseCase_ == 1) {
if (queryResultBuilder_ == null) {
result.response_ = response_;
} else {
result.response_ = queryResultBuilder_.build();
}
}
if (responseCase_ == 2) {
if (doneBuilder_ == null) {
result.response_ = response_;
} else {
result.response_ = doneBuilder_.build();
}
}
if (responseCase_ == 3) {
if (conceptResponseBuilder_ == null) {
result.response_ = response_;
} else {
result.response_ = conceptResponseBuilder_.build();
}
}
if (responseCase_ == 4) {
if (iteratorIdBuilder_ == null) {
result.response_ = response_;
} else {
result.response_ = iteratorIdBuilder_.build();
}
}
if (responseCase_ == 5) {
if (conceptBuilder_ == null) {
result.response_ = response_;
} else {
result.response_ = conceptBuilder_.build();
}
}
if (responseCase_ == 6) {
if (optionalConceptBuilder_ == null) {
result.response_ = response_;
} else {
result.response_ = optionalConceptBuilder_.build();
}
}
if (responseCase_ == 7) {
if (rolePlayerBuilder_ == null) {
result.response_ = response_;
} else {
result.response_ = rolePlayerBuilder_.build();
}
}
result.responseCase_ = responseCase_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.TxResponse) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.TxResponse)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.TxResponse other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.TxResponse.getDefaultInstance()) return this;
switch (other.getResponseCase()) {
case QUERYRESULT: {
mergeQueryResult(other.getQueryResult());
break;
}
case DONE: {
mergeDone(other.getDone());
break;
}
case CONCEPTRESPONSE: {
mergeConceptResponse(other.getConceptResponse());
break;
}
case ITERATORID: {
mergeIteratorId(other.getIteratorId());
break;
}
case CONCEPT: {
mergeConcept(other.getConcept());
break;
}
case OPTIONALCONCEPT: {
mergeOptionalConcept(other.getOptionalConcept());
break;
}
case ROLEPLAYER: {
mergeRolePlayer(other.getRolePlayer());
break;
}
case RESPONSE_NOT_SET: {
break;
}
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.TxResponse parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.TxResponse) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int responseCase_ = 0;
private java.lang.Object response_;
public ResponseCase
getResponseCase() {
return ResponseCase.forNumber(
responseCase_);
}
public Builder clearResponse() {
responseCase_ = 0;
response_ = null;
onChanged();
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.QueryResult, ai.grakn.rpc.generated.GrpcGrakn.QueryResult.Builder, ai.grakn.rpc.generated.GrpcGrakn.QueryResultOrBuilder> queryResultBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.QueryResult queryResult = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.QueryResult getQueryResult() {
if (queryResultBuilder_ == null) {
if (responseCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcGrakn.QueryResult) response_;
}
return ai.grakn.rpc.generated.GrpcGrakn.QueryResult.getDefaultInstance();
} else {
if (responseCase_ == 1) {
return queryResultBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcGrakn.QueryResult.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.QueryResult queryResult = 1;</code>
*/
public Builder setQueryResult(ai.grakn.rpc.generated.GrpcGrakn.QueryResult value) {
if (queryResultBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
response_ = value;
onChanged();
} else {
queryResultBuilder_.setMessage(value);
}
responseCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.QueryResult queryResult = 1;</code>
*/
public Builder setQueryResult(
ai.grakn.rpc.generated.GrpcGrakn.QueryResult.Builder builderForValue) {
if (queryResultBuilder_ == null) {
response_ = builderForValue.build();
onChanged();
} else {
queryResultBuilder_.setMessage(builderForValue.build());
}
responseCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.QueryResult queryResult = 1;</code>
*/
public Builder mergeQueryResult(ai.grakn.rpc.generated.GrpcGrakn.QueryResult value) {
if (queryResultBuilder_ == null) {
if (responseCase_ == 1 &&
response_ != ai.grakn.rpc.generated.GrpcGrakn.QueryResult.getDefaultInstance()) {
response_ = ai.grakn.rpc.generated.GrpcGrakn.QueryResult.newBuilder((ai.grakn.rpc.generated.GrpcGrakn.QueryResult) response_)
.mergeFrom(value).buildPartial();
} else {
response_ = value;
}
onChanged();
} else {
if (responseCase_ == 1) {
queryResultBuilder_.mergeFrom(value);
}
queryResultBuilder_.setMessage(value);
}
responseCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.QueryResult queryResult = 1;</code>
*/
public Builder clearQueryResult() {
if (queryResultBuilder_ == null) {
if (responseCase_ == 1) {
responseCase_ = 0;
response_ = null;
onChanged();
}
} else {
if (responseCase_ == 1) {
responseCase_ = 0;
response_ = null;
}
queryResultBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.QueryResult queryResult = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.QueryResult.Builder getQueryResultBuilder() {
return getQueryResultFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.QueryResult queryResult = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.QueryResultOrBuilder getQueryResultOrBuilder() {
if ((responseCase_ == 1) && (queryResultBuilder_ != null)) {
return queryResultBuilder_.getMessageOrBuilder();
} else {
if (responseCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcGrakn.QueryResult) response_;
}
return ai.grakn.rpc.generated.GrpcGrakn.QueryResult.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.QueryResult queryResult = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.QueryResult, ai.grakn.rpc.generated.GrpcGrakn.QueryResult.Builder, ai.grakn.rpc.generated.GrpcGrakn.QueryResultOrBuilder>
getQueryResultFieldBuilder() {
if (queryResultBuilder_ == null) {
if (!(responseCase_ == 1)) {
response_ = ai.grakn.rpc.generated.GrpcGrakn.QueryResult.getDefaultInstance();
}
queryResultBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.QueryResult, ai.grakn.rpc.generated.GrpcGrakn.QueryResult.Builder, ai.grakn.rpc.generated.GrpcGrakn.QueryResultOrBuilder>(
(ai.grakn.rpc.generated.GrpcGrakn.QueryResult) response_,
getParentForChildren(),
isClean());
response_ = null;
}
responseCase_ = 1;
onChanged();;
return queryResultBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Done, ai.grakn.rpc.generated.GrpcGrakn.Done.Builder, ai.grakn.rpc.generated.GrpcGrakn.DoneOrBuilder> doneBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Done done = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Done getDone() {
if (doneBuilder_ == null) {
if (responseCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcGrakn.Done) response_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Done.getDefaultInstance();
} else {
if (responseCase_ == 2) {
return doneBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcGrakn.Done.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Done done = 2;</code>
*/
public Builder setDone(ai.grakn.rpc.generated.GrpcGrakn.Done value) {
if (doneBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
response_ = value;
onChanged();
} else {
doneBuilder_.setMessage(value);
}
responseCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Done done = 2;</code>
*/
public Builder setDone(
ai.grakn.rpc.generated.GrpcGrakn.Done.Builder builderForValue) {
if (doneBuilder_ == null) {
response_ = builderForValue.build();
onChanged();
} else {
doneBuilder_.setMessage(builderForValue.build());
}
responseCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Done done = 2;</code>
*/
public Builder mergeDone(ai.grakn.rpc.generated.GrpcGrakn.Done value) {
if (doneBuilder_ == null) {
if (responseCase_ == 2 &&
response_ != ai.grakn.rpc.generated.GrpcGrakn.Done.getDefaultInstance()) {
response_ = ai.grakn.rpc.generated.GrpcGrakn.Done.newBuilder((ai.grakn.rpc.generated.GrpcGrakn.Done) response_)
.mergeFrom(value).buildPartial();
} else {
response_ = value;
}
onChanged();
} else {
if (responseCase_ == 2) {
doneBuilder_.mergeFrom(value);
}
doneBuilder_.setMessage(value);
}
responseCase_ = 2;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Done done = 2;</code>
*/
public Builder clearDone() {
if (doneBuilder_ == null) {
if (responseCase_ == 2) {
responseCase_ = 0;
response_ = null;
onChanged();
}
} else {
if (responseCase_ == 2) {
responseCase_ = 0;
response_ = null;
}
doneBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Done done = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Done.Builder getDoneBuilder() {
return getDoneFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Done done = 2;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.DoneOrBuilder getDoneOrBuilder() {
if ((responseCase_ == 2) && (doneBuilder_ != null)) {
return doneBuilder_.getMessageOrBuilder();
} else {
if (responseCase_ == 2) {
return (ai.grakn.rpc.generated.GrpcGrakn.Done) response_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Done.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Done done = 2;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Done, ai.grakn.rpc.generated.GrpcGrakn.Done.Builder, ai.grakn.rpc.generated.GrpcGrakn.DoneOrBuilder>
getDoneFieldBuilder() {
if (doneBuilder_ == null) {
if (!(responseCase_ == 2)) {
response_ = ai.grakn.rpc.generated.GrpcGrakn.Done.getDefaultInstance();
}
doneBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Done, ai.grakn.rpc.generated.GrpcGrakn.Done.Builder, ai.grakn.rpc.generated.GrpcGrakn.DoneOrBuilder>(
(ai.grakn.rpc.generated.GrpcGrakn.Done) response_,
getParentForChildren(),
isClean());
response_ = null;
}
responseCase_ = 2;
onChanged();;
return doneBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptResponse, ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptResponseOrBuilder> conceptResponseBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.ConceptResponse conceptResponse = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptResponse getConceptResponse() {
if (conceptResponseBuilder_ == null) {
if (responseCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcConcept.ConceptResponse) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.getDefaultInstance();
} else {
if (responseCase_ == 3) {
return conceptResponseBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptResponse conceptResponse = 3;</code>
*/
public Builder setConceptResponse(ai.grakn.rpc.generated.GrpcConcept.ConceptResponse value) {
if (conceptResponseBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
response_ = value;
onChanged();
} else {
conceptResponseBuilder_.setMessage(value);
}
responseCase_ = 3;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptResponse conceptResponse = 3;</code>
*/
public Builder setConceptResponse(
ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.Builder builderForValue) {
if (conceptResponseBuilder_ == null) {
response_ = builderForValue.build();
onChanged();
} else {
conceptResponseBuilder_.setMessage(builderForValue.build());
}
responseCase_ = 3;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptResponse conceptResponse = 3;</code>
*/
public Builder mergeConceptResponse(ai.grakn.rpc.generated.GrpcConcept.ConceptResponse value) {
if (conceptResponseBuilder_ == null) {
if (responseCase_ == 3 &&
response_ != ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.getDefaultInstance()) {
response_ = ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.newBuilder((ai.grakn.rpc.generated.GrpcConcept.ConceptResponse) response_)
.mergeFrom(value).buildPartial();
} else {
response_ = value;
}
onChanged();
} else {
if (responseCase_ == 3) {
conceptResponseBuilder_.mergeFrom(value);
}
conceptResponseBuilder_.setMessage(value);
}
responseCase_ = 3;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptResponse conceptResponse = 3;</code>
*/
public Builder clearConceptResponse() {
if (conceptResponseBuilder_ == null) {
if (responseCase_ == 3) {
responseCase_ = 0;
response_ = null;
onChanged();
}
} else {
if (responseCase_ == 3) {
responseCase_ = 0;
response_ = null;
}
conceptResponseBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptResponse conceptResponse = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.Builder getConceptResponseBuilder() {
return getConceptResponseFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptResponse conceptResponse = 3;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptResponseOrBuilder getConceptResponseOrBuilder() {
if ((responseCase_ == 3) && (conceptResponseBuilder_ != null)) {
return conceptResponseBuilder_.getMessageOrBuilder();
} else {
if (responseCase_ == 3) {
return (ai.grakn.rpc.generated.GrpcConcept.ConceptResponse) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.ConceptResponse conceptResponse = 3;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptResponse, ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptResponseOrBuilder>
getConceptResponseFieldBuilder() {
if (conceptResponseBuilder_ == null) {
if (!(responseCase_ == 3)) {
response_ = ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.getDefaultInstance();
}
conceptResponseBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.ConceptResponse, ai.grakn.rpc.generated.GrpcConcept.ConceptResponse.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptResponseOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.ConceptResponse) response_,
getParentForChildren(),
isClean());
response_ = null;
}
responseCase_ = 3;
onChanged();;
return conceptResponseBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.IteratorId, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder, ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder> iteratorIdBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorId getIteratorId() {
if (iteratorIdBuilder_ == null) {
if (responseCase_ == 4) {
return (ai.grakn.rpc.generated.GrpcIterator.IteratorId) response_;
}
return ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance();
} else {
if (responseCase_ == 4) {
return iteratorIdBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 4;</code>
*/
public Builder setIteratorId(ai.grakn.rpc.generated.GrpcIterator.IteratorId value) {
if (iteratorIdBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
response_ = value;
onChanged();
} else {
iteratorIdBuilder_.setMessage(value);
}
responseCase_ = 4;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 4;</code>
*/
public Builder setIteratorId(
ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder builderForValue) {
if (iteratorIdBuilder_ == null) {
response_ = builderForValue.build();
onChanged();
} else {
iteratorIdBuilder_.setMessage(builderForValue.build());
}
responseCase_ = 4;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 4;</code>
*/
public Builder mergeIteratorId(ai.grakn.rpc.generated.GrpcIterator.IteratorId value) {
if (iteratorIdBuilder_ == null) {
if (responseCase_ == 4 &&
response_ != ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance()) {
response_ = ai.grakn.rpc.generated.GrpcIterator.IteratorId.newBuilder((ai.grakn.rpc.generated.GrpcIterator.IteratorId) response_)
.mergeFrom(value).buildPartial();
} else {
response_ = value;
}
onChanged();
} else {
if (responseCase_ == 4) {
iteratorIdBuilder_.mergeFrom(value);
}
iteratorIdBuilder_.setMessage(value);
}
responseCase_ = 4;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 4;</code>
*/
public Builder clearIteratorId() {
if (iteratorIdBuilder_ == null) {
if (responseCase_ == 4) {
responseCase_ = 0;
response_ = null;
onChanged();
}
} else {
if (responseCase_ == 4) {
responseCase_ = 0;
response_ = null;
}
iteratorIdBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder getIteratorIdBuilder() {
return getIteratorIdFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 4;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder getIteratorIdOrBuilder() {
if ((responseCase_ == 4) && (iteratorIdBuilder_ != null)) {
return iteratorIdBuilder_.getMessageOrBuilder();
} else {
if (responseCase_ == 4) {
return (ai.grakn.rpc.generated.GrpcIterator.IteratorId) response_;
}
return ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 4;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.IteratorId, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder, ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder>
getIteratorIdFieldBuilder() {
if (iteratorIdBuilder_ == null) {
if (!(responseCase_ == 4)) {
response_ = ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance();
}
iteratorIdBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.IteratorId, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder, ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder>(
(ai.grakn.rpc.generated.GrpcIterator.IteratorId) response_,
getParentForChildren(),
isClean());
response_ = null;
}
responseCase_ = 4;
onChanged();;
return iteratorIdBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder> conceptBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getConcept() {
if (conceptBuilder_ == null) {
if (responseCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
} else {
if (responseCase_ == 5) {
return conceptBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 5;</code>
*/
public Builder setConcept(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (conceptBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
response_ = value;
onChanged();
} else {
conceptBuilder_.setMessage(value);
}
responseCase_ = 5;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 5;</code>
*/
public Builder setConcept(
ai.grakn.rpc.generated.GrpcConcept.Concept.Builder builderForValue) {
if (conceptBuilder_ == null) {
response_ = builderForValue.build();
onChanged();
} else {
conceptBuilder_.setMessage(builderForValue.build());
}
responseCase_ = 5;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 5;</code>
*/
public Builder mergeConcept(ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (conceptBuilder_ == null) {
if (responseCase_ == 5 &&
response_ != ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance()) {
response_ = ai.grakn.rpc.generated.GrpcConcept.Concept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.Concept) response_)
.mergeFrom(value).buildPartial();
} else {
response_ = value;
}
onChanged();
} else {
if (responseCase_ == 5) {
conceptBuilder_.mergeFrom(value);
}
conceptBuilder_.setMessage(value);
}
responseCase_ = 5;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 5;</code>
*/
public Builder clearConcept() {
if (conceptBuilder_ == null) {
if (responseCase_ == 5) {
responseCase_ = 0;
response_ = null;
onChanged();
}
} else {
if (responseCase_ == 5) {
responseCase_ = 0;
response_ = null;
}
conceptBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept.Builder getConceptBuilder() {
return getConceptFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 5;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder getConceptOrBuilder() {
if ((responseCase_ == 5) && (conceptBuilder_ != null)) {
return conceptBuilder_.getMessageOrBuilder();
} else {
if (responseCase_ == 5) {
return (ai.grakn.rpc.generated.GrpcConcept.Concept) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Concept concept = 5;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>
getConceptFieldBuilder() {
if (conceptBuilder_ == null) {
if (!(responseCase_ == 5)) {
response_ = ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance();
}
conceptBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.Concept, ai.grakn.rpc.generated.GrpcConcept.Concept.Builder, ai.grakn.rpc.generated.GrpcConcept.ConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.Concept) response_,
getParentForChildren(),
isClean());
response_ = null;
}
responseCase_ = 5;
onChanged();;
return conceptBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept, ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalConceptOrBuilder> optionalConceptBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalConcept getOptionalConcept() {
if (optionalConceptBuilder_ == null) {
if (responseCase_ == 6) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance();
} else {
if (responseCase_ == 6) {
return optionalConceptBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 6;</code>
*/
public Builder setOptionalConcept(ai.grakn.rpc.generated.GrpcConcept.OptionalConcept value) {
if (optionalConceptBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
response_ = value;
onChanged();
} else {
optionalConceptBuilder_.setMessage(value);
}
responseCase_ = 6;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 6;</code>
*/
public Builder setOptionalConcept(
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder builderForValue) {
if (optionalConceptBuilder_ == null) {
response_ = builderForValue.build();
onChanged();
} else {
optionalConceptBuilder_.setMessage(builderForValue.build());
}
responseCase_ = 6;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 6;</code>
*/
public Builder mergeOptionalConcept(ai.grakn.rpc.generated.GrpcConcept.OptionalConcept value) {
if (optionalConceptBuilder_ == null) {
if (responseCase_ == 6 &&
response_ != ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance()) {
response_ = ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.newBuilder((ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) response_)
.mergeFrom(value).buildPartial();
} else {
response_ = value;
}
onChanged();
} else {
if (responseCase_ == 6) {
optionalConceptBuilder_.mergeFrom(value);
}
optionalConceptBuilder_.setMessage(value);
}
responseCase_ = 6;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 6;</code>
*/
public Builder clearOptionalConcept() {
if (optionalConceptBuilder_ == null) {
if (responseCase_ == 6) {
responseCase_ = 0;
response_ = null;
onChanged();
}
} else {
if (responseCase_ == 6) {
responseCase_ = 0;
response_ = null;
}
optionalConceptBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder getOptionalConceptBuilder() {
return getOptionalConceptFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 6;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.OptionalConceptOrBuilder getOptionalConceptOrBuilder() {
if ((responseCase_ == 6) && (optionalConceptBuilder_ != null)) {
return optionalConceptBuilder_.getMessageOrBuilder();
} else {
if (responseCase_ == 6) {
return (ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.OptionalConcept optionalConcept = 6;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept, ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalConceptOrBuilder>
getOptionalConceptFieldBuilder() {
if (optionalConceptBuilder_ == null) {
if (!(responseCase_ == 6)) {
response_ = ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.getDefaultInstance();
}
optionalConceptBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.OptionalConcept, ai.grakn.rpc.generated.GrpcConcept.OptionalConcept.Builder, ai.grakn.rpc.generated.GrpcConcept.OptionalConceptOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.OptionalConcept) response_,
getParentForChildren(),
isClean());
response_ = null;
}
responseCase_ = 6;
onChanged();;
return optionalConceptBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.RolePlayer, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder, ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder> rolePlayerBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.RolePlayer rolePlayer = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer getRolePlayer() {
if (rolePlayerBuilder_ == null) {
if (responseCase_ == 7) {
return (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
} else {
if (responseCase_ == 7) {
return rolePlayerBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.RolePlayer rolePlayer = 7;</code>
*/
public Builder setRolePlayer(ai.grakn.rpc.generated.GrpcConcept.RolePlayer value) {
if (rolePlayerBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
response_ = value;
onChanged();
} else {
rolePlayerBuilder_.setMessage(value);
}
responseCase_ = 7;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.RolePlayer rolePlayer = 7;</code>
*/
public Builder setRolePlayer(
ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder builderForValue) {
if (rolePlayerBuilder_ == null) {
response_ = builderForValue.build();
onChanged();
} else {
rolePlayerBuilder_.setMessage(builderForValue.build());
}
responseCase_ = 7;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.RolePlayer rolePlayer = 7;</code>
*/
public Builder mergeRolePlayer(ai.grakn.rpc.generated.GrpcConcept.RolePlayer value) {
if (rolePlayerBuilder_ == null) {
if (responseCase_ == 7 &&
response_ != ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance()) {
response_ = ai.grakn.rpc.generated.GrpcConcept.RolePlayer.newBuilder((ai.grakn.rpc.generated.GrpcConcept.RolePlayer) response_)
.mergeFrom(value).buildPartial();
} else {
response_ = value;
}
onChanged();
} else {
if (responseCase_ == 7) {
rolePlayerBuilder_.mergeFrom(value);
}
rolePlayerBuilder_.setMessage(value);
}
responseCase_ = 7;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.RolePlayer rolePlayer = 7;</code>
*/
public Builder clearRolePlayer() {
if (rolePlayerBuilder_ == null) {
if (responseCase_ == 7) {
responseCase_ = 0;
response_ = null;
onChanged();
}
} else {
if (responseCase_ == 7) {
responseCase_ = 0;
response_ = null;
}
rolePlayerBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.RolePlayer rolePlayer = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder getRolePlayerBuilder() {
return getRolePlayerFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.RolePlayer rolePlayer = 7;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder getRolePlayerOrBuilder() {
if ((responseCase_ == 7) && (rolePlayerBuilder_ != null)) {
return rolePlayerBuilder_.getMessageOrBuilder();
} else {
if (responseCase_ == 7) {
return (ai.grakn.rpc.generated.GrpcConcept.RolePlayer) response_;
}
return ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.RolePlayer rolePlayer = 7;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.RolePlayer, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder, ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder>
getRolePlayerFieldBuilder() {
if (rolePlayerBuilder_ == null) {
if (!(responseCase_ == 7)) {
response_ = ai.grakn.rpc.generated.GrpcConcept.RolePlayer.getDefaultInstance();
}
rolePlayerBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcConcept.RolePlayer, ai.grakn.rpc.generated.GrpcConcept.RolePlayer.Builder, ai.grakn.rpc.generated.GrpcConcept.RolePlayerOrBuilder>(
(ai.grakn.rpc.generated.GrpcConcept.RolePlayer) response_,
getParentForChildren(),
isClean());
response_ = null;
}
responseCase_ = 7;
onChanged();;
return rolePlayerBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.TxResponse)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.TxResponse)
private static final ai.grakn.rpc.generated.GrpcGrakn.TxResponse DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.TxResponse();
}
public static ai.grakn.rpc.generated.GrpcGrakn.TxResponse getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<TxResponse>
PARSER = new com.google.protobuf.AbstractParser<TxResponse>() {
public TxResponse parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new TxResponse(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<TxResponse> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<TxResponse> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.TxResponse getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface QueryResultOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.QueryResult)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.Answer answer = 1;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.Answer getAnswer();
/**
* <code>optional .ai.grakn.rpc.generated.Answer answer = 1;</code>
*/
ai.grakn.rpc.generated.GrpcGrakn.AnswerOrBuilder getAnswerOrBuilder();
/**
* <pre>
* This is used to represent `aggregate` and `compute` query results.
* These come in many different formats, so they are just returned
* as JSON strings.
* </pre>
*
* <code>optional string otherResult = 2;</code>
*/
java.lang.String getOtherResult();
/**
* <pre>
* This is used to represent `aggregate` and `compute` query results.
* These come in many different formats, so they are just returned
* as JSON strings.
* </pre>
*
* <code>optional string otherResult = 2;</code>
*/
com.google.protobuf.ByteString
getOtherResultBytes();
public ai.grakn.rpc.generated.GrpcGrakn.QueryResult.QueryResultCase getQueryResultCase();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.QueryResult}
*/
public static final class QueryResult extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.QueryResult)
QueryResultOrBuilder {
// Use QueryResult.newBuilder() to construct.
private QueryResult(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private QueryResult() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private QueryResult(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcGrakn.Answer.Builder subBuilder = null;
if (queryResultCase_ == 1) {
subBuilder = ((ai.grakn.rpc.generated.GrpcGrakn.Answer) queryResult_).toBuilder();
}
queryResult_ =
input.readMessage(ai.grakn.rpc.generated.GrpcGrakn.Answer.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.Answer) queryResult_);
queryResult_ = subBuilder.buildPartial();
}
queryResultCase_ = 1;
break;
}
case 18: {
java.lang.String s = input.readStringRequireUtf8();
queryResultCase_ = 2;
queryResult_ = s;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_QueryResult_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_QueryResult_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.QueryResult.class, ai.grakn.rpc.generated.GrpcGrakn.QueryResult.Builder.class);
}
private int queryResultCase_ = 0;
private java.lang.Object queryResult_;
public enum QueryResultCase
implements com.google.protobuf.Internal.EnumLite {
ANSWER(1),
OTHERRESULT(2),
QUERYRESULT_NOT_SET(0);
private final int value;
private QueryResultCase(int value) {
this.value = value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static QueryResultCase valueOf(int value) {
return forNumber(value);
}
public static QueryResultCase forNumber(int value) {
switch (value) {
case 1: return ANSWER;
case 2: return OTHERRESULT;
case 0: return QUERYRESULT_NOT_SET;
default: return null;
}
}
public int getNumber() {
return this.value;
}
};
public QueryResultCase
getQueryResultCase() {
return QueryResultCase.forNumber(
queryResultCase_);
}
public static final int ANSWER_FIELD_NUMBER = 1;
/**
* <code>optional .ai.grakn.rpc.generated.Answer answer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Answer getAnswer() {
if (queryResultCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcGrakn.Answer) queryResult_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Answer.getDefaultInstance();
}
/**
* <code>optional .ai.grakn.rpc.generated.Answer answer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.AnswerOrBuilder getAnswerOrBuilder() {
if (queryResultCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcGrakn.Answer) queryResult_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Answer.getDefaultInstance();
}
public static final int OTHERRESULT_FIELD_NUMBER = 2;
/**
* <pre>
* This is used to represent `aggregate` and `compute` query results.
* These come in many different formats, so they are just returned
* as JSON strings.
* </pre>
*
* <code>optional string otherResult = 2;</code>
*/
public java.lang.String getOtherResult() {
java.lang.Object ref = "";
if (queryResultCase_ == 2) {
ref = queryResult_;
}
if (ref instanceof java.lang.String) {
return (java.lang.String) ref;
} else {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
if (queryResultCase_ == 2) {
queryResult_ = s;
}
return s;
}
}
/**
* <pre>
* This is used to represent `aggregate` and `compute` query results.
* These come in many different formats, so they are just returned
* as JSON strings.
* </pre>
*
* <code>optional string otherResult = 2;</code>
*/
public com.google.protobuf.ByteString
getOtherResultBytes() {
java.lang.Object ref = "";
if (queryResultCase_ == 2) {
ref = queryResult_;
}
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
if (queryResultCase_ == 2) {
queryResult_ = b;
}
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (queryResultCase_ == 1) {
output.writeMessage(1, (ai.grakn.rpc.generated.GrpcGrakn.Answer) queryResult_);
}
if (queryResultCase_ == 2) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 2, queryResult_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (queryResultCase_ == 1) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, (ai.grakn.rpc.generated.GrpcGrakn.Answer) queryResult_);
}
if (queryResultCase_ == 2) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, queryResult_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.QueryResult)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.QueryResult other = (ai.grakn.rpc.generated.GrpcGrakn.QueryResult) obj;
boolean result = true;
result = result && getQueryResultCase().equals(
other.getQueryResultCase());
if (!result) return false;
switch (queryResultCase_) {
case 1:
result = result && getAnswer()
.equals(other.getAnswer());
break;
case 2:
result = result && getOtherResult()
.equals(other.getOtherResult());
break;
case 0:
default:
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
switch (queryResultCase_) {
case 1:
hash = (37 * hash) + ANSWER_FIELD_NUMBER;
hash = (53 * hash) + getAnswer().hashCode();
break;
case 2:
hash = (37 * hash) + OTHERRESULT_FIELD_NUMBER;
hash = (53 * hash) + getOtherResult().hashCode();
break;
case 0:
default:
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.QueryResult parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.QueryResult parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.QueryResult parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.QueryResult parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.QueryResult parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.QueryResult parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.QueryResult parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.QueryResult parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.QueryResult parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.QueryResult parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.QueryResult prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.QueryResult}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.QueryResult)
ai.grakn.rpc.generated.GrpcGrakn.QueryResultOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_QueryResult_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_QueryResult_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.QueryResult.class, ai.grakn.rpc.generated.GrpcGrakn.QueryResult.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.QueryResult.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
queryResultCase_ = 0;
queryResult_ = null;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_QueryResult_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.QueryResult getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.QueryResult.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.QueryResult build() {
ai.grakn.rpc.generated.GrpcGrakn.QueryResult result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.QueryResult buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.QueryResult result = new ai.grakn.rpc.generated.GrpcGrakn.QueryResult(this);
if (queryResultCase_ == 1) {
if (answerBuilder_ == null) {
result.queryResult_ = queryResult_;
} else {
result.queryResult_ = answerBuilder_.build();
}
}
if (queryResultCase_ == 2) {
result.queryResult_ = queryResult_;
}
result.queryResultCase_ = queryResultCase_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.QueryResult) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.QueryResult)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.QueryResult other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.QueryResult.getDefaultInstance()) return this;
switch (other.getQueryResultCase()) {
case ANSWER: {
mergeAnswer(other.getAnswer());
break;
}
case OTHERRESULT: {
queryResultCase_ = 2;
queryResult_ = other.queryResult_;
onChanged();
break;
}
case QUERYRESULT_NOT_SET: {
break;
}
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.QueryResult parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.QueryResult) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int queryResultCase_ = 0;
private java.lang.Object queryResult_;
public QueryResultCase
getQueryResultCase() {
return QueryResultCase.forNumber(
queryResultCase_);
}
public Builder clearQueryResult() {
queryResultCase_ = 0;
queryResult_ = null;
onChanged();
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Answer, ai.grakn.rpc.generated.GrpcGrakn.Answer.Builder, ai.grakn.rpc.generated.GrpcGrakn.AnswerOrBuilder> answerBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.Answer answer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Answer getAnswer() {
if (answerBuilder_ == null) {
if (queryResultCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcGrakn.Answer) queryResult_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Answer.getDefaultInstance();
} else {
if (queryResultCase_ == 1) {
return answerBuilder_.getMessage();
}
return ai.grakn.rpc.generated.GrpcGrakn.Answer.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Answer answer = 1;</code>
*/
public Builder setAnswer(ai.grakn.rpc.generated.GrpcGrakn.Answer value) {
if (answerBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
queryResult_ = value;
onChanged();
} else {
answerBuilder_.setMessage(value);
}
queryResultCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Answer answer = 1;</code>
*/
public Builder setAnswer(
ai.grakn.rpc.generated.GrpcGrakn.Answer.Builder builderForValue) {
if (answerBuilder_ == null) {
queryResult_ = builderForValue.build();
onChanged();
} else {
answerBuilder_.setMessage(builderForValue.build());
}
queryResultCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Answer answer = 1;</code>
*/
public Builder mergeAnswer(ai.grakn.rpc.generated.GrpcGrakn.Answer value) {
if (answerBuilder_ == null) {
if (queryResultCase_ == 1 &&
queryResult_ != ai.grakn.rpc.generated.GrpcGrakn.Answer.getDefaultInstance()) {
queryResult_ = ai.grakn.rpc.generated.GrpcGrakn.Answer.newBuilder((ai.grakn.rpc.generated.GrpcGrakn.Answer) queryResult_)
.mergeFrom(value).buildPartial();
} else {
queryResult_ = value;
}
onChanged();
} else {
if (queryResultCase_ == 1) {
answerBuilder_.mergeFrom(value);
}
answerBuilder_.setMessage(value);
}
queryResultCase_ = 1;
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Answer answer = 1;</code>
*/
public Builder clearAnswer() {
if (answerBuilder_ == null) {
if (queryResultCase_ == 1) {
queryResultCase_ = 0;
queryResult_ = null;
onChanged();
}
} else {
if (queryResultCase_ == 1) {
queryResultCase_ = 0;
queryResult_ = null;
}
answerBuilder_.clear();
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.Answer answer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.Answer.Builder getAnswerBuilder() {
return getAnswerFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.Answer answer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcGrakn.AnswerOrBuilder getAnswerOrBuilder() {
if ((queryResultCase_ == 1) && (answerBuilder_ != null)) {
return answerBuilder_.getMessageOrBuilder();
} else {
if (queryResultCase_ == 1) {
return (ai.grakn.rpc.generated.GrpcGrakn.Answer) queryResult_;
}
return ai.grakn.rpc.generated.GrpcGrakn.Answer.getDefaultInstance();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.Answer answer = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Answer, ai.grakn.rpc.generated.GrpcGrakn.Answer.Builder, ai.grakn.rpc.generated.GrpcGrakn.AnswerOrBuilder>
getAnswerFieldBuilder() {
if (answerBuilder_ == null) {
if (!(queryResultCase_ == 1)) {
queryResult_ = ai.grakn.rpc.generated.GrpcGrakn.Answer.getDefaultInstance();
}
answerBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcGrakn.Answer, ai.grakn.rpc.generated.GrpcGrakn.Answer.Builder, ai.grakn.rpc.generated.GrpcGrakn.AnswerOrBuilder>(
(ai.grakn.rpc.generated.GrpcGrakn.Answer) queryResult_,
getParentForChildren(),
isClean());
queryResult_ = null;
}
queryResultCase_ = 1;
onChanged();;
return answerBuilder_;
}
/**
* <pre>
* This is used to represent `aggregate` and `compute` query results.
* These come in many different formats, so they are just returned
* as JSON strings.
* </pre>
*
* <code>optional string otherResult = 2;</code>
*/
public java.lang.String getOtherResult() {
java.lang.Object ref = "";
if (queryResultCase_ == 2) {
ref = queryResult_;
}
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
if (queryResultCase_ == 2) {
queryResult_ = s;
}
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <pre>
* This is used to represent `aggregate` and `compute` query results.
* These come in many different formats, so they are just returned
* as JSON strings.
* </pre>
*
* <code>optional string otherResult = 2;</code>
*/
public com.google.protobuf.ByteString
getOtherResultBytes() {
java.lang.Object ref = "";
if (queryResultCase_ == 2) {
ref = queryResult_;
}
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
if (queryResultCase_ == 2) {
queryResult_ = b;
}
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <pre>
* This is used to represent `aggregate` and `compute` query results.
* These come in many different formats, so they are just returned
* as JSON strings.
* </pre>
*
* <code>optional string otherResult = 2;</code>
*/
public Builder setOtherResult(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
queryResultCase_ = 2;
queryResult_ = value;
onChanged();
return this;
}
/**
* <pre>
* This is used to represent `aggregate` and `compute` query results.
* These come in many different formats, so they are just returned
* as JSON strings.
* </pre>
*
* <code>optional string otherResult = 2;</code>
*/
public Builder clearOtherResult() {
if (queryResultCase_ == 2) {
queryResultCase_ = 0;
queryResult_ = null;
onChanged();
}
return this;
}
/**
* <pre>
* This is used to represent `aggregate` and `compute` query results.
* These come in many different formats, so they are just returned
* as JSON strings.
* </pre>
*
* <code>optional string otherResult = 2;</code>
*/
public Builder setOtherResultBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
queryResultCase_ = 2;
queryResult_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.QueryResult)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.QueryResult)
private static final ai.grakn.rpc.generated.GrpcGrakn.QueryResult DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.QueryResult();
}
public static ai.grakn.rpc.generated.GrpcGrakn.QueryResult getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<QueryResult>
PARSER = new com.google.protobuf.AbstractParser<QueryResult>() {
public QueryResult parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new QueryResult(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<QueryResult> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<QueryResult> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.QueryResult getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface DoneOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Done)
com.google.protobuf.MessageOrBuilder {
}
/**
* <pre>
*Tells the client we have completed their command.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Done}
*/
public static final class Done extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Done)
DoneOrBuilder {
// Use Done.newBuilder() to construct.
private Done(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Done() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Done(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Done_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Done_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Done.class, ai.grakn.rpc.generated.GrpcGrakn.Done.Builder.class);
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.Done)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.Done other = (ai.grakn.rpc.generated.GrpcGrakn.Done) obj;
boolean result = true;
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.Done parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Done parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Done parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Done parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Done parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Done parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Done parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Done parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Done parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Done parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.Done prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* <pre>
*Tells the client we have completed their command.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Done}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Done)
ai.grakn.rpc.generated.GrpcGrakn.DoneOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Done_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Done_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Done.class, ai.grakn.rpc.generated.GrpcGrakn.Done.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.Done.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Done_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.Done getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.Done.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.Done build() {
ai.grakn.rpc.generated.GrpcGrakn.Done result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.Done buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.Done result = new ai.grakn.rpc.generated.GrpcGrakn.Done(this);
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.Done) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.Done)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.Done other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.Done.getDefaultInstance()) return this;
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.Done parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.Done) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Done)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Done)
private static final ai.grakn.rpc.generated.GrpcGrakn.Done DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.Done();
}
public static ai.grakn.rpc.generated.GrpcGrakn.Done getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Done>
PARSER = new com.google.protobuf.AbstractParser<Done>() {
public Done parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Done(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Done> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Done> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.Done getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface AnswerOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Answer)
com.google.protobuf.MessageOrBuilder {
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
int getAnswerCount();
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
boolean containsAnswer(
java.lang.String key);
/**
* Use {@link #getAnswerMap()} instead.
*/
@java.lang.Deprecated
java.util.Map<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept>
getAnswer();
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
java.util.Map<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept>
getAnswerMap();
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getAnswerOrDefault(
java.lang.String key,
ai.grakn.rpc.generated.GrpcConcept.Concept defaultValue);
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
ai.grakn.rpc.generated.GrpcConcept.Concept getAnswerOrThrow(
java.lang.String key);
}
/**
* <pre>
*Represents an answer to a `get`, `insert` or `define` query. e.g.
*```
*$x id V123; $y id V456;
*```
*is represented as:
*```
*Answer {
*"x": Concept { id: "V123" }
*"y": Concept { id: "V456" }
*}
*```
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Answer}
*/
public static final class Answer extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Answer)
AnswerOrBuilder {
// Use Answer.newBuilder() to construct.
private Answer(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Answer() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Answer(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
answer_ = com.google.protobuf.MapField.newMapField(
AnswerDefaultEntryHolder.defaultEntry);
mutable_bitField0_ |= 0x00000001;
}
com.google.protobuf.MapEntry<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept>
answer = input.readMessage(
AnswerDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry);
answer_.getMutableMap().put(answer.getKey(), answer.getValue());
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Answer_descriptor;
}
@SuppressWarnings({"rawtypes"})
protected com.google.protobuf.MapField internalGetMapField(
int number) {
switch (number) {
case 1:
return internalGetAnswer();
default:
throw new RuntimeException(
"Invalid map field number: " + number);
}
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Answer_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Answer.class, ai.grakn.rpc.generated.GrpcGrakn.Answer.Builder.class);
}
public static final int ANSWER_FIELD_NUMBER = 1;
private static final class AnswerDefaultEntryHolder {
static final com.google.protobuf.MapEntry<
java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> defaultEntry =
com.google.protobuf.MapEntry
.<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept>newDefaultInstance(
ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Answer_AnswerEntry_descriptor,
com.google.protobuf.WireFormat.FieldType.STRING,
"",
com.google.protobuf.WireFormat.FieldType.MESSAGE,
ai.grakn.rpc.generated.GrpcConcept.Concept.getDefaultInstance());
}
private com.google.protobuf.MapField<
java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> answer_;
private com.google.protobuf.MapField<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept>
internalGetAnswer() {
if (answer_ == null) {
return com.google.protobuf.MapField.emptyMapField(
AnswerDefaultEntryHolder.defaultEntry);
}
return answer_;
}
public int getAnswerCount() {
return internalGetAnswer().getMap().size();
}
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
public boolean containsAnswer(
java.lang.String key) {
if (key == null) { throw new java.lang.NullPointerException(); }
return internalGetAnswer().getMap().containsKey(key);
}
/**
* Use {@link #getAnswerMap()} instead.
*/
@java.lang.Deprecated
public java.util.Map<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> getAnswer() {
return getAnswerMap();
}
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
public java.util.Map<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> getAnswerMap() {
return internalGetAnswer().getMap();
}
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getAnswerOrDefault(
java.lang.String key,
ai.grakn.rpc.generated.GrpcConcept.Concept defaultValue) {
if (key == null) { throw new java.lang.NullPointerException(); }
java.util.Map<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> map =
internalGetAnswer().getMap();
return map.containsKey(key) ? map.get(key) : defaultValue;
}
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getAnswerOrThrow(
java.lang.String key) {
if (key == null) { throw new java.lang.NullPointerException(); }
java.util.Map<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> map =
internalGetAnswer().getMap();
if (!map.containsKey(key)) {
throw new java.lang.IllegalArgumentException();
}
return map.get(key);
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
for (java.util.Map.Entry<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> entry
: internalGetAnswer().getMap().entrySet()) {
com.google.protobuf.MapEntry<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept>
answer = AnswerDefaultEntryHolder.defaultEntry.newBuilderForType()
.setKey(entry.getKey())
.setValue(entry.getValue())
.build();
output.writeMessage(1, answer);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
for (java.util.Map.Entry<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> entry
: internalGetAnswer().getMap().entrySet()) {
com.google.protobuf.MapEntry<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept>
answer = AnswerDefaultEntryHolder.defaultEntry.newBuilderForType()
.setKey(entry.getKey())
.setValue(entry.getValue())
.build();
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, answer);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.Answer)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.Answer other = (ai.grakn.rpc.generated.GrpcGrakn.Answer) obj;
boolean result = true;
result = result && internalGetAnswer().equals(
other.internalGetAnswer());
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
if (!internalGetAnswer().getMap().isEmpty()) {
hash = (37 * hash) + ANSWER_FIELD_NUMBER;
hash = (53 * hash) + internalGetAnswer().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.Answer parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Answer parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Answer parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Answer parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Answer parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Answer parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Answer parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Answer parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Answer parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Answer parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.Answer prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* <pre>
*Represents an answer to a `get`, `insert` or `define` query. e.g.
*```
*$x id V123; $y id V456;
*```
*is represented as:
*```
*Answer {
*"x": Concept { id: "V123" }
*"y": Concept { id: "V456" }
*}
*```
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Answer}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Answer)
ai.grakn.rpc.generated.GrpcGrakn.AnswerOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Answer_descriptor;
}
@SuppressWarnings({"rawtypes"})
protected com.google.protobuf.MapField internalGetMapField(
int number) {
switch (number) {
case 1:
return internalGetAnswer();
default:
throw new RuntimeException(
"Invalid map field number: " + number);
}
}
@SuppressWarnings({"rawtypes"})
protected com.google.protobuf.MapField internalGetMutableMapField(
int number) {
switch (number) {
case 1:
return internalGetMutableAnswer();
default:
throw new RuntimeException(
"Invalid map field number: " + number);
}
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Answer_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Answer.class, ai.grakn.rpc.generated.GrpcGrakn.Answer.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.Answer.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
internalGetMutableAnswer().clear();
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Answer_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.Answer getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.Answer.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.Answer build() {
ai.grakn.rpc.generated.GrpcGrakn.Answer result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.Answer buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.Answer result = new ai.grakn.rpc.generated.GrpcGrakn.Answer(this);
int from_bitField0_ = bitField0_;
result.answer_ = internalGetAnswer();
result.answer_.makeImmutable();
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.Answer) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.Answer)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.Answer other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.Answer.getDefaultInstance()) return this;
internalGetMutableAnswer().mergeFrom(
other.internalGetAnswer());
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.Answer parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.Answer) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int bitField0_;
private com.google.protobuf.MapField<
java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> answer_;
private com.google.protobuf.MapField<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept>
internalGetAnswer() {
if (answer_ == null) {
return com.google.protobuf.MapField.emptyMapField(
AnswerDefaultEntryHolder.defaultEntry);
}
return answer_;
}
private com.google.protobuf.MapField<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept>
internalGetMutableAnswer() {
onChanged();;
if (answer_ == null) {
answer_ = com.google.protobuf.MapField.newMapField(
AnswerDefaultEntryHolder.defaultEntry);
}
if (!answer_.isMutable()) {
answer_ = answer_.copy();
}
return answer_;
}
public int getAnswerCount() {
return internalGetAnswer().getMap().size();
}
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
public boolean containsAnswer(
java.lang.String key) {
if (key == null) { throw new java.lang.NullPointerException(); }
return internalGetAnswer().getMap().containsKey(key);
}
/**
* Use {@link #getAnswerMap()} instead.
*/
@java.lang.Deprecated
public java.util.Map<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> getAnswer() {
return getAnswerMap();
}
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
public java.util.Map<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> getAnswerMap() {
return internalGetAnswer().getMap();
}
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getAnswerOrDefault(
java.lang.String key,
ai.grakn.rpc.generated.GrpcConcept.Concept defaultValue) {
if (key == null) { throw new java.lang.NullPointerException(); }
java.util.Map<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> map =
internalGetAnswer().getMap();
return map.containsKey(key) ? map.get(key) : defaultValue;
}
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcConcept.Concept getAnswerOrThrow(
java.lang.String key) {
if (key == null) { throw new java.lang.NullPointerException(); }
java.util.Map<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> map =
internalGetAnswer().getMap();
if (!map.containsKey(key)) {
throw new java.lang.IllegalArgumentException();
}
return map.get(key);
}
public Builder clearAnswer() {
getMutableAnswer().clear();
return this;
}
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
public Builder removeAnswer(
java.lang.String key) {
if (key == null) { throw new java.lang.NullPointerException(); }
getMutableAnswer().remove(key);
return this;
}
/**
* Use alternate mutation accessors instead.
*/
@java.lang.Deprecated
public java.util.Map<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept>
getMutableAnswer() {
return internalGetMutableAnswer().getMutableMap();
}
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
public Builder putAnswer(
java.lang.String key,
ai.grakn.rpc.generated.GrpcConcept.Concept value) {
if (key == null) { throw new java.lang.NullPointerException(); }
if (value == null) { throw new java.lang.NullPointerException(); }
getMutableAnswer().put(key, value);
return this;
}
/**
* <code>map<string, .ai.grakn.rpc.generated.Concept> answer = 1;</code>
*/
public Builder putAllAnswer(
java.util.Map<java.lang.String, ai.grakn.rpc.generated.GrpcConcept.Concept> values) {
getMutableAnswer().putAll(values);
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Answer)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Answer)
private static final ai.grakn.rpc.generated.GrpcGrakn.Answer DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.Answer();
}
public static ai.grakn.rpc.generated.GrpcGrakn.Answer getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Answer>
PARSER = new com.google.protobuf.AbstractParser<Answer>() {
public Answer parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Answer(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Answer> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Answer> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.Answer getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface KeyspaceOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Keyspace)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional string value = 1;</code>
*/
java.lang.String getValue();
/**
* <code>optional string value = 1;</code>
*/
com.google.protobuf.ByteString
getValueBytes();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.Keyspace}
*/
public static final class Keyspace extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Keyspace)
KeyspaceOrBuilder {
// Use Keyspace.newBuilder() to construct.
private Keyspace(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Keyspace() {
value_ = "";
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Keyspace(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
value_ = s;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Keyspace_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Keyspace_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Keyspace.class, ai.grakn.rpc.generated.GrpcGrakn.Keyspace.Builder.class);
}
public static final int VALUE_FIELD_NUMBER = 1;
private volatile java.lang.Object value_;
/**
* <code>optional string value = 1;</code>
*/
public java.lang.String getValue() {
java.lang.Object ref = value_;
if (ref instanceof java.lang.String) {
return (java.lang.String) ref;
} else {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
value_ = s;
return s;
}
}
/**
* <code>optional string value = 1;</code>
*/
public com.google.protobuf.ByteString
getValueBytes() {
java.lang.Object ref = value_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
value_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (!getValueBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, value_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (!getValueBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, value_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.Keyspace)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.Keyspace other = (ai.grakn.rpc.generated.GrpcGrakn.Keyspace) obj;
boolean result = true;
result = result && getValue()
.equals(other.getValue());
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
hash = (37 * hash) + VALUE_FIELD_NUMBER;
hash = (53 * hash) + getValue().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.Keyspace parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Keyspace parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Keyspace parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Keyspace parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Keyspace parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Keyspace parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Keyspace parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Keyspace parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Keyspace parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Keyspace parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.Keyspace prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.Keyspace}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Keyspace)
ai.grakn.rpc.generated.GrpcGrakn.KeyspaceOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Keyspace_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Keyspace_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Keyspace.class, ai.grakn.rpc.generated.GrpcGrakn.Keyspace.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.Keyspace.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
value_ = "";
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Keyspace_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.Keyspace getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.Keyspace.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.Keyspace build() {
ai.grakn.rpc.generated.GrpcGrakn.Keyspace result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.Keyspace buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.Keyspace result = new ai.grakn.rpc.generated.GrpcGrakn.Keyspace(this);
result.value_ = value_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.Keyspace) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.Keyspace)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.Keyspace other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.Keyspace.getDefaultInstance()) return this;
if (!other.getValue().isEmpty()) {
value_ = other.value_;
onChanged();
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.Keyspace parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.Keyspace) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private java.lang.Object value_ = "";
/**
* <code>optional string value = 1;</code>
*/
public java.lang.String getValue() {
java.lang.Object ref = value_;
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
value_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <code>optional string value = 1;</code>
*/
public com.google.protobuf.ByteString
getValueBytes() {
java.lang.Object ref = value_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
value_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <code>optional string value = 1;</code>
*/
public Builder setValue(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
return this;
}
/**
* <code>optional string value = 1;</code>
*/
public Builder clearValue() {
value_ = getDefaultInstance().getValue();
onChanged();
return this;
}
/**
* <code>optional string value = 1;</code>
*/
public Builder setValueBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
value_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Keyspace)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Keyspace)
private static final ai.grakn.rpc.generated.GrpcGrakn.Keyspace DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.Keyspace();
}
public static ai.grakn.rpc.generated.GrpcGrakn.Keyspace getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Keyspace>
PARSER = new com.google.protobuf.AbstractParser<Keyspace>() {
public Keyspace parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Keyspace(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Keyspace> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Keyspace> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.Keyspace getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface QueryOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Query)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional string value = 1;</code>
*/
java.lang.String getValue();
/**
* <code>optional string value = 1;</code>
*/
com.google.protobuf.ByteString
getValueBytes();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.Query}
*/
public static final class Query extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Query)
QueryOrBuilder {
// Use Query.newBuilder() to construct.
private Query(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Query() {
value_ = "";
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Query(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
value_ = s;
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Query_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Query_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Query.class, ai.grakn.rpc.generated.GrpcGrakn.Query.Builder.class);
}
public static final int VALUE_FIELD_NUMBER = 1;
private volatile java.lang.Object value_;
/**
* <code>optional string value = 1;</code>
*/
public java.lang.String getValue() {
java.lang.Object ref = value_;
if (ref instanceof java.lang.String) {
return (java.lang.String) ref;
} else {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
value_ = s;
return s;
}
}
/**
* <code>optional string value = 1;</code>
*/
public com.google.protobuf.ByteString
getValueBytes() {
java.lang.Object ref = value_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
value_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (!getValueBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, value_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (!getValueBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, value_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcGrakn.Query)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcGrakn.Query other = (ai.grakn.rpc.generated.GrpcGrakn.Query) obj;
boolean result = true;
result = result && getValue()
.equals(other.getValue());
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
hash = (37 * hash) + VALUE_FIELD_NUMBER;
hash = (53 * hash) + getValue().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcGrakn.Query parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Query parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Query parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Query parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Query parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Query parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Query parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Query parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Query parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcGrakn.Query parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcGrakn.Query prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.Query}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Query)
ai.grakn.rpc.generated.GrpcGrakn.QueryOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Query_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Query_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcGrakn.Query.class, ai.grakn.rpc.generated.GrpcGrakn.Query.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcGrakn.Query.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
value_ = "";
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcGrakn.internal_static_ai_grakn_rpc_generated_Query_descriptor;
}
public ai.grakn.rpc.generated.GrpcGrakn.Query getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcGrakn.Query.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcGrakn.Query build() {
ai.grakn.rpc.generated.GrpcGrakn.Query result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcGrakn.Query buildPartial() {
ai.grakn.rpc.generated.GrpcGrakn.Query result = new ai.grakn.rpc.generated.GrpcGrakn.Query(this);
result.value_ = value_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcGrakn.Query) {
return mergeFrom((ai.grakn.rpc.generated.GrpcGrakn.Query)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcGrakn.Query other) {
if (other == ai.grakn.rpc.generated.GrpcGrakn.Query.getDefaultInstance()) return this;
if (!other.getValue().isEmpty()) {
value_ = other.value_;
onChanged();
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcGrakn.Query parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcGrakn.Query) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private java.lang.Object value_ = "";
/**
* <code>optional string value = 1;</code>
*/
public java.lang.String getValue() {
java.lang.Object ref = value_;
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
value_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <code>optional string value = 1;</code>
*/
public com.google.protobuf.ByteString
getValueBytes() {
java.lang.Object ref = value_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
value_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <code>optional string value = 1;</code>
*/
public Builder setValue(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
value_ = value;
onChanged();
return this;
}
/**
* <code>optional string value = 1;</code>
*/
public Builder clearValue() {
value_ = getDefaultInstance().getValue();
onChanged();
return this;
}
/**
* <code>optional string value = 1;</code>
*/
public Builder setValueBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
value_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Query)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Query)
private static final ai.grakn.rpc.generated.GrpcGrakn.Query DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcGrakn.Query();
}
public static ai.grakn.rpc.generated.GrpcGrakn.Query getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Query>
PARSER = new com.google.protobuf.AbstractParser<Query>() {
public Query parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Query(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Query> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Query> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcGrakn.Query getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_TxRequest_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_TxRequest_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_DeleteRequest_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_DeleteRequest_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_DeleteResponse_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_DeleteResponse_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Open_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Open_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Commit_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Commit_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_ExecQuery_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_ExecQuery_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_RunConceptMethod_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_RunConceptMethod_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_PutAttributeType_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_PutAttributeType_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_PutRule_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_PutRule_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Infer_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Infer_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_TxResponse_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_TxResponse_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_QueryResult_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_QueryResult_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Done_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Done_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Answer_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Answer_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Answer_AnswerEntry_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Answer_AnswerEntry_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Keyspace_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Keyspace_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Query_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Query_fieldAccessorTable;
public static com.google.protobuf.Descriptors.FileDescriptor
getDescriptor() {
return descriptor;
}
private static com.google.protobuf.Descriptors.FileDescriptor
descriptor;
static {
java.lang.String[] descriptorData = {
"\n\013grakn.proto\022\026ai.grakn.rpc.generated\032\rc" +
"oncept.proto\032\016iterator.proto\"\256\006\n\tTxReque" +
"st\022,\n\004open\030\001 \001(\0132\034.ai.grakn.rpc.generate" +
"d.OpenH\000\0220\n\006commit\030\002 \001(\0132\036.ai.grakn.rpc." +
"generated.CommitH\000\0226\n\texecQuery\030\003 \001(\0132!." +
"ai.grakn.rpc.generated.ExecQueryH\000\022,\n\004ne" +
"xt\030\004 \001(\0132\034.ai.grakn.rpc.generated.NextH\000" +
"\022,\n\004stop\030\005 \001(\0132\034.ai.grakn.rpc.generated." +
"StopH\000\022D\n\020runConceptMethod\030\006 \001(\0132(.ai.gr" +
"akn.rpc.generated.RunConceptMethodH\000\0227\n\n",
"getConcept\030\007 \001(\0132!.ai.grakn.rpc.generate" +
"d.ConceptIdH\000\0229\n\020getSchemaConcept\030\010 \001(\0132" +
"\035.ai.grakn.rpc.generated.LabelH\000\022F\n\024getA" +
"ttributesByValue\030\t \001(\0132&.ai.grakn.rpc.ge" +
"nerated.AttributeValueH\000\0226\n\rputEntityTyp" +
"e\030\n \001(\0132\035.ai.grakn.rpc.generated.LabelH\000" +
"\022<\n\023putRelationshipType\030\013 \001(\0132\035.ai.grakn" +
".rpc.generated.LabelH\000\022D\n\020putAttributeTy" +
"pe\030\014 \001(\0132(.ai.grakn.rpc.generated.PutAtt" +
"ributeTypeH\000\0220\n\007putRole\030\r \001(\0132\035.ai.grakn",
".rpc.generated.LabelH\000\0222\n\007putRule\030\016 \001(\0132" +
"\037.ai.grakn.rpc.generated.PutRuleH\000B\t\n\007re" +
"quest\";\n\rDeleteRequest\022*\n\004open\030\001 \001(\0132\034.a" +
"i.grakn.rpc.generated.Open\"\020\n\016DeleteResp" +
"onse\"\216\001\n\004Open\0222\n\010keyspace\030\001 \001(\0132 .ai.gra" +
"kn.rpc.generated.Keyspace\022.\n\006txType\030\002 \001(" +
"\0162\036.ai.grakn.rpc.generated.TxType\022\020\n\010use" +
"rname\030\003 \001(\t\022\020\n\010password\030\004 \001(\t\"\010\n\006Commit\"" +
"g\n\tExecQuery\022,\n\005query\030\001 \001(\0132\035.ai.grakn.r" +
"pc.generated.Query\022,\n\005infer\030\002 \001(\0132\035.ai.g",
"rakn.rpc.generated.Infer\"\177\n\020RunConceptMe" +
"thod\022-\n\002id\030\001 \001(\0132!.ai.grakn.rpc.generate" +
"d.ConceptId\022<\n\rconceptMethod\030\002 \001(\0132%.ai." +
"grakn.rpc.generated.ConceptMethod\"t\n\020Put" +
"AttributeType\022,\n\005label\030\001 \001(\0132\035.ai.grakn." +
"rpc.generated.Label\0222\n\010dataType\030\002 \001(\0162 ." +
"ai.grakn.rpc.generated.DataType\"\225\001\n\007PutR" +
"ule\022,\n\005label\030\001 \001(\0132\035.ai.grakn.rpc.genera" +
"ted.Label\022-\n\004when\030\002 \001(\0132\037.ai.grakn.rpc.g" +
"enerated.Pattern\022-\n\004then\030\003 \001(\0132\037.ai.grak",
"n.rpc.generated.Pattern\"\026\n\005Infer\022\r\n\005valu" +
"e\030\001 \001(\010\"\262\003\n\nTxResponse\022:\n\013queryResult\030\001 " +
"\001(\0132#.ai.grakn.rpc.generated.QueryResult" +
"H\000\022,\n\004done\030\002 \001(\0132\034.ai.grakn.rpc.generate" +
"d.DoneH\000\022B\n\017conceptResponse\030\003 \001(\0132\'.ai.g" +
"rakn.rpc.generated.ConceptResponseH\000\0228\n\n" +
"iteratorId\030\004 \001(\0132\".ai.grakn.rpc.generate" +
"d.IteratorIdH\000\0222\n\007concept\030\005 \001(\0132\037.ai.gra" +
"kn.rpc.generated.ConceptH\000\022B\n\017optionalCo" +
"ncept\030\006 \001(\0132\'.ai.grakn.rpc.generated.Opt",
"ionalConceptH\000\0228\n\nrolePlayer\030\007 \001(\0132\".ai." +
"grakn.rpc.generated.RolePlayerH\000B\n\n\010resp" +
"onse\"e\n\013QueryResult\0220\n\006answer\030\001 \001(\0132\036.ai" +
".grakn.rpc.generated.AnswerH\000\022\025\n\013otherRe" +
"sult\030\002 \001(\tH\000B\r\n\013queryResult\"\006\n\004Done\"\224\001\n\006" +
"Answer\022:\n\006answer\030\001 \003(\0132*.ai.grakn.rpc.ge" +
"nerated.Answer.AnswerEntry\032N\n\013AnswerEntr" +
"y\022\013\n\003key\030\001 \001(\t\022.\n\005value\030\002 \001(\0132\037.ai.grakn" +
".rpc.generated.Concept:\0028\001\"\031\n\010Keyspace\022\r" +
"\n\005value\030\001 \001(\t\"\026\n\005Query\022\r\n\005value\030\001 \001(\t*(\n",
"\006TxType\022\010\n\004Read\020\000\022\t\n\005Write\020\001\022\t\n\005Batch\020\0022" +
"\261\001\n\005Grakn\022O\n\002Tx\022!.ai.grakn.rpc.generated" +
".TxRequest\032\".ai.grakn.rpc.generated.TxRe" +
"sponse(\0010\001\022W\n\006Delete\022%.ai.grakn.rpc.gene" +
"rated.DeleteRequest\032&.ai.grakn.rpc.gener" +
"ated.DeleteResponseB\013B\tGrpcGraknb\006proto3"
};
com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
new com.google.protobuf.Descriptors.FileDescriptor. InternalDescriptorAssigner() {
public com.google.protobuf.ExtensionRegistry assignDescriptors(
com.google.protobuf.Descriptors.FileDescriptor root) {
descriptor = root;
return null;
}
};
com.google.protobuf.Descriptors.FileDescriptor
.internalBuildGeneratedFileFrom(descriptorData,
new com.google.protobuf.Descriptors.FileDescriptor[] {
ai.grakn.rpc.generated.GrpcConcept.getDescriptor(),
ai.grakn.rpc.generated.GrpcIterator.getDescriptor(),
}, assigner);
internal_static_ai_grakn_rpc_generated_TxRequest_descriptor =
getDescriptor().getMessageTypes().get(0);
internal_static_ai_grakn_rpc_generated_TxRequest_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_TxRequest_descriptor,
new java.lang.String[] { "Open", "Commit", "ExecQuery", "Next", "Stop", "RunConceptMethod", "GetConcept", "GetSchemaConcept", "GetAttributesByValue", "PutEntityType", "PutRelationshipType", "PutAttributeType", "PutRole", "PutRule", "Request", });
internal_static_ai_grakn_rpc_generated_DeleteRequest_descriptor =
getDescriptor().getMessageTypes().get(1);
internal_static_ai_grakn_rpc_generated_DeleteRequest_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_DeleteRequest_descriptor,
new java.lang.String[] { "Open", });
internal_static_ai_grakn_rpc_generated_DeleteResponse_descriptor =
getDescriptor().getMessageTypes().get(2);
internal_static_ai_grakn_rpc_generated_DeleteResponse_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_DeleteResponse_descriptor,
new java.lang.String[] { });
internal_static_ai_grakn_rpc_generated_Open_descriptor =
getDescriptor().getMessageTypes().get(3);
internal_static_ai_grakn_rpc_generated_Open_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Open_descriptor,
new java.lang.String[] { "Keyspace", "TxType", "Username", "Password", });
internal_static_ai_grakn_rpc_generated_Commit_descriptor =
getDescriptor().getMessageTypes().get(4);
internal_static_ai_grakn_rpc_generated_Commit_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Commit_descriptor,
new java.lang.String[] { });
internal_static_ai_grakn_rpc_generated_ExecQuery_descriptor =
getDescriptor().getMessageTypes().get(5);
internal_static_ai_grakn_rpc_generated_ExecQuery_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_ExecQuery_descriptor,
new java.lang.String[] { "Query", "Infer", });
internal_static_ai_grakn_rpc_generated_RunConceptMethod_descriptor =
getDescriptor().getMessageTypes().get(6);
internal_static_ai_grakn_rpc_generated_RunConceptMethod_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_RunConceptMethod_descriptor,
new java.lang.String[] { "Id", "ConceptMethod", });
internal_static_ai_grakn_rpc_generated_PutAttributeType_descriptor =
getDescriptor().getMessageTypes().get(7);
internal_static_ai_grakn_rpc_generated_PutAttributeType_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_PutAttributeType_descriptor,
new java.lang.String[] { "Label", "DataType", });
internal_static_ai_grakn_rpc_generated_PutRule_descriptor =
getDescriptor().getMessageTypes().get(8);
internal_static_ai_grakn_rpc_generated_PutRule_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_PutRule_descriptor,
new java.lang.String[] { "Label", "When", "Then", });
internal_static_ai_grakn_rpc_generated_Infer_descriptor =
getDescriptor().getMessageTypes().get(9);
internal_static_ai_grakn_rpc_generated_Infer_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Infer_descriptor,
new java.lang.String[] { "Value", });
internal_static_ai_grakn_rpc_generated_TxResponse_descriptor =
getDescriptor().getMessageTypes().get(10);
internal_static_ai_grakn_rpc_generated_TxResponse_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_TxResponse_descriptor,
new java.lang.String[] { "QueryResult", "Done", "ConceptResponse", "IteratorId", "Concept", "OptionalConcept", "RolePlayer", "Response", });
internal_static_ai_grakn_rpc_generated_QueryResult_descriptor =
getDescriptor().getMessageTypes().get(11);
internal_static_ai_grakn_rpc_generated_QueryResult_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_QueryResult_descriptor,
new java.lang.String[] { "Answer", "OtherResult", "QueryResult", });
internal_static_ai_grakn_rpc_generated_Done_descriptor =
getDescriptor().getMessageTypes().get(12);
internal_static_ai_grakn_rpc_generated_Done_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Done_descriptor,
new java.lang.String[] { });
internal_static_ai_grakn_rpc_generated_Answer_descriptor =
getDescriptor().getMessageTypes().get(13);
internal_static_ai_grakn_rpc_generated_Answer_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Answer_descriptor,
new java.lang.String[] { "Answer", });
internal_static_ai_grakn_rpc_generated_Answer_AnswerEntry_descriptor =
internal_static_ai_grakn_rpc_generated_Answer_descriptor.getNestedTypes().get(0);
internal_static_ai_grakn_rpc_generated_Answer_AnswerEntry_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Answer_AnswerEntry_descriptor,
new java.lang.String[] { "Key", "Value", });
internal_static_ai_grakn_rpc_generated_Keyspace_descriptor =
getDescriptor().getMessageTypes().get(14);
internal_static_ai_grakn_rpc_generated_Keyspace_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Keyspace_descriptor,
new java.lang.String[] { "Value", });
internal_static_ai_grakn_rpc_generated_Query_descriptor =
getDescriptor().getMessageTypes().get(15);
internal_static_ai_grakn_rpc_generated_Query_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Query_descriptor,
new java.lang.String[] { "Value", });
ai.grakn.rpc.generated.GrpcConcept.getDescriptor();
ai.grakn.rpc.generated.GrpcIterator.getDescriptor();
}
// @@protoc_insertion_point(outer_class_scope)
}
|
0
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/rpc
|
java-sources/ai/grakn/grakn-grpc/1.2.0/ai/grakn/rpc/generated/GrpcIterator.java
|
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: iterator.proto
package ai.grakn.rpc.generated;
public final class GrpcIterator {
private GrpcIterator() {}
public static void registerAllExtensions(
com.google.protobuf.ExtensionRegistryLite registry) {
}
public static void registerAllExtensions(
com.google.protobuf.ExtensionRegistry registry) {
registerAllExtensions(
(com.google.protobuf.ExtensionRegistryLite) registry);
}
public interface NextOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Next)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
boolean hasIteratorId();
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
ai.grakn.rpc.generated.GrpcIterator.IteratorId getIteratorId();
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder getIteratorIdOrBuilder();
}
/**
* <pre>
*Request next query result.
*After this message, the server will send a `QueryResult` or a `Done` message and then accept a command message.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Next}
*/
public static final class Next extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Next)
NextOrBuilder {
// Use Next.newBuilder() to construct.
private Next(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Next() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Next(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder subBuilder = null;
if (iteratorId_ != null) {
subBuilder = iteratorId_.toBuilder();
}
iteratorId_ = input.readMessage(ai.grakn.rpc.generated.GrpcIterator.IteratorId.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(iteratorId_);
iteratorId_ = subBuilder.buildPartial();
}
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_Next_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_Next_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcIterator.Next.class, ai.grakn.rpc.generated.GrpcIterator.Next.Builder.class);
}
public static final int ITERATORID_FIELD_NUMBER = 1;
private ai.grakn.rpc.generated.GrpcIterator.IteratorId iteratorId_;
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public boolean hasIteratorId() {
return iteratorId_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorId getIteratorId() {
return iteratorId_ == null ? ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance() : iteratorId_;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder getIteratorIdOrBuilder() {
return getIteratorId();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (iteratorId_ != null) {
output.writeMessage(1, getIteratorId());
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (iteratorId_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, getIteratorId());
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcIterator.Next)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcIterator.Next other = (ai.grakn.rpc.generated.GrpcIterator.Next) obj;
boolean result = true;
result = result && (hasIteratorId() == other.hasIteratorId());
if (hasIteratorId()) {
result = result && getIteratorId()
.equals(other.getIteratorId());
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
if (hasIteratorId()) {
hash = (37 * hash) + ITERATORID_FIELD_NUMBER;
hash = (53 * hash) + getIteratorId().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcIterator.Next parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcIterator.Next parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcIterator.Next parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcIterator.Next parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcIterator.Next parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcIterator.Next parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcIterator.Next parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcIterator.Next parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcIterator.Next parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcIterator.Next parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcIterator.Next prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* <pre>
*Request next query result.
*After this message, the server will send a `QueryResult` or a `Done` message and then accept a command message.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Next}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Next)
ai.grakn.rpc.generated.GrpcIterator.NextOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_Next_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_Next_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcIterator.Next.class, ai.grakn.rpc.generated.GrpcIterator.Next.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcIterator.Next.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
if (iteratorIdBuilder_ == null) {
iteratorId_ = null;
} else {
iteratorId_ = null;
iteratorIdBuilder_ = null;
}
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_Next_descriptor;
}
public ai.grakn.rpc.generated.GrpcIterator.Next getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcIterator.Next.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcIterator.Next build() {
ai.grakn.rpc.generated.GrpcIterator.Next result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcIterator.Next buildPartial() {
ai.grakn.rpc.generated.GrpcIterator.Next result = new ai.grakn.rpc.generated.GrpcIterator.Next(this);
if (iteratorIdBuilder_ == null) {
result.iteratorId_ = iteratorId_;
} else {
result.iteratorId_ = iteratorIdBuilder_.build();
}
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcIterator.Next) {
return mergeFrom((ai.grakn.rpc.generated.GrpcIterator.Next)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcIterator.Next other) {
if (other == ai.grakn.rpc.generated.GrpcIterator.Next.getDefaultInstance()) return this;
if (other.hasIteratorId()) {
mergeIteratorId(other.getIteratorId());
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcIterator.Next parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcIterator.Next) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private ai.grakn.rpc.generated.GrpcIterator.IteratorId iteratorId_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.IteratorId, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder, ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder> iteratorIdBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public boolean hasIteratorId() {
return iteratorIdBuilder_ != null || iteratorId_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorId getIteratorId() {
if (iteratorIdBuilder_ == null) {
return iteratorId_ == null ? ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance() : iteratorId_;
} else {
return iteratorIdBuilder_.getMessage();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public Builder setIteratorId(ai.grakn.rpc.generated.GrpcIterator.IteratorId value) {
if (iteratorIdBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
iteratorId_ = value;
onChanged();
} else {
iteratorIdBuilder_.setMessage(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public Builder setIteratorId(
ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder builderForValue) {
if (iteratorIdBuilder_ == null) {
iteratorId_ = builderForValue.build();
onChanged();
} else {
iteratorIdBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public Builder mergeIteratorId(ai.grakn.rpc.generated.GrpcIterator.IteratorId value) {
if (iteratorIdBuilder_ == null) {
if (iteratorId_ != null) {
iteratorId_ =
ai.grakn.rpc.generated.GrpcIterator.IteratorId.newBuilder(iteratorId_).mergeFrom(value).buildPartial();
} else {
iteratorId_ = value;
}
onChanged();
} else {
iteratorIdBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public Builder clearIteratorId() {
if (iteratorIdBuilder_ == null) {
iteratorId_ = null;
onChanged();
} else {
iteratorId_ = null;
iteratorIdBuilder_ = null;
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder getIteratorIdBuilder() {
onChanged();
return getIteratorIdFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder getIteratorIdOrBuilder() {
if (iteratorIdBuilder_ != null) {
return iteratorIdBuilder_.getMessageOrBuilder();
} else {
return iteratorId_ == null ?
ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance() : iteratorId_;
}
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.IteratorId, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder, ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder>
getIteratorIdFieldBuilder() {
if (iteratorIdBuilder_ == null) {
iteratorIdBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.IteratorId, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder, ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder>(
getIteratorId(),
getParentForChildren(),
isClean());
iteratorId_ = null;
}
return iteratorIdBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Next)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Next)
private static final ai.grakn.rpc.generated.GrpcIterator.Next DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcIterator.Next();
}
public static ai.grakn.rpc.generated.GrpcIterator.Next getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Next>
PARSER = new com.google.protobuf.AbstractParser<Next>() {
public Next parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Next(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Next> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Next> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcIterator.Next getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface StopOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.Stop)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
boolean hasIteratorId();
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
ai.grakn.rpc.generated.GrpcIterator.IteratorId getIteratorId();
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder getIteratorIdOrBuilder();
}
/**
* <pre>
*Tell the server we have finished executing a query.
*After this message, the server will send a `Done` message and then accept a command message.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Stop}
*/
public static final class Stop extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.Stop)
StopOrBuilder {
// Use Stop.newBuilder() to construct.
private Stop(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Stop() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private Stop(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder subBuilder = null;
if (iteratorId_ != null) {
subBuilder = iteratorId_.toBuilder();
}
iteratorId_ = input.readMessage(ai.grakn.rpc.generated.GrpcIterator.IteratorId.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(iteratorId_);
iteratorId_ = subBuilder.buildPartial();
}
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_Stop_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_Stop_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcIterator.Stop.class, ai.grakn.rpc.generated.GrpcIterator.Stop.Builder.class);
}
public static final int ITERATORID_FIELD_NUMBER = 1;
private ai.grakn.rpc.generated.GrpcIterator.IteratorId iteratorId_;
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public boolean hasIteratorId() {
return iteratorId_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorId getIteratorId() {
return iteratorId_ == null ? ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance() : iteratorId_;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder getIteratorIdOrBuilder() {
return getIteratorId();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (iteratorId_ != null) {
output.writeMessage(1, getIteratorId());
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (iteratorId_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, getIteratorId());
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcIterator.Stop)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcIterator.Stop other = (ai.grakn.rpc.generated.GrpcIterator.Stop) obj;
boolean result = true;
result = result && (hasIteratorId() == other.hasIteratorId());
if (hasIteratorId()) {
result = result && getIteratorId()
.equals(other.getIteratorId());
}
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
if (hasIteratorId()) {
hash = (37 * hash) + ITERATORID_FIELD_NUMBER;
hash = (53 * hash) + getIteratorId().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcIterator.Stop parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcIterator.Stop parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcIterator.Stop parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcIterator.Stop parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcIterator.Stop parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcIterator.Stop parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcIterator.Stop parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcIterator.Stop parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcIterator.Stop parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcIterator.Stop parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcIterator.Stop prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* <pre>
*Tell the server we have finished executing a query.
*After this message, the server will send a `Done` message and then accept a command message.
* </pre>
*
* Protobuf type {@code ai.grakn.rpc.generated.Stop}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.Stop)
ai.grakn.rpc.generated.GrpcIterator.StopOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_Stop_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_Stop_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcIterator.Stop.class, ai.grakn.rpc.generated.GrpcIterator.Stop.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcIterator.Stop.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
if (iteratorIdBuilder_ == null) {
iteratorId_ = null;
} else {
iteratorId_ = null;
iteratorIdBuilder_ = null;
}
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_Stop_descriptor;
}
public ai.grakn.rpc.generated.GrpcIterator.Stop getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcIterator.Stop.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcIterator.Stop build() {
ai.grakn.rpc.generated.GrpcIterator.Stop result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcIterator.Stop buildPartial() {
ai.grakn.rpc.generated.GrpcIterator.Stop result = new ai.grakn.rpc.generated.GrpcIterator.Stop(this);
if (iteratorIdBuilder_ == null) {
result.iteratorId_ = iteratorId_;
} else {
result.iteratorId_ = iteratorIdBuilder_.build();
}
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcIterator.Stop) {
return mergeFrom((ai.grakn.rpc.generated.GrpcIterator.Stop)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcIterator.Stop other) {
if (other == ai.grakn.rpc.generated.GrpcIterator.Stop.getDefaultInstance()) return this;
if (other.hasIteratorId()) {
mergeIteratorId(other.getIteratorId());
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcIterator.Stop parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcIterator.Stop) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private ai.grakn.rpc.generated.GrpcIterator.IteratorId iteratorId_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.IteratorId, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder, ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder> iteratorIdBuilder_;
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public boolean hasIteratorId() {
return iteratorIdBuilder_ != null || iteratorId_ != null;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorId getIteratorId() {
if (iteratorIdBuilder_ == null) {
return iteratorId_ == null ? ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance() : iteratorId_;
} else {
return iteratorIdBuilder_.getMessage();
}
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public Builder setIteratorId(ai.grakn.rpc.generated.GrpcIterator.IteratorId value) {
if (iteratorIdBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
iteratorId_ = value;
onChanged();
} else {
iteratorIdBuilder_.setMessage(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public Builder setIteratorId(
ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder builderForValue) {
if (iteratorIdBuilder_ == null) {
iteratorId_ = builderForValue.build();
onChanged();
} else {
iteratorIdBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public Builder mergeIteratorId(ai.grakn.rpc.generated.GrpcIterator.IteratorId value) {
if (iteratorIdBuilder_ == null) {
if (iteratorId_ != null) {
iteratorId_ =
ai.grakn.rpc.generated.GrpcIterator.IteratorId.newBuilder(iteratorId_).mergeFrom(value).buildPartial();
} else {
iteratorId_ = value;
}
onChanged();
} else {
iteratorIdBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public Builder clearIteratorId() {
if (iteratorIdBuilder_ == null) {
iteratorId_ = null;
onChanged();
} else {
iteratorId_ = null;
iteratorIdBuilder_ = null;
}
return this;
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder getIteratorIdBuilder() {
onChanged();
return getIteratorIdFieldBuilder().getBuilder();
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
public ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder getIteratorIdOrBuilder() {
if (iteratorIdBuilder_ != null) {
return iteratorIdBuilder_.getMessageOrBuilder();
} else {
return iteratorId_ == null ?
ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance() : iteratorId_;
}
}
/**
* <code>optional .ai.grakn.rpc.generated.IteratorId iteratorId = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.IteratorId, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder, ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder>
getIteratorIdFieldBuilder() {
if (iteratorIdBuilder_ == null) {
iteratorIdBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.rpc.generated.GrpcIterator.IteratorId, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder, ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder>(
getIteratorId(),
getParentForChildren(),
isClean());
iteratorId_ = null;
}
return iteratorIdBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.Stop)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.Stop)
private static final ai.grakn.rpc.generated.GrpcIterator.Stop DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcIterator.Stop();
}
public static ai.grakn.rpc.generated.GrpcIterator.Stop getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Stop>
PARSER = new com.google.protobuf.AbstractParser<Stop>() {
public Stop parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Stop(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Stop> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Stop> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcIterator.Stop getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface IteratorIdOrBuilder extends
// @@protoc_insertion_point(interface_extends:ai.grakn.rpc.generated.IteratorId)
com.google.protobuf.MessageOrBuilder {
/**
* <code>optional int32 id = 1;</code>
*/
int getId();
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.IteratorId}
*/
public static final class IteratorId extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:ai.grakn.rpc.generated.IteratorId)
IteratorIdOrBuilder {
// Use IteratorId.newBuilder() to construct.
private IteratorId(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private IteratorId() {
id_ = 0;
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
}
private IteratorId(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!input.skipField(tag)) {
done = true;
}
break;
}
case 8: {
id_ = input.readInt32();
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_IteratorId_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_IteratorId_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcIterator.IteratorId.class, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder.class);
}
public static final int ID_FIELD_NUMBER = 1;
private int id_;
/**
* <code>optional int32 id = 1;</code>
*/
public int getId() {
return id_;
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (id_ != 0) {
output.writeInt32(1, id_);
}
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (id_ != 0) {
size += com.google.protobuf.CodedOutputStream
.computeInt32Size(1, id_);
}
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.rpc.generated.GrpcIterator.IteratorId)) {
return super.equals(obj);
}
ai.grakn.rpc.generated.GrpcIterator.IteratorId other = (ai.grakn.rpc.generated.GrpcIterator.IteratorId) obj;
boolean result = true;
result = result && (getId()
== other.getId());
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptorForType().hashCode();
hash = (37 * hash) + ID_FIELD_NUMBER;
hash = (53 * hash) + getId();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.rpc.generated.GrpcIterator.IteratorId parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcIterator.IteratorId parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcIterator.IteratorId parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.rpc.generated.GrpcIterator.IteratorId parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcIterator.IteratorId parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcIterator.IteratorId parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcIterator.IteratorId parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcIterator.IteratorId parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static ai.grakn.rpc.generated.GrpcIterator.IteratorId parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.rpc.generated.GrpcIterator.IteratorId parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(ai.grakn.rpc.generated.GrpcIterator.IteratorId prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* Protobuf type {@code ai.grakn.rpc.generated.IteratorId}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:ai.grakn.rpc.generated.IteratorId)
ai.grakn.rpc.generated.GrpcIterator.IteratorIdOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_IteratorId_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_IteratorId_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.rpc.generated.GrpcIterator.IteratorId.class, ai.grakn.rpc.generated.GrpcIterator.IteratorId.Builder.class);
}
// Construct using ai.grakn.rpc.generated.GrpcIterator.IteratorId.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
id_ = 0;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.rpc.generated.GrpcIterator.internal_static_ai_grakn_rpc_generated_IteratorId_descriptor;
}
public ai.grakn.rpc.generated.GrpcIterator.IteratorId getDefaultInstanceForType() {
return ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance();
}
public ai.grakn.rpc.generated.GrpcIterator.IteratorId build() {
ai.grakn.rpc.generated.GrpcIterator.IteratorId result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.rpc.generated.GrpcIterator.IteratorId buildPartial() {
ai.grakn.rpc.generated.GrpcIterator.IteratorId result = new ai.grakn.rpc.generated.GrpcIterator.IteratorId(this);
result.id_ = id_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.rpc.generated.GrpcIterator.IteratorId) {
return mergeFrom((ai.grakn.rpc.generated.GrpcIterator.IteratorId)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.rpc.generated.GrpcIterator.IteratorId other) {
if (other == ai.grakn.rpc.generated.GrpcIterator.IteratorId.getDefaultInstance()) return this;
if (other.getId() != 0) {
setId(other.getId());
}
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
ai.grakn.rpc.generated.GrpcIterator.IteratorId parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.rpc.generated.GrpcIterator.IteratorId) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int id_ ;
/**
* <code>optional int32 id = 1;</code>
*/
public int getId() {
return id_;
}
/**
* <code>optional int32 id = 1;</code>
*/
public Builder setId(int value) {
id_ = value;
onChanged();
return this;
}
/**
* <code>optional int32 id = 1;</code>
*/
public Builder clearId() {
id_ = 0;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return this;
}
// @@protoc_insertion_point(builder_scope:ai.grakn.rpc.generated.IteratorId)
}
// @@protoc_insertion_point(class_scope:ai.grakn.rpc.generated.IteratorId)
private static final ai.grakn.rpc.generated.GrpcIterator.IteratorId DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.rpc.generated.GrpcIterator.IteratorId();
}
public static ai.grakn.rpc.generated.GrpcIterator.IteratorId getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<IteratorId>
PARSER = new com.google.protobuf.AbstractParser<IteratorId>() {
public IteratorId parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new IteratorId(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<IteratorId> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<IteratorId> getParserForType() {
return PARSER;
}
public ai.grakn.rpc.generated.GrpcIterator.IteratorId getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Next_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Next_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_Stop_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_Stop_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_ai_grakn_rpc_generated_IteratorId_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_ai_grakn_rpc_generated_IteratorId_fieldAccessorTable;
public static com.google.protobuf.Descriptors.FileDescriptor
getDescriptor() {
return descriptor;
}
private static com.google.protobuf.Descriptors.FileDescriptor
descriptor;
static {
java.lang.String[] descriptorData = {
"\n\016iterator.proto\022\026ai.grakn.rpc.generated" +
"\">\n\004Next\0226\n\niteratorId\030\001 \001(\0132\".ai.grakn." +
"rpc.generated.IteratorId\">\n\004Stop\0226\n\niter" +
"atorId\030\001 \001(\0132\".ai.grakn.rpc.generated.It" +
"eratorId\"\030\n\nIteratorId\022\n\n\002id\030\001 \001(\005B\016B\014Gr" +
"pcIteratorb\006proto3"
};
com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
new com.google.protobuf.Descriptors.FileDescriptor. InternalDescriptorAssigner() {
public com.google.protobuf.ExtensionRegistry assignDescriptors(
com.google.protobuf.Descriptors.FileDescriptor root) {
descriptor = root;
return null;
}
};
com.google.protobuf.Descriptors.FileDescriptor
.internalBuildGeneratedFileFrom(descriptorData,
new com.google.protobuf.Descriptors.FileDescriptor[] {
}, assigner);
internal_static_ai_grakn_rpc_generated_Next_descriptor =
getDescriptor().getMessageTypes().get(0);
internal_static_ai_grakn_rpc_generated_Next_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Next_descriptor,
new java.lang.String[] { "IteratorId", });
internal_static_ai_grakn_rpc_generated_Stop_descriptor =
getDescriptor().getMessageTypes().get(1);
internal_static_ai_grakn_rpc_generated_Stop_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_Stop_descriptor,
new java.lang.String[] { "IteratorId", });
internal_static_ai_grakn_rpc_generated_IteratorId_descriptor =
getDescriptor().getMessageTypes().get(2);
internal_static_ai_grakn_rpc_generated_IteratorId_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_ai_grakn_rpc_generated_IteratorId_descriptor,
new java.lang.String[] { "Id", });
}
// @@protoc_insertion_point(outer_class_scope)
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/factory/EmbeddedGraknSession.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.factory;
import ai.grakn.GraknComputer;
import ai.grakn.GraknConfigKey;
import ai.grakn.GraknSession;
import ai.grakn.GraknTx;
import ai.grakn.GraknTxType;
import ai.grakn.Keyspace;
import ai.grakn.engine.GraknConfig;
import ai.grakn.exception.GraknTxOperationException;
import ai.grakn.kb.internal.EmbeddedGraknTx;
import ai.grakn.kb.internal.GraknTxTinker;
import ai.grakn.kb.internal.computer.GraknComputerImpl;
import ai.grakn.util.ErrorMessage;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.CheckReturnValue;
import javax.annotation.Nullable;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
/**
* Builds a {@link TxFactory}. This class facilitates the construction of {@link GraknTx} by determining which factory should be built.
* It does this by either defaulting to an in memory tx {@link GraknTxTinker} or by retrieving the factory definition from engine.
* The deployment of engine decides on the backend and this class will handle producing the correct graphs.
*
* @author Grakn Warriors
*/
public class EmbeddedGraknSession implements GraknSession {
private static final Logger LOG = LoggerFactory.getLogger(EmbeddedGraknSession.class);
private final Keyspace keyspace;
private final GraknConfig config;
private final TxFactory<?> txFactory;
private final TxFactory<?> computerTxFactory;
//References so we don't have to open a tx just to check the count of the transactions
private EmbeddedGraknTx<?> tx = null;
private EmbeddedGraknTx<?> txBatch = null;
//This map is needed to store in memory session - we need to cache them because in Tinker there i not concept of session o Tx
// everything is a graph, if we don't save the session/tx->graph somwhere, other threads won't be able to access the content in memory.
//Example:
// Thread A opens in memory session and loads data on keyspace K
// Thread B opens in memory session and expects to find data in keyspace K
// If the above is not true - some tests that are using Tinker profile will fail
private static final Map<String, EmbeddedGraknSession> inMemorySessions = new ConcurrentHashMap<>();
/**
* Instantiates {@link EmbeddedGraknSession}
*
* @param keyspace to which keyspace the session should be bound to
* @param config config to be used. If null is supplied, it will be created
*/
EmbeddedGraknSession(Keyspace keyspace, @Nullable GraknConfig config, TxFactoryBuilder txFactoryBuilder) {
Objects.requireNonNull(keyspace);
this.keyspace = keyspace;
this.config = config;
this.txFactory = txFactoryBuilder.getFactory(this, false);
this.computerTxFactory = txFactoryBuilder.getFactory(this, true);
}
/**
* Creates a {@link EmbeddedGraknSession} specific for internal use (within Engine),
* using provided Grakn configuration
*/
public static EmbeddedGraknSession createEngineSession(Keyspace keyspace, GraknConfig config, TxFactoryBuilder txFactoryBuilder) {
return new EmbeddedGraknSession(keyspace, config, txFactoryBuilder);
}
public static EmbeddedGraknSession createEngineSession(Keyspace keyspace, GraknConfig config) {
return new EmbeddedGraknSession(keyspace, config, GraknTxFactoryBuilder.getInstance());
}
public static EmbeddedGraknSession createEngineSession(Keyspace keyspace) {
return new EmbeddedGraknSession(keyspace, GraknConfig.create(), GraknTxFactoryBuilder.getInstance());
}
public static EmbeddedGraknSession inMemory(Keyspace keyspace) {
return inMemorySessions.computeIfAbsent(keyspace.getValue(), k -> createEngineSession(keyspace, getTxInMemoryConfig()));
}
public static EmbeddedGraknSession inMemory(String keyspace) {
return inMemory(Keyspace.of(keyspace));
}
/**
* Gets properties which let you build a toy in-memory {@link GraknTx}.
* This does not contact engine in any way and it can be run in an isolated manner
*
* @return the properties needed to build an in-memory {@link GraknTx}
*/
private static GraknConfig getTxInMemoryConfig() {
GraknConfig config = GraknConfig.empty();
config.setConfigProperty(GraknConfigKey.SHARDING_THRESHOLD, 100_000L);
config.setConfigProperty(GraknConfigKey.SESSION_CACHE_TIMEOUT_MS, 30_000);
config.setConfigProperty(GraknConfigKey.KB_MODE, GraknTxFactoryBuilder.IN_MEMORY);
config.setConfigProperty(GraknConfigKey.KB_ANALYTICS, GraknTxFactoryBuilder.IN_MEMORY);
return config;
}
@Override
public EmbeddedGraknTx transaction(GraknTxType transactionType) {
switch (transactionType) {
case READ:
case WRITE:
tx = txFactory.open(transactionType);
return tx;
case BATCH:
txBatch = txFactory.open(transactionType);
return txBatch;
default:
throw GraknTxOperationException.transactionInvalid(transactionType);
}
}
/**
* Get a new or existing GraknComputer.
*
* @return A new or existing Grakn graph computer
* @see GraknComputer
*/
@CheckReturnValue
public GraknComputer getGraphComputer() {
Graph graph = computerTxFactory.getTinkerPopGraph(false);
return new GraknComputerImpl(graph);
}
@Override
public void close() throws GraknTxOperationException {
int openTransactions = openTransactions(tx) + openTransactions(txBatch);
if (openTransactions > 0) {
LOG.warn(ErrorMessage.TXS_OPEN.getMessage(this.keyspace, openTransactions));
}
if (tx != null) tx.closeSession();
if (txBatch != null) txBatch.closeSession();
}
@Override
public Keyspace keyspace() {
return keyspace;
}
/**
* The config options of this {@link GraknSession} which were passed in at the time of construction
*
* @return The config options of this {@link GraknSession}
*/
public GraknConfig config() {
return config;
}
private int openTransactions(EmbeddedGraknTx<?> graph) {
if (graph == null) return 0;
return graph.numOpenTx();
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/factory/GraknTxFactoryBuilder.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.factory;
import ai.grakn.GraknConfigKey;
import ai.grakn.util.ErrorMessage;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableMap;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.concurrent.ConcurrentHashMap;
/**
*
* {@link TxFactoryBuilder} implementation used in Grakn core.
*
* The factories in this class are cached based on factoryType+keyspace
*
* @author Marco Scoppetta
*/
public class GraknTxFactoryBuilder extends TxFactoryBuilder {
private static final Map<String, TxFactory<?>> openFactories = new ConcurrentHashMap<>();
//This is used to map grakn value properties into the underlying properties
private static final Map<String, String> factoryMapper = ImmutableMap.of(
"in-memory", "ai.grakn.factory.TxFactoryTinker",
"production", "ai.grakn.factory.TxFactoryJanus",
"distributed", "ai.grakn.factory.TxFactoryJanusHadoop");
private static TxFactoryBuilder instance = null;
private GraknTxFactoryBuilder() {
}
synchronized public static TxFactoryBuilder getInstance() {
if (instance == null) {
instance = new GraknTxFactoryBuilder();
}
return instance;
}
public TxFactory<?> getFactory(EmbeddedGraknSession session, boolean isComputerFactory) {
try {
String factoryKey = session.config().getProperty(GraknConfigKey.KB_MODE);
if (isComputerFactory) {
factoryKey = session.config().getProperty(GraknConfigKey.KB_ANALYTICS);
}
String factoryType = factoryMapper.get(factoryKey);
return getFactory(factoryType, session);
} catch (MissingResourceException e) {
throw new IllegalArgumentException(ErrorMessage.MISSING_FACTORY_DEFINITION.getMessage());
}
}
/**
* @param factoryType The string defining which factory should be used for creating the grakn graph.
* A valid example includes: ai.grakn.factory.TxFactoryTinker
* @return A graph factory which produces the relevant expected graph.
*/
private static TxFactory<?> getFactory(String factoryType, EmbeddedGraknSession session) {
String key = factoryType + session.keyspace();
return openFactories.computeIfAbsent(key, (k) -> newFactory(factoryType, session));
}
/**
* Clears all connections.
*/
//TODO Should this close each of the factories (and wait for all open transactions to be closed?)
//TODO Calling this from within the code causes a memory leak
@VisibleForTesting
public static void refresh() {
openFactories.clear();
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/factory/TxFactory.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.factory;
import ai.grakn.GraknTxType;
import ai.grakn.kb.internal.EmbeddedGraknTx;
import org.apache.tinkerpop.gremlin.structure.Graph;
/**
* <p>
* Transaction Building Interface
* </p>
*
* <p>
* The interface used to build new graphs from different vendors.
* Adding new vendor support means implementing this interface.
* </p>
*
* @author fppt
*
* @param <T> A vendor implementation of a Tinkerpop {@link Graph}
*/
public interface TxFactory<T extends Graph> {
/**
*
* @param txType The type of transaction to open on the graph
* @return An instance of Grakn graph
*/
EmbeddedGraknTx<T> open(GraknTxType txType);
/**
*
* @param batchLoading A flag which indicates if the graph has batch loading enabled or not.
* @return An instance of a tinker graph
*/
T getTinkerPopGraph(boolean batchLoading);
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/factory/TxFactoryAbstract.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.factory;
import ai.grakn.GraknTx;
import ai.grakn.GraknTxType;
import ai.grakn.exception.GraknTxOperationException;
import ai.grakn.kb.internal.EmbeddedGraknTx;
import org.apache.tinkerpop.gremlin.structure.Graph;
import javax.annotation.CheckReturnValue;
import javax.annotation.Nullable;
import static javax.annotation.meta.When.NEVER;
/**
* <p>
* Defines the abstract construction of {@link GraknTx}s on top of Tinkerpop Graphs.
* For this factory to function a vendor specific implementation of a graph extending
* {@link EmbeddedGraknTx} must be provided. This must be provided with a matching TinkerPop {@link Graph}
* which is wrapped within the {@link GraknTx}
* </p>
*
* @param <Tx> A {@link GraknTx} extending {@link EmbeddedGraknTx} and wrapping a Tinkerpop Graph
* @param <G> A vendor implementation of a Tinkerpop {@link Graph}
* @author fppt
*/
public abstract class TxFactoryAbstract<Tx extends EmbeddedGraknTx<G>, G extends Graph> implements TxFactory<G> {
private final EmbeddedGraknSession session;
protected final GraphWithTx batchTinkerPopGraphWithTx = new GraphWithTx(true);
protected final GraphWithTx tinkerPopGraphWithTx = new GraphWithTx(false);
protected TxFactoryAbstract(EmbeddedGraknSession session) {
this.session = session;
}
protected abstract Tx buildGraknTxFromTinkerGraph(G graph);
protected abstract G buildTinkerPopGraph(boolean batchLoading);
@Override
final public synchronized Tx open(GraknTxType txType) {
if (GraknTxType.BATCH.equals(txType)) {
tinkerPopGraphWithTx.checkTxIsOpen();
return batchTinkerPopGraphWithTx.openTx(txType);
} else {
// Check there is no batch loading Tx open
batchTinkerPopGraphWithTx.checkTxIsOpen();
return tinkerPopGraphWithTx.openTx(txType);
}
}
@Override
final public synchronized G getTinkerPopGraph(boolean batchLoading) {
if (batchLoading) {
return batchTinkerPopGraphWithTx.getTinkerPopGraph();
} else {
return tinkerPopGraphWithTx.getTinkerPopGraph();
}
}
@CheckReturnValue(when = NEVER)
protected abstract G getGraphWithNewTransaction(G graph, boolean batchloading);
final public EmbeddedGraknSession session() {
return session;
}
/**
* Helper class representing a TinkerPop graph that can be open with batchLoading enabled or disabled
*/
class GraphWithTx {
@Nullable
private Tx graknTx = null;
private G graph = null;
private final boolean batchLoading;
public GraphWithTx(boolean batchLoading) {
this.batchLoading = batchLoading;
}
public Tx openTx(GraknTxType txType) {
initialiseGraknTx();
graknTx.openTransaction(txType);
return graknTx;
}
private void initialiseGraknTx() {
// If transaction is already open throw exception
if (graknTx != null && !graknTx.isClosed()) throw GraknTxOperationException.transactionOpen(graknTx);
// Create new transaction from a Tinker graph if tx is null or s closed
if (graknTx == null || graknTx.isTinkerPopGraphClosed()) {
graknTx = buildGraknTxFromTinkerGraph(getTinkerPopGraph());
}
}
protected G getTinkerPopGraph() {
if (graph == null) {
graph = buildTinkerPopGraph(batchLoading);
} else {
graph = getGraphWithNewTransaction(graph, batchLoading);
}
return graph;
}
public void checkTxIsOpen() {
if (graknTx != null && !graknTx.isClosed()) throw GraknTxOperationException.transactionOpen(graknTx);
}
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/factory/TxFactoryBuilder.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.factory;
import ai.grakn.GraknSession;
import ai.grakn.util.ErrorMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.InvocationTargetException;
/**
* <p>
* Builds a {@link TxFactory}
* </p>
* <p>
* <p>
* Builds a {@link TxFactory} which is locked to a specific keyspace and engine URL.
* This uses refection in order to dynamically build any vendor specific factory which implements the
* {@link TxFactory} API.
* <p>
* The factories in this class are treated as singletons.
* </p>
*
* @author fppt
*/
public abstract class TxFactoryBuilder {
public static final String IN_MEMORY = "in-memory";
private static final Logger LOG = LoggerFactory.getLogger(GraknTxFactoryBuilder.class);
public abstract TxFactory<?> getFactory(EmbeddedGraknSession session, boolean isComputerFactory);
/**
* @param factoryType The type of the factory to initialise. Any factory which implements {@link TxFactory}
* @param session The {@link GraknSession} creating this factory
* @return A new factory bound to a specific keyspace
*/
final protected static synchronized TxFactory<?> newFactory(String factoryType, EmbeddedGraknSession session) {
TxFactory<?> txFactory;
try {
txFactory = (TxFactory<?>) Class.forName(factoryType)
.getDeclaredConstructor(EmbeddedGraknSession.class)
.newInstance(session);
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
throw new IllegalArgumentException(ErrorMessage.INVALID_FACTORY.getMessage(factoryType), e);
}
LOG.trace("New factory created " + txFactory);
return txFactory;
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/factory/TxFactoryTinker.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.factory;
import ai.grakn.GraknTx;
import ai.grakn.kb.internal.GraknTxTinker;
import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
/**
* <p>
* A {@link GraknTx} on top of {@link TinkerGraph}
* </p>
*
* <p>
* This produces an in memory grakn graph on top of {@link TinkerGraph}.
* The base construction process defined by {@link TxFactoryAbstract} ensures the graph factories are singletons.
* </p>
*
* @author fppt
*/
public class TxFactoryTinker extends TxFactoryAbstract<GraknTxTinker, TinkerGraph> {
private TinkerGraph tinkerGraph;
TxFactoryTinker(EmbeddedGraknSession session){
super(session);
tinkerGraph = TinkerGraph.open();
}
@Override
protected GraknTxTinker buildGraknTxFromTinkerGraph(TinkerGraph graph) { return new GraknTxTinker(session(), graph); }
@Override
protected TinkerGraph buildTinkerPopGraph(boolean batchLoading) {
return tinkerGraph;
}
public TinkerGraph getTinkerPopGraph(){
return tinkerGraph;
}
@Override
protected TinkerGraph getGraphWithNewTransaction(TinkerGraph graph, boolean batchLoading) {
return tinkerGraph;
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/factory/package-info.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
/**
* Provides graph accessors for different backends.
*/
package ai.grakn.factory;
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal/EmbeddedGraknTx.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.kb.internal;
import ai.grakn.GraknConfigKey;
import ai.grakn.GraknTx;
import ai.grakn.GraknTxType;
import ai.grakn.QueryExecutor;
import ai.grakn.concept.Attribute;
import ai.grakn.concept.AttributeType;
import ai.grakn.concept.Concept;
import ai.grakn.concept.ConceptId;
import ai.grakn.concept.EntityType;
import ai.grakn.concept.Label;
import ai.grakn.concept.LabelId;
import ai.grakn.concept.Relationship;
import ai.grakn.concept.RelationshipType;
import ai.grakn.concept.Role;
import ai.grakn.concept.Rule;
import ai.grakn.concept.SchemaConcept;
import ai.grakn.concept.Type;
import ai.grakn.exception.GraknTxOperationException;
import ai.grakn.exception.InvalidKBException;
import ai.grakn.exception.PropertyNotUniqueException;
import ai.grakn.factory.EmbeddedGraknSession;
import ai.grakn.graql.Pattern;
import ai.grakn.graql.QueryBuilder;
import ai.grakn.kb.admin.GraknAdmin;
import ai.grakn.kb.internal.cache.GlobalCache;
import ai.grakn.kb.internal.cache.TxCache;
import ai.grakn.kb.internal.cache.TxRuleCache;
import ai.grakn.kb.internal.concept.AttributeImpl;
import ai.grakn.kb.internal.concept.ConceptImpl;
import ai.grakn.kb.internal.concept.ConceptVertex;
import ai.grakn.kb.internal.concept.ElementFactory;
import ai.grakn.kb.internal.concept.RelationshipEdge;
import ai.grakn.kb.internal.concept.RelationshipImpl;
import ai.grakn.kb.internal.concept.RelationshipReified;
import ai.grakn.kb.internal.concept.SchemaConceptImpl;
import ai.grakn.kb.internal.concept.TypeImpl;
import ai.grakn.kb.internal.structure.EdgeElement;
import ai.grakn.kb.internal.structure.VertexElement;
import ai.grakn.kb.log.CommitLog;
import ai.grakn.util.ErrorMessage;
import ai.grakn.util.Schema;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReadOnlyStrategy;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Element;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Nullable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static ai.grakn.util.ErrorMessage.CANNOT_FIND_CLASS;
import static java.util.stream.Collectors.toSet;
/**
* The {@link GraknTx} Base Implementation.
* This defines how a grakn graph sits on top of a Tinkerpop {@link Graph}.
* It mostly act as a construction object which ensure the resulting graph conforms to the Grakn Object model.
*
* @param <G> A vendor specific implementation of a Tinkerpop {@link Graph}.
* @author Grakn Warriors
*/
public abstract class EmbeddedGraknTx<G extends Graph> implements GraknAdmin {
final Logger LOG = LoggerFactory.getLogger(EmbeddedGraknTx.class);
private static final String QUERY_BUILDER_CLASS_NAME = "ai.grakn.graql.internal.query.QueryBuilderImpl";
private static final String QUERY_EXECUTOR_CLASS_NAME = "ai.grakn.graql.internal.query.executor.QueryExecutorImpl";
//----------------------------- Shared Variables
private final EmbeddedGraknSession session;
private final G graph;
private final ElementFactory elementFactory;
private final GlobalCache globalCache;
private static final @Nullable
Constructor<?> queryBuilderConstructor = getQueryBuilderConstructor();
private static final @Nullable
Method queryExecutorFactory = getQueryExecutorFactory();
//----------------------------- Transaction Specific
private final ThreadLocal<TxCache> localConceptLog = new ThreadLocal<>();
private @Nullable GraphTraversalSource graphTraversalSource = null;
private final TxRuleCache ruleCache;
public EmbeddedGraknTx(EmbeddedGraknSession session, G graph) {
this.session = session;
this.graph = graph;
this.elementFactory = new ElementFactory(this);
this.ruleCache = new TxRuleCache(this);
//Initialise Graph Caches
globalCache = new GlobalCache(session.config());
//Initialise Graph
txCache().openTx(GraknTxType.WRITE);
if (initialiseMetaConcepts()) commit();
}
@Override
public EmbeddedGraknSession session() {
return session;
}
public TxRuleCache ruleCache(){ return ruleCache;}
/**
* Converts a Type Label into a type Id for this specific graph. Mapping labels to ids will differ between graphs
* so be sure to use the correct graph when performing the mapping.
*
* @param label The label to be converted to the id
* @return The matching type id
*/
public LabelId convertToId(Label label) {
if (txCache().isLabelCached(label)) {
return txCache().convertLabelToId(label);
}
return LabelId.invalid();
}
/**
* Gets and increments the current available type id.
*
* @return the current available Grakn id which can be used for types
*/
private LabelId getNextId() {
TypeImpl<?, ?> metaConcept = (TypeImpl<?, ?>) getMetaConcept();
Integer currentValue = metaConcept.vertex().property(Schema.VertexProperty.CURRENT_LABEL_ID);
if (currentValue == null) {
currentValue = Schema.MetaSchema.values().length + 1;
} else {
currentValue = currentValue + 1;
}
//Vertex is used directly here to bypass meta type mutation check
metaConcept.property(Schema.VertexProperty.CURRENT_LABEL_ID, currentValue);
return LabelId.of(currentValue);
}
/**
* @return The graph cache which contains all the data cached and accessible by all transactions.
*/
GlobalCache getGlobalCache() {
return globalCache;
}
/**
* @return The number of open transactions currently.
*/
public abstract int numOpenTx();
/**
* Opens the thread bound transaction
*/
public void openTransaction(GraknTxType txType) {
txCache().openTx(txType);
}
/**
* Gets the config option which determines the number of instances a {@link Type} must have before the {@link Type}
* if automatically sharded.
*
* @return the number of instances a {@link Type} must have before it is shareded
*/
public long shardingThreshold() {
return session().config().getProperty(GraknConfigKey.SHARDING_THRESHOLD);
}
public TxCache txCache() {
TxCache txCache = localConceptLog.get();
if (txCache == null) {
localConceptLog.set(txCache = new TxCache(getGlobalCache()));
}
if (txCache.isTxOpen() && txCache.schemaNotCached()) {
txCache.refreshSchemaCache();
}
return txCache;
}
@Override
public boolean isClosed() {
return !txCache().isTxOpen();
}
public abstract boolean isTinkerPopGraphClosed();
@Override
public GraknTxType txType() {
return txCache().txType();
}
@Override
public GraknAdmin admin() {
return this;
}
/**
* @param <T> The type of the concept being built
* @param vertex A vertex which contains properties necessary to build a concept from.
* @return A concept built using the provided vertex
*/
public <T extends Concept> T buildConcept(Vertex vertex) {
return factory().buildConcept(vertex);
}
/**
* @param <T> The type of the {@link Concept} being built
* @param edge An {@link Edge} which contains properties necessary to build a {@link Concept} from.
* @return A {@link Concept} built using the provided {@link Edge}
*/
public <T extends Concept> T buildConcept(Edge edge) {
return factory().buildConcept(edge);
}
/**
* A flag to check if batch loading is enabled and consistency checks are switched off
*
* @return true if batch loading is enabled
*/
public boolean isBatchTx() {
return GraknTxType.BATCH.equals(txCache().txType());
}
@SuppressWarnings("unchecked")
private boolean initialiseMetaConcepts() {
boolean schemaInitialised = false;
if (isMetaSchemaNotInitialised()) {
VertexElement type = addTypeVertex(Schema.MetaSchema.THING.getId(), Schema.MetaSchema.THING.getLabel(), Schema.BaseType.TYPE);
VertexElement entityType = addTypeVertex(Schema.MetaSchema.ENTITY.getId(), Schema.MetaSchema.ENTITY.getLabel(), Schema.BaseType.ENTITY_TYPE);
VertexElement relationType = addTypeVertex(Schema.MetaSchema.RELATIONSHIP.getId(), Schema.MetaSchema.RELATIONSHIP.getLabel(), Schema.BaseType.RELATIONSHIP_TYPE);
VertexElement resourceType = addTypeVertex(Schema.MetaSchema.ATTRIBUTE.getId(), Schema.MetaSchema.ATTRIBUTE.getLabel(), Schema.BaseType.ATTRIBUTE_TYPE);
addTypeVertex(Schema.MetaSchema.ROLE.getId(), Schema.MetaSchema.ROLE.getLabel(), Schema.BaseType.ROLE);
addTypeVertex(Schema.MetaSchema.RULE.getId(), Schema.MetaSchema.RULE.getLabel(), Schema.BaseType.RULE);
relationType.property(Schema.VertexProperty.IS_ABSTRACT, true);
resourceType.property(Schema.VertexProperty.IS_ABSTRACT, true);
entityType.property(Schema.VertexProperty.IS_ABSTRACT, true);
relationType.addEdge(type, Schema.EdgeLabel.SUB);
resourceType.addEdge(type, Schema.EdgeLabel.SUB);
entityType.addEdge(type, Schema.EdgeLabel.SUB);
schemaInitialised = true;
}
//Copy entire schema to the graph cache. This may be a bad idea as it will slow down graph initialisation
copyToCache(getMetaConcept());
//Role and rule have to be copied separately due to not being connected to meta schema
copyToCache(getMetaRole());
copyToCache(getMetaRule());
return schemaInitialised;
}
/**
* Copies the {@link SchemaConcept} and it's subs into the {@link TxCache}.
* This is important as lookups for {@link SchemaConcept}s based on {@link Label} depend on this caching.
*
* @param schemaConcept the {@link SchemaConcept} to be copied into the {@link TxCache}
*/
private void copyToCache(SchemaConcept schemaConcept) {
schemaConcept.subs().forEach(concept -> {
getGlobalCache().cacheLabel(concept.label(), concept.labelId());
getGlobalCache().cacheType(concept.label(), concept);
});
}
private boolean isMetaSchemaNotInitialised() {
return getMetaConcept() == null;
}
public G getTinkerPopGraph() {
return graph;
}
/**
* Utility function to get a read-only Tinkerpop traversal.
*
* @return A read-only Tinkerpop traversal for manually traversing the graph
*/
public GraphTraversalSource getTinkerTraversal() {
operateOnOpenGraph(() -> null); //This is to check if the graph is open
if (graphTraversalSource == null) {
graphTraversalSource = getTinkerPopGraph().traversal().withStrategies(ReadOnlyStrategy.instance());
}
return graphTraversalSource;
}
@Override
public QueryBuilder graql() {
if (queryBuilderConstructor == null) {
throw new RuntimeException(CANNOT_FIND_CLASS.getMessage("query executor", QUERY_EXECUTOR_CLASS_NAME));
}
try {
return (QueryBuilder) queryBuilderConstructor.newInstance(this);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public ElementFactory factory() {
return elementFactory;
}
/**
* @param key The concept property tp search by.
* @param value The value of the concept
* @return A concept with the matching key and value
*/
//----------------------------------------------General Functionality-----------------------------------------------
public <T extends Concept> Optional<T> getConcept(Schema.VertexProperty key, Object value) {
Iterator<Vertex> vertices = getTinkerTraversal().V().has(key.name(), value);
if (vertices.hasNext()) {
Vertex vertex = vertices.next();
return Optional.of(factory().buildConcept(vertex));
} else {
return Optional.empty();
}
}
@Override
public final Stream<SchemaConcept> sups(SchemaConcept schemaConcept) {
Set<SchemaConcept> superSet = new HashSet<>();
while (schemaConcept != null) {
superSet.add(schemaConcept);
schemaConcept = schemaConcept.sup();
}
return superSet.stream();
}
private Set<Concept> getConcepts(Schema.VertexProperty key, Object value) {
Set<Concept> concepts = new HashSet<>();
getTinkerTraversal().V().has(key.name(), value).forEachRemaining(v -> concepts.add(factory().buildConcept(v)));
return concepts;
}
public void checkSchemaMutationAllowed() {
checkMutationAllowed();
if (isBatchTx()) throw GraknTxOperationException.schemaMutation();
}
public void checkMutationAllowed() {
if (GraknTxType.READ.equals(txType())) throw GraknTxOperationException.transactionReadOnly(this);
}
public VertexElement addVertexElement(Schema.BaseType baseType, ConceptId... conceptIds) {
return factory().addVertexElement(baseType, conceptIds);
}
/**
* Adds a new type vertex which occupies a grakn id. This result in the grakn id count on the meta concept to be
* incremented.
*
* @param label The label of the new type vertex
* @param baseType The base type of the new type
* @return The new type vertex
*/
private VertexElement addTypeVertex(LabelId id, Label label, Schema.BaseType baseType) {
VertexElement vertexElement = addVertexElement(baseType);
vertexElement.property(Schema.VertexProperty.SCHEMA_LABEL, label.getValue());
vertexElement.property(Schema.VertexProperty.LABEL_ID, id.getValue());
return vertexElement;
}
/**
* An operation on the graph which requires it to be open.
*
* @param supplier The operation to be performed on the graph
* @return The result of the operation on the graph.
* @throws GraknTxOperationException if the graph is closed.
*/
private <X> X operateOnOpenGraph(Supplier<X> supplier) {
if (isClosed()) throw GraknTxOperationException.transactionClosed(this, txCache().getClosedReason());
return supplier.get();
}
@Override
public EntityType putEntityType(Label label) {
return putSchemaConcept(label, Schema.BaseType.ENTITY_TYPE, false,
v -> factory().buildEntityType(v, getMetaEntityType()));
}
/**
* This is a helper method which will either find or create a {@link SchemaConcept}.
* When a new {@link SchemaConcept} is created it is added for validation through it's own creation method for
* example {@link ai.grakn.kb.internal.concept.RoleImpl#create(VertexElement, Role)}.
* <p>
* When an existing {@link SchemaConcept} is found it is build via it's get method such as
* {@link ai.grakn.kb.internal.concept.RoleImpl#get(VertexElement)} and skips validation.
* <p>
* Once the {@link SchemaConcept} is found or created a few checks for uniqueness and correct
* {@link ai.grakn.util.Schema.BaseType} are performed.
*
* @param label The {@link Label} of the {@link SchemaConcept} to find or create
* @param baseType The {@link Schema.BaseType} of the {@link SchemaConcept} to find or create
* @param isImplicit a flag indicating if the label we are creating is for an implicit {@link Type} or not
* @param newConceptFactory the factory to be using when creating a new {@link SchemaConcept}
* @param <T> The type of {@link SchemaConcept} to return
* @return a new or existing {@link SchemaConcept}
*/
private <T extends SchemaConcept> T putSchemaConcept(Label label, Schema.BaseType baseType, boolean isImplicit, Function<VertexElement, T> newConceptFactory) {
checkSchemaMutationAllowed();
//Get the type if it already exists otherwise build a new one
SchemaConceptImpl schemaConcept = getSchemaConcept(convertToId(label));
if (schemaConcept == null) {
if (!isImplicit && label.getValue().startsWith(Schema.ImplicitType.RESERVED.getValue())) {
throw GraknTxOperationException.invalidLabelStart(label);
}
VertexElement vertexElement = addTypeVertex(getNextId(), label, baseType);
//Mark it as implicit here so we don't have to pass it down the constructors
if (isImplicit) {
vertexElement.property(Schema.VertexProperty.IS_IMPLICIT, true);
}
schemaConcept = SchemaConceptImpl.from(buildSchemaConcept(label, () -> newConceptFactory.apply(vertexElement)));
} else if (!baseType.equals(schemaConcept.baseType())) {
throw labelTaken(schemaConcept);
}
//noinspection unchecked
return (T) schemaConcept;
}
/**
* Throws an exception when adding a {@link SchemaConcept} using a {@link Label} which is already taken
*/
private GraknTxOperationException labelTaken(SchemaConcept schemaConcept) {
if (Schema.MetaSchema.isMetaLabel(schemaConcept.label())) {
return GraknTxOperationException.reservedLabel(schemaConcept.label());
}
return PropertyNotUniqueException.cannotCreateProperty(schemaConcept, Schema.VertexProperty.SCHEMA_LABEL, schemaConcept.label());
}
private <T extends Concept> T validateSchemaConcept(Concept concept, Schema.BaseType baseType, Supplier<T> invalidHandler) {
if (concept != null && baseType.getClassType().isInstance(concept)) {
//noinspection unchecked
return (T) concept;
} else {
return invalidHandler.get();
}
}
/**
* A helper method which either retrieves the {@link SchemaConcept} from the cache or builds it using a provided supplier
*
* @param label The {@link Label} of the {@link SchemaConcept} to retrieve or build
* @param dbBuilder A method which builds the {@link SchemaConcept} via a DB read or write
* @return The {@link SchemaConcept} which was either cached or built via a DB read or write
*/
private SchemaConcept buildSchemaConcept(Label label, Supplier<SchemaConcept> dbBuilder) {
if (txCache().isTypeCached(label)) {
return txCache().getCachedSchemaConcept(label);
} else {
return dbBuilder.get();
}
}
@Override
public RelationshipType putRelationshipType(Label label) {
return putSchemaConcept(label, Schema.BaseType.RELATIONSHIP_TYPE, false,
v -> factory().buildRelationshipType(v, getMetaRelationType()));
}
public RelationshipType putRelationTypeImplicit(Label label) {
return putSchemaConcept(label, Schema.BaseType.RELATIONSHIP_TYPE, true,
v -> factory().buildRelationshipType(v, getMetaRelationType()));
}
@Override
public Role putRole(Label label) {
return putSchemaConcept(label, Schema.BaseType.ROLE, false,
v -> factory().buildRole(v, getMetaRole()));
}
public Role putRoleTypeImplicit(Label label) {
return putSchemaConcept(label, Schema.BaseType.ROLE, true,
v -> factory().buildRole(v, getMetaRole()));
}
@SuppressWarnings("unchecked")
@Override
public <V> AttributeType<V> putAttributeType(Label label, AttributeType.DataType<V> dataType) {
@SuppressWarnings("unchecked")
AttributeType<V> attributeType = putSchemaConcept(label, Schema.BaseType.ATTRIBUTE_TYPE, false,
v -> factory().buildAttributeType(v, getMetaAttributeType(), dataType));
//These checks is needed here because caching will return a type by label without checking the datatype
if (Schema.MetaSchema.isMetaLabel(label)) {
throw GraknTxOperationException.metaTypeImmutable(label);
} else if (!dataType.equals(attributeType.dataType())) {
throw GraknTxOperationException.immutableProperty(attributeType.dataType(), dataType, Schema.VertexProperty.DATA_TYPE);
}
return attributeType;
}
@Override
public Rule putRule(Label label, Pattern when, Pattern then) {
Rule rule = putSchemaConcept(label, Schema.BaseType.RULE, false,
v -> factory().buildRule(v, getMetaRule(), when, then));
//NB: thenTypes() will be empty as type edges added on commit
//NB: this will cache also non-committed rules
if (rule.then() != null){
rule.then().admin().varPatterns().stream()
.flatMap(v -> v.getTypeLabels().stream())
.map(vl -> this.admin().<SchemaConcept>getSchemaConcept(vl))
.filter(Objects::nonNull)
.filter(Concept::isType)
.forEach(type -> ruleCache.updateRules(type, rule));
}
return rule;
}
//------------------------------------ Lookup
@Override
public <T extends Concept> T getConcept(ConceptId id) {
return operateOnOpenGraph(() -> {
if (txCache().isConceptCached(id)) {
return txCache().getCachedConcept(id);
} else {
if (id.getValue().startsWith(Schema.PREFIX_EDGE)) {
Optional<T> concept = getConceptEdge(id);
if (concept.isPresent()) return concept.get();
}
return this.<T>getConcept(Schema.VertexProperty.ID, id.getValue()).orElse(null);
}
});
}
private <T extends Concept> Optional<T> getConceptEdge(ConceptId id) {
String edgeId = id.getValue().substring(1);
GraphTraversal<Edge, Edge> traversal = getTinkerTraversal().E(edgeId);
if (traversal.hasNext()) {
return Optional.of(factory().buildConcept(factory().buildEdgeElement(traversal.next())));
}
return Optional.empty();
}
private <T extends SchemaConcept> T getSchemaConcept(Label label, Schema.BaseType baseType) {
operateOnOpenGraph(() -> null); //Makes sure the graph is open
SchemaConcept schemaConcept = buildSchemaConcept(label, () -> getSchemaConcept(convertToId(label)));
return validateSchemaConcept(schemaConcept, baseType, () -> null);
}
@Nullable
public <T extends SchemaConcept> T getSchemaConcept(LabelId id) {
if (!id.isValid()) return null;
return this.<T>getConcept(Schema.VertexProperty.LABEL_ID, id.getValue()).orElse(null);
}
@Override
public <V> Collection<Attribute<V>> getAttributesByValue(V value) {
if (value == null) return Collections.emptySet();
//Make sure you trying to retrieve supported data type
if (!AttributeType.DataType.SUPPORTED_TYPES.containsKey(value.getClass().getName())) {
throw GraknTxOperationException.unsupportedDataType(value);
}
HashSet<Attribute<V>> attributes = new HashSet<>();
AttributeType.DataType dataType = AttributeType.DataType.SUPPORTED_TYPES.get(value.getClass().getTypeName());
//noinspection unchecked
getConcepts(dataType.getVertexProperty(), dataType.getPersistenceValue(value)).forEach(concept -> {
if (concept != null && concept.isAttribute()) {
//noinspection unchecked
attributes.add(concept.asAttribute());
}
});
return attributes;
}
@Override
public <T extends SchemaConcept> T getSchemaConcept(Label label) {
Schema.MetaSchema meta = Schema.MetaSchema.valueOf(label);
if (meta != null) return getSchemaConcept(meta.getId());
return getSchemaConcept(label, Schema.BaseType.SCHEMA_CONCEPT);
}
@Override
public <T extends Type> T getType(Label label) {
return getSchemaConcept(label, Schema.BaseType.TYPE);
}
@Override
public EntityType getEntityType(String label) {
return getSchemaConcept(Label.of(label), Schema.BaseType.ENTITY_TYPE);
}
@Override
public RelationshipType getRelationshipType(String label) {
return getSchemaConcept(Label.of(label), Schema.BaseType.RELATIONSHIP_TYPE);
}
@Override
public <V> AttributeType<V> getAttributeType(String label) {
return getSchemaConcept(Label.of(label), Schema.BaseType.ATTRIBUTE_TYPE);
}
@Override
public Role getRole(String label) {
return getSchemaConcept(Label.of(label), Schema.BaseType.ROLE);
}
@Override
public Rule getRule(String label) {
return getSchemaConcept(Label.of(label), Schema.BaseType.RULE);
}
//This is overridden by vendors for more efficient clearing approaches
public void clearGraph() {
getTinkerPopGraph().traversal().V().drop().iterate();
}
/**
* Closes the root session this graph stems from. This will automatically rollback any pending transactions.
*/
public void closeSession() {
try {
txCache().closeTx(ErrorMessage.SESSION_CLOSED.getMessage(keyspace()));
getTinkerPopGraph().close();
} catch (Exception e) {
throw GraknTxOperationException.closingFailed(this, e);
}
}
/**
* Close the transaction without committing
*/
@Override
public void close() {
if (isClosed()) {
return;
}
try {
txCache().writeToGraphCache(txType().equals(GraknTxType.READ));
} finally {
String closeMessage = ErrorMessage.TX_CLOSED_ON_ACTION.getMessage("closed", keyspace());
closeTransaction(closeMessage);
}
}
/**
* Commits and closes the transaction without returning CommitLog
*
* @throws InvalidKBException
*/
@Override
public void commit() throws InvalidKBException {
if (isClosed()) {
return;
}
String closeMessage = ErrorMessage.TX_CLOSED_ON_ACTION.getMessage("committed", keyspace());
try {
validateGraph();
commitTransactionInternal();
txCache().writeToGraphCache(true);
} finally {
closeTransaction(closeMessage);
}
}
/**
* Commits, closes transaction and returns CommitLog.
*
* @return the commit log that would have been submitted if it is needed.
* @throws InvalidKBException when the graph does not conform to the object concept
*/
public Optional<CommitLog> commitAndGetLogs() throws InvalidKBException {
if (isClosed()) {
return Optional.empty();
}
try {
return commitWithLogs();
} finally {
String closeMessage = ErrorMessage.TX_CLOSED_ON_ACTION.getMessage("committed", keyspace());
closeTransaction(closeMessage);
}
}
private void closeTransaction(String closedReason) {
try {
graph.tx().close();
} catch (UnsupportedOperationException e) {
//Ignored for Tinker
} finally {
txCache().closeTx(closedReason);
ruleCache().closeTx();
}
}
private Optional<CommitLog> commitWithLogs() throws InvalidKBException {
validateGraph();
Map<ConceptId, Long> newInstances = txCache().getShardingCount();
Map<String, Set<ConceptId>> newAttributes = txCache().getNewAttributes();
boolean logsExist = !newInstances.isEmpty() || !newAttributes.isEmpty();
commitTransactionInternal();
txCache().writeToGraphCache(true);
//If we have logs to commit get them and add them
if (logsExist) {
return Optional.of(CommitLog.create(keyspace(), newInstances, newAttributes));
}
return Optional.empty();
}
void commitTransactionInternal() {
try {
LOG.trace("Graph is valid. Committing graph . . . ");
getTinkerPopGraph().tx().commit();
LOG.trace("Graph committed.");
} catch (UnsupportedOperationException e) {
//IGNORED
}
}
private void validateGraph() throws InvalidKBException {
Validator validator = new Validator(this);
if (!validator.validate()) {
List<String> errors = validator.getErrorsFound();
if (!errors.isEmpty()) throw InvalidKBException.validationErrors(errors);
}
}
public boolean isValidElement(Element element) {
return element != null;
}
//------------------------------------------ Fixing Code for Postprocessing ----------------------------------------
/**
* Returns the duplicates of the given concept
*
* @param mainConcept primary concept - this one is returned by the index and not considered a duplicate
* @param conceptIds Set of Ids containing potential duplicates of the main concept
* @return a set containing the duplicates of the given concept
*/
private <X extends ConceptImpl> Set<X> getDuplicates(X mainConcept, Set<ConceptId> conceptIds) {
Set<X> duplicated = conceptIds.stream()
.map(this::<X>getConcept)
//filter non-null, will be null if previously deleted/merged
.filter(Objects::nonNull)
.collect(toSet());
duplicated.remove(mainConcept);
return duplicated;
}
/**
* Creates a new shard for the concept
*
* @param conceptId the id of the concept to shard
*/
public void shard(ConceptId conceptId) {
ConceptImpl type = getConcept(conceptId);
if (type == null) {
LOG.warn("Cannot shard concept [" + conceptId + "] due to it not existing in the graph");
} else {
type.createShard();
}
}
/**
* Returns the current number of shards the provided {@link Type} has. This is used in creating more
* efficient query plans.
*
* @param concept The {@link Type} which may contain some shards.
* @return the number of Shards the {@link Type} currently has.
*/
public long getShardCount(Type concept) {
return TypeImpl.from(concept).shardCount();
}
@Override
public final QueryExecutor queryExecutor() {
if (queryExecutorFactory == null) {
throw new RuntimeException(CANNOT_FIND_CLASS.getMessage("query builder", QUERY_BUILDER_CLASS_NAME));
}
try {
return (QueryExecutor) queryExecutorFactory.invoke(null, this);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static @Nullable
Constructor<?> getQueryBuilderConstructor() {
try {
return Class.forName(QUERY_BUILDER_CLASS_NAME).getConstructor(GraknTx.class);
} catch (NoSuchMethodException | SecurityException | ClassNotFoundException e) {
return null;
}
}
private static @Nullable
Method getQueryExecutorFactory() {
try {
return Class.forName(QUERY_EXECUTOR_CLASS_NAME).getDeclaredMethod("create", EmbeddedGraknTx.class);
} catch (NoSuchMethodException | SecurityException | ClassNotFoundException e) {
return null;
}
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal/GraknTxTinker.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.kb.internal;
import ai.grakn.GraknTx;
import ai.grakn.factory.EmbeddedGraknSession;
import ai.grakn.util.ErrorMessage;
import ai.grakn.util.Schema;
import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
/**
* <p>
* A {@link GraknTx} using {@link TinkerGraph} as a vendor backend.
* </p>
*
* <p>
* Wraps up a {@link TinkerGraph} as a method of storing the {@link GraknTx} object Model.
* With this vendor some exceptions are in place:
* 1. Transactions do not exists and all threads work on the same graph at the same time.
* </p>
*
* @author fppt
*/
public class GraknTxTinker extends EmbeddedGraknTx<TinkerGraph> {
private final TinkerGraph rootGraph;
public GraknTxTinker(EmbeddedGraknSession session, TinkerGraph tinkerGraph){
super(session, tinkerGraph);
rootGraph = tinkerGraph;
}
@Override
public int numOpenTx() {
return 1;
}
@Override
public boolean isTinkerPopGraphClosed() {
return !rootGraph.traversal().V().has(Schema.VertexProperty.SCHEMA_LABEL.name(), Schema.MetaSchema.ENTITY.getLabel().getValue()).hasNext();
}
@Override
public void commit(){
LOG.warn(ErrorMessage.TRANSACTIONS_NOT_SUPPORTED.getMessage(TinkerGraph.class.getName(), "committed"));
super.commit();
}
@Override
public void abort(){
LOG.warn(ErrorMessage.TRANSACTIONS_NOT_SUPPORTED.getMessage(TinkerGraph.class.getName(), "aborted"));
super.abort();
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal/ValidateGlobalRules.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.kb.internal;
import ai.grakn.GraknTx;
import ai.grakn.concept.Attribute;
import ai.grakn.concept.Label;
import ai.grakn.concept.Relationship;
import ai.grakn.concept.RelationshipType;
import ai.grakn.concept.Role;
import ai.grakn.concept.Rule;
import ai.grakn.concept.SchemaConcept;
import ai.grakn.concept.Thing;
import ai.grakn.concept.Type;
import ai.grakn.exception.GraknTxOperationException;
import ai.grakn.graql.Pattern;
import ai.grakn.graql.admin.Atomic;
import ai.grakn.graql.admin.Conjunction;
import ai.grakn.graql.admin.ReasonerQuery;
import ai.grakn.graql.admin.VarPatternAdmin;
import ai.grakn.kb.internal.concept.RelationshipTypeImpl;
import ai.grakn.kb.internal.concept.RuleImpl;
import ai.grakn.kb.internal.concept.SchemaConceptImpl;
import ai.grakn.kb.internal.concept.TypeImpl;
import ai.grakn.kb.internal.structure.Casting;
import ai.grakn.util.CommonUtil;
import ai.grakn.util.ErrorMessage;
import ai.grakn.util.Schema;
import com.google.common.collect.Iterables;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static ai.grakn.util.ErrorMessage.VALIDATION_CASTING;
import static ai.grakn.util.ErrorMessage.VALIDATION_NOT_EXACTLY_ONE_KEY;
import static ai.grakn.util.ErrorMessage.VALIDATION_RELATION_CASTING_LOOP_FAIL;
import static ai.grakn.util.ErrorMessage.VALIDATION_RELATION_TYPE;
import static ai.grakn.util.ErrorMessage.VALIDATION_RELATION_TYPES_ROLES_SCHEMA;
import static ai.grakn.util.ErrorMessage.VALIDATION_REQUIRED_RELATION;
import static ai.grakn.util.ErrorMessage.VALIDATION_ROLE_TYPE_MISSING_RELATION_TYPE;
/**
* <p>
* Specific Validation Rules
* </p>
*
* <p>
* This class contains the implementation for the following validation rules:
* 1. Plays Validation which ensures that a {@link Thing} is allowed to play the {@link Role}
* it has been assigned to.
* 2. Relates Validation which ensures that every {@link Role} which is not abstract is
* assigned to a {@link RelationshipType} via {@link RelationshipType#relates(Role)}.
* 3. Minimum Role Validation which ensures that every {@link RelationshipType} has at least 2 {@link Role}
* assigned to it via {@link RelationshipType#relates(Role)}.
* 4. {@link Relationship} Structure Validation which ensures that each {@link Relationship} has the
* correct structure.
* 5. Abstract Type Validation which ensures that each abstract {@link Type} has no {@link Thing}.
* 6. {@link RelationshipType} Hierarchy Validation which ensures that {@link RelationshipType} with a hierarchical structure
* have a valid matching {@link Role} hierarchical structure.
* 7. Required Resources validation which ensures that each {@link Thing} with required
* {@link Attribute} has a valid {@link Relationship} to that {@link Attribute}.
* 8. Unique {@link Relationship} Validation which ensures that no duplicate {@link Relationship} are created.
* </p>
*
* @author fppt
*/
class ValidateGlobalRules {
private ValidateGlobalRules() {
throw new UnsupportedOperationException();
}
/**
* This method checks if the plays edge has been added between the roleplayer's {@link Type} and
* the {@link Role} being played.
*
* It also checks if the {@link Role} of the {@link Casting} has been linked to the {@link RelationshipType} of the
* {@link Relationship} which the {@link Casting} connects to.
*
* @return Specific errors if any are found
*/
static Set<String> validatePlaysAndRelatesStructure(Casting casting) {
Set<String> errors = new HashSet<>();
//Gets here to make sure we traverse/read only once
Thing thing = casting.getRolePlayer();
Role role = casting.getRole();
Relationship relationship = casting.getRelationship();
//Actual checks
roleNotAllowedToBePlayed(role, thing).ifPresent(errors::add);
roleNotLinkedToRelationShip(role, relationship.type(), relationship).ifPresent(errors::add);
return errors;
}
/**
* Checks if the {@link Role} of the {@link Casting} has been linked to the {@link RelationshipType} of
* the {@link Relationship} which the {@link Casting} connects to.
*
* @param role the {@link Role} which the {@link Casting} refers to
* @param relationshipType the {@link RelationshipType} which should connect to the role
* @param relationship the {@link Relationship} which the {@link Casting} refers to
* @return an error if one is found
*/
private static Optional<String> roleNotLinkedToRelationShip(Role role, RelationshipType relationshipType, Relationship relationship){
boolean notFound = role.relationships().
noneMatch(innerRelationType -> innerRelationType.label().equals(relationshipType.label()));
if(notFound){
return Optional.of(VALIDATION_RELATION_CASTING_LOOP_FAIL.getMessage(relationship.id(), role.label(), relationshipType.label()));
}
return Optional.empty();
}
/**
* Checks if the plays edge has been added between the roleplayer's {@link Type} and
* the {@link Role} being played.
*
* Also checks that required {@link Role} are satisfied
*
* @param role The {@link Role} which the role-player is playing
* @param thing the role-player
* @return an error if one is found
*/
private static Optional<String> roleNotAllowedToBePlayed(Role role, Thing thing){
TypeImpl<?, ?> currentConcept = (TypeImpl<?, ?>) thing.type();
boolean satisfiesPlays = false;
while(currentConcept != null){
Map<Role, Boolean> plays = currentConcept.directPlays();
for (Map.Entry<Role, Boolean> playsEntry : plays.entrySet()) {
Role rolePlayed = playsEntry.getKey();
Boolean required = playsEntry.getValue();
if(rolePlayed.label().equals(role.label())){
satisfiesPlays = true;
// Assert unique relationship for this role type
if (required && !CommonUtil.containsOnly(thing.relationships(role), 1)) {
return Optional.of(VALIDATION_REQUIRED_RELATION.getMessage(thing.id(), thing.type().label(), role.label(), thing.relationships(role).count()));
}
}
}
currentConcept = (TypeImpl) currentConcept.sup();
}
if(satisfiesPlays) {
return Optional.empty();
} else {
return Optional.of(VALIDATION_CASTING.getMessage(thing.type().label(), thing.id(), role.label()));
}
}
/**
*
* @param role The Role to validate
* @return An error message if the relates does not have a single incoming RELATES edge
*/
static Optional<String> validateHasSingleIncomingRelatesEdge(Role role){
if(!role.relationships().findAny().isPresent()) {
return Optional.of(VALIDATION_ROLE_TYPE_MISSING_RELATION_TYPE.getMessage(role.label()));
}
return Optional.empty();
}
/**
*
* @param relationshipType The {@link RelationshipType} to validate
* @return An error message if the relationTypes does not have at least 1 role
*/
static Optional<String> validateHasMinimumRoles(RelationshipType relationshipType) {
if(relationshipType.isAbstract() || relationshipType.roles().iterator().hasNext()){
return Optional.empty();
} else {
return Optional.of(VALIDATION_RELATION_TYPE.getMessage(relationshipType.label()));
}
}
/**
*
* @param relationshipType the {@link RelationshipType} to be validated
* @return Error messages if the role type sub structure does not match the {@link RelationshipType} sub structure
*/
static Set<String> validateRelationTypesToRolesSchema(RelationshipType relationshipType){
RelationshipTypeImpl superRelationType = (RelationshipTypeImpl) relationshipType.sup();
if(Schema.MetaSchema.isMetaLabel(superRelationType.label()) || superRelationType.isAbstract()){ //If super type is a meta type no validation needed
return Collections.emptySet();
}
Set<String> errorMessages = new HashSet<>();
Collection<Role> superRelates = superRelationType.roles().collect(Collectors.toSet());
Collection<Role> relates = relationshipType.roles().collect(Collectors.toSet());
Set<Label> relatesLabels = relates.stream().map(SchemaConcept::label).collect(Collectors.toSet());
//TODO: Determine if this check is redundant
//Check 1) Every role of relationTypes is the sub of a role which is in the relates of it's supers
if(!superRelationType.isAbstract()) {
Set<Label> allSuperRolesPlayed = new HashSet<>();
superRelationType.sups().forEach(rel -> rel.roles().forEach(roleType -> allSuperRolesPlayed.add(roleType.label())));
for (Role relate : relates) {
boolean validRoleTypeFound = SchemaConceptImpl.from(relate).sups().
anyMatch(superRole -> allSuperRolesPlayed.contains(superRole.label()));
if(!validRoleTypeFound){
errorMessages.add(VALIDATION_RELATION_TYPES_ROLES_SCHEMA.getMessage(relate.label(), relationshipType.label(), "super", "super", superRelationType.label()));
}
}
}
//Check 2) Every role of superRelationType has a sub role which is in the relates of relationTypes
for (Role superRelate : superRelates) {
boolean subRoleNotFoundInRelates = superRelate.subs().noneMatch(sub -> relatesLabels.contains(sub.label()));
if(subRoleNotFoundInRelates){
errorMessages.add(VALIDATION_RELATION_TYPES_ROLES_SCHEMA.getMessage(superRelate.label(), superRelationType.label(), "sub", "sub", relationshipType.label()));
}
}
return errorMessages;
}
/**
*
* @param thing The thing to be validated
* @return An error message if the thing does not have all the required resources
*/
static Optional<String> validateInstancePlaysAllRequiredRoles(Thing thing) {
TypeImpl<?, ?> currentConcept = (TypeImpl) thing.type();
while(currentConcept != null){
Map<Role, Boolean> plays = currentConcept.directPlays();
for (Map.Entry<Role, Boolean> playsEntry : plays.entrySet()) {
if(playsEntry.getValue()){
Role role = playsEntry.getKey();
// Assert there is a relationship for this type
Stream<Relationship> relationships = thing.relationships(role);
if(!CommonUtil.containsOnly(relationships, 1)){
Label resourceTypeLabel = Schema.ImplicitType.explicitLabel(role.label());
return Optional.of(VALIDATION_NOT_EXACTLY_ONE_KEY.getMessage(thing.id(), resourceTypeLabel));
}
}
}
currentConcept = (TypeImpl) currentConcept.sup();
}
return Optional.empty();
}
/**
* @param graph graph used to ensure the rule is a valid Horn clause
* @param rule the rule to be validated
* @return Error messages if the rule is not a valid Horn clause (in implication form, conjunction in the body, single-atom conjunction in the head)
*/
static Set<String> validateRuleIsValidHornClause(GraknTx graph, Rule rule){
Set<String> errors = new HashSet<>();
if (rule.when().admin().isDisjunction()){
errors.add(ErrorMessage.VALIDATION_RULE_DISJUNCTION_IN_BODY.getMessage(rule.label()));
}
if (errors.isEmpty()){
errors.addAll(validateRuleHead(graph, rule));
}
return errors;
}
private static ReasonerQuery combinedRuleQuery(GraknTx graph, Rule rule){
ReasonerQuery bodyQuery = rule.when().admin().getDisjunctiveNormalForm().getPatterns().iterator().next().toReasonerQuery(graph);
ReasonerQuery headQuery = rule.then().admin().getDisjunctiveNormalForm().getPatterns().iterator().next().toReasonerQuery(graph);
return headQuery.conjunction(bodyQuery);
}
/**
* NB: this only gets checked if the rule obeys the Horn clause form
* @param graph graph used to ensure the rule is a valid Horn clause
* @param rule the rule to be validated ontologically
* @return Error messages if the rule has ontological inconsistencies
*/
static Set<String> validateRuleOntologically(GraknTx graph, Rule rule) {
Set<String> errors = new HashSet<>();
//both body and head refer to the same graph and have to be valid with respect to the schema that governs it
//as a result the rule can be ontologically validated by combining them into a conjunction
//this additionally allows to cross check body-head references
ReasonerQuery combinedQuery = combinedRuleQuery(graph, rule);
errors.addAll(combinedQuery.validateOntologically());
return errors;
}
/**
* @param graph graph used to ensure the rule head is valid
* @param rule the rule to be validated
* @return Error messages if the rule head is invalid - is not a single-atom conjunction, doesn't contain illegal atomics and is ontologically valid
*/
private static Set<String> validateRuleHead(GraknTx graph, Rule rule) {
Set<String> errors = new HashSet<>();
Set<Conjunction<VarPatternAdmin>> headPatterns = rule.then().admin().getDisjunctiveNormalForm().getPatterns();
if (headPatterns.size() != 1){
errors.add(ErrorMessage.VALIDATION_RULE_DISJUNCTION_IN_HEAD.getMessage(rule.label()));
} else {
ReasonerQuery bodyQuery = Iterables.getOnlyElement(rule.when().admin().getDisjunctiveNormalForm().getPatterns()).toReasonerQuery(graph);
ReasonerQuery headQuery = Iterables.getOnlyElement(headPatterns).toReasonerQuery(graph);
ReasonerQuery combinedQuery = headQuery.conjunction(bodyQuery);
Set<Atomic> headAtoms = headQuery.getAtoms();
combinedQuery.getAtoms().stream()
.filter(headAtoms::contains)
.map(at -> at.validateAsRuleHead(rule))
.forEach(errors::addAll);
Set<Atomic> selectableHeadAtoms = headAtoms.stream()
.filter(Atomic::isAtom)
.filter(Atomic::isSelectable)
.collect(Collectors.toSet());
if (selectableHeadAtoms.size() > 1) {
errors.add(ErrorMessage.VALIDATION_RULE_HEAD_NON_ATOMIC.getMessage(rule.label()));
}
}
return errors;
}
/**
*
* @param rule The rule to be validated
* @return Error messages if the when or then of a rule refers to a non existent type
*/
static Set<String> validateRuleSchemaConceptExist(GraknTx graph, Rule rule){
Set<String> errors = new HashSet<>();
errors.addAll(checkRuleSideInvalid(graph, rule, Schema.VertexProperty.RULE_WHEN, rule.when()));
errors.addAll(checkRuleSideInvalid(graph, rule, Schema.VertexProperty.RULE_THEN, rule.then()));
return errors;
}
/**
*
* @param graph The graph to query against
* @param rule The rule the pattern was extracted from
* @param side The side from which the pattern was extracted
* @param pattern The pattern from which we will extract the types in the pattern
* @return A list of errors if the pattern refers to any non-existent types in the graph
*/
private static Set<String> checkRuleSideInvalid(GraknTx graph, Rule rule, Schema.VertexProperty side, Pattern pattern) {
Set<String> errors = new HashSet<>();
pattern.admin().varPatterns().stream()
.flatMap(v -> v.innerVarPatterns().stream())
.flatMap(v -> v.getTypeLabels().stream()).forEach(typeLabel -> {
SchemaConcept schemaConcept = graph.getSchemaConcept(typeLabel);
if(schemaConcept == null){
errors.add(ErrorMessage.VALIDATION_RULE_MISSING_ELEMENTS.getMessage(side, rule.label(), typeLabel));
} else {
if(Schema.VertexProperty.RULE_WHEN.equals(side)){
if (schemaConcept.isType()){
RuleImpl.from(rule).addHypothesis(schemaConcept.asType());
}
} else if (Schema.VertexProperty.RULE_THEN.equals(side)){
if (schemaConcept.isType()) {
RuleImpl.from(rule).addConclusion(schemaConcept.asType());
}
} else {
throw GraknTxOperationException.invalidPropertyUse(rule, side);
}
}
});
return errors;
}
/**
* Checks if a {@link Relationship} has at least one role player.
* @param relationship The {@link Relationship} to check
*/
static Optional<String> validateRelationshipHasRolePlayers(Relationship relationship) {
if(!relationship.rolePlayers().findAny().isPresent()){
return Optional.of(ErrorMessage.VALIDATION_RELATIONSHIP_WITH_NO_ROLE_PLAYERS.getMessage(relationship.id(), relationship.type().label()));
}
return Optional.empty();
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal/Validator.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.kb.internal;
import ai.grakn.concept.Relationship;
import ai.grakn.concept.RelationshipType;
import ai.grakn.concept.Role;
import ai.grakn.concept.Rule;
import ai.grakn.concept.Thing;
import ai.grakn.kb.internal.structure.Casting;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
/**
* <p>
* Ensures each concept undergoes the correct type of validation.
* </p>
*
* <p>
* Handles calling the relevant validation defined in {@link ValidateGlobalRules} depending on the
* type of the concept.
* </p>
*
* @author fppt
*
*/
class Validator {
private final EmbeddedGraknTx<?> graknGraph;
private final List<String> errorsFound = new ArrayList<>();
public Validator(EmbeddedGraknTx graknGraph){
this.graknGraph = graknGraph;
}
/**
*
* @return Any errors found during validation
*/
public List<String> getErrorsFound(){
return errorsFound;
}
/**
*
* @return True if the data and schema conforms to our concept.
*/
public boolean validate(){
//Validate Things
graknGraph.txCache().getModifiedThings().forEach(this::validateThing);
//Validate Relationships
graknGraph.txCache().getNewRelationships().forEach(this::validateRelationship);
//Validate RoleTypes
graknGraph.txCache().getModifiedRoles().forEach(this::validateRole);
//Validate Role Players
graknGraph.txCache().getModifiedCastings().forEach(this::validateCasting);
//Validate Relationship Types
graknGraph.txCache().getModifiedRelationshipTypes().forEach(this::validateRelationType);
//Validate Rules
graknGraph.txCache().getModifiedRules().forEach(rule -> validateRule(graknGraph, rule));
return errorsFound.size() == 0;
}
/**
* Validation rules exclusive to rules
* the precedence of validation is: labelValidation -> ontologicalValidation -> clauseValidation
* each of the validation happens only if the preceding validation yields no errors
* @param graph the graph to query against
* @param rule the rule which needs to be validated
*/
private void validateRule(EmbeddedGraknTx<?> graph, Rule rule){
Set<String> labelErrors = ValidateGlobalRules.validateRuleSchemaConceptExist(graph, rule);
errorsFound.addAll(labelErrors);
if (labelErrors.isEmpty()) {
Set<String> ontologicalErrors = ValidateGlobalRules.validateRuleOntologically(graph, rule);
errorsFound.addAll(ontologicalErrors);
if (ontologicalErrors.isEmpty()) {
errorsFound.addAll(ValidateGlobalRules.validateRuleIsValidHornClause(graph, rule));
}
}
}
/**
* Validation rules exclusive to role players
* @param casting The Role player to validate
*/
private void validateCasting(Casting casting){
errorsFound.addAll(ValidateGlobalRules.validatePlaysAndRelatesStructure(casting));
}
/**
* Validation rules exclusive to role
* @param role The {@link Role} to validate
*/
private void validateRole(Role role){
ValidateGlobalRules.validateHasSingleIncomingRelatesEdge(role).ifPresent(errorsFound::add);
}
/**
* Validation rules exclusive to relation types
* @param relationshipType The relationTypes to validate
*/
private void validateRelationType(RelationshipType relationshipType){
ValidateGlobalRules.validateHasMinimumRoles(relationshipType).ifPresent(errorsFound::add);
errorsFound.addAll(ValidateGlobalRules.validateRelationTypesToRolesSchema(relationshipType));
}
/**
* Validation rules exclusive to instances
* @param thing The {@link Thing} to validate
*/
private void validateThing(Thing thing) {
ValidateGlobalRules.validateInstancePlaysAllRequiredRoles(thing).ifPresent(errorsFound::add);
}
/**
* Validates that {@link Relationship}s can be committed.
* @param relationship The {@link Relationship} to validate
*/
private void validateRelationship(Relationship relationship){
ValidateGlobalRules.validateRelationshipHasRolePlayers(relationship).ifPresent(errorsFound::add);
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal/package-info.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
/**
* Internal implementation of {@link ai.grakn.GraknTx}.
*/
package ai.grakn.kb.internal;
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal/cache/Cache.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.kb.internal.cache;
import ai.grakn.concept.RelationshipType;
import ai.grakn.concept.Role;
import ai.grakn.kb.internal.concept.ConceptImpl;
import javax.annotation.Nullable;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Supplier;
/**
* <p>
* An internal cached element
* </p>
*
* <p>
* An internal cached object which hits the database only when it needs to.
* This is used to cache the components of ontological concepts. i.e. the fields of {@link ai.grakn.concept.Type},
* {@link RelationshipType}, and {@link Role}.
* </p>
*
* @param <V> The object it is caching
*
* @author fppt
*
*/
public class Cache<V> {
//If no cache can produce the data then the database is read
private final Supplier<V> databaseReader;
//Use to copy the cached value safely
private final Cacheable<V> cacheable;
//Transaction bound. If this is not set it does not yet exist in the scope of the transaction.
private final ThreadLocal<V> valueTx = new ThreadLocal<>();
//Globally bound value which has already been persisted and acts as a shared component cache
private Optional<V> valueGlobal = Optional.empty();
//Flag indicating if this Cache should be flushed into the Session cache upon being disposed of
private final boolean isSessionCache;
//Flag indicating if this Cache can be cleared.
// If this is false then the owner object must be deleted and garabe collected for the cache to die
private final boolean isClearable;
private Cache(CacheOwner owner, Cacheable<V> cacheable, boolean isSessionCache, boolean isClearable, Supplier<V> databaseReader){
this.isSessionCache = isSessionCache;
this.isClearable = isClearable;
this.cacheable = cacheable;
this.databaseReader = databaseReader;
owner.registerCache(this);
}
/**
* Creates a {@link Cache} that will only exist within the context of a Transaction
*/
public static Cache createTxCache(CacheOwner owner, Cacheable cacheable, Supplier databaseReader){
return new Cache(owner, cacheable, false, true, databaseReader);
}
/**
* Creates a {@link Cache} that will only flush to a central shared cache then the Transaction is disposed off
*/
public static Cache createSessionCache(CacheOwner owner, Cacheable cacheable, Supplier databaseReader){
return new Cache(owner, cacheable, true, true, databaseReader);
}
/**
* Creates a session level {@link Cache} which cannot be cleared.
* When creating these types of {@link Cache}s the only way to get rid of them is to remove the owner {@link ConceptImpl}
*/
public static Cache createPersistentCache(CacheOwner owner, Cacheable cacheable, Supplier databaseReader) {
return new Cache(owner, cacheable, true, false, databaseReader);
}
/**
* Retrieves the object in the cache. If nothing is cached the database is read.
*
* @return The cached object.
*/
@Nullable
public V get(){
V value = valueTx.get();
if(value != null) return value;
if(valueGlobal.isPresent()) value = cacheable.copy(valueGlobal.get());
if(value == null) value = databaseReader.get();
if(value == null) return null;
valueTx.set(value);
return valueTx.get();
}
/**
* Clears the cache.
*/
public void clear(){
if(isClearable) {
valueTx.remove();
}
}
/**
* Explicitly set the cache to a provided value
*
* @param value the value to be cached
*/
public void set(@Nullable V value){
valueTx.set(value);
}
/**
*
* @return true if there is anything stored in the cache
*/
public boolean isPresent(){
return valueTx.get() != null || valueGlobal.isPresent();
}
/**
* Mutates the cached value if something is cached. Otherwise does nothing.
*
* @param modifier the mutator function.
*/
public void ifPresent(Consumer<V> modifier){
if(isPresent()){
modifier.accept(get());
}
}
/**
* Takes the current value in the transaction cache if it is present and puts it in the valueGlobal reference so
* that it can be accessed via all transactions.
*/
public void flush(){
if(isSessionCache && isPresent()) {
V newValue = get();
if(!valueGlobal.isPresent() || !valueGlobal.get().equals(newValue)) valueGlobal = Optional.of(get());
}
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal/cache/CacheOwner.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.kb.internal.cache;
import ai.grakn.concept.Concept;
import java.util.Collection;
/**
* <p>
* Indicates a {@link Cache} is contained within the class
* </p>
*
* <p>
* Wraps up behaviour which needs to be handled whenever a {@link Cache} is used in a class
* </p>
*
* @author fppt
*
*/
public interface CacheOwner {
/**
*
* @return all the caches beloning to the {@link CacheOwner}
*/
Collection<Cache> caches();
/**
* Clears the internal {@link Cache}
*/
default void txCacheClear() {
caches().forEach(Cache::clear);
}
/**
* Registers a {@link Cache} so that later it can be cleaned up
*/
default void registerCache(Cache cache) {
caches().add(cache);
}
/**
* Flushes the internal transaction caches so they can refresh with persisted graph
*/
default void txCacheFlush(){
caches().forEach(Cache::flush);
}
/**
* Helper method to cast {@link Concept} into {@link CacheOwner}
*/
static CacheOwner from(Concept concept){
return (CacheOwner) concept;
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal/cache/Cacheable.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.kb.internal.cache;
import ai.grakn.concept.Concept;
import ai.grakn.concept.ConceptId;
import ai.grakn.concept.Label;
import ai.grakn.concept.LabelId;
import ai.grakn.kb.internal.structure.Shard;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.UnaryOperator;
/**
* <p>
* Contains the functionality needed to add an {@link Object} to {@link Cache}
* </p>
*
* <p>
* This is used to wrap functionality needed by {@link Cache}.
* Specifically it is used to ensure that when flushing {@link Cache#valueGlobal} into {@link Cache#valueTx}
* no cache leaks can occur. For example this is needed when caching {@link java.util.Collection}
* </p>
*
* @author fppt
*
* @param <V>
*/
public class Cacheable<V> {
private final UnaryOperator<V> copier;
private Cacheable(UnaryOperator<V> copier){
this.copier = copier;
}
// Constructors for supported cache-able items
public static Cacheable<ConceptId> conceptId(){
return new Cacheable<>((o) -> o);
}
public static Cacheable<Long> number(){
return new Cacheable<>((o) -> o);
}
public static Cacheable<Label> label(){
return new Cacheable<>((o) -> o);
}
public static Cacheable<LabelId> labelId(){
return new Cacheable<>((o) -> o);
}
public static Cacheable<Boolean> bool(){
return new Cacheable<>((o) -> o);
}
public static Cacheable<Shard> shard(){
return new Cacheable<>((o) -> o);
}
public static <T extends Concept> Cacheable<T> concept(){
return new Cacheable<>((o) -> o);
}
public static <T> Cacheable<Set<T>> set(){
return new Cacheable<>(HashSet::new);
}
public static <K, T> Cacheable<Map<K, T>> map(){
return new Cacheable<>(HashMap::new);
}
/**
* Copies the old value into a new value. How this copying is done is dictated by {@link Cacheable#copier}
*
* @param oldValue The old value
* @return the new value as defined by {@link Cacheable#copier}
*/
public V copy(V oldValue){
return copier.apply(oldValue);
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal/cache/GlobalCache.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.kb.internal.cache;
import ai.grakn.GraknConfigKey;
import ai.grakn.concept.Label;
import ai.grakn.concept.LabelId;
import ai.grakn.concept.SchemaConcept;
import ai.grakn.engine.GraknConfig;
import ai.grakn.kb.internal.concept.SchemaConceptImpl;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.collect.ImmutableMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* <p>
* Tracks Knowledge Base Specific Variables
* </p>
*
* <p>
* Caches Knowledge Base or Session specific data which is shared across transactions:
* <ol>
* <li>Schema Cache - All the types which make up the schema. This cache expires</li>
* <li>
* Label Cache - All the labels which make up the schema. This can never expire and is needed in order
* to perform fast lookups. Essentially it is used for mapping labels to ids.
* </li>
* <ol/>
* </p>
*
* @author fppt
*
*/
public class GlobalCache {
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
//Caches
private final Cache<Label, SchemaConcept> cachedTypes;
private final Map<Label, LabelId> cachedLabels;
public GlobalCache(GraknConfig config) {
cachedLabels = new ConcurrentHashMap<>();
int cacheTimeout = config.getProperty(GraknConfigKey.SESSION_CACHE_TIMEOUT_MS);
cachedTypes = CacheBuilder.newBuilder()
.maximumSize(1000)
.expireAfterAccess(cacheTimeout, TimeUnit.MILLISECONDS)
.build();
}
void populateSchemaTxCache(TxCache txCache){
try {
lock.writeLock().lock();
Map<Label, SchemaConcept> cachedSchemaSnapshot = getCachedTypes();
Map<Label, LabelId> cachedLabelsSnapshot = getCachedLabels();
//Read central cache into txCache cloning only base concepts. Sets clones later
for (SchemaConcept type : cachedSchemaSnapshot.values()) {
txCache.cacheConcept(type);
}
//Load Labels Separately. We do this because the TypeCache may have expired.
cachedLabelsSnapshot.forEach(txCache::cacheLabel);
} finally {
lock.writeLock().unlock();
}
}
/**
* Caches a type so that we can retrieve ontological concepts without making a DB read.
*
* @param label The label of the type to cache
* @param type The type to cache
*/
public void cacheType(Label label, SchemaConcept type) {
cachedTypes.put(label, type);
}
/**
* Caches a label so we can map type labels to type ids. This is necesssary so we can make fast
* indexed lookups.
*
* @param label The label of the type to cache
* @param id The id of the type to cache
*/
public void cacheLabel(Label label, LabelId id) {
cachedLabels.put(label, id);
}
/**
* Reads the {@link SchemaConcept} and their {@link Label} currently in the transaction cache
* into the graph cache. This usually happens when a commit occurs and allows us to track schema
* mutations without having to read the graph.
*
* @param txCache The transaction cache
*/
void readTxCache(TxCache txCache) {
//Check if the ontology has been changed and should be flushed into this cache
if(!cachedLabels.equals(txCache.getLabelCache())) {
try {
lock.readLock().lock();
//Clear the cache
cachedLabels.clear();
cachedTypes.invalidateAll();
//Add a new one
cachedLabels.putAll(txCache.getLabelCache());
cachedTypes.putAll(txCache.getSchemaConceptCache());
} finally {
lock.readLock().unlock();
}
}
//Flush All The Internal Transaction Caches
txCache.getSchemaConceptCache().values().forEach(schemaConcept
-> SchemaConceptImpl.from(schemaConcept).txCacheFlush());
}
/**
* A copy of the cached labels. This is used when creating a new transaction.
*
* @return an immutable copy of the cached labels.
*/
private Map<Label, LabelId> getCachedLabels() {
return ImmutableMap.copyOf(cachedLabels);
}
/**
* A copy of the cached schema. This is used when creating a new transaction.
*
* @return an immutable copy of the cached schema.
*/
public Map<Label, SchemaConcept> getCachedTypes() {
return ImmutableMap.copyOf(cachedTypes.asMap());
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal/cache/TxCache.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.kb.internal.cache;
import ai.grakn.GraknTxType;
import ai.grakn.concept.Concept;
import ai.grakn.concept.ConceptId;
import ai.grakn.concept.Label;
import ai.grakn.concept.LabelId;
import ai.grakn.concept.Relationship;
import ai.grakn.concept.RelationshipType;
import ai.grakn.concept.Role;
import ai.grakn.concept.Rule;
import ai.grakn.concept.SchemaConcept;
import ai.grakn.concept.Thing;
import ai.grakn.concept.Type;
import ai.grakn.kb.internal.concept.AttributeImpl;
import ai.grakn.kb.internal.structure.Casting;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
* <p>
* Tracks Transaction Specific Variables
* </p>
*
* <p>
* Caches Transaction specific data this includes:
* <ol>
* <li>Validation Concepts - Concepts which need to undergo validation.</li>
* <li>Built Concepts - Prevents rebuilding when the same vertex is encountered</li>
* <li>The Schema - Optimises validation checks by preventing db read. </li>
* <li> {@link Label} - Allows mapping type labels to type Ids</li>
* <li>Transaction meta Data - Allows transactions to function in different ways</li>
* <ol/>
* </p>
*
* @author fppt
*
*/
public class TxCache{
//Cache which is shared across multiple transactions
private final GlobalCache globalCache;
//Caches any concept which has been touched before
private final Map<ConceptId, Concept> conceptCache = new HashMap<>();
private final Map<Label, SchemaConcept> schemaConceptCache = new HashMap<>();
private final Map<Label, LabelId> labelCache = new HashMap<>();
//Elements Tracked For Validation
private final Set<Relationship> newRelationships = new HashSet<>();
private final Set<Thing> modifiedThings = new HashSet<>();
private final Set<Role> modifiedRoles = new HashSet<>();
private final Set<Casting> modifiedCastings = new HashSet<>();
private final Set<RelationshipType> modifiedRelationshipTypes = new HashSet<>();
private final Set<Rule> modifiedRules = new HashSet<>();
//We Track the number of concept connections which have been made which may result in a new shard
private final Map<ConceptId, Long> shardingCount = new HashMap<>();
//New attributes are tracked so that we can merge any duplicate attributes in post.
// This is a map of attribute indices to concept ids
// The index and id are directly cached to prevent unneeded reads
private Multimap<String, ConceptId> newAttributes = ArrayListMultimap.create();
//Transaction Specific Meta Data
private boolean isTxOpen = false;
private boolean writeOccurred = false;
private GraknTxType txType;
private String closedReason = null;
public TxCache(GlobalCache globalCache) {
this.globalCache = globalCache;
}
/**
* A helper method which writes back into the graph cache at the end of a transaction.
*
* @param isSafe true only if it is safe to copy the cache completely without any checks
*/
public void writeToGraphCache(boolean isSafe){
//When a commit has occurred or a transaction is read only all types can be overridden this is because we know they are valid.
//When it is not safe to simply flush we have to check that no mutations were made
if(isSafe || ! writeOccurred){
globalCache.readTxCache(this);
}
}
/**
* Notifies the cache that a write has occurred.
* This is later used to determine if it is safe to flush the transaction cache to the session cache or not.
*/
public void writeOccurred(){
writeOccurred = true;
}
/**
*
* @return true if ths schema labels have been cached. The graph cannot operate if this is false.
*/
public boolean schemaNotCached(){
return labelCache.isEmpty();
}
/**
* Refreshes the transaction schema cache by reading the central schema cache is read into this transaction cache.
* This method performs this operation whilst making a deep clone of the cached concepts to ensure transactions
* do not accidentally break the central schema cache.
*
*/
public void refreshSchemaCache(){
globalCache.populateSchemaTxCache(this);
}
/**
*
* @param concept The element to be later validated
*/
public void trackForValidation(Concept concept) {
if (concept.isThing()) {
modifiedThings.add(concept.asThing());
} else if (concept.isRole()) {
modifiedRoles.add(concept.asRole());
} else if (concept.isRelationshipType()) {
modifiedRelationshipTypes.add(concept.asRelationshipType());
} else if (concept.isRule()){
modifiedRules.add(concept.asRule());
}
}
public void trackForValidation(Casting casting) {
modifiedCastings.add(casting);
}
public void removeFromValidation(Type type){
if (type.isRelationshipType()) {
modifiedRelationshipTypes.remove(type.asRelationshipType());
}
}
/**
*
* @return All the types that have gained or lost instances and by how much
*/
public Map<ConceptId, Long> getShardingCount(){
return shardingCount;
}
/**
*
* @return All the types currently cached in the transaction. Used for
*/
Map<Label, SchemaConcept> getSchemaConceptCache(){
return schemaConceptCache;
}
/**
*
* @return All the types labels currently cached in the transaction.
*/
Map<Label, LabelId> getLabelCache(){
return labelCache;
}
/**
*
* @return All the concepts which have been accessed in this transaction
*/
Map<ConceptId, Concept> getConceptCache() {
return conceptCache;
}
/**
*
* @param concept The concept to no longer track
*/
@SuppressWarnings("SuspiciousMethodCalls")
public void remove(Concept concept){
modifiedThings.remove(concept);
modifiedRoles.remove(concept);
modifiedRelationshipTypes.remove(concept);
modifiedRules.remove(concept);
if(concept.isAttribute()) {
newAttributes.removeAll(AttributeImpl.from(concept.asAttribute()).getIndex());
}
if(concept.isRelationship()){
newRelationships.remove(concept.asRelationship());
}
conceptCache.remove(concept.id());
if (concept.isSchemaConcept()) {
Label label = concept.asSchemaConcept().label();
schemaConceptCache.remove(label);
labelCache.remove(label);
}
}
public void remove(Casting casting){
modifiedCastings.remove(casting);
}
/**
* Caches a concept so it does not have to be rebuilt later.
*
* @param concept The concept to be cached.
*/
public void cacheConcept(Concept concept){
conceptCache.put(concept.id(), concept);
if(concept.isSchemaConcept()){
SchemaConcept schemaConcept = concept.asSchemaConcept();
schemaConceptCache.put(schemaConcept.label(), schemaConcept);
labelCache.put(schemaConcept.label(), schemaConcept.labelId());
}
}
/**
* Caches the mapping of a type label to a type id. This is necessary in order for ANY types to be looked up.
*
* @param label The type label to cache
* @param id Its equivalent id which can be looked up quickly in the graph
*/
void cacheLabel(Label label, LabelId id){
labelCache.put(label, id);
}
/**
* Checks if the concept has been built before and is currently cached
*
* @param id The id of the concept
* @return true if the concept is cached
*/
public boolean isConceptCached(ConceptId id){
return conceptCache.containsKey(id);
}
/**
*
* @param label The label of the type to cache
* @return true if the concept is cached
*/
public boolean isTypeCached(Label label){
return schemaConceptCache.containsKey(label);
}
/**
*
* @param label the type label which may be in the cache
* @return true if the label is cached and has a valid mapping to a id
*/
public boolean isLabelCached(Label label){
return labelCache.containsKey(label);
}
/**
* Returns a previously built concept
*
* @param id The id of the concept
* @param <X> The type of the concept
* @return The cached concept
*/
public <X extends Concept> X getCachedConcept(ConceptId id){
//noinspection unchecked
return (X) conceptCache.get(id);
}
/**
* Returns a previously built type
*
* @param label The label of the type
* @param <X> The type of the type
* @return The cached type
*/
public <X extends SchemaConcept> X getCachedSchemaConcept(Label label){
//noinspection unchecked
return (X) schemaConceptCache.get(label);
}
public LabelId convertLabelToId(Label label){
return labelCache.get(label);
}
public void addedInstance(ConceptId conceptId){
shardingCount.compute(conceptId, (key, value) -> value == null ? 1 : value + 1);
cleanupShardingCount(conceptId);
}
public void removedInstance(ConceptId conceptId){
shardingCount.compute(conceptId, (key, value) -> value == null ? -1 : value - 1);
cleanupShardingCount(conceptId);
}
private void cleanupShardingCount(ConceptId conceptId){
if(shardingCount.get(conceptId) == 0) shardingCount.remove(conceptId);
}
public void addNewAttribute(String index, ConceptId conceptId){
newAttributes.put(index, conceptId);
}
public Map<String, Set<ConceptId>> getNewAttributes() {
Map<String, Set<ConceptId>> map = new HashMap<>();
newAttributes.asMap().forEach((attrValue, conceptIds) -> map.put(attrValue, new HashSet<>(conceptIds)));
return map;
}
//--------------------------------------- Concepts Needed For Validation -------------------------------------------
public Set<Thing> getModifiedThings() {
return modifiedThings;
}
public Set<Role> getModifiedRoles() {
return modifiedRoles;
}
public Set<RelationshipType> getModifiedRelationshipTypes() {
return modifiedRelationshipTypes;
}
public Set<Rule> getModifiedRules() {
return modifiedRules;
}
public Set<Casting> getModifiedCastings() {
return modifiedCastings;
}
public void addNewRelationship(Relationship relationship){
newRelationships.add(relationship);
}
public Set<Relationship> getNewRelationships() {
return newRelationships;
}
//--------------------------------------- Transaction Specific Meta Data -------------------------------------------
public void closeTx(String closedReason){
isTxOpen = false;
this.closedReason = closedReason;
//Clear Concept Caches
conceptCache.values().forEach(concept -> CacheOwner.from(concept).txCacheClear());
//Clear Collection Caches
modifiedThings.clear();
modifiedRoles.clear();
modifiedRelationshipTypes.clear();
modifiedRules.clear();
modifiedCastings.clear();
newAttributes.clear();
newRelationships.clear();
shardingCount.clear();
conceptCache.clear();
schemaConceptCache.clear();
labelCache.clear();
}
public void openTx(GraknTxType txType){
isTxOpen = true;
this.txType = txType;
closedReason = null;
}
public boolean isTxOpen(){
return isTxOpen;
}
public GraknTxType txType(){
return txType;
}
public String getClosedReason(){
return closedReason;
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal/cache/TxRuleCache.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package ai.grakn.kb.internal.cache;
import ai.grakn.concept.Rule;
import ai.grakn.concept.SchemaConcept;
import ai.grakn.kb.internal.EmbeddedGraknTx;
import ai.grakn.util.Schema;
import com.google.common.collect.Sets;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* Caches rules applicable to schema concepts and their conversion to InferenceRule object (parsing is expensive when large number of rules present).
* NB: non-committed rules are alse cached.
*
* @author Kasper Piskorski
*/
public class TxRuleCache {
private final Map<SchemaConcept, Set<Rule>> ruleMap = new HashMap<>();
private final Map<Rule, Object> ruleConversionMap = new HashMap<>();
private final EmbeddedGraknTx tx;
public TxRuleCache(EmbeddedGraknTx tx){
this.tx = tx;
}
/**
* @return set of inference rules contained in the graph
*/
public Stream<Rule> getRules() {
Rule metaRule = tx.getMetaRule();
return metaRule.subs().filter(sub -> !sub.equals(metaRule));
}
/**
* @param type to be update
* @param rule to be appended
* @return updated entry vlue
*/
public Set<Rule> updateRules(SchemaConcept type, Rule rule){
Set<Rule> match = ruleMap.get(type);
if (match == null){
Set<Rule> rules = Sets.newHashSet(rule);
getTypes(type, false).stream()
.flatMap(SchemaConcept::thenRules)
.forEach(rules::add);
ruleMap.put(type, rules);
return rules;
}
match.add(rule);
return match;
}
/**
* @param type for which rules containing it in the head are sought
* @return rules containing specified type in the head
*/
public Stream<Rule> getRulesWithType(SchemaConcept type){
return getRulesWithType(type, false);
}
private Set<SchemaConcept> getTypes(SchemaConcept type, boolean direct) {
Set<SchemaConcept> types = direct ? Sets.newHashSet(type) : type.subs().collect(Collectors.toSet());
return type.isImplicit()?
types.stream().flatMap(t -> Stream.of(t, tx.getSchemaConcept(Schema.ImplicitType.explicitLabel(t.label())))).collect(Collectors.toSet()):
types;
}
/**
* @param type for which rules containing it in the head are sought
* @param direct way of assessing isa edges
* @return rules containing specified type in the head
*/
public Stream<Rule> getRulesWithType(SchemaConcept type, boolean direct){
if (type == null) return getRules();
Set<Rule> match = ruleMap.get(type);
if (match != null) return match.stream();
Set<Rule> rules = new HashSet<>();
ruleMap.put(type, rules);
return getTypes(type, direct).stream()
.flatMap(SchemaConcept::thenRules)
.peek(rules::add);
}
/**
*
* @param rule for which the parsed rule should be retrieved
* @param converter rule converter
* @param <T> type of object converter converts to
* @return parsed rule object
*/
public <T> T getRule(Rule rule, Supplier<T> converter){
T match = (T) ruleConversionMap.get(rule);
if (match != null) return match;
T newMatch = converter.get();
ruleConversionMap.put(rule, newMatch);
return newMatch;
}
/**
* cleans cache contents
*/
public void closeTx(){
ruleMap.clear();
ruleConversionMap.clear();
}
}
|
0
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal
|
java-sources/ai/grakn/grakn-kb/1.4.3/ai/grakn/kb/internal/cache/package-info.java
|
/*
* GRAKN.AI - THE KNOWLEDGE GRAPH
* Copyright (C) 2018 Grakn Labs Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
/**
* Internal implementation of caching mechanism used by any {@link ai.grakn.GraknTx}
*/
package ai.grakn.kb.internal.cache;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.