<p>
The <code>GraphqlApi</code> objects.
</p>

@param graphqlApis
The <code>GraphqlApi</code> objects.
180441
public void setGraphqlApis(java.util.Collection<GraphqlApi> graphqlApis) {
        if (graphqlApis == null) {
            this.graphqlApis = null;
            return;
        }

        this.graphqlApis = new java.util.ArrayList<GraphqlApi>(graphqlApis);
    }
1374997
public void dropGraph(long graphId) {
        val builder = new FlatBufferBuilder(128);

        val off = FlatDropRequest.createFlatDropRequest(builder, graphId);
        builder.finish(off);

        val req = FlatDropRequest.getRootAsFlatDropRequest(builder.dataBuffer());

        val v = blockingStub.forgetGraph(req);
        if (v.status() != 0)
            throw new ND4JIllegalStateException("registerGraph() gRPC call failed");
    }
737049
@Override
	public <T> GraphRequest<T> post(String object, Class<T> type, Param... params) {
		this.checkForBatchExecution();

		// The data is transformed through a chain of wrappers
		GraphRequest<T> req =
			new GraphRequest<T>(object, HttpMethod.POST, params, this.mapper, this.<T>createMappingChain(mapper.getTypeFactory().constructType(type)));
		
		this.graphRequests.add(req);
		return req;
	}
449639
public void setNetworkInterfaceIds(java.util.Collection<String> networkInterfaceIds) {
        if (networkInterfaceIds == null) {
            this.networkInterfaceIds = null;
            return;
        }

        this.networkInterfaceIds = new com.amazonaws.internal.SdkInternalList<String>(networkInterfaceIds);
    }
43620
private void checkObjectImplementsInterface(GraphQLObjectType objectType, GraphQLInterfaceType interfaceType, SchemaValidationErrorCollector validationErrorCollector) {
        List<GraphQLFieldDefinition> fieldDefinitions = interfaceType.getFieldDefinitions();
        for (GraphQLFieldDefinition interfaceFieldDef : fieldDefinitions) {
            GraphQLFieldDefinition objectFieldDef = objectType.getFieldDefinition(interfaceFieldDef.getName());
            if (objectFieldDef == null) {
                validationErrorCollector.addError(
                        error(format("object type '%s' does not implement interface '%s' because field '%s' is missing",
                                objectType.getName(), interfaceType.getName(), interfaceFieldDef.getName())));
            } else {
                checkFieldTypeCompatibility(objectType, interfaceType, validationErrorCollector, interfaceFieldDef, objectFieldDef);
            }
        }
    }
1247867
public static <T> void resetVertices(List<Vertex<T>> vertices)
    {
        Iterator<Vertex<T>> it = vertices.iterator();
        while (it.hasNext())
        {
            it.next().reset();
        }
    }
883501
public void setEndpoints(java.util.Collection<Endpoint> endpoints) {
        if (endpoints == null) {
            this.endpoints = null;
            return;
        }

        this.endpoints = new java.util.ArrayList<Endpoint>(endpoints);
    }
836822
public <NV> Graph<K, NV, EV> mapVertices(final MapFunction<Vertex<K, VV>, NV> mapper, TypeInformation<Vertex<K, NV>> returnType) {
		DataSet<Vertex<K, NV>> mappedVertices = vertices.map(
				new MapFunction<Vertex<K, VV>, Vertex<K, NV>>() {
					private Vertex<K, NV> output = new Vertex<>();

					public Vertex<K, NV> map(Vertex<K, VV> value) throws Exception {
						output.f0 = value.f0;
						output.f1 = mapper.map(value);
						return output;
					}
				})
				.returns(returnType)
				.withForwardedFields("f0")
					.name("Map vertices");

		return new Graph<>(mappedVertices, this.edges, this.context);
	}
764539
public void setGeometries(List<Geometry> geometries) {
        this.mGeometries.clear();
        if (geometries != null) {
            this.mGeometries.addAll(geometries);
        }
    }
342024
void build(int nodeOffset, GraphMeshData graphData, List<int[]> connections) {
		for (int n = 0; n < connections.size(); n++) {
			int[] nodeConnections = connections.get(n);
			MeshData tile = graphData.getTile(n);
			Poly node = graphData.getNode(n);
			for (int connection : nodeConnections) {
				MeshData neighbourTile = graphData.getTile(connection - nodeOffset);
				if (neighbourTile != tile) {
					buildExternalLink(tile, node, neighbourTile);
				} else {
					Poly neighbour = graphData.getNode(connection - nodeOffset);
					buildInternalLink(tile, node, neighbourTile, neighbour);
				}
			}
		}
	}
229631
protected void initializeGraph() {
        mGraph = new Graph(getContext());
        addView(mGraph);

        mGraphOverlay = new GraphOverlay(getContext());
        addView(mGraphOverlay);

        mLegend = new Legend(getContext());
        addView(mLegend);
    }
370746
public void setGatewayNetworkInterfaces(java.util.Collection<NetworkInterface> gatewayNetworkInterfaces) {
        if (gatewayNetworkInterfaces == null) {
            this.gatewayNetworkInterfaces = null;
            return;
        }

        this.gatewayNetworkInterfaces = new com.amazonaws.internal.SdkInternalList<NetworkInterface>(gatewayNetworkInterfaces);
    }
902734
def _create_interface_specification(schema_graph, graphql_types, hidden_classes, cls_name):
    """"""
    def interface_spec():
        """Return a list of GraphQL interface types implemented by the type named 'cls_name'."""
        abstract_inheritance_set = (
            superclass_name
            for superclass_name in sorted(list(schema_graph.get_inheritance_set(cls_name)))
            if (superclass_name not in hidden_classes and
                schema_graph.get_element_by_class_name(superclass_name).abstract)
        )

        return [
            graphql_types[x]
            for x in abstract_inheritance_set
            if x not in hidden_classes
        ]

    return interface_spec
254822
public void setSelection(List<GraphUser> graphUsers) {
        List<String> userIds = new ArrayList<String>();
        for(GraphUser graphUser: graphUsers) {
            userIds.add(graphUser.getId());
        }
        setSelectionByIds(userIds);
    }
224533
public void addVerticesToSet(Set<VertexType> set) {
        // Add the vertex for this object
        set.add(this.m_vertex);

        // Add vertices for all children
        Iterator<SearchTree<VertexType>> i = childIterator();
        while (i.hasNext()) {
            SearchTree<VertexType> child = i.next();
            child.addVerticesToSet(set);
        }
    }
163609
func (s *UpdateGraphqlApiOutput) SetGraphqlApi(v *GraphqlApi) *UpdateGraphqlApiOutput {
	s.GraphqlApi = v
	return s
}
713825
public void setBulletPoints(java.util.Collection<String> bulletPoints) {
        if (bulletPoints == null) {
            this.bulletPoints = null;
            return;
        }

        this.bulletPoints = new java.util.ArrayList<String>(bulletPoints);
    }