environment-impl.H

Go to the documentation of this file.

// Copyright 2012, 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 RERANKER_ENVIRONMENT_IMPL_H_
#define RERANKER_ENVIRONMENT_IMPL_H_

#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <typeinfo>

#include "environment.H"

namespace reranker {

using std::ostringstream;
using std::string;
using std::unordered_map;
using std::unordered_set;

class EnvironmentImpl : public Environment {
 public:
  EnvironmentImpl(int debug = 0);

  virtual ~EnvironmentImpl() {
    for (unordered_map<string, VarMapBase *>::iterator it = var_map_.begin();
         it != var_map_.end(); ++it) {
      delete it->second;
    }
  }

  virtual bool Defined(const string &varname) const {
    unordered_map<string, string>::const_iterator it = types_.find(varname);
    return it != types_.end();
  }

  virtual void ReadAndSet(const string &varname, StreamTokenizer &st,
                          const string type);

  virtual const string &GetType(const string &varname) const {
    unordered_map<string, string>::const_iterator type_it =
        types_.find(varname);
    if (type_it == types_.end()) {
      // Error or warning.
    }
    return type_it->second;
  }

  virtual VarMapBase *GetVarMap(const string &varname) {
    return GetVarMapForType(GetType(varname));
  }

  virtual VarMapBase *GetVarMapForType(const string &type) {
    string lookup_type = type;
    // First, check if this is a concrete Factory-constructible type.
    // If so, map to its abstract type name.
    unordered_map<string, string>::const_iterator factory_type_it =
        concrete_to_factory_type_.find(type);
    if (factory_type_it != concrete_to_factory_type_.end()) {
      lookup_type = factory_type_it->second;
    }

    unordered_map<string, VarMapBase *>::const_iterator var_map_it =
        var_map_.find(lookup_type);
    if (var_map_it == var_map_.end()) {
      return NULL;
    }
    return var_map_it->second;
  }

  virtual void Print(ostream &os) const {
    for (unordered_map<string, VarMapBase *>::const_iterator var_map_it =
             var_map_.begin();
         var_map_it != var_map_.end(); ++var_map_it) {
      var_map_it->second->Print(os);
    }
  }

  virtual void PrintFactories(ostream &os) const;

  virtual Environment *Copy() const {
    EnvironmentImpl *new_env = new EnvironmentImpl(*this);
    // Now go through and create copies of each VarMap.
    for (unordered_map<string, VarMapBase *>::iterator new_env_var_map_it =
             new_env->var_map_.begin();
         new_env_var_map_it != new_env->var_map_.end(); ++new_env_var_map_it) {
      new_env_var_map_it->second = new_env_var_map_it->second->Copy(new_env);
    }
    return new_env;
  }

  template<typename T>
  bool Get(const string &varname, T *value) const;

 private:
  string InferType(const string &varname,
                   const StreamTokenizer &st, bool is_vector,
                   bool *is_object_type);

  unordered_map<string, string> types_;

  unordered_map<string, VarMapBase *> var_map_;

  unordered_map<string, string> concrete_to_factory_type_;

  int debug_;
};

template<typename T>
bool
EnvironmentImpl::Get(const string &varname, T *value) const {
  unordered_map<string, string>::const_iterator type_it =
      types_.find(varname);
  if (type_it == types_.end()) {
    if (debug_ >= 1) {
      ostringstream err_ss;
      err_ss << "Environment::Get: error: no value for variable "
             << varname;
      cerr << err_ss.str() << endl;
    }
    return false;
  }

  // Now that we have the type, look up the VarMap.
  const string &type = type_it->second;
  unordered_map<string, VarMapBase*>::const_iterator var_map_it =
      var_map_.find(type);

  if (var_map_it == var_map_.end()) {
    ostringstream err_ss;
    err_ss << "Environment::Get: error: types_ and var_map_ data members "
           << "are out of sync";
    throw std::runtime_error(err_ss.str());
  }

  // Do a dynamic_cast down to the type-specific VarMap.
  VarMapBase *var_map = var_map_it->second;
  VarMap<T> *typed_var_map = dynamic_cast<VarMap<T> *>(var_map);

  if (typed_var_map == NULL) {
    ostringstream err_ss;
    err_ss << "Environment::Get: error: no value for variable "
           << varname << " of type " << typeid(*value).name()
           << "; perhaps you meant " << type << "?";
    cerr << err_ss.str() << endl;
    return false;
  }
  bool success = typed_var_map->Get(varname, value);
  if (!success) {
    ostringstream err_ss;
    err_ss << "Environment::Get: error: no value for variable "
           << varname << " of type " << typeid(*value).name()
           << "; types_ and var_map_ data members are out of sync";
    throw std::runtime_error(err_ss.str());
  }
  return success;
  }

}  // namespace reranker

#endif