Register注册工厂

谁践踏了优雅 2022-09-10 01:20 105阅读 0赞

注册工厂

class FileSystemRegistry {
     public:
      typedef std::function<FileSystem*()> Factory;
    
      virtual ~FileSystemRegistry();
      virtual Status Register(const string& scheme, Factory factory) = 0;
      virtual FileSystem* Lookup(const string& scheme) = 0;
      virtual Status GetRegisteredFileSystemSchemes(
          std::vector<string>* schemes) = 0;
    };

工厂实现

class FileSystemRegistryImpl : public FileSystemRegistry {
    public:
     Status Register(const string& scheme, Factory factory) override;
     FileSystem* Lookup(const string& scheme) override;
     Status GetRegisteredFileSystemSchemes(std::vector<string>* schemes) override;
    
    private:
     mutable mutex mu_;
     mutable std::unordered_map<string, std::unique_ptr<FileSystem>> registry_
         GUARDED_BY(mu_);
    };
    
    Status FileSystemRegistryImpl::Register(const string& scheme,
                                           FileSystemRegistry::Factory factory) {
     mutex_lock lock(mu_);
     if (!registry_.emplace(string(scheme), std::unique_ptr<FileSystem>(factory()))
              .second) {
       return errors::AlreadyExists("File factory for ", scheme,
                                    " already registered");
     }
     return Status::OK();
    }
    
    FileSystem* FileSystemRegistryImpl::Lookup(const string& scheme) {
     mutex_lock lock(mu_);
     const auto found = registry_.find(scheme);
     if (found == registry_.end()) {
       return nullptr;
     }
     return found->second.get();
    }
    
    Status FileSystemRegistryImpl::GetRegisteredFileSystemSchemes(
       std::vector<string>* schemes) {
     mutex_lock lock(mu_);
     for (const auto& e : registry_) {
       schemes->push_back(e.first);
     }
     return Status::OK();
    }

Env handle类

class Env {
     public:
      Env() : file_system_registry_(new FileSystemRegistryImpl) {}
      virtual ~Env() = default;
      virtual Status RegisterFileSystem(const string& scheme,
                                        FileSystemRegistry::Factory factory) {
       return file_system_registry_->Register(scheme, std::move(factory));
       }
                                    
    private:
      std::unique_ptr<FileSystemRegistry> file_system_registry_;
      TF_DISALLOW_COPY_AND_ASSIGN(Env);
      EnvTime* envTime = EnvTime::Default();

实际不同子例的注册

namespace register_file_system {
    
    template <typename Factory>
    struct Register {
      Register(Env* env, const string& scheme) {
        // TODO(b/32704451): Don't just ignore the ::tensorflow::Status object!
        env->RegisterFileSystem(scheme, []() -> FileSystem* { return new Factory; })
            .IgnoreError();
      }
    };
    
    }  // namespace register_file_system
    
    // END_SKIP_DOXYGEN
    
    }  // namespace tensorflow
    
    // Register a FileSystem implementation for a scheme. Files with names that have
    // "scheme://" prefixes are routed to use this implementation.
    #define REGISTER_FILE_SYSTEM_ENV(env, scheme, factory) \
      REGISTER_FILE_SYSTEM_UNIQ_HELPER(__COUNTER__, env, scheme, factory)
    #define REGISTER_FILE_SYSTEM_UNIQ_HELPER(ctr, env, scheme, factory) \
      REGISTER_FILE_SYSTEM_UNIQ(ctr, env, scheme, factory)
    #define REGISTER_FILE_SYSTEM_UNIQ(ctr, env, scheme, factory)   \
      static ::tensorflow::register_file_system::Register<factory> \
          register_ff##ctr TF_ATTRIBUTE_UNUSED =                   \
              ::tensorflow::register_file_system::Register<factory>(env, scheme)
    
    #define REGISTER_FILE_SYSTEM(scheme, factory) \
      REGISTER_FILE_SYSTEM_ENV(::tensorflow::Env::Default(), scheme, factory);

实际一个例子：

#include "third_party/hadoop/hdfs.h"
    
    class HadoopFileSystem : public FileSystem {
    public:
     HadoopFileSystem();
     ~HadoopFileSystem();
    }
    private:
     Status Connect(StringPiece fname, hdfsFS* fs);
     LibHDFS* hdfs_;