for (const auto& p : *shapes_and_types) {
      auto* out_shape_and_type = handle_data.add_shape_and_type();
      ic->ShapeHandleToProto(p.shape, out_shape_and_type->mutable_shape());
      out_shape_and_type->set_dtype(p.dtype);
      *out_shape_and_type->mutable_type() = p.type;
    }
  }
  string str_data;
  handle_data.SerializeToString(&str_data);

func createServerEndpoints(serverAddr string, poolArgs []poolDisksLayout, legacy bool) (
	endpointServerPools EndpointServerPools, setupType SetupType, err error,
) {
	if len(poolArgs) == 0 {
		return nil, -1, errInvalidArgument
	}

	poolEndpoints, setupType, err := CreatePoolEndpoints(serverAddr, poolArgs...)
	if err != nil {
		return nil, -1, err
	}

	for i, endpointList := range poolEndpoints {

                final IndexRequestBuilder indexRequestBuilder = new IndexRequestBuilder(client, IndexAction.INSTANCE, index);
                indexRequestBuilder.setId(item.getId())
                        .setOpType(IndexRequest.OpType.INDEX)
                        .setSource(item.getUpdatedSource(getResponse.getSourceAsMap()));
                bulkRequestBuilder.add(indexRequestBuilder);
            } else {

                    break;
                }
                if (ch == '#') {
                    state = ST_COMM;
                    break;
                }
                state = ST_TYPE;
            case ST_TYPE:
                if (ch == ' ' || ch == '\t') {
                    state = ST_GAP;
                } else {
                    type[t++] = ch;
                }
                break;

			}
			pools, setupType, err := CreatePoolEndpoints(testCase.serverAddr, srvCtxt.Layout.pools...)
			if err == nil && testCase.expectedErr != nil {
				t.Errorf("Test %d: expected = %v, got = <nil>", i+1, testCase.expectedErr)
			}
			if err == nil {
				if setupType != testCase.expectedSetupType {
					t.Errorf("Test %d: setupType: expected = %v, got = %v", i+1, testCase.expectedSetupType, setupType)

     */
    public void testSet() throws Exception {
        final Method m1 = SetType.class.getMethod("setOfString");
        final Type t1 = m1.getGenericReturnType();
        assertThat(GenericsUtil.isTypeOf(t1, Set.class), is(true));
        assertThat(GenericsUtil.getElementTypeOfSet(t1), is(sameClass(String.class)));

        final Method m2 = SetType.class.getMethod("setOfClass");
        final Type t2 = m2.getGenericReturnType();

     * @return the parsed sitemap set
     */
    protected SitemapSet parseTextSitemaps(final InputStream in) {
        final SitemapSet sitemapSet = new SitemapSet();
        sitemapSet.setType(SitemapSet.URLSET);

        try {
            final BufferedReader br = new BufferedReader(new InputStreamReader(in, Constants.UTF_8));
            String line;
            while ((line = br.readLine()) != null) {

	env.RegisterGlobalCAs(globalRootCAs)

	globalEndpoints, setupType, err = createServerEndpoints(globalMinioAddr, ctxt.Layout.pools, ctxt.Layout.legacy)
	logger.FatalIf(err, "Invalid command line arguments")
	globalNodes = globalEndpoints.GetNodes()

	globalIsErasure = (setupType == ErasureSetupType)
	globalIsDistErasure = (setupType == DistErasureSetupType)
	if globalIsDistErasure {
		globalIsErasure = true
	}

                    .setIgnoreIdleThreads(ignoreIdleThreads)
                    .setInterval(interval)
                    .setThreads(threads)
                    .setTimeout(timeout)
                    .setType(type)
                    .execute()
                    .actionGet(timeout);
            append(buf, "cluster_name", () -> response.getClusterName().value()).append(',');

        return sitemapList.toArray(new Sitemap[sitemapList.size()]);
    }

    /**
     * Sets the type of this sitemap set.
     * @param type the type to set (URLSET or INDEX)
     */
    public void setType(final String type) {
        this.type = type;
    }

    /**
     * Checks if this sitemap set is of type URLSET.
     * @return true if this is a URLSET, false otherwise
     */
    public boolean isUrlSet() {