Fallback implementation.
189646
@Override
  protected void visitSoyNode(SoyNode node) {
    if (isComputableAsJsExprsVisitor.exec(node)) {
      // Simply generate JS expressions for this node and add them to the current output var.
      jsCodeBuilder.addChunksToOutputVar(genJsExprsVisitor.exec(node));

    } else {
      // Need to implement visit*Node() for the specific case.
      throw new UnsupportedOperationException("implement visit*Node for" + node.getKind());
    }
  }
390065
private function addParameterFallback($name, $fallbackData = null)
    {
        if (!isset($this->parameters[$name]) && !empty($fallbackData)) {
            $this->parameters[$name] = $fallbackData;
        }
    }
1119889
private <T> T nullableWithFallback(final T first, final T second) {
    return first != null ? first : second;
  }
1248279
public boolean loadFallback() {
        try {
            if (fallbackLocation == null) {
                Logger.getLogger(getClass().getName()).warning("No fallback resource for " + this +
                        ", loadFallback not supported.");
                return false;
            }
            load(fallbackLocation, true);
            clearCache();
            return true;
        } catch (Exception e) {
            LOG.log(Level.SEVERE, "Failed to load fallback resource: " + fallbackLocation, e);
        }
        return false;
    }
1052346
public RolloutOptions withFallback(final RolloutOptions that) {
    return RolloutOptions.newBuilder()
        .setTimeout(firstNonNull(timeout, that.timeout))
        .setParallelism(firstNonNull(parallelism, that.parallelism))
        .setMigrate(firstNonNull(migrate, that.migrate))
        .setOverlap(firstNonNull(overlap, that.overlap))
        .setToken(firstNonNull(token, that.token))
        .setIgnoreFailures(firstNonNull(ignoreFailures, that.ignoreFailures))
        .build();
  }
218747
public static function fallback()
    {
        return function() {
            return Promise\promise_for(
                new Configuration(
                    self::DEFAULT_ENABLED,
                    self::DEFAULT_PORT,
                    self::DEFAULT_CLIENT_ID
                )
            );
        };
    }
169754
function createFallbacks(options) {
  var bootstrapSrc = options.bootstrapSrc;

  if (options.useFallbacks && options.verbose) {
    console.log("Creating fallbacks if they are necessary..");
  }

  return getManifest({
    addonDir: options.addonDir
  }).then(function(manifest) {
    return when.all([
      options.needsInstallRDF ? when.resolve(
        RDF.createRDF(manifest, options.needsBootstrapJS)) : when.resolve(),
      options.needsBootstrapJS ? when.resolve(
        fs.readFile(bootstrapSrc)) : when.resolve(),
    ]).then(function(fallbacks) {
      if (fallbacks) {
        return {
          installRDF: fallbacks[0],
          bootstrapJS: fallbacks[1]
        };
      }
    });
  });
}
1022756
function rollback(client, done, error, callback) {
  client.query('ROLLBACK', rollbackError => {
    done(rollbackError);
    return callback(rollbackError || error, null);
  });
}
1125148
public function setFallback($fallback = null)
    {
        if ($fallback === null) {
            $this->fallback = __DIR__.'/images/error.jpg';
        } else {
            $this->fallback = $fallback;
        }

        return $this;
    }
381535
public function use_fallback($boolean = NULL)
	{
		if ($boolean === NULL)
		{
			return $this->_use_fallback;
		}
		$this->_use_fallback = $boolean;
		return $this;
	}
1315098
function list(body, ordered) {
  if (inList()) return body + endList();
  return fallback.list.call(this, body, ordered);
}
397272
function (translationId, interpolateParams, Interpolator, sanitizeStrategy) {
      // Start with the fallbackLanguage with index 0
      return resolveForFallbackLanguageInstant((startFallbackIteration > 0 ? startFallbackIteration : fallbackIndex), translationId, interpolateParams, Interpolator, sanitizeStrategy);
    }
1025507
function fallbackResolve(path, root) {
  let steps = path.split("/")
  let node = root
  while (node) {
    let step = steps.shift()
    if (step === undefined) break
    if (step === '.') continue
    let [name, position] = step.split(/[\[\]]/)
    name = name.replace('_default_:', '')
    position = position ? parseInt(position) : 1
    node = findChild(node, name, position)
  }
  return node
}
781400
@Override
    @Deprecated
    public void fallback(AllocationPoint point, AllocationShape shape) {
        throw new IllegalStateException("Can't fallback from [" + point.getAllocationStatus() + "]");
    }
339520
def handle_fallback(*args)
      case @fallback_policy
      when :abort
        raise RejectedExecutionError
      when :discard
        false
      when :caller_runs
        begin
          yield(*args)
        rescue => e
          Chef::Log.debug "Caught exception => #{e}"
        end
        true
      else
        fail "Unknown fallback policy #{@fallback_policy}"
      end
    end
677873
@SuppressWarnings("unchecked")
  public static <R> Fallback<R> ofAsync(CheckedFunction<ExecutionAttemptedEvent<? extends R>, ? extends R> fallback) {
    return new Fallback<>(Assert.notNull((CheckedFunction) fallback, "fallback"), true);
  }
375307
public static <S extends Node, E extends Event> void installFallback(InputMapTemplate<S, E> imt, S node) {
        Nodes.addFallbackInputMap(node, imt.instantiate(node));
    }