try {
            return configureTransport(Git.lsRemoteRepository()).setRemote(normalizeUri(gitSpec.getUrl())).setTags(tags).setHeads(heads).call();
        } catch (URISyntaxException | GitAPIException e) {
            throw wrapGitCommandException("ls-remote", gitSpec.getUrl(), null, e);
        }
    }

func updateDead(info *types.Info, dead map[ast.Node]bool, node ast.Node) {
	if dead[node] {
		// The node is already marked as dead.
		return
	}

	// setDead marks the node and all the children as dead.
	setDead := func(n ast.Node) {
		ast.Inspect(n, func(node ast.Node) bool {
			if node != nil {
				dead[node] = true
			}
			return true
		})
	}

	switch stmt := node.(type) {

    @Inject
    public DefaultConfigurableUserClassFilePermissions(int unixNumeric) {
        setRead(isRead(unixNumeric));
        setWrite(isWrite(unixNumeric));
        setExecute(isExecute(unixNumeric));
    }

    @Override
    public void unix(String unixSymbolic) {
        setRead(isRead(unixSymbolic));
        setWrite(isWrite(unixSymbolic));
        setExecute(isExecute(unixSymbolic));
    }

      }
      is_cpu_read = parsed_name.type == kCpuDeviceType;
      return success();
    }
  }
  is_cpu_read = false;
  return success();
}

// Get the reads to hoist in the `replicate`.
LogicalResult GetReads(FuncOp func, ReplicateOp replicate,
                       llvm::SmallVector<ReadVariableOp, 4>& reads) {
  for (Operation& op : replicate.getBody().front()) {
    if (auto read = llvm::dyn_cast<ReadVariableOp>(&op)) {

			strings.Join(args, " "), output, err)
	}

	files, err := ioutil.ReadDir(dir)
	if err != nil {
		return err
	}

	if len(b.revision) == 0 {
		// Done!
		volumeutil.SetReady(b.getMetaDir())
		return nil
	}

	var subdir string

	switch {
	case len(b.target) != 0 && filepath.Clean(b.target) == ".":
		// if target dir is '.', use the current dir

     * <p>
     * Read access grants the capability to view the contents of a file,
     * or to list the contents of a directory.
     */
    void setRead(boolean read);

    /**
     * Enables or disables write access to a file or directory for a certain class of users.
     * <p>
     * Write access grants the capability to modify or remove the contents of a file,

		// We had a watch error - that's no good
		return err
	case <-ctx.Done():
		return ctx.Err()
	default:
		// Valid configuration; set isReady to true and wait for modifications before checking again
		setReady(in.isReady)
		cniInstalls.With(resultLabel.Value(resultSuccess)).Increment()
		// Pod set to "NotReady" before termination
		return watcher.Wait(ctx)
	}
}

	}

	if !s.Mode().IsRegular() {
		klog.Errorf("ready-file is not a file: %s", readyFile)
		return false
	}

	return true
}

// SetReady creates a file called 'ready' in the given
// directory.  It logs an error if the file cannot be
// created.
func SetReady(dir string) {
	if err := os.MkdirAll(dir, 0750); err != nil && !os.IsExist(err) {
		klog.Errorf("Can't mkdir %s: %v", dir, err)
		return
	}

  ResourceId GetResourceId() const { return resource_id_; }

  void SetAlloc() { effects_.set(kAlloc); }
  void SetFree() { effects_.set(kFree); }
  void SetRead() { effects_.set(kRead); }
  void SetWrite() { effects_.set(kWrite); }
  void SetUnknownEffect() { effects_.set(); }
  void SetResourceId(ResourceId resource_id) { resource_id_ = resource_id; }

	// If setting up the quota fails, just log a message but don't actually error out.
	// We'll use the old du mechanism in this case, at least until we support
	// enforcement.
	if err == nil {
		volumeutil.SetReady(ed.getMetaDir())
		err = ed.assignQuota(dir, mounterArgs.DesiredSize)
	}
	return err
}

// assignQuota checks if the underlying medium supports quotas and if so, sets