public class MappedList<U, V> extends AbstractList<U> {
    private final List<V> list;
    private final Function<V, U> mapper;

    public MappedList(List<V> list, Function<V, U> mapper) {
        this.list = list;
        this.mapper = mapper;
    }

    @Override
    public U get(int index) {
        return mapper.apply(list.get(index));
    }

    @Override
    public int size() {
        return list.size();
    }

	mapper := NewDefaultRESTMapper([]schema.GroupVersion{expectedGroupVersion1, expectedGroupVersion2})
	mapper.Add(expectedGroupVersion1.WithKind("InternalObject"), RESTScopeNamespace)
	mapper.Add(expectedGroupVersion2.WithKind("OtherObject"), RESTScopeNamespace)

	// pick default matching object kind based on search order
	mapping, err := mapper.RESTMapping(otherObjectGK)
	if err != nil {

		if path[0] == "" {
			return nil, false, fmt.Errorf("getFromStructPath path %s, empty map key value", path)
		}
		mapVal := val.MapIndex(reflect.ValueOf(path[0]))
		if !mapVal.IsValid() {
			return nil, false, fmt.Errorf("getFromStructPath path %s, path does not exist", path)
		}
		return getFromStructPath(mapVal.Interface(), path[1:])
	case reflect.Slice:
		idx, err := strconv.Atoi(path[0])
		if err != nil {

	return int(right >> 62)
}

func capver(rights *CapRights) int {
	return caprver(rights.Rights[0])
}

func caparsize(rights *CapRights) int {
	return capver(rights) + 2
}

// CapRightsSet sets the permissions in setrights in rights.
func CapRightsSet(rights *CapRights, setrights []uint64) error {
	// This is essentially a copy of cap_rights_vset()
	if capver(rights) != CAP_RIGHTS_VERSION_00 {

    @Test
    public void testRenameWithCapture() {
        RegExpNameMapper mapper = new RegExpNameMapper("(.+).java", "$1Test.java");
        assertEquals("SourceTest.java", mapper.transform("Source.java"));
        assertEquals("SecondTest.java", mapper.transform("Second.java"));
    }

    @Test
    public void testRenameNoMatch() {
        RegExpNameMapper mapper = new RegExpNameMapper("(.+).java", "$1Test.java");

			},
			result: schema.GroupVersionResource{Group: "one", Version: "a", Resource: "second"},
		},
	}

	for _, tc := range tcs {
		mapper := PriorityRESTMapper{Delegate: tc.delegate, ResourcePriority: tc.resourcePatterns}

		actualResult, actualErr := mapper.ResourceFor(schema.GroupVersionResource{})
		if e, a := tc.result, actualResult; e != a {
			t.Errorf("%s: expected %v, got %v", tc.name, e, a)
		}

public class MappedCollection<U, V> extends AbstractCollection<U> {
    private final Collection<V> list;
    private final Function<V, U> mapper;

    public MappedCollection(Collection<V> list, Function<V, U> mapper) {
        this.list = list;
        this.mapper = mapper;
    }

    @Override
    public Iterator<U> iterator() {
        Iterator<V> it = list.iterator();
        return new Iterator<U>() {

}

// ToRESTMapper implements RESTClientGetter.
// Returns a mapper.
func (f *TestConfigFlags) ToRESTMapper() (meta.RESTMapper, error) {
	if f.restMapper != nil {
		return f.restMapper, nil
	}
	if f.discoveryClient != nil {
		mapper := restmapper.NewDeferredDiscoveryRESTMapper(f.discoveryClient)
		expander := restmapper.NewShortcutExpander(mapper, f.discoveryClient, nil)
		return expander, nil
	}

	"istio.io/istio/pkg/util/protomarshal"
)

func TestCleanupEmptyMaps(t *testing.T) {
	tc := []struct {
		name  string
		given func() Mapper
		want  func() *matcher.Matcher
	}{
		{
			name: "empty map at depth = 0",
			given: func() Mapper {
				// root (dest port):
				//   <no matches>
				//   fallback (dest ip):
				//     1.2.3.4: chain
				fallback := NewDestinationIP()

							<mapper>
								<type>perm</type>
								<user>${packaging.fess.user}</user>
								<group>${packaging.fess.group}</group>
							</mapper>
						</data>
						<data>
							<type>directory</type>
							<src>${project.build.directory}/fess/WEB-INF/classes/org/codelibs/fess/tomcat</src>
							<mapper>
								<type>perm</type>