index
int64 | repo_id
string | file_path
string | content
string |
|---|---|---|---|
0
|
java-sources/ai/grakn/grakn-titan-factory/0.10.0/ai/grakn
|
java-sources/ai/grakn/grakn-titan-factory/0.10.0/ai/grakn/factory/TitanInternalFactory.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.factory;
import ai.grakn.graph.internal.GraknTitanGraph;
import ai.grakn.util.ErrorMessage;
import ai.grakn.util.Schema;
import com.thinkaurelius.titan.core.EdgeLabel;
import com.thinkaurelius.titan.core.PropertyKey;
import com.thinkaurelius.titan.core.RelationType;
import com.thinkaurelius.titan.core.TitanFactory;
import com.thinkaurelius.titan.core.TitanGraph;
import com.thinkaurelius.titan.core.VertexLabel;
import com.thinkaurelius.titan.core.schema.TitanIndex;
import com.thinkaurelius.titan.core.schema.TitanManagement;
import org.apache.tinkerpop.gremlin.process.traversal.Order;
import org.apache.tinkerpop.gremlin.structure.Direction;
import org.apache.tinkerpop.gremlin.structure.Transaction;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.Set;
/**
* <p>
* A Grakn Graph on top of {@link TitanGraph}
* </p>
*
* <p>
* This produces an in memory grakn graph on top of {@link TitanGraph}.
* The base construction process defined by {@link AbstractInternalFactory} ensures the graph factories are singletons.
* </p>
*
* @author fppt
*/
class TitanInternalFactory extends AbstractInternalFactory<GraknTitanGraph, TitanGraph> {
private final static String DEFAULT_CONFIG = "backend-default";
TitanInternalFactory(String keyspace, String engineUrl, Properties properties) {
super(keyspace, engineUrl, properties);
}
@Override
boolean isClosed(TitanGraph innerGraph) {
return innerGraph.isClosed();
}
@Override
public TitanGraph getGraphWithNewTransaction(TitanGraph graph){
if(!graph.tx().isOpen()){
graph.tx().open();
}
return graph;
}
@Override
GraknTitanGraph buildGraknGraphFromTinker(TitanGraph graph, boolean batchLoading) {
return new GraknTitanGraph(graph, super.keyspace, super.engineUrl, batchLoading);
}
@Override
TitanGraph buildTinkerPopGraph(boolean batchLoading) {
return newTitanGraph(super.keyspace, super.engineUrl, super.properties, batchLoading);
}
private synchronized TitanGraph newTitanGraph(String name, String address, Properties properties, boolean batchLoading){
TitanGraph titanGraph = configureGraph(name, address, properties, batchLoading);
buildTitanIndexes(titanGraph);
titanGraph.tx().onClose(Transaction.CLOSE_BEHAVIOR.ROLLBACK);
return titanGraph;
}
private TitanGraph configureGraph(String name, String address, Properties properties, boolean batchLoading){
//Load default properties if none provided
if(properties == null){
properties = new Properties();
InputStream in = getClass().getResourceAsStream(DEFAULT_CONFIG);
try {
properties.load(in);
in.close();
} catch (IOException e) {
throw new RuntimeException(ErrorMessage.INVALID_PATH_TO_CONFIG.getMessage(DEFAULT_CONFIG), e);
}
}
TitanFactory.Builder builder = TitanFactory.build().
set("storage.hostname", address).
set("storage.cassandra.keyspace", name).
set("storage.batch-loading", batchLoading);
properties.entrySet().forEach(entry-> builder.set(entry.getKey().toString(), entry.getValue()));
return builder.open();
}
private static void buildTitanIndexes(TitanGraph graph) {
TitanManagement management = graph.openManagement();
makeVertexLabels(management);
makeEdgeLabels(management);
makePropertyKeys(management);
makeIndicesVertexCentric(management);
makeIndicesComposite(management);
management.commit();
}
private static void makeEdgeLabels(TitanManagement management){
for (Schema.EdgeLabel edgeLabel : Schema.EdgeLabel.values()) {
EdgeLabel label = management.getEdgeLabel(edgeLabel.getLabel());
if(label == null)
management.makeEdgeLabel(edgeLabel.getLabel()).make();
}
}
private static void makeVertexLabels(TitanManagement management){
for (Schema.BaseType baseType : Schema.BaseType.values()) {
VertexLabel foundLabel = management.getVertexLabel(baseType.name());
if(foundLabel == null) {
management.makeVertexLabel(baseType.name()).make();
}
}
}
private static void makeIndicesVertexCentric(TitanManagement management){
ResourceBundle keys = ResourceBundle.getBundle("indices-edges");
Set<String> edgeLabels = keys.keySet();
for(String edgeLabel : edgeLabels){
String properties = keys.getString(edgeLabel);
if(properties.length() > 0){
String[] propertyKey = keys.getString(edgeLabel).split(",");
for (String aPropertyKey : propertyKey) {
PropertyKey key = management.getPropertyKey(aPropertyKey);
if (key == null)
throw new RuntimeException("Trying to create edge index on label [" + edgeLabel + "] but the property [" + aPropertyKey + "] does not exist");
RelationType relationType = management.getRelationType(edgeLabel);
if (management.getRelationIndex(relationType, edgeLabel + "by" + aPropertyKey) == null) {
EdgeLabel label = management.getEdgeLabel(edgeLabel);
management.buildEdgeIndex(label, edgeLabel + "by" + aPropertyKey, Direction.OUT, Order.decr, key);
}
}
}
}
}
private static void makePropertyKeys(TitanManagement management){
Arrays.stream(Schema.ConceptProperty.values()).forEach(property ->
makePropertyKey(management, property.name(), property.getDataType()));
Arrays.stream(Schema.EdgeProperty.values()).forEach(property ->
makePropertyKey(management, property.name(), property.getDataType()));
}
private static void makePropertyKey(TitanManagement management, String propertyKey, Class type){
if (management.getPropertyKey(propertyKey) == null) {
management.makePropertyKey(propertyKey).dataType(type).make();
}
}
private static void makeIndicesComposite(TitanManagement management){
ResourceBundle keys = ResourceBundle.getBundle("indices-composite");
Set<String> keyString = keys.keySet();
for(String propertyKeyLabel : keyString){
String indexLabel = "by" + propertyKeyLabel;
TitanIndex index = management.getGraphIndex(indexLabel);
if(index == null) {
boolean isUnique = Boolean.parseBoolean(keys.getString(propertyKeyLabel));
PropertyKey key = management.getPropertyKey(propertyKeyLabel);
TitanManagement.IndexBuilder indexBuilder = management.buildIndex(indexLabel, Vertex.class).addKey(key);
if (isUnique)
indexBuilder.unique();
indexBuilder.buildCompositeIndex();
}
}
}
}
|
0
|
java-sources/ai/grakn/grakn-titan-factory/0.10.0/ai/grakn/graph
|
java-sources/ai/grakn/grakn-titan-factory/0.10.0/ai/grakn/graph/internal/GraknTitanGraph.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.graph.internal;
import ai.grakn.exception.GraknBackendException;
import ai.grakn.exception.GraphRuntimeException;
import ai.grakn.util.ErrorMessage;
import com.thinkaurelius.titan.core.TitanException;
import com.thinkaurelius.titan.core.TitanGraph;
import com.thinkaurelius.titan.core.util.TitanCleanup;
import com.thinkaurelius.titan.graphdb.database.StandardTitanGraph;
/**
* <p>
* A Grakn Graph using {@link TitanGraph} as a vendor backend.
* </p>
*
* <p>
* Wraps up a {@link TitanGraph} as a method of storing the Grakn Graph object Model.
* With this vendor some issues to be aware of:
* 1. Whenever a transaction is closed if none remain open then the connection to the graph is closed permanently.
* 2. Clearing the graph explicitly closes the connection as well.
* </p>
*
* @author fppt
*/
public class GraknTitanGraph extends AbstractGraknGraph<TitanGraph> {
public GraknTitanGraph(TitanGraph graph, String name, String engineUrl, boolean batchLoading){
super(graph, name, engineUrl, batchLoading);
}
@Override
protected void clearGraph() {
TitanGraph titanGraph = getTinkerPopGraph();
titanGraph.close();
TitanCleanup.clear(titanGraph);
}
@Override
public void closeGraph(String reason){
finaliseClose(this::closeTitan, reason);
}
@Override
public TitanGraph getTinkerPopGraph(){
TitanGraph graph = super.getTinkerPopGraph();
if(graph.isClosed()){
throw new GraphRuntimeException(ErrorMessage.GRAPH_PERMANENTLY_CLOSED.getMessage(getKeyspace()));
} else {
return graph;
}
}
@Override
public void commitTx(){
try {
super.commitTx();
} catch (TitanException e){
throw new GraknBackendException(e);
}
if(!getTinkerPopGraph().tx().isOpen()){
getTinkerPopGraph().tx().open(); //Until we sort out the transaction handling properly commits have to result in transactions being auto opened
}
}
private void closeTitan(){
StandardTitanGraph graph = (StandardTitanGraph) getTinkerPopGraph();
synchronized (graph) { //Have to block here because the list of open transactions in Titan is not thread safe.
if(graph.tx().isOpen())
graph.tx().close();
if (graph.getOpenTxs() == 0) {
closePermanent();
}
}
}
}
|
0
|
java-sources/ai/grakn/janus-factory/1.1.0/ai/grakn
|
java-sources/ai/grakn/janus-factory/1.1.0/ai/grakn/factory/JanusPreviousPropertyStep.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.factory;
import org.apache.tinkerpop.gremlin.process.traversal.Pop;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
import org.apache.tinkerpop.gremlin.process.traversal.step.Scoping;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.FlatMapStep;
import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
import org.janusgraph.core.JanusGraphTransaction;
import org.janusgraph.core.JanusGraphVertex;
import org.janusgraph.graphdb.tinkerpop.optimize.JanusGraphTraversalUtil;
import java.util.Collections;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.Objects;
import java.util.Set;
import static java.util.Collections.emptyIterator;
/**
* Optimise a particular traversal in Janus:
* <p>
* <code>
* g.V().outE().values(c).as(b).V().filter(__.properties(a).where(P.eq(b)));
* </code>
* <p>
* This step can be used in place of {@code V().filter(..)} since we are referring to a previously visited property in
* the traversal.
*
* @author Felix Chapman
*/
class JanusPreviousPropertyStep<S> extends FlatMapStep<S, JanusGraphVertex> implements Scoping {
private static final long serialVersionUID = -8906462828437711078L;
private final String propertyKey;
private final String stepLabel;
/**
* @param traversal the traversal that contains this step
* @param propertyKey the property key that we are looking up
* @param stepLabel
* the step label that refers to a previously visited value in the traversal.
* e.g. in {@code g.V().as(b)}, {@code b} is a step label.
*/
JanusPreviousPropertyStep(Traversal.Admin traversal, String propertyKey, String stepLabel) {
super(traversal);
this.propertyKey = Objects.requireNonNull(propertyKey);
this.stepLabel = Objects.requireNonNull(stepLabel);
}
@Override
protected Iterator<JanusGraphVertex> flatMap(Traverser.Admin<S> traverser) {
JanusGraphTransaction tx = JanusGraphTraversalUtil.getTx(this.traversal);
// Retrieve property value to look-up, that is identified in the traversal by the `stepLabel`
Object value = getNullableScopeValue(Pop.first, stepLabel, traverser);
return value != null ? verticesWithProperty(tx, value) : emptyIterator();
}
/**
* Look up vertices in Janus which have a property {@link JanusPreviousPropertyStep#propertyKey} with the given
* value.
* @param tx the Janus transaction to read from
* @param value the value that the property should have
*/
private Iterator<JanusGraphVertex> verticesWithProperty(JanusGraphTransaction tx, Object value) {
return tx.query().has(propertyKey, value).vertices().iterator();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if (!super.equals(o)) return false;
JanusPreviousPropertyStep<?> that = (JanusPreviousPropertyStep<?>) o;
return propertyKey.equals(that.propertyKey) && stepLabel.equals(that.stepLabel);
}
@Override
public int hashCode() {
int result = super.hashCode();
result = 31 * result + propertyKey.hashCode();
result = 31 * result + stepLabel.hashCode();
return result;
}
@Override
public String toString() {
return StringFactory.stepString(this, propertyKey, stepLabel);
}
@Override
public Set<String> getScopeKeys() {
return Collections.singleton(stepLabel);
}
@Override
public Set<TraverserRequirement> getRequirements() {
// This step requires being able to access previously visited properties in the traversal,
// so it needs `LABELED_PATH`.
return EnumSet.of(TraverserRequirement.LABELED_PATH);
}
}
|
0
|
java-sources/ai/grakn/janus-factory/1.1.0/ai/grakn
|
java-sources/ai/grakn/janus-factory/1.1.0/ai/grakn/factory/JanusPreviousPropertyStepStrategy.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.factory;
import org.apache.tinkerpop.gremlin.process.traversal.Compare;
import org.apache.tinkerpop.gremlin.process.traversal.P;
import org.apache.tinkerpop.gremlin.process.traversal.Step;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy.ProviderOptimizationStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.TraversalFilterStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.WherePredicateStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.PropertiesStep;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.AbstractTraversalStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import java.util.List;
import java.util.Optional;
/**
* Optimisation applied to use Janus indices in the following additional case:
* <p>
* <code>
* g.V().outE().values(c).as(b).V().filter(__.properties(a).where(P.eq(b)));
* </code>
* <p>
* In this instance, the vertex can be looked up directly in Janus, joining the {@code V().filter(..)}
* steps together.
*
* @author Felix Chapman
*/
public class JanusPreviousPropertyStepStrategy
extends AbstractTraversalStrategy<ProviderOptimizationStrategy> implements ProviderOptimizationStrategy {
private static final long serialVersionUID = 6888929702831948298L;
@Override
public void apply(Traversal.Admin<?, ?> traversal) {
// Retrieve all graph (`V()`) steps - this is the step the strategy should replace
List<GraphStep> graphSteps = TraversalHelper.getStepsOfAssignableClass(GraphStep.class, traversal);
for (GraphStep graphStep : graphSteps) {
// For each graph step, confirm it follows this pattern:
// `V().filter(__.properties(a).where(P.eq(b)))`
if (!(graphStep.getNextStep() instanceof TraversalFilterStep)) continue;
TraversalFilterStep<Vertex> filterStep = (TraversalFilterStep<Vertex>) graphStep.getNextStep();
// Retrieve the filter steps e.g. `__.properties(a).where(P.eq(b))`
List<Step> steps = stepsFromFilterStep(filterStep);
if (steps.size() < 2) continue;
Step propertiesStep = steps.get(0); // This is `properties(a)`
Step whereStep = steps.get(1); // This is `filter(__.where(P.eq(b)))`
// Get the property key `a`
if (!(propertiesStep instanceof PropertiesStep)) continue;
Optional<String> propertyKey = propertyFromPropertiesStep((PropertiesStep<Vertex>) propertiesStep);
if (!propertyKey.isPresent()) continue;
// Get the step label `b`
if (!(whereStep instanceof WherePredicateStep)) continue;
Optional<String> label = labelFromWhereEqPredicate((WherePredicateStep<Vertex>) whereStep);
if (!label.isPresent()) continue;
executeStrategy(traversal, graphStep, filterStep, propertyKey.get(), label.get());
}
}
private List<Step> stepsFromFilterStep(TraversalFilterStep<Vertex> filterStep) {
// TraversalFilterStep always has exactly one child, so this is safe
return filterStep.getLocalChildren().get(0).getSteps();
}
private Optional<String> propertyFromPropertiesStep(PropertiesStep<Vertex> propertiesStep) {
String[] propertyKeys = propertiesStep.getPropertyKeys();
if (propertyKeys.length != 1) return Optional.empty();
return Optional.of(propertyKeys[0]);
}
private Optional<String> labelFromWhereEqPredicate(WherePredicateStep<Vertex> whereStep) {
Optional<P<?>> optionalPredicate = whereStep.getPredicate();
return optionalPredicate.flatMap(predicate -> {
if (!predicate.getBiPredicate().equals(Compare.eq)) return Optional.empty();
return Optional.of((String) predicate.getValue());
});
}
/**
* Replace the {@code graphStep} and {@code filterStep} with a new {@link JanusPreviousPropertyStep} in the given
* {@code traversal}.
*/
private void executeStrategy(
Traversal.Admin<?, ?> traversal, GraphStep<?, ?> graphStep, TraversalFilterStep<Vertex> filterStep,
String propertyKey, String label) {
JanusPreviousPropertyStep newStep = new JanusPreviousPropertyStep(traversal, propertyKey, label);
traversal.removeStep(filterStep);
TraversalHelper.replaceStep(graphStep, newStep, traversal);
}
}
|
0
|
java-sources/ai/grakn/janus-factory/1.1.0/ai/grakn
|
java-sources/ai/grakn/janus-factory/1.1.0/ai/grakn/factory/TxFactoryJanus.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.factory;
import ai.grakn.GraknSession;
import ai.grakn.GraknTx;
import ai.grakn.kb.internal.GraknTxJanus;
import ai.grakn.util.ErrorMessage;
import ai.grakn.util.Schema;
import com.google.common.collect.ImmutableMap;
import org.apache.tinkerpop.gremlin.process.traversal.Order;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.LazyBarrierStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.PathRetractionStrategy;
import org.apache.tinkerpop.gremlin.structure.Direction;
import org.apache.tinkerpop.gremlin.structure.Transaction;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.janusgraph.core.EdgeLabel;
import org.janusgraph.core.JanusGraph;
import org.janusgraph.core.JanusGraphFactory;
import org.janusgraph.core.Namifiable;
import org.janusgraph.core.PropertyKey;
import org.janusgraph.core.RelationType;
import org.janusgraph.core.VertexLabel;
import org.janusgraph.core.schema.JanusGraphIndex;
import org.janusgraph.core.schema.JanusGraphManagement;
import org.janusgraph.graphdb.database.StandardJanusGraph;
import org.janusgraph.graphdb.transaction.StandardJanusGraphTx;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;
import static java.util.Arrays.stream;
/**
* <p>
* A {@link GraknTx} on top of {@link JanusGraph}
* </p>
*
* <p>
* This produces a grakn graph on top of {@link JanusGraph}.
* The base construction process defined by {@link TxFactoryAbstract} ensures the graph factories are singletons.
* </p>
*
* @author fppt
*/
final public class TxFactoryJanus extends TxFactoryAbstract<GraknTxJanus, JanusGraph> {
private final static Logger LOG = LoggerFactory.getLogger(TxFactoryJanus.class);
private static final AtomicBoolean strategiesApplied = new AtomicBoolean(false);
//These properties are loaded in by default and can optionally be overwritten
static final Properties DEFAULT_PROPERTIES;
static {
String DEFAULT_CONFIG = "default-configs.properties";
DEFAULT_PROPERTIES = new Properties();
try (InputStream in = TxFactoryJanus.class.getClassLoader().getResourceAsStream(DEFAULT_CONFIG)) {
DEFAULT_PROPERTIES.load(in);
in.close();
} catch (IOException e) {
throw new RuntimeException(ErrorMessage.INVALID_PATH_TO_CONFIG.getMessage(DEFAULT_CONFIG), e);
}
}
/**
* This map is used to override hidden config files.
* The key of the map refers to the key of the properties file that gets passed in which provides the value to be injected.
* The value of the map specifies the key to inject into.
*/
private static final Map<String, String> overrideMap = ImmutableMap.of(
"storage.backend", "janusmr.ioformat.conf.storage.backend",
"storage.hostname", "janusmr.ioformat.conf.storage.hostname"
);
//This maps the storage backend to the needed value
private static final Map<String, String> storageBackendMapper = ImmutableMap.of("grakn-production", "cassandra");
TxFactoryJanus(GraknSession session) {
super(session);
}
@Override
public JanusGraph getGraphWithNewTransaction(JanusGraph graph, boolean batchloading){
if(graph.isClosed()) graph = buildTinkerPopGraph(batchloading);
if(!graph.tx().isOpen()){
graph.tx().open();
}
return graph;
}
@Override
GraknTxJanus buildGraknGraphFromTinker(JanusGraph graph) {
return new GraknTxJanus(session(), graph);
}
@Override
JanusGraph buildTinkerPopGraph(boolean batchLoading) {
return newJanusGraph(batchLoading);
}
private synchronized JanusGraph newJanusGraph(boolean batchLoading){
JanusGraph JanusGraph = configureGraph(batchLoading);
buildJanusIndexes(JanusGraph);
JanusGraph.tx().onClose(Transaction.CLOSE_BEHAVIOR.ROLLBACK);
if (!strategiesApplied.getAndSet(true)) {
TraversalStrategies strategies = TraversalStrategies.GlobalCache.getStrategies(StandardJanusGraph.class);
strategies = strategies.clone().addStrategies(new JanusPreviousPropertyStepStrategy());
//TODO: find out why Tinkerpop added these strategies. They result in many NoOpBarrier steps which slowed down our queries so we had to remove them.
strategies.removeStrategies(PathRetractionStrategy.class, LazyBarrierStrategy.class);
TraversalStrategies.GlobalCache.registerStrategies(StandardJanusGraph.class, strategies);
TraversalStrategies.GlobalCache.registerStrategies(StandardJanusGraphTx.class, strategies);
}
return JanusGraph;
}
private JanusGraph configureGraph(boolean batchLoading){
JanusGraphFactory.Builder builder = JanusGraphFactory.build().
set("storage.hostname", session().uri()).
set("storage.cassandra.keyspace", session().keyspace().getValue()).
set("storage.batch-loading", batchLoading);
String storageBackend = "storage.backend";
//Load Defaults
DEFAULT_PROPERTIES.forEach((key, value) -> builder.set(key.toString(), value));
//Load Passed in properties
session().config().properties().forEach((key, value) -> {
//Overwrite storage
if(key.equals(storageBackend)){
value = storageBackendMapper.get(value);
}
//Inject properties into other default properties
if(overrideMap.containsKey(key)){
builder.set(overrideMap.get(key), value);
}
builder.set(key.toString(), value);
});
LOG.debug("Opening graph on {}", session().uri());
return builder.open();
}
private static void buildJanusIndexes(JanusGraph graph) {
JanusGraphManagement management = graph.openManagement();
makeVertexLabels(management);
makeEdgeLabels(management);
makePropertyKeys(management);
makeIndicesVertexCentric(management);
makeIndicesComposite(management);
management.commit();
}
private static void makeEdgeLabels(JanusGraphManagement management){
for (Schema.EdgeLabel edgeLabel : Schema.EdgeLabel.values()) {
EdgeLabel label = management.getEdgeLabel(edgeLabel.getLabel());
if(label == null) {
management.makeEdgeLabel(edgeLabel.getLabel()).make();
}
}
}
private static void makeVertexLabels(JanusGraphManagement management){
for (Schema.BaseType baseType : Schema.BaseType.values()) {
VertexLabel foundLabel = management.getVertexLabel(baseType.name());
if(foundLabel == null) {
management.makeVertexLabel(baseType.name()).make();
}
}
}
private static void makeIndicesVertexCentric(JanusGraphManagement management){
ResourceBundle keys = ResourceBundle.getBundle("indices-edges");
Set<String> edgeLabels = keys.keySet();
for(String edgeLabel : edgeLabels){
String[] propertyKeyStrings = keys.getString(edgeLabel).split(",");
//Get all the property keys we need
Set<PropertyKey> propertyKeys = stream(propertyKeyStrings).map(keyId ->{
PropertyKey key = management.getPropertyKey(keyId);
if (key == null) {
throw new RuntimeException("Trying to create edge index on label [" + edgeLabel + "] but the property [" + keyId + "] does not exist");
}
return key;
}).collect(Collectors.toSet());
//Get the edge and indexing information
RelationType relationType = management.getRelationType(edgeLabel);
EdgeLabel label = management.getEdgeLabel(edgeLabel);
//Create index on each property key
for (PropertyKey key : propertyKeys) {
if (management.getRelationIndex(relationType, edgeLabel + "by" + key.name()) == null) {
management.buildEdgeIndex(label, edgeLabel + "by" + key.name(), Direction.BOTH, Order.decr, key);
}
}
//Create index on all property keys
String propertyKeyId = propertyKeys.stream().map(Namifiable::name).collect(Collectors.joining("_"));
if (management.getRelationIndex(relationType, edgeLabel + "by" + propertyKeyId) == null) {
PropertyKey [] allKeys = propertyKeys.toArray(new PropertyKey[propertyKeys.size()]);
management.buildEdgeIndex(label, edgeLabel + "by" + propertyKeyId, Direction.BOTH, Order.decr, allKeys);
}
}
}
private static void makePropertyKeys(JanusGraphManagement management){
stream(Schema.VertexProperty.values()).forEach(property ->
makePropertyKey(management, property.name(), property.getDataType()));
stream(Schema.EdgeProperty.values()).forEach(property ->
makePropertyKey(management, property.name(), property.getDataType()));
}
private static void makePropertyKey(JanusGraphManagement management, String propertyKey, Class type){
if (management.getPropertyKey(propertyKey) == null) {
management.makePropertyKey(propertyKey).dataType(type).make();
}
}
private static void makeIndicesComposite(JanusGraphManagement management){
ResourceBundle keys = ResourceBundle.getBundle("indices-composite");
Set<String> keyString = keys.keySet();
for(String propertyKeyLabel : keyString){
String indexLabel = "by" + propertyKeyLabel;
JanusGraphIndex index = management.getGraphIndex(indexLabel);
if(index == null) {
boolean isUnique = Boolean.parseBoolean(keys.getString(propertyKeyLabel));
PropertyKey key = management.getPropertyKey(propertyKeyLabel);
JanusGraphManagement.IndexBuilder indexBuilder = management.buildIndex(indexLabel, Vertex.class).addKey(key);
if (isUnique) {
indexBuilder.unique();
}
indexBuilder.buildCompositeIndex();
}
}
}
}
|
0
|
java-sources/ai/grakn/janus-factory/1.1.0/ai/grakn
|
java-sources/ai/grakn/janus-factory/1.1.0/ai/grakn/factory/TxFactoryJanusHadoop.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.factory;
import ai.grakn.GraknSession;
import ai.grakn.kb.internal.GraknTxAbstract;
import ai.grakn.util.ErrorMessage;
import org.apache.tinkerpop.gremlin.hadoop.structure.HadoopGraph;
import org.apache.tinkerpop.gremlin.structure.util.GraphFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* <p>
* A {@link ai.grakn.GraknTx} on top of {@link HadoopGraph}
* </p>
*
* <p>
* This produces a graph on top of {@link HadoopGraph}.
* The base construction process defined by {@link TxFactoryAbstract} ensures the graph factories are singletons.
* With this vendor some exceptions are in places:
* 1. The Grakn API cannnot work on {@link HadoopGraph} this is due to not being able to directly write to a
* {@link HadoopGraph}.
* 2. This factory primarily exists as a means of producing a
* {@link org.apache.tinkerpop.gremlin.process.computer.GraphComputer} on of {@link HadoopGraph}
* </p>
*
* @author fppt
*/
public class TxFactoryJanusHadoop extends TxFactoryAbstract<GraknTxAbstract<HadoopGraph>, HadoopGraph> {
private static final String CLUSTER_KEYSPACE = "janusmr.ioformat.conf.storage.cassandra.keyspace";
private static final String INPUT_KEYSPACE = "cassandra.input.keyspace";
private final Logger LOG = LoggerFactory.getLogger(TxFactoryJanusHadoop.class);
TxFactoryJanusHadoop(GraknSession session) {
super(session);
session().config().properties().setProperty(CLUSTER_KEYSPACE, session().keyspace().getValue());
session().config().properties().setProperty(INPUT_KEYSPACE, session().keyspace().getValue());
}
@Override
GraknTxAbstract<HadoopGraph> buildGraknGraphFromTinker(HadoopGraph graph) {
throw new UnsupportedOperationException(ErrorMessage.CANNOT_PRODUCE_TX.getMessage(HadoopGraph.class.getName()));
}
@Override
HadoopGraph buildTinkerPopGraph(boolean batchLoading) {
LOG.warn("Hadoop graph ignores parameter address [" + session().uri() + "]");
//Load Defaults
TxFactoryJanus.DEFAULT_PROPERTIES.forEach((key, value) -> {
if(!session().config().properties().containsKey(key)){
session().config().properties().put(key, value);
}
});
return (HadoopGraph) GraphFactory.open(session().config().properties());
}
//TODO: Get rid of the need for batch loading parameter
@Override
protected HadoopGraph getGraphWithNewTransaction(HadoopGraph graph, boolean batchloading) {
return graph;
}
}
|
0
|
java-sources/ai/grakn/janus-factory/1.1.0/ai/grakn/kb
|
java-sources/ai/grakn/janus-factory/1.1.0/ai/grakn/kb/internal/GraknTxJanus.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.kb.internal;
import ai.grakn.GraknSession;
import ai.grakn.GraknTx;
import ai.grakn.GraknTxType;
import ai.grakn.concept.ConceptId;
import ai.grakn.exception.GraknBackendException;
import ai.grakn.exception.TemporaryWriteException;
import ai.grakn.kb.internal.structure.VertexElement;
import ai.grakn.util.Schema;
import org.apache.tinkerpop.gremlin.structure.Element;
import org.janusgraph.core.JanusGraph;
import org.janusgraph.core.JanusGraphElement;
import org.janusgraph.core.JanusGraphException;
import org.janusgraph.core.util.JanusGraphCleanup;
import org.janusgraph.diskstorage.locking.PermanentLockingException;
import org.janusgraph.diskstorage.locking.TemporaryLockingException;
import org.janusgraph.graphdb.database.StandardJanusGraph;
import java.util.function.Supplier;
/**
* <p>
* A {@link GraknTx} using {@link JanusGraph} as a vendor backend.
* </p>
*
* <p>
* Wraps up a {@link JanusGraph} as a method of storing the {@link GraknTx} object Model.
* With this vendor some issues to be aware of:
* 1. Whenever a transaction is closed if none remain open then the connection to the graph is closed permanently.
* 2. Clearing the graph explicitly closes the connection as well.
* </p>
*
* @author fppt
*/
public class GraknTxJanus extends GraknTxAbstract<JanusGraph> {
public GraknTxJanus(GraknSession session, JanusGraph graph){
super(session, graph);
}
@Override
public void openTransaction(GraknTxType txType){
super.openTransaction(txType);
if(getTinkerPopGraph().isOpen() && !getTinkerPopGraph().tx().isOpen()) getTinkerPopGraph().tx().open();
}
@Override
public boolean isSessionClosed() {
return getTinkerPopGraph().isClosed();
}
@Override
public int numOpenTx() {
return ((StandardJanusGraph) getTinkerPopGraph()).getOpenTransactions().size();
}
@Override
protected void clearGraph() {
JanusGraphCleanup.clear(getTinkerPopGraph());
}
@Override
public void commitTransactionInternal(){
executeLockingMethod(() -> {
super.commitTransactionInternal();
return null;
});
}
@Override
public VertexElement addVertexElement(Schema.BaseType baseType, ConceptId... conceptIds){
return executeLockingMethod(() -> super.addVertexElement(baseType, conceptIds));
}
/**
* Executes a method which has the potential to throw a {@link TemporaryLockingException} or a {@link PermanentLockingException}.
* If the exception is thrown it is wrapped in a {@link GraknBackendException} so that the transaction can be retried.
*
* @param method The locking method to execute
*/
private <X> X executeLockingMethod(Supplier<X> method){
try {
return method.get();
} catch (JanusGraphException e){
if(e.isCausedBy(TemporaryLockingException.class) || e.isCausedBy(PermanentLockingException.class)){
throw TemporaryWriteException.temporaryLock(e);
} else {
throw GraknBackendException.unknown(e);
}
}
}
@Override
public boolean isValidElement(Element element) {
return super.isValidElement(element) && !((JanusGraphElement) element).isRemoved();
}
}
|
0
|
java-sources/ai/grakn/kgms/client/1.4.3/ai/grakn
|
java-sources/ai/grakn/kgms/client/1.4.3/ai/grakn/client/ClientFactory.java
|
package ai.grakn.client;
import ai.grakn.Keyspace;
import ai.grakn.kgms.console.rpc.GrpcChannelFactory;
import ai.grakn.rpc.proto.SessionProto;
import ai.grakn.util.SimpleURI;
import io.grpc.ManagedChannel;
import java.nio.file.Path;
public class ClientFactory {
private final Grakn.OpenRequestBuilder openRequestBuilder;
private final SimpleURI uri;
public ClientFactory(SimpleURI uri, String username, String password) {
this.uri = uri;
this.openRequestBuilder = (type, keyspace) -> {
SessionProto.Transaction.Open.Req req = SessionProto.Transaction.Open.Req.newBuilder()
.setKeyspace(keyspace.getValue())
.setType(SessionProto.Transaction.Type.valueOf(type.getId()))
.setUsername(username)
.setPassword(password)
.build();
return SessionProto.Transaction.Req.newBuilder().setOpenReq(req).build();
};
}
public Grakn client() {
ManagedChannel channel = GrpcChannelFactory.getChannel(uri);
return new Grakn(channel, openRequestBuilder);
}
public Grakn encryptedClient(){
ManagedChannel channel = GrpcChannelFactory.getEncryptedChannel(uri);
return new Grakn(channel, openRequestBuilder);
}
public Grakn.Session encryptedClient(Keyspace keyspace, Path trustedStorePath) {
ManagedChannel channel = GrpcChannelFactory.getEncryptedChannel(uri, trustedStorePath);
return new Grakn(channel, openRequestBuilder).session(keyspace);
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/KGMSConsole.java
|
package ai.grakn.kgms.console;
import ai.grakn.GraknConfigKey;
import ai.grakn.engine.GraknConfig;
import ai.grakn.kgms.console.command.CommandBus;
import ai.grakn.kgms.console.command.PrintWriterNotRecognised;
import ai.grakn.kgms.console.command.createuser.CreateUserCommand;
import ai.grakn.kgms.console.command.createuser.CreateUserDisplay;
import ai.grakn.kgms.console.command.deleteuser.DeleteUserCommand;
import ai.grakn.kgms.console.command.deleteuser.DeleteUserDisplay;
import ai.grakn.kgms.console.command.retrieveallusers.RetrieveAllUserCommand;
import ai.grakn.kgms.console.command.retrieveallusers.RetrieveAllUserDisplay;
import ai.grakn.kgms.console.command.retrieveuser.RetrieveUserCommand;
import ai.grakn.kgms.console.command.retrieveuser.RetrieveUserDisplay;
import ai.grakn.kgms.console.command.updateuser.UpdateUserCommand;
import ai.grakn.kgms.console.command.updateuser.UpdateUserDisplay;
import ai.grakn.kgms.console.rpc.GrpcChannelFactory;
import ai.grakn.kgms.console.rpc.ResponseListener;
import ai.grakn.kgms.console.rpc.UserManagementClient;
import ai.grakn.kgms.rpc.generated.KGMSConsoleGrpc;
import ai.grakn.util.SimpleURI;
import io.grpc.ManagedChannel;
import jline.console.ConsoleReader;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Nullable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.nio.file.Paths;
import java.util.concurrent.ArrayBlockingQueue;
/**
* KGMS Authenticated Console that can be run from command line
*
* @author Marco Scoppetta
*/
public class KGMSConsole {
private static final Logger LOG = LoggerFactory.getLogger(KGMSConsole.class);
private static final String PROMPT = ">>> ";
private static final String USERNAME = "u";
private static final String PASSWORD = "p";
private static final String CONTACT_POINT = "c";
private static final String TLS = "tls";
private static final String TRUST_MANAGER = "tm";
private static final String EXIT_COMMAND = "exit";
private PrintWriter outPrinter;
private final ConsoleReader console;
private final ManagedChannel channel;
private final CommandBus commandBus;
private final UserManagementClient userManagementClient;
public static void main(String[] args) {
int exitCode = (startConsole(args, System.in, System.out, GraknConfig.create())) ? 0 : 1;
System.exit(exitCode);
}
public static boolean startConsole(String[] args, InputStream in, OutputStream out, GraknConfig config) {
try {
CommandLine cmd = initialiseCommandLine(args);
String username = cmd.getOptionValue('u');
String password = cmd.getOptionValue('p');
ManagedChannel channel = getChannel(cmd, config);
KGMSConsole console = new KGMSConsole(in, out, channel);
console.start(username, password);
} catch (IOException | ParseException e) {
LOG.error("Unable to start KGMS console", e);
return false;
}
return true;
}
KGMSConsole(InputStream in, OutputStream out, ManagedChannel channel) throws IOException {
this.console = new ConsoleReader(in, out);
this.outPrinter = new PrintWriter(console.getOutput());
this.channel = channel;
ResponseListener responseListener = new ResponseListener(new ArrayBlockingQueue<>(1));
this.userManagementClient = new UserManagementClient(KGMSConsoleGrpc.newStub(channel), responseListener);
this.commandBus = initialiseCommandBus();
registerShutdownHook();
}
void start(@Nullable String username, @Nullable String password) throws IOException {
if (username == null) {
username = console.readLine("Username: ");
}
if (password == null) {
password = console.readLine("Passsword: ", '*');
}
userManagementClient.login(username, password);
authenticatedShell();
}
private void authenticatedShell() throws IOException {
console.setPrompt(PROMPT);
String line;
while ((line = console.readLine()) != null) {
// Handle exit command here as we need to close client and channel
if (line.trim().equals(EXIT_COMMAND)) {
close();
return;
}
commandBus.run(line);
}
}
void close() {
userManagementClient.close();
this.channel.shutdown();
}
// -------- Helpers ---------- //
private CommandBus initialiseCommandBus() {
return new CommandBus(new PrintWriterNotRecognised(this.outPrinter),
new CreateUserCommand(userManagementClient, new CreateUserDisplay(this.outPrinter)),
new RetrieveAllUserCommand(userManagementClient, new RetrieveAllUserDisplay(this.outPrinter)),
new DeleteUserCommand(userManagementClient, new DeleteUserDisplay(this.outPrinter)),
new RetrieveUserCommand(userManagementClient, new RetrieveUserDisplay(this.outPrinter)),
new UpdateUserCommand(userManagementClient, new UpdateUserDisplay(this.outPrinter)));
}
private static ManagedChannel getChannel(CommandLine cmd, GraknConfig config) {
// Define contact point with Server
SimpleURI contactPoint;
if (cmd.hasOption('c')) {
contactPoint = new SimpleURI(cmd.getOptionValue('c'));
} else {
contactPoint = new SimpleURI(config.getProperty(GraknConfigKey.SERVER_HOST_NAME) + ":" + config.getProperty(GraknConfigKey.GRPC_PORT));
}
// Determine whether the connection needs to be encrypted
boolean encryptionEnabled = Boolean.valueOf(cmd.getOptionValue(TLS));
// Load path to trust manager for self-signed certificates (this is optional)
String trustManager = cmd.getOptionValue(TRUST_MANAGER);
if (encryptionEnabled) {
if (trustManager == null) {
return GrpcChannelFactory.getEncryptedChannel(contactPoint);
} else {
return GrpcChannelFactory.getEncryptedChannel(contactPoint, Paths.get(trustManager));
}
} else {
return GrpcChannelFactory.getChannel(contactPoint);
}
}
private static CommandLine initialiseCommandLine(String[] args) throws ParseException {
Options options = new Options();
//TODO: unify this options object with KGMSShellOptions
options.addOption(USERNAME, "username", true, "username of admin user");
options.addOption(PASSWORD, "password", true, "password of admin user");
options.addOption(CONTACT_POINT, "contact-point", true, "contact point for gRPC server");
options.addOption(TLS, "enable-tls", false, "enable TLS encryption");
options.addOption(TRUST_MANAGER, "trust-manager", true, "path to trust manager for self-signed certificates");
CommandLineParser parser = new DefaultParser();
CommandLine cmd;
cmd = parser.parse(options, args);
return cmd;
}
/**
* If user uses CTRL+C to close console we try our best to terminate gracefully.
*/
private void registerShutdownHook() {
Runtime.getRuntime().addShutdownHook(new Thread(() -> close()));
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/Command.java
|
package ai.grakn.kgms.console.command;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public abstract class Command {
final public void handle(String command) {
Matcher matcher = pattern().matcher(command);
boolean matches = matcher.matches();
if (matches) {
handleParsed(command, matcher);
} else {
throw new CommandNotMatchedException();
}
}
final public boolean recognize(String command) {
return pattern().matcher(command).matches();
}
protected abstract Pattern pattern();
protected abstract void handleParsed(String command, Matcher matcher);
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/CommandBus.java
|
package ai.grakn.kgms.console.command;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
public class CommandBus {
private final NotRecognised unrecognized;
private final List<Command> commands;
public CommandBus(NotRecognised unrecognized, Command... commands) {
this.unrecognized = unrecognized;
this.commands = Arrays.asList(commands);
}
public void run(String command) {
Optional<Command> cmdc = commands.stream()
.filter((cmd) -> cmd.recognize(command)).findAny();
if (cmdc.isPresent()) {
cmdc.get().handle(command);
} else {
unrecognized.handle(command);
}
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/CommandNotMatchedException.java
|
package ai.grakn.kgms.console.command;
import ai.grakn.kgms.util.ErrorMessage;
public class CommandNotMatchedException extends RuntimeException {
public CommandNotMatchedException() {
super(ErrorMessage.ERROR_COMMAND_NOT_MATCHED.getMessage());
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/NotRecognised.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.kgms.console.command;
public interface NotRecognised {
void handle(String command);
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/PrintStreamNotRecognised.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.kgms.console.command;
import java.io.PrintStream;
public class PrintStreamNotRecognised implements NotRecognised {
private final PrintStream output;
public PrintStreamNotRecognised(PrintStream output) {
this.output = output;
}
@Override
public void handle(String command) {
output.println("Command '"+command+"' not recognized");
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/PrintWriterNotRecognised.java
|
package ai.grakn.kgms.console.command;
import java.io.PrintWriter;
public class PrintWriterNotRecognised implements NotRecognised {
private final PrintWriter output;
public PrintWriterNotRecognised(PrintWriter output) {
this.output = output;
}
@Override
public void handle(String command) {
output.println("Command '" + command + "' not recognized");
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/createuser/CreateUserCommand.java
|
package ai.grakn.kgms.console.command.createuser;
import ai.grakn.kgms.console.command.Command;
import ai.grakn.kgms.console.rpc.UserManagementClient;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class CreateUserCommand extends Command {
private final Pattern pattern = Pattern.compile(
"\\s*CREATE USER\\s+([0-9a-zA-Z]+)\\s+" +
"WITH PASSWORD\\s+([0-9a-zA-Z]+)\\s*"// + "WITH ROLE\\s+([a-z]+)\\s*" re-enable when adding Authorisation
, Pattern.CASE_INSENSITIVE
);
private final UserManagementClient client;
private final CreateUserDisplay display;
public CreateUserCommand(UserManagementClient client, CreateUserDisplay display) {
this.client = client;
this.display = display;
}
@Override
protected void handleParsed(String command, Matcher matcher) {
String username = matcher.group(1);
String password = matcher.group(2);
String role = "admin";//TODO: re-enable this when adding Authorisation -> matcher.group(3);
client.create(username, password, role);
display.created();
}
@Override
protected Pattern pattern() {
return pattern;
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/createuser/CreateUserDisplay.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.kgms.console.command.createuser;
import java.io.PrintWriter;
public class CreateUserDisplay {
private final PrintWriter output;
public CreateUserDisplay(PrintWriter output) {
this.output = output;
}
public void created() {
output.println("User created!");
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/deleteuser/DeleteUserCommand.java
|
package ai.grakn.kgms.console.command.deleteuser;
import ai.grakn.kgms.console.command.Command;
import ai.grakn.kgms.console.rpc.UserManagementClient;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class DeleteUserCommand extends Command {
private final Pattern pattern = Pattern.compile("\\s*DELETE USER\\s+([0-9a-zA-Z]+)\\s*", Pattern.CASE_INSENSITIVE);
private final DeleteUserDisplay display;
private final UserManagementClient client;
public DeleteUserCommand(UserManagementClient client, DeleteUserDisplay display) {
this.client = client;
this.display = display;
}
@Override
protected Pattern pattern() {
return pattern;
}
@Override
protected void handleParsed(String command, Matcher matcher) {
String username = matcher.group(1);
client.delete(username);
display.deleted();
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/deleteuser/DeleteUserDisplay.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.kgms.console.command.deleteuser;
import java.io.PrintWriter;
public class DeleteUserDisplay {
private final PrintWriter output;
public DeleteUserDisplay(PrintWriter output) {
this.output = output;
}
public void deleted() {
output.println("User deleted.");
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/retrieveallusers/RetrieveAllUserCommand.java
|
package ai.grakn.kgms.console.command.retrieveallusers;
import ai.grakn.kgms.authentication.model.User;
import ai.grakn.kgms.console.command.Command;
import ai.grakn.kgms.console.rpc.UserManagementClient;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RetrieveAllUserCommand extends Command {
private final Pattern pattern = Pattern.compile("\\s*LIST USERS\\s*", Pattern.CASE_INSENSITIVE);
private final UserManagementClient client;
private final RetrieveAllUserDisplay display;
public RetrieveAllUserCommand(UserManagementClient client, RetrieveAllUserDisplay display) {
this.client = client;
this.display = display;
}
@Override
protected Pattern pattern() { return pattern; }
@Override
protected void handleParsed(String command, Matcher matcher) {
List<User> users = client.retrieveAll();
display.retrieved(users);
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/retrieveallusers/RetrieveAllUserDisplay.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.kgms.console.command.retrieveallusers;
import ai.grakn.kgms.authentication.model.User;
import java.io.PrintWriter;
import java.util.List;
public class RetrieveAllUserDisplay {
private final PrintWriter output;
public RetrieveAllUserDisplay(PrintWriter output) {
this.output = output;
}
void retrieved(List<User> users) {
String leftAlignFormat = "| %-15s | %-5s |%n";
output.format("+-----------------+--------+%n");
output.format("| Username | Role |%n");
output.format("+-----------------+--------+%n");
for(User user : users){
output.format(leftAlignFormat, user.username(), user.role());
}
output.format("+-----------------+--------+%n");
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/retrieveuser/RetrieveUserCommand.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.kgms.console.command.retrieveuser;
import ai.grakn.kgms.authentication.model.User;
import ai.grakn.kgms.console.command.Command;
import ai.grakn.kgms.console.rpc.UserManagementClient;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RetrieveUserCommand extends Command {
private final Pattern pattern = Pattern.compile("\\s*GET USER\\s+([0-9a-zA-Z]+)\\s*", Pattern.CASE_INSENSITIVE);
private final UserManagementClient client;
private final RetrieveUserDisplay display;
public RetrieveUserCommand(UserManagementClient client, RetrieveUserDisplay display) {
this.client = client;
this.display = display;
}
@Override
protected Pattern pattern() {
return pattern;
}
@Override
protected void handleParsed(String command, Matcher matcher) {
String username = matcher.group(1);
User user = client.retrieve(username);
display.retrieved(user);
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/retrieveuser/RetrieveUserDisplay.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.kgms.console.command.retrieveuser;
import ai.grakn.kgms.authentication.model.User;
import java.io.PrintWriter;
public class RetrieveUserDisplay {
private final PrintWriter output;
public RetrieveUserDisplay(PrintWriter output) {
this.output = output;
}
void retrieved(User user) {
output.println("Username: " + user.username() + " - Role: " + user.role());
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/updateuser/UpdateUserCommand.java
|
package ai.grakn.kgms.console.command.updateuser;
import ai.grakn.kgms.console.command.Command;
import ai.grakn.kgms.console.rpc.UserManagementClient;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class UpdateUserCommand extends Command {
// TODO: re enable this when adding Authorisation
// private static final String UPDATE_USER = "\\s*UPDATE USER\\s+(?<username>[0-9a-zA-Z]+)";
// // Update only user password
// private static final String WITH_PASS = "(\\s+WITH PASSWORD\\s+([0-9a-zA-Z]+))";
// // Update only user role
// private static final String WITH_ROLE = "(\\s+WITH ROLE\\s+([0-9a-zA-Z]+)\\s*)";
// // Update user password and role
// private static final String WITH_PASS_OR_ROLE = "(?<roleandpassword>" + WITH_PASS + WITH_ROLE + ")" + "|" + "(?<rolegroup>" + WITH_ROLE + ")" + "|" + "(?<passwordgroup>" + WITH_PASS + ")";
//
// // This regex checks that the update user command has update of password or role or both.
// private final Pattern pattern = Pattern.compile("^" + UPDATE_USER + "(" + WITH_PASS_OR_ROLE + ")\\s*$", Pattern.CASE_INSENSITIVE);
private final Pattern pattern = Pattern.compile(
"\\s*UPDATE USER\\s+([0-9a-zA-Z]+)\\s+" +
"WITH PASSWORD\\s+([0-9a-zA-Z]+)\\s*"
, Pattern.CASE_INSENSITIVE
);
private final UserManagementClient client;
private final UpdateUserDisplay display;
public UpdateUserCommand(UserManagementClient client, UpdateUserDisplay display) {
this.client = client;
this.display = display;
}
@Override
protected void handleParsed(String command, Matcher matcher) {
// String username = matcher.group("username");
// String password = null;
// String role = null;
//
// if (matcher.group("roleandpassword") != null) {
// password = matcher.group(5);
// role = matcher.group(7);
// } else if (matcher.group("rolegroup") != null) {
// role = matcher.group(10);
// } else if (matcher.group("passwordgroup") != null) {
// password = matcher.group(13);
// }
String username = matcher.group(1);
String password = matcher.group(2);
client.update(username, password, null);
display.updated();
}
@Override
protected Pattern pattern() {
return pattern;
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/command/updateuser/UpdateUserDisplay.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.kgms.console.command.updateuser;
import java.io.PrintWriter;
public class UpdateUserDisplay {
private final PrintWriter output;
public UpdateUserDisplay(PrintWriter output) {
this.output = output;
}
public void updated() { output.println("User updated."); }
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/rpc/GrpcChannelFactory.java
|
package ai.grakn.kgms.console.rpc;
import ai.grakn.util.SimpleURI;
import io.grpc.ManagedChannel;
import io.grpc.netty.GrpcSslContexts;
import io.grpc.netty.NettyChannelBuilder;
import javax.net.ssl.SSLException;
import java.io.File;
import java.nio.file.Path;
/**
*
* Factory used to provide gRPC channels.
*
* - plain text channel, no encryption.
* - encrypted channel over TLS with valid/public Certificate from server
* - encrypted channel over TLS with self-signed Certificate from server
*
* @author Marco Scoppetta
*/
public class GrpcChannelFactory {
public static final int GRPC_MAX_MESSAGE_SIZE_IN_BYTES = Integer.MAX_VALUE; // 2 GB
// Get channel that works over plain text
public static ManagedChannel getChannel(SimpleURI uri){
return NettyChannelBuilder
.forAddress(uri.getHost(), uri.getPort())
.maxInboundMessageSize(GRPC_MAX_MESSAGE_SIZE_IN_BYTES)
.usePlaintext(true)
.build();
}
// Get encrypted channel over TLS using self-signed Certificate
public static ManagedChannel getEncryptedChannel(SimpleURI uri, Path trustedCertPath){
File trustedCert = new File(trustedCertPath.toString());
try {
return NettyChannelBuilder
.forAddress(uri.getHost(), uri.getPort())
.maxInboundMessageSize(GRPC_MAX_MESSAGE_SIZE_IN_BYTES)
.sslContext(GrpcSslContexts.forClient().trustManager(trustedCert).build())
.build();
} catch (SSLException e) {
throw new RuntimeException(e);
}
}
// Get encrypted channel over TLS using public Certificate
public static ManagedChannel getEncryptedChannel(SimpleURI uri){
return NettyChannelBuilder.forAddress(uri.getHost(), uri.getPort())
.maxInboundMessageSize(GRPC_MAX_MESSAGE_SIZE_IN_BYTES)
.build();
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/rpc/GrpcResponse.java
|
package ai.grakn.kgms.console.rpc;
import ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement;
public class GrpcResponse {
private boolean completed;
private UserManagement.Res response;
private Throwable throwable;
GrpcResponse(UserManagement.Res response) {
this.response = response;
this.completed = false;
}
GrpcResponse(Throwable throwable){
this.throwable = throwable;
this.completed = false;
}
GrpcResponse(){
this.completed = true;
}
public UserManagement.Res getResponse(){
return response;
}
public Throwable getException(){
return throwable;
}
public boolean isException(){
return (throwable != null);
}
public boolean isCompleted(){
return completed;
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/rpc/ResponseListener.java
|
package ai.grakn.kgms.console.rpc;
import ai.grakn.kgms.rpc.generated.KGMSConsoleProto;
import io.grpc.stub.StreamObserver;
import java.util.concurrent.BlockingQueue;
public class ResponseListener implements StreamObserver<KGMSConsoleProto.UserManagement.Res> {
private final BlockingQueue<GrpcResponse> queue;
public ResponseListener(BlockingQueue<GrpcResponse> queue) {
this.queue = queue;
}
@Override
public synchronized void onNext(KGMSConsoleProto.UserManagement.Res res) {
queue.add(new GrpcResponse(res));
}
@Override
public void onError(Throwable throwable) {
queue.add(new GrpcResponse(throwable));
}
@Override
public void onCompleted() {
queue.add(new GrpcResponse());
}
public GrpcResponse getResponse() throws InterruptedException {
return queue.take();
}
}
|
0
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console
|
java-sources/ai/grakn/kgms/console/1.4.3/ai/grakn/kgms/console/rpc/UserManagementClient.java
|
package ai.grakn.kgms.console.rpc;
import ai.grakn.kgms.authentication.model.User;
import ai.grakn.kgms.rpc.generated.KGMSConsoleGrpc;
import ai.grakn.kgms.rpc.generated.KGMSConsoleProto;
import io.grpc.stub.StreamObserver;
import java.util.List;
import java.util.stream.Collectors;
/**
* Class that provides use cases for User management over gRPC
*/
public class UserManagementClient {
private StreamObserver<KGMSConsoleProto.UserManagement.Req> requestSender;
private final ResponseListener responseListener;
private boolean terminated = false;
public UserManagementClient(KGMSConsoleGrpc.KGMSConsoleStub stub, ResponseListener responseListener) {
this.responseListener = responseListener;
requestSender = stub.userManagement(responseListener);
}
public void login(String username, String password) {
KGMSConsoleProto.Login.Req userRequest = KGMSConsoleProto.Login.Req.newBuilder()
.setUsername(username)
.setPassword(password)
.build();
KGMSConsoleProto.UserManagement.Req loginReq = KGMSConsoleProto.UserManagement.Req.newBuilder().setLoginReq(userRequest).build();
send(loginReq);
}
/**
* Send create user request to server
* NOTE: we ignore the response as we don't want to show it to the user
*/
public void create(String username, String password, String role) {
KGMSConsoleProto.Create.Req createReq = KGMSConsoleProto.Create.Req.newBuilder()
.setUsername(username)
.setPassword(password)
.setRole(role)
.build();
KGMSConsoleProto.UserManagement.Req req = KGMSConsoleProto.UserManagement.Req.newBuilder()
.setCreateReq(createReq).build();
send(req);
}
/**
* Send delete user request to server
* NOTE: we ignore the response as we don't want to show it to the user
*/
public void delete(String username) {
KGMSConsoleProto.Delete.Req deleteReq = KGMSConsoleProto.Delete.Req.newBuilder()
.setUsername(username).build();
KGMSConsoleProto.UserManagement.Req req = KGMSConsoleProto.UserManagement.Req.newBuilder()
.setDeleteReq(deleteReq).build();
send(req);
}
/**
* Send retrieve user request to server and return new User
*/
public User retrieve(String username) {
KGMSConsoleProto.Retrieve.Req retrieveReq = KGMSConsoleProto.Retrieve.Req.newBuilder()
.setUsername(username).build();
KGMSConsoleProto.UserManagement.Req req = KGMSConsoleProto.UserManagement.Req.newBuilder()
.setRetrieveReq(retrieveReq).build();
KGMSConsoleProto.UserManagement.Res response = send(req);
return new User(response.getRetrieveRes().getUser().getUsername(), response.getRetrieveRes().getUser().getRole());
}
/**
* Send retrieve all users request to server and return new User
*/
public List<User> retrieveAll() {
KGMSConsoleProto.RetrieveAll.Req retrieveAllReq = KGMSConsoleProto.RetrieveAll.Req.newBuilder().build();
KGMSConsoleProto.UserManagement.Req req = KGMSConsoleProto.UserManagement.Req.newBuilder()
.setRetrieveAllReq(retrieveAllReq).build();
KGMSConsoleProto.UserManagement.Res response = send(req);
return response.getRetrieveAllRes().getUsersList()
.stream()
.map(user -> new User(user.getUsername(), user.getRole()))
.collect(Collectors.toList());
}
/**
* Send create user request to server
* NOTE: we ignore the response as we don't want to show it to the user
*/
public void update(String username, String password, String role) {
KGMSConsoleProto.Update.Req.Builder updateReqBuilder = KGMSConsoleProto.Update.Req.newBuilder()
.setUsername(username);
if (password != null) updateReqBuilder.setPassword(password);
if (role != null) updateReqBuilder.setRole(role);
KGMSConsoleProto.UserManagement.Req req = KGMSConsoleProto.UserManagement.Req.newBuilder()
.setUpdateReq(updateReqBuilder.build()).build();
send(req);
}
/**
* Send UserManagement Request to Server and wait for response
*
* @return UserManagement Response
*/
private KGMSConsoleProto.UserManagement.Res send(KGMSConsoleProto.UserManagement.Req req) {
if (terminated) throw new RuntimeException("Connection is already closed.");
try {
requestSender.onNext(req);
GrpcResponse response = responseListener.getResponse();
if (response.isException()) throw response.getException();
if (response.isCompleted()) close(); //Note: this should never be the case, as it's always the Client completing the communication.
return response.getResponse();
} catch (Throwable e) {
close();
// Re throw Runtime exception as the client should terminate when getting exception from the Server
throw new RuntimeException(e);
}
}
public void close() {
if (terminated) return;
requestSender.onCompleted();
terminated = true;
}
}
|
0
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms/authentication
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms/authentication/model/User.java
|
package ai.grakn.kgms.authentication.model;
public class User {
private String username;
private String password;
private String role;
private boolean admin;
public User(String username, String password, String role) {
this.username = username;
this.password = password;
this.role = role;
this.admin = role.equals("admin");
}
public User(String username, boolean admin) {
this.username = username;
this.admin = admin;
this.role = (admin) ? "admin" : "user";
}
public User(String username, String role) {
this.username = username;
this.role = role;
this.admin = role.equals("admin");
}
/**
* We will use this getter until we properly support role.
* For now the only role a user can have are:
* - admin if the user is a Cassandra Superuser
* - user if the user is NOT a Cassandra Superuser
*/
public String role() {
return (admin) ? "admin" : "user";
}
public String username() {
return username;
}
public String password() {
return password;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
if (!username.equals(user.username)) return false;
if (password == null && user.password() != null) return false;
if (password != null && user.password() == null) return false;
if (password != null && user.password() != null && !password.equals(user.password)) return false;
return role.equals(user.role);
}
@Override
public int hashCode() {
int result = username.hashCode();
result = 31 * result + password.hashCode();
result = 31 * result + role.hashCode();
return result;
}
}
|
0
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms/repository/RepositoryDeleteByName.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.kgms.repository;
/**
*
*/
public interface RepositoryDeleteByName<T> {
void deleteByName(String id);
}
|
0
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms/repository/RepositoryLoadAll.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.kgms.repository;
import java.util.List;
/**
*
* Do not use this with cryptographic keys!
*
*/
public interface RepositoryLoadAll<T> {
//TODO: maybe implement pagination
List<T> load();
}
|
0
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms/repository/RepositoryLoadByName.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.kgms.repository;
/**
*
* Do not use this with cryptographic keys!
*
*/
public interface RepositoryLoadByName<T> {
T load(String id);
}
|
0
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms/repository/RepositorySaveByName.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.kgms.repository;
/**
*
* Do not use this with cryptographic keys!
*
*/
public interface RepositorySaveByName<T> {
T save(String id, T obj);
}
|
0
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms/repository/RepositoryUpdateByName.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.kgms.repository;
/**
*
* Interface implemented by repositories that allow updating an object by id.
*
*/
public interface RepositoryUpdateByName<T> {
T update(String id, T obj);
}
|
0
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms/repository/UserRepository.java
|
package ai.grakn.kgms.repository;
import ai.grakn.kgms.authentication.model.User;
import java.util.List;
public interface UserRepository {
void deleteByName(String name);
List<User> loadAll();
User loadByName(String name);
User saveByName(String name, User user);
User updateByName(String name, User user);
}
|
0
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms/repository/UserRepositoryFactory.java
|
package ai.grakn.kgms.repository;
import ai.grakn.kgms.authentication.model.User;
public interface UserRepositoryFactory {
RepositorySaveByName<User> repositorySaveUserByName();
RepositoryLoadByName<User> repositoryLoadUserByName();
RepositoryLoadAll<User> repositoryLoadAllUsers();
RepositoryDeleteByName<User> repositoryDeleteUserByName();
RepositoryUpdateByName<User> repositoryUpdateUserByName();
}
|
0
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms
|
java-sources/ai/grakn/kgms/core/1.4.3/ai/grakn/kgms/util/ErrorMessage.java
|
package ai.grakn.kgms.util;
/**
* Enum containing error messages.
*
* Each error message contains a single format string, with a method {@link ErrorMessage#getMessage(Object...)} that
* accepts arguments to be passed to the format string.
*
*/
public enum ErrorMessage {
// --------- Bootup errors -------------
UNABLE_TO_START_GRAKN("Unable to start Grakn"),
UNABLE_TO_GET_GRAKN_HOME_FOLDER("Unable to find Grakn home folder"),
UNABLE_TO_GET_GRAKN_CONFIG_FOLDER("Unable to find Grakn config folder"),
UNRECOGNISED_COMMAND_SUPPLIED("Unrecognised command supplied: '%s' with options '%s'"),
// --------- Grakn PIDs errors -------------
COULD_NOT_GET_GRAKN_PID("Unable to get Grakn process id. Received [%s]"),
UNABLE_TO_RETRIEVE_PID("Unable to retrieve process id. The Operating System returned exit code: %s"),
// --------- Monitoring errors -------------
UNABLE_TO_READ_MONITORING_LOCKFILE("Unable to read monitoring lock file at [%s]"),
// -------------------------------------- Post-processing And Distributed Locks Error -----------------------------
QUEUE_ALREADY_STARTED("Queue has already been started"),
QUEUE_NOT_YET_STARTED("Queue not yet started"),
// -------------------------------------- Authentication Errors -----------------------------
INCORRECT_PASSWORD_PROVIDED("Incorrect password provided."),
NO_PERMISSION_TO_ACCESS_RESOURCE("Current user does not have appropriate permissions to access this resource."),
UNKNOWN_RESOURCE_TO_AUTHORISE("Unknown resource to authorise."),
AUTHENTICATION_NEEDED_TO_ACCESS_RESOURCE("Authentication needed to access this resource."),
USER_NOT_FOUND("User [%s] not found."),
INVALID_TOKEN_PROVIDED("The provided authenticated token is not valid."),
//--------------------------------------------- Repository Errors -----------------------------------------------
REPOSITORY_ERORR_OBJECT_NOT_FOUND("[%s] not found"),
REPOSITORY_ERORR_OBJECT_ALREADY_PRESENT("[%s] already present"),
//--------------------------------------------- Console Errors -----------------------------------------------
ERROR_COMMAND_NOT_MATCHED("If a command doesn't match, it should not be run");
private final String message;
ErrorMessage(String message) {
this.message = message;
}
public String getMessage(Object... args) {
return String.format(message, args);
}
}
|
0
|
java-sources/ai/grakn/kgms/grakn-kgms-client/1.2.0/ai/grakn
|
java-sources/ai/grakn/kgms/grakn-kgms-client/1.2.0/ai/grakn/kgms/KGMSClientShell.java
|
package ai.grakn.kgms;
import ai.grakn.GraknConfigKey;
import ai.grakn.engine.GraknConfig;
import ai.grakn.kgms.authentication.service.SignedToken;
import ai.grakn.kgms.console.AuthenticatedCommandBus;
import ai.grakn.kgms.console.AuthenticatedCommandBusImpl;
import ai.grakn.kgms.console.PrintWriterNotRecognised;
import ai.grakn.kgms.console.authentication.createuser.CreateUserCommand;
import ai.grakn.kgms.console.authentication.createuser.CreateUserDisplay;
import ai.grakn.kgms.console.authentication.deleteuser.DeleteUserCommand;
import ai.grakn.kgms.console.authentication.deleteuser.DeleteUserDisplay;
import ai.grakn.kgms.console.authentication.retrieveallusers.RetrieveAllUserCommand;
import ai.grakn.kgms.console.authentication.retrieveallusers.RetrieveAllUserDisplay;
import ai.grakn.kgms.console.authentication.retrieveuser.RetrieveUserCommand;
import ai.grakn.kgms.console.authentication.retrieveuser.RetrieveUserDisplay;
import ai.grakn.kgms.console.authentication.updateuser.UpdateUserCommand;
import ai.grakn.kgms.console.authentication.updateuser.UpdateUserDisplay;
import ai.grakn.kgms.rpc.GrpcClient;
import ai.grakn.util.SimpleURI;
import jline.console.ConsoleReader;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Nullable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.nio.file.Path;
import static ai.grakn.GraknConfigKey.GRPC_PORT;
/**
* KGMS Authenticated gRPC Shell that can be run from command line
*
* @author Marco Scoppetta
*/
public class KGMSClientShell {
private static final Logger LOG = LoggerFactory.getLogger(KGMSClientShell.class);
private static final GraknConfigKey<Path> KGMS_TRUST_STORE_PATH = GraknConfigKey.key("kgms.client.trust-store", GraknConfigKey.PATH);
private static final String PROMPT = ">>> ";
private SignedToken authToken;
private PrintWriter outPrinter;
private final ConsoleReader console;
private final GrpcClient grpcClient;
private final AuthenticatedCommandBus commandBus;
public static void main(String[] args) {
int exitCode = (startShell(args, System.in, System.out, GraknConfig.create())) ? 0 : 1;
System.exit(exitCode);
}
public static boolean startShell(String[] args, InputStream in, OutputStream out, GraknConfig config) {
Options options = new Options();
options.addOption("u", "username", true, "username of admin user");
options.addOption("p", "password", true, "password of admin user");
options.addOption("c", "contact-point", true, "contact point for gRPC server");
CommandLineParser parser = new DefaultParser();
CommandLine cmd;
try {
cmd = parser.parse(options, args);
int grpcPort;
String grpcHost;
if (cmd.hasOption('c')) {
SimpleURI contactPoint = new SimpleURI(cmd.getOptionValue('c'));
grpcHost = contactPoint.getHost();
grpcPort = contactPoint.getPort();
}else{
grpcHost = config.getProperty(GraknConfigKey.SERVER_HOST_NAME);
grpcPort = config.getProperty(GRPC_PORT);
}
GrpcClient grpcClient = new GrpcClient(grpcHost, grpcPort, config.getProperty(KGMS_TRUST_STORE_PATH));
KGMSClientShell shell = new KGMSClientShell(in, out, grpcClient);
String username = cmd.getOptionValue('u');
String password = cmd.getOptionValue('p');
shell.start(username, password);
} catch (IOException | ParseException e){
LOG.error("Unable to start KGMS console", e);
return false;
}
return true;
}
KGMSClientShell(InputStream in, OutputStream out, GrpcClient grpcClient) throws IOException {
this.console = new ConsoleReader(in, out);
this.outPrinter = new PrintWriter(console.getOutput());
this.grpcClient = grpcClient;
this.commandBus = initialiseCommandBus();
}
void start(@Nullable String username, @Nullable String password) throws IOException {
if (username == null) {
username = console.readLine("Username: ");
}
if (password == null) {
password = console.readLine("Password: ", '*');
}
authToken = grpcClient.authenticateUser(username, password);
authenticatedShell();
}
private void authenticatedShell() throws IOException {
console.setPrompt(PROMPT);
String line;
while ((line = console.readLine()) != null) {
commandBus.run(line, authToken);
}
}
private AuthenticatedCommandBus initialiseCommandBus() {
return new AuthenticatedCommandBusImpl(new PrintWriterNotRecognised(this.outPrinter),
new CreateUserCommand(grpcClient.createNewUser(), new CreateUserDisplay(this.outPrinter)),
new RetrieveAllUserCommand(grpcClient.retrieveAllUser(), new RetrieveAllUserDisplay(this.outPrinter)),
new DeleteUserCommand(grpcClient.deleteUser(), new DeleteUserDisplay(this.outPrinter)),
new RetrieveUserCommand(grpcClient.retrieveUser(), new RetrieveUserDisplay(this.outPrinter)),
new UpdateUserCommand(grpcClient.updateUser(), new UpdateUserDisplay(this.outPrinter)));
}
}
|
0
|
java-sources/ai/grakn/kgms/grakn-kgms-client/1.2.0/ai/grakn/kgms
|
java-sources/ai/grakn/kgms/grakn-kgms-client/1.2.0/ai/grakn/kgms/remote/GraknKGMSRemoteSession.java
|
package ai.grakn.kgms.remote;
import ai.grakn.GraknTxType;
import ai.grakn.Keyspace;
import ai.grakn.remote.RemoteGraknSession;
import ai.grakn.remote.RemoteGraknTx;
import ai.grakn.rpc.generated.GrpcGrakn;
import ai.grakn.rpc.generated.GrpcGrakn.TxRequest;
import ai.grakn.rpc.generated.GrpcGrakn.TxType;
import ai.grakn.util.CommonUtil;
import ai.grakn.util.SimpleURI;
import io.grpc.ManagedChannel;
public class GraknKGMSRemoteSession extends RemoteGraknSession {
private final String username;
private final String password;
private GraknKGMSRemoteSession(Keyspace keyspace, SimpleURI uri, ManagedChannel channel, String username, String password) {
super(keyspace, uri, channel);
this.username = username;
this.password = password;
}
public static GraknKGMSRemoteSession create(Keyspace keyspace, SimpleURI uri, ManagedChannel channel, String username, String password) {
return new GraknKGMSRemoteSession(keyspace, uri, channel, username, password);
}
@Override
public RemoteGraknTx open(GraknTxType transactionType) {
TxRequest request = buildRequest(transactionType);
return RemoteGraknTx.create(this, request);
}
private TxRequest buildRequest(GraknTxType txType) {
GrpcGrakn.Open open = GrpcGrakn.Open.newBuilder()
.setKeyspace(GrpcGrakn.Keyspace.newBuilder().setValue(keyspace().getValue()))
.setTxType(convert(txType))
.setUsername(username)
.setPassword(password)
.build();
return TxRequest.newBuilder().setOpen(open).build();
}
//TODO: make this convert method public in opensource version so that we can re-use it here.
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);
}
}
}
|
0
|
java-sources/ai/grakn/kgms/grakn-kgms-client/1.2.0/ai/grakn/kgms
|
java-sources/ai/grakn/kgms/grakn-kgms-client/1.2.0/ai/grakn/kgms/remote/RemoteKGMS.java
|
package ai.grakn.kgms.remote;
import ai.grakn.Keyspace;
import ai.grakn.remote.RemoteGraknSession;
import ai.grakn.util.SimpleURI;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import java.nio.file.Path;
public class RemoteKGMS {
private RemoteKGMS() {
}
public static RemoteGraknSession session(SimpleURI uri, Path trustedCertPath, Keyspace keyspace, String username, String password) {
// File trustedCert = new File(trustedCertPath.toString());
ManagedChannel channel = ManagedChannelBuilder
.forAddress(uri.getHost(), uri.getPort())
.usePlaintext(true)
.build();
return GraknKGMSRemoteSession.create(keyspace, uri, channel, username, password);
}
}
|
0
|
java-sources/ai/grakn/kgms/grakn-kgms-client/1.2.0/ai/grakn/kgms
|
java-sources/ai/grakn/kgms/grakn-kgms-client/1.2.0/ai/grakn/kgms/rpc/GrpcClient.java
|
package ai.grakn.kgms.rpc;
import ai.grakn.kgms.authentication.model.User;
import ai.grakn.kgms.authentication.service.SignedToken;
import ai.grakn.kgms.authentication.usecase.UseCaseReq;
import ai.grakn.kgms.authentication.usecase.UseCaseReqResp;
import ai.grakn.kgms.authentication.usecase.createuser.CreateNewUserRequest;
import ai.grakn.kgms.authentication.usecase.deleteuser.DeleteUserRequest;
import ai.grakn.kgms.authentication.usecase.retrieveallusers.RetrieveAllUserRequest;
import ai.grakn.kgms.authentication.usecase.retrieveuser.RetrieveUserRequest;
import ai.grakn.kgms.authentication.usecase.updateuser.UpdateUserRequest;
import ai.grakn.kgms.rpc.generated.KGMSConsoleAuthGrpc;
import ai.grakn.kgms.rpc.generated.KGMSConsoleAuthGrpc.KGMSConsoleAuthBlockingStub;
import ai.grakn.kgms.rpc.generated.KGMSConsoleAuthProto;
import ai.grakn.kgms.rpc.generated.KGMSConsoleAuthProto.AuthenticatedRequest;
import io.grpc.Channel;
import io.grpc.ManagedChannelBuilder;
import javax.net.ssl.SSLException;
import java.io.File;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Collectors;
/**
* Class that provides interfaces to gRPC usecases
*
* @author Marco Scoppetta
*/
public class GrpcClient {
private final Channel channel;
private final KGMSConsoleAuthBlockingStub stub;
public GrpcClient(String host, int port, Path trustCertPath) throws SSLException {
File trustedCert = new File(trustCertPath.toString());
System.out.println(trustedCert);
channel = ManagedChannelBuilder
.forAddress(host, port)
.usePlaintext(true)
.build();
stub = KGMSConsoleAuthGrpc.newBlockingStub(channel);
}
public SignedToken authenticateUser(String username, String password) {
KGMSConsoleAuthProto.User userRequest = KGMSConsoleAuthProto.User.newBuilder()
.setUsername(username)
.setPassword(password).build();
return new SignedToken(stub.authenticateUser(userRequest).getToken());
}
public UseCaseReqResp<CreateNewUserRequest, User> createNewUser() {
return (req, token) -> {
KGMSConsoleAuthProto.User userRequest = KGMSConsoleAuthProto.User.newBuilder()
.setUsername(req.username)
.setPassword(req.password)
.setRole(req.role).build();
// cc coun ter stit counte () {
//
AuthenticatedRequest authRequest = AuthenticatedRequest.newBuilder()
.setUser(userRequest)
.setToken(token.token).build();
stub.createUser(authRequest);
return new User(req.username, req.password, req.role);
};
}
public UseCaseReqResp<RetrieveAllUserRequest, List<User>> retrieveAllUser() {
return (req, token) -> {
AuthenticatedRequest authRequest = AuthenticatedRequest.newBuilder()
.setToken(token.token).build();
return stub.retrieveAllUsers(authRequest).getUsersList().stream()
.map(user -> new User(user.getUsername(), user.getPassword(), user.getRole()))
.collect(Collectors.toList());
};
}
public UseCaseReqResp<RetrieveUserRequest, User> retrieveUser() {
return (req, token) -> {
KGMSConsoleAuthProto.User userRequest = KGMSConsoleAuthProto.User.newBuilder()
.setUsername(req.username)
.build();
AuthenticatedRequest authRequest = AuthenticatedRequest.newBuilder()
.setUser(userRequest)
.setToken(token.token).build();
KGMSConsoleAuthProto.User retrievedUser = stub.retrieveUser(authRequest);
return new User(retrievedUser.getUsername(), null, retrievedUser.getRole());
};
}
public UseCaseReq<DeleteUserRequest> deleteUser() {
return (req, token) -> {
KGMSConsoleAuthProto.User userRequest = KGMSConsoleAuthProto.User.newBuilder()
.setUsername(req.username)
.build();
AuthenticatedRequest authRequest = AuthenticatedRequest.newBuilder()
.setUser(userRequest)
.setToken(token.token).build();
stub.deleteUser(authRequest);
};
}
public UseCaseReqResp<UpdateUserRequest, User> updateUser() {
return (req, token) -> {
KGMSConsoleAuthProto.User.Builder userRequest = KGMSConsoleAuthProto.User.newBuilder().setUsername(req.username());
if (req.password() != null) userRequest.setPassword(req.password());
if (req.role() != null) userRequest.setRole(req.role());
AuthenticatedRequest authRequest = AuthenticatedRequest.newBuilder()
.setUser(userRequest.build())
.setToken(token.token).build();
stub.updateUser(authRequest);
return new User(req.username(), req.password(), req.role());
};
}
}
|
0
|
java-sources/ai/grakn/kgms/grpc/1.4.3/ai/grakn/kgms/rpc
|
java-sources/ai/grakn/kgms/grpc/1.4.3/ai/grakn/kgms/rpc/generated/KGMSConsoleGrpc.java
|
package ai.grakn.kgms.rpc.generated;
import static io.grpc.MethodDescriptor.generateFullMethodName;
import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
import static io.grpc.stub.ClientCalls.asyncUnaryCall;
import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
import static io.grpc.stub.ClientCalls.blockingUnaryCall;
import static io.grpc.stub.ClientCalls.futureUnaryCall;
import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
/**
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 1.9.0)",
comments = "Source: kbms_console.proto")
public final class KGMSConsoleGrpc {
private KGMSConsoleGrpc() {}
public static final String SERVICE_NAME = "KGMSConsole";
// Static method descriptors that strictly reflect the proto.
@io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
@java.lang.Deprecated // Use {@link #getUserManagementMethod()} instead.
public static final io.grpc.MethodDescriptor<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req,
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res> METHOD_USER_MANAGEMENT = getUserManagementMethod();
private static volatile io.grpc.MethodDescriptor<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req,
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res> getUserManagementMethod;
@io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
public static io.grpc.MethodDescriptor<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req,
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res> getUserManagementMethod() {
io.grpc.MethodDescriptor<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res> getUserManagementMethod;
if ((getUserManagementMethod = KGMSConsoleGrpc.getUserManagementMethod) == null) {
synchronized (KGMSConsoleGrpc.class) {
if ((getUserManagementMethod = KGMSConsoleGrpc.getUserManagementMethod) == null) {
KGMSConsoleGrpc.getUserManagementMethod = getUserManagementMethod =
io.grpc.MethodDescriptor.<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res>newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
.setFullMethodName(generateFullMethodName(
"KGMSConsole", "UserManagement"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res.getDefaultInstance()))
.setSchemaDescriptor(new KGMSConsoleMethodDescriptorSupplier("UserManagement"))
.build();
}
}
}
return getUserManagementMethod;
}
/**
* Creates a new async stub that supports all call types for the service
*/
public static KGMSConsoleStub newStub(io.grpc.Channel channel) {
return new KGMSConsoleStub(channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static KGMSConsoleBlockingStub newBlockingStub(
io.grpc.Channel channel) {
return new KGMSConsoleBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary calls on the service
*/
public static KGMSConsoleFutureStub newFutureStub(
io.grpc.Channel channel) {
return new KGMSConsoleFutureStub(channel);
}
/**
*/
public static abstract class KGMSConsoleImplBase implements io.grpc.BindableService {
/**
*/
public io.grpc.stub.StreamObserver<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req> userManagement(
io.grpc.stub.StreamObserver<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res> responseObserver) {
return asyncUnimplementedStreamingCall(getUserManagementMethod(), responseObserver);
}
@java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
.addMethod(
getUserManagementMethod(),
asyncBidiStreamingCall(
new MethodHandlers<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req,
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res>(
this, METHODID_USER_MANAGEMENT)))
.build();
}
}
/**
*/
public static final class KGMSConsoleStub extends io.grpc.stub.AbstractStub<KGMSConsoleStub> {
private KGMSConsoleStub(io.grpc.Channel channel) {
super(channel);
}
private KGMSConsoleStub(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected KGMSConsoleStub build(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
return new KGMSConsoleStub(channel, callOptions);
}
/**
*/
public io.grpc.stub.StreamObserver<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req> userManagement(
io.grpc.stub.StreamObserver<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res> responseObserver) {
return asyncBidiStreamingCall(
getChannel().newCall(getUserManagementMethod(), getCallOptions()), responseObserver);
}
}
/**
*/
public static final class KGMSConsoleBlockingStub extends io.grpc.stub.AbstractStub<KGMSConsoleBlockingStub> {
private KGMSConsoleBlockingStub(io.grpc.Channel channel) {
super(channel);
}
private KGMSConsoleBlockingStub(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected KGMSConsoleBlockingStub build(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
return new KGMSConsoleBlockingStub(channel, callOptions);
}
}
/**
*/
public static final class KGMSConsoleFutureStub extends io.grpc.stub.AbstractStub<KGMSConsoleFutureStub> {
private KGMSConsoleFutureStub(io.grpc.Channel channel) {
super(channel);
}
private KGMSConsoleFutureStub(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected KGMSConsoleFutureStub build(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
return new KGMSConsoleFutureStub(channel, callOptions);
}
}
private static final int METHODID_USER_MANAGEMENT = 0;
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 KGMSConsoleImplBase serviceImpl;
private final int methodId;
MethodHandlers(KGMSConsoleImplBase 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) {
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_USER_MANAGEMENT:
return (io.grpc.stub.StreamObserver<Req>) serviceImpl.userManagement(
(io.grpc.stub.StreamObserver<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res>) responseObserver);
default:
throw new AssertionError();
}
}
}
private static abstract class KGMSConsoleBaseDescriptorSupplier
implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
KGMSConsoleBaseDescriptorSupplier() {}
@java.lang.Override
public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.getDescriptor();
}
@java.lang.Override
public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
return getFileDescriptor().findServiceByName("KGMSConsole");
}
}
private static final class KGMSConsoleFileDescriptorSupplier
extends KGMSConsoleBaseDescriptorSupplier {
KGMSConsoleFileDescriptorSupplier() {}
}
private static final class KGMSConsoleMethodDescriptorSupplier
extends KGMSConsoleBaseDescriptorSupplier
implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
private final String methodName;
KGMSConsoleMethodDescriptorSupplier(String methodName) {
this.methodName = methodName;
}
@java.lang.Override
public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
return getServiceDescriptor().findMethodByName(methodName);
}
}
private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
public static io.grpc.ServiceDescriptor getServiceDescriptor() {
io.grpc.ServiceDescriptor result = serviceDescriptor;
if (result == null) {
synchronized (KGMSConsoleGrpc.class) {
result = serviceDescriptor;
if (result == null) {
serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
.setSchemaDescriptor(new KGMSConsoleFileDescriptorSupplier())
.addMethod(getUserManagementMethod())
.build();
}
}
}
return result;
}
}
|
0
|
java-sources/ai/grakn/kgms/grpc/1.4.3/ai/grakn/kgms/rpc
|
java-sources/ai/grakn/kgms/grpc/1.4.3/ai/grakn/kgms/rpc/generated/KGMSConsoleProto.java
|
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: kbms_console.proto
package ai.grakn.kgms.rpc.generated;
public final class KGMSConsoleProto {
private KGMSConsoleProto() {}
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 UserManagementOrBuilder extends
// @@protoc_insertion_point(interface_extends:UserManagement)
com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code UserManagement}
*/
public static final class UserManagement extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:UserManagement)
UserManagementOrBuilder {
private static final long serialVersionUID = 0L;
// Use UserManagement.newBuilder() to construct.
private UserManagement(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private UserManagement() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private UserManagement(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Builder.class);
}
public interface ReqOrBuilder extends
// @@protoc_insertion_point(interface_extends:UserManagement.Req)
com.google.protobuf.MessageOrBuilder {
/**
* <code>.Login.Req login_req = 1;</code>
*/
boolean hasLoginReq();
/**
* <code>.Login.Req login_req = 1;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req getLoginReq();
/**
* <code>.Login.Req login_req = 1;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ReqOrBuilder getLoginReqOrBuilder();
/**
* <code>.Create.Req create_req = 2;</code>
*/
boolean hasCreateReq();
/**
* <code>.Create.Req create_req = 2;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req getCreateReq();
/**
* <code>.Create.Req create_req = 2;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ReqOrBuilder getCreateReqOrBuilder();
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
boolean hasDeleteReq();
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req getDeleteReq();
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ReqOrBuilder getDeleteReqOrBuilder();
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
boolean hasRetrieveReq();
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req getRetrieveReq();
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ReqOrBuilder getRetrieveReqOrBuilder();
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
boolean hasRetrieveAllReq();
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req getRetrieveAllReq();
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ReqOrBuilder getRetrieveAllReqOrBuilder();
/**
* <code>.Update.Req update_req = 6;</code>
*/
boolean hasUpdateReq();
/**
* <code>.Update.Req update_req = 6;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req getUpdateReq();
/**
* <code>.Update.Req update_req = 6;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ReqOrBuilder getUpdateReqOrBuilder();
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req.ReqCase getReqCase();
}
/**
* Protobuf type {@code UserManagement.Req}
*/
public static final class Req extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:UserManagement.Req)
ReqOrBuilder {
private static final long serialVersionUID = 0L;
// Use Req.newBuilder() to construct.
private Req(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Req() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Req(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
int mutable_bitField0_ = 0;
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.Builder subBuilder = null;
if (reqCase_ == 1) {
subBuilder = ((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req) req_).toBuilder();
}
req_ =
input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req) req_);
req_ = subBuilder.buildPartial();
}
reqCase_ = 1;
break;
}
case 18: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.Builder subBuilder = null;
if (reqCase_ == 2) {
subBuilder = ((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req) req_).toBuilder();
}
req_ =
input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req) req_);
req_ = subBuilder.buildPartial();
}
reqCase_ = 2;
break;
}
case 26: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.Builder subBuilder = null;
if (reqCase_ == 3) {
subBuilder = ((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req) req_).toBuilder();
}
req_ =
input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req) req_);
req_ = subBuilder.buildPartial();
}
reqCase_ = 3;
break;
}
case 34: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.Builder subBuilder = null;
if (reqCase_ == 4) {
subBuilder = ((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req) req_).toBuilder();
}
req_ =
input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req) req_);
req_ = subBuilder.buildPartial();
}
reqCase_ = 4;
break;
}
case 42: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.Builder subBuilder = null;
if (reqCase_ == 5) {
subBuilder = ((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req) req_).toBuilder();
}
req_ =
input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req) req_);
req_ = subBuilder.buildPartial();
}
reqCase_ = 5;
break;
}
case 50: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.Builder subBuilder = null;
if (reqCase_ == 6) {
subBuilder = ((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req) req_).toBuilder();
}
req_ =
input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req) req_);
req_ = subBuilder.buildPartial();
}
reqCase_ = 6;
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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req.Builder.class);
}
private int reqCase_ = 0;
private java.lang.Object req_;
public enum ReqCase
implements com.google.protobuf.Internal.EnumLite {
LOGIN_REQ(1),
CREATE_REQ(2),
DELETE_REQ(3),
RETRIEVE_REQ(4),
RETRIEVE_ALL_REQ(5),
UPDATE_REQ(6),
REQ_NOT_SET(0);
private final int value;
private ReqCase(int value) {
this.value = value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static ReqCase valueOf(int value) {
return forNumber(value);
}
public static ReqCase forNumber(int value) {
switch (value) {
case 1: return LOGIN_REQ;
case 2: return CREATE_REQ;
case 3: return DELETE_REQ;
case 4: return RETRIEVE_REQ;
case 5: return RETRIEVE_ALL_REQ;
case 6: return UPDATE_REQ;
case 0: return REQ_NOT_SET;
default: return null;
}
}
public int getNumber() {
return this.value;
}
};
public ReqCase
getReqCase() {
return ReqCase.forNumber(
reqCase_);
}
public static final int LOGIN_REQ_FIELD_NUMBER = 1;
/**
* <code>.Login.Req login_req = 1;</code>
*/
public boolean hasLoginReq() {
return reqCase_ == 1;
}
/**
* <code>.Login.Req login_req = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req getLoginReq() {
if (reqCase_ == 1) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.getDefaultInstance();
}
/**
* <code>.Login.Req login_req = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ReqOrBuilder getLoginReqOrBuilder() {
if (reqCase_ == 1) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.getDefaultInstance();
}
public static final int CREATE_REQ_FIELD_NUMBER = 2;
/**
* <code>.Create.Req create_req = 2;</code>
*/
public boolean hasCreateReq() {
return reqCase_ == 2;
}
/**
* <code>.Create.Req create_req = 2;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req getCreateReq() {
if (reqCase_ == 2) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.getDefaultInstance();
}
/**
* <code>.Create.Req create_req = 2;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ReqOrBuilder getCreateReqOrBuilder() {
if (reqCase_ == 2) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.getDefaultInstance();
}
public static final int DELETE_REQ_FIELD_NUMBER = 3;
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
public boolean hasDeleteReq() {
return reqCase_ == 3;
}
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req getDeleteReq() {
if (reqCase_ == 3) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.getDefaultInstance();
}
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ReqOrBuilder getDeleteReqOrBuilder() {
if (reqCase_ == 3) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.getDefaultInstance();
}
public static final int RETRIEVE_REQ_FIELD_NUMBER = 4;
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
public boolean hasRetrieveReq() {
return reqCase_ == 4;
}
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req getRetrieveReq() {
if (reqCase_ == 4) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.getDefaultInstance();
}
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ReqOrBuilder getRetrieveReqOrBuilder() {
if (reqCase_ == 4) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.getDefaultInstance();
}
public static final int RETRIEVE_ALL_REQ_FIELD_NUMBER = 5;
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
public boolean hasRetrieveAllReq() {
return reqCase_ == 5;
}
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req getRetrieveAllReq() {
if (reqCase_ == 5) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.getDefaultInstance();
}
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ReqOrBuilder getRetrieveAllReqOrBuilder() {
if (reqCase_ == 5) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.getDefaultInstance();
}
public static final int UPDATE_REQ_FIELD_NUMBER = 6;
/**
* <code>.Update.Req update_req = 6;</code>
*/
public boolean hasUpdateReq() {
return reqCase_ == 6;
}
/**
* <code>.Update.Req update_req = 6;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req getUpdateReq() {
if (reqCase_ == 6) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.getDefaultInstance();
}
/**
* <code>.Update.Req update_req = 6;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ReqOrBuilder getUpdateReqOrBuilder() {
if (reqCase_ == 6) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.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 (reqCase_ == 1) {
output.writeMessage(1, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req) req_);
}
if (reqCase_ == 2) {
output.writeMessage(2, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req) req_);
}
if (reqCase_ == 3) {
output.writeMessage(3, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req) req_);
}
if (reqCase_ == 4) {
output.writeMessage(4, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req) req_);
}
if (reqCase_ == 5) {
output.writeMessage(5, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req) req_);
}
if (reqCase_ == 6) {
output.writeMessage(6, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req) req_);
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (reqCase_ == 1) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req) req_);
}
if (reqCase_ == 2) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(2, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req) req_);
}
if (reqCase_ == 3) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(3, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req) req_);
}
if (reqCase_ == 4) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(4, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req) req_);
}
if (reqCase_ == 5) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(5, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req) req_);
}
if (reqCase_ == 6) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(6, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req) req_);
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req) obj;
boolean result = true;
result = result && getReqCase().equals(
other.getReqCase());
if (!result) return false;
switch (reqCase_) {
case 1:
result = result && getLoginReq()
.equals(other.getLoginReq());
break;
case 2:
result = result && getCreateReq()
.equals(other.getCreateReq());
break;
case 3:
result = result && getDeleteReq()
.equals(other.getDeleteReq());
break;
case 4:
result = result && getRetrieveReq()
.equals(other.getRetrieveReq());
break;
case 5:
result = result && getRetrieveAllReq()
.equals(other.getRetrieveAllReq());
break;
case 6:
result = result && getUpdateReq()
.equals(other.getUpdateReq());
break;
case 0:
default:
}
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
switch (reqCase_) {
case 1:
hash = (37 * hash) + LOGIN_REQ_FIELD_NUMBER;
hash = (53 * hash) + getLoginReq().hashCode();
break;
case 2:
hash = (37 * hash) + CREATE_REQ_FIELD_NUMBER;
hash = (53 * hash) + getCreateReq().hashCode();
break;
case 3:
hash = (37 * hash) + DELETE_REQ_FIELD_NUMBER;
hash = (53 * hash) + getDeleteReq().hashCode();
break;
case 4:
hash = (37 * hash) + RETRIEVE_REQ_FIELD_NUMBER;
hash = (53 * hash) + getRetrieveReq().hashCode();
break;
case 5:
hash = (37 * hash) + RETRIEVE_ALL_REQ_FIELD_NUMBER;
hash = (53 * hash) + getRetrieveAllReq().hashCode();
break;
case 6:
hash = (37 * hash) + UPDATE_REQ_FIELD_NUMBER;
hash = (53 * hash) + getUpdateReq().hashCode();
break;
case 0:
default:
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req 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.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req 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.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req 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.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req 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.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req 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 UserManagement.Req}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:UserManagement.Req)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.ReqOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req.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();
reqCase_ = 0;
req_ = null;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_Req_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req(this);
if (reqCase_ == 1) {
if (loginReqBuilder_ == null) {
result.req_ = req_;
} else {
result.req_ = loginReqBuilder_.build();
}
}
if (reqCase_ == 2) {
if (createReqBuilder_ == null) {
result.req_ = req_;
} else {
result.req_ = createReqBuilder_.build();
}
}
if (reqCase_ == 3) {
if (deleteReqBuilder_ == null) {
result.req_ = req_;
} else {
result.req_ = deleteReqBuilder_.build();
}
}
if (reqCase_ == 4) {
if (retrieveReqBuilder_ == null) {
result.req_ = req_;
} else {
result.req_ = retrieveReqBuilder_.build();
}
}
if (reqCase_ == 5) {
if (retrieveAllReqBuilder_ == null) {
result.req_ = req_;
} else {
result.req_ = retrieveAllReqBuilder_.build();
}
}
if (reqCase_ == 6) {
if (updateReqBuilder_ == null) {
result.req_ = req_;
} else {
result.req_ = updateReqBuilder_.build();
}
}
result.reqCase_ = reqCase_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req.getDefaultInstance()) return this;
switch (other.getReqCase()) {
case LOGIN_REQ: {
mergeLoginReq(other.getLoginReq());
break;
}
case CREATE_REQ: {
mergeCreateReq(other.getCreateReq());
break;
}
case DELETE_REQ: {
mergeDeleteReq(other.getDeleteReq());
break;
}
case RETRIEVE_REQ: {
mergeRetrieveReq(other.getRetrieveReq());
break;
}
case RETRIEVE_ALL_REQ: {
mergeRetrieveAllReq(other.getRetrieveAllReq());
break;
}
case UPDATE_REQ: {
mergeUpdateReq(other.getUpdateReq());
break;
}
case REQ_NOT_SET: {
break;
}
}
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int reqCase_ = 0;
private java.lang.Object req_;
public ReqCase
getReqCase() {
return ReqCase.forNumber(
reqCase_);
}
public Builder clearReq() {
reqCase_ = 0;
req_ = null;
onChanged();
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ReqOrBuilder> loginReqBuilder_;
/**
* <code>.Login.Req login_req = 1;</code>
*/
public boolean hasLoginReq() {
return reqCase_ == 1;
}
/**
* <code>.Login.Req login_req = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req getLoginReq() {
if (loginReqBuilder_ == null) {
if (reqCase_ == 1) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.getDefaultInstance();
} else {
if (reqCase_ == 1) {
return loginReqBuilder_.getMessage();
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.getDefaultInstance();
}
}
/**
* <code>.Login.Req login_req = 1;</code>
*/
public Builder setLoginReq(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req value) {
if (loginReqBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
req_ = value;
onChanged();
} else {
loginReqBuilder_.setMessage(value);
}
reqCase_ = 1;
return this;
}
/**
* <code>.Login.Req login_req = 1;</code>
*/
public Builder setLoginReq(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.Builder builderForValue) {
if (loginReqBuilder_ == null) {
req_ = builderForValue.build();
onChanged();
} else {
loginReqBuilder_.setMessage(builderForValue.build());
}
reqCase_ = 1;
return this;
}
/**
* <code>.Login.Req login_req = 1;</code>
*/
public Builder mergeLoginReq(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req value) {
if (loginReqBuilder_ == null) {
if (reqCase_ == 1 &&
req_ != ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.getDefaultInstance()) {
req_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.newBuilder((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req) req_)
.mergeFrom(value).buildPartial();
} else {
req_ = value;
}
onChanged();
} else {
if (reqCase_ == 1) {
loginReqBuilder_.mergeFrom(value);
}
loginReqBuilder_.setMessage(value);
}
reqCase_ = 1;
return this;
}
/**
* <code>.Login.Req login_req = 1;</code>
*/
public Builder clearLoginReq() {
if (loginReqBuilder_ == null) {
if (reqCase_ == 1) {
reqCase_ = 0;
req_ = null;
onChanged();
}
} else {
if (reqCase_ == 1) {
reqCase_ = 0;
req_ = null;
}
loginReqBuilder_.clear();
}
return this;
}
/**
* <code>.Login.Req login_req = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.Builder getLoginReqBuilder() {
return getLoginReqFieldBuilder().getBuilder();
}
/**
* <code>.Login.Req login_req = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ReqOrBuilder getLoginReqOrBuilder() {
if ((reqCase_ == 1) && (loginReqBuilder_ != null)) {
return loginReqBuilder_.getMessageOrBuilder();
} else {
if (reqCase_ == 1) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.getDefaultInstance();
}
}
/**
* <code>.Login.Req login_req = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ReqOrBuilder>
getLoginReqFieldBuilder() {
if (loginReqBuilder_ == null) {
if (!(reqCase_ == 1)) {
req_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.getDefaultInstance();
}
loginReqBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ReqOrBuilder>(
(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req) req_,
getParentForChildren(),
isClean());
req_ = null;
}
reqCase_ = 1;
onChanged();;
return loginReqBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ReqOrBuilder> createReqBuilder_;
/**
* <code>.Create.Req create_req = 2;</code>
*/
public boolean hasCreateReq() {
return reqCase_ == 2;
}
/**
* <code>.Create.Req create_req = 2;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req getCreateReq() {
if (createReqBuilder_ == null) {
if (reqCase_ == 2) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.getDefaultInstance();
} else {
if (reqCase_ == 2) {
return createReqBuilder_.getMessage();
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.getDefaultInstance();
}
}
/**
* <code>.Create.Req create_req = 2;</code>
*/
public Builder setCreateReq(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req value) {
if (createReqBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
req_ = value;
onChanged();
} else {
createReqBuilder_.setMessage(value);
}
reqCase_ = 2;
return this;
}
/**
* <code>.Create.Req create_req = 2;</code>
*/
public Builder setCreateReq(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.Builder builderForValue) {
if (createReqBuilder_ == null) {
req_ = builderForValue.build();
onChanged();
} else {
createReqBuilder_.setMessage(builderForValue.build());
}
reqCase_ = 2;
return this;
}
/**
* <code>.Create.Req create_req = 2;</code>
*/
public Builder mergeCreateReq(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req value) {
if (createReqBuilder_ == null) {
if (reqCase_ == 2 &&
req_ != ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.getDefaultInstance()) {
req_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.newBuilder((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req) req_)
.mergeFrom(value).buildPartial();
} else {
req_ = value;
}
onChanged();
} else {
if (reqCase_ == 2) {
createReqBuilder_.mergeFrom(value);
}
createReqBuilder_.setMessage(value);
}
reqCase_ = 2;
return this;
}
/**
* <code>.Create.Req create_req = 2;</code>
*/
public Builder clearCreateReq() {
if (createReqBuilder_ == null) {
if (reqCase_ == 2) {
reqCase_ = 0;
req_ = null;
onChanged();
}
} else {
if (reqCase_ == 2) {
reqCase_ = 0;
req_ = null;
}
createReqBuilder_.clear();
}
return this;
}
/**
* <code>.Create.Req create_req = 2;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.Builder getCreateReqBuilder() {
return getCreateReqFieldBuilder().getBuilder();
}
/**
* <code>.Create.Req create_req = 2;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ReqOrBuilder getCreateReqOrBuilder() {
if ((reqCase_ == 2) && (createReqBuilder_ != null)) {
return createReqBuilder_.getMessageOrBuilder();
} else {
if (reqCase_ == 2) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.getDefaultInstance();
}
}
/**
* <code>.Create.Req create_req = 2;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ReqOrBuilder>
getCreateReqFieldBuilder() {
if (createReqBuilder_ == null) {
if (!(reqCase_ == 2)) {
req_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.getDefaultInstance();
}
createReqBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ReqOrBuilder>(
(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req) req_,
getParentForChildren(),
isClean());
req_ = null;
}
reqCase_ = 2;
onChanged();;
return createReqBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ReqOrBuilder> deleteReqBuilder_;
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
public boolean hasDeleteReq() {
return reqCase_ == 3;
}
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req getDeleteReq() {
if (deleteReqBuilder_ == null) {
if (reqCase_ == 3) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.getDefaultInstance();
} else {
if (reqCase_ == 3) {
return deleteReqBuilder_.getMessage();
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.getDefaultInstance();
}
}
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
public Builder setDeleteReq(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req value) {
if (deleteReqBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
req_ = value;
onChanged();
} else {
deleteReqBuilder_.setMessage(value);
}
reqCase_ = 3;
return this;
}
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
public Builder setDeleteReq(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.Builder builderForValue) {
if (deleteReqBuilder_ == null) {
req_ = builderForValue.build();
onChanged();
} else {
deleteReqBuilder_.setMessage(builderForValue.build());
}
reqCase_ = 3;
return this;
}
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
public Builder mergeDeleteReq(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req value) {
if (deleteReqBuilder_ == null) {
if (reqCase_ == 3 &&
req_ != ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.getDefaultInstance()) {
req_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.newBuilder((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req) req_)
.mergeFrom(value).buildPartial();
} else {
req_ = value;
}
onChanged();
} else {
if (reqCase_ == 3) {
deleteReqBuilder_.mergeFrom(value);
}
deleteReqBuilder_.setMessage(value);
}
reqCase_ = 3;
return this;
}
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
public Builder clearDeleteReq() {
if (deleteReqBuilder_ == null) {
if (reqCase_ == 3) {
reqCase_ = 0;
req_ = null;
onChanged();
}
} else {
if (reqCase_ == 3) {
reqCase_ = 0;
req_ = null;
}
deleteReqBuilder_.clear();
}
return this;
}
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.Builder getDeleteReqBuilder() {
return getDeleteReqFieldBuilder().getBuilder();
}
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ReqOrBuilder getDeleteReqOrBuilder() {
if ((reqCase_ == 3) && (deleteReqBuilder_ != null)) {
return deleteReqBuilder_.getMessageOrBuilder();
} else {
if (reqCase_ == 3) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.getDefaultInstance();
}
}
/**
* <code>.Delete.Req delete_req = 3;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ReqOrBuilder>
getDeleteReqFieldBuilder() {
if (deleteReqBuilder_ == null) {
if (!(reqCase_ == 3)) {
req_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.getDefaultInstance();
}
deleteReqBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ReqOrBuilder>(
(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req) req_,
getParentForChildren(),
isClean());
req_ = null;
}
reqCase_ = 3;
onChanged();;
return deleteReqBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ReqOrBuilder> retrieveReqBuilder_;
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
public boolean hasRetrieveReq() {
return reqCase_ == 4;
}
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req getRetrieveReq() {
if (retrieveReqBuilder_ == null) {
if (reqCase_ == 4) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.getDefaultInstance();
} else {
if (reqCase_ == 4) {
return retrieveReqBuilder_.getMessage();
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.getDefaultInstance();
}
}
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
public Builder setRetrieveReq(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req value) {
if (retrieveReqBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
req_ = value;
onChanged();
} else {
retrieveReqBuilder_.setMessage(value);
}
reqCase_ = 4;
return this;
}
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
public Builder setRetrieveReq(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.Builder builderForValue) {
if (retrieveReqBuilder_ == null) {
req_ = builderForValue.build();
onChanged();
} else {
retrieveReqBuilder_.setMessage(builderForValue.build());
}
reqCase_ = 4;
return this;
}
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
public Builder mergeRetrieveReq(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req value) {
if (retrieveReqBuilder_ == null) {
if (reqCase_ == 4 &&
req_ != ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.getDefaultInstance()) {
req_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.newBuilder((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req) req_)
.mergeFrom(value).buildPartial();
} else {
req_ = value;
}
onChanged();
} else {
if (reqCase_ == 4) {
retrieveReqBuilder_.mergeFrom(value);
}
retrieveReqBuilder_.setMessage(value);
}
reqCase_ = 4;
return this;
}
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
public Builder clearRetrieveReq() {
if (retrieveReqBuilder_ == null) {
if (reqCase_ == 4) {
reqCase_ = 0;
req_ = null;
onChanged();
}
} else {
if (reqCase_ == 4) {
reqCase_ = 0;
req_ = null;
}
retrieveReqBuilder_.clear();
}
return this;
}
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.Builder getRetrieveReqBuilder() {
return getRetrieveReqFieldBuilder().getBuilder();
}
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ReqOrBuilder getRetrieveReqOrBuilder() {
if ((reqCase_ == 4) && (retrieveReqBuilder_ != null)) {
return retrieveReqBuilder_.getMessageOrBuilder();
} else {
if (reqCase_ == 4) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.getDefaultInstance();
}
}
/**
* <code>.Retrieve.Req retrieve_req = 4;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ReqOrBuilder>
getRetrieveReqFieldBuilder() {
if (retrieveReqBuilder_ == null) {
if (!(reqCase_ == 4)) {
req_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.getDefaultInstance();
}
retrieveReqBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ReqOrBuilder>(
(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req) req_,
getParentForChildren(),
isClean());
req_ = null;
}
reqCase_ = 4;
onChanged();;
return retrieveReqBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ReqOrBuilder> retrieveAllReqBuilder_;
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
public boolean hasRetrieveAllReq() {
return reqCase_ == 5;
}
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req getRetrieveAllReq() {
if (retrieveAllReqBuilder_ == null) {
if (reqCase_ == 5) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.getDefaultInstance();
} else {
if (reqCase_ == 5) {
return retrieveAllReqBuilder_.getMessage();
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.getDefaultInstance();
}
}
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
public Builder setRetrieveAllReq(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req value) {
if (retrieveAllReqBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
req_ = value;
onChanged();
} else {
retrieveAllReqBuilder_.setMessage(value);
}
reqCase_ = 5;
return this;
}
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
public Builder setRetrieveAllReq(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.Builder builderForValue) {
if (retrieveAllReqBuilder_ == null) {
req_ = builderForValue.build();
onChanged();
} else {
retrieveAllReqBuilder_.setMessage(builderForValue.build());
}
reqCase_ = 5;
return this;
}
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
public Builder mergeRetrieveAllReq(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req value) {
if (retrieveAllReqBuilder_ == null) {
if (reqCase_ == 5 &&
req_ != ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.getDefaultInstance()) {
req_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.newBuilder((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req) req_)
.mergeFrom(value).buildPartial();
} else {
req_ = value;
}
onChanged();
} else {
if (reqCase_ == 5) {
retrieveAllReqBuilder_.mergeFrom(value);
}
retrieveAllReqBuilder_.setMessage(value);
}
reqCase_ = 5;
return this;
}
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
public Builder clearRetrieveAllReq() {
if (retrieveAllReqBuilder_ == null) {
if (reqCase_ == 5) {
reqCase_ = 0;
req_ = null;
onChanged();
}
} else {
if (reqCase_ == 5) {
reqCase_ = 0;
req_ = null;
}
retrieveAllReqBuilder_.clear();
}
return this;
}
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.Builder getRetrieveAllReqBuilder() {
return getRetrieveAllReqFieldBuilder().getBuilder();
}
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ReqOrBuilder getRetrieveAllReqOrBuilder() {
if ((reqCase_ == 5) && (retrieveAllReqBuilder_ != null)) {
return retrieveAllReqBuilder_.getMessageOrBuilder();
} else {
if (reqCase_ == 5) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.getDefaultInstance();
}
}
/**
* <code>.RetrieveAll.Req retrieve_all_req = 5;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ReqOrBuilder>
getRetrieveAllReqFieldBuilder() {
if (retrieveAllReqBuilder_ == null) {
if (!(reqCase_ == 5)) {
req_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.getDefaultInstance();
}
retrieveAllReqBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ReqOrBuilder>(
(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req) req_,
getParentForChildren(),
isClean());
req_ = null;
}
reqCase_ = 5;
onChanged();;
return retrieveAllReqBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ReqOrBuilder> updateReqBuilder_;
/**
* <code>.Update.Req update_req = 6;</code>
*/
public boolean hasUpdateReq() {
return reqCase_ == 6;
}
/**
* <code>.Update.Req update_req = 6;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req getUpdateReq() {
if (updateReqBuilder_ == null) {
if (reqCase_ == 6) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.getDefaultInstance();
} else {
if (reqCase_ == 6) {
return updateReqBuilder_.getMessage();
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.getDefaultInstance();
}
}
/**
* <code>.Update.Req update_req = 6;</code>
*/
public Builder setUpdateReq(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req value) {
if (updateReqBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
req_ = value;
onChanged();
} else {
updateReqBuilder_.setMessage(value);
}
reqCase_ = 6;
return this;
}
/**
* <code>.Update.Req update_req = 6;</code>
*/
public Builder setUpdateReq(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.Builder builderForValue) {
if (updateReqBuilder_ == null) {
req_ = builderForValue.build();
onChanged();
} else {
updateReqBuilder_.setMessage(builderForValue.build());
}
reqCase_ = 6;
return this;
}
/**
* <code>.Update.Req update_req = 6;</code>
*/
public Builder mergeUpdateReq(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req value) {
if (updateReqBuilder_ == null) {
if (reqCase_ == 6 &&
req_ != ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.getDefaultInstance()) {
req_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.newBuilder((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req) req_)
.mergeFrom(value).buildPartial();
} else {
req_ = value;
}
onChanged();
} else {
if (reqCase_ == 6) {
updateReqBuilder_.mergeFrom(value);
}
updateReqBuilder_.setMessage(value);
}
reqCase_ = 6;
return this;
}
/**
* <code>.Update.Req update_req = 6;</code>
*/
public Builder clearUpdateReq() {
if (updateReqBuilder_ == null) {
if (reqCase_ == 6) {
reqCase_ = 0;
req_ = null;
onChanged();
}
} else {
if (reqCase_ == 6) {
reqCase_ = 0;
req_ = null;
}
updateReqBuilder_.clear();
}
return this;
}
/**
* <code>.Update.Req update_req = 6;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.Builder getUpdateReqBuilder() {
return getUpdateReqFieldBuilder().getBuilder();
}
/**
* <code>.Update.Req update_req = 6;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ReqOrBuilder getUpdateReqOrBuilder() {
if ((reqCase_ == 6) && (updateReqBuilder_ != null)) {
return updateReqBuilder_.getMessageOrBuilder();
} else {
if (reqCase_ == 6) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req) req_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.getDefaultInstance();
}
}
/**
* <code>.Update.Req update_req = 6;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ReqOrBuilder>
getUpdateReqFieldBuilder() {
if (updateReqBuilder_ == null) {
if (!(reqCase_ == 6)) {
req_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.getDefaultInstance();
}
updateReqBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ReqOrBuilder>(
(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req) req_,
getParentForChildren(),
isClean());
req_ = null;
}
reqCase_ = 6;
onChanged();;
return updateReqBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:UserManagement.Req)
}
// @@protoc_insertion_point(class_scope:UserManagement.Req)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Req>
PARSER = new com.google.protobuf.AbstractParser<Req>() {
public Req parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Req(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Req> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Req> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Req getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface ResOrBuilder extends
// @@protoc_insertion_point(interface_extends:UserManagement.Res)
com.google.protobuf.MessageOrBuilder {
/**
* <code>.Login.Res login_res = 1;</code>
*/
boolean hasLoginRes();
/**
* <code>.Login.Res login_res = 1;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res getLoginRes();
/**
* <code>.Login.Res login_res = 1;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ResOrBuilder getLoginResOrBuilder();
/**
* <code>.Create.Res create_res = 2;</code>
*/
boolean hasCreateRes();
/**
* <code>.Create.Res create_res = 2;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res getCreateRes();
/**
* <code>.Create.Res create_res = 2;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ResOrBuilder getCreateResOrBuilder();
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
boolean hasDeleteRes();
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res getDeleteRes();
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ResOrBuilder getDeleteResOrBuilder();
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
boolean hasRetrieveRes();
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res getRetrieveRes();
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ResOrBuilder getRetrieveResOrBuilder();
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
boolean hasRetrieveAllRes();
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res getRetrieveAllRes();
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ResOrBuilder getRetrieveAllResOrBuilder();
/**
* <code>.Update.Res update_res = 6;</code>
*/
boolean hasUpdateRes();
/**
* <code>.Update.Res update_res = 6;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res getUpdateRes();
/**
* <code>.Update.Res update_res = 6;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ResOrBuilder getUpdateResOrBuilder();
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res.ResCase getResCase();
}
/**
* Protobuf type {@code UserManagement.Res}
*/
public static final class Res extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:UserManagement.Res)
ResOrBuilder {
private static final long serialVersionUID = 0L;
// Use Res.newBuilder() to construct.
private Res(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Res() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Res(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
int mutable_bitField0_ = 0;
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.Builder subBuilder = null;
if (resCase_ == 1) {
subBuilder = ((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res) res_).toBuilder();
}
res_ =
input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res) res_);
res_ = subBuilder.buildPartial();
}
resCase_ = 1;
break;
}
case 18: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.Builder subBuilder = null;
if (resCase_ == 2) {
subBuilder = ((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res) res_).toBuilder();
}
res_ =
input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res) res_);
res_ = subBuilder.buildPartial();
}
resCase_ = 2;
break;
}
case 26: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.Builder subBuilder = null;
if (resCase_ == 3) {
subBuilder = ((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res) res_).toBuilder();
}
res_ =
input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res) res_);
res_ = subBuilder.buildPartial();
}
resCase_ = 3;
break;
}
case 34: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.Builder subBuilder = null;
if (resCase_ == 4) {
subBuilder = ((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res) res_).toBuilder();
}
res_ =
input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res) res_);
res_ = subBuilder.buildPartial();
}
resCase_ = 4;
break;
}
case 42: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.Builder subBuilder = null;
if (resCase_ == 5) {
subBuilder = ((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res) res_).toBuilder();
}
res_ =
input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res) res_);
res_ = subBuilder.buildPartial();
}
resCase_ = 5;
break;
}
case 50: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.Builder subBuilder = null;
if (resCase_ == 6) {
subBuilder = ((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res) res_).toBuilder();
}
res_ =
input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res) res_);
res_ = subBuilder.buildPartial();
}
resCase_ = 6;
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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res.Builder.class);
}
private int resCase_ = 0;
private java.lang.Object res_;
public enum ResCase
implements com.google.protobuf.Internal.EnumLite {
LOGIN_RES(1),
CREATE_RES(2),
DELETE_RES(3),
RETRIEVE_RES(4),
RETRIEVE_ALL_RES(5),
UPDATE_RES(6),
RES_NOT_SET(0);
private final int value;
private ResCase(int value) {
this.value = value;
}
/**
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static ResCase valueOf(int value) {
return forNumber(value);
}
public static ResCase forNumber(int value) {
switch (value) {
case 1: return LOGIN_RES;
case 2: return CREATE_RES;
case 3: return DELETE_RES;
case 4: return RETRIEVE_RES;
case 5: return RETRIEVE_ALL_RES;
case 6: return UPDATE_RES;
case 0: return RES_NOT_SET;
default: return null;
}
}
public int getNumber() {
return this.value;
}
};
public ResCase
getResCase() {
return ResCase.forNumber(
resCase_);
}
public static final int LOGIN_RES_FIELD_NUMBER = 1;
/**
* <code>.Login.Res login_res = 1;</code>
*/
public boolean hasLoginRes() {
return resCase_ == 1;
}
/**
* <code>.Login.Res login_res = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res getLoginRes() {
if (resCase_ == 1) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.getDefaultInstance();
}
/**
* <code>.Login.Res login_res = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ResOrBuilder getLoginResOrBuilder() {
if (resCase_ == 1) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.getDefaultInstance();
}
public static final int CREATE_RES_FIELD_NUMBER = 2;
/**
* <code>.Create.Res create_res = 2;</code>
*/
public boolean hasCreateRes() {
return resCase_ == 2;
}
/**
* <code>.Create.Res create_res = 2;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res getCreateRes() {
if (resCase_ == 2) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.getDefaultInstance();
}
/**
* <code>.Create.Res create_res = 2;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ResOrBuilder getCreateResOrBuilder() {
if (resCase_ == 2) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.getDefaultInstance();
}
public static final int DELETE_RES_FIELD_NUMBER = 3;
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
public boolean hasDeleteRes() {
return resCase_ == 3;
}
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res getDeleteRes() {
if (resCase_ == 3) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.getDefaultInstance();
}
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ResOrBuilder getDeleteResOrBuilder() {
if (resCase_ == 3) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.getDefaultInstance();
}
public static final int RETRIEVE_RES_FIELD_NUMBER = 4;
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
public boolean hasRetrieveRes() {
return resCase_ == 4;
}
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res getRetrieveRes() {
if (resCase_ == 4) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.getDefaultInstance();
}
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ResOrBuilder getRetrieveResOrBuilder() {
if (resCase_ == 4) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.getDefaultInstance();
}
public static final int RETRIEVE_ALL_RES_FIELD_NUMBER = 5;
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
public boolean hasRetrieveAllRes() {
return resCase_ == 5;
}
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res getRetrieveAllRes() {
if (resCase_ == 5) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.getDefaultInstance();
}
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ResOrBuilder getRetrieveAllResOrBuilder() {
if (resCase_ == 5) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.getDefaultInstance();
}
public static final int UPDATE_RES_FIELD_NUMBER = 6;
/**
* <code>.Update.Res update_res = 6;</code>
*/
public boolean hasUpdateRes() {
return resCase_ == 6;
}
/**
* <code>.Update.Res update_res = 6;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res getUpdateRes() {
if (resCase_ == 6) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.getDefaultInstance();
}
/**
* <code>.Update.Res update_res = 6;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ResOrBuilder getUpdateResOrBuilder() {
if (resCase_ == 6) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.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 (resCase_ == 1) {
output.writeMessage(1, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res) res_);
}
if (resCase_ == 2) {
output.writeMessage(2, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res) res_);
}
if (resCase_ == 3) {
output.writeMessage(3, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res) res_);
}
if (resCase_ == 4) {
output.writeMessage(4, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res) res_);
}
if (resCase_ == 5) {
output.writeMessage(5, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res) res_);
}
if (resCase_ == 6) {
output.writeMessage(6, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res) res_);
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (resCase_ == 1) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res) res_);
}
if (resCase_ == 2) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(2, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res) res_);
}
if (resCase_ == 3) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(3, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res) res_);
}
if (resCase_ == 4) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(4, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res) res_);
}
if (resCase_ == 5) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(5, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res) res_);
}
if (resCase_ == 6) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(6, (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res) res_);
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res) obj;
boolean result = true;
result = result && getResCase().equals(
other.getResCase());
if (!result) return false;
switch (resCase_) {
case 1:
result = result && getLoginRes()
.equals(other.getLoginRes());
break;
case 2:
result = result && getCreateRes()
.equals(other.getCreateRes());
break;
case 3:
result = result && getDeleteRes()
.equals(other.getDeleteRes());
break;
case 4:
result = result && getRetrieveRes()
.equals(other.getRetrieveRes());
break;
case 5:
result = result && getRetrieveAllRes()
.equals(other.getRetrieveAllRes());
break;
case 6:
result = result && getUpdateRes()
.equals(other.getUpdateRes());
break;
case 0:
default:
}
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
switch (resCase_) {
case 1:
hash = (37 * hash) + LOGIN_RES_FIELD_NUMBER;
hash = (53 * hash) + getLoginRes().hashCode();
break;
case 2:
hash = (37 * hash) + CREATE_RES_FIELD_NUMBER;
hash = (53 * hash) + getCreateRes().hashCode();
break;
case 3:
hash = (37 * hash) + DELETE_RES_FIELD_NUMBER;
hash = (53 * hash) + getDeleteRes().hashCode();
break;
case 4:
hash = (37 * hash) + RETRIEVE_RES_FIELD_NUMBER;
hash = (53 * hash) + getRetrieveRes().hashCode();
break;
case 5:
hash = (37 * hash) + RETRIEVE_ALL_RES_FIELD_NUMBER;
hash = (53 * hash) + getRetrieveAllRes().hashCode();
break;
case 6:
hash = (37 * hash) + UPDATE_RES_FIELD_NUMBER;
hash = (53 * hash) + getUpdateRes().hashCode();
break;
case 0:
default:
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res 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.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res 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.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res 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.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res 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.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res 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 UserManagement.Res}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:UserManagement.Res)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.ResOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res.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();
resCase_ = 0;
res_ = null;
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_Res_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res(this);
if (resCase_ == 1) {
if (loginResBuilder_ == null) {
result.res_ = res_;
} else {
result.res_ = loginResBuilder_.build();
}
}
if (resCase_ == 2) {
if (createResBuilder_ == null) {
result.res_ = res_;
} else {
result.res_ = createResBuilder_.build();
}
}
if (resCase_ == 3) {
if (deleteResBuilder_ == null) {
result.res_ = res_;
} else {
result.res_ = deleteResBuilder_.build();
}
}
if (resCase_ == 4) {
if (retrieveResBuilder_ == null) {
result.res_ = res_;
} else {
result.res_ = retrieveResBuilder_.build();
}
}
if (resCase_ == 5) {
if (retrieveAllResBuilder_ == null) {
result.res_ = res_;
} else {
result.res_ = retrieveAllResBuilder_.build();
}
}
if (resCase_ == 6) {
if (updateResBuilder_ == null) {
result.res_ = res_;
} else {
result.res_ = updateResBuilder_.build();
}
}
result.resCase_ = resCase_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res.getDefaultInstance()) return this;
switch (other.getResCase()) {
case LOGIN_RES: {
mergeLoginRes(other.getLoginRes());
break;
}
case CREATE_RES: {
mergeCreateRes(other.getCreateRes());
break;
}
case DELETE_RES: {
mergeDeleteRes(other.getDeleteRes());
break;
}
case RETRIEVE_RES: {
mergeRetrieveRes(other.getRetrieveRes());
break;
}
case RETRIEVE_ALL_RES: {
mergeRetrieveAllRes(other.getRetrieveAllRes());
break;
}
case UPDATE_RES: {
mergeUpdateRes(other.getUpdateRes());
break;
}
case RES_NOT_SET: {
break;
}
}
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int resCase_ = 0;
private java.lang.Object res_;
public ResCase
getResCase() {
return ResCase.forNumber(
resCase_);
}
public Builder clearRes() {
resCase_ = 0;
res_ = null;
onChanged();
return this;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ResOrBuilder> loginResBuilder_;
/**
* <code>.Login.Res login_res = 1;</code>
*/
public boolean hasLoginRes() {
return resCase_ == 1;
}
/**
* <code>.Login.Res login_res = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res getLoginRes() {
if (loginResBuilder_ == null) {
if (resCase_ == 1) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.getDefaultInstance();
} else {
if (resCase_ == 1) {
return loginResBuilder_.getMessage();
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.getDefaultInstance();
}
}
/**
* <code>.Login.Res login_res = 1;</code>
*/
public Builder setLoginRes(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res value) {
if (loginResBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
res_ = value;
onChanged();
} else {
loginResBuilder_.setMessage(value);
}
resCase_ = 1;
return this;
}
/**
* <code>.Login.Res login_res = 1;</code>
*/
public Builder setLoginRes(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.Builder builderForValue) {
if (loginResBuilder_ == null) {
res_ = builderForValue.build();
onChanged();
} else {
loginResBuilder_.setMessage(builderForValue.build());
}
resCase_ = 1;
return this;
}
/**
* <code>.Login.Res login_res = 1;</code>
*/
public Builder mergeLoginRes(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res value) {
if (loginResBuilder_ == null) {
if (resCase_ == 1 &&
res_ != ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.getDefaultInstance()) {
res_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.newBuilder((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res) res_)
.mergeFrom(value).buildPartial();
} else {
res_ = value;
}
onChanged();
} else {
if (resCase_ == 1) {
loginResBuilder_.mergeFrom(value);
}
loginResBuilder_.setMessage(value);
}
resCase_ = 1;
return this;
}
/**
* <code>.Login.Res login_res = 1;</code>
*/
public Builder clearLoginRes() {
if (loginResBuilder_ == null) {
if (resCase_ == 1) {
resCase_ = 0;
res_ = null;
onChanged();
}
} else {
if (resCase_ == 1) {
resCase_ = 0;
res_ = null;
}
loginResBuilder_.clear();
}
return this;
}
/**
* <code>.Login.Res login_res = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.Builder getLoginResBuilder() {
return getLoginResFieldBuilder().getBuilder();
}
/**
* <code>.Login.Res login_res = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ResOrBuilder getLoginResOrBuilder() {
if ((resCase_ == 1) && (loginResBuilder_ != null)) {
return loginResBuilder_.getMessageOrBuilder();
} else {
if (resCase_ == 1) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.getDefaultInstance();
}
}
/**
* <code>.Login.Res login_res = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ResOrBuilder>
getLoginResFieldBuilder() {
if (loginResBuilder_ == null) {
if (!(resCase_ == 1)) {
res_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.getDefaultInstance();
}
loginResBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ResOrBuilder>(
(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res) res_,
getParentForChildren(),
isClean());
res_ = null;
}
resCase_ = 1;
onChanged();;
return loginResBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ResOrBuilder> createResBuilder_;
/**
* <code>.Create.Res create_res = 2;</code>
*/
public boolean hasCreateRes() {
return resCase_ == 2;
}
/**
* <code>.Create.Res create_res = 2;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res getCreateRes() {
if (createResBuilder_ == null) {
if (resCase_ == 2) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.getDefaultInstance();
} else {
if (resCase_ == 2) {
return createResBuilder_.getMessage();
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.getDefaultInstance();
}
}
/**
* <code>.Create.Res create_res = 2;</code>
*/
public Builder setCreateRes(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res value) {
if (createResBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
res_ = value;
onChanged();
} else {
createResBuilder_.setMessage(value);
}
resCase_ = 2;
return this;
}
/**
* <code>.Create.Res create_res = 2;</code>
*/
public Builder setCreateRes(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.Builder builderForValue) {
if (createResBuilder_ == null) {
res_ = builderForValue.build();
onChanged();
} else {
createResBuilder_.setMessage(builderForValue.build());
}
resCase_ = 2;
return this;
}
/**
* <code>.Create.Res create_res = 2;</code>
*/
public Builder mergeCreateRes(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res value) {
if (createResBuilder_ == null) {
if (resCase_ == 2 &&
res_ != ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.getDefaultInstance()) {
res_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.newBuilder((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res) res_)
.mergeFrom(value).buildPartial();
} else {
res_ = value;
}
onChanged();
} else {
if (resCase_ == 2) {
createResBuilder_.mergeFrom(value);
}
createResBuilder_.setMessage(value);
}
resCase_ = 2;
return this;
}
/**
* <code>.Create.Res create_res = 2;</code>
*/
public Builder clearCreateRes() {
if (createResBuilder_ == null) {
if (resCase_ == 2) {
resCase_ = 0;
res_ = null;
onChanged();
}
} else {
if (resCase_ == 2) {
resCase_ = 0;
res_ = null;
}
createResBuilder_.clear();
}
return this;
}
/**
* <code>.Create.Res create_res = 2;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.Builder getCreateResBuilder() {
return getCreateResFieldBuilder().getBuilder();
}
/**
* <code>.Create.Res create_res = 2;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ResOrBuilder getCreateResOrBuilder() {
if ((resCase_ == 2) && (createResBuilder_ != null)) {
return createResBuilder_.getMessageOrBuilder();
} else {
if (resCase_ == 2) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.getDefaultInstance();
}
}
/**
* <code>.Create.Res create_res = 2;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ResOrBuilder>
getCreateResFieldBuilder() {
if (createResBuilder_ == null) {
if (!(resCase_ == 2)) {
res_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.getDefaultInstance();
}
createResBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ResOrBuilder>(
(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res) res_,
getParentForChildren(),
isClean());
res_ = null;
}
resCase_ = 2;
onChanged();;
return createResBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ResOrBuilder> deleteResBuilder_;
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
public boolean hasDeleteRes() {
return resCase_ == 3;
}
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res getDeleteRes() {
if (deleteResBuilder_ == null) {
if (resCase_ == 3) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.getDefaultInstance();
} else {
if (resCase_ == 3) {
return deleteResBuilder_.getMessage();
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.getDefaultInstance();
}
}
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
public Builder setDeleteRes(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res value) {
if (deleteResBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
res_ = value;
onChanged();
} else {
deleteResBuilder_.setMessage(value);
}
resCase_ = 3;
return this;
}
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
public Builder setDeleteRes(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.Builder builderForValue) {
if (deleteResBuilder_ == null) {
res_ = builderForValue.build();
onChanged();
} else {
deleteResBuilder_.setMessage(builderForValue.build());
}
resCase_ = 3;
return this;
}
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
public Builder mergeDeleteRes(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res value) {
if (deleteResBuilder_ == null) {
if (resCase_ == 3 &&
res_ != ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.getDefaultInstance()) {
res_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.newBuilder((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res) res_)
.mergeFrom(value).buildPartial();
} else {
res_ = value;
}
onChanged();
} else {
if (resCase_ == 3) {
deleteResBuilder_.mergeFrom(value);
}
deleteResBuilder_.setMessage(value);
}
resCase_ = 3;
return this;
}
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
public Builder clearDeleteRes() {
if (deleteResBuilder_ == null) {
if (resCase_ == 3) {
resCase_ = 0;
res_ = null;
onChanged();
}
} else {
if (resCase_ == 3) {
resCase_ = 0;
res_ = null;
}
deleteResBuilder_.clear();
}
return this;
}
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.Builder getDeleteResBuilder() {
return getDeleteResFieldBuilder().getBuilder();
}
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ResOrBuilder getDeleteResOrBuilder() {
if ((resCase_ == 3) && (deleteResBuilder_ != null)) {
return deleteResBuilder_.getMessageOrBuilder();
} else {
if (resCase_ == 3) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.getDefaultInstance();
}
}
/**
* <code>.Delete.Res delete_res = 3;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ResOrBuilder>
getDeleteResFieldBuilder() {
if (deleteResBuilder_ == null) {
if (!(resCase_ == 3)) {
res_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.getDefaultInstance();
}
deleteResBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ResOrBuilder>(
(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res) res_,
getParentForChildren(),
isClean());
res_ = null;
}
resCase_ = 3;
onChanged();;
return deleteResBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ResOrBuilder> retrieveResBuilder_;
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
public boolean hasRetrieveRes() {
return resCase_ == 4;
}
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res getRetrieveRes() {
if (retrieveResBuilder_ == null) {
if (resCase_ == 4) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.getDefaultInstance();
} else {
if (resCase_ == 4) {
return retrieveResBuilder_.getMessage();
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.getDefaultInstance();
}
}
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
public Builder setRetrieveRes(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res value) {
if (retrieveResBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
res_ = value;
onChanged();
} else {
retrieveResBuilder_.setMessage(value);
}
resCase_ = 4;
return this;
}
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
public Builder setRetrieveRes(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.Builder builderForValue) {
if (retrieveResBuilder_ == null) {
res_ = builderForValue.build();
onChanged();
} else {
retrieveResBuilder_.setMessage(builderForValue.build());
}
resCase_ = 4;
return this;
}
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
public Builder mergeRetrieveRes(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res value) {
if (retrieveResBuilder_ == null) {
if (resCase_ == 4 &&
res_ != ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.getDefaultInstance()) {
res_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.newBuilder((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res) res_)
.mergeFrom(value).buildPartial();
} else {
res_ = value;
}
onChanged();
} else {
if (resCase_ == 4) {
retrieveResBuilder_.mergeFrom(value);
}
retrieveResBuilder_.setMessage(value);
}
resCase_ = 4;
return this;
}
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
public Builder clearRetrieveRes() {
if (retrieveResBuilder_ == null) {
if (resCase_ == 4) {
resCase_ = 0;
res_ = null;
onChanged();
}
} else {
if (resCase_ == 4) {
resCase_ = 0;
res_ = null;
}
retrieveResBuilder_.clear();
}
return this;
}
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.Builder getRetrieveResBuilder() {
return getRetrieveResFieldBuilder().getBuilder();
}
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ResOrBuilder getRetrieveResOrBuilder() {
if ((resCase_ == 4) && (retrieveResBuilder_ != null)) {
return retrieveResBuilder_.getMessageOrBuilder();
} else {
if (resCase_ == 4) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.getDefaultInstance();
}
}
/**
* <code>.Retrieve.Res retrieve_res = 4;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ResOrBuilder>
getRetrieveResFieldBuilder() {
if (retrieveResBuilder_ == null) {
if (!(resCase_ == 4)) {
res_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.getDefaultInstance();
}
retrieveResBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ResOrBuilder>(
(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res) res_,
getParentForChildren(),
isClean());
res_ = null;
}
resCase_ = 4;
onChanged();;
return retrieveResBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ResOrBuilder> retrieveAllResBuilder_;
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
public boolean hasRetrieveAllRes() {
return resCase_ == 5;
}
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res getRetrieveAllRes() {
if (retrieveAllResBuilder_ == null) {
if (resCase_ == 5) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.getDefaultInstance();
} else {
if (resCase_ == 5) {
return retrieveAllResBuilder_.getMessage();
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.getDefaultInstance();
}
}
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
public Builder setRetrieveAllRes(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res value) {
if (retrieveAllResBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
res_ = value;
onChanged();
} else {
retrieveAllResBuilder_.setMessage(value);
}
resCase_ = 5;
return this;
}
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
public Builder setRetrieveAllRes(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.Builder builderForValue) {
if (retrieveAllResBuilder_ == null) {
res_ = builderForValue.build();
onChanged();
} else {
retrieveAllResBuilder_.setMessage(builderForValue.build());
}
resCase_ = 5;
return this;
}
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
public Builder mergeRetrieveAllRes(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res value) {
if (retrieveAllResBuilder_ == null) {
if (resCase_ == 5 &&
res_ != ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.getDefaultInstance()) {
res_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.newBuilder((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res) res_)
.mergeFrom(value).buildPartial();
} else {
res_ = value;
}
onChanged();
} else {
if (resCase_ == 5) {
retrieveAllResBuilder_.mergeFrom(value);
}
retrieveAllResBuilder_.setMessage(value);
}
resCase_ = 5;
return this;
}
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
public Builder clearRetrieveAllRes() {
if (retrieveAllResBuilder_ == null) {
if (resCase_ == 5) {
resCase_ = 0;
res_ = null;
onChanged();
}
} else {
if (resCase_ == 5) {
resCase_ = 0;
res_ = null;
}
retrieveAllResBuilder_.clear();
}
return this;
}
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.Builder getRetrieveAllResBuilder() {
return getRetrieveAllResFieldBuilder().getBuilder();
}
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ResOrBuilder getRetrieveAllResOrBuilder() {
if ((resCase_ == 5) && (retrieveAllResBuilder_ != null)) {
return retrieveAllResBuilder_.getMessageOrBuilder();
} else {
if (resCase_ == 5) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.getDefaultInstance();
}
}
/**
* <code>.RetrieveAll.Res retrieve_all_res = 5;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ResOrBuilder>
getRetrieveAllResFieldBuilder() {
if (retrieveAllResBuilder_ == null) {
if (!(resCase_ == 5)) {
res_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.getDefaultInstance();
}
retrieveAllResBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ResOrBuilder>(
(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res) res_,
getParentForChildren(),
isClean());
res_ = null;
}
resCase_ = 5;
onChanged();;
return retrieveAllResBuilder_;
}
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ResOrBuilder> updateResBuilder_;
/**
* <code>.Update.Res update_res = 6;</code>
*/
public boolean hasUpdateRes() {
return resCase_ == 6;
}
/**
* <code>.Update.Res update_res = 6;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res getUpdateRes() {
if (updateResBuilder_ == null) {
if (resCase_ == 6) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.getDefaultInstance();
} else {
if (resCase_ == 6) {
return updateResBuilder_.getMessage();
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.getDefaultInstance();
}
}
/**
* <code>.Update.Res update_res = 6;</code>
*/
public Builder setUpdateRes(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res value) {
if (updateResBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
res_ = value;
onChanged();
} else {
updateResBuilder_.setMessage(value);
}
resCase_ = 6;
return this;
}
/**
* <code>.Update.Res update_res = 6;</code>
*/
public Builder setUpdateRes(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.Builder builderForValue) {
if (updateResBuilder_ == null) {
res_ = builderForValue.build();
onChanged();
} else {
updateResBuilder_.setMessage(builderForValue.build());
}
resCase_ = 6;
return this;
}
/**
* <code>.Update.Res update_res = 6;</code>
*/
public Builder mergeUpdateRes(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res value) {
if (updateResBuilder_ == null) {
if (resCase_ == 6 &&
res_ != ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.getDefaultInstance()) {
res_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.newBuilder((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res) res_)
.mergeFrom(value).buildPartial();
} else {
res_ = value;
}
onChanged();
} else {
if (resCase_ == 6) {
updateResBuilder_.mergeFrom(value);
}
updateResBuilder_.setMessage(value);
}
resCase_ = 6;
return this;
}
/**
* <code>.Update.Res update_res = 6;</code>
*/
public Builder clearUpdateRes() {
if (updateResBuilder_ == null) {
if (resCase_ == 6) {
resCase_ = 0;
res_ = null;
onChanged();
}
} else {
if (resCase_ == 6) {
resCase_ = 0;
res_ = null;
}
updateResBuilder_.clear();
}
return this;
}
/**
* <code>.Update.Res update_res = 6;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.Builder getUpdateResBuilder() {
return getUpdateResFieldBuilder().getBuilder();
}
/**
* <code>.Update.Res update_res = 6;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ResOrBuilder getUpdateResOrBuilder() {
if ((resCase_ == 6) && (updateResBuilder_ != null)) {
return updateResBuilder_.getMessageOrBuilder();
} else {
if (resCase_ == 6) {
return (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res) res_;
}
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.getDefaultInstance();
}
}
/**
* <code>.Update.Res update_res = 6;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ResOrBuilder>
getUpdateResFieldBuilder() {
if (updateResBuilder_ == null) {
if (!(resCase_ == 6)) {
res_ = ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.getDefaultInstance();
}
updateResBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ResOrBuilder>(
(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res) res_,
getParentForChildren(),
isClean());
res_ = null;
}
resCase_ = 6;
onChanged();;
return updateResBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:UserManagement.Res)
}
// @@protoc_insertion_point(class_scope:UserManagement.Res)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Res>
PARSER = new com.google.protobuf.AbstractParser<Res>() {
public Res parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Res(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Res> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Res> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Res getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
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 {
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement) obj;
boolean result = true;
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement 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.kgms.rpc.generated.KGMSConsoleProto.UserManagement parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement 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.kgms.rpc.generated.KGMSConsoleProto.UserManagement parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement 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.kgms.rpc.generated.KGMSConsoleProto.UserManagement parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement 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.kgms.rpc.generated.KGMSConsoleProto.UserManagement 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 UserManagement}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:UserManagement)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagementOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.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.kgms.rpc.generated.KGMSConsoleProto.internal_static_UserManagement_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement(this);
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement.getDefaultInstance()) return this;
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.UserManagement parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:UserManagement)
}
// @@protoc_insertion_point(class_scope:UserManagement)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<UserManagement>
PARSER = new com.google.protobuf.AbstractParser<UserManagement>() {
public UserManagement parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new UserManagement(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<UserManagement> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<UserManagement> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserManagement getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface LoginOrBuilder extends
// @@protoc_insertion_point(interface_extends:Login)
com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code Login}
*/
public static final class Login extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Login)
LoginOrBuilder {
private static final long serialVersionUID = 0L;
// Use Login.newBuilder() to construct.
private Login(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Login() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Login(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Builder.class);
}
public interface ReqOrBuilder extends
// @@protoc_insertion_point(interface_extends:Login.Req)
com.google.protobuf.MessageOrBuilder {
/**
* <code>string username = 1;</code>
*/
java.lang.String getUsername();
/**
* <code>string username = 1;</code>
*/
com.google.protobuf.ByteString
getUsernameBytes();
/**
* <code>string password = 2;</code>
*/
java.lang.String getPassword();
/**
* <code>string password = 2;</code>
*/
com.google.protobuf.ByteString
getPasswordBytes();
}
/**
* Protobuf type {@code Login.Req}
*/
public static final class Req extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Login.Req)
ReqOrBuilder {
private static final long serialVersionUID = 0L;
// Use Req.newBuilder() to construct.
private Req(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Req() {
username_ = "";
password_ = "";
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Req(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
int mutable_bitField0_ = 0;
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
username_ = s;
break;
}
case 18: {
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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.Builder.class);
}
public static final int USERNAME_FIELD_NUMBER = 1;
private volatile java.lang.Object username_;
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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 = 2;
private volatile java.lang.Object password_;
/**
* <code>string password = 2;</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>string password = 2;</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 (!getUsernameBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, username_);
}
if (!getPasswordBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 2, password_);
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (!getUsernameBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, username_);
}
if (!getPasswordBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, password_);
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req) obj;
boolean result = true;
result = result && getUsername()
.equals(other.getUsername());
result = result && getPassword()
.equals(other.getPassword());
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
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.kgms.rpc.generated.KGMSConsoleProto.Login.Req parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req 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.kgms.rpc.generated.KGMSConsoleProto.Login.Req parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req 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.kgms.rpc.generated.KGMSConsoleProto.Login.Req parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req 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.kgms.rpc.generated.KGMSConsoleProto.Login.Req parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req 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.kgms.rpc.generated.KGMSConsoleProto.Login.Req 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 Login.Req}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Login.Req)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ReqOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.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();
username_ = "";
password_ = "";
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_Req_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req(this);
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,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req.getDefaultInstance()) return this;
if (!other.getUsername().isEmpty()) {
username_ = other.username_;
onChanged();
}
if (!other.getPassword().isEmpty()) {
password_ = other.password_;
onChanged();
}
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Login.Req parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private java.lang.Object username_ = "";
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</code>
*/
public Builder setUsername(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
username_ = value;
onChanged();
return this;
}
/**
* <code>string username = 1;</code>
*/
public Builder clearUsername() {
username_ = getDefaultInstance().getUsername();
onChanged();
return this;
}
/**
* <code>string username = 1;</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>string password = 2;</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>string password = 2;</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>string password = 2;</code>
*/
public Builder setPassword(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
password_ = value;
onChanged();
return this;
}
/**
* <code>string password = 2;</code>
*/
public Builder clearPassword() {
password_ = getDefaultInstance().getPassword();
onChanged();
return this;
}
/**
* <code>string password = 2;</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 super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Login.Req)
}
// @@protoc_insertion_point(class_scope:Login.Req)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Req>
PARSER = new com.google.protobuf.AbstractParser<Req>() {
public Req parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Req(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Req> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Req> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Req getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface ResOrBuilder extends
// @@protoc_insertion_point(interface_extends:Login.Res)
com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code Login.Res}
*/
public static final class Res extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Login.Res)
ResOrBuilder {
private static final long serialVersionUID = 0L;
// Use Res.newBuilder() to construct.
private Res(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Res() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Res(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.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 {
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res) obj;
boolean result = true;
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res 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.kgms.rpc.generated.KGMSConsoleProto.Login.Res parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res 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.kgms.rpc.generated.KGMSConsoleProto.Login.Res parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res 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.kgms.rpc.generated.KGMSConsoleProto.Login.Res parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res 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.kgms.rpc.generated.KGMSConsoleProto.Login.Res 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 Login.Res}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Login.Res)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.ResOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.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.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_Res_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res(this);
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res.getDefaultInstance()) return this;
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Login.Res parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Login.Res)
}
// @@protoc_insertion_point(class_scope:Login.Res)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Res>
PARSER = new com.google.protobuf.AbstractParser<Res>() {
public Res parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Res(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Res> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Res> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Res getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
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 {
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login) obj;
boolean result = true;
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login 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.kgms.rpc.generated.KGMSConsoleProto.Login parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login 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.kgms.rpc.generated.KGMSConsoleProto.Login parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login 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.kgms.rpc.generated.KGMSConsoleProto.Login parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login 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.kgms.rpc.generated.KGMSConsoleProto.Login 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 Login}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Login)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.LoginOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.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.kgms.rpc.generated.KGMSConsoleProto.internal_static_Login_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login(this);
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login.getDefaultInstance()) return this;
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Login parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Login)
}
// @@protoc_insertion_point(class_scope:Login)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Login>
PARSER = new com.google.protobuf.AbstractParser<Login>() {
public Login parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Login(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Login> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Login> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Login getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface CreateOrBuilder extends
// @@protoc_insertion_point(interface_extends:Create)
com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code Create}
*/
public static final class Create extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Create)
CreateOrBuilder {
private static final long serialVersionUID = 0L;
// Use Create.newBuilder() to construct.
private Create(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Create() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Create(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Builder.class);
}
public interface ReqOrBuilder extends
// @@protoc_insertion_point(interface_extends:Create.Req)
com.google.protobuf.MessageOrBuilder {
/**
* <code>string username = 1;</code>
*/
java.lang.String getUsername();
/**
* <code>string username = 1;</code>
*/
com.google.protobuf.ByteString
getUsernameBytes();
/**
* <code>string password = 2;</code>
*/
java.lang.String getPassword();
/**
* <code>string password = 2;</code>
*/
com.google.protobuf.ByteString
getPasswordBytes();
/**
* <code>string role = 3;</code>
*/
java.lang.String getRole();
/**
* <code>string role = 3;</code>
*/
com.google.protobuf.ByteString
getRoleBytes();
}
/**
* Protobuf type {@code Create.Req}
*/
public static final class Req extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Create.Req)
ReqOrBuilder {
private static final long serialVersionUID = 0L;
// Use Req.newBuilder() to construct.
private Req(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Req() {
username_ = "";
password_ = "";
role_ = "";
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Req(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
int mutable_bitField0_ = 0;
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
username_ = s;
break;
}
case 18: {
java.lang.String s = input.readStringRequireUtf8();
password_ = s;
break;
}
case 26: {
java.lang.String s = input.readStringRequireUtf8();
role_ = 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.Builder.class);
}
public static final int USERNAME_FIELD_NUMBER = 1;
private volatile java.lang.Object username_;
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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 = 2;
private volatile java.lang.Object password_;
/**
* <code>string password = 2;</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>string password = 2;</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;
}
}
public static final int ROLE_FIELD_NUMBER = 3;
private volatile java.lang.Object role_;
/**
* <code>string role = 3;</code>
*/
public java.lang.String getRole() {
java.lang.Object ref = role_;
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();
role_ = s;
return s;
}
}
/**
* <code>string role = 3;</code>
*/
public com.google.protobuf.ByteString
getRoleBytes() {
java.lang.Object ref = role_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
role_ = 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 (!getUsernameBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, username_);
}
if (!getPasswordBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 2, password_);
}
if (!getRoleBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 3, role_);
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (!getUsernameBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, username_);
}
if (!getPasswordBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, password_);
}
if (!getRoleBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, role_);
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req) obj;
boolean result = true;
result = result && getUsername()
.equals(other.getUsername());
result = result && getPassword()
.equals(other.getPassword());
result = result && getRole()
.equals(other.getRole());
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (37 * hash) + USERNAME_FIELD_NUMBER;
hash = (53 * hash) + getUsername().hashCode();
hash = (37 * hash) + PASSWORD_FIELD_NUMBER;
hash = (53 * hash) + getPassword().hashCode();
hash = (37 * hash) + ROLE_FIELD_NUMBER;
hash = (53 * hash) + getRole().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req 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.kgms.rpc.generated.KGMSConsoleProto.Create.Req parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req 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.kgms.rpc.generated.KGMSConsoleProto.Create.Req parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req 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.kgms.rpc.generated.KGMSConsoleProto.Create.Req parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req 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.kgms.rpc.generated.KGMSConsoleProto.Create.Req 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 Create.Req}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Create.Req)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ReqOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.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();
username_ = "";
password_ = "";
role_ = "";
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_Req_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req(this);
result.username_ = username_;
result.password_ = password_;
result.role_ = role_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req.getDefaultInstance()) return this;
if (!other.getUsername().isEmpty()) {
username_ = other.username_;
onChanged();
}
if (!other.getPassword().isEmpty()) {
password_ = other.password_;
onChanged();
}
if (!other.getRole().isEmpty()) {
role_ = other.role_;
onChanged();
}
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Create.Req parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private java.lang.Object username_ = "";
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</code>
*/
public Builder setUsername(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
username_ = value;
onChanged();
return this;
}
/**
* <code>string username = 1;</code>
*/
public Builder clearUsername() {
username_ = getDefaultInstance().getUsername();
onChanged();
return this;
}
/**
* <code>string username = 1;</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>string password = 2;</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>string password = 2;</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>string password = 2;</code>
*/
public Builder setPassword(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
password_ = value;
onChanged();
return this;
}
/**
* <code>string password = 2;</code>
*/
public Builder clearPassword() {
password_ = getDefaultInstance().getPassword();
onChanged();
return this;
}
/**
* <code>string password = 2;</code>
*/
public Builder setPasswordBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
password_ = value;
onChanged();
return this;
}
private java.lang.Object role_ = "";
/**
* <code>string role = 3;</code>
*/
public java.lang.String getRole() {
java.lang.Object ref = role_;
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
role_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <code>string role = 3;</code>
*/
public com.google.protobuf.ByteString
getRoleBytes() {
java.lang.Object ref = role_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
role_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <code>string role = 3;</code>
*/
public Builder setRole(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
role_ = value;
onChanged();
return this;
}
/**
* <code>string role = 3;</code>
*/
public Builder clearRole() {
role_ = getDefaultInstance().getRole();
onChanged();
return this;
}
/**
* <code>string role = 3;</code>
*/
public Builder setRoleBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
role_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Create.Req)
}
// @@protoc_insertion_point(class_scope:Create.Req)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Req>
PARSER = new com.google.protobuf.AbstractParser<Req>() {
public Req parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Req(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Req> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Req> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Req getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface ResOrBuilder extends
// @@protoc_insertion_point(interface_extends:Create.Res)
com.google.protobuf.MessageOrBuilder {
/**
* <code>.User user = 1;</code>
*/
boolean hasUser();
/**
* <code>.User user = 1;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getUser();
/**
* <code>.User user = 1;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder getUserOrBuilder();
}
/**
* Protobuf type {@code Create.Res}
*/
public static final class Res extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Create.Res)
ResOrBuilder {
private static final long serialVersionUID = 0L;
// Use Res.newBuilder() to construct.
private Res(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Res() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Res(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
int mutable_bitField0_ = 0;
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder subBuilder = null;
if (user_ != null) {
subBuilder = user_.toBuilder();
}
user_ = input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(user_);
user_ = 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.Builder.class);
}
public static final int USER_FIELD_NUMBER = 1;
private ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User user_;
/**
* <code>.User user = 1;</code>
*/
public boolean hasUser() {
return user_ != null;
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getUser() {
return user_ == null ? ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.getDefaultInstance() : user_;
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder getUserOrBuilder() {
return getUser();
}
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 (user_ != null) {
output.writeMessage(1, getUser());
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (user_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, getUser());
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res) obj;
boolean result = true;
result = result && (hasUser() == other.hasUser());
if (hasUser()) {
result = result && getUser()
.equals(other.getUser());
}
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
if (hasUser()) {
hash = (37 * hash) + USER_FIELD_NUMBER;
hash = (53 * hash) + getUser().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res 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.kgms.rpc.generated.KGMSConsoleProto.Create.Res parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res 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.kgms.rpc.generated.KGMSConsoleProto.Create.Res parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res 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.kgms.rpc.generated.KGMSConsoleProto.Create.Res parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res 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.kgms.rpc.generated.KGMSConsoleProto.Create.Res 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 Create.Res}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Create.Res)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.ResOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.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 (userBuilder_ == null) {
user_ = null;
} else {
user_ = null;
userBuilder_ = null;
}
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_Res_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res(this);
if (userBuilder_ == null) {
result.user_ = user_;
} else {
result.user_ = userBuilder_.build();
}
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res.getDefaultInstance()) return this;
if (other.hasUser()) {
mergeUser(other.getUser());
}
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Create.Res parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User user_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder> userBuilder_;
/**
* <code>.User user = 1;</code>
*/
public boolean hasUser() {
return userBuilder_ != null || user_ != null;
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getUser() {
if (userBuilder_ == null) {
return user_ == null ? ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.getDefaultInstance() : user_;
} else {
return userBuilder_.getMessage();
}
}
/**
* <code>.User user = 1;</code>
*/
public Builder setUser(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User value) {
if (userBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
user_ = value;
onChanged();
} else {
userBuilder_.setMessage(value);
}
return this;
}
/**
* <code>.User user = 1;</code>
*/
public Builder setUser(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder builderForValue) {
if (userBuilder_ == null) {
user_ = builderForValue.build();
onChanged();
} else {
userBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>.User user = 1;</code>
*/
public Builder mergeUser(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User value) {
if (userBuilder_ == null) {
if (user_ != null) {
user_ =
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.newBuilder(user_).mergeFrom(value).buildPartial();
} else {
user_ = value;
}
onChanged();
} else {
userBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>.User user = 1;</code>
*/
public Builder clearUser() {
if (userBuilder_ == null) {
user_ = null;
onChanged();
} else {
user_ = null;
userBuilder_ = null;
}
return this;
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder getUserBuilder() {
onChanged();
return getUserFieldBuilder().getBuilder();
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder getUserOrBuilder() {
if (userBuilder_ != null) {
return userBuilder_.getMessageOrBuilder();
} else {
return user_ == null ?
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.getDefaultInstance() : user_;
}
}
/**
* <code>.User user = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder>
getUserFieldBuilder() {
if (userBuilder_ == null) {
userBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder>(
getUser(),
getParentForChildren(),
isClean());
user_ = null;
}
return userBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Create.Res)
}
// @@protoc_insertion_point(class_scope:Create.Res)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Res>
PARSER = new com.google.protobuf.AbstractParser<Res>() {
public Res parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Res(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Res> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Res> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Res getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
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 {
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create) obj;
boolean result = true;
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create 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.kgms.rpc.generated.KGMSConsoleProto.Create parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create 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.kgms.rpc.generated.KGMSConsoleProto.Create parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create 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.kgms.rpc.generated.KGMSConsoleProto.Create parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create 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.kgms.rpc.generated.KGMSConsoleProto.Create 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 Create}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Create)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.CreateOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.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.kgms.rpc.generated.KGMSConsoleProto.internal_static_Create_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create(this);
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create.getDefaultInstance()) return this;
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Create parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Create)
}
// @@protoc_insertion_point(class_scope:Create)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Create>
PARSER = new com.google.protobuf.AbstractParser<Create>() {
public Create parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Create(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Create> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Create> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Create getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface DeleteOrBuilder extends
// @@protoc_insertion_point(interface_extends:Delete)
com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code Delete}
*/
public static final class Delete extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Delete)
DeleteOrBuilder {
private static final long serialVersionUID = 0L;
// Use Delete.newBuilder() to construct.
private Delete(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Delete() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Delete(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Builder.class);
}
public interface ReqOrBuilder extends
// @@protoc_insertion_point(interface_extends:Delete.Req)
com.google.protobuf.MessageOrBuilder {
/**
* <code>string username = 1;</code>
*/
java.lang.String getUsername();
/**
* <code>string username = 1;</code>
*/
com.google.protobuf.ByteString
getUsernameBytes();
}
/**
* Protobuf type {@code Delete.Req}
*/
public static final class Req extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Delete.Req)
ReqOrBuilder {
private static final long serialVersionUID = 0L;
// Use Req.newBuilder() to construct.
private Req(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Req() {
username_ = "";
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Req(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
int mutable_bitField0_ = 0;
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
username_ = 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.Builder.class);
}
public static final int USERNAME_FIELD_NUMBER = 1;
private volatile java.lang.Object username_;
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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;
}
}
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 (!getUsernameBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, username_);
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (!getUsernameBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, username_);
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req) obj;
boolean result = true;
result = result && getUsername()
.equals(other.getUsername());
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (37 * hash) + USERNAME_FIELD_NUMBER;
hash = (53 * hash) + getUsername().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req 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.kgms.rpc.generated.KGMSConsoleProto.Delete.Req parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req 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.kgms.rpc.generated.KGMSConsoleProto.Delete.Req parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req 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.kgms.rpc.generated.KGMSConsoleProto.Delete.Req parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req 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.kgms.rpc.generated.KGMSConsoleProto.Delete.Req 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 Delete.Req}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Delete.Req)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ReqOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.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();
username_ = "";
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_Req_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req(this);
result.username_ = username_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req.getDefaultInstance()) return this;
if (!other.getUsername().isEmpty()) {
username_ = other.username_;
onChanged();
}
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Delete.Req parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private java.lang.Object username_ = "";
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</code>
*/
public Builder setUsername(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
username_ = value;
onChanged();
return this;
}
/**
* <code>string username = 1;</code>
*/
public Builder clearUsername() {
username_ = getDefaultInstance().getUsername();
onChanged();
return this;
}
/**
* <code>string username = 1;</code>
*/
public Builder setUsernameBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
username_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Delete.Req)
}
// @@protoc_insertion_point(class_scope:Delete.Req)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Req>
PARSER = new com.google.protobuf.AbstractParser<Req>() {
public Req parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Req(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Req> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Req> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Req getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface ResOrBuilder extends
// @@protoc_insertion_point(interface_extends:Delete.Res)
com.google.protobuf.MessageOrBuilder {
/**
* <code>string username = 1;</code>
*/
java.lang.String getUsername();
/**
* <code>string username = 1;</code>
*/
com.google.protobuf.ByteString
getUsernameBytes();
}
/**
* Protobuf type {@code Delete.Res}
*/
public static final class Res extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Delete.Res)
ResOrBuilder {
private static final long serialVersionUID = 0L;
// Use Res.newBuilder() to construct.
private Res(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Res() {
username_ = "";
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Res(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
int mutable_bitField0_ = 0;
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
username_ = 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.Builder.class);
}
public static final int USERNAME_FIELD_NUMBER = 1;
private volatile java.lang.Object username_;
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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;
}
}
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 (!getUsernameBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, username_);
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (!getUsernameBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, username_);
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res) obj;
boolean result = true;
result = result && getUsername()
.equals(other.getUsername());
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (37 * hash) + USERNAME_FIELD_NUMBER;
hash = (53 * hash) + getUsername().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res 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.kgms.rpc.generated.KGMSConsoleProto.Delete.Res parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res 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.kgms.rpc.generated.KGMSConsoleProto.Delete.Res parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res 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.kgms.rpc.generated.KGMSConsoleProto.Delete.Res parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res 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.kgms.rpc.generated.KGMSConsoleProto.Delete.Res 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 Delete.Res}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Delete.Res)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.ResOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.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();
username_ = "";
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_Res_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res(this);
result.username_ = username_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res.getDefaultInstance()) return this;
if (!other.getUsername().isEmpty()) {
username_ = other.username_;
onChanged();
}
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Delete.Res parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private java.lang.Object username_ = "";
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</code>
*/
public Builder setUsername(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
username_ = value;
onChanged();
return this;
}
/**
* <code>string username = 1;</code>
*/
public Builder clearUsername() {
username_ = getDefaultInstance().getUsername();
onChanged();
return this;
}
/**
* <code>string username = 1;</code>
*/
public Builder setUsernameBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
username_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Delete.Res)
}
// @@protoc_insertion_point(class_scope:Delete.Res)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Res>
PARSER = new com.google.protobuf.AbstractParser<Res>() {
public Res parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Res(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Res> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Res> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Res getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
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 {
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete) obj;
boolean result = true;
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete 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.kgms.rpc.generated.KGMSConsoleProto.Delete parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete 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.kgms.rpc.generated.KGMSConsoleProto.Delete parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete 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.kgms.rpc.generated.KGMSConsoleProto.Delete parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete 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.kgms.rpc.generated.KGMSConsoleProto.Delete 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 Delete}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Delete)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.DeleteOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.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.kgms.rpc.generated.KGMSConsoleProto.internal_static_Delete_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete(this);
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete.getDefaultInstance()) return this;
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Delete parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Delete)
}
// @@protoc_insertion_point(class_scope:Delete)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Delete>
PARSER = new com.google.protobuf.AbstractParser<Delete>() {
public Delete parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Delete(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Delete> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Delete> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Delete getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface RetrieveOrBuilder extends
// @@protoc_insertion_point(interface_extends:Retrieve)
com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code Retrieve}
*/
public static final class Retrieve extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Retrieve)
RetrieveOrBuilder {
private static final long serialVersionUID = 0L;
// Use Retrieve.newBuilder() to construct.
private Retrieve(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Retrieve() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Retrieve(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Builder.class);
}
public interface ReqOrBuilder extends
// @@protoc_insertion_point(interface_extends:Retrieve.Req)
com.google.protobuf.MessageOrBuilder {
/**
* <code>string username = 1;</code>
*/
java.lang.String getUsername();
/**
* <code>string username = 1;</code>
*/
com.google.protobuf.ByteString
getUsernameBytes();
}
/**
* Protobuf type {@code Retrieve.Req}
*/
public static final class Req extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Retrieve.Req)
ReqOrBuilder {
private static final long serialVersionUID = 0L;
// Use Req.newBuilder() to construct.
private Req(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Req() {
username_ = "";
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Req(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
int mutable_bitField0_ = 0;
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
username_ = 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.Builder.class);
}
public static final int USERNAME_FIELD_NUMBER = 1;
private volatile java.lang.Object username_;
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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;
}
}
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 (!getUsernameBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, username_);
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (!getUsernameBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, username_);
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req) obj;
boolean result = true;
result = result && getUsername()
.equals(other.getUsername());
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (37 * hash) + USERNAME_FIELD_NUMBER;
hash = (53 * hash) + getUsername().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req 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.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req 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.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req 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.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req 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.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req 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 Retrieve.Req}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Retrieve.Req)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ReqOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.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();
username_ = "";
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_Req_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req(this);
result.username_ = username_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req.getDefaultInstance()) return this;
if (!other.getUsername().isEmpty()) {
username_ = other.username_;
onChanged();
}
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private java.lang.Object username_ = "";
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</code>
*/
public Builder setUsername(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
username_ = value;
onChanged();
return this;
}
/**
* <code>string username = 1;</code>
*/
public Builder clearUsername() {
username_ = getDefaultInstance().getUsername();
onChanged();
return this;
}
/**
* <code>string username = 1;</code>
*/
public Builder setUsernameBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
username_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Retrieve.Req)
}
// @@protoc_insertion_point(class_scope:Retrieve.Req)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Req>
PARSER = new com.google.protobuf.AbstractParser<Req>() {
public Req parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Req(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Req> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Req> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Req getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface ResOrBuilder extends
// @@protoc_insertion_point(interface_extends:Retrieve.Res)
com.google.protobuf.MessageOrBuilder {
/**
* <code>.User user = 1;</code>
*/
boolean hasUser();
/**
* <code>.User user = 1;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getUser();
/**
* <code>.User user = 1;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder getUserOrBuilder();
}
/**
* Protobuf type {@code Retrieve.Res}
*/
public static final class Res extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Retrieve.Res)
ResOrBuilder {
private static final long serialVersionUID = 0L;
// Use Res.newBuilder() to construct.
private Res(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Res() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Res(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
int mutable_bitField0_ = 0;
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder subBuilder = null;
if (user_ != null) {
subBuilder = user_.toBuilder();
}
user_ = input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(user_);
user_ = 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.Builder.class);
}
public static final int USER_FIELD_NUMBER = 1;
private ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User user_;
/**
* <code>.User user = 1;</code>
*/
public boolean hasUser() {
return user_ != null;
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getUser() {
return user_ == null ? ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.getDefaultInstance() : user_;
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder getUserOrBuilder() {
return getUser();
}
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 (user_ != null) {
output.writeMessage(1, getUser());
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (user_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, getUser());
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res) obj;
boolean result = true;
result = result && (hasUser() == other.hasUser());
if (hasUser()) {
result = result && getUser()
.equals(other.getUser());
}
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
if (hasUser()) {
hash = (37 * hash) + USER_FIELD_NUMBER;
hash = (53 * hash) + getUser().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res 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.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res 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.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res 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.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res 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.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res 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 Retrieve.Res}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Retrieve.Res)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.ResOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.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 (userBuilder_ == null) {
user_ = null;
} else {
user_ = null;
userBuilder_ = null;
}
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_Res_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res(this);
if (userBuilder_ == null) {
result.user_ = user_;
} else {
result.user_ = userBuilder_.build();
}
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res.getDefaultInstance()) return this;
if (other.hasUser()) {
mergeUser(other.getUser());
}
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User user_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder> userBuilder_;
/**
* <code>.User user = 1;</code>
*/
public boolean hasUser() {
return userBuilder_ != null || user_ != null;
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getUser() {
if (userBuilder_ == null) {
return user_ == null ? ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.getDefaultInstance() : user_;
} else {
return userBuilder_.getMessage();
}
}
/**
* <code>.User user = 1;</code>
*/
public Builder setUser(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User value) {
if (userBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
user_ = value;
onChanged();
} else {
userBuilder_.setMessage(value);
}
return this;
}
/**
* <code>.User user = 1;</code>
*/
public Builder setUser(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder builderForValue) {
if (userBuilder_ == null) {
user_ = builderForValue.build();
onChanged();
} else {
userBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>.User user = 1;</code>
*/
public Builder mergeUser(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User value) {
if (userBuilder_ == null) {
if (user_ != null) {
user_ =
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.newBuilder(user_).mergeFrom(value).buildPartial();
} else {
user_ = value;
}
onChanged();
} else {
userBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>.User user = 1;</code>
*/
public Builder clearUser() {
if (userBuilder_ == null) {
user_ = null;
onChanged();
} else {
user_ = null;
userBuilder_ = null;
}
return this;
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder getUserBuilder() {
onChanged();
return getUserFieldBuilder().getBuilder();
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder getUserOrBuilder() {
if (userBuilder_ != null) {
return userBuilder_.getMessageOrBuilder();
} else {
return user_ == null ?
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.getDefaultInstance() : user_;
}
}
/**
* <code>.User user = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder>
getUserFieldBuilder() {
if (userBuilder_ == null) {
userBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder>(
getUser(),
getParentForChildren(),
isClean());
user_ = null;
}
return userBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Retrieve.Res)
}
// @@protoc_insertion_point(class_scope:Retrieve.Res)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Res>
PARSER = new com.google.protobuf.AbstractParser<Res>() {
public Res parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Res(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Res> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Res> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Res getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
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 {
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve) obj;
boolean result = true;
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve 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.kgms.rpc.generated.KGMSConsoleProto.Retrieve parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve 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.kgms.rpc.generated.KGMSConsoleProto.Retrieve parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve 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.kgms.rpc.generated.KGMSConsoleProto.Retrieve parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve 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.kgms.rpc.generated.KGMSConsoleProto.Retrieve 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 Retrieve}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Retrieve)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.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.kgms.rpc.generated.KGMSConsoleProto.internal_static_Retrieve_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve(this);
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve.getDefaultInstance()) return this;
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Retrieve parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Retrieve)
}
// @@protoc_insertion_point(class_scope:Retrieve)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Retrieve>
PARSER = new com.google.protobuf.AbstractParser<Retrieve>() {
public Retrieve parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Retrieve(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Retrieve> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Retrieve> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Retrieve getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface RetrieveAllOrBuilder extends
// @@protoc_insertion_point(interface_extends:RetrieveAll)
com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code RetrieveAll}
*/
public static final class RetrieveAll extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:RetrieveAll)
RetrieveAllOrBuilder {
private static final long serialVersionUID = 0L;
// Use RetrieveAll.newBuilder() to construct.
private RetrieveAll(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private RetrieveAll() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private RetrieveAll(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Builder.class);
}
public interface ReqOrBuilder extends
// @@protoc_insertion_point(interface_extends:RetrieveAll.Req)
com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code RetrieveAll.Req}
*/
public static final class Req extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:RetrieveAll.Req)
ReqOrBuilder {
private static final long serialVersionUID = 0L;
// Use Req.newBuilder() to construct.
private Req(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Req() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Req(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.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 {
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req) obj;
boolean result = true;
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req 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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req 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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req 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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req 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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req 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 RetrieveAll.Req}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:RetrieveAll.Req)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ReqOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.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.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_Req_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req(this);
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req.getDefaultInstance()) return this;
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:RetrieveAll.Req)
}
// @@protoc_insertion_point(class_scope:RetrieveAll.Req)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Req>
PARSER = new com.google.protobuf.AbstractParser<Req>() {
public Req parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Req(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Req> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Req> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Req getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface ResOrBuilder extends
// @@protoc_insertion_point(interface_extends:RetrieveAll.Res)
com.google.protobuf.MessageOrBuilder {
/**
* <code>repeated .User users = 1;</code>
*/
java.util.List<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User>
getUsersList();
/**
* <code>repeated .User users = 1;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getUsers(int index);
/**
* <code>repeated .User users = 1;</code>
*/
int getUsersCount();
/**
* <code>repeated .User users = 1;</code>
*/
java.util.List<? extends ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder>
getUsersOrBuilderList();
/**
* <code>repeated .User users = 1;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder getUsersOrBuilder(
int index);
}
/**
* Protobuf type {@code RetrieveAll.Res}
*/
public static final class Res extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:RetrieveAll.Res)
ResOrBuilder {
private static final long serialVersionUID = 0L;
// Use Res.newBuilder() to construct.
private Res(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Res() {
users_ = java.util.Collections.emptyList();
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Res(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
int mutable_bitField0_ = 0;
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
users_ = new java.util.ArrayList<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User>();
mutable_bitField0_ |= 0x00000001;
}
users_.add(
input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.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)) {
users_ = java.util.Collections.unmodifiableList(users_);
}
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.Builder.class);
}
public static final int USERS_FIELD_NUMBER = 1;
private java.util.List<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User> users_;
/**
* <code>repeated .User users = 1;</code>
*/
public java.util.List<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User> getUsersList() {
return users_;
}
/**
* <code>repeated .User users = 1;</code>
*/
public java.util.List<? extends ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder>
getUsersOrBuilderList() {
return users_;
}
/**
* <code>repeated .User users = 1;</code>
*/
public int getUsersCount() {
return users_.size();
}
/**
* <code>repeated .User users = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getUsers(int index) {
return users_.get(index);
}
/**
* <code>repeated .User users = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder getUsersOrBuilder(
int index) {
return users_.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 < users_.size(); i++) {
output.writeMessage(1, users_.get(i));
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
for (int i = 0; i < users_.size(); i++) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, users_.get(i));
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res) obj;
boolean result = true;
result = result && getUsersList()
.equals(other.getUsersList());
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
if (getUsersCount() > 0) {
hash = (37 * hash) + USERS_FIELD_NUMBER;
hash = (53 * hash) + getUsersList().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res 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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res 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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res 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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res 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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res 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 RetrieveAll.Res}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:RetrieveAll.Res)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.ResOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
getUsersFieldBuilder();
}
}
public Builder clear() {
super.clear();
if (usersBuilder_ == null) {
users_ = java.util.Collections.emptyList();
bitField0_ = (bitField0_ & ~0x00000001);
} else {
usersBuilder_.clear();
}
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_Res_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res(this);
int from_bitField0_ = bitField0_;
if (usersBuilder_ == null) {
if (((bitField0_ & 0x00000001) == 0x00000001)) {
users_ = java.util.Collections.unmodifiableList(users_);
bitField0_ = (bitField0_ & ~0x00000001);
}
result.users_ = users_;
} else {
result.users_ = usersBuilder_.build();
}
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res.getDefaultInstance()) return this;
if (usersBuilder_ == null) {
if (!other.users_.isEmpty()) {
if (users_.isEmpty()) {
users_ = other.users_;
bitField0_ = (bitField0_ & ~0x00000001);
} else {
ensureUsersIsMutable();
users_.addAll(other.users_);
}
onChanged();
}
} else {
if (!other.users_.isEmpty()) {
if (usersBuilder_.isEmpty()) {
usersBuilder_.dispose();
usersBuilder_ = null;
users_ = other.users_;
bitField0_ = (bitField0_ & ~0x00000001);
usersBuilder_ =
com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
getUsersFieldBuilder() : null;
} else {
usersBuilder_.addAllMessages(other.users_);
}
}
}
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int bitField0_;
private java.util.List<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User> users_ =
java.util.Collections.emptyList();
private void ensureUsersIsMutable() {
if (!((bitField0_ & 0x00000001) == 0x00000001)) {
users_ = new java.util.ArrayList<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User>(users_);
bitField0_ |= 0x00000001;
}
}
private com.google.protobuf.RepeatedFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder> usersBuilder_;
/**
* <code>repeated .User users = 1;</code>
*/
public java.util.List<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User> getUsersList() {
if (usersBuilder_ == null) {
return java.util.Collections.unmodifiableList(users_);
} else {
return usersBuilder_.getMessageList();
}
}
/**
* <code>repeated .User users = 1;</code>
*/
public int getUsersCount() {
if (usersBuilder_ == null) {
return users_.size();
} else {
return usersBuilder_.getCount();
}
}
/**
* <code>repeated .User users = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getUsers(int index) {
if (usersBuilder_ == null) {
return users_.get(index);
} else {
return usersBuilder_.getMessage(index);
}
}
/**
* <code>repeated .User users = 1;</code>
*/
public Builder setUsers(
int index, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User value) {
if (usersBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
ensureUsersIsMutable();
users_.set(index, value);
onChanged();
} else {
usersBuilder_.setMessage(index, value);
}
return this;
}
/**
* <code>repeated .User users = 1;</code>
*/
public Builder setUsers(
int index, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder builderForValue) {
if (usersBuilder_ == null) {
ensureUsersIsMutable();
users_.set(index, builderForValue.build());
onChanged();
} else {
usersBuilder_.setMessage(index, builderForValue.build());
}
return this;
}
/**
* <code>repeated .User users = 1;</code>
*/
public Builder addUsers(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User value) {
if (usersBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
ensureUsersIsMutable();
users_.add(value);
onChanged();
} else {
usersBuilder_.addMessage(value);
}
return this;
}
/**
* <code>repeated .User users = 1;</code>
*/
public Builder addUsers(
int index, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User value) {
if (usersBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
ensureUsersIsMutable();
users_.add(index, value);
onChanged();
} else {
usersBuilder_.addMessage(index, value);
}
return this;
}
/**
* <code>repeated .User users = 1;</code>
*/
public Builder addUsers(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder builderForValue) {
if (usersBuilder_ == null) {
ensureUsersIsMutable();
users_.add(builderForValue.build());
onChanged();
} else {
usersBuilder_.addMessage(builderForValue.build());
}
return this;
}
/**
* <code>repeated .User users = 1;</code>
*/
public Builder addUsers(
int index, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder builderForValue) {
if (usersBuilder_ == null) {
ensureUsersIsMutable();
users_.add(index, builderForValue.build());
onChanged();
} else {
usersBuilder_.addMessage(index, builderForValue.build());
}
return this;
}
/**
* <code>repeated .User users = 1;</code>
*/
public Builder addAllUsers(
java.lang.Iterable<? extends ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User> values) {
if (usersBuilder_ == null) {
ensureUsersIsMutable();
com.google.protobuf.AbstractMessageLite.Builder.addAll(
values, users_);
onChanged();
} else {
usersBuilder_.addAllMessages(values);
}
return this;
}
/**
* <code>repeated .User users = 1;</code>
*/
public Builder clearUsers() {
if (usersBuilder_ == null) {
users_ = java.util.Collections.emptyList();
bitField0_ = (bitField0_ & ~0x00000001);
onChanged();
} else {
usersBuilder_.clear();
}
return this;
}
/**
* <code>repeated .User users = 1;</code>
*/
public Builder removeUsers(int index) {
if (usersBuilder_ == null) {
ensureUsersIsMutable();
users_.remove(index);
onChanged();
} else {
usersBuilder_.remove(index);
}
return this;
}
/**
* <code>repeated .User users = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder getUsersBuilder(
int index) {
return getUsersFieldBuilder().getBuilder(index);
}
/**
* <code>repeated .User users = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder getUsersOrBuilder(
int index) {
if (usersBuilder_ == null) {
return users_.get(index); } else {
return usersBuilder_.getMessageOrBuilder(index);
}
}
/**
* <code>repeated .User users = 1;</code>
*/
public java.util.List<? extends ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder>
getUsersOrBuilderList() {
if (usersBuilder_ != null) {
return usersBuilder_.getMessageOrBuilderList();
} else {
return java.util.Collections.unmodifiableList(users_);
}
}
/**
* <code>repeated .User users = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder addUsersBuilder() {
return getUsersFieldBuilder().addBuilder(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.getDefaultInstance());
}
/**
* <code>repeated .User users = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder addUsersBuilder(
int index) {
return getUsersFieldBuilder().addBuilder(
index, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.getDefaultInstance());
}
/**
* <code>repeated .User users = 1;</code>
*/
public java.util.List<ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder>
getUsersBuilderList() {
return getUsersFieldBuilder().getBuilderList();
}
private com.google.protobuf.RepeatedFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder>
getUsersFieldBuilder() {
if (usersBuilder_ == null) {
usersBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder>(
users_,
((bitField0_ & 0x00000001) == 0x00000001),
getParentForChildren(),
isClean());
users_ = null;
}
return usersBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:RetrieveAll.Res)
}
// @@protoc_insertion_point(class_scope:RetrieveAll.Res)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Res>
PARSER = new com.google.protobuf.AbstractParser<Res>() {
public Res parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Res(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Res> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Res> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Res getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
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 {
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll) obj;
boolean result = true;
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll 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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll 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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll 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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll 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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll 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 RetrieveAll}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:RetrieveAll)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAllOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.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.kgms.rpc.generated.KGMSConsoleProto.internal_static_RetrieveAll_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll(this);
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll.getDefaultInstance()) return this;
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:RetrieveAll)
}
// @@protoc_insertion_point(class_scope:RetrieveAll)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<RetrieveAll>
PARSER = new com.google.protobuf.AbstractParser<RetrieveAll>() {
public RetrieveAll parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new RetrieveAll(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<RetrieveAll> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<RetrieveAll> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.RetrieveAll getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface UpdateOrBuilder extends
// @@protoc_insertion_point(interface_extends:Update)
com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code Update}
*/
public static final class Update extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Update)
UpdateOrBuilder {
private static final long serialVersionUID = 0L;
// Use Update.newBuilder() to construct.
private Update(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Update() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Update(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Builder.class);
}
public interface ReqOrBuilder extends
// @@protoc_insertion_point(interface_extends:Update.Req)
com.google.protobuf.MessageOrBuilder {
/**
* <code>string username = 1;</code>
*/
java.lang.String getUsername();
/**
* <code>string username = 1;</code>
*/
com.google.protobuf.ByteString
getUsernameBytes();
/**
* <code>string password = 2;</code>
*/
java.lang.String getPassword();
/**
* <code>string password = 2;</code>
*/
com.google.protobuf.ByteString
getPasswordBytes();
/**
* <code>string role = 3;</code>
*/
java.lang.String getRole();
/**
* <code>string role = 3;</code>
*/
com.google.protobuf.ByteString
getRoleBytes();
}
/**
* Protobuf type {@code Update.Req}
*/
public static final class Req extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Update.Req)
ReqOrBuilder {
private static final long serialVersionUID = 0L;
// Use Req.newBuilder() to construct.
private Req(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Req() {
username_ = "";
password_ = "";
role_ = "";
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Req(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
int mutable_bitField0_ = 0;
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
username_ = s;
break;
}
case 18: {
java.lang.String s = input.readStringRequireUtf8();
password_ = s;
break;
}
case 26: {
java.lang.String s = input.readStringRequireUtf8();
role_ = 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.Builder.class);
}
public static final int USERNAME_FIELD_NUMBER = 1;
private volatile java.lang.Object username_;
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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 = 2;
private volatile java.lang.Object password_;
/**
* <code>string password = 2;</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>string password = 2;</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;
}
}
public static final int ROLE_FIELD_NUMBER = 3;
private volatile java.lang.Object role_;
/**
* <code>string role = 3;</code>
*/
public java.lang.String getRole() {
java.lang.Object ref = role_;
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();
role_ = s;
return s;
}
}
/**
* <code>string role = 3;</code>
*/
public com.google.protobuf.ByteString
getRoleBytes() {
java.lang.Object ref = role_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
role_ = 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 (!getUsernameBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, username_);
}
if (!getPasswordBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 2, password_);
}
if (!getRoleBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 3, role_);
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (!getUsernameBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, username_);
}
if (!getPasswordBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, password_);
}
if (!getRoleBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, role_);
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req) obj;
boolean result = true;
result = result && getUsername()
.equals(other.getUsername());
result = result && getPassword()
.equals(other.getPassword());
result = result && getRole()
.equals(other.getRole());
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (37 * hash) + USERNAME_FIELD_NUMBER;
hash = (53 * hash) + getUsername().hashCode();
hash = (37 * hash) + PASSWORD_FIELD_NUMBER;
hash = (53 * hash) + getPassword().hashCode();
hash = (37 * hash) + ROLE_FIELD_NUMBER;
hash = (53 * hash) + getRole().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req 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.kgms.rpc.generated.KGMSConsoleProto.Update.Req parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req 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.kgms.rpc.generated.KGMSConsoleProto.Update.Req parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req 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.kgms.rpc.generated.KGMSConsoleProto.Update.Req parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req 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.kgms.rpc.generated.KGMSConsoleProto.Update.Req 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 Update.Req}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Update.Req)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ReqOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_Req_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_Req_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.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();
username_ = "";
password_ = "";
role_ = "";
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_Req_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req(this);
result.username_ = username_;
result.password_ = password_;
result.role_ = role_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req.getDefaultInstance()) return this;
if (!other.getUsername().isEmpty()) {
username_ = other.username_;
onChanged();
}
if (!other.getPassword().isEmpty()) {
password_ = other.password_;
onChanged();
}
if (!other.getRole().isEmpty()) {
role_ = other.role_;
onChanged();
}
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Update.Req parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private java.lang.Object username_ = "";
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</code>
*/
public Builder setUsername(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
username_ = value;
onChanged();
return this;
}
/**
* <code>string username = 1;</code>
*/
public Builder clearUsername() {
username_ = getDefaultInstance().getUsername();
onChanged();
return this;
}
/**
* <code>string username = 1;</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>string password = 2;</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>string password = 2;</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>string password = 2;</code>
*/
public Builder setPassword(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
password_ = value;
onChanged();
return this;
}
/**
* <code>string password = 2;</code>
*/
public Builder clearPassword() {
password_ = getDefaultInstance().getPassword();
onChanged();
return this;
}
/**
* <code>string password = 2;</code>
*/
public Builder setPasswordBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
password_ = value;
onChanged();
return this;
}
private java.lang.Object role_ = "";
/**
* <code>string role = 3;</code>
*/
public java.lang.String getRole() {
java.lang.Object ref = role_;
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
role_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <code>string role = 3;</code>
*/
public com.google.protobuf.ByteString
getRoleBytes() {
java.lang.Object ref = role_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
role_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <code>string role = 3;</code>
*/
public Builder setRole(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
role_ = value;
onChanged();
return this;
}
/**
* <code>string role = 3;</code>
*/
public Builder clearRole() {
role_ = getDefaultInstance().getRole();
onChanged();
return this;
}
/**
* <code>string role = 3;</code>
*/
public Builder setRoleBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
role_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Update.Req)
}
// @@protoc_insertion_point(class_scope:Update.Req)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Req>
PARSER = new com.google.protobuf.AbstractParser<Req>() {
public Req parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Req(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Req> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Req> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Req getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface ResOrBuilder extends
// @@protoc_insertion_point(interface_extends:Update.Res)
com.google.protobuf.MessageOrBuilder {
/**
* <code>.User user = 1;</code>
*/
boolean hasUser();
/**
* <code>.User user = 1;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getUser();
/**
* <code>.User user = 1;</code>
*/
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder getUserOrBuilder();
}
/**
* Protobuf type {@code Update.Res}
*/
public static final class Res extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:Update.Res)
ResOrBuilder {
private static final long serialVersionUID = 0L;
// Use Res.newBuilder() to construct.
private Res(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private Res() {
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private Res(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
int mutable_bitField0_ = 0;
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder subBuilder = null;
if (user_ != null) {
subBuilder = user_.toBuilder();
}
user_ = input.readMessage(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.parser(), extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(user_);
user_ = 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.Builder.class);
}
public static final int USER_FIELD_NUMBER = 1;
private ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User user_;
/**
* <code>.User user = 1;</code>
*/
public boolean hasUser() {
return user_ != null;
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getUser() {
return user_ == null ? ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.getDefaultInstance() : user_;
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder getUserOrBuilder() {
return getUser();
}
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 (user_ != null) {
output.writeMessage(1, getUser());
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (user_ != null) {
size += com.google.protobuf.CodedOutputStream
.computeMessageSize(1, getUser());
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res) obj;
boolean result = true;
result = result && (hasUser() == other.hasUser());
if (hasUser()) {
result = result && getUser()
.equals(other.getUser());
}
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
if (hasUser()) {
hash = (37 * hash) + USER_FIELD_NUMBER;
hash = (53 * hash) + getUser().hashCode();
}
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res 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.kgms.rpc.generated.KGMSConsoleProto.Update.Res parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res 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.kgms.rpc.generated.KGMSConsoleProto.Update.Res parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res 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.kgms.rpc.generated.KGMSConsoleProto.Update.Res parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res 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.kgms.rpc.generated.KGMSConsoleProto.Update.Res 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 Update.Res}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Update.Res)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.ResOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_Res_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_Res_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.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 (userBuilder_ == null) {
user_ = null;
} else {
user_ = null;
userBuilder_ = null;
}
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_Res_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res(this);
if (userBuilder_ == null) {
result.user_ = user_;
} else {
result.user_ = userBuilder_.build();
}
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res.getDefaultInstance()) return this;
if (other.hasUser()) {
mergeUser(other.getUser());
}
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Update.Res parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User user_ = null;
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder> userBuilder_;
/**
* <code>.User user = 1;</code>
*/
public boolean hasUser() {
return userBuilder_ != null || user_ != null;
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getUser() {
if (userBuilder_ == null) {
return user_ == null ? ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.getDefaultInstance() : user_;
} else {
return userBuilder_.getMessage();
}
}
/**
* <code>.User user = 1;</code>
*/
public Builder setUser(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User value) {
if (userBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
}
user_ = value;
onChanged();
} else {
userBuilder_.setMessage(value);
}
return this;
}
/**
* <code>.User user = 1;</code>
*/
public Builder setUser(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder builderForValue) {
if (userBuilder_ == null) {
user_ = builderForValue.build();
onChanged();
} else {
userBuilder_.setMessage(builderForValue.build());
}
return this;
}
/**
* <code>.User user = 1;</code>
*/
public Builder mergeUser(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User value) {
if (userBuilder_ == null) {
if (user_ != null) {
user_ =
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.newBuilder(user_).mergeFrom(value).buildPartial();
} else {
user_ = value;
}
onChanged();
} else {
userBuilder_.mergeFrom(value);
}
return this;
}
/**
* <code>.User user = 1;</code>
*/
public Builder clearUser() {
if (userBuilder_ == null) {
user_ = null;
onChanged();
} else {
user_ = null;
userBuilder_ = null;
}
return this;
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder getUserBuilder() {
onChanged();
return getUserFieldBuilder().getBuilder();
}
/**
* <code>.User user = 1;</code>
*/
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder getUserOrBuilder() {
if (userBuilder_ != null) {
return userBuilder_.getMessageOrBuilder();
} else {
return user_ == null ?
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.getDefaultInstance() : user_;
}
}
/**
* <code>.User user = 1;</code>
*/
private com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder>
getUserFieldBuilder() {
if (userBuilder_ == null) {
userBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder>(
getUser(),
getParentForChildren(),
isClean());
user_ = null;
}
return userBuilder_;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Update.Res)
}
// @@protoc_insertion_point(class_scope:Update.Res)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Res>
PARSER = new com.google.protobuf.AbstractParser<Res>() {
public Res parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Res(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Res> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Res> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Res getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
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 {
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update) obj;
boolean result = true;
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update 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.kgms.rpc.generated.KGMSConsoleProto.Update parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update 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.kgms.rpc.generated.KGMSConsoleProto.Update parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update 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.kgms.rpc.generated.KGMSConsoleProto.Update parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update 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.kgms.rpc.generated.KGMSConsoleProto.Update 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 Update}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:Update)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UpdateOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.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.kgms.rpc.generated.KGMSConsoleProto.internal_static_Update_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update(this);
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update.getDefaultInstance()) return this;
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.Update parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:Update)
}
// @@protoc_insertion_point(class_scope:Update)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<Update>
PARSER = new com.google.protobuf.AbstractParser<Update>() {
public Update parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new Update(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<Update> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<Update> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.Update getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface UserOrBuilder extends
// @@protoc_insertion_point(interface_extends:User)
com.google.protobuf.MessageOrBuilder {
/**
* <code>string username = 1;</code>
*/
java.lang.String getUsername();
/**
* <code>string username = 1;</code>
*/
com.google.protobuf.ByteString
getUsernameBytes();
/**
* <code>string role = 2;</code>
*/
java.lang.String getRole();
/**
* <code>string role = 2;</code>
*/
com.google.protobuf.ByteString
getRoleBytes();
}
/**
* Protobuf type {@code User}
*/
public static final class User extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:User)
UserOrBuilder {
private static final long serialVersionUID = 0L;
// Use User.newBuilder() to construct.
private User(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private User() {
username_ = "";
role_ = "";
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private User(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
int mutable_bitField0_ = 0;
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownFieldProto3(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
java.lang.String s = input.readStringRequireUtf8();
username_ = s;
break;
}
case 18: {
java.lang.String s = input.readStringRequireUtf8();
role_ = 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 {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_User_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_User_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder.class);
}
public static final int USERNAME_FIELD_NUMBER = 1;
private volatile java.lang.Object username_;
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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 ROLE_FIELD_NUMBER = 2;
private volatile java.lang.Object role_;
/**
* <code>string role = 2;</code>
*/
public java.lang.String getRole() {
java.lang.Object ref = role_;
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();
role_ = s;
return s;
}
}
/**
* <code>string role = 2;</code>
*/
public com.google.protobuf.ByteString
getRoleBytes() {
java.lang.Object ref = role_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
role_ = 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 (!getUsernameBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, username_);
}
if (!getRoleBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 2, role_);
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (!getUsernameBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, username_);
}
if (!getRoleBytes().isEmpty()) {
size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, role_);
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User)) {
return super.equals(obj);
}
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User other = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User) obj;
boolean result = true;
result = result && getUsername()
.equals(other.getUsername());
result = result && getRole()
.equals(other.getRole());
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (37 * hash) + USERNAME_FIELD_NUMBER;
hash = (53 * hash) + getUsername().hashCode();
hash = (37 * hash) + ROLE_FIELD_NUMBER;
hash = (53 * hash) + getRole().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User 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.kgms.rpc.generated.KGMSConsoleProto.User parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User 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.kgms.rpc.generated.KGMSConsoleProto.User parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User 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.kgms.rpc.generated.KGMSConsoleProto.User parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User 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.kgms.rpc.generated.KGMSConsoleProto.User 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 User}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:User)
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.UserOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_User_descriptor;
}
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_User_fieldAccessorTable
.ensureFieldAccessorsInitialized(
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.class, ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.Builder.class);
}
// Construct using ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.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();
username_ = "";
role_ = "";
return this;
}
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.internal_static_User_descriptor;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getDefaultInstanceForType() {
return ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.getDefaultInstance();
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User build() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User buildPartial() {
ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User result = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User(this);
result.username_ = username_;
result.role_ = role_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.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, java.lang.Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User) {
return mergeFrom((ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User other) {
if (other == ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User.getDefaultInstance()) return this;
if (!other.getUsername().isEmpty()) {
username_ = other.username_;
onChanged();
}
if (!other.getRole().isEmpty()) {
role_ = other.role_;
onChanged();
}
this.mergeUnknownFields(other.unknownFields);
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.kgms.rpc.generated.KGMSConsoleProto.User parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private java.lang.Object username_ = "";
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</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;
}
}
/**
* <code>string username = 1;</code>
*/
public Builder setUsername(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
username_ = value;
onChanged();
return this;
}
/**
* <code>string username = 1;</code>
*/
public Builder clearUsername() {
username_ = getDefaultInstance().getUsername();
onChanged();
return this;
}
/**
* <code>string username = 1;</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 role_ = "";
/**
* <code>string role = 2;</code>
*/
public java.lang.String getRole() {
java.lang.Object ref = role_;
if (!(ref instanceof java.lang.String)) {
com.google.protobuf.ByteString bs =
(com.google.protobuf.ByteString) ref;
java.lang.String s = bs.toStringUtf8();
role_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
/**
* <code>string role = 2;</code>
*/
public com.google.protobuf.ByteString
getRoleBytes() {
java.lang.Object ref = role_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
com.google.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
role_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
/**
* <code>string role = 2;</code>
*/
public Builder setRole(
java.lang.String value) {
if (value == null) {
throw new NullPointerException();
}
role_ = value;
onChanged();
return this;
}
/**
* <code>string role = 2;</code>
*/
public Builder clearRole() {
role_ = getDefaultInstance().getRole();
onChanged();
return this;
}
/**
* <code>string role = 2;</code>
*/
public Builder setRoleBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
checkByteStringIsUtf8(value);
role_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFieldsProto3(unknownFields);
}
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:User)
}
// @@protoc_insertion_point(class_scope:User)
private static final ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User();
}
public static ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<User>
PARSER = new com.google.protobuf.AbstractParser<User>() {
public User parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new User(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<User> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<User> getParserForType() {
return PARSER;
}
public ai.grakn.kgms.rpc.generated.KGMSConsoleProto.User getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_UserManagement_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_UserManagement_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_UserManagement_Req_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_UserManagement_Req_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_UserManagement_Res_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_UserManagement_Res_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Login_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Login_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Login_Req_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Login_Req_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Login_Res_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Login_Res_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Create_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Create_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Create_Req_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Create_Req_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Create_Res_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Create_Res_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Delete_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Delete_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Delete_Req_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Delete_Req_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Delete_Res_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Delete_Res_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Retrieve_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Retrieve_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Retrieve_Req_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Retrieve_Req_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Retrieve_Res_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Retrieve_Res_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_RetrieveAll_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_RetrieveAll_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_RetrieveAll_Req_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_RetrieveAll_Req_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_RetrieveAll_Res_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_RetrieveAll_Res_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Update_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Update_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Update_Req_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Update_Req_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_Update_Res_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_Update_Res_fieldAccessorTable;
private static final com.google.protobuf.Descriptors.Descriptor
internal_static_User_descriptor;
private static final
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internal_static_User_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\022kbms_console.proto\"\354\003\n\016UserManagement\032" +
"\353\001\n\003Req\022\037\n\tlogin_req\030\001 \001(\0132\n.Login.ReqH\000" +
"\022!\n\ncreate_req\030\002 \001(\0132\013.Create.ReqH\000\022!\n\nd" +
"elete_req\030\003 \001(\0132\013.Delete.ReqH\000\022%\n\014retrie" +
"ve_req\030\004 \001(\0132\r.Retrieve.ReqH\000\022,\n\020retriev" +
"e_all_req\030\005 \001(\0132\020.RetrieveAll.ReqH\000\022!\n\nu" +
"pdate_req\030\006 \001(\0132\013.Update.ReqH\000B\005\n\003req\032\353\001" +
"\n\003Res\022\037\n\tlogin_res\030\001 \001(\0132\n.Login.ResH\000\022!" +
"\n\ncreate_res\030\002 \001(\0132\013.Create.ResH\000\022!\n\ndel" +
"ete_res\030\003 \001(\0132\013.Delete.ResH\000\022%\n\014retrieve" +
"_res\030\004 \001(\0132\r.Retrieve.ResH\000\022,\n\020retrieve_" +
"all_res\030\005 \001(\0132\020.RetrieveAll.ResH\000\022!\n\nupd" +
"ate_res\030\006 \001(\0132\013.Update.ResH\000B\005\n\003res\"9\n\005L" +
"ogin\032)\n\003Req\022\020\n\010username\030\001 \001(\t\022\020\n\010passwor" +
"d\030\002 \001(\t\032\005\n\003Res\"]\n\006Create\0327\n\003Req\022\020\n\010usern" +
"ame\030\001 \001(\t\022\020\n\010password\030\002 \001(\t\022\014\n\004role\030\003 \001(" +
"\t\032\032\n\003Res\022\023\n\004user\030\001 \001(\0132\005.User\":\n\006Delete\032" +
"\027\n\003Req\022\020\n\010username\030\001 \001(\t\032\027\n\003Res\022\020\n\010usern" +
"ame\030\001 \001(\t\"?\n\010Retrieve\032\027\n\003Req\022\020\n\010username" +
"\030\001 \001(\t\032\032\n\003Res\022\023\n\004user\030\001 \001(\0132\005.User\"1\n\013Re" +
"trieveAll\032\005\n\003Req\032\033\n\003Res\022\024\n\005users\030\001 \003(\0132\005" +
".User\"]\n\006Update\0327\n\003Req\022\020\n\010username\030\001 \001(\t" +
"\022\020\n\010password\030\002 \001(\t\022\014\n\004role\030\003 \001(\t\032\032\n\003Res\022" +
"\023\n\004user\030\001 \001(\0132\005.User\"&\n\004User\022\020\n\010username" +
"\030\001 \001(\t\022\014\n\004role\030\002 \001(\t2M\n\013KGMSConsole\022>\n\016U" +
"serManagement\022\023.UserManagement.Req\032\023.Use" +
"rManagement.Res(\0010\001B/\n\033ai.grakn.kgms.rpc" +
".generatedB\020KGMSConsoleProtob\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_UserManagement_descriptor =
getDescriptor().getMessageTypes().get(0);
internal_static_UserManagement_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_UserManagement_descriptor,
new java.lang.String[] { });
internal_static_UserManagement_Req_descriptor =
internal_static_UserManagement_descriptor.getNestedTypes().get(0);
internal_static_UserManagement_Req_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_UserManagement_Req_descriptor,
new java.lang.String[] { "LoginReq", "CreateReq", "DeleteReq", "RetrieveReq", "RetrieveAllReq", "UpdateReq", "Req", });
internal_static_UserManagement_Res_descriptor =
internal_static_UserManagement_descriptor.getNestedTypes().get(1);
internal_static_UserManagement_Res_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_UserManagement_Res_descriptor,
new java.lang.String[] { "LoginRes", "CreateRes", "DeleteRes", "RetrieveRes", "RetrieveAllRes", "UpdateRes", "Res", });
internal_static_Login_descriptor =
getDescriptor().getMessageTypes().get(1);
internal_static_Login_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Login_descriptor,
new java.lang.String[] { });
internal_static_Login_Req_descriptor =
internal_static_Login_descriptor.getNestedTypes().get(0);
internal_static_Login_Req_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Login_Req_descriptor,
new java.lang.String[] { "Username", "Password", });
internal_static_Login_Res_descriptor =
internal_static_Login_descriptor.getNestedTypes().get(1);
internal_static_Login_Res_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Login_Res_descriptor,
new java.lang.String[] { });
internal_static_Create_descriptor =
getDescriptor().getMessageTypes().get(2);
internal_static_Create_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Create_descriptor,
new java.lang.String[] { });
internal_static_Create_Req_descriptor =
internal_static_Create_descriptor.getNestedTypes().get(0);
internal_static_Create_Req_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Create_Req_descriptor,
new java.lang.String[] { "Username", "Password", "Role", });
internal_static_Create_Res_descriptor =
internal_static_Create_descriptor.getNestedTypes().get(1);
internal_static_Create_Res_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Create_Res_descriptor,
new java.lang.String[] { "User", });
internal_static_Delete_descriptor =
getDescriptor().getMessageTypes().get(3);
internal_static_Delete_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Delete_descriptor,
new java.lang.String[] { });
internal_static_Delete_Req_descriptor =
internal_static_Delete_descriptor.getNestedTypes().get(0);
internal_static_Delete_Req_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Delete_Req_descriptor,
new java.lang.String[] { "Username", });
internal_static_Delete_Res_descriptor =
internal_static_Delete_descriptor.getNestedTypes().get(1);
internal_static_Delete_Res_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Delete_Res_descriptor,
new java.lang.String[] { "Username", });
internal_static_Retrieve_descriptor =
getDescriptor().getMessageTypes().get(4);
internal_static_Retrieve_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Retrieve_descriptor,
new java.lang.String[] { });
internal_static_Retrieve_Req_descriptor =
internal_static_Retrieve_descriptor.getNestedTypes().get(0);
internal_static_Retrieve_Req_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Retrieve_Req_descriptor,
new java.lang.String[] { "Username", });
internal_static_Retrieve_Res_descriptor =
internal_static_Retrieve_descriptor.getNestedTypes().get(1);
internal_static_Retrieve_Res_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Retrieve_Res_descriptor,
new java.lang.String[] { "User", });
internal_static_RetrieveAll_descriptor =
getDescriptor().getMessageTypes().get(5);
internal_static_RetrieveAll_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_RetrieveAll_descriptor,
new java.lang.String[] { });
internal_static_RetrieveAll_Req_descriptor =
internal_static_RetrieveAll_descriptor.getNestedTypes().get(0);
internal_static_RetrieveAll_Req_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_RetrieveAll_Req_descriptor,
new java.lang.String[] { });
internal_static_RetrieveAll_Res_descriptor =
internal_static_RetrieveAll_descriptor.getNestedTypes().get(1);
internal_static_RetrieveAll_Res_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_RetrieveAll_Res_descriptor,
new java.lang.String[] { "Users", });
internal_static_Update_descriptor =
getDescriptor().getMessageTypes().get(6);
internal_static_Update_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Update_descriptor,
new java.lang.String[] { });
internal_static_Update_Req_descriptor =
internal_static_Update_descriptor.getNestedTypes().get(0);
internal_static_Update_Req_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Update_Req_descriptor,
new java.lang.String[] { "Username", "Password", "Role", });
internal_static_Update_Res_descriptor =
internal_static_Update_descriptor.getNestedTypes().get(1);
internal_static_Update_Res_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_Update_Res_descriptor,
new java.lang.String[] { "User", });
internal_static_User_descriptor =
getDescriptor().getMessageTypes().get(7);
internal_static_User_fieldAccessorTable = new
com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
internal_static_User_descriptor,
new java.lang.String[] { "Username", "Role", });
}
// @@protoc_insertion_point(outer_class_scope)
}
|
0
|
java-sources/ai/grakn/migration-base/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-base/1.4.3/ai/grakn/migration/base/MigrationCLI.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.migration.base;
import ai.grakn.GraknTx;
import ai.grakn.GraknTxType;
import ai.grakn.batch.Client;
import ai.grakn.client.Grakn;
import ai.grakn.graql.QueryBuilder;
import ai.grakn.util.CommonUtil;
import com.google.common.io.Files;
import java.util.concurrent.TimeUnit;
import org.apache.commons.cli.HelpFormatter;
import org.yaml.snakeyaml.Yaml;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static ai.grakn.graql.Graql.count;
import static ai.grakn.graql.Graql.label;
import static ai.grakn.graql.Graql.var;
import static ai.grakn.util.Schema.MetaSchema.ATTRIBUTE;
import static ai.grakn.util.Schema.MetaSchema.ENTITY;
import static ai.grakn.util.Schema.MetaSchema.RELATIONSHIP;
import static ai.grakn.util.Schema.MetaSchema.RULE;
import static java.util.stream.Collectors.joining;
/**
*
* @author alexandraorth
*/
public class MigrationCLI {
private static final String COULD_NOT_CONNECT = "Could not connect to Grakn Engine. Have you run 'grakn server start'?";
public static <T extends MigrationOptions> List<Optional<T>> init(String[] args, Function<String[], T> constructor) {
// get the options from the command line
T baseOptions = constructor.apply(args);
// If there is configuration, create multiple options objects from the config
if (baseOptions.getConfiguration() != null) {
return extractOptionsFromConfiguration(baseOptions.getConfiguration(), args).stream()
.map(constructor)
.map(MigrationCLI::validate)
.collect(Collectors.toList());
} else { // Otherwise, create options from the base options
return Collections.singletonList(validate(baseOptions));
}
}
private static <T extends MigrationOptions> Optional<T> validate(T options){
// Print the help message
if (options.isHelp()) {
printHelpMessage(options);
return Optional.empty();
}
// Check that options were provided
if(options.getNumberOptions() == 0){
printHelpMessage(options);
return Optional.empty();
}
// Check that engine is running
if(!Client.serverIsRunning(options.getUri())){
System.err.println(COULD_NOT_CONNECT);
return Optional.empty();
}
return Optional.of(options);
}
public static void loadOrPrint(File templateFile, Stream<Map<String, Object>> data, MigrationOptions options){
String template = fileAsString(templateFile);
Migrator migrator = new MigratorBuilder()
.setUri(options.getUri())
.setMigrationOptions(options)
.setKeyspace(options.getKeyspace())
.build();
if(options.isNo()){
migrator.print(template, data);
} else {
printInitMessage(options);
migrator.getReporter().start(1, TimeUnit.MINUTES);
try {
migrator.load(template, data);
} catch (Throwable e) {
// This is to catch migration exceptions and return intelligible output messages
StringBuilder message = CommonUtil.simplifyExceptionMessage(e);
System.out.println("ERROR: Exception while loading data (disabling debug mode might skip and continue): " + message.toString());
} finally {
migrator.getReporter().stop();
}
printWholeCompletionMessage(options);
}
}
public static void printInitMessage(MigrationOptions options){
System.out.println("Migrating data " + (options.hasInput() ? options.getInput() : "") +
" using Grakn Engine " + options.getUri() +
" into graph " + options.getKeyspace());
}
public static void printWholeCompletionMessage(MigrationOptions options){
System.out.println("Migration complete.");
if(options.isVerbose()) {
System.out.println("Gathering information about migrated data. If in a hurry, you can ctrl+c now.");
GraknTx tx = new Grakn(options.getUri()).session(options.getKeyspace()).transaction(GraknTxType.WRITE);
QueryBuilder qb = tx.graql();
StringBuilder builder = new StringBuilder();
builder.append("Graph schema contains:\n");
builder.append("\t ").append(tx.admin().getMetaEntityType().instances().count()).append(" entity types\n");
builder.append("\t ").append(tx.admin().getMetaRelationType().instances().count()).append(" relation types\n");
builder.append("\t ").append(tx.admin().getMetaRole().subs().count()).append(" roles\n\n");
builder.append("\t ").append(tx.admin().getMetaAttributeType().instances().count()).append(" resource types\n");
builder.append("\t ").append(tx.admin().getMetaRule().subs().count()).append(" rules\n\n");
builder.append("Graph data contains:\n");
builder.append("\t ").append(qb.match(var("x").isa(label(ENTITY.getLabel()))).aggregate(count()).execute()).append(" entities\n");
builder.append("\t ").append(qb.match(var("x").isa(label(RELATIONSHIP.getLabel()))).aggregate(count()).execute()).append(" relations\n");
builder.append("\t ").append(qb.match(var("x").isa(label(ATTRIBUTE.getLabel()))).aggregate(count()).execute()).append(" resources\n");
builder.append("\t ").append(qb.match(var("x").isa(label(RULE.getLabel()))).aggregate(count()).execute()).append(" rules\n\n");
System.out.println(builder);
tx.close();
}
}
private static String fileAsString(File file){
try {
return Files.readLines(file, StandardCharsets.UTF_8).stream().collect(joining("\n"));
} catch (IOException e) {
throw new IllegalArgumentException("Could not read file " + file.getPath(), e);
}
}
private static void printHelpMessage(MigrationOptions options){
HelpFormatter helpFormatter = new HelpFormatter();
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(System.out, 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 migrate", null, options.getOptions(), leftPadding, descPadding, null);
printWriter.flush();
}
private static List<String[]> extractOptionsFromConfiguration(String path, String[] args){
// check file exists
File configuration = new File(path);
if(!configuration.exists()){
throw new IllegalArgumentException("Could not find configuration file "+ path);
}
try (InputStreamReader reader = new InputStreamReader(new FileInputStream(configuration), Charset.defaultCharset())){
List<Map<String, String>> config = (List<Map<String, String>>) new Yaml().load(reader);
List<String[]> options = new ArrayList<>();
for(Map<String, String> c:config){
List<String> parameters = new ArrayList<>(Arrays.asList(args));
c.entrySet().stream()
.flatMap(m -> Stream.of("-" + m.getKey(), m.getValue()))
.forEach(parameters::add);
options.add(parameters.toArray(new String[parameters.size()]));
}
return options;
} catch (IOException e){
throw new RuntimeException("Could not parse configuration file.");
}
}
}
|
0
|
java-sources/ai/grakn/migration-base/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-base/1.4.3/ai/grakn/migration/base/MigrationOptions.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.migration.base;
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.Options;
import org.apache.commons.cli.ParseException;
import javax.annotation.Nullable;
import java.nio.file.Path;
import java.nio.file.Paths;
import static java.lang.Integer.parseInt;
/**
* Configure the default migration options and access arguments passed by the user
*
* @author alexandraorth
*/
public class MigrationOptions {
public static final String MAX_DELAY_DEFAULT_VALUE = "1000";
public static final String RETRY_DEFAULT_VALUE = "5";
public static final String LINES_DEFAULT_VALUE = "-1";
private static final SimpleURI DEFAULT_URI = new SimpleURI("localhost", 4567);
private int numberOptions;
protected final Options options = new Options();
protected CommandLine command;
public MigrationOptions() {
options.addOption("v", "verbose", false, "Print counts of migrated data.");
options.addOption("h", "help", false, "Print usage message.");
options.addOption("k", "keyspace", true, "Grakn graph. Required.");
options.addOption("u", "uri", true, "Location of Grakn Engine.");
options.addOption("m", "maxdelay", true, "Max delay before a request is batched.");
options.addOption("n", "no", false, "Write to standard out.");
options.addOption("c", "config", true, "Configuration file.");
options.addOption("r", "retry", true,
"Number of times to retry sending tasks if engine is not available");
options.addOption("d", "debug", false,
"Immediately stop and fail migration if an error occurs");
options.addOption("z", "lines", true,
"Number of lines to be processed. Used for testing when we want to stop earlier.");
}
public boolean isVerbose() {
return command.hasOption("v");
}
public boolean isHelp() {
return command.hasOption("h");
}
public boolean isNo() {
return command.hasOption("n");
}
public boolean isDebug() {
return command.hasOption("d");
}
public Keyspace getKeyspace() {
if (!command.hasOption("k")) {
throw new IllegalArgumentException("Keyspace missing (-k)");
}
return Keyspace.of(command.getOptionValue("k"));
}
@Nullable
public String getConfiguration() {
return command.hasOption("c") ? command.getOptionValue("c") : null;
}
public SimpleURI getUri() {
return command.hasOption("u") ? new SimpleURI(command.getOptionValue("u")) : DEFAULT_URI;
}
public Options getOptions() {
return options;
}
public int getNumberOptions() {
return numberOptions;
}
public String getInput() {
if (!command.hasOption("i")) {
throw new IllegalArgumentException("Data file missing (-i)");
}
return resolvePath(command.getOptionValue("i"));
}
public boolean hasInput() {
return command.hasOption("i");
}
public String getTemplate() {
if (!command.hasOption("t")) {
throw new IllegalArgumentException("Template file missing (-t)");
}
return resolvePath(command.getOptionValue("t"));
}
public int getRetry() {
return parseInt(command.getOptionValue("r", RETRY_DEFAULT_VALUE));
}
public int getMaxDelay() {
return parseInt(command.getOptionValue("m", MAX_DELAY_DEFAULT_VALUE));
}
public int getLines() {
return parseInt(command.getOptionValue("z", LINES_DEFAULT_VALUE));
}
protected void parse(String[] args) {
try {
CommandLineParser parser = new DefaultParser();
command = parser.parse(options, args);
numberOptions = command.getOptions().length;
} catch (ParseException e) {
throw new IllegalArgumentException(e);
}
}
private String resolvePath(String path) {
Path givenPath = Paths.get(path);
if (givenPath.isAbsolute()) {
return givenPath.toAbsolutePath().toString();
}
return Paths.get("").toAbsolutePath().resolve(givenPath).toString();
}
}
|
0
|
java-sources/ai/grakn/migration-base/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-base/1.4.3/ai/grakn/migration/base/Migrator.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.migration.base;
import ai.grakn.Keyspace;
import ai.grakn.batch.BatchExecutorClient;
import ai.grakn.batch.GraknClient;
import ai.grakn.exception.GraknBackendException;
import ai.grakn.graql.Graql;
import ai.grakn.graql.Query;
import ai.grakn.graql.QueryParser;
import ai.grakn.util.SimpleURI;
import com.codahale.metrics.ConsoleReporter;
import com.codahale.metrics.Meter;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.Timer;
import com.codahale.metrics.Timer.Context;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Stream;
import static com.codahale.metrics.MetricRegistry.name;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
/**
* <p>
* Abstract migrator class containing methods and functionality needed by
* all extending migrator classes.
* </p>
*
* @author alexandraorth
* @author Domenico Corapi
*/
public class Migrator {
private final static Logger LOG = LoggerFactory.getLogger(Migrator.class);
private final QueryParser queryParser = Graql.withoutGraph().infer(false).parser();
private final SimpleURI uri;
private final Keyspace keyspace;
private final int retries;
private final boolean failFast;
private final int maxDelayMs;
private final int maxLines;
private final MetricRegistry metricRegistry;
private final ConsoleReporter reporter;
private final Meter totalMeter;
private final Meter successMeter;
private final Timer parseTemplate;
/**
* @param uri Uri where one instance of Grakn Engine is running
* @param keyspace The {@link Keyspace} where the data should be persisted
*/
public Migrator(SimpleURI uri, Keyspace keyspace, int retries, boolean failFast, int maxDelayMs, int maxLines) {
this.uri = uri;
this.keyspace = keyspace;
this.retries = retries;
this.failFast = failFast;
this.maxDelayMs = maxDelayMs;
this.maxLines = maxLines;
this.metricRegistry = new MetricRegistry();
this.totalMeter = metricRegistry.meter(name(this.getClass(), "total"));
this.successMeter = metricRegistry.meter(name(this.getClass(), "success"));
this.parseTemplate = metricRegistry.timer(name(this.getClass(), "parse", "template"));
this.reporter = ConsoleReporter.forRegistry(metricRegistry)
.convertRatesTo(TimeUnit.SECONDS)
.convertDurationsTo(MILLISECONDS)
.build();
}
/**
* Print data passed in data parameter using the given template
*
* @param template Used to transform the data
* @param data Data being migrated
*/
public void print(String template, Stream<Map<String, Object>> data) {
data.flatMap(d -> template(template, d, false)).forEach(System.out::println);
}
/**
* Migrate data constrained by this migrator using a loader configured
* by the provided parameters.
*
* @param template Template used to extract the data
* @param data Data being migrated
*/
public void load(String template, Stream<Map<String, Object>> data) {
GraknClient graknClient = GraknClient.of(uri);
AtomicInteger queriesExecuted = new AtomicInteger(0);
try (BatchExecutorClient loader =
BatchExecutorClient.newBuilder()
.taskClient(graknClient)
.maxRetries(retries)
.maxDelay(maxDelayMs)
.metricRegistry(metricRegistry)
.build()) {
subscribeToReportOutcome(failFast, loader, queriesExecuted);
Stream<Query> queryStream = data.flatMap(d -> template(template, d, failFast));
if (maxLines > -1) {
queryStream = queryStream.limit(maxLines);
}
queryStream
.forEach(q -> {
LOG.trace("Adding query {}", q);
totalMeter.mark();
loader.add(q, keyspace);
});
}
System.out.println("Loaded " + queriesExecuted + " statements");
}
private void subscribeToReportOutcome(
boolean failFast, BatchExecutorClient batchExecutorClient, AtomicInteger queriesExecuted
) {
batchExecutorClient.onNext(taskResult -> {
LOG.trace("Successfully executed: {}", taskResult);
queriesExecuted.incrementAndGet();
successMeter.mark();
});
batchExecutorClient.onError(error -> {
System.err.println("Error in execution: " + error);
if (failFast) {
throw GraknBackendException
.migrationFailure(error.getMessage());
}
});
}
/**
* @param template a string representing a templated graql query
* @param data data used in the template
* @return an insert query
*/
protected Stream<Query> template(String template, Map<String, Object> data, boolean failFast) {
try (Context c = parseTemplate.time()){
return queryParser.parseTemplate(template, data);
} catch (Exception e) {
System.out.println("Query not sent to server: " + e.getMessage());
if (failFast) {
throw e;
}
}
return Stream.empty();
}
ConsoleReporter getReporter() {
return reporter;
}
}
|
0
|
java-sources/ai/grakn/migration-base/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-base/1.4.3/ai/grakn/migration/base/MigratorBuilder.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.migration.base;
import ai.grakn.Keyspace;
import ai.grakn.batch.GraknClient;
import ai.grakn.util.SimpleURI;
/**
* <p>
* Builder for the migrator.
* </p>
*
* @author Domenico Corapi
*/
public class MigratorBuilder {
private static final int DEFAULT_RETRIES = GraknClient.DEFAULT_MAX_RETRY;
private static final boolean DEFAULT_FAIL_FAST = true;
private static final int DEFAULT_MAX_DELAY_MS = 500;
private static final int DEFAULT_LINES = -1;
private SimpleURI uri;
private Keyspace keyspace;
private MigrationOptions migrationOptions = null;
private int retries = DEFAULT_RETRIES;
private boolean failFast = DEFAULT_FAIL_FAST;
private int maxDelayMs = DEFAULT_MAX_DELAY_MS;
private int lines = DEFAULT_LINES;
public MigratorBuilder setUri(SimpleURI uri) {
this.uri = uri;
return this;
}
public MigratorBuilder setKeyspace(Keyspace keyspace) {
this.keyspace = keyspace;
return this;
}
public MigratorBuilder setMigrationOptions(MigrationOptions migrationOptions) {
this.migrationOptions = migrationOptions;
return this;
}
public MigratorBuilder setRetries(int retries) {
this.retries = retries;
return this;
}
public MigratorBuilder setFailFast(boolean failFast) {
this.failFast = failFast;
return this;
}
public MigratorBuilder setLines(int lines) {
this.lines = lines;
return this;
}
public Migrator build() {
if (migrationOptions != null) {
retries = migrationOptions.getRetry();
maxDelayMs = migrationOptions.getMaxDelay();
failFast = migrationOptions.isDebug();
lines = migrationOptions.getLines();
}
return new Migrator(uri, keyspace, retries, failFast, maxDelayMs, lines);
}
}
|
0
|
java-sources/ai/grakn/migration-base/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-base/1.4.3/ai/grakn/migration/base/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/>.
*/
/**
* Base migration package, which implements command line options and base interfaces for importing data into Grakn.
*/
package ai.grakn.migration.base;
|
0
|
java-sources/ai/grakn/migration-csv/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-csv/1.4.3/ai/grakn/migration/csv/CSVMigrationOptions.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.migration.csv;
import ai.grakn.migration.base.MigrationOptions;
/**
* Configure the default CSV migration options and access arguments passed by the user
* @author alexandraorth
*/
public class CSVMigrationOptions extends MigrationOptions {
private final String separator = Character.toString(CSVMigrator.SEPARATOR);
private final String quote = Character.toString(CSVMigrator.QUOTE);
private final String nullString = CSVMigrator.NULL_STRING;
public CSVMigrationOptions(String[] args) {
super();
options.addOption("i", "input", true, "Input csv file.");
options.addOption("t", "template", true, "Graql template to apply to the data.");
options.addOption("s", "separator", true, "Separator of columns in input file.");
options.addOption("q", "quote", true, "Character used to encapsulate values containing special characters.");
options.addOption("l", "null", true, "String that will be evaluated as null.");
parse(args);
}
public char getSeparator() {
String sep = command.getOptionValue("s", separator);
if (sep.toCharArray().length != 1) {
throw new IllegalArgumentException("Wrong number of characters in quote " + sep);
}
return sep.charAt(0);
}
public char getQuote() {
String quo = command.getOptionValue("q", quote);
if (quo.toCharArray().length != 1) {
throw new IllegalArgumentException("Wrong number of characters in quote " + quo);
}
return quo.charAt(0);
}
public String getNullString() {
return command.getOptionValue("l", nullString);
}
}
|
0
|
java-sources/ai/grakn/migration-csv/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-csv/1.4.3/ai/grakn/migration/csv/CSVMigrator.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.migration.csv;
import ai.grakn.migration.base.MigrationCLI;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Map;
import java.util.Optional;
import java.util.Spliterator;
import java.util.Spliterators;
import static java.util.stream.Collectors.toMap;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVParser;
import org.apache.commons.csv.CSVRecord;
/**
* The CSV migrator will migrate all of the data in a CSV file into Grakn Graql var patters, to be
* imported into a graph as the user sees fit.
* @author alexandraorth
*/
public class CSVMigrator implements AutoCloseable {
static final char SEPARATOR = ',';
static final char QUOTE = '\"';
static final String NULL_STRING = null;
private char separator = SEPARATOR;
private char quote = QUOTE;
private String nullString = NULL_STRING;
private final Reader reader;
public static void main(String[] args) {
try{
MigrationCLI.init(args, CSVMigrationOptions::new).stream()
.filter(Optional::isPresent)
.map(Optional::get)
.forEach(CSVMigrator::runCSV);
} catch (IllegalArgumentException e){
System.err.println(e.getMessage());
}
}
private static void runCSV(CSVMigrationOptions options){
File csvDataFile = new File(options.getInput());
File csvTemplate = new File(options.getTemplate());
if (!csvTemplate.exists()) {
throw new IllegalArgumentException("Cannot find file: " + options.getTemplate());
}
if (!csvDataFile.exists()) {
throw new IllegalArgumentException("Cannot find file: " + options.getInput());
}
try (
CSVMigrator csvMigrator =
new CSVMigrator(csvDataFile)
.setSeparator(options.getSeparator())
.setQuoteChar(options.getQuote())
.setNullString(options.getNullString())
) {
MigrationCLI.loadOrPrint(csvTemplate, csvMigrator.convert(), options);
}
}
/**
* Construct a CSVMigrator to migrate data in the given file
* @param file file with the data to be migrated
*/
public CSVMigrator(File file) {
try {
this.reader = new InputStreamReader(new FileInputStream(file), Charset.defaultCharset());
} catch (IOException e){
throw new RuntimeException(e);
}
}
/**
* Construct a CSVMigrator to migrate data in the given Reader
* @param reader reader over the data to be migrated
*/
public CSVMigrator(Reader reader){
this.reader = reader;
}
/**
* Set separator the input file will be split on
* @param separator character separating columns in input
*/
public CSVMigrator setSeparator(char separator){
this.separator = separator;
return this;
}
/**
* Set character used to encapsulate values containing special characters.
* @param quote the quote character
*/
public CSVMigrator setQuoteChar(char quote){
this.quote = quote;
return this;
}
/**
* Set string that will be evaluated as null
* @param nullString string that will be evaluated as null, if null, everything will be
* evaluated as a string
*/
public CSVMigrator setNullString(String nullString){
this.nullString = nullString;
return this;
}
/**
* Each String in the stream is a CSV file
* @return stream of parsed insert queries
*/
public Stream<Map<String, Object>> convert() {
try{
CSVParser csvParser = CSVFormat.newFormat(separator)
.withIgnoreEmptyLines()
.withEscape('\\' )
.withFirstRecordAsHeader()
.withQuote(quote)
.withNullString(nullString)
.parse(reader);
return stream(csvParser.iterator()).map(this::parse);
} catch (IOException e){
throw new RuntimeException(e);
}
}
/**
* Close the reader
*/
@Override
public void close() {
try {
reader.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/**
* Convert data in arrays (from CSV reader) to Map<String, Object>, the current input format for
* graql templating.
* @param data all bu first row of input file
* @return given data in a map
*/
private Map<String, Object> parse(CSVRecord data){
if(!data.isConsistent()){
throw new RuntimeException("Invalid CSV " + data.toMap());
}
return data.toMap().entrySet().stream()
.filter((e) -> validValue(e.getValue()))
.collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
}
/**
* Partition a stream into a stream of collections, each with batchSize elements.
* @param iterator Iterator to partition
* @param <T> Type of values of iterator
* @return Stream over a collection that are each of batchSize
*/
protected <T> Stream<T> stream(Iterator<T> iterator){
return StreamSupport.stream(
Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED), false);
}
/**
* Test if an object is a valid Grakn value
* @param value object to check
* @return if the value is valid
*/
private boolean validValue(Object value){
return value != null;
}}
|
0
|
java-sources/ai/grakn/migration-csv/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-csv/1.4.3/ai/grakn/migration/csv/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/>.
*/
/**
* Implements migration of CSV data into Grakn.
*/
package ai.grakn.migration.csv;
|
0
|
java-sources/ai/grakn/migration-export/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-export/1.4.3/ai/grakn/migration/export/InstanceMapper.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.migration.export;
import ai.grakn.concept.Attribute;
import ai.grakn.concept.AttributeType;
import ai.grakn.concept.Entity;
import ai.grakn.concept.Relationship;
import ai.grakn.concept.Role;
import ai.grakn.concept.Thing;
import ai.grakn.graql.Graql;
import ai.grakn.graql.VarPattern;
import ai.grakn.util.CommonUtil;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import static ai.grakn.graql.Graql.var;
import static ai.grakn.util.Schema.ImplicitType.HAS_VALUE;
/**
* Map Grakn Core instance to Graql representation
* @author alexandraorth
*/
public class InstanceMapper {
/**
* Map an Thing to the equivalent Graql representation
* @param thing thing to be mapped
* @return Graql representation of given thing
*/
public static VarPattern map(Thing thing){
if(thing.isEntity()){
return map(thing.asEntity());
} else if(thing.isAttribute()){
return map(thing.asAttribute());
} else if(thing.isRelationship()){
return map(thing.asRelationship());
} else {
throw CommonUtil.unreachableStatement("Unrecognised thing " + thing);
}
}
/**
* Map a {@link Entity} to a {@link VarPattern}
* This includes mapping the instance itself, its id and any has relations
* @param entity entity to be mapped
* @return var patterns representing given instance
*/
private static VarPattern map(Entity entity){
return base(entity);
}
/**
* Map a {@link Relationship} to a var, along with all of the roleplayers
* Exclude any relations that are mapped to an encountered resource
* @param relationship {@link Relationship} to be mapped
* @return var patterns representing the given instance
*/
//TODO resources on relations
private static VarPattern map(Relationship relationship){
if(relationship.type().isImplicit()){
return var();
}
VarPattern var = base(relationship);
var = roleplayers(var, relationship);
return var;
}
/**
* Map a {@link Attribute} to a var IF it is not attached in a has relation to another instance
* @param attribute {@link Attribute} to be mapped
* @return var patterns representing the given instance
*/
private static VarPattern map(Attribute attribute){
if(isHasResourceResource(attribute)){
return var();
}
VarPattern var = base(attribute);
var = var.val(attribute.value());
return var;
}
/**
* Add the resources of an entity
* @param var var representing the entity
* @param thing thing containing resource information
* @return var pattern with resources
*/
private static VarPattern hasResources(VarPattern var, Thing thing){
for(Attribute attribute : thing.attributes().collect(Collectors.toSet())){
var = var.has(attribute.type().label(), var().val(attribute.value()));
}
return var;
}
/**
* Add the roleplayers of a {@link Relationship} to the relationship var
* @param var var representing the relationship
* @param relationship {@link Relationship} that contains roleplayer data
* @return var pattern with roleplayers
*/
private static VarPattern roleplayers(VarPattern var, Relationship relationship){
for(Map.Entry<Role, Set<Thing>> entry: relationship.rolePlayersMap().entrySet()){
Role role = entry.getKey();
for (Thing thing : entry.getValue()) {
var = var.rel(Graql.label(role.label()), thing.id().getValue());
}
}
return var;
}
/**
* Given an thing, return a var with the type.
* @param thing thing to map
* @return var patterns representing given thing
*/
private static VarPattern base(Thing thing){
VarPattern var = var(thing.id().getValue()).isa(Graql.label(thing.type().label()));
return hasResources(var, thing);
}
/**
* Check if the given {@link Attribute} conforms to the has syntax and structural requirements
* @param attribute {@link Attribute} to check
* @return true if the {@link Attribute} is target of has relation
*/
private static boolean isHasResourceResource(Attribute attribute){
AttributeType attributeType = attribute.type();
// TODO: Make sure this is tested
boolean plays = attributeType.playing().map(Role::label)
.allMatch(c -> c.equals(HAS_VALUE.getLabel(attributeType.label())));
return attribute.owners().findAny().isPresent() && plays;
}
}
|
0
|
java-sources/ai/grakn/migration-export/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-export/1.4.3/ai/grakn/migration/export/KBWriter.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.migration.export;
import ai.grakn.GraknTx;
import ai.grakn.concept.Concept;
import ai.grakn.concept.Role;
import ai.grakn.concept.Rule;
import ai.grakn.concept.SchemaConcept;
import ai.grakn.concept.Type;
import ai.grakn.graql.VarPattern;
import ai.grakn.util.Schema;
import java.util.function.Function;
import java.util.stream.Stream;
import static java.util.stream.Collectors.joining;
/**
* Export contents of a Grakn Knowledge Base as a Graql insert query.
* @author alexandraorth
*/
public class KBWriter {
private static final String EOL = ";\n";
private final GraknTx tx;
public KBWriter(GraknTx tx){
this.tx = tx;
}
/**
* Export the schema of a Grakn graph as Graql string
* @return Graql insert query with schema of given graph
*/
public String dumpSchema(){
return join(schemaConcepts().map(SchemaConceptMapper::map));
}
/**
* Export the data of a Grakn graph as a Graql string
* @return Graql insert query with data in given graph
*/
public String dumpData(){
return join(schemaConcepts()
.filter(Concept::isType)
.map(Concept::asType)
.flatMap(Type::instances)
.map(InstanceMapper::map));
}
/**
* Turn a stream of Graql patterns into a Graql insert query.
* @param stream stream of Graql patterns
* @return Graql patterns as a string
*/
private String join(Stream<VarPattern> stream){
return stream
.filter(varPattern -> varPattern.admin().getProperties().findAny().isPresent())
.map(Object::toString)
.collect(joining(EOL, "", EOL));
}
/**
* Get all the {@link SchemaConcept}s in a graph.
* @return a stream of all {@link SchemaConcept}s with non-reserved IDs
*/
private Stream<? extends SchemaConcept> schemaConcepts(){
Stream<? extends Type> types = tx.admin().getMetaConcept().subs();
Stream<Role> roles = tx.admin().getMetaRole().subs();
Stream<Rule> rules = tx.admin().getMetaRule().subs();
return Stream.of(types, roles, rules)
.flatMap(Function.identity())
.filter(t -> !Schema.MetaSchema.isMetaLabel(t.label()));
}
}
|
0
|
java-sources/ai/grakn/migration-export/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-export/1.4.3/ai/grakn/migration/export/KBWriterOptions.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.migration.export;
import ai.grakn.migration.base.MigrationOptions;
/**
* Configure the default export options and access arguments passed by the user
* @author alexandraorth
*/
public class KBWriterOptions extends MigrationOptions {
public KBWriterOptions(String[] args) {
super();
options.addOption("schema", false, "export schema");
options.addOption("data", false, "export data");
parse(args);
}
public boolean exportSchema(){
return command.hasOption("schema");
}
public boolean exportData(){
return command.hasOption("data");
}
}
|
0
|
java-sources/ai/grakn/migration-export/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-export/1.4.3/ai/grakn/migration/export/Main.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.migration.export;
import ai.grakn.GraknTx;
import ai.grakn.GraknTxType;
import ai.grakn.client.Grakn;
import ai.grakn.migration.base.MigrationCLI;
import java.util.Optional;
/**
* Export data from a Grakn graph to Graql statements - prints to System.out
* @author alexandraorth
*/
public class Main {
public static void main(String[] args){
try{
MigrationCLI.init(args, KBWriterOptions::new).stream()
.filter(Optional::isPresent)
.map(Optional::get)
.forEach(Main::runExport);
} catch (IllegalArgumentException e){
System.err.println(e.getMessage());
}
}
private static void runExport(KBWriterOptions options) {
if(!options.exportSchema() && !options.exportData()) {
throw new IllegalArgumentException("Missing arguments -schema and/or -data");
}
try(GraknTx tx = new Grakn(options.getUri()).session(options.getKeyspace()).transaction(GraknTxType.READ)) {
KBWriter graphWriter = new KBWriter(tx);
if (options.exportSchema()) {
System.out.println(graphWriter.dumpSchema());
}
if (options.exportData()) {
System.out.println(graphWriter.dumpData());
}
}
}
}
|
0
|
java-sources/ai/grakn/migration-export/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-export/1.4.3/ai/grakn/migration/export/SchemaConceptMapper.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.migration.export;
import ai.grakn.concept.AttributeType;
import ai.grakn.concept.RelationshipType;
import ai.grakn.concept.Role;
import ai.grakn.concept.SchemaConcept;
import ai.grakn.concept.Type;
import ai.grakn.graql.Graql;
import ai.grakn.graql.VarPattern;
import java.util.stream.Collectors;
import static ai.grakn.graql.Graql.var;
/**
* Map Grakn Core type to equivalent Graql representation
* @author alexandraorth
*/
public class SchemaConceptMapper {
/**
* Map a Type to the Graql string representation
* @param schemaConcept type to be mapped
* @return Graql var equivalent to the given type
*/
public static VarPattern map(SchemaConcept schemaConcept) {
VarPattern mapped = formatBase(schemaConcept);
if (schemaConcept.isRelationshipType()) {
mapped = map(mapped, schemaConcept.asRelationshipType());
} else if (schemaConcept.isAttributeType()) {
mapped = map(mapped, schemaConcept.asAttributeType());
}
return mapped;
}
/**
* Map a {@link RelationshipType} to a {@link VarPattern} with all of the relates edges
* @param var holder var with basic information
* @param relationshipType type to be mapped
* @return var with {@link RelationshipType} specific metadata
*/
private static VarPattern map(VarPattern var, RelationshipType relationshipType) {
return relates(var, relationshipType);
}
/**
* Map a {@link AttributeType} to a {@link VarPattern} with the datatype
* @param var holder var with basic information
* @param attributeType type to be mapped
* @return var with {@link AttributeType} specific metadata
*/
private static VarPattern map(VarPattern var, AttributeType attributeType) {
return datatype(var, attributeType);
}
/**
* Create a var with the information underlying all Types
* @param schemaConcept type to be mapped
* @return {@link VarPattern} containing basic information about the given type
*/
private static VarPattern formatBase(SchemaConcept schemaConcept) {
VarPattern var = var().label(schemaConcept.label());
SchemaConcept superType = schemaConcept.sup();
if (schemaConcept.sup() != null) {
var = var.sub(Graql.label(superType.label()));
}
if(schemaConcept.isType()) {
Type type = schemaConcept.asType();
var = plays(var, type);
var = isAbstract(var, type);
}
return var;
}
/**
* Add is-abstract annotation to a var
* @param var var to be marked
* @param type type from which metadata extracted
*/
private static VarPattern isAbstract(VarPattern var, Type type) {
return type.isAbstract() ? var.isAbstract() : var;
}
/**
* Add plays edges to a var, given a type
* @param var var to be modified
* @param type type from which metadata extracted
* @return var with appropriate plays edges
*/
private static VarPattern plays(VarPattern var, Type type) {
for(Role role:type.playing().collect(Collectors.toSet())){
var = var.plays(Graql.label(role.label()));
}
return var;
}
/**
* Add relates edges to a var, given a type
* @param var var to be modified
* @param type type from which metadata extracted
* @return var with appropriate relates edges
*/
private static VarPattern relates(VarPattern var, RelationshipType type){
for(Role role:type.roles().collect(Collectors.toSet())){
var = var.relates(Graql.label(role.label()));
}
return var;
}
/**
* Add a datatype to a resource type var
* @param var var to be modified
* @param type type from which metadata extracted
* @return var with appropriate datatype
*/
private static VarPattern datatype(VarPattern var, AttributeType type) {
AttributeType.DataType dataType = type.dataType();
if (dataType != null) {
return var.datatype(dataType);
} else {
return var;
}
}
}
|
0
|
java-sources/ai/grakn/migration-export/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-export/1.4.3/ai/grakn/migration/export/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/>.
*/
/**
* Implements export of data and schema from a Grakn graph into Graql statements.
*/
package ai.grakn.migration.export;
|
0
|
java-sources/ai/grakn/migration-json/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-json/1.4.3/ai/grakn/migration/json/JsonMigrationOptions.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.migration.json;
import ai.grakn.migration.base.MigrationOptions;
/**
* Configure the default JSON migration options and access arguments passed by the user
* @author alexandraorth
*/
public class JsonMigrationOptions extends MigrationOptions {
public JsonMigrationOptions(String[] args){
super();
options.addOption("i", "input", true, "Input json data file or directory.");
options.addOption("t", "template", true, "Graql template to apply to the data.");
parse(args);
}
}
|
0
|
java-sources/ai/grakn/migration-json/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-json/1.4.3/ai/grakn/migration/json/JsonMigrator.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.migration.json;
import ai.grakn.migration.base.MigrationCLI;
import com.google.common.io.CharStreams;
import mjson.Json;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.Charset;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Stream;
import static java.util.stream.Collectors.toSet;
/**
* Migrator for migrating JSON data into Grakn instances
* @author alexandraorth
*/
public class JsonMigrator implements AutoCloseable {
private final Set<Reader> readers;
public static void main(String[] args) {
try{
MigrationCLI.init(args, JsonMigrationOptions::new).stream()
.filter(Optional::isPresent)
.map(Optional::get)
.forEach(JsonMigrator::runJson);
} catch (IllegalArgumentException e){
System.err.println(e.getMessage());
}
}
private static void runJson(JsonMigrationOptions options){
File jsonDataFile = new File(options.getInput());
File jsonTemplateFile = new File(options.getTemplate());
if(!jsonDataFile.exists()){
throw new IllegalArgumentException("Cannot find file: " + options.getInput());
}
if(!jsonTemplateFile.exists() || jsonTemplateFile.isDirectory()){
throw new IllegalArgumentException("Cannot find file: " + options.getTemplate());
}
try(JsonMigrator jsonMigrator = new JsonMigrator(jsonDataFile)){
MigrationCLI.loadOrPrint(jsonTemplateFile, jsonMigrator.convert(), options);
} catch(Exception e) {
System.out.println(e.getMessage());
}
}
/**
* Construct a JsonMigrator to migrate data in the given file or dir
* @param jsonFileOrDir either a Json file or a directory containing Json files
*/
public JsonMigrator(File jsonFileOrDir){
File[] files = {jsonFileOrDir};
if(jsonFileOrDir.isDirectory()){
// Filter that will only accept JSON files with the .json extension
FilenameFilter jsonFiles = (dir, name) -> name.toLowerCase().endsWith(".json");
files = jsonFileOrDir.listFiles(jsonFiles);
}
this.readers = Stream.of(files).map(this::asReader).collect(toSet());
}
/**
* Migrate each of the given json objects as an insert query
* @return stream of parsed insert queries
*/
public Stream<Map<String, Object>> convert(){
return readers.stream()
.map(this::asString)
.map(this::toJsonMap);
}
/**
* Close the readers
*/
@Override
public void close() {
readers.forEach((reader) -> {
try {
reader.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
/**
* Convert data in JSON object to a Map<String, Object>, the current templating input.
* There is a direct mapping between any JSON object and a Map.
* @param data data to convert
* @return converted json map
*/
private Map<String, Object> toJsonMap(String data){
return Json.read(data).asMap();
}
/**
* Convert a reader to a string
* @param reader reader to be converted
* @return Json object representing the file, empty if problem reading file
*/
private String asString(Reader reader){
try {
return CharStreams.toString(reader);
} catch (IOException e){
throw new RuntimeException("Problem reading input");
}
}
/**
* Convert a file into a Reader
* @param file file to be converted
* @return Json object representing the file, empty if problem reading file
*/
private InputStreamReader asReader(File file){
try {
return new InputStreamReader(new FileInputStream(file), Charset.defaultCharset());
} catch (IOException e){
throw new RuntimeException("Problem reading input");
}
}
}
|
0
|
java-sources/ai/grakn/migration-json/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-json/1.4.3/ai/grakn/migration/json/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/>.
*/
/**
* Implements migration of JSON data into Grakn.
*/
package ai.grakn.migration.json;
|
0
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration/owl/Main.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.migration.owl;
import ai.grakn.Grakn;
import ai.grakn.GraknTx;
import ai.grakn.GraknTxType;
import ai.grakn.migration.base.MigrationCLI;
import org.semanticweb.owlapi.apibinding.OWLManager;
import java.io.File;
import java.util.Optional;
import static ai.grakn.migration.base.MigrationCLI.printInitMessage;
import static ai.grakn.migration.base.MigrationCLI.printWholeCompletionMessage;
/**
* <p>
* Main program to migrate an OWL knowledge base into a Grakn knowledge graph. Expected
* arguments are an OWL file and a Grakn Engine URL. At a minimum an OWL file must be provided.
* Note that the OWLAPI is not very good at intelligently resolving imports, such as looking in the
* same folder etc. To import a large ontology made up of multiple imports scattered around in files,
* the easiest thing is to use protege to "merge" them into a single ontology file with all axioms
* inside it.
* </p>
*
* @author alexandraorth
*
*/
public class Main {
public static void main(String[] args) {
try{
MigrationCLI.init(args, OwlMigrationOptions::new).stream()
.filter(Optional::isPresent)
.map(Optional::get)
.forEach(Main::runOwl);
} catch (IllegalArgumentException e){
System.err.println(e.getMessage());
}
}
private static void runOwl(OwlMigrationOptions options){
File owlfile = new File(options.getInput());
if (!owlfile.exists()) {
throw new IllegalArgumentException("Cannot find file: " + options.getInput());
}
printInitMessage(options);
OWLMigrator migrator = new OWLMigrator();
try(GraknTx graph = Grakn.session(options.getUri(), options.getKeyspace()).open(GraknTxType.WRITE)) {
migrator.tx(graph)
.ontology(OWLManager.createOWLOntologyManager().loadOntologyFromOntologyDocument(owlfile))
.migrate();
printWholeCompletionMessage(options);
} catch (Throwable t) {
System.err.println(t.getMessage());
}
}
}
|
0
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration/owl/Namer.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.migration.owl;
import ai.grakn.concept.Label;
import ai.grakn.concept.RelationshipType;
import ai.grakn.util.Schema;
import org.semanticweb.owlapi.model.IRI;
/**
* <p>
* A <code>Namer</code> provides functions to generate Grakn schema names (IDs for
* types, relations, roles etc.) from OWL ontology elements. All methods have default
* implementations.
* </p>
* <p>
* The implementation is not configurable: future work may provide for configuring prefixes,
* or some mapping schema from OWL to Grakn prefixes, including the standard OWL/RDF prefixes
* etc. Such mapping schema should be based on some practical experience with the migration tool.
* </p>
* @author borislav
*
*/
public interface Namer {
/**
* Create and return a name from a full IRI. By default this is just the fragment (the part after the '#'
* sign in an IRI).
*/
default String fromIri(IRI iri) {
return iri.getShortForm();
}
/**
* @see {{@link #fromIri(IRI)}
*/
default String fromIri(String iriAsString) {
return fromIri(IRI.create(iriAsString));
}
/**
* Generate the name of a Grakn entity from the IRI of an OWL individual
*/
default String individualEntityName(IRI individualIri) {
return "e" + fromIri(individualIri);
}
/**
* Generate the name of a Grakn entity type from the IRI of an OWL class
*/
default String classEntityTypeLabel(IRI classIri) {
return "t" + fromIri(classIri);
}
/**
* Generate the name of a Grakn relation type from the IRI of an OWL object property
*/
default String objectPropertyName(IRI propIri) {
return "op-" + fromIri(propIri);
}
/**
* Make a name/id for the Grakn {@link RelationshipType} representing
* a relation b/w an entity (OWL individual) and its resource (the OWL data property)
*/
default String resourceRelation(IRI dataPropertyIRI) {
return "has-" + dataPropertyIRI.getShortForm();
}
/**
* Make a name for the role type corresponding to the object (i.e. range) of an OWL object
* property.
*
* @param relationLabel The label of the Grakn {@link RelationshipType}.
*/
default Label objectRole(Label relationLabel) {
return relationLabel.map(relation -> OwlModel.OBJECT.owlname() + "-" + relation);
}
/**
* Make a name for the role type corresponding to the subject (i.e. domain) of an OWL object
* property.
*
* @param relationLabel The label of the Grakn {@link RelationshipType}.
*/
default Label subjectRole(Label relationLabel) {
return relationLabel.map(relation -> OwlModel.SUBJECT.owlname() + "-" + relation);
}
/**
* The name of the entity role type in an entity-role relation representing an OWL data property
*/
default Label entityRole(Label resourceLabel) {
return Schema.ImplicitType.HAS_OWNER.getLabel(resourceLabel);
}
/**
* Make a name for a resource relation type representing the value of an OWL data property.
*/
default Label resourceRelation(Label resourceLabel) {
return Schema.ImplicitType.HAS.getLabel(resourceLabel);
}
/**
* Make a name for a resource role player representing the value of an OWL data property.
*/
default Label resourceRole(Label resourceLabel) {
return Schema.ImplicitType.HAS_VALUE.getLabel(resourceLabel);
}
}
|
0
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration/owl/OWLMigrator.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.migration.owl;
import ai.grakn.GraknTx;
import ai.grakn.concept.AttributeType;
import ai.grakn.concept.ConceptId;
import ai.grakn.concept.Entity;
import ai.grakn.concept.EntityType;
import ai.grakn.concept.Thing;
import ai.grakn.concept.RelationshipType;
import ai.grakn.concept.Attribute;
import ai.grakn.concept.Role;
import ai.grakn.concept.Label;
import ai.grakn.exception.InvalidKBException;
import ai.grakn.util.Schema;
import org.semanticweb.owlapi.model.OWLAnnotationProperty;
import org.semanticweb.owlapi.model.OWLClass;
import org.semanticweb.owlapi.model.OWLClassAssertionAxiom;
import org.semanticweb.owlapi.model.OWLDataProperty;
import org.semanticweb.owlapi.model.OWLDataPropertyRangeAxiom;
import org.semanticweb.owlapi.model.OWLNamedIndividual;
import org.semanticweb.owlapi.model.OWLObjectProperty;
import org.semanticweb.owlapi.model.OWLOntology;
import org.semanticweb.owlapi.vocab.OWL2Datatype;
import javax.annotation.Nullable;
import java.util.Optional;
import java.util.function.Supplier;
/**
*
* <p>
* The OWL migrator is the main driver an OWL migration process: configure with the ontology to migrate, the
* target {@link GraknTx} and instance and hit go with the {@link OWLMigrator#migrate()}
* </p>
*
* @author Borislav Iordanov
*
*/
public class OWLMigrator {
private Namer namer;
private OWLOntology ontology;
private GraknTx tx;
private <T> T eval(Supplier<T> f) {
return f.get();
}
public OWLMigrator() {
this.namer = new DefaultNamer();
}
public OWLMigrator namer(Namer namer) {
this.namer = namer;
return this;
}
public Namer namer() {
return namer;
}
public OWLMigrator ontology(OWLOntology ontology) {
this.ontology = ontology;
return this;
}
public OWLOntology ontology() {
return this.ontology;
}
public OWLMigrator tx(GraknTx graph) {
this.tx = graph;
return this;
}
public GraknTx tx() {
return tx;
}
public void migrate() throws InvalidKBException {
OwlGraknTxStoringVisitor visitor = new OwlGraknTxStoringVisitor(this);
visitor.prepareOWL();
ontology.axioms().forEach(ax -> ax.accept(visitor));
tx.commit();
}
public AttributeType.DataType<?> owlBuiltInToGraknDatatype(OWL2Datatype propertyType) {
if (propertyType == OWL2Datatype.XSD_BOOLEAN) {
return AttributeType.DataType.BOOLEAN;
} else if (propertyType == OWL2Datatype.XSD_FLOAT ||
propertyType == OWL2Datatype.XSD_DOUBLE ||
propertyType == OWL2Datatype.OWL_REAL ||
propertyType == OWL2Datatype.OWL_RATIONAL ||
propertyType == OWL2Datatype.XSD_DECIMAL) {
return AttributeType.DataType.DOUBLE;
} else if (propertyType.isNumeric()) {
return AttributeType.DataType.LONG;
} else {
return AttributeType.DataType.STRING;
}
}
public EntityType owlThingEntityType() {
return tx.putEntityType(
namer.classEntityTypeLabel(
ontology.getOWLOntologyManager().getOWLDataFactory().getOWLClass(
OwlModel.THING.owlname()).getIRI()));
}
public AttributeType<String> owlIriResource(){
return tx.putAttributeType(OwlModel.IRI.owlname(), AttributeType.DataType.STRING);
}
@Nullable
public <T> Entity getEntity(T id, AttributeType<T> rtype){
Attribute<T> iri = rtype.getAttribute(id);
Thing inst = iri != null? iri.ownerInstances().findFirst().orElse(null) : null;
return inst != null? inst.asEntity() : null;
}
public Entity putEntity(String id, EntityType type) {
Entity current = getEntity(id, owlIriResource());
if(current != null) return current;
Label hasIriResourceId = Label.of(OwlModel.IRI.owlname());
AttributeType<String> iriResource = owlIriResource();
Role hasIriOwner = entityRole(type, iriResource);
Role hasIriValue = resourceRole(iriResource);
RelationshipType hasIriRelation = tx.putRelationshipType(namer.resourceRelation(hasIriResourceId))
.relates(hasIriOwner).relates(hasIriValue);
Entity entity = type.addEntity();
Attribute attributeInstance = iriResource.putAttribute(id);
hasIriRelation.addRelationship()
.addRolePlayer(hasIriOwner, entity)
.addRolePlayer(hasIriValue, attributeInstance);
return entity;
}
public EntityType entityType(OWLClass owlclass) {
EntityType type = tx.putEntityType(namer.classEntityTypeLabel(owlclass.getIRI()));
EntityType thing = owlThingEntityType();
if (Schema.MetaSchema.isMetaLabel(type.sup().getLabel()) && !type.equals(thing)) {
type.sup(thing);
}
return type;
}
public Entity entity(OWLNamedIndividual individual) {
String id = namer.individualEntityName(individual.getIRI());
Entity entity = tx.getConcept(ConceptId.of(id));
if (entity != null) {
return entity;
}
OWLClass owlclass = eval(() -> {
Optional<OWLClassAssertionAxiom> expr = ontology
.classAssertionAxioms(individual)
.filter(ax -> ax.getClassExpression().isOWLClass())
.findFirst();
return expr.isPresent() ? expr.get().getClassExpression().asOWLClass() : null;
});
return putEntity(id, owlclass == null ? owlThingEntityType() : entityType(owlclass));
}
public RelationshipType relation(OWLObjectProperty property) {
RelationshipType relType = tx.putRelationshipType(namer.objectPropertyName(property.getIRI()));
Role subjectRole = subjectRole(relType);
Role objectRole = objectRole(relType);
relType.relates(subjectRole);
relType.relates(objectRole);
EntityType top = this.owlThingEntityType();
top.plays(subjectRole);
top.plays(objectRole);
return relType;
}
public RelationshipType relation(OWLDataProperty property) {
RelationshipType relType = tx.putRelationshipType(namer.resourceRelation(property.getIRI()));
AttributeType<?> attributeType = resourceType(property);
relType.relates(entityRole(owlThingEntityType(), attributeType));
relType.relates(resourceRole(attributeType));
return relType;
}
public RelationshipType relation(OWLAnnotationProperty property) {
RelationshipType relType = tx.putRelationshipType(namer.resourceRelation(property.getIRI()));
AttributeType<?> attributeType = tx.putAttributeType(namer.fromIri(property.getIRI()), AttributeType.DataType.STRING);
relType.relates(entityRole(owlThingEntityType(), attributeType));
relType.relates(resourceRole(attributeType));
return relType;
}
public Role subjectRole(RelationshipType relType) {
return tx.putRole(namer.subjectRole(relType.getLabel()));
}
public Role objectRole(RelationshipType relType) {
return tx.putRole(namer.objectRole(relType.getLabel()));
}
public Role entityRole(EntityType entityType, AttributeType<?> attributeType) {
Role role = tx.putRole(namer.entityRole(attributeType.getLabel()));
entityType.plays(role);
return role;
}
public Role resourceRole(AttributeType<?> attributeType) {
Role role = tx.putRole(namer.resourceRole(attributeType.getLabel()));
attributeType.plays(role);
return role;
}
public AttributeType<?> resourceType(OWLDataProperty property) {
OWL2Datatype propertyType= eval(() -> {
Optional<OWLDataPropertyRangeAxiom> ax = ontology.dataPropertyRangeAxioms(property)
.filter(rangeAxiom -> rangeAxiom.getRange().isOWLDatatype() &&
rangeAxiom.getRange().asOWLDatatype().isBuiltIn())
.findFirst();
return ax.isPresent() ? ax.get().getRange().asOWLDatatype().getBuiltInDatatype() : null;
});
AttributeType.DataType<?> graknType = propertyType == null ? AttributeType.DataType.STRING : owlBuiltInToGraknDatatype(propertyType);
AttributeType<?> attributeType = tx.putAttributeType(namer.fromIri(property.getIRI()), graknType);
return attributeType;
}
private static class DefaultNamer implements Namer {
}
}
|
0
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration/owl/OwlGraknTxStoringVisitor.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.migration.owl;
import ai.grakn.concept.AttributeType;
import ai.grakn.concept.Concept;
import ai.grakn.concept.Entity;
import ai.grakn.concept.EntityType;
import ai.grakn.concept.Label;
import ai.grakn.concept.RelationshipType;
import ai.grakn.concept.Attribute;
import ai.grakn.concept.Role;
import ai.grakn.exception.GraknTxOperationException;
import ai.grakn.graql.internal.reasoner.utils.ReasonerUtils;
import ai.grakn.graql.internal.reasoner.utils.Pair;
import org.semanticweb.owlapi.model.AsOWLObjectProperty;
import org.semanticweb.owlapi.model.OWLAnnotationAssertionAxiom;
import org.semanticweb.owlapi.model.OWLAnnotationProperty;
import org.semanticweb.owlapi.model.OWLAxiomVisitorEx;
import org.semanticweb.owlapi.model.OWLClass;
import org.semanticweb.owlapi.model.OWLClassAssertionAxiom;
import org.semanticweb.owlapi.model.OWLClassExpression;
import org.semanticweb.owlapi.model.OWLDataProperty;
import org.semanticweb.owlapi.model.OWLDataPropertyAssertionAxiom;
import org.semanticweb.owlapi.model.OWLDeclarationAxiom;
import org.semanticweb.owlapi.model.OWLEntityVisitorEx;
import org.semanticweb.owlapi.model.OWLEquivalentObjectPropertiesAxiom;
import org.semanticweb.owlapi.model.OWLInverseObjectPropertiesAxiom;
import org.semanticweb.owlapi.model.OWLLiteral;
import org.semanticweb.owlapi.model.OWLNamedIndividual;
import org.semanticweb.owlapi.model.OWLObjectProperty;
import org.semanticweb.owlapi.model.OWLObjectPropertyAssertionAxiom;
import org.semanticweb.owlapi.model.OWLObjectPropertyDomainAxiom;
import org.semanticweb.owlapi.model.OWLObjectPropertyExpression;
import org.semanticweb.owlapi.model.OWLObjectPropertyRangeAxiom;
import org.semanticweb.owlapi.model.OWLReflexiveObjectPropertyAxiom;
import org.semanticweb.owlapi.model.OWLSubClassOfAxiom;
import org.semanticweb.owlapi.model.OWLSubDataPropertyOfAxiom;
import org.semanticweb.owlapi.model.OWLSubObjectPropertyOfAxiom;
import org.semanticweb.owlapi.model.OWLSubPropertyChainOfAxiom;
import org.semanticweb.owlapi.model.OWLTransitiveObjectPropertyAxiom;
import org.semanticweb.owlapi.model.SWRLRule;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
/**
* <p>
* This is the main class processing an OWL ontology file. It implements the OWLAPI visitor interfaces
* to traverse all axioms and entities in the ontology and convert them into equivalent Grakn elements.
* </p>
* <p>
* TODO - a lot of the logical more advanced axioms are skipped for now, waiting for the Grakn reasoning engine
* to mature a bit.
* </p>
*
* @author borislav
*
*/
public class OwlGraknTxStoringVisitor implements OWLAxiomVisitorEx<Concept>, OWLEntityVisitorEx<Concept> {
private final OWLMigrator migrator;
public OwlGraknTxStoringVisitor(OWLMigrator migrator) {
this.migrator = migrator;
}
public OwlGraknTxStoringVisitor prepareOWL() {
migrator.entityType(migrator.ontology().getOWLOntologyManager().getOWLDataFactory().getOWLClass(OwlModel.THING.owlname()));
migrator.relation(migrator.ontology().getOWLOntologyManager().getOWLDataFactory().getOWLObjectProperty(OwlModel.OBJECT_PROPERTY.owlname()))
.relates(migrator.tx().putRole(OwlModel.OBJECT.owlname()))
.relates(migrator.tx().putRole(OwlModel.SUBJECT.owlname()));
return this;
}
@Override
public Concept visit(OWLClass ce) {
return migrator.entityType(ce);
}
@Override
public Concept visit(OWLObjectProperty property) {
return migrator.relation(property);
}
@Override
public Concept visit(OWLDataProperty property) {
return migrator.resourceType(property);
}
@Override
public Concept visit(OWLAnnotationProperty property) {
return migrator.relation(property);
}
@Override
public Concept visit(OWLNamedIndividual individual) {
return migrator.entity(individual);
}
@Override
public Concept visit(OWLDeclarationAxiom axiom) {
return axiom.getEntity().accept(this);
}
@Override
public Concept visit(OWLSubClassOfAxiom axiom) {
OWLClassExpression subclass = axiom.getSubClass();
EntityType subtype;
if (subclass.isOWLClass()) {
subtype = migrator.entityType(subclass.asOWLClass());
} else {
// TODO - we need a strategy to support class expressions, e.g. as constraints
// on instances
return null;
}
OWLClassExpression superclass = axiom.getSuperClass();
EntityType supertype;
if (superclass.isOWLClass()) {
supertype = migrator.entityType(superclass.asOWLClass());
} else {
// TODO - we need a strategy to support class expressions, e.g. as constraints
// on instances
return null;
}
if (!supertype.equals(subtype.sup())) {
subtype.sup(supertype);
}
return null;
}
@Override
public Concept visit(OWLObjectPropertyDomainAxiom axiom) {
if (!axiom.getProperty().isOWLObjectProperty()) {
return null;
}
RelationshipType objectRelation = migrator.relation(axiom.getProperty().asOWLObjectProperty());
if (axiom.getDomain().isOWLClass()) {
EntityType entityType = migrator.entityType(axiom.getDomain().asOWLClass());
Role domain = migrator.subjectRole(objectRelation);
migrator.owlThingEntityType().deletePlays(domain);
entityType.plays(domain);
objectRelation.relates(domain);
// System.out.println("Replaced domain thing with " + entityType.getLabel());
}
return objectRelation;
}
@Override
public Concept visit(OWLObjectPropertyRangeAxiom axiom) {
if (!axiom.getProperty().isOWLObjectProperty()) {
return null;
}
RelationshipType objectRelation = migrator.relation(axiom.getProperty().asOWLObjectProperty());
if (axiom.getRange().isOWLClass()) {
EntityType entityType = migrator.entityType(axiom.getRange().asOWLClass());
Role range = migrator.objectRole(objectRelation);
objectRelation.relates(range);
migrator.owlThingEntityType().deletePlays(range);
entityType.plays(range);
}
return objectRelation;
}
@Override
public Concept visit(OWLSubObjectPropertyOfAxiom axiom) {
if (!axiom.getSubProperty().isOWLObjectProperty() || !axiom.getSuperProperty().isOWLObjectProperty()) {
return null;
}
RelationshipType subRelation = migrator.relation(axiom.getSubProperty().asOWLObjectProperty());
RelationshipType superRelation = migrator.relation(axiom.getSuperProperty().asOWLObjectProperty());
Map<Label, Label> roleMap = new HashMap<>();
roleMap.put(migrator.namer().subjectRole(superRelation.getLabel()), migrator.namer().subjectRole(subRelation.getLabel()));
roleMap.put(migrator.namer().objectRole(superRelation.getLabel()), migrator.namer().objectRole(subRelation.getLabel()));
ReasonerUtils.createSubPropertyRule("Sub Property Rule Between [" + superRelation.getLabel() + "] and [" + subRelation.getLabel() + "]", superRelation, subRelation, roleMap, migrator.tx());
migrator.subjectRole(subRelation).sup(migrator.subjectRole(superRelation));
migrator.objectRole(subRelation).sup(migrator.objectRole(superRelation));
subRelation.sup(superRelation);
return null;
}
@Override
public Concept visit(OWLSubDataPropertyOfAxiom axiom) {
if (!axiom.getSubProperty().isOWLDataProperty() || !axiom.getSuperProperty().isOWLDataProperty()) {
return null;
}
RelationshipType subRelation = migrator.relation(axiom.getSubProperty().asOWLDataProperty());
RelationshipType superRelation = migrator.relation(axiom.getSuperProperty().asOWLDataProperty());
subRelation.sup(superRelation);
return null;
}
@Override
public Concept visit(OWLEquivalentObjectPropertiesAxiom axiom) {
Set<OWLObjectPropertyExpression> properties = axiom.getAxiomWithoutAnnotations()
.properties().filter(AsOWLObjectProperty::isOWLObjectProperty).collect(Collectors.toSet());
if (properties.size() != axiom.getAxiomWithoutAnnotations().properties().count()) {
return null;
}
for (OWLObjectPropertyExpression property : properties) {
RelationshipType relation = migrator.relation(property.asOWLObjectProperty());
properties.forEach(prop -> {
RelationshipType eqRelation = migrator.relation(prop.asOWLObjectProperty());
if (!relation.equals(eqRelation)) {
Map<Label, Label> roleMap = new HashMap<>();
roleMap.put(migrator.namer().subjectRole(relation.getLabel()),
migrator.namer().subjectRole(eqRelation.getLabel()));
roleMap.put(migrator.namer().objectRole(relation.getLabel()),
migrator.namer().objectRole(eqRelation.getLabel()));
ReasonerUtils.createSubPropertyRule("Sub Property Rule Between [" + relation.getLabel() + "] and [" + eqRelation.getLabel() + "]", relation, eqRelation, roleMap, migrator.tx());
}
});
}
return null;
}
@Override
public Concept visit(OWLInverseObjectPropertiesAxiom axiom) {
if (!axiom.getFirstProperty().isOWLObjectProperty() || !axiom.getSecondProperty().isOWLObjectProperty()) {
return null;
}
RelationshipType relation = migrator.relation(axiom.getFirstProperty().asOWLObjectProperty());
RelationshipType inverseRelation = migrator.relation(axiom.getSecondProperty().asOWLObjectProperty());
Map<Label, Label> roleMapFD = new HashMap<>();
roleMapFD.put(migrator.namer().subjectRole(relation.getLabel()), migrator.namer().objectRole(inverseRelation.getLabel()));
roleMapFD.put(migrator.namer().objectRole(relation.getLabel()), migrator.namer().subjectRole(inverseRelation.getLabel()));
ReasonerUtils.createSubPropertyRule("Sub Property Rule Between [" + relation.getLabel() + "] and [" + inverseRelation.getLabel() + "]", relation, inverseRelation, roleMapFD, migrator.tx());
Map<Label, Label> roleMapBD = new HashMap<>();
roleMapBD.put(migrator.namer().subjectRole(inverseRelation.getLabel()), migrator.namer().objectRole(relation.getLabel()));
roleMapBD.put(migrator.namer().objectRole(inverseRelation.getLabel()), migrator.namer().subjectRole(relation.getLabel()));
ReasonerUtils.createSubPropertyRule("Sub Property Rule Between [" + inverseRelation.getLabel() + "] and [" + relation.getLabel() + "]", inverseRelation, relation, roleMapBD, migrator.tx());
return null;
}
@Override
public Concept visit(OWLTransitiveObjectPropertyAxiom axiom) {
if (!axiom.getProperty().isOWLObjectProperty()) {
return null;
}
RelationshipType relation = migrator.relation(axiom.getProperty().asOWLObjectProperty());
Label fromRoleLabel = migrator.namer().subjectRole(relation.getLabel());
Label toRoleLabel = migrator.namer().objectRole(relation.getLabel());
ReasonerUtils.createTransitiveRule(
"Transitive Rule Between [" + relation.getLabel() + "], [" + fromRoleLabel + "] and [" + toRoleLabel + "]",
relation,
fromRoleLabel,
toRoleLabel,
migrator.tx());
return null;
}
@Override
public Concept visit(OWLReflexiveObjectPropertyAxiom axiom) {
if (!axiom.getProperty().isOWLObjectProperty()) {
return null;
}
RelationshipType relation = migrator.relation(axiom.getProperty().asOWLObjectProperty());
Label fromRoleLabel = migrator.namer().subjectRole(relation.getLabel());
Label toRoleLabel = migrator.namer().objectRole(relation.getLabel());
ReasonerUtils.createReflexiveRule(
"Reflexive Rule Between [" + fromRoleLabel + "] and [" + toRoleLabel + "]",
relation,
fromRoleLabel,
toRoleLabel,
migrator.tx());
return null;
}
@Override
public Concept visit(OWLSubPropertyChainOfAxiom axiom) {
if (!axiom.getSuperProperty().isOWLObjectProperty()) {
return null;
}
RelationshipType superRelation = migrator.relation(axiom.getSuperProperty().asOWLObjectProperty());
LinkedHashMap<RelationshipType, Pair<Label, Label>> chain = new LinkedHashMap<>();
axiom.getPropertyChain().forEach(property -> {
RelationshipType relation = migrator.relation(property.asOWLObjectProperty());
chain.put(relation,
new Pair<>(migrator.namer().subjectRole(relation.getLabel()), migrator.namer().objectRole(relation.getLabel())));
});
Label fromRoleLabel = migrator.namer().subjectRole(superRelation.getLabel());
Label toRoleLabel = migrator.namer().objectRole(superRelation.getLabel());
ReasonerUtils.createPropertyChainRule("Chain Rule Between [" + superRelation.getLabel() + "], [" + fromRoleLabel + "], and [" + toRoleLabel + "]",
superRelation, fromRoleLabel,
toRoleLabel, chain, migrator.tx());
return null;
}
@Override
public Concept visit(OWLClassAssertionAxiom axiom) {
if (!axiom.getIndividual().isNamed()) {
return null;
} else {
return migrator.entity(axiom.getIndividual().asOWLNamedIndividual());
}
}
@Override
public Concept visit(OWLObjectPropertyAssertionAxiom axiom) {
if (!axiom.getSubject().isNamed() ||
!axiom.getObject().isNamed() ||
!axiom.getProperty().isOWLObjectProperty()) {
return null;
}
Entity subject = migrator.entity(axiom.getSubject().asOWLNamedIndividual());
Entity object = migrator.entity(axiom.getObject().asOWLNamedIndividual());
RelationshipType relationshipType = migrator.relation(axiom.getProperty().asOWLObjectProperty());
return relationshipType.addRelationship()
.addRolePlayer(migrator.subjectRole(relationshipType), subject)
.addRolePlayer(migrator.objectRole(relationshipType), object);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public Concept visit(OWLDataPropertyAssertionAxiom axiom) {
if (!axiom.getProperty().isOWLDataProperty() || !axiom.getSubject().isNamed()) {
return null;
}
AttributeType attributeType = migrator.resourceType(axiom.getProperty().asOWLDataProperty());
Entity entity = migrator.entity(axiom.getSubject().asOWLNamedIndividual());
String valueAsString = axiom.getObject().getLiteral();
Object value = valueAsString;
if (attributeType.getDataType() == AttributeType.DataType.BOOLEAN) {
value = Boolean.parseBoolean(valueAsString);
} else if (attributeType.getDataType() == AttributeType.DataType.LONG) {
value = Long.parseLong(valueAsString);
} else if (attributeType.getDataType() == AttributeType.DataType.DOUBLE) {
value = Double.parseDouble(valueAsString);
}
Attribute attribute = attributeType.putAttribute(value);
RelationshipType propertyRelation = migrator.relation(axiom.getProperty().asOWLDataProperty());
Role entityRole = migrator.entityRole(entity.type(), attribute.type());
Role resourceRole = migrator.resourceRole(attribute.type());
try {
return propertyRelation.addRelationship()
.addRolePlayer(entityRole, entity)
.addRolePlayer(resourceRole, attribute);
}
catch (GraknTxOperationException ex) {
if (ex.getMessage().contains("The Relationship with the provided role players already exists")) {
System.err.println("[WARN] Grakn does not support multiple values per data property/attribute, ignoring axiom " + axiom);
} else {
ex.printStackTrace(System.err);
}
return null;
}
}
@Override
public Concept visit(OWLAnnotationAssertionAxiom axiom) {
if (! (axiom.getSubject() instanceof OWLNamedIndividual) ) {
return null;
}
Optional<OWLLiteral> value = axiom.getValue().asLiteral();
if (!value.isPresent()) {
return null;
}
@SuppressWarnings("unchecked")
AttributeType<String> attributeType = (AttributeType<String>)visit(axiom.getProperty());
Entity entity = migrator.entity((OWLNamedIndividual)axiom.getSubject());
Attribute<String> attribute = attributeType.putAttribute(value.get().getLiteral());
RelationshipType propertyRelation = migrator.relation(axiom.getProperty());
return propertyRelation.addRelationship()
.addRolePlayer(migrator.entityRole(entity.type(), attribute.type()), entity)
.addRolePlayer(migrator.resourceRole(attribute.type()), attribute);
}
@Override
public Concept visit(SWRLRule node) {
//TODO
return null;
}
}
|
0
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration/owl/OwlMigrationOptions.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.migration.owl;
import ai.grakn.migration.base.MigrationOptions;
/**
* Configure the default OWL migration options and access arguments passed by the user
* @author alexandraorth
*/
public class OwlMigrationOptions extends MigrationOptions {
public OwlMigrationOptions(String[] args){
super();
options.addOption("i", "input", true, "input csv file");
parse(args);
}
}
|
0
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration/owl/OwlModel.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.migration.owl;
/**
* Enumerate default/predefined elements that need to be created
* in Grakn regardless of the ontology being migrated.
*
* @author borislav
*
*/
public enum OwlModel {
THING("owl:Thing"),
OBJECT_PROPERTY("owl:topObjectProperty"),
SUBJECT_PROPERTY("owl:topDataProperty"),
SUBJECT("owl-subject"),
OBJECT("owl-object"),
IRI("owl-iri")
;
private final String name;
OwlModel(String name) {
this.name = name;
}
public String owlname() {
return name;
}
}
|
0
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration
|
java-sources/ai/grakn/migration-owl/0.18.0/ai/grakn/migration/owl/package-info.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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>.
*/
/**
* Implements migration of OWL into Grakn.
*/
package ai.grakn.migration.owl;
|
0
|
java-sources/ai/grakn/migration-sql/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-sql/1.4.3/ai/grakn/migration/sql/SQLMigrationOptions.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.migration.sql;
import ai.grakn.migration.base.MigrationOptions;
import java.sql.Driver;
/**
* Configure the default SQL migration options and access arguments passed by the user
* @author alexandraorth
*/
public class SQLMigrationOptions extends MigrationOptions {
public SQLMigrationOptions(String[] args){
super();
options.addOption("driver", true, "JDBC driver");
options.addOption("location", true, "JDBC url (location of DB)");
options.addOption("user", true, "JDBC username");
options.addOption("pass", true, "JDBC password");
options.addOption("q", "query", true, "SQL Query");
options.addOption("t", "template", true, "Graql template to apply to the data.");
parse(args);
}
public Driver getDriver() {
if(command.hasOption("driver")){
try {
return (Driver) Class.forName(command.getOptionValue("driver")).newInstance();
} catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
throw new IllegalArgumentException(e.getMessage());
}
}
throw new IllegalArgumentException("No driver specified (-driver)");
}
public boolean hasDriver(){
return command.hasOption("driver");
}
public String getLocation() {
if(command.hasOption("location")){
return command.getOptionValue("location");
}
throw new IllegalArgumentException("No db specified (-location)");
}
public String getUsername() {
if(command.hasOption("user")){
return command.getOptionValue("user");
}
throw new IllegalArgumentException("No username specified (-user)");
}
public String getPassword() {
if(command.hasOption("pass")){
return command.getOptionValue("pass");
}
throw new IllegalArgumentException("No password specified (-pass)");
}
public String getQuery() {
if(command.hasOption("query")){
return command.getOptionValue("query");
}
throw new IllegalArgumentException("No SQL query specified (-query)");
}
}
|
0
|
java-sources/ai/grakn/migration-sql/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-sql/1.4.3/ai/grakn/migration/sql/SQLMigrator.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.migration.sql;
import ai.grakn.migration.base.MigrationCLI;
import com.google.common.collect.Maps;
import org.jooq.DSLContext;
import org.jooq.Record;
import org.jooq.impl.DSL;
import java.io.File;
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Stream;
/**
* The SQL migrator will execute the given SQL query and then apply the given template to those results.
* @author alexandraorth
*/
public class SQLMigrator {
private final Stream<Record> records;
public static void main(String[] args) {
try {
MigrationCLI.init(args, SQLMigrationOptions::new).stream()
.filter(Optional::isPresent)
.map(Optional::get)
.forEach(SQLMigrator::runSQL);
} catch (IllegalArgumentException e){
System.err.println(e.getMessage());
}
}
private static void runSQL(SQLMigrationOptions options) {
try {
File sqlTemplate = new File(options.getTemplate());
if(!sqlTemplate.exists()){
System.err.println("Cannot find file: " + options.getTemplate());
return;
}
if(options.hasDriver()) {
DriverManager.registerDriver(options.getDriver());
}
try(Connection connection = DriverManager.getConnection(options.getLocation(),
options.getUsername(), options.getPassword())) {
SQLMigrator sqlMigrator = new SQLMigrator(options.getQuery(), connection);
MigrationCLI.loadOrPrint(sqlTemplate, sqlMigrator.convert(), options);
}
} catch (Throwable throwable){
System.err.println(throwable.getMessage());
}
}
/**
* Construct a SQL migrator to migrate data from the given DB
* @param query SQL query to gather data from database
* @param connection JDBC connection to the SQL database
*/
public SQLMigrator(String query, Connection connection){
DSLContext create = DSL.using(connection);
records = create.fetchStream(query);
}
/**
* Migrate the results of the SQL statement with the provided template
* @return stream of parsed insert queries
*/
public Stream<Map<String, Object>> convert() {
return records.map(Record::intoMap).map(this::convertToValidValues);
}
/**
* Convert values to be valid - removing nulls and changing to supported types
* @param data data to make valid
* @return valid data
*/
private Map<String, Object> convertToValidValues(Map<String, Object> data){
data = Maps.filterValues(data, Objects::nonNull);
data = Maps.transformValues(data, this::convertToSupportedTypes);
return data;
}
/**
* If a SQL value is not one of the supported types, convert it to a string
* @param object object to convert
* @return object as one of the supported types
*/
private Object convertToSupportedTypes(Object object) {
if(!(object instanceof String ||
object instanceof Number ||
object instanceof List ||
object instanceof Boolean)){
return object.toString();
}
return object;
}
}
|
0
|
java-sources/ai/grakn/migration-sql/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-sql/1.4.3/ai/grakn/migration/sql/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/>.
*/
/**
* Implements migration of SQL data into Grakn.
*/
package ai.grakn.migration.sql;
|
0
|
java-sources/ai/grakn/migration-xml/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-xml/1.4.3/ai/grakn/migration/xml/XmlMigrationOptions.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.migration.xml;
import ai.grakn.migration.base.MigrationOptions;
/**
* Configure the default XML migration options and access arguments passed by the user
* @author alexandraorth
*/
public class XmlMigrationOptions extends MigrationOptions {
public XmlMigrationOptions(String[] args) {
super();
options.addOption("i", "input", true, "Input XML data file or directory.");
options.addOption("s", "schema", true, "The XML Schema file name, usually .xsd extension defining with type information about the data.");
options.addOption("e", "element", true, "The name of the XML element to migrate - all others will be ignored.");
options.addOption("t", "template", true, "Graql template to apply to the data.");
parse(args);
}
public String getElement() {
return command.getOptionValue("e", null);
}
public String getSchemaFile() {
return command.getOptionValue("s", null);
}
}
|
0
|
java-sources/ai/grakn/migration-xml/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-xml/1.4.3/ai/grakn/migration/xml/XmlMigrator.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.migration.xml;
import ai.grakn.migration.base.MigrationCLI;
import ai.grakn.migration.xml.XmlSchema.TypeInfo;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import static java.util.stream.Collectors.toSet;
/**
* Migrator for migrating XML data into Grakn instances
* @author boris
*/
public class XmlMigrator implements AutoCloseable {
public static void main(String[] args) {
try {
MigrationCLI.init(args, XmlMigrationOptions::new).stream()
.filter(Optional::isPresent)
.map(Optional::get)
.forEach(XmlMigrator::runXml);
} catch (IllegalArgumentException e){
System.err.println(e.getMessage());
}
}
public static void runXml(XmlMigrationOptions options){
File xmlDataFile = new File(options.getInput());
File xmlTemplateFile = new File(options.getTemplate());
if(!xmlDataFile.exists()){
throw new IllegalArgumentException("Cannot find file: " + options.getInput());
}
if(!xmlTemplateFile.exists() || xmlTemplateFile.isDirectory()){
throw new IllegalArgumentException("Cannot find file: " + options.getTemplate());
}
try(XmlMigrator xmlMigrator = new XmlMigrator(xmlDataFile)){
if (options.getElement() != null) {
xmlMigrator.element(options.getElement());
} else {
throw new IllegalArgumentException("Please specify XML element for the top-level data item.");
}
if (options.getSchemaFile() != null) {
xmlMigrator.schema(new XmlSchema().read(new File(options.getSchemaFile())));
}
MigrationCLI.loadOrPrint(xmlTemplateFile, xmlMigrator.convert(), options);
}
}
private XmlSchema schema;
private final Set<Reader> readers;
private String element;
/**
* Construct a XmlMigrator to migrate data in the given file or dir
* @param xmlFileOrDir either a XML file or a directory containing XML files
*/
public XmlMigrator(File xmlFileOrDir) {
File[] files = {xmlFileOrDir};
if(xmlFileOrDir.isDirectory()){
files = xmlFileOrDir.listFiles(xmlFiles);
}
this.readers = Stream.of(files).map(this::asReader).collect(toSet());
this.schema = new XmlSchema();
}
public XmlMigrator element(String element) {
this.element = element;
return this;
}
public XmlMigrator schema(XmlSchema schema) {
this.schema = schema;
return this;
}
/**
* Migrate each of the given XML objects as a nested Map structure
*/
public Stream<Map<String, Object>> convert(){
return readers.stream()
.flatMap(this::toXmlNodes)
.map(this::digest)
.map(data -> (Map<String, Object>)data);
//.map(data -> { System.out.println(data); return data; } );
}
/**
* Close the readers
* @throws Exception
*/
public void close() {
readers.forEach((reader) -> {
try {
reader.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
/**
* Convert data in XML element to a Map<String, Object> or plain text depending on its content.
*
* @param node XML element (a tag) to convert
* @return A String containing the text content of the element or a Map with its nested elements.
*/
Map<String, Object> digest(Element node) {
Map<String, Object> result = new HashMap<String, Object>();
StringBuilder textContent = new StringBuilder();
NodeList children = node.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node child = children.item(i);
switch (child.getNodeType()) {
case Node.ELEMENT_NODE:{
Element el = (Element)child;
Object value = null;
TypeInfo type = schema.typeOf(el.getNodeName());
if ("xs:complexType".equals(type.name())) {
value = digest(el);
}
else if ("xs:boolean".equals(type.name())) {
value = "true".equals(el.getTextContent().trim());
}
else if ("xs:int".equals(type.name())) {
value = Integer.parseInt(el.getTextContent().trim());
}
else if ("xs:double".equals(type.name())) {
value = Double.parseDouble(el.getTextContent().trim());
}
else { // default to string, but there are other that we could support, e.g. dates etc.
value = el.getTextContent();
}
if (type.cardinality() > 1) {
@SuppressWarnings("unchecked")
List<Object> allValues = (List<Object>)result.get(el.getTagName());
if (allValues == null) {
allValues = new ArrayList<Object>();
result.put(el.getTagName(), allValues);
}
allValues.add(value);
}
else {
result.put(el.getTagName(), value);
}
break;
}
default:
textContent.append(child.getTextContent().trim());
}
}
NamedNodeMap attributes = node.getAttributes();
for(int i = 0; i < attributes.getLength(); i++){
Attr attr = (Attr) attributes.item(i);
result.put("~" + attr.getName(), attr.getValue());
}
if(textContent.length() > 0) {
result.put("textContent", textContent.toString());
}
return result;
}
Stream<Element> toXmlNodes(Reader reader) {
try {
DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
Document doc = docBuilder.parse(new InputSource(reader));
final NodeList list = doc.getElementsByTagName(this.element);
Iterable<Element> iterable = () -> new ElementIterator(list);
return StreamSupport.stream(iterable.spliterator(), false);
} catch (ParserConfigurationException | SAXException | IOException e) {
throw new RuntimeException(e);
}
}
/**
* Convert a file into a Reader
* @param file file to be converted
* @return Json object representing the file, empty if problem reading file
*/
private InputStreamReader asReader(File file){
try {
return new InputStreamReader(new FileInputStream(file), Charset.defaultCharset());
} catch (IOException e){
throw new RuntimeException("Problem reading input");
}
}
/**
* Filter that will only accept XML files with the .xml extension
*/
private final FilenameFilter xmlFiles = (dir, name) -> name.toLowerCase().endsWith(".xml");
private static class ElementIterator implements Iterator<Element> {
private final NodeList list;
int current;
ElementIterator(NodeList list) {
this.list = list;
current = 0;
}
public boolean hasNext() { return current < list.getLength(); }
public Element next() {
Element elem = (Element) list.item(current++);
if (elem == null) {
throw new NoSuchElementException();
} else {
return elem;
}
}
public void remove() { throw new UnsupportedOperationException(); }
}
}
|
0
|
java-sources/ai/grakn/migration-xml/1.4.3/ai/grakn/migration
|
java-sources/ai/grakn/migration-xml/1.4.3/ai/grakn/migration/xml/XmlSchema.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.migration.xml;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
/**
* Read an XML Schema (a .xsd) file and provide information about the types inside it.
*
* @author borislav
*
*/
public class XmlSchema {
/**
* Holds type information about an XML element: the XML Schema type name and max number of occurrences.
*/
public static class TypeInfo {
private String name;
private long cardinality;
public TypeInfo(String name, long cardinality) {
this.name = name;
this.cardinality = cardinality;
}
public String name() { return name; }
public long cardinality() { return cardinality; }
}
private Map<String, TypeInfo> types = new HashMap<String, TypeInfo>();
/**
* Return the type info of an element or <code>new TypeInfo("xs:complexType", Long.MAX_LONG)</code> as
* a default.
*/
public TypeInfo typeOf(String elementName) {
TypeInfo ti = types.get(elementName);
return ti == null ? new TypeInfo("xs:complexType", 2) : ti;
}
public XmlSchema read(File schemaFile) {
try {
DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
Document doc = docBuilder.parse(schemaFile);
NodeList list = doc.getElementsByTagName("xs:element");
for (int i = 0; i < list.getLength(); i++) {
Element el = (Element)list.item(i);
long cardinality = 1;
if (el.hasAttribute("maxOccurs")) {
cardinality = ("unbounded".equals(el.getAttribute("maxOccurs"))) ?
Long.MAX_VALUE :
Long.parseLong(el.getAttribute("maxOccurs"));
}
if (el.hasAttribute("type")) {
types.put(el.getAttribute("name"), new TypeInfo(el.getAttribute("type"), cardinality));
}
else {
types.put(el.getAttribute("name"), new TypeInfo("xs:complexType", cardinality));
}
}
return this;
} catch (ParserConfigurationException | IOException | SAXException e) {
throw new RuntimeException(e);
}
}
}
|
0
|
java-sources/ai/grakn/orientdb-factory/0.16.0/ai/grakn
|
java-sources/ai/grakn/orientdb-factory/0.16.0/ai/grakn/factory/OrientDBInternalFactory.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.factory;
import ai.grakn.Grakn;
import ai.grakn.graph.internal.GraknOrientDBGraph;
import ai.grakn.util.ErrorMessage;
import ai.grakn.util.Schema;
import com.orientechnologies.orient.core.metadata.schema.OImmutableClass;
import com.orientechnologies.orient.core.metadata.schema.OType;
import org.apache.commons.configuration.BaseConfiguration;
import org.apache.tinkerpop.gremlin.orientdb.OrientGraph;
import org.apache.tinkerpop.gremlin.orientdb.OrientGraphFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.Set;
import static ai.grakn.util.ErrorMessage.INVALID_DATATYPE;
/**
* <p>
* A Grakn Graph on top of {@link OrientGraph}
* </p>
*
* <p>
* This produces an grakn graph on top of {@link OrientGraph}.
* The base construction process defined by {@link AbstractInternalFactory} ensures the graph factories are singletons.
* </p>
*
* @author fppt
*/
public class OrientDBInternalFactory extends AbstractInternalFactory<GraknOrientDBGraph, OrientGraph> {
private final Logger LOG = LoggerFactory.getLogger(OrientDBInternalFactory.class);
private final Map<String, OrientGraphFactory> openFactories;
public OrientDBInternalFactory(String keyspace, String engineUrl, Properties properties) {
super(keyspace, engineUrl, properties);
openFactories = new HashMap<>();
}
@Override
GraknOrientDBGraph buildGraknGraphFromTinker(OrientGraph graph) {
return new GraknOrientDBGraph(graph, super.keyspace, super.engineUrl, super.properties);
}
@Override
OrientGraph buildTinkerPopGraph(boolean batchLoading) {
LOG.warn(ErrorMessage.CONFIG_IGNORED.getMessage("properties", properties));
return configureGraph(super.keyspace, super.engineUrl);
}
//TODO: Fix this later
@Override
protected OrientGraph getGraphWithNewTransaction(OrientGraph graph, boolean batchloading) {
return graph;
}
private OrientGraph configureGraph(String name, String address){
boolean schemaDefinitionRequired = false;
OrientGraphFactory factory = getFactory(name, address);
OrientGraph graph = factory.getNoTx();
//Check if the schema has been created
for (Schema.BaseType baseType : Schema.BaseType.values()) {
try {
graph.database().browseClass(OImmutableClass.VERTEX_CLASS_NAME + "_" + baseType);
} catch (IllegalArgumentException e){
schemaDefinitionRequired = true;
break;
}
}
//Create the schema if needed
if(schemaDefinitionRequired){
graph = createGraphWithSchema(factory, graph);
}
return graph;
}
private OrientGraph createGraphWithSchema(OrientGraphFactory factory, OrientGraph graph){
for (Schema.BaseType baseType : Schema.BaseType.values()) {
graph.createVertexClass(baseType.name());
}
for (Schema.EdgeLabel edgeLabel : Schema.EdgeLabel.values()) {
graph.createEdgeClass(edgeLabel.name());
}
graph = createIndicesVertex(graph);
graph.commit();
return factory.getNoTx();
}
private OrientGraph createIndicesVertex(OrientGraph graph){
ResourceBundle keys = ResourceBundle.getBundle("indices-vertices");
Set<String> labels = keys.keySet();
for (String label : labels) {
String [] configs = keys.getString(label).split(",");
for (String propertyConfig : configs) {
String[] propertyConfigs = propertyConfig.split(":");
Schema.VertexProperty property = Schema.VertexProperty.valueOf(propertyConfigs[0]);
boolean isUnique = Boolean.parseBoolean(propertyConfigs[1]);
OType orientDataType = getOrientDataType(property);
BaseConfiguration indexConfig = new BaseConfiguration();
indexConfig.setProperty("keytype", orientDataType);
//TODO: Figure out why this is not working when the Orient Guys say it should
//indexConfig.setProperty("metadata.ignoreNullValues", true);
if(isUnique){
indexConfig.setProperty("type", "UNIQUE");
}
if(!graph.getVertexIndexedKeys(label).contains(property.name())) {
graph.createVertexIndex(property.name(), label, indexConfig);
}
}
}
return graph;
}
private OType getOrientDataType(Schema.VertexProperty property){
Class propertyDataType = property.getDataType();
if(propertyDataType.equals(String.class)){
return OType.STRING;
} else if(propertyDataType.equals(Long.class)){
return OType.LONG;
} else if(propertyDataType.equals(Double.class)){
return OType.DOUBLE;
} else if(propertyDataType.equals(Boolean.class)){
return OType.BOOLEAN;
} else {
String options = String.class.getName() + ", " + Long.class.getName() + ", " +
Double.class.getName() + ", or " + Boolean.class.getName();
throw new RuntimeException(INVALID_DATATYPE.getMessage(propertyDataType.getName(), options));
}
}
private OrientGraphFactory getFactory(String name, String address){
if (Grakn.IN_MEMORY.equals(address)){
address = "memory";
//name = "/tmp/" + name;
}
String key = name + address;
if(!openFactories.containsKey(key)){
openFactories.put(key, new OrientGraphFactory(address + ":" + name));
}
return openFactories.get(key);
}
}
|
0
|
java-sources/ai/grakn/orientdb-factory/0.16.0/ai/grakn/graph
|
java-sources/ai/grakn/orientdb-factory/0.16.0/ai/grakn/graph/internal/GraknOrientDBGraph.java
|
/*
* Grakn - A Distributed Semantic Database
* Copyright (C) 2016 Grakn Labs Limited
*
* Grakn is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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.graph.internal;
import ai.grakn.concept.Concept;
import org.apache.tinkerpop.gremlin.orientdb.OrientGraph;
import java.util.Properties;
/**
* <p>
* A Grakn Graph using {@link OrientGraph} as a vendor backend.
* </p>
*
* <p>
* Wraps up a {@link OrientGraph} as a method of storing the Grakn Graph object Model.
* With this vendor some issues to be aware of:
* 1. {@link AbstractGraknGraph#isConceptModified(ConceptImpl)} always returns true due to methods not available
* yet on orient's side.
* 2. Indexing is done across labels as opposed to global indices
* </p>
*
* @author fppt
*/
public class GraknOrientDBGraph extends AbstractGraknGraph<OrientGraph> {
public GraknOrientDBGraph(OrientGraph graph, String name, String engineUrl, Properties properties){
super(graph, name, engineUrl, properties);
}
/**
*
* @param concept A concept in the graph
* @return True because at the moment there is no method in
* {@link org.apache.tinkerpop.gremlin.orientdb.OrientElement} which helps us to determine this.
*/
@Override
public boolean isConceptModified(Concept concept) {
return true;
}
@Override
public int numOpenTx() {
return 1;
}
@Override
public boolean isSessionClosed() {
//TODO: determine if the connection is closed
return false;
}
@Override
protected void commitTransactionInternal(){
getTinkerPopGraph().commit();
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/RedisBase.java
|
package ai.grakn.redismock;
import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
/**
* Created by Xiaolu on 2015/4/20.
*/
public class RedisBase {
private final Map<Slice, Set<RedisClient>> subscribers = new ConcurrentHashMap<>();
private final Map<Slice, Slice> base = new ConcurrentHashMap<>();
private final Map<Slice, Long> deadlines = new ConcurrentHashMap<>();
private final Set<RedisBase> syncBases = ConcurrentHashMap.newKeySet();
public RedisBase() {}
public void addSyncBase(RedisBase base) {
syncBases.add(base);
}
public Set<Slice> keys(){
return base.keySet();
}
public Slice rawGet(Slice key) {
Preconditions.checkNotNull(key);
Long deadline = deadlines.get(key);
if (deadline != null && deadline != -1 && deadline <= System.currentTimeMillis()) {
base.remove(key);
deadlines.remove(key);
return null;
}
return base.get(key);
}
public Long getTTL(Slice key) {
Preconditions.checkNotNull(key);
Long deadline = deadlines.get(key);
if (deadline == null) {
return null;
}
if (deadline == -1) {
return deadline;
}
long now = System.currentTimeMillis();
if (now < deadline) {
return deadline - now;
}
base.remove(key);
deadlines.remove(key);
return null;
}
public long setTTL(Slice key, long ttl) {
Preconditions.checkNotNull(key);
if (base.containsKey(key)) {
deadlines.put(key, ttl + System.currentTimeMillis());
for (RedisBase base : syncBases) {
base.setTTL(key, ttl);
}
return 1L;
}
return 0L;
}
public long setDeadline(Slice key, long deadline) {
Preconditions.checkNotNull(key);
if (base.containsKey(key)) {
deadlines.put(key, deadline);
for (RedisBase base : syncBases) {
base.setDeadline(key, deadline);
}
return 1L;
}
return 0L;
}
public void clear(){
base.clear();
subscribers.clear();
deadlines.clear();
syncBases.clear();
}
public void rawPut(Slice key, Slice value, Long ttl) {
Preconditions.checkNotNull(key);
Preconditions.checkNotNull(value);
base.put(key, value);
if (ttl != null) {
if (ttl != -1) {
deadlines.put(key, ttl + System.currentTimeMillis());
} else {
deadlines.put(key, -1L);
}
}
for (RedisBase base : syncBases) {
base.rawPut(key, value, ttl);
}
}
public void del(Slice key) {
Preconditions.checkNotNull(key);
base.remove(key);
deadlines.remove(key);
for (RedisBase base : syncBases) {
base.del(key);
}
}
public void addSubscriber(Slice channel, RedisClient client){
Set<RedisClient> newClient = new HashSet<>();
newClient.add(client);
subscribers.merge(channel, newClient, (currentSubscribers, newSubscribers) -> {
currentSubscribers.addAll(newSubscribers);
return currentSubscribers;
});
}
public boolean removeSubscriber(Slice channel, RedisClient client){
if(subscribers.containsKey(channel)){
subscribers.get(channel).remove(client);
return true;
}
return false;
}
public Set<RedisClient> getSubscribers(Slice channel){
if (subscribers.containsKey(channel)) {
return subscribers.get(channel);
}
return Collections.emptySet();
}
public List<Slice> getSubscriptions(RedisClient client){
List<Slice> subscriptions = new ArrayList<>();
subscribers.forEach((channel, subscribers) -> {
if(subscribers.contains(client)){
subscriptions.add(channel);
}
});
return subscriptions;
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/RedisClient.java
|
package ai.grakn.redismock;
import ai.grakn.redismock.commands.RedisOperationExecutor;
import ai.grakn.redismock.exception.EOFException;
import com.google.common.base.Preconditions;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicBoolean;
;
/**
* Created by Xiaolu on 2015/4/18.
*/
public class RedisClient implements Runnable {
private static final org.slf4j.Logger LOG = LoggerFactory.getLogger(RedisClient.class);
private final AtomicBoolean running;
private final RedisOperationExecutor executor;
private final Socket socket;
private final ServiceOptions options;
private final InputStream in;
private final OutputStream out;
public RedisClient(RedisBase base, Socket socket, ServiceOptions options) throws IOException {
Preconditions.checkNotNull(base);
Preconditions.checkNotNull(socket);
Preconditions.checkNotNull(options);
this.executor = new RedisOperationExecutor(base, this);
this.socket = socket;
this.options = options;
this.in = socket.getInputStream();
this.out = socket.getOutputStream();
this.running = new AtomicBoolean(true);
}
public void run() {
int count = 0;
while (running.get()) {
Optional<RedisCommand> command = nextCommand();
if(command.isPresent()){
Slice response = executor.execCommand(command.get());
sendResponse(response, command.toString());
count++;
if (options.getCloseSocketAfterSeveralCommands() != 0
&& options.getCloseSocketAfterSeveralCommands() == count) {
break;
}
}
}
LOG.debug("Mock redis connection shutting down.");
}
/**
* Gets the next command on the stream if one has been issued
*
* @return The next command on the stream if one was issues
*/
private Optional<RedisCommand> nextCommand(){
try {
return Optional.of(RedisCommandParser.parse(in));
} catch (EOFException e) {
//IGNORED often there will be nothing on the stream
}
return Optional.empty();
}
/**
* Send a response due to a specific command.
*
* @param response The respond to send.
* @param respondingTo The reason for sending this response
*/
public void sendResponse(Slice response, String respondingTo) {
try {
if (!response.equals(Response.SKIP)) {
out.write(response.data());
}
} catch (IOException e){
LOG.error("unable to send [" + response + "] as response to [" + respondingTo +"]", e);
}
}
/**
* Close all the streams used by this client effectively closing the client.
* Also signals the client to stop working.
*/
public void close(){
running.set(false);
Utils.closeQuietly(socket);
Utils.closeQuietly(in);
Utils.closeQuietly(out);
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/RedisCommand.java
|
package ai.grakn.redismock;
import com.google.common.collect.Lists;
import java.util.List;
import java.util.stream.Collectors;
/**
* Created by Xiaolu on 2015/4/20.
*/
public class RedisCommand {
private List<Slice> params = Lists.newArrayList();
RedisCommand() {}
void addParameter(Slice token) {
this.params.add(token);
}
public List<Slice> getParameters() {
return params;
}
@Override
public String toString(){
return params.stream().map(Slice::toString).collect(Collectors.joining(" "));
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/RedisCommandParser.java
|
package ai.grakn.redismock;
import ai.grakn.redismock.exception.EOFException;
import ai.grakn.redismock.exception.ParseErrorException;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
/**
* Created by Xiaolu on 2015/4/20.
*/
public class RedisCommandParser {
@VisibleForTesting
static RedisCommand parse(String stringInput) throws ParseErrorException, EOFException {
Preconditions.checkNotNull(stringInput);
return parse(new ByteArrayInputStream(stringInput.getBytes()));
}
static RedisCommand parse(InputStream messageInput) throws ParseErrorException, EOFException {
Preconditions.checkNotNull(messageInput);
long count = SliceParser.consumeCount(messageInput);
if (count == 0) {
throw new ParseErrorException();
}
RedisCommand command = new RedisCommand();
for (long i = 0; i < count; i++) {
command.addParameter(SliceParser.consumeParameter(messageInput));
}
return command;
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/RedisServer.java
|
package ai.grakn.redismock;
import com.google.common.base.Preconditions;
import java.io.IOException;
import java.net.ServerSocket;
/**
* Created by Xiaolu on 2015/4/18.
*/
public class RedisServer {
private final int bindPort;
private ServiceOptions options = new ServiceOptions();
private ServerSocket server = null;
private Thread service = null;
private final RedisBase base = new RedisBase();
public RedisServer() throws IOException {
this(0);
}
public RedisServer(int port) throws IOException {
this.bindPort = port;
}
static public RedisServer newRedisServer() throws IOException {
return new RedisServer();
}
static public RedisServer newRedisServer(int port) throws IOException {
return new RedisServer(port);
}
public void setOptions(ServiceOptions options) {
Preconditions.checkNotNull(options);
this.options = options;
}
public void start() throws IOException {
Preconditions.checkState(server == null);
Preconditions.checkState(service == null);
server = new ServerSocket(bindPort);
service = new Thread(new RedisService(server, base, options));
service.start();
}
public void stop() {
Preconditions.checkNotNull(service);
Preconditions.checkState(service.isAlive());
try {
server.close();
} catch (Exception e) {
e.printStackTrace();
// do nothing
}
try {
service.join(100);
if (service.isAlive()) {
service.stop();
}
} catch (InterruptedException e) {
service.stop();
}
server = null;
service = null;
}
public String getHost() {
Preconditions.checkNotNull(server);
return server.getInetAddress().getHostAddress();
}
public int getBindPort() {
Preconditions.checkNotNull(server);
return server.getLocalPort();
}
public RedisBase getBase() {
return base;
}
public void setSlave(RedisServer slave) {
Preconditions.checkState(server == null);
Preconditions.checkState(service == null);
base.addSyncBase(slave.getBase());
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/RedisService.java
|
package ai.grakn.redismock;
import com.google.common.base.Preconditions;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
* Created by Xiaolu on 2015/4/21.
*/
public class RedisService implements Runnable {
private final ServerSocket server;
private final RedisBase base;
private final ServiceOptions options;
public RedisService(ServerSocket server, RedisBase base, ServiceOptions options) {
Preconditions.checkNotNull(server);
Preconditions.checkNotNull(base);
Preconditions.checkNotNull(options);
this.server = server;
this.base = base;
this.options = options;
}
public void run() {
while (!server.isClosed()) {
try {
Socket socket = server.accept();
Thread t = new Thread(new RedisClient(base, socket, options));
t.start();
} catch (IOException e) {
// Do noting
}
}
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/Response.java
|
package ai.grakn.redismock;
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
/**
* Created by Xiaolu on 2015/4/20.
*/
public class Response {
private static final org.slf4j.Logger LOG = LoggerFactory.getLogger(Response.class);
private static final String LINE_SEPARATOR = "\r\n";
public static final Slice OK = new Slice("+OK" + LINE_SEPARATOR);
public static final Slice NULL = new Slice("$-1" + LINE_SEPARATOR);
public static final Slice SKIP = new Slice("Skip this submission");
private Response() {}
public static Slice bulkString(Slice s) {
if (s == null) {
return NULL;
}
ByteArrayDataOutput bo = ByteStreams.newDataOutput();
bo.write(String.format("$%d%s", s.length(), LINE_SEPARATOR).getBytes());
bo.write(s.data());
bo.write(LINE_SEPARATOR.getBytes());
return new Slice(bo.toByteArray());
}
public static Slice error(String s) {
return new Slice(String.format("-%s%s", s, LINE_SEPARATOR));
}
public static Slice integer(long v) {
return new Slice(String.format(":%d%s", v, LINE_SEPARATOR));
}
public static Slice array(List<Slice> values) {
ByteArrayDataOutput bo = ByteStreams.newDataOutput();
bo.write(String.format("*%d%s", values.size(), LINE_SEPARATOR).getBytes());
for (Slice value : values) {
bo.write(value.data());
}
return new Slice(bo.toByteArray());
}
public static Slice publishedMessage(Slice channel, Slice message){
Slice operation = SliceParser.consumeParameter("$7\r\nmessage\r\n".getBytes());
List<Slice> slices = new ArrayList<>();
slices.add(Response.bulkString(operation));
slices.add(Response.bulkString(channel));
slices.add(Response.bulkString(message));
return array(slices);
}
public static Slice subscribedToChannel(List<Slice> channels){
Slice operation = SliceParser.consumeParameter("$9\r\nsubscribe\r\n".getBytes());
List<Slice> slices = new ArrayList<>();
slices.add(Response.bulkString(operation));
channels.forEach(channel -> slices.add(bulkString(channel)));
slices.add(Response.integer(channels.size()));
return array(slices);
}
public static Slice unsubscribe(Slice channel, int remainingSubscriptions){
Slice operation = SliceParser.consumeParameter("$11\r\nunsubscribe\r\n".getBytes());
List<Slice> slices = new ArrayList<>();
slices.add(Response.bulkString(operation));
slices.add(Response.bulkString(channel));
slices.add(Response.integer(remainingSubscriptions));
return array(slices);
}
public static Slice clientResponse(String command, Slice response){
String stringResponse = response.toString().replace("\n", "").replace("\r", "");
if(!response.equals(SKIP)) {
LOG.debug("Received command [" + command + "] sending reply [" + stringResponse + "]");
}
return response;
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/ServiceOptions.java
|
package ai.grakn.redismock;
/**
* Created by Xiaolu on 2015/4/22.
*/
public class ServiceOptions {
private int closeSocketAfterSeveralCommands = 0;
public ServiceOptions() {}
public void setCloseSocketAfterSeveralCommands(int count) {
this.closeSocketAfterSeveralCommands = count;
}
public int getCloseSocketAfterSeveralCommands() {
return closeSocketAfterSeveralCommands;
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/Slice.java
|
package ai.grakn.redismock;
import java.io.Serializable;
import java.util.Arrays;
/**
* Created by Xiaolu on 2015/4/23.
*/
public class Slice implements Comparable<Slice>, Serializable {
private static final long serialVersionUID = 247772234876073528L;
private final byte[] data;
public Slice(byte[] data) {
this.data = data.clone();
}
public Slice(String data) {
this.data = data.getBytes().clone();
}
public byte[] data() {
return this.data.clone();
}
public int length() {
return this.data.length;
}
@Override
public String toString() {
return new String(data);
}
@Override
public boolean equals(Object b) {
return b instanceof Slice && Arrays.equals(data, ((Slice) b).data());
}
@Override
public int hashCode() {
return Arrays.hashCode(data);
}
public int compareTo(Slice b) {
int len1 = data.length;
int len2 = b.data.length;
int lim = Math.min(len1, len2);
int k = 0;
while (k < lim) {
byte b1 = data[k];
byte b2 = b.data[k];
if (b1 != b2) {
return b1 - b2;
}
k++;
}
return len1 - len2;
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/SliceParser.java
|
package ai.grakn.redismock;
import ai.grakn.redismock.exception.EOFException;
import ai.grakn.redismock.exception.ParseErrorException;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
public class SliceParser {
@VisibleForTesting
public static byte consumeByte(InputStream messageInput) throws EOFException {
int b;
try {
b = messageInput.read();
} catch (IOException e) {
throw new EOFException();
}
if (b == -1) {
throw new EOFException();
}
return (byte) b;
}
@VisibleForTesting
public static void expectByte(InputStream messageInput, byte c) throws ParseErrorException, EOFException {
if (consumeByte(messageInput) != c) {
throw new ParseErrorException();
}
}
@VisibleForTesting
public static long consumeLong(InputStream messageInput) throws ParseErrorException {
byte c;
long ret = 0;
boolean hasLong = false;
while (true) {
try {
c = consumeByte(messageInput);
} catch (EOFException e) {
throw new ParseErrorException();
}
if (c == '\r') {
break;
}
if (!isNumber(c)) {
throw new ParseErrorException();
}
ret = ret * 10 + c - '0';
hasLong = true;
}
if (!hasLong) {
throw new ParseErrorException();
}
return ret;
}
@VisibleForTesting
public static Slice consumeSlice(InputStream messageInput, long len) throws ParseErrorException {
ByteArrayDataOutput bo = ByteStreams.newDataOutput();
for (long i = 0; i < len; i++) {
try {
bo.write(consumeByte(messageInput));
} catch (EOFException e) {
throw new ParseErrorException();
}
}
return new Slice(bo.toByteArray());
}
@VisibleForTesting
public static long consumeCount(InputStream messageInput) throws ParseErrorException {
try {
expectByte(messageInput, (byte) '*');
long count = consumeLong(messageInput);
expectByte(messageInput, (byte) '\n');
return count;
} catch (EOFException e) {
throw new ParseErrorException();
}
}
public static long consumeCount(byte [] message) throws ParseErrorException{
InputStream stream = new ByteArrayInputStream(message);
return consumeCount(stream);
}
private static boolean isNumber(byte c) {
return '0' <= c && c <= '9';
}
public static Slice consumeParameter(InputStream messageInput) throws ParseErrorException {
try {
expectByte(messageInput, (byte) '$');
long len = consumeLong(messageInput);
expectByte(messageInput, (byte) '\n');
Slice para = consumeSlice(messageInput, len);
expectByte(messageInput, (byte) '\r');
expectByte(messageInput, (byte) '\n');
return para;
} catch (EOFException e) {
throw new ParseErrorException();
}
}
public static Slice consumeParameter(byte [] message) throws ParseErrorException {
InputStream stream = new ByteArrayInputStream(message);
return consumeParameter(stream);
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/Utils.java
|
package ai.grakn.redismock;
import ai.grakn.redismock.exception.InternalException;
import ai.grakn.redismock.exception.WrongNumberOfArgumentsException;
import ai.grakn.redismock.exception.WrongValueTypeException;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.List;
/**
* Created by Xiaolu on 2015/4/21.
*/
public class Utils {
public static void closeQuietly(Closeable closeable) {
try {
closeable.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void checkArgumentsNumberEquals(List<Slice> args, int expect) throws WrongNumberOfArgumentsException {
if (args.size() != expect) {
throw new WrongNumberOfArgumentsException();
}
}
public static void checkArgumentsNumberGreater(List<Slice> args, int expect) throws WrongNumberOfArgumentsException {
if (args.size() <= expect) {
throw new WrongNumberOfArgumentsException();
}
}
public static void checkArgumentsNumberFactor(List<Slice> args, int factor) throws WrongNumberOfArgumentsException {
if (args.size() % factor != 0) {
throw new WrongNumberOfArgumentsException();
}
}
public static Slice serializeObject(Object o){
try {
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(bo);
oo.writeObject(o);
Slice encode = new Slice(bo.toByteArray());
oo.close();
bo.close();
return encode;
} catch (IOException e){
throw new InternalException(e.getMessage());
}
}
public static <T> T deserializeObject(Slice data){
try {
ByteArrayInputStream bi = new ByteArrayInputStream(data.data());
ObjectInputStream oi = new ObjectInputStream(bi);
T ret = (T) oi.readObject();
oi.close();
bi.close();
return ret;
} catch (IOException | ClassNotFoundException e){
throw new WrongValueTypeException("WRONGTYPE Key is not a valid HyperLogLog string value.");
}
}
public static long convertToLong(String value){
try {
return Long.parseLong(value);
} catch (NumberFormatException e) {
throw new WrongValueTypeException("ERR value is not an integer or out of range");
}
}
public static byte convertToByte(String value){
try {
byte bit = Byte.parseByte(value);
if (bit != 0 && bit != 1) {
throw new NumberFormatException();
}
return bit;
} catch (NumberFormatException e) {
throw new WrongValueTypeException("ERR bit is not an integer or out of range");
}
}
public static int convertToNonNegativeInteger(String value){
try {
int pos = Integer.parseInt(value);
if(pos < 0) throw new NumberFormatException("Int less than 0");
return pos;
} catch (NumberFormatException e) {
throw new WrongValueTypeException("ERR bit offset is not an integer or out of range");
}
}
public static int convertToInteger(String value){
try {
return Integer.parseInt(value);
} catch (NumberFormatException e) {
throw new WrongValueTypeException("ERR bit offset is not an integer or out of range");
}
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/commands/AbstractRedisOperation.java
|
package ai.grakn.redismock.commands;
import ai.grakn.redismock.RedisBase;
import ai.grakn.redismock.Slice;
import java.util.List;
import static ai.grakn.redismock.Utils.checkArgumentsNumberEquals;
import static ai.grakn.redismock.Utils.checkArgumentsNumberFactor;
import static ai.grakn.redismock.Utils.checkArgumentsNumberGreater;
abstract class AbstractRedisOperation implements RedisOperation {
private final RedisBase base;
private final List<Slice> params;
AbstractRedisOperation(RedisBase base, List<Slice> params, Integer expectedParams, Integer minParams, Integer factorParams) {
this.base = base;
this.params = params;
precheck(expectedParams, minParams, factorParams);
}
void doOptionalWork(){
}
abstract Slice response();
RedisBase base(){
return base;
}
List<Slice> params(){
return params;
}
@Override
public Slice execute(){
doOptionalWork();
synchronized (base){
return response();
}
}
/**
* Runs a default precheck to make sure the parameters are as expected
*/
private void precheck(Integer expectedParams, Integer minParams, Integer factorParams){
if(expectedParams != null) checkArgumentsNumberEquals(params, expectedParams);
if(minParams != null) checkArgumentsNumberGreater(params, minParams);
if(factorParams != null) checkArgumentsNumberFactor(params, factorParams);
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/commands/RO_append.java
|
package ai.grakn.redismock.commands;
import ai.grakn.redismock.RedisBase;
import ai.grakn.redismock.Response;
import ai.grakn.redismock.Slice;
import java.util.List;
class RO_append extends AbstractRedisOperation {
RO_append(RedisBase base, List<Slice> params) {
super(base, params, 2, null, null);
}
Slice response() {
Slice key = params().get(0);
Slice value = params().get(1);
Slice s = base().rawGet(key);
if (s == null) {
base().rawPut(key, value, -1L);
return Response.integer(value.length());
}
byte[] b = new byte[s.length() + value.length()];
for (int i = 0; i < s.length(); i++) {
b[i] = s.data()[i];
}
for (int i = s.length(); i < s.length() + value.length(); i++) {
b[i] = value.data()[i - s.length()];
}
base().rawPut(key, new Slice(b), -1L);
return Response.integer(b.length);
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/commands/RO_brpoplpush.java
|
package ai.grakn.redismock.commands;
import ai.grakn.redismock.RedisBase;
import ai.grakn.redismock.Response;
import ai.grakn.redismock.Slice;
import ai.grakn.redismock.SliceParser;
import java.util.Arrays;
import java.util.List;
import static ai.grakn.redismock.Utils.convertToLong;
class RO_brpoplpush extends RO_rpoplpush {
private long count = 0L;
RO_brpoplpush(RedisBase base, List<Slice> params) {
//NOTE: The minimum number of arguments is 1 because this mock is used for brpoplpush as well which takes in 3 arguments
super(base, params, 3);
}
void doOptionalWork(){
Slice source = params().get(0);
long timeout = convertToLong(params().get(2).toString());
//TODO: Remove active block dumb.
long currentSleep = 0L;
while(count == 0L && currentSleep < timeout * 1000){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
currentSleep = currentSleep + 100;
count = getCount(source);
}
}
Slice response() {
if(count != 0){
return super.response();
} else {
return Response.NULL;
}
}
private long getCount(Slice source){
Slice index = new Slice("0");
List<Slice> commands = Arrays.asList(source, index, index);
Slice result = new RO_lrange(base(), commands).execute();
return SliceParser.consumeCount(result.data());
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/commands/RO_decr.java
|
package ai.grakn.redismock.commands;
import ai.grakn.redismock.RedisBase;
import ai.grakn.redismock.Slice;
import java.util.List;
class RO_decr extends RO_decrby {
RO_decr(RedisBase base, List<Slice> params) {
super(base, params, 1);
}
@Override
long incrementOrDecrementValue(List<Slice> params){
return -1L;
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/commands/RO_decrby.java
|
package ai.grakn.redismock.commands;
import ai.grakn.redismock.RedisBase;
import ai.grakn.redismock.Slice;
import java.util.List;
import static ai.grakn.redismock.Utils.convertToLong;
class RO_decrby extends RO_incrOrDecrBy {
RO_decrby(RedisBase base, List<Slice> params) {
super(base, params, 2);
}
RO_decrby(RedisBase base, List<Slice> params, Integer expectedParams) {
super(base, params, expectedParams);
}
long incrementOrDecrementValue(List<Slice> params){
return convertToLong(String.valueOf(params.get(1))) * -1;
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/commands/RO_del.java
|
package ai.grakn.redismock.commands;
import ai.grakn.redismock.RedisBase;
import ai.grakn.redismock.Response;
import ai.grakn.redismock.Slice;
import java.util.List;
class RO_del extends AbstractRedisOperation {
RO_del(RedisBase base, List<Slice> params) {
super(base, params,null, 0, null);
}
Slice response(){
int count = 0;
for (Slice key : params()) {
Slice value = base().rawGet(key);
base().del(key);
if (value != null) {
count++;
}
}
return Response.integer(count);
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/commands/RO_exec.java
|
package ai.grakn.redismock.commands;
import ai.grakn.redismock.RedisBase;
import ai.grakn.redismock.Response;
import ai.grakn.redismock.Slice;
import org.slf4j.LoggerFactory;
import java.util.List;
import java.util.stream.Collectors;
class RO_exec extends AbstractRedisOperation {
private static final org.slf4j.Logger LOG = LoggerFactory.getLogger(RO_exec.class);
private final List<RedisOperation> transaction;
RO_exec(RedisBase base, List<RedisOperation> transaction, List<Slice> params) {
super(base, params,0, null, null);
this.transaction = transaction;
}
Slice response() {
try {
List<Slice> results = transaction.stream().
map(RedisOperation::execute).
collect(Collectors.toList());
transaction.clear();
return Response.array(results);
} catch (Throwable t){
LOG.error("ERROR during committing transaction", t);
return Response.NULL;
}
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/commands/RO_exists.java
|
package ai.grakn.redismock.commands;
import ai.grakn.redismock.RedisBase;
import ai.grakn.redismock.Response;
import ai.grakn.redismock.Slice;
import java.util.List;
class RO_exists extends AbstractRedisOperation {
RO_exists(RedisBase base, List<Slice> params) {
super(base, params, 1, null, null);
}
Slice response() {
if (base().rawGet(params().get(0)) != null) {
return Response.integer(1);
}
return Response.integer(0);
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/commands/RO_expire.java
|
package ai.grakn.redismock.commands;
import ai.grakn.redismock.RedisBase;
import ai.grakn.redismock.Slice;
import java.util.List;
class RO_expire extends RO_pexpire {
RO_expire(RedisBase base, List<Slice> params) {
super(base, params);
}
@Override
long getValue(List<Slice> params){
return super.getValue(params) * 1000;
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/commands/RO_expireat.java
|
package ai.grakn.redismock.commands;
import ai.grakn.redismock.RedisBase;
import ai.grakn.redismock.Response;
import ai.grakn.redismock.Slice;
import java.util.List;
import static ai.grakn.redismock.Utils.convertToLong;
class RO_expireat extends AbstractRedisOperation {
RO_expireat(RedisBase base, List<Slice> params) {
super(base, params, 2, null, null);
}
Slice response() {
long deadline = convertToLong(new String(params().get(1).data())) * 1000;
return Response.integer(base().setDeadline(params().get(0), deadline));
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/commands/RO_flushall.java
|
package ai.grakn.redismock.commands;
import ai.grakn.redismock.RedisBase;
import ai.grakn.redismock.Response;
import ai.grakn.redismock.Slice;
import java.util.List;
class RO_flushall extends AbstractRedisOperation {
RO_flushall(RedisBase base, List<Slice> params) {
super(base, params, 0, null, null);
}
Slice response(){
base().clear();
return Response.OK;
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/commands/RO_get.java
|
package ai.grakn.redismock.commands;
import ai.grakn.redismock.RedisBase;
import ai.grakn.redismock.Response;
import ai.grakn.redismock.Slice;
import java.util.List;
class RO_get extends AbstractRedisOperation {
RO_get(RedisBase base, List<Slice> params) {
super(base, params, 1, null, null);
}
Slice response() {
return Response.bulkString(base().rawGet(params().get(0)));
}
}
|
0
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock
|
java-sources/ai/grakn/redis-mock/0.1.6/ai/grakn/redismock/commands/RO_getbit.java
|
package ai.grakn.redismock.commands;
import ai.grakn.redismock.RedisBase;
import ai.grakn.redismock.Response;
import ai.grakn.redismock.Slice;
import java.util.List;
import static ai.grakn.redismock.Utils.convertToNonNegativeInteger;
class RO_getbit extends AbstractRedisOperation {
RO_getbit(RedisBase base, List<Slice> params) {
super(base, params, 2, null, null);
}
Slice response() {
Slice value = base().rawGet(params().get(0));
int pos = convertToNonNegativeInteger(params().get(1).toString());
if (value == null) {
return Response.integer(0L);
}
if (pos >= value.length() * 8) {
return Response.integer(0L);
}
if ((value.data()[pos / 8] & (1 << (pos % 8))) != 0) {
return Response.integer(1);
}
return Response.integer(0);
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.