Method getCachedFile

deps/GraphBLAS/CUDA/GB_jit_cache.h:202–256

    template <typename T, typename FileDescType>
    named_prog<T> getCachedFile(
            FileDescType &file_object,
        umap_str_shptr<T>& map )
    {

//        printf("INside get cached file\n");
        std::string name = file_object.filename;

        // Find memory cached T object
        auto it = map.find(name);
        if ( it != map.end()) {
//            std::cout<<"found memory-cached file "<<name<<std::endl;
            return std::make_pair(name, it->second);
        }
        else { // Find file cached T object
            bool successful_read = false;
            std::string serialized;
            std::string cache_dir = getCacheDir();
            std::string file_name = cache_dir + "/" + name;
            if (not cache_dir.empty() ) {
                // TODO: Use OS-agnostic path separator here
//                std::cout<<"looking for prog in file "<<file_name<<std::endl;
                file_object.open(file_name.c_str(), "r");
                cacheFile file{file_name};
                serialized = file.read_file();
                successful_read = file.is_read_successful();
//                std::cout << "successful_read: " << successful_read << std::endl;
                if(successful_read) {
                    file_object.close();
//                    std::cout << "Just closed" << std::endl;
                }
            }
            if (not successful_read) {
                // JIT compile and write to file if possible
//                std::cout << "not successful read. macrofying" << std::endl;
                file_object.open(file_name.c_str(), "w");
                file_object.macrofy();
//                std::cout<<" got fresh content for "<<name<<std::endl;
                file_object.close();

                if (not cache_dir.empty()) {
//                    std::cout<<"writing in file "<<file_name<<std::endl;
                    cacheFile file{file_name};

                    cacheFile macrofied{name};
                    serialized = macrofied.read_file();
                    file.write(serialized);
                }
            }
            // Add deserialized T to cache and return
            map[name] = std::make_shared<std::string>(serialized);
            //std::cout<<"storing file in memory "<<name<<std::endl;
            return std::make_pair(name, map[name]);
        }
    }


    // GetCached