policyToRule[name][rule] = struct{}{}
	}

	for _, parsed := range parsedListeners {
		for _, fc := range parsed.filterChains {
			for _, rbacHTTP := range fc.rbacHTTP {
				action := rbacHTTP.GetRules().GetAction()
				for name := range rbacHTTP.GetRules().GetPolicies() {
					nameOfPolicy, indexOfRule := extractName(name)
					addPolicy(action, nameOfPolicy, indexOfRule)
				}

    int nextEntryOffset;
    int action;
    int fileNameLength;
    String fileName;


    /**
     * 
     */
    public FileNotifyInformationImpl () {}


    @Override
    public int getAction () {
        return this.action;
    }


    @Override
    public String getFileName () {
        return this.fileName;
    }


    /**
     * @return the nextEntryOffset
     */

     * The operating system detects a change in file size only when the file is written to the disk. For operating
     * systems that use extensive caching, detection occurs only when the cache is sufficiently flushed.s
     */
    public static final int FILE_NOTIFY_CHANGE_SIZE = 0x00000008;

    /**

     * @return the deviceState
     */
    public final int getDeviceState () {
        return this.deviceState;
    }


    /**
     * @return the action
     */
    public final int getAction () {
        return this.action;
    }


    /**
     * @return the serverFid
     */
    public final int getServerFid () {
        return this.serverFid;
    }


    /**

        if ( infos != null ) {
            infos.addAll(notifications);
        }
        boolean found = false;
        for ( FileNotifyInformation fi : notifications ) {
            if ( fi.getAction() == action && fi.getFileName().equals(name) ) {
                found = true;
            }
        }
        return found;
    }

				route.Name = fmt.Sprintf("route/%s", route.Name)
			}
			if filter.Verbose {
				for _, vhosts := range route.GetVirtualHosts() {
					for _, r := range vhosts.Routes {
						if !isPassthrough(r.GetAction()) {
							fmt.Fprintf(w, "%v\t%s\t%s\t%s\t%s\n",
								route.Name,
								vhosts.Name,
								describeRouteDomains(vhosts.GetDomains()),
								describeMatch(r.GetMatch()),

		return ""
	}
	if len(vh.GetRoutes()) != 1 {
		return ""
	}
	r := vh.GetRoutes()[0]
	if r.GetMatch().GetPrefix() != "/" {
		return ""
	}
	a, ok := r.GetAction().(*route.Route_Route)
	if !ok {
		return ""
	}
	cl, ok := a.Route.ClusterSpecifier.(*route.RouteAction_Cluster)
	if !ok {
		return ""
	}
	if strings.Contains(cl.Cluster, "Cluster") {

	"strings"
	"time"
)

const (
	// deadline (in seconds) up to which the go routine leak detection has to be retried.
	leakDetectDeadline = 5
	// pause time (in milliseconds) between each snapshot at the end of the go routine leak detection.
	leakDetectPauseTimeMs = 50
)

// LeakDetect - type with  methods for go routine leak detection.
type LeakDetect struct {
	relevantRoutines map[string]bool
}

      matrix:
        # Override automatic language detection by changing the below list
        # Supported options are ['csharp', 'cpp', 'go', 'java', 'javascript', 'python']
        language: ['java']
        # Learn more...
        # https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#overriding-automatic-language-detection

    steps:
    - name: Checkout repository

      }
    },

    /**
     * Disables cycle detection. This option causes the factory to return unmodified lock
     * implementations provided by the JDK, and is provided to allow applications to easily
     * parameterize when cycle detection is enabled.
     *
     * <p>Note that locks created by a factory with this policy will not participate the
     * cycle detection performed by locks created by other factories.
     */