# 📨 👔 📟

🎏 🌌 👆 💪 ✔ 📨 🏷, 👆 💪 📣 🇺🇸🔍 👔 📟 ⚙️ 📨 ⏮️ 🔢 `status_code` 🙆 *➡ 🛠️*:

* `@app.get()`
* `@app.post()`
* `@app.put()`
* `@app.delete()`
* ♒️.

```Python hl_lines="6"
{!../../docs_src/response_status_code/tutorial001.py!}
```

/// note

👀 👈 `status_code` 🔢 "👨‍🎨" 👩‍🔬 (`get`, `post`, ♒️). 🚫 👆 *➡ 🛠️ 🔢*, 💖 🌐 🔢 & 💪.

///

`status_code` 🔢 📨 🔢 ⏮️ 🇺🇸🔍 👔 📟.

/// info

 * implementing {@code Map}, the additional type-safe operations {@link #putInstance} and {@link
 * #getInstance} are available.
 *
 * <p>Generally, implementations don't support {@link #put} and {@link #putAll} because there is no
 * way to check an object at runtime to be an instance of a {@link TypeToken}. Instead, caller
 * should use the type safe {@link #putInstance}.
 *

      if (frequency == null) {
        frequency = 0;
      }
      if (occurrences == 0) {
        return frequency;
      }
      checkArgument(occurrences <= Integer.MAX_VALUE - frequency);
      backingMap.put(element, frequency + occurrences);
      return frequency;
    }

    @Override
    Iterator<E> elementIterator() {
      return Multisets.elementIterator(entryIterator());
    }

    @Override

                addr = new NbtAddress( name, ip, false, NbtAddress.B_NODE,
                                    false, false, true, true,
                                    NbtAddress.UNKNOWN_MAC_ADDRESS );
                TAB.put( name, addr );
            }
        }
    }

 * implementing {@code Map}, the additional type-safe operations {@link #putInstance} and {@link
 * #getInstance} are available.
 *
 * <p>Generally, implementations don't support {@link #put} and {@link #putAll} because there is no
 * way to check an object at runtime to be an instance of a {@link TypeToken}. Instead, caller
 * should use the type safe {@link #putInstance}.
 *

            {
                for ( java.util.Iterator it = expressions.iterator(); it.hasNext(); )
                {
                    Expression expr = (Expression) it.next();

                    expressionsBySyntax.put( expr.getSyntax(), expr );
                }
            }
        }

        return expressionsBySyntax;
    }

    public void flushExpressionsBySyntax()
    {
        expressionsBySyntax = null;
    }

// Target - store target interface
type Target interface {
	Name() string
	SendFromStore(key Key) error
}

// Store - Used to persist items.
type Store[I any] interface {
	Put(item I) (Key, error)
	PutMultiple(item []I) (Key, error)
	Get(key Key) (I, error)
	GetMultiple(key Key) ([]I, error)
	GetRaw(key Key) ([]byte, error)
	PutRaw(b []byte) (Key, error)
	Len() int
	List() []Key

		if s.skipCount > l && l < copyBufferSize {
			// We may get a very small buffer, so we grab a temporary buffer.
			bufp := copyBufPool.Get().(*[]byte)
			buf := *bufp
			tmp = buf[:copyBufferSize]
			defer copyBufPool.Put(bufp)
			l = int64(len(tmp))
		}
		for s.skipCount > 0 {
			if l > s.skipCount {
				l = s.skipCount
			}
			n, err := s.Reader.Read(tmp[:l])
			if err != nil {
				return 0, err
			}

   * typically useful for {@code return} statements. That leaves the code with two options: Either
   * add the suppression to the whole method (which turns off checking for a large section of code),
   * or extract a variable, and put the suppression on that. However, a local variable typically
   * doesn't work: Because nullness analyses typically infer the nullness of local variables,

              synchronized (loadedClasses) {
                Class<?> toReturn = loadedClasses.get(name);
                if (toReturn == null) {
                  toReturn = super.findClass(name);
                  loadedClasses.put(name, toReturn);
                }
                return toReturn;
              }
            }
            return super.loadClass(name);
          }
        };