Returns the full string of the file contents from the cache for
        the file that we are currently providing intellisense for.
973017
def cachedstr(self):
        """"""
        if self._cachedstr is None:
            if self.module is not None:
                refstring = self.module.refstring
                self._cachedstr = refstring.splitlines()
            else:
                self._cachedstr = []

        return self._cachedstr
307534
private void cacheStream() {
        try {
            File fi = getTemproralCacheFile();
            if (fi.exists()) {
                if (!fi.delete()) {
                    throw new IllegalStateException("Cannot delete file " + fi.getAbsolutePath() + "!");
                }
            }
            FileOutputStream fout = new FileOutputStream(fi);
            InputStream in = grabStream();
            byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
            int n;
            while (-1 != (n = in.read(buffer))) {
                fout.write(buffer, 0, n);
            }
            fout.flush();
            fout.close();
            in.close();
            
            File cacheFile = getCacheFile();
            if (!fi.renameTo(cacheFile)) {
                throw new IllegalStateException("Cannot rename file \"" + fi.getAbsolutePath() + "\" to \"" + cacheFile.getAbsolutePath() + "\"!");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
704273
def _read_cache(self):
        """"""
        if os.path.exists(self.filepath):
            with open(self.filepath, 'rt', encoding='utf8') as fh:
                lines = [x.strip() for x in fh]
        else:
            logger.debug("Index not found, starting empty")
            lines = []
        return lines
731361
function getIncludedContent(fileName, css) {
      return fs.readFileAsync(dirname + fileName, {encoding: 'utf8'}).then(function(data) {
        if (css && conf.cssUrlReplacer) {
          data = data.replace(cssurl, function(matched, pref, theUrl, suf) {
            //console.log('readFileAsync, css replacer: ' + url + ', ' + theUrl);
            return pref + conf.cssUrlReplacer(theUrl) + suf;
          });
        }
        incfiles[fileName] = data;
      })
      .catch(function(e) {
        // If we can't read the file, just issue a console warning and continue.
        // Content for this file will not be inlined.
        console.warn('Inliner:\n' + e);
      });
    }
1134542
protected function getCachedFileInfo()
    {
        $cached = $this->getCachedInfo();

        if ($cached !== null && array_key_exists($this->filePath, $cached)) {
            return $cached[$this->filePath];
        }

        return null;
    }
252326
private InputStream getInputStreamFromFile(File f) throws FileNotFoundException{
		InputStream stream = null;



		if ( cacheRawFiles ){
			stream = FlatFileCache.getInputStream(f.getAbsolutePath());

			if ( stream == null){
				FlatFileCache.addToCache(f.getAbsolutePath(),f);
				stream = FlatFileCache.getInputStream(f.getAbsolutePath());
			}
		}

		if ( stream == null)
			stream = new FileInputStream(f);

		return stream;
	}
373514
private function getContent()
    {
        if (null === $this->contentCache) {
            $item = $this->getCachedContent();

            if (null === $this->contentCache) {
                $this->contentCache = $this->saveContentInCache($item, $this->readFile());
            }
        }

        return $this->contentCache;
    }
361426
def package_contents(self):
        ''

        if self.contents_cache:
            return self.contents_cache

        # Get a list of ZipInfo objects.
        files = self.zf.infolist()
        out_files = {}

        # Iterate through each file in the XPI.
        for file_ in files:

            file_doc = {'name': file_.filename,
                        'size': file_.file_size,
                        'name_lower': file_.filename.lower()}

            file_doc['extension'] = file_doc['name_lower'].split('.')[-1]

            out_files[file_.filename] = file_doc

        self.contents_cache = out_files
        return out_files
763482
def getCoeffStr(self):
        '''
        
        '''
        txt = ''
        for key, val in self.coeffs.items():
            txt += '%s = %s\n' % (key, val)
        return txt
1276548
def get_all_data_from_cache(self, filename=''):
        '''  '''

        data = ''
        if not filename:
            filename = self.cache_path_cache
        with open(filename, 'r') as cache:
            data = cache.read()
        return json.loads(data)
159125
def _get_cache_contents(self):
        
        if not os.path.isdir(self._path):
            return []

        def sort_key(name):
            path, stamp = self._get_cache_dir(name)
            try:
                return os.stat(stamp).st_mtime
            except OSError:
                return 0

        names = os.listdir(self._path)
        names.sort(key=sort_key, reverse=True)
        return names
1132776
def contents(custom_binding = nil)
      return @contents unless @contents.nil?

      @contents = File.read(path)
      if path.extname == '.erb'
        @contents = ERB.new(@contents, nil, '>').result(custom_binding ? custom_binding : binding)
      end
      @contents
    end
1214460
def getSimpleFileData(self, fileInfo, data):
		""""""
		result = fileInfo[fileInfo.find(data + "</td>"):]
		result = result[:result.find("</A></td>")]
		result = result[result.rfind(">") + 1:]
		return result
853606
def _read_cache_from_file(self):
        """"""
        cache = {}
        try:
            with(open(self._cache_file_name, 'r')) as fp:
                contents = fp.read()
                cache = simplejson.loads(contents)
        except (IOError, JSONDecodeError):
            # The file could not be read. This is not a problem if the file does not exist.
            pass

        return cache
504254
def get_file(self, cache_id_obj, section=None):
        """"""
        section = "default" if section is None else section
        if "/" in section:
            raise ValueError("invalid section '{0}'".format(section))
        cache_id = "{:08x}".format(
            zlib.crc32(b"&".join(sorted([
                str(k).encode('utf8') + b"=" + str(v).encode('utf8')
                for k, v in cache_id_obj.items()
            ]))) & 0xffffffff)
        return os.path.join(self._full_base,
                            os.path.join(section,
                                         os.path.join(
                                             "{0}".format(cache_id[:2]),
                                             "{0}.tmp".format(cache_id[2:]))))
235615
def get_full_filename(self, dataType, subjectArea):
        
        return dataPath + os.sep + 'core' + os.sep + dataType + '_' + subjectArea + '.CSV'
288236
function () {
            var filePath = this.getFileName();
            if (!this.__fileContentsCache && filePath) {
                // Leave the stage early when 'Unknown' is passed
                // this would otherwise raise an exception when
                // open_basedir is enabled.
                if (filePath === "Unknown") {
                    return null;
                }

                // Return null if the file doesn't actually exist.
                if (!fs.existsSync(filePath)) {
                    if (process.env.NVM_DIR && process.versions.node) {
                        filePath = path.join(process.env.NVM_DIR, 'src/node-v' + process.versions.node, 'lib', filePath);
                        if (!fs.existsSync(filePath)) {
                            return null;
                        }
                    } else {
                        return null;
                    }
                }

                this.__fileContentsCache = fs.readFileSync(filePath, 'utf-8');
            }

            return this.__fileContentsCache;
        }