DataAbstractModule::DataAbstractModule ( int inputs, int modputs, int outputs ) {
qDebug() << __PRETTY_FUNCTION__;
this->inputs=inputs;
this->modputs=modputs;
this->outputs=outputs;
for (int i = 0; i < ports(PortDirection::IN); ++i) {
DataPort* p = new DataPort(PortType::LIBNOISE, PortDirection::IN, i);
DataAbstractItem* portItem = dynamic_cast<DataAbstractItem*>(p);
portItem->setParent(this);
appendChild(portItem);
}
for (int i = 0; i < ports(PortDirection::MOD); ++i) {
DataPort* p = new DataPort(PortType::LIBNOISE, PortDirection::MOD, i);
DataAbstractItem* portItem = dynamic_cast<DataAbstractItem*>(p);
portItem->setParent(this);
appendChild(portItem);
}
for (int i = 0; i < ports(PortDirection::OUT); ++i) {
DataPort* p = new DataPort(PortType::LIBNOISE, PortDirection::OUT, i);
DataAbstractItem* portItem = dynamic_cast<DataAbstractItem*>(p);
portItem->setParent(this);
appendChild(portItem);
}
}
JointStatePublisher::JointStatePublisher(const std::string& name) :
RTT::TaskContext(name, PreOperational), msr_jnt_pos_port_("msrJntPos"),
joint_state_port_("joints_state"), joint_names_prop("joint_names",
"number of joints")
{
ports()->addPort(msr_jnt_pos_port_);
ports()->addPort(joint_state_port_);
this->addProperty(joint_names_prop);
}
JointStatePublisher::JointStatePublisher(const std::string& name) :
RTT::TaskContext(name, PreOperational), joint_names_prop("joint_names",
"number of joints"), number_of_joints_(0) {
ports()->addPort("JointPosition", port_joint_position_);
ports()->addPort("JointVelocity", port_joint_velocity_);
ports()->addPort("JointEffort", port_joint_effort_);
ports()->addPort("joint_state", joint_state_port_);
this->addProperty(joint_names_prop);
}
const QList<Entry> & get()
{
static QList<Entry> profiles;
static bool init=false;
if(!init)
{
static const char * constProfileDir="/etc/ufw/applications.d/";
QStringList files(QDir(constProfileDir).entryList());
QStringList::ConstIterator it(files.constBegin()),
end(files.constEnd());
for(; it!=end; ++it)
if((*it)!="." && (*it)!="..")
{
KConfig cfg(constProfileDir+(*it), KConfig::SimpleConfig);
QStringList groups(cfg.groupList());
QStringList::ConstIterator gIt(groups.constBegin()),
gEnd(groups.constEnd());
for(; gIt!=gEnd; ++gIt)
{
QString ports(cfg.group(*gIt).readEntry("ports", QString()));
if(!ports.isEmpty() && !profiles.contains(*gIt))
profiles.append(Entry(*gIt, ports));
}
}
qSort(profiles);
}
return profiles;
}
int lua_cbacks::udp_setpeername(lua_State *ls)
{
lua_getglobal(ls, "sichisel");
sinsp_chisel* ch = (sinsp_chisel*)lua_touserdata(ls, -1);
string addr(lua_tostring(ls, 1));
string ports(lua_tostring(ls, 2));
uint16_t port = htons(sinsp_numparser::parseu16(ports));
ch->m_udp_socket = socket(AF_INET, SOCK_DGRAM, 0);
if(ch->m_udp_socket < 0)
{
string err = "udp_setpeername error: unable to create the socket";
fprintf(stderr, "%s\n", err.c_str());
throw sinsp_exception("chisel error");
}
memset(&ch->m_serveraddr, 0, sizeof(ch->m_serveraddr));
ch->m_serveraddr.sin_family = AF_INET;
ch->m_serveraddr.sin_port = port;
if(inet_pton(AF_INET, addr.c_str(), &ch->m_serveraddr.sin_addr) <= 0)
{
string err = "inet_pton error occured";
fprintf(stderr, "%s\n", err.c_str());
throw sinsp_exception("chisel error");
}
return 0;
}
void Source::setActivePortIndex(quint32 port_index)
{
Port *port = qobject_cast<Port *>(ports().at(port_index));
if (!port) {
qCWarning(PLASMAPA) << "invalid port set request" << port_index;
return;
}
context()->setGenericPort(index(), port->name(), &pa_context_set_source_port_by_index);
}
Appender::Appender(std::string name) :
RTT::TaskContext(name),
appender(0),
layoutName_prop("LayoutName", "Layout name (e.g. 'simple', 'pattern')"),
layoutPattern_prop("LayoutPattern", "Layout conversion pattern (for those layouts that use a pattern)")
{
ports()->addEventPort("LogPort", log_port );
properties()->addProperty(layoutName_prop);
properties()->addProperty(layoutPattern_prop);
}
// Derived port finder.
qjackctlAlsaPort *qjackctlAlsaClient::findPort ( int iAlsaPort )
{
QListIterator<qjackctlPortItem *> iter(ports());
while (iter.hasNext()) {
qjackctlAlsaPort *pPort
= static_cast<qjackctlAlsaPort *> (iter.next());
if (iAlsaPort == pPort->alsaPort())
return pPort;
}
return NULL;
}
int main(int argc, char *argv[])
{
paracel::str_type init_port = paracel::gen_init_port();
auto ports_tmp = paracel::get_hostnames_string(1, "7773");
paracel::str_type ports(ports_tmp.begin() + 8, ports_tmp.end());
paracel::kvclt kvc("beater7", ports);
{
paracel::str_type key0 = "key_0";
paracel::str_type key1 = "key_1";
kvc.push_int(key0, 1);
kvc.push_int(key1, 2);
}
{
paracel::str_type key0 = "key_0";
kvc.incr_int(key0, 9);
std::cout << kvc.pull_int(key0) << std::endl;;
}
return 0;
}
QVariant RouterModel::data(const QModelIndex & index, int role) const
{
if (!index.isValid())
return QVariant();
const bt::UPnPRouter* r = routers.at(index.row());
if (role == Qt::DisplayRole)
{
switch (index.column())
{
case 0:
return r->getDescription().friendlyName;
case 1:
if (!r->getError().isEmpty())
return r->getError();
else
return ports(r);
}
}
else if (role == Qt::DecorationRole)
{
if (index.column() == 0)
return KIcon("modem");
else if (index.column() == 1 && !r->getError().isEmpty())
return KIcon("dialog-error");
}
else if (role == Qt::ToolTipRole)
{
if (index.column() == 0)
{
const bt::UPnPDeviceDescription & d = r->getDescription();
return i18n(
"Model Name: <b>%1</b><br/>"
"Manufacturer: <b>%2</b><br/>"
"Model Description: <b>%3</b><br/>",d.modelName,d.manufacturer,d.modelDescription);
}
else if (index.column() == 1 && !r->getError().isEmpty())
return r->getError();
}
return QVariant();
}
Mops_Rec::Mops_Rec(std::string const& name) :
TaskContext(name, PreOperational),
_verbose(false),
_priority(defPriority),
_cpu(defCpu)
{
// Add operations
addOperation("addSub",
&Mops_Rec::_addSub,
this,
RTT::OwnThread).
doc("Add subscribtion topic").
arg("topic", "New topic to subscribe");
// Add attributes
addAttribute("verbose", _verbose);
addAttribute("priority", _priority);
addAttribute("cpu", _cpu);
// Add output ports
ports()->addPort("outPort", _outPort).doc("Receiver output port");
if(_verbose)
std::cout << "Mops_Rec constructed !" <<std::endl;
}
void
CCDReader4qxml::componentfeatures (DOMElement* element)
throw(CCDReadException)
{
DOMNode* child = element->getFirstChild();
while (child != 0)
{
if (child->getNodeType() == DOMNode::ELEMENT_NODE)
{
//
// ports
//
if (!XMLString::compareString(child->getNodeName(), X("ports")))
{
ports((DOMElement*)child);
}
}
// get next child
child = child->getNextSibling();
}
}
void basicTests()
{
TestSink sink {*this};
TestThread thread;
sink.threshold (beast::severities::Severity::kAll);
beast::Journal journal {sink};
TestHandler handler;
auto s = make_Server (handler,
thread.get_io_service(), journal);
std::vector<Port> list;
list.resize(1);
list.back().port = testPort;
list.back().ip = boost::asio::ip::address::from_string (
"127.0.0.1");
list.back().protocol.insert("http");
s->ports (list);
test_request();
//test_keepalive();
//s->close();
s = nullptr;
pass();
}
void ladspaBrowserView::showPorts( const ladspa_key_t & _key )
{
ladspaPortDialog ports( _key );
ports.exec();
}
MessagePortArray ServiceWorkerMessageEvent::ports() const
{
bool unused;
return ports(unused);
}
/** Converts this policy to a form Tor understands. The format is:
* "accept|reject ADDR[/MASK][:PORT]"
*
* PORT can be a single port number, an interval of ports "FROM_PORT-TO_PORT",
* or "*". If PORT is omitted, that means "*"
*/
QString
Policy::toString() const
{
QString act = (_action == Accept ? "accept" : "reject");
return act + " " + address() + ":" + ports();
}
NS_IMETHODIMP
InputPortManager::NotifySuccess(nsIArray* aDataList)
{
MOZ_ASSERT(aDataList);
if (!aDataList) {
RejectPendingGetInputPortsPromises(NS_ERROR_DOM_ABORT_ERR);
return NS_ERROR_INVALID_ARG;
}
uint32_t length;
nsresult rv = aDataList->GetLength(&length);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
nsCOMPtr<nsIInputPortListener> portListener;
rv = mInputPortService->GetInputPortListener(
getter_AddRefs(portListener));
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
ErrorResult erv;
nsTArray<nsRefPtr<InputPort>> ports(length);
for (uint32_t i = 0; i < length; i++) {
nsCOMPtr<nsIInputPortData> portData = do_QueryElementAt(aDataList, i);
if (NS_WARN_IF(!portData)) {
continue;
}
InputPortData* data = static_cast<InputPortData*>(portData.get());
nsRefPtr<InputPort> port;
switch (data->GetType()) {
case InputPortType::Av:
port = AVInputPort::Create(GetParentObject(), portListener,
portData, erv);
break;
case InputPortType::Displayport:
port = DisplayPortInputPort::Create(GetParentObject(),
portListener, portData, erv);
break;
case InputPortType::Hdmi:
port = HDMIInputPort::Create(GetParentObject(), portListener,
portData, erv);
break;
default:
MOZ_ASSERT_UNREACHABLE("Unknown InputPort type");
break;
}
MOZ_ASSERT(port);
ports.AppendElement(port);
}
if (NS_WARN_IF(erv.Failed())) {
return erv.StealNSResult();
}
erv = SetInputPorts(ports);
return erv.StealNSResult();
}
void lv2BrowserView::showPorts( const lv2_key_t & _key )
{
lv2PortDialog ports( _key );
ports.exec();
}
MessagePortArray ExtendableMessageEvent::ports() const {
bool unused;
return ports(unused);
}
void stressTest()
{
struct NullHandler
{
bool
onAccept (Session& session,
boost::asio::ip::tcp::endpoint endpoint)
{
return true;
}
Handoff
onHandoff (Session& session,
std::unique_ptr <beast::asio::ssl_bundle>&& bundle,
http_request_type&& request,
boost::asio::ip::tcp::endpoint remote_address)
{
return Handoff{};
}
Handoff
onHandoff (Session& session, boost::asio::ip::tcp::socket&& socket,
http_request_type&& request,
boost::asio::ip::tcp::endpoint remote_address)
{
return Handoff{};
}
void
onRequest (Session& session)
{
}
void
onWSMessage(std::shared_ptr<WSSession> session,
std::vector<boost::asio::const_buffer> const& buffers)
{
}
void
onClose (Session& session,
boost::system::error_code const&)
{
}
void
onStopped (Server& server)
{
}
};
NullHandler h;
for(int i = 0; i < 1000; ++i)
{
TestThread thread;
auto s = make_Server(h,
thread.get_io_service(), {});
std::vector<Port> list;
list.resize(1);
list.back().port = testPort;
list.back().ip = boost::asio::ip::address::from_string (
"127.0.0.1");
list.back().protocol.insert("http");
s->ports (list);
}
}
int main(int argc, char *argv[])
{
auto ports_tmp = paracel::get_hostnames_string(1);
paracel::str_type ports(ports_tmp.begin() + 8, ports_tmp.end());
paracel::kvclt kvc("beater7", ports);
{
paracel::str_type key0 = "test_key0";
kvc.push(key0, 1);
paracel::str_type key = "test_key";
paracel::str_type key10 = "test_key10";
kvc.push(key10, 10);
auto r = kvc.push(key, 2);
std::cout << r << std::endl;
auto r2 = kvc.pull<int>(key);
std::cout << r2 << std::endl;
}
{
paracel::str_type key = "test_key1";
auto r = kvc.push(key, paracel::str_type("sa"));
std::cout << r << std::endl;
auto r2 = kvc.pull<paracel::str_type>(key);
std::cout << r2 << std::endl;
}
{
paracel::str_type key2 = "test_key2";
paracel::list_type<double> val2 = {1., 2., 0., 3., 4.};
auto r_new = kvc.push(key2, val2);
std::cout << r_new << std::endl;
auto r2_new = kvc.pull<paracel::list_type<double> >(key2);
for(auto & v : r2_new) {
std::cout << v << std::endl;
}
}
{
paracel::str_type key = "test_key3";
paracel::str_type key2 = "test_key";
std::cout << kvc.contains(key) << std::endl;
std::cout << kvc.contains(key2) << std::endl;
}
{
paracel::str_type key = "test_keyn";
paracel::str_type key2 = "test_key";
auto r = kvc.push(key, 7);
std::cout << r << std::endl;
int r2;
kvc.pull(key, r2);
std::cout << r2 << std::endl;
std::cout << "contain " << kvc.contains(key) << std::endl;
kvc.remove(key);
int tt = 0;
for(int i = 0; i < 1000000; ++i) {
tt += i;
}
int r3;
//std::cout << "remove this " << kvc.pull<int>(key) << std::endl;
//std::cout << "remove this " << kvc.pull<int>(key) << std::endl;
std::cout << "not remove this " << kvc.pull<int>(key2) << std::endl;
std::cout << "not contain " << kvc.contains(key) << std::endl;
std::cout << "contain " << kvc.contains(key2) << std::endl;
kvc.clear();
for(int i = 0; i < 1000000; ++i) {
tt += i;
}
//std::cout << "after clear " << kvc.pull<int>(key2) << std::endl;
//std::cout << "after clear " << kvc.pull<int>(key2) << std::endl;
//std::cout << "after clear " << kvc.pull<int>(key2) << std::endl;
}
{
paracel::str_type key7 = "key";
paracel::str_type val7 = "abcsadsABCDrv";
//paracel::str_type val7 = "PARACELparasolPARASOL";
auto r = kvc.push(key7, val7);
std::cout << r << std::endl;
auto r2 = kvc.pull<paracel::str_type>(key7);
std::cout << "*" << r2 << "*"<< std::endl;
}
{
paracel::str_type key8 = "key8";
std::unordered_map<paracel::str_type, paracel::list_type<double> > d;
paracel::list_type<double> target1 = {1.11, 2.22, 3.33};
paracel::list_type<double> target2 = {3.33, 2.22, 1.11};
d["key_0"] = target1;
d["key_1"] = target2;
kvc.push(key8, d);
auto r = kvc.pull<std::unordered_map<paracel::str_type, paracel::list_type<double> > >(key8);
for(auto & v : r) {
std::cout << v.first << ":";
for(auto & val : v.second) {
std::cout << val << "|";
}
std::cout << std::endl;
}
}
{
paracel::str_type kk = "kk";
int aa = 77, bb = 88;
kvc.push(kk, aa);
paracel::str_type kkk = "kkk";
kvc.push(kkk, bb);
paracel::list_type<paracel::str_type> s = {"kk", "kkk"};
std::cout << kvc.pull<int>(paracel::str_type("kk")) << std::endl;
std::cout << kvc.pull<int>(paracel::str_type("kkk")) << std::endl;
auto r = kvc.pull_multi<int>(s);
for(auto & v : r) {
std::cout << v << std::endl;
}
}
/*
{
std::unordered_map<paracel::str_type, int> tmp{std::pair<paracel::str_type, int>(paracel::str_type("x"), 100), std::pair<paracel::str_type, int>(paracel::str_type("y"), 200)};
kvc.push_multi(tmp);
std::cout << kvc.contains(paracel::str_type("x")) << std::endl;
std::cout << kvc.pull<int>(paracel::str_type("x")) << std::endl;
}
*/
return 0;
}
bool firewire_source::try_open()
{
auto_raw1394 handle(raw1394_new_handle());
if (!handle.get())
return false;
raw1394_set_userdata(handle.get(), this);
int n_ports = raw1394_get_port_info(handle.get(), NULL, 0);
std::vector<raw1394_portinfo> ports(n_ports);
if (n_ports > 0)
{
int n_ports_again =
raw1394_get_port_info(handle.get(), &ports[0], n_ports);
if (n_ports > n_ports_again)
{
n_ports = n_ports_again;
ports.resize(n_ports);
}
}
if (n_ports == 0)
{
fprintf(stderr, "ERROR: No Firewire ports accessible\n");
return false;
}
// Try converting name to an integer
char * end;
int i = strtoul(port_name_.c_str(), &end, 10);
// If we didn't convert the whole string, assume it really is a name
if (*end)
for (i = 0; i != n_ports; ++i)
if (port_name_ == ports[i].name)
break;
if (i >= n_ports)
{
fprintf(stderr, "ERROR: %s: not found\n", port_name_.c_str());
return false;
}
if (verbose)
printf("INFO: Reading from Firewire port %s\n", ports[i].name);
if (raw1394_set_port(handle.get(), i))
{
perror("raw1394_set_port");
return false;
}
if (raw1394_iso_recv_init(handle.get(), raw_receive, /*buf_packets=*/ 600,
/*max_packet_size=*/
CIF_HEADER_SIZE + CIF_PACKET_SIZE + 8,
/*channel=*/ 63,
/*mode=*/ RAW1394_DMA_DEFAULT,
/*irq_interval=*/ 100))
{
perror("raw1394_iso_recv_init");
return false;
}
if (raw1394_iso_recv_start(handle.get(), -1, -1, -1))
{
perror("raw1394_iso_recv_start");
raw1394_iso_shutdown(handle.get()); // see comment on destructor
return false;
}
handle_ = handle;
return true;
}
