/* Send cached version of compilation
504006
public function sendCache()
    {
        if (!file_exists($this->pathHtmlCache.$this->name.'_cache.html')) {
            $this->cached = true;
            return $this;
        }

        $this->setContent(file_get_contents($this->pathHtmlCache.$this->name.'_cache.html'));
        $this->send();
    }
399992
def _cached_replace_compile(pattern, repl, flags, pattern_type):
    """"""

    return _bregex_parse._ReplaceParser().parse(pattern, repl, bool(flags & FORMAT))
997193
function(funcID, args)
    {
        var result;
        var func = this.localFunctionCache[funcID];

        if(func != undefined)
        {
            result = this.serialize(func.apply(null, this.deserialize(args)));
        }

        return result;
    }
1287140
public void sendUpdateQuery(String queryString, SPARQLQueryBindingSet bindings, boolean includeInferred, String baseURI) throws IOException, RepositoryException, MalformedQueryException,UpdateExecutionException {
		getClient().performUpdateQuery(queryString, bindings, this.tx, includeInferred, baseURI);
	}
299085
function emitCacheInformationFile (loader, query, cacheFile, fileHash, iconResult) {
  if (!query.persistentCache) {
    return;
  }
  loader.emitFile(cacheFile, JSON.stringify({
    hash: fileHash,
    version: pluginVersion,
    optionHash: generateHashForOptions(query),
    result: iconResult
  }));
}
486383
function sendVersionMiss() {
    var adapter = requireModule('ember-debug/adapters/' + currentAdapter)['default'].create();
    adapter.onMessageReceived(function(message) {
      if (message.type === 'check-version') {
        sendVersionMismatch();
      }
    });
    sendVersionMismatch();

    function sendVersionMismatch() {
      adapter.sendMessage({
        name: 'version-mismatch',
        version: Ember.VERSION,
        from: 'inspectedWindow'
      });
    }
  }
558159
function done(err, content) {
            if (err) return cb(err);

            var code = JSON.parse(self.square.package.source)
              , current = bundle.version || self.version(bundle.meta.content)
              , source;

            code.bundle[key].version = version;
            bundle.version = version;
            bundle.content = content;

            // now that we have updated the shizzle, we can write a new file
            // also update the old source with the new version
            source = JSON.stringify(code, null, 2);
            self.square.package.source = source;

            try {
              async.parallel([
                  async.apply(fs.writeFile, self.square.package.location, source)
                , async.apply(fs.writeFile, bundle.meta.location, content)
              ], function (err, results) {
                self.square.logger.notice(
                    'sucessfully updated %s from version %s to %s'
                  , key
                  , current.grey
                  , version.green
                );

                cb(err);
              });
            } catch (e) { err = e; }
          }
239701
function publishCachedMessages() {
    if (_cachedPublishMessages.length > 0) {
      async.each(_cachedPublishMessages, function(message, callback) {
        debug('republish message', message);
        self.publishTopic(message.exchange, message.topic, message.message, message.options, function(err) {
          if (err) {
            debug('Failed to republish message', message);
          } else {
            var idx = _cachedPublishMessages.indexOf(message);
            _cachedPublishMessages.splice(idx, 1);
            debug('cached publish message re-published, now there are ' + _cachedPublishMessages.length + ' messages left');
          }
          return callback();
        });
      }, function() {
        debug('cached publish messages processed');
      });
    }
  }
434816
static function sendXmlHttpResponseHeaders($contenttype = "application/json", $charset = 'utf-8')
	{
		if ( is_null($charset) )
			$charset = mb_internal_encoding();
			
		// charset
		header("Content-Type: $contenttype; charset=$charset");
		
		// no cache
		header("Expires: Sat, 1 Jan 2005 00:00:00 GMT");
		header("Last-Modified: ".gmdate( "D, d M Y H:i:s")." GMT");
		header("Cache-Control: no-cache, must-revalidate");
		header("Pragma: no-cache");	
	}
995474
public static function _sendCacheHeaders($expire = 5) {
        if (!is_numeric($expire) || $expire < 1 || $expire > 240) {
            $expire = 5;
            _Log::warn("Attempt to send cache headers with invalid expiration");
        }
        header("Cache-Control: public"); // HTTP/1.1
        header("Expires: " . gmdate("D, d M Y H:i:s", time() + 60 * $expire) . " GMT");
        header("Last-Modified: " . gmdate('D, d M Y H:i:s') . " GMT");
    }
860917
function showVersion(){
  var jshint_proc = fork(__dirname + '/node_modules/jshint/bin/jshint', ['-v'], {silent: true});
  var ts = through(function write(chunk){
    this.queue("JSXHint v" + require('./package.json').version + " (" +
      chunk.toString().replace("\n", "") + ")\n");
  });
  jshint_proc.stderr.pipe(ts).pipe(process.stderr);
}
1129254
function makeCacheable(rawFunction) {
    var lastArguments;
    var currentArguments;
    var lastResult;
    var cacheFunction = function () {
        currentArguments = arguments;
        if (lastArguments == undefined || Array.prototype.some.call(lastArguments, function (value, index) {
            return value != currentArguments[index];
        })) {
            lastResult = rawFunction.apply(null, currentArguments);
            lastArguments = currentArguments;
        }
        return lastResult;
    };
    return cacheFunction;
}
1020815
function (current, temp) {
            if (!Immutable.is(current, temp)) {
                validUrls = temp;
                methods.sendUpdatedUrls(validUrls);
            }
        }
1015027
function afterEmit(compilation, callback) {
    var failures;
    if (options.persist) {
      var cache    = compilation.cache,
          filePath = path.resolve(options.file);

      stats.serialise.encode.start = Date.now();
      var encoded = encode(cache);
      failures = (encoded.$failed || [])
        .filter(filterIgnored);
      delete encoded.$failed;
      stats.serialise.encode.stop = Date.now();

      stats.failures = failures.length;

      // abort
      if (failures.length) {
        stats.serialise.fs.start = Date.now();
        fs.unlink(filePath, complete.bind(null, true));
      }
      // serialise and write file
      else {
        stats.serialise.decycle.start = Date.now();
        var decycled = cycle.decycle(encoded);
        stats.serialise.decycle.stop = Date.now();

        stats.serialise.fs.start = Date.now();
        var buffer = new Buffer(JSON.stringify(decycled, null, 2));
        stats.serialise.size = buffer.length;
        fs.writeFile(filePath, buffer, complete);
      }
    }
    else {
      failures = [];
      complete();
    }

    function complete(error) {
      stats.serialise.fs.stop = Date.now();
      stats.serialise.success = !error;
      options.warn && pushFailures(failures, compilation.warnings, (options.warn === 'verbose'));
      options.stats && printStats(stats);
      callback();
    }
  }
487220
def setCachedDataKey(engineVersionHash, key, value):
		
		cacheFile = CachedDataManager._cacheFileForHash(engineVersionHash)
		return JsonDataManager(cacheFile).setKey(key, value)
409823
private <T> void setCached(String prefix, String postfix, T data) {
    cache.put(prefix + '.' + postfix, data);
  }
222963
function getChildCompiler (mainCompiler) {
  const cachedChildCompiler = childCompilerCache.get(mainCompiler);
  if (cachedChildCompiler) {
    return cachedChildCompiler;
  }
  const newCompiler = new HtmlWebpackChildCompiler();
  childCompilerCache.set(mainCompiler, newCompiler);
  return newCompiler;
}