*/
internal sealed class Tags {
  /**
   * Returns a tags instance that maps [key] to [value]. If [value] is null, this returns a tags
   * instance that does not have any mapping for [key].
   */
  abstract fun <T : Any> plus(
    key: KClass<T>,
    value: T?,
  ): Tags

  abstract operator fun <T : Any> get(key: KClass<T>): T?
}

/** An empty tags. This is always the tail of a [LinkedTags] chain. */

## Metadata for tags { #metadata-for-tags }

You can also add additional metadata for the different tags used to group your path operations with the parameter `openapi_tags`.

It takes a list containing one dictionary for each tag.

Each dictionary can contain:

* `name` (**required**): a `str` with the same tag name you use in the `tags` parameter in your *path operations* and `APIRouter`s.

        .plus(Boolean::class, null)
    assertThat(tags).isEqualTo(EmptyTags)
    assertThat(tags.toString()).isEqualTo("{}")
  }

  @Test
  fun removeAbsentFromEmpty() {
    val tags = EmptyTags.plus(String::class, null)
    assertThat(tags).isEqualTo(EmptyTags)
    assertThat(tags.toString()).isEqualTo("{}")
  }

  @Test
  fun removeAbsentFromNonEmpty() {
    val tags =
      EmptyTags

		ilmNewerNoncurrentVersions = "ilm-newer-noncurrent-versions"
		ilmNoncurrentDays          = "ilm-noncurrent-days"
	)
	tags := make(map[string]string, 5)
	if src > lcEventSrc_None {
		tags[ilmSrc] = src.String()
	}
	tags[ilmAction] = event.Action.String()
	tags[ilmRuleID] = event.RuleID

	if !event.Due.IsZero() {
		tags[ilmDue] = event.Due.Format(iso8601Format)
	}

	// rule with Transition/NoncurrentVersionTransition in effect

     */
    public List<String> getWordList(final SearchRequestType searchRequestType, final String seed, final String[] tags, final String[] roles,
            final String[] fields, final String[] excludes) {
        final String baseSeed = seed != null ? seed : fessConfig.getSuggestPopularWordSeed();
        final String[] baseTags = tags != null ? tags : fessConfig.getSuggestPopularWordTagsAsArray();
        final String[] baseRoles = roles != null ? roles

from enum import Enum

from fastapi import FastAPI

app = FastAPI()


class Tags(Enum):
    items = "items"
    users = "users"


@app.get("/items/", tags=[Tags.items])
async def get_items():
    return ["Portal gun", "Plumbus"]


@app.get("/users/", tags=[Tags.users])
async def read_users():

	defer r.Unlock()
	// Search of tag key already exists in tags
	var updated bool
	for _, tag := range r.tags {
		if tag.Key == key {
			tag.Val = val
			updated = true
			break
		}
	}
	if !updated {
		// Append to the end of tags list
		r.tags = append(r.tags, KeyVal{key, val})
	}
	return r
}

// GetTags - returns the user defined tags
func (r *ReqInfo) GetTags() []KeyVal {
	if r == nil {

			return err
		}
	}
	return nil
}

// TestTags tests if the object tags satisfy the Filter tags requirement,
// it returns true if there is no tags in the underlying Filter.
func (f *Filter) TestTags(userTags string) bool {
	if f.cachedTags == nil {
		cached := make(map[string]string)
		for _, t := range append(f.And.Tags, f.Tag) {
			if !t.IsEmpty() {
				cached[t.Key] = t.Value
			}
		}
		f.cachedTags = cached
	}

    }

    /**
     * Gets the custom pre-tags for highlighting.
     *
     * @return the pre-tags array, or null if using defaults
     */
    public String[] getPreTags() {
        return preTags;
    }

    /**
     * Sets the custom pre-tags for highlighting with fluent interface.
     *
     * @param preTags the pre-tags to set
     * @return this HighlightInfo instance for method chaining

        this.fields = fields;
        if (tags == null) {
            this.tags = Collections.emptyList();
        } else {
            this.tags = tags;
        }
        if (roles == null) {
            this.roles = Collections.emptyList();
        } else {
            this.roles = roles;
        }
    }

    /**
     * Returns the elevate word.
     *
     * @return the elevate word
     */