//template <typename T> public param_num_t(core_device_t device, string name, T val) : base(device, name) { m_param = val; bool found = false; string p = this.get_initial(device, out found); if (found) { plib.pfunction <nl_fptype, nl_fptype_ops> func = new plib.pfunction <nl_fptype, nl_fptype_ops>(); func.compile_infix(p, new std.vector <string>()); var valx = func.evaluate(); if (ops.is_integral()) //if (plib::is_integral<T>::value) { if (plib.pg.abs(valx - plib.pg.trunc(valx)) > nlconst.magic(1e-6)) { throw new nl_exception(MF_INVALID_NUMBER_CONVERSION_1_2(device.name() + "." + name, p)); } } m_param = ops.cast(valx); //m_param = plib::narrow_cast<T>(valx); } device.state().save(this, m_param, this.name(), "m_param"); }
protected string get_initial(core_device_t dev, out bool found) { string res = dev.state().setup().get_initial_param_val(this.name(), ""); found = !res.empty(); return(res); }
/// \brief Constructor public analog_input_t(core_device_t dev, ///< owning device string aname, ///< name of terminal nldelegate delegate_) ///< delegate : base(dev, aname, state_e.STATE_INP_ACTIVE, delegate_) { state().setup().register_term(this); }
public analog_output_t(core_device_t dev, string aname) : base(dev, aname, state_e.STATE_OUT, null) //: analog_t(dev, aname, STATE_OUT, nldelegate()) { m_my_net = new analog_net_t(dev.state(), name() + ".net", this); state().register_net(m_my_net); //state().register_net(device_arena::owned_ptr<analog_net_t>(&m_my_net, false)); this.set_net(m_my_net); //net().m_cur_Analog = NL_FCONST(0.0); state().setup().register_term(this); }
void core_device_t_after_ctor(core_device_t owner, string name) { m_hint_deactivate = false; m_active_outputs = new state_var_s32(this, "m_active_outputs", 1); //printf("owned device: %s\n", this->name().c_str()); owner.state().register_device(this.name(), this); //owner.state().register_device(this->name(), device_arena::owned_ptr<core_device_t>(this, false)); if (exec().stats_enabled()) { m_stats = new stats_t(); //m_stats = owner.state().make_pool_object<stats_t>(); } }
Pointer <nl_fptype> m_gt; //nl_fptype *m_gt; ///< conductance for total conductance /// \brief constructor /// /// @param dev core_devict_t object owning the terminal /// @param aname name of this terminal /// @param otherterm pointer to the sibling terminal public terminal_t(core_device_t dev, string aname, nldelegate delegate_) //terminal_t(core_device_t &dev, const pstring &aname, terminal_t *otherterm, const std::array<terminal_t *, 2> &splitterterms, nldelegate delegate) : base(dev, aname, state_e.STATE_BIDIR, delegate_) { // NOTE - make sure to call terminal_t_after_ctor() m_Idr = null; m_go = null; m_gt = null; // this is handled below so that recursive links can be handled properly. see nld_twoterm() //state().setup().register_term(*this, otherterm, splitterterms); }
} //void register_net(device_arena::owned_ptr<T> &&net) { m_nets.push_back(std::move(net)); } /// \brief Get device pointer by name /// /// /// \param name Name of the device /// /// \return core_device_t pointer if device exists, else nullptr //core_device_t *find_device(const pstring &name) const //{ // for (const auto & d : m_devices) // if (d.first == name) // return d.second.get(); // return nullptr; //} /// \brief Register device using owned_ptr /// /// Used to register owned devices. These are devices declared as objects /// in another devices. /// /// \param name Name of the device /// \param dev Device to be registered //template <typename T> public void register_device(string name, core_device_t dev) //void register_device(const pstring &name, device_arena::owned_ptr<T> &&dev) noexcept(false) { foreach (var d in m_devices) { if (d.first == name) { //dev.release(); log().fatal.op(MF_DUPLICATE_NAME_DEVICE_LIST(name)); throw new nl_exception(MF_DUPLICATE_NAME_DEVICE_LIST(name)); } } //m_devices.push_back(dev); m_devices.Add(new std.pair <string, core_device_t>(name, dev)); //m_devices.insert(m_devices.end(), { name, std::move(dev) }); }
core_device_t get_single_device(string classname, get_single_device_func cc) //core_device_t *get_single_device(const pstring &classname, bool (*cc)(core_device_t *)) const; { core_device_t ret = null; foreach (var d in m_devices) { if (cc(d.second)) { if (ret != null) { m_log.fatal.op(MF_MORE_THAN_ONE_1_DEVICE_FOUND(classname)); throw new nl_exception(MF_MORE_THAN_ONE_1_DEVICE_FOUND(classname)); } ret = d.second; } } return(ret); }
public param_enum_t(core_device_t device, string name, T val) : base(device, name) { m_param = val; bool found = false; string p = this.get_initial(device, out found); if (found) { T temp = val; bool ok = ops.set_from_string(p, out temp); //bool ok = temp.set_from_string(p); if (!ok) { device.state().log().fatal.op(MF_INVALID_ENUM_CONVERSION_1_2(name, p)); throw new nl_exception(MF_INVALID_ENUM_CONVERSION_1_2(name, p)); } m_param = temp; } device.state().save(this, m_param, this.name(), "m_param"); }
//PCOPYASSIGNMOVE(netlist_state_t, delete) /// \brief Destructor /// /// The destructor is virtual to allow implementation specific devices /// to connect to the outside world. For examples see MAME netlist.cpp. /// //virtual ~netlist_state_t() noexcept = default; //template<class C> static bool check_class <C>(core_device_t p) where C : core_device_t { return(p is C); //return dynamic_cast<C *>(p) != nullptr; }
//using value_t = value_base_t<nl_fptype>; //using value_str_t = value_base_t<pstring>; public param_model_t(core_device_t device, string name, string val) : base(device, name, val) { }
protected param_t(core_device_t device, string name) : base(device, device.name() + "." + name) { device.state().setup().register_param_t(this); }
string m_param; //host_arena::unique_ptr<pstring> m_param; public param_str_t(core_device_t device, string name, string val) : base(device, name) { m_param = val; //m_param = plib::make_unique<pstring, host_arena>(val); m_param = device.state().setup().get_initial_param_val(this.name(), val); //*m_param = device.state().setup().get_initial_param_val(this->name(),val); }
protected analog_t(core_device_t dev, string aname, state_e state, nldelegate delegate_) : base(dev, aname, state, delegate_) { }