Return a List with all the VNFDependencies that are contained in a specific
NetworkServiceDescriptor.

@param idNSD the ID of the NetworkServiceDescriptor
@return the List of VNFDependencies
@throws SDKException if the request fails
5465
@Help(
    help =
        "Get all the VirtualNetworkFunctionDescriptor Dependency of a NetworkServiceDescriptor with specific id"
  )
  public List<VNFDependency> getVNFDependencies(final String idNSD) throws SDKException {
    String url = idNSD + "/vnfdependencies";
    return Arrays.asList((VNFDependency[]) requestGetAll(url, VNFDependency.class));
  }
1261968
public Collection<String> getChaincodeNamespaceTypes() throws ProposalException {

        final Lifecycle.QueryNamespaceDefinitionsResult queryNamespaceDefinitionsResult = parsePayload();
        if (queryNamespaceDefinitionsResult == null) {
            return Collections.emptySet();
        }

        final Map<String, Lifecycle.QueryNamespaceDefinitionsResult.Namespace> namespacesMap = queryNamespaceDefinitionsResult.getNamespacesMap();
        if (null == namespacesMap) {
            return Collections.emptySet();
        }

        final Set<String> ret = new HashSet<>();
        namespacesMap.forEach((s, namespace) -> {
            if ("Chaincode".equalsIgnoreCase(namespace.getType())) {
                ret.add(s);
            }
        });
        return Collections.unmodifiableSet(ret);

    }
825081
public List<TypedDependency> getStanfordTypedDependencies(DependencyForm form) {
        List<TypedDependency> dependencies = new ArrayList<TypedDependency>();
        if (this.nodes == null)
        	nodes = getStanfordTreeGraphNodes(form);

        List<AgigaTypedDependency> agigaDeps = getAgigaDeps(form);
        for (AgigaTypedDependency agigaDep : agigaDeps) {
            // Add one, since the tokens are zero-indexed but the TreeGraphNodes are one-indexed
            TreeGraphNode gov = nodes.get(agigaDep.getGovIdx() + 1);
            TreeGraphNode dep = nodes.get(agigaDep.getDepIdx() + 1);
            // Create the typed dependency
            TypedDependency typedDep = new TypedDependency(GrammaticalRelation.valueOf(agigaDep.getType()), gov, dep);
            dependencies.add(typedDep);
        }
        return dependencies;
    }
674839
public List<Struct> listTraitDefinitions(final String guid) throws AtlasServiceException{
        JSONObject jsonResponse = callAPIWithBodyAndParams(API.GET_ALL_TRAIT_DEFINITIONS, null, guid, TRAIT_DEFINITIONS);
        List<JSONObject> traitDefList = extractResults(jsonResponse, AtlasClient.RESULTS, new ExtractOperation<JSONObject, JSONObject>());
        ArrayList<Struct> traitStructList = new ArrayList<>();
        for(JSONObject traitDef:traitDefList){
            Struct traitStruct = InstanceSerialization.fromJsonStruct(traitDef.toString(), true);
            traitStructList.add(traitStruct);
        }
        return traitStructList;
    }
1257314
protected List<NodeInterface> getNodesAt(final NodeInterface locationNode) {

		final List<NodeInterface> nodes = new LinkedList<>();

		for(RelationshipInterface rel : locationNode.getIncomingRelationships(NodeHasLocation.class)) {

			NodeInterface startNode = rel.getSourceNode();

			nodes.add(startNode);

			// add more nodes which are "at" this one
			nodes.addAll(getNodesAt(startNode));
		}

		return nodes;

	}
1014857
ImmutableCollection<String> getKnownProvides() {
    return concat(
        dependencyInfo != null ? dependencyInfo.getProvides() : ImmutableList.<String>of(),
        extraProvides);
  }
888147
public DependencyList getDependencyList(int id) {
        ClientResource resource = new ClientResource(Route.DEPENDENCY.url(id));

        try {
            Representation repr = resource.get();
            return mapper.readValue(repr.getText(), DependencyList.class);
        } catch (IOException ex) {
            LEX4JLogger.log(Level.WARNING, "Could not retrieve lot dependencies correctly!");
            return null;
        }
    }
