ModulePtr ModuleManager::discoverModule(const std::string& moduleFile) { ModulePtr module; try { OTMLDocumentPtr doc = OTMLDocument::parse(moduleFile); OTMLNodePtr moduleNode = doc->at("Module"); std::string name = moduleNode->valueAt("name"); bool push = false; module = getModule(name); if(!module) { module = ModulePtr(new Module(name)); push = true; } module->discover(moduleNode); // not loaded modules are always in back if(push) m_modules.push_back(module); } catch(stdext::exception& e) { g_logger.error(stdext::format("Unable to discover module from file '%s': %s", moduleFile, e.what())); } return module; }
ModulePtr container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module())) { m->add(fun( std::function<size_t (const ContainerType *)>( [](const ContainerType *a) { return a->size(); } ) ), "size"); m->add(fun( std::function<bool (const ContainerType *)>( [](const ContainerType *a) { return a->empty(); } ) ), "empty"); m->add(fun( std::function<void (ContainerType *)>( [](ContainerType *a) { a->clear(); } ) ), "clear"); return m; }
ModulePtr container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module())) { boost::function<int (const ContainerType *)> f = detail::return_int(&ContainerType::size); m->add(fun(f), "size"); m->add(fun<bool (ContainerType::*)() const>(&ContainerType::empty), "empty"); m->add(fun<void (ContainerType::*)()>(&ContainerType::clear), "clear"); return m; }
ModulePtr list_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) { m->add(user_type<ListType>(), type); front_insertion_sequence_type<ListType>(type, m); back_insertion_sequence_type<ListType>(type, m); sequence_type<ListType>(type, m); container_type<ListType>(type, m); default_constructible_type<ListType>(type, m); assignable_type<ListType>(type, m); input_range_type<ListType>(type, m); return m; }
CellSBSFast::CellSBSFast(int row,int col) : BitStreamGenerator(row,col) { //Create routers for(int i = 0 ; i < 4 ;i ++){ ModulePtr router = ModulePtr(new SBSFastRouter(row,col)); this->subModules.push_back(router); router->initParams();//TODO this is a massive gotcha } //attributes this->nbBitReceived = 0; this->activated = false; this->dead = false; this->sbs.reset(); }
ModulePtr sequence_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module())) { std::string insert_name; if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value)) { insert_name = "insert_ref_at"; } else { insert_name = "insert_at"; } m->add(fun(&detail::insert_at<ContainerType>), insert_name); m->add(fun(&detail::erase_at<ContainerType>), "erase_at"); return m; }
ModulePtr map_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) { m->add(user_type<MapType>(), type); typedef typename MapType::mapped_type &(MapType::*elemaccess)(const typename MapType::key_type &); m->add(fun(static_cast<elemaccess>(&MapType::operator[])), "[]"); container_type<MapType>(type, m); assignable_type<MapType>(type, m); unique_associative_container_type<MapType>(type, m); pair_associative_container_type<MapType>(type, m); input_range_type<MapType>(type, m); return m; }
ModulePtr pair_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) { m->add(user_type<PairType>(), type); typename PairType::first_type PairType::* f = &PairType::first; typename PairType::second_type PairType::* s = &PairType::second; m->add(fun(f), "first"); m->add(fun(s), "second"); basic_constructors<PairType>(type, m); m->add(constructor<PairType (const typename PairType::first_type &, const typename PairType::second_type &)>(), type); return m; }
ModulePtr input_range_type_impl(const std::string &type, ModulePtr m = ModulePtr(new Module())) { m->add(user_type<Bidir_Type>(), type + "_Range"); copy_constructor<Bidir_Type>(type + "_Range", m); m->add(constructor<Bidir_Type (typename Bidir_Type::container_type &)>(), "range"); m->add(fun(&Bidir_Type::empty), "empty"); m->add(fun(&Bidir_Type::pop_front), "pop_front"); m->add(fun(&Bidir_Type::front), "front"); m->add(fun(&Bidir_Type::pop_back), "pop_back"); m->add(fun(&Bidir_Type::back), "back"); return m; }
ModulePtr ModuleManager::discoverModule(const std::string& moduleFile) { ModulePtr module; try { OTMLDocumentPtr doc = OTMLDocument::parse(moduleFile); OTMLNodePtr moduleNode = doc->at("Module"); std::string name = moduleNode->valueAt("name"); if(getModule(name)) Fw::throwException("module '", name, "' already exists, cannot have duplicate module names"); module = ModulePtr(new Module(name)); module->discover(moduleNode); m_modules.push_back(module); } catch(Exception& e) { logError("Unable to discover module from file '", moduleFile, "': ", e.what()); } return module; }
ModulePtr front_insertion_sequence_type(const std::string &, ModulePtr m = ModulePtr(new Module())) { typedef typename ContainerType::reference (ContainerType::*frontptr)(); typedef void (ContainerType::*pushptr)(typename ContainerType::const_reference); typedef void (ContainerType::*popptr)(); m->add(fun(static_cast<frontptr>(&ContainerType::front)), "front"); std::string push_front_name; if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value)) { push_front_name = "push_front_ref"; } else { push_front_name = "push_front"; } m->add(fun(static_cast<pushptr>(&ContainerType::push_front)), push_front_name); m->add(fun(static_cast<popptr>(&ContainerType::pop_front)), "pop_front"); return m; }
ModulePtr vector_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) { m->add(user_type<VectorType>(), type); typedef typename VectorType::reference (VectorType::*frontptr)(); m->add(fun(static_cast<frontptr>(&VectorType::front)), "front"); back_insertion_sequence_type<VectorType>(type, m); sequence_type<VectorType>(type, m); random_access_container_type<VectorType>(type, m); container_type<VectorType>(type, m); default_constructible_type<VectorType>(type, m); assignable_type<VectorType>(type, m); input_range_type<VectorType>(type, m); if (typeid(VectorType) == typeid(std::vector<Boxed_Value>)) { m->eval("def Vector::`==`(rhs) : type_match(rhs, this) { \ if ( rhs.size() != this.size() ) { \ return false; \ } else { \ var r1 = range(this); \ var r2 = range(rhs); \ while (!r1.empty()) \ { \ if (!eq(r1.front(), r2.front())) \ { \ return false; \ } \ r1.pop_front(); \ r2.pop_front(); \ } \ return true; \ } \ }");
ModulePtr logical_compliment(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&logical_compliment<bool, const T &>), "!"); return m; }
ModulePtr less_than_equal(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&less_than_equal<bool, const T&, const T&>), "<="); return m; }
ModulePtr remainder(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&remainder<T, const T &, const T &>), "%"); return m; }
ModulePtr left_shift(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&left_shift<T, const T &, const T &>), "<<"); return m; }
ModulePtr subtraction(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&subtraction<T, const T &, const T &>), "-"); return m; }
ModulePtr not_equal(ModulePtr m = ModulePtr(new Module())) { m->add(fun(¬_equal<bool, const T &, const T &>), "!="); return m; }
ModulePtr addition(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&addition<T, const T &, const T &>), "+"); return m; }
ModulePtr bitwise_and(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&bitwise_and<T, const T &, const T &>), "&"); return m; }
ModulePtr unary_minus(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&unary_minus<T, const T &>), "-"); return m; }
ModulePtr bitwise_or(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&bitwise_or<T, const T &, const T &>), "|"); return m; }
ModulePtr bitwise_compliment(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&bitwise_compliment<T, const T &>), "~"); return m; }
ModulePtr prefix_increment(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&prefix_increment<T &, T &>), "++"); return m; }
ModulePtr division(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&division<T, const T &, const T &>), "/"); return m; }
ModulePtr equal(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&equal<bool, const T&, const T&>), "=="); return m; }
ModulePtr multiplication(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&multiplication<T, const T &, const T &>), "*"); return m; }
ModulePtr greater_than_equal(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&greater_than_equal<bool, const T&, const T&>), ">="); return m; }
ModulePtr right_shift(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&right_shift<T, const T &, const T &>), ">>"); return m; }
ModulePtr less_than(ModulePtr m = ModulePtr(new Module())) { m->add(fun(&less_than<bool, const T&, const T&>), "<"); return m; }