factory.h

Go to the documentation of this file.

// Copyright 2014, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//   * Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above
//     copyright notice, this list of conditions and the following disclaimer
//     in the documentation and/or other materials provided with the
//     distribution.
//   * Neither the name of Google Inc. nor the names of its
//     contributors may be used to endorse or promote products derived from
//     this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// -----------------------------------------------------------------------------
//
//

#ifndef INFACT_FACTORY_H_
#define INFACT_FACTORY_H_

#include <iostream>
#include <sstream>
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <stdexcept>

#include "environment.h"
#include "error.h"
#include "stream-tokenizer.h"

#define INFACT_ADD_PARAM(param) initializers.Add(#param, &_ ## param)

#define INFACT_ADD_PARAM_(param) initializers.Add(#param, &param ## _)

#define INFACT_ADD_REQUIRED_PARAM(param) \
  initializers.Add(#param, &_ ## param, true)

#define INFACT_ADD_REQUIRED_PARAM_(param) \
  initializers.Add(#param, &param ## _, true)

#define INFACT_ADD_TEMPORARY(type, var) \
  initializers.Add(#var, static_cast<type *>(nullptr))

#define INFACT_ADD_REQUIRED_TEMPORARY(type, var) \
  initializers.Add(#var, static_cast<type *>(nullptr), true)

namespace infact {

using std::cerr;
using std::endl;
using std::ostream;
using std::ostringstream;
using std::shared_ptr;
using std::unordered_map;
using std::unordered_set;
using std::vector;

template <typename T>
class TypeName {
 public:
  string ToString() {
    return Factory<T>().BaseName();
  }
};

template <>
class TypeName<bool> {
 public:
  string ToString() {
    return "bool";
  }
};

template <>
class TypeName<int> {
 public:
  string ToString() {
    return "int";
  }
};

template <>
class TypeName<double> {
 public:
  string ToString() {
    return "double";
  }
};

template <>
class TypeName<string> {
 public:
  string ToString() {
    return "string";
  }
};

template <typename T>
class TypeName<shared_ptr<T> > {
 public:
  string ToString() {
    return TypeName<T>().ToString();
  }
};

template <typename T>
class TypeName<vector<T> > {
 public:
  string ToString() {
    return TypeName<T>().ToString() + "[]";
  }
};

class MemberInitializer {
 public:
  //                  appear in spec strings parsed by the
  MemberInitializer(const string &name, bool required) :
      name_(name), initialized_(0), required_(required) { }

  virtual ~MemberInitializer() { }

  virtual string Name() { return name_; }

  virtual void Init(StreamTokenizer &st, Environment *env) = 0;

  virtual int Initialized() const { return initialized_; }

  virtual bool Required() const { return required_; }

 protected:
  string name_;
  int initialized_;
  bool required_;
};

template <typename T>
class TypedMemberInitializer : public MemberInitializer {
 public:
  //                  appear in spec strings parsed by the
  TypedMemberInitializer(const string &name, T *member, bool required = false) :
      MemberInitializer(name, required), member_(member) { }
  virtual ~TypedMemberInitializer() { }
  virtual void Init(StreamTokenizer &st, Environment *env) {
    env->ReadAndSet(Name(), st, TypeName<T>().ToString());
    if (member_ != nullptr) {
      VarMapBase *var_map = env->GetVarMap(Name());
      VarMap<T> *typed_var_map = dynamic_cast<VarMap<T> *>(var_map);
      if (typed_var_map != nullptr) {
        bool success = typed_var_map->Get(Name(), member_);
        if (success) {
          ++initialized_;
        }
      }
    } else {
      // When the goal is simply to modify the environment, we say that this
      // "non-member" has been successfully initialized when we've modified
      // the environment.
      ++initialized_;
    }
  }
 protected:
  T *member_;
};

class Initializers {
 public:
  typedef unordered_map<string, MemberInitializer *>::const_iterator
      const_iterator;
  typedef unordered_map<string, MemberInitializer *>::iterator iterator;

  Initializers() { }
  virtual ~Initializers() {
    for (iterator init_it = initializers_.begin();
         init_it != initializers_.end();
         ++init_it) {
      delete init_it->second;
    }
  }

  template<typename T>
  void Add(const string &name, T *member, bool required = false) {
    if (initializers_.find(name) != initializers_.end()) {
      ostringstream err_ss;
      err_ss << "Initializers::Add: error: two members have the same name: "
             << name;
      Error(err_ss.str());
    }
    initializers_[name] = new TypedMemberInitializer<T>(name, member, required);
  }

  const_iterator begin() const { return initializers_.begin(); }
  const_iterator end() const { return initializers_.end(); }

  iterator begin() { return initializers_.begin(); }
  iterator end() { return initializers_.end(); }

  const_iterator find(const string &name) const {
    return initializers_.find(name);
  }
  iterator find(const string &name) {
    return initializers_.find(name);
  }
 private:
  unordered_map<string, MemberInitializer *> initializers_;
};

class FactoryBase {
 public:
  virtual ~FactoryBase() { }
  virtual void Clear() = 0;
  virtual const string BaseName() const = 0;
  virtual void CollectRegistered(unordered_set<string> &registered) const = 0;

  virtual VarMapBase *CreateVarMap(Environment *env) const = 0;

  virtual VarMapBase *CreateVectorVarMap(Environment *env) const = 0;
};

class FactoryContainer {
 public:
  typedef vector<FactoryBase *>::iterator iterator;

  static void Add(FactoryBase *factory) {
    if (!initialized_) {
      factories_ = new vector<FactoryBase *>();
      initialized_ = 1;
    }
    factories_->push_back(factory);
  }
  static void Clear() {
    if (initialized_) {
      for (vector<FactoryBase *>::iterator it = factories_->begin();
           it != factories_->end();
           ++it) {
        (*it)->Clear();
        delete *it;
      }
      delete factories_;
    }
  }

  // Provide two methods to iterate over the FactoryBase instances
  // held by this FactoryContainer.
  static iterator begin() {
    if (factories_ == nullptr) {
      cerr << "FactoryContainer::begin: error: no FactoryBase instances!"
           << endl;
    }
    return factories_->begin();
  }
  static iterator end() {
    if (factories_ == nullptr) {
      cerr << "FactoryContainer::begin: error: no FactoryBase instances!"
           << endl;
    }
    return factories_->end();
  }

  static void Print(ostream &os) {
    if (!initialized_) {
      return;
    }
    cerr << "Number of factories: " << factories_->size() << "." << endl;
    for (vector<FactoryBase *>::iterator factory_it = factories_->begin();
         factory_it != factories_->end();
         ++factory_it) {
      unordered_set<string> registered;
      (*factory_it)->CollectRegistered(registered);
      os << "Factory<" << (*factory_it)->BaseName() << "> can construct:\n";
      for (unordered_set<string>::const_iterator it = registered.begin();
           it != registered.end();
           ++it) {
        os << "\t" << *it << "\n";
      }
    }
    os.flush();
  }
 private:
  static int initialized_;
  static vector<FactoryBase *> *factories_;
};

// \tparam T the abstract type that this <tt>Constructor</tt> constructs
template <typename T>
class Constructor {
 public:
  virtual ~Constructor() { }
  virtual T *NewInstance() const = 0;
};

class FactoryConstructible {
 public:
  virtual ~FactoryConstructible() { }

  virtual void RegisterInitializers(Initializers &initializers) { }

  virtual void PostInit(const Environment *env, const string &init_str) { }
};

template <typename T>
class Factory : public FactoryBase {
 public:
  Factory() { }

  virtual void Clear() {
    ClearStatic();
  }

  shared_ptr<T> CreateOrDie(StreamTokenizer &st, Environment *env = nullptr) {
    shared_ptr<Environment> env_ptr(env == nullptr ?
                                    Environment::CreateEmpty() : env->Copy());
    size_t start = st.PeekTokenStart();
    StreamTokenizer::TokenType token_type = st.PeekTokenType();
    if (token_type == StreamTokenizer::RESERVED_WORD &&
        (st.Peek() == "nullptr" || st.Peek() == "NULL")) {
      // Consume the nullptr.
      st.Next();
      return shared_ptr<T>();
    }
    if (token_type != StreamTokenizer::IDENTIFIER) {
      ostringstream err_ss;
      err_ss << "Factory<" << BaseName() << ">: "
             << "error: expected type specifier token but found "
             << StreamTokenizer::TypeName(token_type);
      Error(err_ss.str());
    }

    // Read the concrete type of object to be created.
    string type = st.Next();

    // Read the open parenthesis token.
    if (st.Peek() != "(") {
      ostringstream err_ss;
      err_ss << "Factory<" << BaseName() << ">: "
             << "error: expected '(' at stream position "
             << st.PeekTokenStart() << " but found \"" << st.Peek() << "\"";
      Error(err_ss.str());
    }
    st.Next();

    // Attempt to create an instance of type.
    typename unordered_map<string, const Constructor<T> *>::iterator cons_it =
        cons_table_->find(type);
    if (cons_it == cons_table_->end()) {
      ostringstream err_ss;
      err_ss << "Factory<" << BaseName() << ">: "
             << "error: unknown type: \"" << type << "\"";
      Error(err_ss.str());
    }
    shared_ptr<T> instance(cons_it->second->NewInstance());

    // Ask new instance to set up member initializers.
    Initializers initializers;
    instance->RegisterInitializers(initializers);

    // Parse initializer list.
    while (st.Peek() != ")") {
      token_type = st.PeekTokenType();
      if (token_type != StreamTokenizer::IDENTIFIER) {
        ostringstream err_ss;
        err_ss << "Factory<" << BaseName() << ">: "
               << "error: expected token of type IDENTIFIER at "
               << "stream position " << st.PeekTokenStart() << " but found "
               << StreamTokenizer::TypeName(token_type) << ": \""
               << st.Peek() << "\"";
        Error(err_ss.str());
      }
      size_t member_name_start = st.PeekTokenStart();
      string member_name = st.Next();
      typename Initializers::iterator init_it = initializers.find(member_name);
      if (init_it == initializers.end()) {
        ostringstream err_ss;
        err_ss << "Factory<" << BaseName() << ">: "
               << "error: unknown member name \"" << member_name
               << "\" in initializer list for type " << type << " at stream "
               << "position " << member_name_start;
        Error(err_ss.str());
      }
      MemberInitializer *member_initializer = init_it->second;

      // Read open parenthesis or equals sign.
      size_t member_init_start = st.PeekTokenStart();
      bool saw_member_init_open_paren = st.Peek() == "(";
      bool saw_member_init_equals_sign = st.Peek() == "=";
      if (!saw_member_init_open_paren && !saw_member_init_equals_sign) {
        ostringstream err_ss;
        err_ss << "Factory<" << BaseName() << ">: "
               << "error initializing member " << member_name << ": "
               << "expected '(' or '=' at stream position "
               << st.PeekTokenStart() << " but found \"" << st.Peek() << "\"";
        Error(err_ss.str());
      }
      st.Next();

      // Initialize member based on following token(s).
      member_initializer->Init(st, env_ptr.get());

      // If an open parenthesis was seen, read close parenthesis.
      if (saw_member_init_open_paren) {
        if (st.Peek() != ")") {
          ostringstream err_ss;
          err_ss << "Factory<" << BaseName() << ">: "
              << "error initializing member " << member_name << ": "
              << "saw '(' at stream position " << member_init_start
              << "; expected ')' at stream position "
              << st.PeekTokenStart() << " but found \"" << st.Peek() << "\"";
          Error(err_ss.str());
        }
        st.Next();
      }

      // Each member initializer must be followed by a comma or the final
      // closing parenthesis.
      if (st.Peek() != ","  && st.Peek() != ")") {
        ostringstream err_ss;
        err_ss << "Factory<" << BaseName() << ">: "
               << "error initializing member " << member_name << ": "
               << "expected ',' or ')' at stream position "
               << st.PeekTokenStart() << " but found \"" << st.Peek() << "\"";
        Error(err_ss.str());
      }
      // Read comma, if present.
      if (st.Peek() == ",") {
        st.Next();
      }
    }

    // Read the close parenthesis token for this factory type specification.
    if (st.Peek() != ")") {
      ostringstream err_ss;
      err_ss << "Factory<" << BaseName() << ">: "
             << "error at initializer list end: "
             << "expected ')' at stream position "
             << st.PeekTokenStart() << " but found \"" << st.Peek() << "\"";
      Error(err_ss.str());
    }
    st.Next();

    // Run through all member initializers: if any are required but haven't
    // been invoked, it is an error.
    for (typename Initializers::const_iterator init_it = initializers.begin();
         init_it != initializers.end();
         ++init_it) {
      MemberInitializer *member_initializer = init_it->second;
      if (member_initializer->Required() &&
          member_initializer->Initialized() == 0) {
        ostringstream err_ss;
        err_ss << "Factory<" << BaseName() << ">: "
               << "error: initialization for member with name \""
               << init_it->first << "\" required but not found (current "
               << "stream position: " << st.tellg() << ")";
        Error(err_ss.str());
      }
    }

    size_t end = st.tellg();
    // Invoke new instance's Init method.
    string stream_str = st.str();
    //cerr << "Full stream string is: \"" << stream_str << "\"" << endl;
    string init_str = stream_str.substr(start, end - start);
    //cerr << "PostInit string is: \"" << init_str << "\"" << endl;
    instance->PostInit(env_ptr.get(), init_str);

    return instance;
  }

  shared_ptr<T> CreateOrDie(const string &spec, const string err_msg,
                            Environment *env = nullptr) {
    StreamTokenizer st(spec);
    return CreateOrDie(st, env);
  }


  virtual const string BaseName() const { return base_name_; }

  static bool IsRegistered(const string &type) {
    return initialized_ && cons_table_->find(type) != cons_table_->end();
  }

  virtual void CollectRegistered(unordered_set<string> &registered) const {
    if (initialized_) {
      for (typename unordered_map<string, const Constructor<T> *>::iterator it =
               cons_table_->begin();
           it != cons_table_->end();
           ++it) {
        registered.insert(it->first);
      }
    }
  }

  virtual VarMapBase *CreateVarMap(Environment *env) const {
    bool is_primitive = false;
    return new VarMap<shared_ptr<T> >(BaseName(), env, is_primitive);
  }

  virtual VarMapBase *CreateVectorVarMap(Environment *env) const {
    string name = BaseName() + "[]";
    bool is_primitive = false;
    return new VarMap<vector<shared_ptr<T> > >(name, BaseName(), env,
                                               is_primitive);
  }

  static const Constructor<T> *Register(const string &type,
                                        const Constructor<T> *p) {
    if (!initialized_) {
      cons_table_ = new unordered_map<string, const Constructor<T> *>();
      initialized_ = 1;
      FactoryContainer::Add(new Factory<T>());
    }
    typename unordered_map<string, const Constructor<T> *>::iterator cons_it =
        cons_table_->find(type);
    if (cons_it == cons_table_->end()) {
      (*cons_table_)[type] = p;
      return p;
    } else {
      delete p;
      return cons_it->second;
    }
  }

  static void ClearStatic() {
    if (initialized_) {
      for (typename unordered_map<string, const Constructor<T> *>::iterator it =
               cons_table_->begin();
           it != cons_table_->end();
           ++it) {
        delete it->second;
      }
      delete cons_table_;
      initialized_ = 0;
    }
  }
 private:
  // data members
  static int initialized_;
  static unordered_map<string, const Constructor<T> *> *cons_table_;
  static const char *base_name_;
};

// Initialize the templated static data member cons_table_ right here,
// since the compiler will happily remove the duplicate definitions.
template <typename T>
unordered_map<string, const Constructor<T> *> *
Factory<T>::cons_table_ = 0;

#define DEFINE_CONS_CLASS(TYPE,NAME,BASE) \
  class NAME ## Constructor : public infact::Constructor<BASE> { \
   public: virtual BASE *NewInstance() const { return new TYPE(); } };

#define REGISTER_NAMED(TYPE,NAME,BASE)  \
  DEFINE_CONS_CLASS(TYPE,NAME,BASE) \
  static const infact::Constructor<BASE> *NAME ## _my_protoype = \
      infact::Factory<BASE>::Register(string(#NAME), new NAME ## Constructor());

#define IMPLEMENT_FACTORY(BASE) \
  template<> int infact::Factory<BASE>::initialized_ = 0; \
  template<> const char *infact::Factory<BASE>::base_name_ = #BASE;

}  // namespace infact

#endif