/*
Documented, #after
179099
public static <E> Supplier<E> after(final int count, final Supplier<E> function) {
        class AfterFunction implements Supplier<E> {
            private final int count;
            private final Supplier<E> localFunction;
            private int index;
            private E result;

            AfterFunction(final int count, final Supplier<E> function) {
                this.count = count;
                this.localFunction = function;
            }
            public E get() {
                if (++index >= count) {
                    result = localFunction.get();
                }
                return result;
            }
        }
        return new AfterFunction(count, function);
    }
55583
function afterExtends (klass, baseKlass, superFunc) {
    var newKlass = createNamedClass(klass.name, klass, baseKlass, superFunc);
    newKlass.prototype = createPrototype(klass, baseKlass, newKlass);
    
    return newKlass;
}
111105
function after(args) {
    const source = args.source;
    const index = args.index;
    const err = args.err;
    const errTarget = args.errTarget;
    const lineCheckStr = args.lineCheckStr;
    const onlyOneChar =
      args.onlyOneChar === undefined ? false : args.onlyOneChar;

    activeArgs = { source, index, err, errTarget, onlyOneChar };

    switch (expectation) {
      case "always":
        expectAfter();
        break;
      case "never":
        rejectAfter();
        break;
      case "always-single-line":
        if (!isSingleLineString(lineCheckStr || source)) {
          return;
        }

        expectAfter(messages.expectedAfterSingleLine);
        break;
      case "never-single-line":
        if (!isSingleLineString(lineCheckStr || source)) {
          return;
        }

        rejectAfter(messages.rejectedAfterSingleLine);
        break;
      case "always-multi-line":
        if (isSingleLineString(lineCheckStr || source)) {
          return;
        }

        expectAfter(messages.expectedAfterMultiLine);
        break;
      case "never-multi-line":
        if (isSingleLineString(lineCheckStr || source)) {
          return;
        }

        rejectAfter(messages.rejectedAfterMultiLine);
        break;
      default:
        throw configurationError(`Unknown expectation "${expectation}"`);
    }
  }
135251
protected function resolveAfter($after)
    {
        $getAfter = $this->resolveMiddleware($after);

        return function (Request $request, Response $response, Application $app) use ($getAfter) {
            $callback = $getAfter($request);
            if (!is_callable($callback)) {
                return null;
            }

            return $callback($request, $response, $app);
        };
    }
1085519
protected void afterParserOrEnumRuleCall() {
	ICompositeNode newCurrent = nodeBuilder.compressAndReturnParent(currentNode);
	if(currentNode == lastConsumedNode){
		lastConsumedNode = newCurrent;
	}
		currentNode = newCurrent;
    }
615481
def after(self, after):
        
        if after is None:
            raise ValueError("Invalid value for `after`, must not be `None`")
        if after is not None and not re.search('^[A-Za-z0-9]{32}', after):
            raise ValueError("Invalid value for `after`, must be a follow pattern or equal to `/^[A-Za-z0-9]{32}/`")

        self._after = after
1131905
def text_after(self, start, match_on):
        """"""
        text = ""
        index = start - 1
        while index > 0:
            text = self.code[index:start]
            if text.startswith(match_on):
                return text.lstrip(match_on)
            index -= 1

        return text.lstrip(match_on)
671315
public void after(Filter filter) {
        addFilter(HttpMethod.after, FilterImpl.create(SparkUtils.ALL_PATHS, filter));
    }
1219031
public function afterFind()
    {
        parent::afterFind();
        static::$propertyIdToKey[$this->id] = $this->key;
        static::$identityMap[$this->id] = $this;

        // cast scalar values
        $this->allow_multiple_values = (bool) $this->allow_multiple_values;
        $this->is_internal = (bool) $this->is_internal;
        $this->data_type = (int) $this->data_type;
        $this->property_handler_id = (int) $this->property_handler_id;
    }
513412
function expectSpaceAfter(token, pattern) {
            const nextToken = sourceCode.getTokenAfter(token);

            if (nextToken &&
                (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) &&
                !isCloseParenOfTemplate(nextToken) &&
                astUtils.isTokenOnSameLine(token, nextToken) &&
                !sourceCode.isSpaceBetweenTokens(token, nextToken)
            ) {
                context.report({
                    loc: token.loc.start,
                    messageId: "expectedAfter",
                    data: token,
                    fix(fixer) {
                        return fixer.insertTextAfter(token, " ");
                    }
                });
            }
        }
55870
function after(element, content) {
  if (isString(content)) {
    return element.insertAdjacentHTML('afterEnd', content);
  } else {
    // when the second parameter of 'insertBefore' is 'null' the content is
    // appended to the end of the 'parentNode'.
    return element.parentNode.insertBefore(normalizeContent(content), element.nextSibling);
  }
}
249172
def include_after(predicate, num, iterative):
    
    (it0, it1) = itertools.tee(iterative)
    ps = _forward_shifted_predicate(predicate, num, it1)
    return (e for (e, p) in zip(it0, ps) if p)
795610
public static boolean after(final Date point, final Date when)
	{
		final Calendar pointCalendar = Calendar.getInstance();
		pointCalendar.setTime(point);
		final Calendar whenCalendar = Calendar.getInstance();
		whenCalendar.setTime(when);
		return pointCalendar.after(whenCalendar);
	}
280146
public function after($response)
	{
		// If nothing was returned default to the template
		if ($response === null)
		{
			$response = $this->template;
		}

		return parent::after($response);
	}
1211945
@Override
	public void afterPropertiesSet() throws Exception {
		super.afterPropertiesSet();
		Assert.notNull(sql, "The SQL query must be provided");
		Assert.notNull(rowMapper, "RowMapper must be provided");
	}
1061490
function after(yd){
  var res;

  yd = Resolver.when(yd);
  if(yd[yielded]) return yd[yielded];
  res = new Resolver();
  yd.listen(res.accept,[],res);
  return yd[yielded] = res.yielded;
}
965716
function runWithAfter (ret, runWith) {
    // after original promise resolves then run after methods
    return ret.then(res => {
        // wait for all extension methods to complete
        return Promise.all(runWith)
        // merge returned data into original
        .then(function (results) {
            // either merge or replace result
            _.each(results, result => {
                // both original res and after result are objects
                if (typeof res === 'object' && res !== null && typeof result === 'object' && result !== null) {
                    // merge after into original
                    _.merge(res, result)
                }
                // one is not an object
                else if (result !== undefined) {
                    // replace original with after
                    res = result
                }
            })
            // return final result
            return res
        })
    })
}