@Override final Role asSelf(Concept concept) { return concept.asRole(); }
@Override final Role asCurrentBaseType(Concept other) { return other.asRole(); }
@Override public Role putRole(Label label) { return client().putRole(label).asRole(); }
@Override Label transform(MatchableConcept item) { Concept concept = item.get(); return concept.isRole() ? concept.asRole().label() : null; } };
/** * * @param concept The element to be later validated */ public void trackForValidation(Concept concept) { if (concept.isThing()) { modifiedThings.add(concept.asThing()); } else if (concept.isRole()) { modifiedRoles.add(concept.asRole()); } else if (concept.isRelationshipType()) { modifiedRelationshipTypes.add(concept.asRelationshipType()); } else if (concept.isRule()){ modifiedRules.add(concept.asRule()); } } public void trackForValidation(Casting casting) {
@Override public Role putRole(Label label) { transceiver.send(RequestBuilder.Transaction.putRole(label)); return RemoteConcept.of(responseOrThrow().getPutRoleRes().getRole(), this).asRole(); }
@Override // TODO: Weird. Why is this not a stream, while other collections are returned as stream public final Map<Role, Set<Thing>> rolePlayersMap() { ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder() .setRelationRolePlayersMapReq(ConceptProto.Relation.RolePlayersMap.Req.getDefaultInstance()).build(); int iteratorId = runMethod(method).getRelationRolePlayersMapIter().getId(); Iterable<ConceptProto.Relation.RolePlayersMap.Iter.Res> rolePlayers = () -> new Grakn.Transaction.Iterator<>( tx(), iteratorId, res -> res.getConceptMethodIterRes().getRelationRolePlayersMapIterRes() ); Map<Role, Set<Thing>> rolePlayerMap = new HashMap<>(); for (ConceptProto.Relation.RolePlayersMap.Iter.Res rolePlayer : rolePlayers) { Role role = RemoteConcept.of(rolePlayer.getRole(), tx()).asRole(); Thing player = RemoteConcept.of(rolePlayer.getPlayer(), tx()).asThing(); if (rolePlayerMap.containsKey(role)) { rolePlayerMap.get(role).add(player); } else { rolePlayerMap.put(role, new HashSet<>(Collections.singletonList(player))); } } return rolePlayerMap; }
default RolePlayer convert(GrpcConcept.RolePlayer rolePlayer) { return RolePlayer.create(convert(rolePlayer.getRole()).asRole(), convert(rolePlayer.getPlayer()).asThing()); } }
@Override public Collection<PropertyExecutor> define(Var var) throws GraqlQueryException { PropertyExecutor.Method method = executor -> { Role role = executor.get(this.role().var()).asRole(); executor.get(var).asType().plays(role); }; return ImmutableSet.of(PropertyExecutor.builder(method).requires(var, role().var()).build()); }
@Override public String toString() { if (concept.isAttribute()) { return "hasValue(" + valueToString(concept.asAttribute().value()) + ")"; } else if (concept.isThing()) { Thing thing = concept.asThing(); Stream<Attribute<?>> resources = thing.attributes(); Optional<?> value = resources .filter(resource -> NAME_TYPES.contains(resource.type().label())) .map(Attribute::value).findFirst(); return "instance(" + value.map(StringUtil::valueToString).orElse("") + ") isa " + thing.type().label(); } else if (concept.isType()) { return "type(" + concept.asType().label() + ")"; } else if (concept.isRole()) { return "role(" + concept.asRole().label() + ")"; } else if (concept.isRule()) { return "rule(" + concept.asRule().label() + ")"; } else { throw CommonUtil.unreachableStatement("Unrecognised concept " + concept); } }
/** * Add a roleplayer to the given {@link Relationship} * @param relationship the concept representing the {@link Relationship} * @param relationPlayer a casting between a role type and role player */ private void addRoleplayer(QueryOperationExecutor executor, Relationship relationship, RelationPlayer relationPlayer) { VarPatternAdmin roleVar = getRole(relationPlayer); Role role = executor.get(roleVar.var()).asRole(); Thing roleplayer = executor.get(relationPlayer.getRolePlayer().var()).asThing(); relationship.assign(role, roleplayer); }
@Override public Collection<PropertyExecutor> undefine(Var var) throws GraqlQueryException { PropertyExecutor.Method method = executor -> { Type type = executor.get(var).asType(); Role role = executor.get(this.role().var()).asRole(); if (!type.isDeleted() && !role.isDeleted()) { type.unplay(role); } }; return ImmutableSet.of(PropertyExecutor.builder(method).requires(var, role().var()).build()); }
@Override public Collection<PropertyExecutor> undefine(Var var) throws GraqlQueryException { PropertyExecutor.Method method = executor -> { RelationshipType relationshipType = executor.get(var).asRelationshipType(); Role role = executor.get(this.role().var()).asRole(); if (!relationshipType.isDeleted() && !role.isDeleted()) { relationshipType.unrelate(role); } }; return ImmutableSet.of(PropertyExecutor.builder(method).requires(var, role().var()).build()); }
public static Map<Role, Set<Thing>> convert(GrpcConceptConverter converter, RolePlayers allRolePlayers) { ImmutableSetMultimap.Builder<Role, Thing> map = ImmutableSetMultimap.builder(); for (GrpcConcept.RolePlayer rolePlayer : allRolePlayers.getRolePlayerList()) { Role role = converter.convert(rolePlayer.getRole()).asRole(); Thing player = converter.convert(rolePlayer.getPlayer()).asThing(); map.put(role, player); } return Multimaps.asMap(map.build()); }
@Override public Collection<PropertyExecutor> define(Var var) throws GraqlQueryException { Var roleVar = role().var(); PropertyExecutor.Method relatesMethod = executor -> { Role role = executor.get(roleVar).asRole(); executor.get(var).asRelationshipType().relates(role); }; PropertyExecutor relatesExecutor = PropertyExecutor.builder(relatesMethod).requires(var, roleVar).build(); // This allows users to skip stating `$roleVar sub role` when they say `$var relates $roleVar` PropertyExecutor.Method isRoleMethod = executor -> executor.builder(roleVar).isRole(); PropertyExecutor isRoleExecutor = PropertyExecutor.builder(isRoleMethod).produces(roleVar).build(); VarPatternAdmin superRoleVarPattern = superRole(); if (superRoleVarPattern != null) { Var superRoleVar = superRoleVarPattern.var(); PropertyExecutor.Method subMethod = executor -> { Role superRole = executor.get(superRoleVar).asRole(); executor.builder(roleVar).sub(superRole); }; PropertyExecutor subExecutor = PropertyExecutor.builder(subMethod) .requires(superRoleVar).produces(roleVar).build(); return ImmutableSet.of(relatesExecutor, isRoleExecutor, subExecutor); } else { return ImmutableSet.of(relatesExecutor, isRoleExecutor); } }
return setAbstract(conceptMethod.getSetAbstract()); case SETROLEPLAYEDBYTYPE: return setRolePlayedByType(converter.convert(conceptMethod.getSetRolePlayedByType()).asRole()); case UNSETROLEPLAYEDBYTYPE: return unsetRolePlayedByType(converter.convert(conceptMethod.getUnsetRolePlayedByType()).asRole()); case ADDENTITY: return ADD_ENTITY; case SETRELATEDROLE: return setRelatedRole(converter.convert(conceptMethod.getSetRelatedRole()).asRole()); case UNSETRELATEDROLE: return unsetRelatedRole(converter.convert(conceptMethod.getUnsetRelatedRole()).asRole()); case PUTATTRIBUTE: return putAttribute(convert(conceptMethod.getPutAttribute()));