void PublicationBase::update(void *data)
{
if (_handle != nullptr) {
int ret = orb_publish(getMeta(), getHandle(), data);
if (ret != PX4_OK) { warnx("publish fail"); }
} else {
orb_advert_t handle;
if (_priority > 0) {
handle = orb_advertise_multi(
getMeta(), data,
&_instance, _priority);
} else {
handle = orb_advertise(getMeta(), data);
}
if (int64_t(handle) != PX4_ERROR) {
setHandle(handle);
} else {
warnx("advert fail");
}
}
}
Subscription<T>::Subscription(
List<SubscriptionBase *> * list,
const struct orb_metadata *meta, unsigned interval) :
T(), // initialize data structure to zero
SubscriptionBase(list, meta) {
setHandle(orb_subscribe(getMeta()));
orb_set_interval(getHandle(), interval);
}
SubscriptionBase::SubscriptionBase(const struct orb_metadata *meta,
unsigned interval, unsigned instance) :
_meta(meta),
_instance(instance),
_handle()
{
if (_instance > 0) {
_handle = orb_subscribe_multi(
getMeta(), instance);
} else {
_handle = orb_subscribe(getMeta());
}
if (_handle < 0) { warnx("sub failed"); }
orb_set_interval(getHandle(), interval);
}
int main(int argc, char** argv) {
QApplication app(argc, argv);
const auto handler = new Bridge(nullptr);
QString str;
QTextStream output(&str);
getMeta(handler, output);
qDebug() << qPrintable(str);
return 0;
}
void getMeta(const QObject* object, QTextStream& output) {
const auto metaObject = object->metaObject();
// properties
const auto propertyCount = metaObject->propertyCount();
for (int i = 0; i < propertyCount; i++) {
const auto property = metaObject->property(i);
if (QString(property.typeName()).endsWith("*")) {
const auto propertyObject = object->property(property.name());
getMeta(qvariant_cast<QObject*>(propertyObject), output);
output << "Object" << " "
<< property.typeName() << " "
<< qPrintable(QString(metaObject->className()) + "::" + property.name())
<< endl;
} else {
output << "Property" << " "
<< property.typeName() << " "
<< qPrintable(QString(metaObject->className()) + "::" + property.name())
<< endl;
}
}
// methods
const auto methodCount = metaObject->methodCount();
for (int i = 0; i < methodCount; i++) {
const auto method = metaObject->method(i);
switch (method.methodType()) {
case QMetaMethod::Slot: {
if (method.access() == QMetaMethod::Public) {
output << "Slot" << " "
<< method.typeName() << " "
<< qPrintable(QString(metaObject->className()) + "::" + method.methodSignature().constData())
<< endl;
}
break;
}
case QMetaMethod::Signal: {
output << "Signal" << " "
<< method.typeName() << " "
<< qPrintable(QString(metaObject->className()) + "::" + method.methodSignature().constData())
<< endl;
break;
}
default: {
}
}
}
}
static int read_directory(const char *path, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi) {
filler(buf, ".", NULL, 0);
filler(buf, "..", NULL, 0);
fmeta *meta;
int metaNum = getMeta(path, &meta);
if (metaNum == -1) return -ENOENT;
char *data;
int size = readData(meta, &data);
int i = 0, n = size/sizeof(int);
while (i < n) {
filler(buf, fs.meta[((int*)data)[i]].name, NULL, 0);
i++;
}
return 0;
}
int mkdir_op(const char *path, mode_t mode) {
return create_file(path, mode | S_IFDIR);
static int unlink(const char* path) {
if (deleteFile(path) != 0) return -1;
return 0;
}
static int write(const char *path, const char *buf, size_t off_t offset, struct fuse_file_info *fi) {
fmeta *meta;
int metaNum = getMeta(path, &meta);
if (metaNum == -1) return -ENOENT;
int s = writeData(meta, buf, nbytes, offset);
if (s != -1) {
writeMeta(metaNum);
return s;
}
return -1;
}
void TExampleForMissing::resetExample()
{
checkProperty(dataDescription);
DCs.clear();
DKs.clear();
float averageWeight=1;
TVarList::const_iterator vi(domain->attributes->begin()), vie(domain->attributes->end());
TExample::iterator ei(begin()), bei(ei);
vector<float>::const_iterator ai(dataDescription->averages.begin()), aei(dataDescription->averages.end());
for(; vi!=vie; ei++, vi++) {
if ((*ei).isSpecial()) {
if ((*vi)->varType==TValue::FLOATVAR)
*ei=TValue(*ai);
else if (dataDescription->missingWeight && (*ei).isDK()) {
DKs.push_back(ei-bei);
averageWeight/=float((*vi)->noOfValues());
}
else
DCs.push_back(ei-bei);
(*vi)->firstValue(*ei);
}
if (ai!=aei)
ai++;
}
if (dataDescription->missingWeight) {
float weight = dataDescription->originalWeight ? getMeta(dataDescription->originalWeight).floatV : 1;
if (dataDescription->domainDistributions) {
TDomainDistributions::const_iterator di(dataDescription->domainDistributions->begin());
ITERATE(vector<int>, ci, DKs) {
// DKs contain only discrete variables, so it is safe to cast
const TDiscDistribution &dist = CAST_TO_DISCDISTRIBUTION(*(di+*ci));
if (dist.abs)
weight *= dist.front() / dist.abs;
}
}
int MediaLibrary::controlMedia( int query, va_list args )
{
auto mediaId = va_arg( args, int64_t );
auto m = m_ml->media( mediaId );
if ( m == nullptr )
return VLC_EGENERIC;
switch( query )
{
case VLC_ML_MEDIA_INCREASE_PLAY_COUNT:
if ( m->increasePlayCount() == false )
return VLC_EGENERIC;
return VLC_SUCCESS;
case VLC_ML_MEDIA_GET_MEDIA_PLAYBACK_PREF:
{
auto meta = va_arg( args, int );
auto res = va_arg( args, char** );
return getMeta( *m, meta, res );
}
case VLC_ML_MEDIA_SET_MEDIA_PLAYBACK_PREF:
{
auto meta = va_arg( args, int );
auto value = va_arg( args, const char* );
return setMeta( *m, meta, value );
}
case VLC_ML_MEDIA_SET_THUMBNAIL:
{
auto mrl = va_arg( args, const char* );
m->setThumbnail( mrl );
return VLC_SUCCESS;
}
case VLC_ML_MEDIA_GENERATE_THUMBNAIL:
{
auto res = m_ml->requestThumbnail( m );
return res == true ? VLC_SUCCESS : VLC_EGENERIC;
}
case VLC_ML_MEDIA_ADD_EXTERNAL_MRL:
{
auto mrl = va_arg( args, const char* );
auto type = va_arg( args, int );
medialibrary::IFile::Type mlType;
switch ( type )
{
case VLC_ML_FILE_TYPE_UNKNOWN:
// The type can't be main since this is added to an existing media
// which must already have a file
case VLC_ML_FILE_TYPE_MAIN:
case VLC_ML_FILE_TYPE_PLAYLIST:
return VLC_EGENERIC;
case VLC_ML_FILE_TYPE_PART:
mlType = medialibrary::IFile::Type::Part;
break;
case VLC_ML_FILE_TYPE_SOUNDTRACK:
mlType = medialibrary::IFile::Type::Soundtrack;
break;
case VLC_ML_FILE_TYPE_SUBTITLE:
mlType = medialibrary::IFile::Type::Subtitles;
break;
default:
vlc_assert_unreachable();
}
if ( m->addExternalMrl( mrl, mlType ) == nullptr )
return VLC_EGENERIC;
return VLC_SUCCESS;
}
default:
vlc_assert_unreachable();
}
}
void GSVWrapper::processQueue()
{
if (requestQueue.isEmpty()) {
qDebug() << "GSVWrapper::processQueue(): requestQueue is empty";
return;
} else {
qDebug() << "GSVWrapper::processQueue()";
printRequests(); // Debug
}
foreach(QSharedPointer<Request> req, requestQueue) {
switch (req->state()) {
case Request::Unready:
req->setState(Request::Running);
switch (req->type()) {
case Request::Pano: {
qDebug() << "Requesting panorama" << req->lat << req->lng;
if (req->getMetadata() != 0) {
// Metadata is already fetched
QVector2D v = getZoomLevel(req->zoomLevel);
qDebug() << QString("Zoomlevel %1 max x = %2 and max y = %3").arg(req->zoomLevel).arg(v.x()).arg(v.y());
// Here is tile logic
for (int x = 0; x < v.x(); x++) {
for (int y = 0; y < v.y(); y++) {
QImage tile = filehandler.getTile(req->getMetadata()->lat.toDouble(),
req->getMetadata()->lng.toDouble(),
x, y, req->zoomLevel);
if (tile.isNull()) { // Must get tile from network
networkhandler.getTile(req->id,
req->getMetadata()->pano_id,
req->zoomLevel,
x, y, req->priority);
} else { // Tile found from cache
// Save tile to current panorama
Tile *t = new Tile(x, y, req->zoomLevel, tile);
req->getPanorama()->addTile(*t);
emit tileReady(tile, req->lat, req->lng, x, y, req->zoomLevel);
}
}
}
} else { // Panorama request, but must fetch first metadata
qDebug() << "Get metadata first for" << req->id;
getMeta(req);
}
}
break;
case Request::Meta:
qDebug() << "Requesting metafield" << req->fieldName;
networkhandler.getMeta(req->id, req->lat, req->lng);
break;
default:
qDebug() << "GSVWrapper::handleMetadata: Error: Unkown request type";
break;
}
break;
case Request::Running:
break;
case Request::Ready:
break;
default:
qDebug() << "Unknown request state";
break;
}
}
removeReadyRequests();
}