141044
def getServiceDependencies(self):
        
        calc = self.getCalculation()
        if calc:
            return calc.getCalculationDependencies(flat=True)
        return []
241467
public static List<DependencyInfo> readDependencies(InputStream in) throws IOException {
        try (InputStreamReader inputStreamReader = new InputStreamReader(in, UTF_8);
             BufferedReader br = new BufferedReader(inputStreamReader);
             JsonReader reader = new JsonReader(br)) {
            return getDependencies(reader);
        } catch (IOException ex) {
            logger.error("Failed to read dependencies: {}", ex.getMessage());
        }
        return null;
    }
1029845
@Help(
    help =
        "Delete the VirtualNetworkFunctionDescriptor dependency of a NetworkServiceDescriptor with specific id"
  )
  public void deleteVNFDependency(final String idNSD, final String idVnfd) throws SDKException {
    String url = idNSD + "/vnfdependencies" + "/" + idVnfd;
    requestDelete(url);
  }
834709
@Help(help = "Get all the Security of a NetworkServiceDescriptor with specific id")
  public Security getSecurities(final String idNsd) throws SDKException {
    String url = idNsd + "/security";
    return ((Security) requestGet(url, Security.class));
  }
1358084
private List<String> searchTokens(SNode n, long cnr)
  {
    List<String> result = new LinkedList<String>();
    if (n instanceof SToken)
    {
      result.add(n.getId());
      if (componentOfToken.get(n.getId()) == null)
      {
        List<Long> newlist = new LinkedList<Long>();
        newlist.add(cnr);
        componentOfToken.put(n.getId(), newlist);
      }
      else
      {
        List<Long> newlist = componentOfToken.get(n.getId());
        if (!newlist.contains(cnr))
        {
          newlist.add(cnr);
        }
      }
    }
    else
    {
      List<SRelation<SNode, SNode>> outgoing = n.getGraph().getOutRelations(n.getId());
      if(outgoing != null)
      {
        for (SRelation<? extends SNode,? extends SNode> e : outgoing)
        {
          if(!(e instanceof SPointingRelation) && e.getSource() instanceof SNode && e.getTarget() instanceof SNode)
          {
            List<String> Med = searchTokens((SNode) e.getTarget(), cnr);
            for (String s : Med)
            {
              if (!result.contains(s))
              {
                result.add(s);
              }
            }
          }
        }
      }
    }
    return result;
  }
682975
@Help(
    help =
        "Create the VirtualNetworkFunctionDescriptor dependency of a NetworkServiceDescriptor with specific id"
  )
  public VNFDependency createVNFDependency(final String idNSD, final VNFDependency vnfDependency)
      throws SDKException {
    String url = idNSD + "/vnfdependencies" + "/";
    return (VNFDependency) requestPost(url, vnfDependency);
  }
1124791
@Help(
    help =
        "get the VirtualNetworkFunctionDescriptor dependency with specific id of a NetworkServiceDescriptor with specific id"
  )
  public VNFDependency getVNFDependency(final String idNSD, final String idVnfd)
      throws SDKException {
    String url = idNSD + "/vnfdependencies" + "/" + idVnfd;
    return (VNFDependency) requestGet(url, VNFDependency.class);
  }
283830
public java.util.List<String> getNatGatewayIds() {
        if (natGatewayIds == null) {
            natGatewayIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return natGatewayIds;
    }
337726
public List<DomainBareJid> getSearchServices() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException  {
        ServiceDiscoveryManager discoManager = ServiceDiscoveryManager.getInstanceFor(con);
        return discoManager.findServices(UserSearch.NAMESPACE, false, false);
    }
407824
public List<String> getDependencyPath(int nodeIndex, int rootIndex) {
    TreeGraphNode node = getNodeByIndex(nodeIndex);
    TreeGraphNode rootTree = getNodeByIndex(rootIndex);
    return getDependencyPath(node, rootTree);
  }