return (ComponentState) selected;
        }
        if (selected instanceof NodeState) {
            return ((NodeState) selected).getComponent();
        }
        throw new IllegalArgumentException("Cannot extract a ComponentState from " + selected.getClass());
    }


    private final Collection<? extends ModuleIdentifier> participatingModules;
    private final ComponentState selected;

	} `yaml:"ftp"`
	SFTP struct {
		Address       string `yaml:"address"`
		SSHPrivateKey string `yaml:"ssh-private-key"`
	} `yaml:"sftp"`
}

// ServerConfigVersion struct is used to extract the version
type ServerConfigVersion struct {
	Version string `yaml:"version"`
}

// ServerConfigCommon struct for server config common options
type ServerConfigCommon struct {
	RootUser    string `yaml:"rootUser"`

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.model.internal.manage.schema.extract

import org.gradle.model.RuleSource
import org.gradle.model.internal.manage.schema.CompositeSchema
import org.gradle.model.internal.manage.schema.ManagedImplSchema

        // Must rename to "*.tgz" for unpacking to work
        def tgzCacheEntry = temporaryFolder.file("cache.tgz")
        cacheEntry.copyBytesTo(tgzCacheEntry)
        def extractDir = temporaryFolder.file("extract")
        tgzCacheEntry.untarTo(extractDir)
        tgzCacheEntry.delete()

        def metadata = new Properties()
        extractDir.file("METADATA").withInputStream { input ->
            metadata.load(input)

        // withFileLock prevents other processes from extracting into the expandedDir at the same time
        // but multiple threads in this process could still try to extract into the same directory.
        cache.withFileLock(() -> {
            // guardByKey prevents multiple threads in this process from extracting into the same directory at the same time.

			if f, ok := d.(*ast.FuncDecl); ok && f.Name.Name == functionname {
				fun = f
				return
			}
		}
	}
	panic("function not found")
}

func printSelf() {
	// Parse source file and extract the AST without comments for
	// this function, with position information referring to the
	// file set fset.
	funcAST, fset := parseFunc("example_test.go", "printSelf")

	// Print the function body into buffer buf.

        """
        elt = self.element.find('sts:{}'.format(name), _STS_NS)
        return STSElement(self.root_name, elt) if elt is not None else None

    def get_child_text(self, name, strict=True):
        """Extract text of a child element. If strict, and child element is
        not present, raises InvalidXMLError and otherwise returns
        None.

        """
        if strict:
            try:

			},
			expectedIDs:    nil,
			expectedErrMsg: "failed to extract identities from SAN extension (error asn1: syntax error: data truncated)",
		},
		"Extensions with incorrectly encoded SAN": {
			exts: []pkix.Extension{
				{Id: asn1.ObjectIdentifier{2, 5, 29, 17}, Value: append(copyBytes(sanExt.Value), 'x')},
			},
			expectedIDs:    nil,

    /**
     * Pattern to extract task output.
     */
    private static final Pattern TASK_OUTPUT_PATTERN = patternForHeader(TASK_HEADER);

    /**
     * Pattern to extract task output.
     */
    private static final Pattern TRANSFORM_OUTPUT_PATTERN = patternForHeader(TRANSFORM_HEADER);

	// If there is no match, "" is returned.
	originalValue := func(value string) string {
		match := rDeprecated.FindStringSubmatch(value)
		if len(match) < 2 {
			return ""
		}
		return match[1]
	}
	// extract deprecated aliases for existing analyses
	for _, flag := range analysisFlags {
		if o := originalValue(flag.Usage); analyzerSet[o] {
			analyzerSet[flag.Name] = true
		}
	}

	var analyzers []string