} catch (UnsupportedOperationException e) {
                                            if (debugEnabled && logger != null) {
                                                logger.debug("Skipping interpolation of field: " + field + " in: "
                                                        + cls.getName()
                                                        + "; it is an unmodifiable collection.");

This is in contrast to the **development** stages, where you are constantly changing the code, breaking it and fixing it, stopping and restarting the development server, etc.

## Deployment Strategies { #deployment-strategies }

There are several ways to do it depending on your specific use case and the tools that you use.

        if (!policy.isEnabled()) {
            if (getLogger().isDebugEnabled()) {
                getLogger()
                        .debug("Skipping update check for " + artifact + " (" + file + ") from " + repository.getId()
                                + " (" + repository.getUrl() + ")");
            }

            return false;
        }

		if err != nil {
			if err == io.EOF {
				if extracted {
					return nil
				}
				return errors.New("no data found on stream")
			}
			if errors.Is(err, estream.ErrNoKey) {
				fmt.Println("Skipping", stream.Name, "no private key")
				if err := stream.Skip(); err != nil {
					return fmt.Errorf("stream skip: %w", err)
				}
				continue
			}
			return fmt.Errorf("next stream: %w", err)
		}

   * blocks, it can prevent this service from changing state. If you need to performing a blocking
   * operation in order to trigger shutdown, consider instead registering a listener and
   * implementing {@code stopping}. Note, however, that {@code stopping} does not run at exactly the
   * same times as {@code triggerShutdown}.
   */
  protected void triggerShutdown() {}

  /**

    this.lockLikeObject = checkNotNull(lockLikeObject);
    start();
  }

  // Thread.stop() is okay because all threads started by a test are dying at the end of the test,
  // so there is no object state put at risk by stopping the threads abruptly. In some cases a test
  // may put a thread into an uninterruptible operation intentionally, so there is no other way to
  // clean up these threads.
  @SuppressWarnings("deprecation")
  @Override

	}

	for loc, expectedDiskName := range expectedDisksName {
		diskName := actualDisksName[loc]
		if diskName == "" {
			log.Printf("skipping disk location `%s`, err: %v\n", diskName, err)
			continue
		}
		mami, err := getMajorMinor(diskName)
		if err != nil {
			log.Printf("skipping `%s`, err: %v\n", diskName, err)
			continue
		}
		devName := mountMap[mami]
		uuid := uuidMap[devName]

    ;;

    *)
        echo "pre remove script called with unknown argument \`$1'" >&2
        exit 1
    ;;
esac

# Stops the service
if [ "$STOP_REQUIRED" = "true" ]; then
    echo -n "Stopping fess service..."
    if command -v systemctl >/dev/null; then
        systemctl --no-reload stop fess.service > /dev/null 2>&1 || true

    elif [ -x /etc/init.d/fess ]; then

        Set<Feature<?>> missingFeatures = copyToSet(requirements.getPresentFeatures());
        missingFeatures.removeAll(features);
        logger.finer(
            Platform.format(
                "%s: skipping because these features are absent: %s", method, missingFeatures));
      }
      return false;
    }
    if (intersect(features, requirements.getAbsentFeatures())) {
      if (logger.isLoggable(FINER)) {

					return layout, err
				}
			}
		}

		var stopping bool
		var singleNode bool
		var eps []string

		for i := 0; ; i++ {
			for _, node := range endpointsList {
				if node.nodeName == "" {
					singleNode = true
				}

				if len(node.disks) <= i {
					stopping = true
					continue
				}
				if stopping {
					return layout, errors.New("number of disks per node does not match")