}
			names = append(names, attrs...)
		} else {
			names = append(names, name)
		}
		var data [][]string
		for _, attr := range names {
			value, err := getxattr(path, attr)
			if err != nil {
				data = append(data, []string{attr, errors.Unwrap(err).Error()})
			} else {
				data = append(data, []string{attr, fmt.Sprintf("%d", value)})
			}
		}
		table.AppendBulk(data) // Add Bulk Data

    val prefixes: MutableSet<String> = hashSetOf()

    private
    val names: MutableSet<String> = hashSetOf()

    init {
        givenPrefixes.map { it.replace('.', '/') }.forEach { internalName ->
            names.add(internalName)
            prefixes.add("$internalName/")
        }
    }

    fun matches(packageName: String): Boolean {
        if (names.contains(packageName)) {
            return true
        }

    #   [true]
    #     Add schema to table SQL name. (The table name on query is SCHEMA.TABLE)
    #
    #; isAvailableAddingSchemaToTableSqlName = false
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o isAvailableAddingCatalogToTableSqlName: (NotRequired - Default false)
    #   [true]
    #     Add catalog to table SQL name. (The table name on query is CATALOG.SCHEMA.TABLE)
    #

    /**
     * Add a header with the specified name and formatted date. Does validation of header names and
     * value.
     */
    fun add(
      name: String,
      value: Date,
    ) = add(name, value.toHttpDateString())

    /**
     * Add a header with the specified name and formatted instant. Does validation of header names
     * and value.
     */

<img src="/img/tutorial/generate-clients/image06.png">

In this case you have:

* `ItemsService`
* `UsersService`

### Client Method Names

Right now the generated method names like `createItemItemsPost` don't look very clean:

```TypeScript
ItemsService.createItemItemsPost({name: "Plumbus", price: 5})
```

...that's because the client generator uses the OpenAPI internal **operation ID** for each *path operation*.

#
# This property uses classification names of classificationDefinitionMap.
# The table name '$$ALL$$' means all tables are target.
# The table names and column names are treated as case insensitive.
#
# You don't need specify here about table classifications.
# Because table classifications are auto-deployed by relation information.
#
# Specification:
# map: {
#     [table-name or $$ALL$$] = map:{

	if !reflect.DeepEqual(names, want) {
		t.Errorf("got unexpected result: %#v", names)
	}
	err = r.skip(5)
	if err != nil {
		t.Fatal(err)
	}
	names, err = r.readNames(5)
	if err != nil {
		t.Fatal(err)
	}
	want = loadMetacacheSampleNames[10:15]
	if !reflect.DeepEqual(names, want) {
		t.Errorf("got unexpected result: %#v", names)
	}

                c.createNewFile();

                String[] names = f.list();
                assertNotNull(names);
                assertEquals(3, names.length);
                Arrays.sort(names);
                Assert.assertArrayEquals(new String[] {
                    "a", "b", "c"
                }, names);

                SmbFile[] files = f.listFiles();
                assertNotNull(files);

        public rpc.unicode_string name;
        public rpc.sid_t sid;


        @Override
        public void encode ( NdrBuffer _dst ) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_short(this.name.length);
            _dst.enc_ndr_short(this.name.maximum_length);
            _dst.enc_ndr_referent(this.name.buffer, 1);
            _dst.enc_ndr_referent(this.sid, 1);

		return false
	})

	for _, c := range cs {
		// show warning message the callback name already exists
		if idx := getRIndex(names, c.name); idx > -1 && !c.replace && !c.remove && !cs[idx].remove {
			c.processor.db.Logger.Warn(context.Background(), "duplicated callback `%s` from %s\n", c.name, utils.FileWithLineNum())
		}
		names = append(names, c.name)
	}

	sortCallback = func(c *callback) error {