docs: protected CmsStaticExportData getRfsExportData(CmsObject cms, String uri) {
  
          // cut export prefix from name
          String rfsName = uri.substring(getRfsPrefixForRfsName(uri).length());
  
          // check if we have the result already in the cache
          CmsStaticExportData data = null;
          String siteRoot = OpenCms.getSiteManager().getSiteRoot(cms.getRequestContext().getSiteRoot());
          if (siteRoot != null) {
              data = m_cacheExportUris.get(siteRoot + ":" + rfsName);
          } else {
              data = m_cacheExportUris.get(rfsName);
          }
  
          if (data == null) {
              // export uri not in cache, must look up the file in the VFS
              try {
                  data = getVfsNameInternal(cms, rfsName);
              } catch (CmsVfsResourceNotFoundException e) {
                  // could happen but is the expected behavior because
                  // the accoring vfs resource for the given rfsname could not be found
                  // maybe the rfsname has parameters set -> go on
              }
          }
  
          if (data == null) {
              // it could be a translated resourcename with parameters,
              // so make a lookup in the published resources table
              try {
                  String parameters = cms.readStaticExportPublishedResourceParameters(rfsName);
                  // there was a match in the db table, so get the StaticExportData
                  if (CmsStringUtil.isNotEmpty(parameters)) {
                      // get the rfs base string without the parameter hashcode
                      String rfsBaseName = rfsName.substring(0, rfsName.lastIndexOf('_'));
                      if (rfsBaseName.endsWith(EXPORT_DEFAULT_FILE)) {
                          rfsBaseName = rfsBaseName.substring(0, rfsBaseName.length() - EXPORT_DEFAULT_FILE.length());
                      }
                      // get the vfs base name, which is later used to read the resource in the vfs
                      data = getVfsNameInternal(cms, rfsBaseName);
                      if (data != null) {
                          data.setParameters(parameters);
                      }
                  }
              } catch (CmsVfsResourceNotFoundException e) {
                  if (LOG.isDebugEnabled()) {
                      LOG.debug(
                          Messages.get().getBundle().key(
                              Messages.LOG_NO_INTERNAL_VFS_RESOURCE_FOUND_1,
                              new String[] {rfsName}));
                  }
              } catch (CmsException e) {
                  // ignore, resource does not exist
                  if (LOG.isWarnEnabled()) {
                      LOG.warn(
                          Messages.get().getBundle().key(Messages.ERR_EXPORT_FILE_FAILED_1, new String[] {rfsName}),
                          e);
                  }
              }
          }
  
          if (data == null) {
              // no export data found
              data = new CmsStaticExportData(CACHEVALUE_404, rfsName, null, null);
          }
  
          if (data.getResource() != null) {
              siteRoot = OpenCms.getSiteManager().getSiteRoot(data.getResource().getRootPath());
          }
          if (siteRoot != null) {
              m_cacheExportUris.put(siteRoot + ":" + rfsName, data);
          } else {
              m_cacheExportUris.put(rfsName, data);
          }
  
          // this object comparison is safe, see caller method
          if (data.getVfsName() != CACHEVALUE_404) {
              if (data.getResource().isFolder() && !CmsResource.isFolder(rfsName)) {
                  // be sure that folders are folders!
                  rfsName += "/";
              }
              data.setRfsName(rfsName);
              // this uri can be exported
              return data;
          }
          // this uri can not be exported
          return null;
      }