text:
require recipes-graphics/images/core-image-x11.bb
include core-image-x11.inc

DESCRIPTION = "Image with x11 support that includes everything within \
core-image-x11 plus meta-toolchain, development headers and libraries to \
form a standalone SDK."

IMAGE_FEATURES += "dev-pkgs tools-sdk tools-debug debug-tweaks ssh-server-openssh"

IMAGE_INSTALL += "kernel-dev \
				  ltp"


text:
DESCRIPTION = "Bootchart is a tool for performance analysis and visualization of the GNU/Linux boot process."
LICENSE = "GPLv2"
HOMEPAGE = "http://www.bootchart.org/"
MAINTAINER = "Koen Kooi <koen@dominion.kabel.utwente.nl>"

#this only installs the loggers, you will need to run the renderers on your workstation
#boot with 'init=/sbin/bootchartd' and do '/sbin/bootchartd stop' to end the logging

#needed for a real /bin/sh and /bin/sleep
DEPENDS = "bash coreutils"
RDEPENDS = "bash coreutils"

#this is a plain shell script
PACKAGE_ARCH = "all"

SRC_URI = "file://bootchart \
	   file://bootchartd \
	   file://bootchartd.conf"

do_install() {
	install -d ${D}/sbin
	install -d ${D}/etc
	install -m 755 ${WORKDIR}/bootchart ${D}/sbin
	install -m 755 ${WORKDIR}/bootchartd ${D}/sbin
	install -m 644 ${WORKDIR}/bootchart ${D}/etc
}

license: MIT

repository: BackupTheBerlios/openslug-svn

license_type: permissive

repo_name: BackupTheBerlios/openslug-svn

branch_name: refs/heads/master

extension: bb


text:
SECTION = "x11/wm"
SUMMARY = "Metacity is the boring window manager for the adult in you"
LICENSE = "GPLv2+"
LIC_FILES_CHKSUM = "file://COPYING;md5=b4cce53560b8e619ffa7c830fb8761aa \
                    file://src/include/main.h;endline=24;md5=72148ede07a6dadd01de6a882d20a9ad"

DEPENDS = "gsettings-desktop-schemas startup-notification \
           gnome-doc-utils gdk-pixbuf-native \
           gtk+3 glib-2.0 libcanberra libgtop intltool-native"

inherit autotools gettext gnomebase distro_features_check
# depends on startup-notification which depends on virtual/libx11
REQUIRED_DISTRO_FEATURES = "x11"

SRC_URI = "git://github.com/GNOME/metacity.git;branch=master \
           file://0001-drop-zenity-detection.patch \
"

S = "${WORKDIR}/git"
SRCREV = "c0d4b2fc0fcd6f2d3c37da935923f9e9ed5eb99f"

EXTRA_OECONF += "--disable-xinerama"

do_configure_prepend() {
    cd ${S}
    aclocal --install || exit 1
    autoreconf --verbose --force --install -Wno-portability || exit 1
    cd -

}

FILES_${PN} += "${datadir}/themes ${datadir}/gnome-control-center ${datadir}/gnome"
RDEPENDS_${PN} += "gsettings-desktop-schemas"

repository: astarche/meta-openembedded

repo_name: astarche/meta-openembedded

branch_name: refs/heads/nilrt/master/sumo

gha_license_id: MIT


text:
package portunus

import (
	"bytes"
	"log"
)

var (
	buf bytes.Buffer
	logger = log.New(&buf, "logger ", log.Lshortfile)
)

repository: fossabot/portunus

repo_name: fossabot/portunus

extension: go


text:
@article{jamaluddin_proteomic_2019,
 abstract = {© The Author(s) 2018. Uterine leiomyomas (fibroids) are the most common gynecological tumors, which are enriched in the extracellular matrix (ECM). Fibroids are leading cause of abnormal uterine bleeding and hysterectomy. One of the major questions yet to be answered is the overproduction of specific ECM components in human uterine fibroids, particularly in relation to mutations in the driver gene mediator complex subunit 12 (MED12). Surgical specimens from 14 patients with uterine leiomyoma having fibroids and corresponding adjacent normal myometrium (ANM) were utilized to analyze genetic and proteomic expression patterns in the tissue samples. MED12 mutations in the fibroids were screened by Sanger sequencing. iTRAQ was used to label the peptides in small-, medium-, and large-sized fibroid samples of annotated MED12 mutation from the same patient. The mixtures of the peptides were fractionated by hydrophilic interaction liquid chromatography (HILIC) and analyzed by liquid chromatography–tandem mass spectrometry (LC-MS/MS) to identify the differential expression proteins. Using isobaric tagged-based quantitative mass spectrometry on 3 selected patients, ECM-related protein tenascin-C (TNC) was observed significantly upregulated (\textgreater1.5-fold) with a confidence corresponding to false discovery rate (FDR) \textless1% in small-, medium-, and large-sized fibroid samples regardless of MED12 mutation status. The TNC was validated on additional patient samples using Western blotting (WB) and immunohistochemistry (IHC) and confirmed significant overexpression of this protein in fibroids compared to matched ANM. Proteomic analyses have identified the increased ECM protein expression, TNC, as a hallmark of uterine fibroids regardless of MED12 mutations. Further functional studies focusing on the upregulated ECM proteins in leiomyogenesis will lead to the identification of novel ECM drug targets for fibroid treatment.},
 author = {Jamaluddin, M.F.B. and Nagendra, P.B. and Nahar, P. and Oldmeadow, C. and Tanwar, P.S.},
 doi = {10.1177/1933719118773420},
 issn = {1933-7205},
 journal = {Reproductive Sciences},
 month = {April},
 number = {4},
 pages = {476--486},
 title = {Proteomic Analysis Identifies Tenascin-C Expression Is Upregulated in Uterine Fibroids},
 volume = {26},
 year = {2019}
}

repository: ChrisOldmeadow/academic-kickstart

repo_name: ChrisOldmeadow/academic-kickstart

extension: bib


text:
package test

import (
	"local/biz/ac"
	"local/biz/mdl"
	"local/biz/modules/config"
	"local/biz/modules/demo"
)

// some test datas
const (
	TestDBUser   = "biz_test"
	TestPassword = "pwd"

	DropTestDB    = true
	NotDropTestDB = false
)

// some permissions
var (
	ConfigPermissions   []ac.Permission = []ac.Permission{config.PermissionCreateConfig, config.PermissionReadConfig, config.PermissionEditConfig}
	DemoDataPermissions []ac.Permission = []ac.Permission{demo.PermissionUpdateContent, demo.PermissionReadData}

	// AllPermissions []string = append(ConfigPermissions, DemoDataPermissions...)
	// AllStringPermissions []string = AllPermissions
)

// some test datas, should be used for testing only
var (
	TestDataVldGroups = []mdl.Group{{
		ID:          "TGROUP2",
		Name:        "nm",
		Permissions: []string{"ADMIN", "USER"},
	}, {
		ID:          "TGROUP3",
		Name:        "管理员",
		Permissions: []string{"ADMIN", "USER", "WATCHER"},
	},
	// {
	// 	ID: "SUPER",
	// 	Name: "超级管理员super admin",
	// 	Permissions: AllPermissions,
	// }
	}

	TestDataVldUsers = []mdl.User{{
		Username: "userOK1",
		Groups:   TestDataVldGroups,
		Password: "pwd",
		State:    mdl.UserStateOk,
	}}

	TestDataVldConfigs = []mdl.Config{
		{
			Key:    "testCfg",
			Type:   mdl.ConfigTypeString,
			Name:   "测试name",
			Module: "test",
		},
	}

	TestDataVldBranchs = []mdl.Branch{
		{
			No:        "BJ001",
			Name:      "001Name",
			Address:   "xxx Street",
			Tel:       "101-001-002",
			AdminDesc: "first branch",
			State:     mdl.BranchStateOff,
		},
		{
			No:        "BJ002",
			Name:      "002Name",
			Address:   "xxx Street2",
			Tel:       "101-001-003",
			AdminDesc: "second branch",
			State:     mdl.BranchStateOff,
		},
	}
)

repository: sxsteam/go-starter-biz

repo_name: sxsteam/go-starter-biz


text:
package domain

import (
	"encoding/json"
	"fmt"
	"regexp"
)

// SubscriberID is ID of the subscriber, unique within channel
type SubscriberID string

// SubscriberLocator is unique identifier of the PubSub subscriber, unique within channel
type SubscriberLocator struct {
	ChannelID    ChannelID
	SubscriberID SubscriberID
}

// MessageID is ID of the message, unique within channel
type MessageID string

// MessageLocator is unique identifier of the Message, unique within channel
type MessageLocator struct {
	ChannelID ChannelID
	MessageID MessageID
}

// Message is an atomic datagram of the PubSub communication
type Message struct {
	MessageLocator
	Content json.RawMessage
}

// AckHandle is an token to remove received (acknowledged) messages from a subscriber.
type AckHandle struct {
	SubscriberLocator
	Handle string
}

// see: doc/interface/validation_rule.md
var (
	subscriberIDRegexp = regexp.MustCompile("^[0-9a-z][0-9a-z_-]{0,62}$")
	messageIDRegexp    = regexp.MustCompile("^[0-9a-z][0-9a-z_-]{0,62}$")
)

// ParseSubscriberID try to parse ID
func ParseSubscriberID(str string) (SubscriberID, error) {
	if !subscriberIDRegexp.MatchString(str) {
		return SubscriberID(""), fmt.Errorf("SubscriberID must match with %s", subscriberIDRegexp.String())
	}
	return SubscriberID(str), nil
}

// ParseMessageID try to parse ID
func ParseMessageID(str string) (MessageID, error) {
	if !messageIDRegexp.MatchString(str) {
		return MessageID(""), fmt.Errorf("MessageID must match with %s", messageIDRegexp.String())
	}
	return MessageID(str), nil
}

branch_name: refs/heads/main


text:
require xserver-xorg.inc

COMPATIBLE_MACHINE = "(salvator-x|ebisu|ulcb|draak)"

SRC_URI += "file://musl-arm-inb-outb.patch \
            file://0001-configure.ac-Fix-check-for-CLOCK_MONOTONIC.patch \
            file://0003-modesetting-Fix-16-bit-depth-bpp-mode.patch \
            file://0003-Remove-check-for-useSIGIO-option.patch \
            file://0001-xf86pciBus.c-use-Intel-ddx-only-for-pre-gen4-hardwar.patch \
            file://0001-config-fix-NULL-value-detection-for-ID_INPUT-being-u.patch \
            "
SRC_URI[md5sum] = "3e47777ff034a331aed2322b078694a8"
SRC_URI[sha256sum] = "a732502f1db000cf36a376cd0c010ffdbf32ecdd7f1fa08ba7f5bdf9601cc197"

# These extensions are now integrated into the server, so declare the migration
# path for in-place upgrades.

RREPLACES_${PN} =  "${PN}-extension-dri \
                    ${PN}-extension-dri2 \
                    ${PN}-extension-record \
                    ${PN}-extension-extmod \
                    ${PN}-extension-dbe \
                   "
RPROVIDES_${PN} =  "${PN}-extension-dri \
                    ${PN}-extension-dri2 \
                    ${PN}-extension-record \
                    ${PN}-extension-extmod \
                    ${PN}-extension-dbe \
                   "
RCONFLICTS_${PN} = "${PN}-extension-dri \
                    ${PN}-extension-dri2 \
                    ${PN}-extension-record \
                    ${PN}-extension-extmod \
                    ${PN}-extension-dbe \
                   "

repository: renesas-rcar/meta-renesas

repo_name: renesas-rcar/meta-renesas

branch_name: refs/heads/dunfell

gha_language: BitBake


text:
@inproceedings{wen2011esscirc,
 author = { Cheng-Yuan Wen and Jeyanandh Paramesh and Larry Pileggi and Jing Li and SangBum Kim and Jonathan Proesel and Chung Lam},
 booktitle = {2011 Proceedings of the ESSCIRC (**ESSCIRC**)},
 doi = {10.1109/ESSCIRC.2011.6044997},
 issn = {1930-8833},
 keywords = {conference, CMOS analogue integrated circuits,antimony compounds,calibration,chalcogenide glasses,comparators (circuits),elemental semiconductors,germanium compounds,phase change memories,redundancy,silicon,tellurium compounds,Ge2Sb2Te5,IBM CMOS technology,PCRAM mushroom cells,Si,analog CMOS,capacitance 4.41 fF,combinatorial redundancy,digital calibration,embedded GST,nonvolatile phase-change random access memory cells,offset-minimized CMOS comparator,post-manufacturing calibration,post-silicon calibration,power 55.42 muW,size 90 nm,switchable resistances,voltage 1 V,Arrays,CMOS integrated circuits,Calibration,Generators,Phase change random access memory,Redundancy,Resistance},
 month = {Sept},
 note = {(Acceptance Rate: \underline{38\%}, 121 out of 314)},
 number = {},
 pages = {423--426},
 title = {Post-silicon calibration of analog {CMOS} using phase-change memory cells},
 volume = {},
 year = {2011}
}


text:
@article{De Haan-2022-Vegetation‐related,
    title = "Vegetation‐related influences on carbon and water dynamics of two temperate forage crops",
    author = "De Haan, Kevin  and
      Khomik, Myroslava  and
      Kessel, Eric  and
      Green, Adam  and
      Kompanizare, Mazda  and
      Helgason, Warren  and
      Macrae, Merrin L.  and
      Petrone, Richard M.",
    journal = "Agronomy Journal, Volume 114, Issue 3",
    volume = "114",
    number = "3",
    year = "2022",
    publisher = "Wiley",
    url = "https://aclanthology.org/G22-1001",
    doi = "10.1002/agj2.21056",
    pages = "1782--1799",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications

gha_language: Python


text:
package dashboards

import (
	"github.com/grafana/grafana/pkg/util"
	"math/rand"
	"os"
	"path/filepath"
	"runtime"
	"testing"
	"time"

	"github.com/grafana/grafana/pkg/bus"
	"github.com/grafana/grafana/pkg/models"
	"github.com/grafana/grafana/pkg/services/dashboards"

	"github.com/grafana/grafana/pkg/infra/log"
	. "github.com/smartystreets/goconvey/convey"
)

var (
	defaultDashboards = "testdata/test-dashboards/folder-one"
	brokenDashboards  = "testdata/test-dashboards/broken-dashboards"
	oneDashboard      = "testdata/test-dashboards/one-dashboard"
	containingId      = "testdata/test-dashboards/containing-id"
	unprovision       = "testdata/test-dashboards/unprovision"

	fakeService *fakeDashboardProvisioningService
)

func TestCreatingNewDashboardFileReader(t *testing.T) {
	Convey("creating new dashboard file reader", t, func() {
		cfg := &DashboardsAsConfig{
			Name:    "Default",
			Type:    "file",
			OrgId:   1,
			Folder:  "",
			Options: map[string]interface{}{},
		}

		Convey("using path parameter", func() {
			cfg.Options["path"] = defaultDashboards
			reader, err := NewDashboardFileReader(cfg, log.New("test-logger"))
			So(err, ShouldBeNil)
			So(reader.Path, ShouldNotEqual, "")
		})

		Convey("using folder as options", func() {
			cfg.Options["folder"] = defaultDashboards
			reader, err := NewDashboardFileReader(cfg, log.New("test-logger"))
			So(err, ShouldBeNil)
			So(reader.Path, ShouldNotEqual, "")
		})

		Convey("using full path", func() {
			fullPath := "/var/lib/grafana/dashboards"
			if runtime.GOOS == "windows" {
				fullPath = `c:\var\lib\grafana`
			}

			cfg.Options["folder"] = fullPath
			reader, err := NewDashboardFileReader(cfg, log.New("test-logger"))
			So(err, ShouldBeNil)

			So(reader.Path, ShouldEqual, fullPath)
			So(filepath.IsAbs(reader.Path), ShouldBeTrue)
		})

		Convey("using relative path", func() {
			cfg.Options["folder"] = defaultDashboards
			reader, err := NewDashboardFileReader(cfg, log.New("test-logger"))
			So(err, ShouldBeNil)

			resolvedPath := reader.resolvedPath()
			So(filepath.IsAbs(resolvedPath), ShouldBeTrue)
		})
	})
}

func TestDashboardFileReader(t *testing.T) {
	Convey("Dashboard file reader", t, func() {
		bus.ClearBusHandlers()
		origNewDashboardProvisioningService := dashboards.NewProvisioningService
		fakeService = mockDashboardProvisioningService()

		bus.AddHandler("test", mockGetDashboardQuery)
		logger := log.New("test.logger")

		Convey("Reading dashboards from disk", func() {

			cfg := &DashboardsAsConfig{
				Name:    "Default",
				Type:    "file",
				OrgId:   1,
				Folder:  "",
				Options: map[string]interface{}{},
			}

			Convey("Can read default dashboard", func() {
				cfg.Options["path"] = defaultDashboards
				cfg.Folder = "Team A"

				reader, err := NewDashboardFileReader(cfg, logger)
				So(err, ShouldBeNil)

				err = reader.startWalkingDisk()
				So(err, ShouldBeNil)

				folders := 0
				dashboards := 0

				for _, i := range fakeService.inserted {
					if i.Dashboard.IsFolder {
						folders++
					} else {
						dashboards++
					}
				}

				So(folders, ShouldEqual, 1)
				So(dashboards, ShouldEqual, 2)
			})

			Convey("Can read default dashboard and replace old version in database", func() {
				cfg.Options["path"] = oneDashboard

				stat, _ := os.Stat(oneDashboard + "/dashboard1.json")

				fakeService.getDashboard = append(fakeService.getDashboard, &models.Dashboard{
					Updated: stat.ModTime().AddDate(0, 0, -1),
					Slug:    "grafana",
				})

				reader, err := NewDashboardFileReader(cfg, logger)
				So(err, ShouldBeNil)

				err = reader.startWalkingDisk()
				So(err, ShouldBeNil)

				So(len(fakeService.inserted), ShouldEqual, 1)
			})

			Convey("Overrides id from dashboard.json files", func() {
				cfg.Options["path"] = containingId

				reader, err := NewDashboardFileReader(cfg, logger)
				So(err, ShouldBeNil)

				err = reader.startWalkingDisk()
				So(err, ShouldBeNil)

				So(len(fakeService.inserted), ShouldEqual, 1)
			})

			Convey("Invalid configuration should return error", func() {
				cfg := &DashboardsAsConfig{
					Name:   "Default",
					Type:   "file",
					OrgId:  1,
					Folder: "",
				}

				_, err := NewDashboardFileReader(cfg, logger)
				So(err, ShouldNotBeNil)
			})

			Convey("Broken dashboards should not cause error", func() {
				cfg.Options["path"] = brokenDashboards

				_, err := NewDashboardFileReader(cfg, logger)
				So(err, ShouldBeNil)
			})

			Convey("Two dashboard providers should be able to provisioned the same dashboard without uid", func() {
				cfg1 := &DashboardsAsConfig{Name: "1", Type: "file", OrgId: 1, Folder: "f1", Options: map[string]interface{}{"path": containingId}}
				cfg2 := &DashboardsAsConfig{Name: "2", Type: "file", OrgId: 1, Folder: "f2", Options: map[string]interface{}{"path": containingId}}

				reader1, err := NewDashboardFileReader(cfg1, logger)
				So(err, ShouldBeNil)

				err = reader1.startWalkingDisk()
				So(err, ShouldBeNil)

				reader2, err := NewDashboardFileReader(cfg2, logger)
				So(err, ShouldBeNil)

				err = reader2.startWalkingDisk()
				So(err, ShouldBeNil)

				var folderCount int
				var dashCount int
				for _, o := range fakeService.inserted {
					if o.Dashboard.IsFolder {
						folderCount++
					} else {
						dashCount++
					}
				}

				So(folderCount, ShouldEqual, 2)
				So(dashCount, ShouldEqual, 2)
			})
		})

		Convey("Should not create new folder if folder name is missing", func() {
			cfg := &DashboardsAsConfig{
				Name:   "Default",
				Type:   "file",
				OrgId:  1,
				Folder: "",
				Options: map[string]interface{}{
					"folder": defaultDashboards,
				},
			}

			_, err := getOrCreateFolderId(cfg, fakeService)
			So(err, ShouldEqual, ErrFolderNameMissing)
		})

		Convey("can get or Create dashboard folder", func() {
			cfg := &DashboardsAsConfig{
				Name:   "Default",
				Type:   "file",
				OrgId:  1,
				Folder: "TEAM A",
				Options: map[string]interface{}{
					"folder": defaultDashboards,
				},
			}

			folderId, err := getOrCreateFolderId(cfg, fakeService)
			So(err, ShouldBeNil)
			inserted := false
			for _, d := range fakeService.inserted {
				if d.Dashboard.IsFolder && d.Dashboard.Id == folderId {
					inserted = true
				}
			}
			So(len(fakeService.inserted), ShouldEqual, 1)
			So(inserted, ShouldBeTrue)
		})

		Convey("Walking the folder with dashboards", func() {
			noFiles := map[string]os.FileInfo{}

			Convey("should skip dirs that starts with .", func() {
				shouldSkip := createWalkFn(noFiles)("path", &FakeFileInfo{isDirectory: true, name: ".folder"}, nil)
				So(shouldSkip, ShouldEqual, filepath.SkipDir)
			})

			Convey("should keep walking if file is not .json", func() {
				shouldSkip := createWalkFn(noFiles)("path", &FakeFileInfo{isDirectory: true, name: "folder"}, nil)
				So(shouldSkip, ShouldBeNil)
			})
		})

		Convey("Given missing dashboard file", func() {
			cfg := &DashboardsAsConfig{
				Name:  "Default",
				Type:  "file",
				OrgId: 1,
				Options: map[string]interface{}{
					"folder": unprovision,
				},
			}

			fakeService.inserted = []*dashboards.SaveDashboardDTO{
				{Dashboard: &models.Dashboard{Id: 1}},
				{Dashboard: &models.Dashboard{Id: 2}},
			}

			absPath1, err := filepath.Abs(unprovision + "/dashboard1.json")
			So(err, ShouldBeNil)
			// This one does not exist on disc, simulating a deleted file
			absPath2, err := filepath.Abs(unprovision + "/dashboard2.json")
			So(err, ShouldBeNil)

			fakeService.provisioned = map[string][]*models.DashboardProvisioning{
				"Default": {
					{DashboardId: 1, Name: "Default", ExternalId: absPath1},
					{DashboardId: 2, Name: "Default", ExternalId: absPath2},
				},
			}

			Convey("Missing dashboard should be unprovisioned if DisableDeletion = true", func() {
				cfg.DisableDeletion = true

				reader, err := NewDashboardFileReader(cfg, logger)
				So(err, ShouldBeNil)

				err = reader.startWalkingDisk()
				So(err, ShouldBeNil)

				So(len(fakeService.provisioned["Default"]), ShouldEqual, 1)
				So(fakeService.provisioned["Default"][0].ExternalId, ShouldEqual, absPath1)

			})

			Convey("Missing dashboard should be deleted if DisableDeletion = false", func() {
				reader, err := NewDashboardFileReader(cfg, logger)
				So(err, ShouldBeNil)

				err = reader.startWalkingDisk()
				So(err, ShouldBeNil)

				So(len(fakeService.provisioned["Default"]), ShouldEqual, 1)
				So(fakeService.provisioned["Default"][0].ExternalId, ShouldEqual, absPath1)
				So(len(fakeService.inserted), ShouldEqual, 1)
				So(fakeService.inserted[0].Dashboard.Id, ShouldEqual, 1)
			})
		})

		Reset(func() {
			dashboards.NewProvisioningService = origNewDashboardProvisioningService
		})
	})
}

type FakeFileInfo struct {
	isDirectory bool
	name        string
}

func (ffi *FakeFileInfo) IsDir() bool {
	return ffi.isDirectory
}

func (ffi FakeFileInfo) Size() int64 {
	return 1
}

func (ffi FakeFileInfo) Mode() os.FileMode {
	return 0777
}

func (ffi FakeFileInfo) Name() string {
	return ffi.name
}

func (ffi FakeFileInfo) ModTime() time.Time {
	return time.Time{}
}

func (ffi FakeFileInfo) Sys() interface{} {
	return nil
}

func mockDashboardProvisioningService() *fakeDashboardProvisioningService {
	mock := fakeDashboardProvisioningService{
		provisioned: map[string][]*models.DashboardProvisioning{},
	}
	dashboards.NewProvisioningService = func() dashboards.DashboardProvisioningService {
		return &mock
	}
	return &mock
}

type fakeDashboardProvisioningService struct {
	inserted     []*dashboards.SaveDashboardDTO
	provisioned  map[string][]*models.DashboardProvisioning
	getDashboard []*models.Dashboard
}

func (s *fakeDashboardProvisioningService) GetProvisionedDashboardData(name string) ([]*models.DashboardProvisioning, error) {
	if _, ok := s.provisioned[name]; !ok {
		s.provisioned[name] = []*models.DashboardProvisioning{}
	}

	return s.provisioned[name], nil
}

func (s *fakeDashboardProvisioningService) SaveProvisionedDashboard(dto *dashboards.SaveDashboardDTO, provisioning *models.DashboardProvisioning) (*models.Dashboard, error) {
	// Copy the structs as we need to change them but do not want to alter outside world.
	var copyProvisioning = &models.DashboardProvisioning{}
	*copyProvisioning = *provisioning

	var copyDto = &dashboards.SaveDashboardDTO{}
	*copyDto = *dto

	if copyDto.Dashboard.Id == 0 {
		copyDto.Dashboard.Id = rand.Int63n(1000000)
	} else {
		err := s.DeleteProvisionedDashboard(dto.Dashboard.Id, dto.Dashboard.OrgId)
		// Lets delete existing so we do not have duplicates
		if err != nil {
			return nil, err
		}
	}

	s.inserted = append(s.inserted, dto)

	if _, ok := s.provisioned[provisioning.Name]; !ok {
		s.provisioned[provisioning.Name] = []*models.DashboardProvisioning{}
	}

	for _, val := range s.provisioned[provisioning.Name] {
		if val.DashboardId == dto.Dashboard.Id && val.Name == provisioning.Name {
			// Do not insert duplicates
			return dto.Dashboard, nil
		}
	}

	copyProvisioning.DashboardId = copyDto.Dashboard.Id

	s.provisioned[provisioning.Name] = append(s.provisioned[provisioning.Name], copyProvisioning)
	return dto.Dashboard, nil
}

func (s *fakeDashboardProvisioningService) SaveFolderForProvisionedDashboards(dto *dashboards.SaveDashboardDTO) (*models.Dashboard, error) {
	s.inserted = append(s.inserted, dto)
	return dto.Dashboard, nil
}

func (s *fakeDashboardProvisioningService) UnprovisionDashboard(dashboardId int64) error {
	for key, val := range s.provisioned {
		for index, dashboard := range val {
			if dashboard.DashboardId == dashboardId {
				s.provisioned[key] = append(s.provisioned[key][:index], s.provisioned[key][index+1:]...)
			}
		}
	}
	return nil
}

func (s *fakeDashboardProvisioningService) DeleteProvisionedDashboard(dashboardId int64, orgId int64) error {
	err := s.UnprovisionDashboard(dashboardId)
	if err != nil {
		return err
	}

	for index, val := range s.inserted {
		if val.Dashboard.Id == dashboardId {
			s.inserted = append(s.inserted[:index], s.inserted[util.MinInt(index+1, len(s.inserted)):]...)
		}
	}
	return nil
}

func (s *fakeDashboardProvisioningService) GetProvisionedDashboardDataByDashboardId(dashboardId int64) (*models.DashboardProvisioning, error) {
	return nil, nil
}

func mockGetDashboardQuery(cmd *models.GetDashboardQuery) error {
	for _, d := range fakeService.getDashboard {
		if d.Slug == cmd.Slug {
			cmd.Result = d
			return nil
		}
	}

	return models.ErrDashboardNotFound
}

gha_language: TypeScript


text:
# Generated by superflore -- DO NOT EDIT
#
# Copyright Open Source Robotics Foundation

inherit ros_distro_noetic
inherit ros_superflore_generated

DESCRIPTION = "Complete functionality tests for PR2. Contains utilities designed to test and verify devices, mechanicals and sensors."
AUTHOR = "David Feil-Seifer <dave@cse.unr.edu>"
ROS_AUTHOR = "Kevin Watts"
HOMEPAGE = "http://ros.org/wiki/pr2_bringup_tests"
SECTION = "devel"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://package.xml;beginline=7;endline=7;md5=d566ef916e9dedc494f5f793a6690ba5"

ROS_CN = "pr2_self_test"
ROS_BPN = "pr2_bringup_tests"

ROS_BUILD_DEPENDS = " \
    camera-calibration \
    ethercat-trigger-controllers \
    image-view \
    pr2-bringup \
    pr2-controller-manager \
    pr2-mannequin-mode \
"

ROS_BUILDTOOL_DEPENDS = " \
    catkin-native \
"

ROS_EXPORT_DEPENDS = " \
    camera-calibration \
    ethercat-trigger-controllers \
    image-view \
    pr2-bringup \
    pr2-controller-manager \
    pr2-mannequin-mode \
"

ROS_BUILDTOOL_EXPORT_DEPENDS = ""

ROS_EXEC_DEPENDS = " \
    camera-calibration \
    ethercat-trigger-controllers \
    image-view \
    pr2-bringup \
    pr2-controller-manager \
    pr2-mannequin-mode \
"

# Currently informational only -- see http://www.ros.org/reps/rep-0149.html#dependency-tags.
ROS_TEST_DEPENDS = ""

DEPENDS = "${ROS_BUILD_DEPENDS} ${ROS_BUILDTOOL_DEPENDS}"
# Bitbake doesn't support the "export" concept, so build them as if we needed them to build this package (even though we actually
# don't) so that they're guaranteed to have been staged should this package appear in another's DEPENDS.
DEPENDS += "${ROS_EXPORT_DEPENDS} ${ROS_BUILDTOOL_EXPORT_DEPENDS}"

RDEPENDS:${PN} += "${ROS_EXEC_DEPENDS}"

# matches with: https://github.com/pr2-gbp/pr2_self_test-release/archive/release/noetic/pr2_bringup_tests/1.0.15-1.tar.gz
ROS_BRANCH ?= "branch=release/noetic/pr2_bringup_tests"
SRC_URI = "git://github.com/pr2-gbp/pr2_self_test-release;${ROS_BRANCH};protocol=https"
SRCREV = "d2dc0fda5179e3015cf273125c420d84bce610a9"
S = "${WORKDIR}/git"

ROS_BUILD_TYPE = "catkin"

inherit ros_${ROS_BUILD_TYPE}

repository: DasRoteSkelett/meta-ros

repo_name: DasRoteSkelett/meta-ros


text:
package types

import (
	"time"

	proto "github.com/gogo/protobuf/proto"

	"github.com/cosmos/cosmos-sdk/codec/types"
	sdk "github.com/cosmos/cosmos-sdk/types"
	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
)

var (
	_ types.UnpackInterfacesMessage = &FeeAllowanceGrant{}
)

// NewFeeAllowanceGrant creates a new FeeAllowanceGrant.
//nolint:interfacer
func NewFeeAllowanceGrant(granter, grantee sdk.AccAddress, feeAllowance FeeAllowanceI) (FeeAllowanceGrant, error) {
	msg, ok := feeAllowance.(proto.Message)
	if !ok {
		return FeeAllowanceGrant{}, sdkerrors.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", feeAllowance)
	}

	any, err := types.NewAnyWithValue(msg)
	if err != nil {
		return FeeAllowanceGrant{}, err
	}

	return FeeAllowanceGrant{
		Granter:   granter.String(),
		Grantee:   grantee.String(),
		Allowance: any,
	}, nil
}

// ValidateBasic performs basic validation on
// FeeAllowanceGrant
func (a FeeAllowanceGrant) ValidateBasic() error {
	if a.Granter == "" {
		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "missing granter address")
	}
	if a.Grantee == "" {
		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "missing grantee address")
	}
	if a.Grantee == a.Granter {
		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "cannot self-grant fee authorization")
	}

	return a.GetFeeGrant().ValidateBasic()
}

// GetFeeGrant unpacks allowance
func (a FeeAllowanceGrant) GetFeeGrant() FeeAllowanceI {
	allowance, ok := a.Allowance.GetCachedValue().(FeeAllowanceI)
	if !ok {
		return nil
	}

	return allowance
}

// UnpackInterfaces implements UnpackInterfacesMessage.UnpackInterfaces
func (a FeeAllowanceGrant) UnpackInterfaces(unpacker types.AnyUnpacker) error {
	var allowance FeeAllowanceI
	return unpacker.UnpackAny(a.Allowance, &allowance)
}

// PrepareForExport will make all needed changes to the allowance to prepare to be
// re-imported at height 0, and return a copy of this grant.
func (a FeeAllowanceGrant) PrepareForExport(dumpTime time.Time, dumpHeight int64) FeeAllowanceGrant {
	feegrant := a.GetFeeGrant().PrepareForExport(dumpTime, dumpHeight)
	if feegrant == nil {
		return FeeAllowanceGrant{}
	}

	granter, err := sdk.AccAddressFromBech32(a.Granter)
	if err != nil {
		return FeeAllowanceGrant{}
	}

	grantee, err := sdk.AccAddressFromBech32(a.Grantee)
	if err != nil {
		return FeeAllowanceGrant{}
	}

	grant, err := NewFeeAllowanceGrant(granter, grantee, feegrant)
	if err != nil {
		return FeeAllowanceGrant{}
	}

	return grant
}

repository: sahith-narahari/cosmos-sdk

repo_name: sahith-narahari/cosmos-sdk


text:
SUMMARY = "Pure-Python interface to Apple Bonjour"

LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://setup.py;beginline=51;endline=51;md5=ba5f17915133a3b6556acac9dbcefe53"

PV = "1.1.1"
SRCREV = "82d0c1fb183b038d485fd21255d273734d81b531"
SRC_URI = "git://github.com/nickstenning/pybonjour.git"

S = "${WORKDIR}/git"

inherit distutils

repository: koenkooi/meta-maker

repo_name: koenkooi/meta-maker


text:
// Copyright 2022 Molecula Corp. (DBA FeatureBase).
// SPDX-License-Identifier: Apache-2.0
package pilosa

import (
	"context"
	"database/sql"
	"fmt"
	"strconv"
	"strings"

	"github.com/featurebasedb/featurebase/v3/pql"
	"github.com/featurebasedb/featurebase/v3/sql2"
)

type Planner struct {
	executor *executor
}

func NewPlanner(executor *executor) *Planner {
	return &Planner{executor: executor}
}

func (p *Planner) PlanStatement(ctx context.Context, stmt sql2.Statement) (*Stmt, error) {
	node, err := p.planStatement(ctx, stmt)
	if err != nil {
		return nil, err
	}
	return &Stmt{node: node}, nil
}

func (p *Planner) planStatement(ctx context.Context, stmt sql2.Statement) (StmtNode, error) {
	if err := p.checkStatement(stmt); err != nil {
		return nil, err
	}

	switch stmt := stmt.(type) {
	case *sql2.SelectStatement:
		return p.planSelectStatement(ctx, stmt)
	default:
		return nil, fmt.Errorf("cannot plan statement: %T", stmt)
	}
}

func (p *Planner) planSelectStatement(ctx context.Context, stmt *sql2.SelectStatement) (_ StmtNode, err error) {
	if stmt.IsAggregate() {
		return p.planAggregateSelectStatement(ctx, stmt)
	}
	return p.planNonAggregateSelectStatement(ctx, stmt)
}

func (p *Planner) planAggregateSelectStatement(ctx context.Context, stmt *sql2.SelectStatement) (_ StmtNode, err error) {
	// Handle specific case of a two-table INNER JOIN with a COUNT().
	if _, ok := stmt.Source.(*sql2.JoinClause); ok {
		return p.planAggregateCountJoin(ctx, stmt)
	}

	indexName, err := statementTableName(stmt)
	if err != nil {
		return nil, err
	}

	// Convert WHERE clause.
	cond, err := p.planExprPQL(ctx, stmt, stmt.WhereExpr)
	if err != nil {
		return nil, err
	}

	// Extract calls and grouped expressions from column list.
	// TODO: Recursively traverse all expression trees.
	var calls []*sql2.Call
	var columns []*StmtColumn
	var resultCols []string
	for _, c := range stmt.Columns {
		columns = append(columns, &StmtColumn{
			Name: c.Name(),
			Type: sql2.ExprDataType(c.Expr),
		})

		switch expr := c.Expr.(type) {
		case *sql2.Call:
			calls = append(calls, expr)
			resultCols = append(resultCols, "_aggregate")
		case *sql2.QualifiedRef:
			resultCols = append(resultCols, expr.Column.Name)
		default:
			return nil, fmt.Errorf("unsupported expression type in aggregate query: %T", expr)
		}
	}

	// TODO: Support multiple calls per query.
	if len(calls) > 1 {
		return nil, fmt.Errorf("only one aggregate call allowed")
	}

	// Extract column names in GROUP BY clause.
	var groupByCols []string
	for _, expr := range stmt.GroupByExprs {
		switch expr := expr.(type) {
		case *sql2.QualifiedRef:
			groupByCols = append(groupByCols, expr.Column.Name)
		default:
			return nil, fmt.Errorf("unsupported expression type in GROUP BY clause: %T", expr)
		}
	}

	// Extract aggregate call and build execution node.
	callName := strings.ToUpper(sql2.IdentName(calls[0].Name))
	switch callName {
	case "COUNT":
		if len(groupByCols) == 0 {
			if cond == nil {
				cond = &pql.Call{Name: "All"}
			}
			return NewCountNode(p.executor, indexName, columns[0], &pql.Call{
				Name:     "Count",
				Children: []*pql.Call{cond},
			}), nil
		}

		var aggregate *pql.Call
		if calls[0].Distinct.IsValid() {
			if len(calls[0].Args) != 1 {
				return nil, fmt.Errorf("distinct count must have exactly one field specified")
			}
			ref, ok := calls[0].Args[0].(*sql2.QualifiedRef)
			if !ok {
				return nil, fmt.Errorf("distinct count argument must be a field name")
			}

			aggregate = &pql.Call{
				Name: "Count",
				Children: []*pql.Call{{
					Name: "Distinct",
					Args: map[string]interface{}{"field": ref.Column.Name},
				}},
			}
		}

		return NewGroupByNode(p.executor, indexName, resultCols, groupByCols, columns, aggregate, cond), nil

	case "SUM":
		if len(calls[0].Args) != 1 {
			return nil, fmt.Errorf("sum must have exactly one field specified")
		}
		ref, ok := calls[0].Args[0].(*sql2.QualifiedRef)
		if !ok {
			return nil, fmt.Errorf("sum argument must be a field name")
		}

		aggregate := &pql.Call{
			Name: "Sum",
			Args: map[string]interface{}{"field": ref.Column.Name},
		}

		return NewGroupByNode(p.executor, indexName, resultCols, groupByCols, columns, aggregate, cond), nil

	default:
		return nil, fmt.Errorf("unsupported call in aggregate query: %s", callName)
	}

	// TODO: Support HAVING
}

func (p *Planner) planAggregateCountJoin(ctx context.Context, stmt *sql2.SelectStatement) (_ StmtNode, err error) {
	// Ensure we have an INNER JOIN.
	join := stmt.Source.(*sql2.JoinClause) // caller checked
	if !join.Operator.Inner.IsValid() {
		return nil, fmt.Errorf("only inner joins are currently supported")
	}

	// Determine the two tables we are joining.
	tbl0, ok := join.X.(*sql2.QualifiedTableName)
	if !ok {
		return nil, fmt.Errorf("left side of join must be a table")
	}
	tbl1, ok := join.Y.(*sql2.QualifiedTableName)
	if !ok {
		return nil, fmt.Errorf("left side of join must be a table")
	}

	// Ensure INNER JOIN has an "ON" constraint.
	if join.Constraint == nil {
		return nil, fmt.Errorf("joins must have an ON constraint")
	}
	cons, ok := join.Constraint.(*sql2.OnConstraint)
	if !ok {
		return nil, fmt.Errorf("joins only support an ON constraint")
	}

	// Determine the joined columns.
	cx, ok := cons.X.(*sql2.BinaryExpr)
	if !ok {
		return nil, fmt.Errorf("join must use a binary expression")
	} else if cx.Op != sql2.EQ {
		return nil, fmt.Errorf("join must use an equality expression")
	}

	// Extract join columns & validate that they reference known tables and join on "_id".
	x, ok := cx.X.(*sql2.QualifiedRef)
	if !ok {
		return nil, fmt.Errorf("left-hand side of join expression must be a table-qualified column")
	} else if x.Table.Name != tbl0.TableName() && x.Table.Name != tbl1.TableName() {
		return nil, fmt.Errorf("no such table: %q", x.Table.Name)
	}

	y, ok := cx.Y.(*sql2.QualifiedRef)
	if !ok {
		return nil, fmt.Errorf("right-hand side of join expression must be a table-qualified column")
	} else if y.Table.Name != tbl0.TableName() && y.Table.Name != tbl1.TableName() {
		return nil, fmt.Errorf("no such table: %q", y.Table.Name)
	}

	if x.Column.Name != "_id" && y.Column.Name != "_id" {
		return nil, fmt.Errorf("must join table on _id column")
	} else if x.Column.Name == "_id" && y.Column.Name == "_id" {
		return nil, fmt.Errorf("cannot join _id field of two tables")
	}

	// Move ID column to LHS.
	if x.Column.Name != "_id" {
		x, y = y, x
	}

	// Move parent table to LHS.
	if x.Table.Name != tbl0.TableName() {
		tbl0, tbl1 = tbl1, tbl0
	}

	// Ensure column expression is a single COUNT.
	if len(stmt.Columns) != 1 {
		return nil, fmt.Errorf("only COUNT() is supported on joined tables")
	}
	expr, ok := stmt.Columns[0].Expr.(*sql2.Call)
	if !ok || strings.ToUpper(expr.Name.Name) != "COUNT" {
		return nil, fmt.Errorf("only COUNT() is supported on joined tables")
	}

	// Extract WHERE clause and separate by parent/child tables.
	var cond0, cond1 sql2.Expr
	for _, cond := range sql2.SplitExprTree(stmt.WhereExpr) {
		tblName, ok := sql2.ExprTableName(cond)
		if !ok {
			return nil, fmt.Errorf("cannot filter across multiple tables in an expression")
		} else if tblName == "" {
			return nil, fmt.Errorf("expression must reference a table name")
		} else if tblName != tbl0.TableName() && tblName != tbl1.TableName() {
			return nil, fmt.Errorf("no such table: %q", tblName)
		}

		// Match to parent table.
		if tblName == tbl0.TableName() {
			if cond0 == nil {
				cond0 = cond
			} else {
				cond0 = &sql2.BinaryExpr{X: cond0, Op: sql2.AND, Y: cond}
			}
			continue
		}

		// Match to child table.
		if cond1 == nil {
			cond1 = cond
		}
		cond1 = &sql2.BinaryExpr{X: cond1, Op: sql2.AND, Y: cond}
	}

	// Convert conditions to PQL.
	pqlCond0, err := p.planExprPQL(ctx, stmt, cond0)
	if err != nil {
		return nil, err
	} else if pqlCond0 == nil {
		pqlCond0 = &pql.Call{Name: "All"}
	}

	pqlCond1, err := p.planExprPQL(ctx, stmt, cond1)
	if err != nil {
		return nil, err
	} else if pqlCond1 == nil {
		pqlCond1 = &pql.Call{
			Name: "Row",
			Args: map[string]interface{}{y.Column.Name: &pql.Condition{
				Op: pql.NEQ,
			}},
		}
	}

	return NewCountNode(p.executor, tbl0.Name.Name,
		&StmtColumn{
			Name: stmt.Columns[0].Name(),
			Type: sql2.DataTypeInt,
		},
		&pql.Call{
			Name: "Count",
			Children: []*pql.Call{{
				Name: "Intersect",
				Children: []*pql.Call{
					pqlCond0,
					{
						Name: "Distinct",
						Children: []*pql.Call{
							pqlCond1,
						},
						Args: map[string]interface{}{
							"index": tbl1.Name.Name,
							"field": y.Column.Name,
						},
					},
				},
			}},
		},
	), nil
}

func (p *Planner) planNonAggregateSelectStatement(ctx context.Context, stmt *sql2.SelectStatement) (_ StmtNode, err error) {
	indexName, err := statementTableName(stmt)
	if err != nil {
		return nil, err
	}

	// Lookup index.
	idx := p.executor.Holder.Index(indexName)
	if idx == nil {
		return nil, newNotFoundError(ErrIndexNotFound, indexName)
	}

	// Convert WHERE clause.
	cond, err := p.planExprPQL(ctx, stmt, stmt.WhereExpr)
	if err != nil {
		return nil, err
	}

	// Build column list.
	var srcs []string
	var columns []*StmtColumn
	for _, col := range stmt.Columns {
		// Handle expressions and qualified references.
		switch expr := col.Expr.(type) {
		case *sql2.QualifiedRef:
			srcs = append(srcs, sql2.IdentName(expr.Column))
			columns = append(columns, &StmtColumn{
				Name: sql2.IdentName(expr.Column),
				Type: sql2.ExprDataType(col.Expr),
			})

		default:
			return nil, fmt.Errorf("unsupported column expression: %T", expr)
		}
	}

	return NewExtractNode(p.executor, indexName, srcs, columns, cond), nil
}

// planExprPQL returns a PQL call tree for a given expression.
func (p *Planner) planExprPQL(ctx context.Context, stmt *sql2.SelectStatement, expr sql2.Expr) (_ *pql.Call, err error) {
	if expr == nil {
		return nil, nil
	}

	switch expr := expr.(type) {
	case *sql2.BinaryExpr:
		return p.planBinaryExprPQL(ctx, stmt, expr)
	case *sql2.BindExpr:
		return nil, fmt.Errorf("bind expressions are not supported")
	case *sql2.BlobLit:
		return nil, fmt.Errorf("blob literals are not supported")
	case *sql2.BoolLit:
		return nil, fmt.Errorf("boolean literals are not supported")
	case *sql2.Call:
		return nil, fmt.Errorf("call expressions are not supported")
	case *sql2.CaseExpr:
		return nil, fmt.Errorf("case expressions are not supported")
	case *sql2.CastExpr:
		return nil, fmt.Errorf("cast expressions are not supported")
	case *sql2.Exists:
		return nil, fmt.Errorf("exists expressions are not supported")
	case *sql2.ExprList:
		return nil, fmt.Errorf("expression lists are not supported")
	case *sql2.Ident:
		return nil, fmt.Errorf("identifiers are not supported")
	case *sql2.NullLit:
		return nil, fmt.Errorf("NULL expressions are not supported")
	case *sql2.NumberLit:
		return nil, fmt.Errorf("number expressions are not supported")
	case *sql2.ParenExpr:
		return p.planExprPQL(ctx, stmt, expr.X)
	case *sql2.QualifiedRef:
		return nil, fmt.Errorf("qualified references are not supported")
	case *sql2.Raise:
		return nil, fmt.Errorf("raise expressions are not supported")
	case *sql2.Range:
		return nil, fmt.Errorf("range expressions are not supported")
	case *sql2.StringLit:
		return nil, fmt.Errorf("string literals are not supported")
	case *sql2.UnaryExpr:
		return nil, fmt.Errorf("unary expressions are not supported")
	default:
		return nil, fmt.Errorf("unexpected SQL expression type: %T", expr)
	}
}

func (p *Planner) planBinaryExprPQL(ctx context.Context, stmt *sql2.SelectStatement, expr *sql2.BinaryExpr) (_ *pql.Call, err error) {
	switch op := expr.Op; op {
	case sql2.AND, sql2.OR:
		name := "Intersect"
		if op == sql2.OR {
			name = "Union"
		}

		x, err := p.planExprPQL(ctx, stmt, expr.X)
		if err != nil {
			return nil, err
		}
		y, err := p.planExprPQL(ctx, stmt, expr.Y)
		if err != nil {
			return nil, err
		}

		return &pql.Call{
			Name:     name,
			Children: []*pql.Call{x, y},
		}, nil

	case sql2.EQ, sql2.NE, sql2.LT, sql2.LE, sql2.GT, sql2.GE:
		// Ensure field reference exists in binary expression.
		x, y := expr.X, expr.Y
		xRef, xOk := x.(*sql2.QualifiedRef)
		yRef, yOk := y.(*sql2.QualifiedRef)
		if xOk && yOk {
			return nil, fmt.Errorf("cannot compare fields in a WHERE clause")
		} else if !xOk && !yOk {
			return nil, fmt.Errorf("expression must reference one field")
		}

		// Rewrite expression so field ref is LHS.
		if !xOk && yOk {
			xRef, y = yRef, x
			switch op {
			case sql2.LT:
				op = sql2.GT
			case sql2.LE:
				op = sql2.GE
			case sql2.GT:
				op = sql2.LT
			case sql2.GE:
				op = sql2.LE
			}
		}

		pqlValue, err := sqlToPQLValue(y)
		if err != nil {
			return nil, err
		}

		isBSI := true // TODO: Check field if it is a BSI field.
		if !isBSI {
			return &pql.Call{
				Name: "Row",
				Args: map[string]interface{}{
					sql2.IdentName(xRef.Column): pqlValue,
				},
			}, nil
		}

		pqlOp, err := sqlToPQLOp(op)
		if err != nil {
			return nil, err
		}
		return &pql.Call{
			Name: "Row",
			Args: map[string]interface{}{
				sql2.IdentName(xRef.Column): &pql.Condition{
					Op:    pqlOp,
					Value: pqlValue,
				},
			},
		}, nil

	case sql2.BITAND, sql2.BITOR, sql2.BITNOT, sql2.LSHIFT, sql2.RSHIFT:
		return nil, fmt.Errorf("bitwise operators are not supported in WHERE clause")
	case sql2.PLUS, sql2.MINUS, sql2.STAR, sql2.SLASH, sql2.REM: // +
		return nil, fmt.Errorf("arithmetic operators are not supported in WHERE clause")
	case sql2.CONCAT:
		return nil, fmt.Errorf("concatenation operator is not supported in WHERE clause")
	case sql2.IN, sql2.NOTIN:
		return nil, fmt.Errorf("IN operator is not supported")
	case sql2.BETWEEN, sql2.NOTBETWEEN:
		return nil, fmt.Errorf("BETWEEN operator is not supported")
	default:
		return nil, fmt.Errorf("unexpected binary expression operator: %s", expr.Op)
	}
}

// sqlToPQLOp converts a SQL2 operation token to PQL.
func sqlToPQLOp(op sql2.Token) (pql.Token, error) {
	switch op {
	case sql2.EQ:
		return pql.EQ, nil
	case sql2.NE:
		return pql.NEQ, nil
	case sql2.LT:
		return pql.LT, nil
	case sql2.LE:
		return pql.LTE, nil
	case sql2.GT:
		return pql.GT, nil
	case sql2.GE:
		return pql.GTE, nil
	default:
		return pql.ILLEGAL, fmt.Errorf("cannot convert SQL op %q to PQL", op)
	}
}

// sqlToPQLValue converts a literal SQL2 expression node to a PQL Go value.
func sqlToPQLValue(expr sql2.Expr) (interface{}, error) {
	switch expr := expr.(type) {
	case *sql2.StringLit:
		return expr.Value, nil
	case *sql2.NumberLit:
		if expr.IsFloat() {
			return strconv.ParseFloat(expr.Value, 64)
		}
		return strconv.ParseInt(expr.Value, 10, 64)
	case *sql2.BoolLit:
		return expr.Value, nil
	default:
		return nil, fmt.Errorf("cannot convert SQL expression %T to a literal value", expr)
	}
}

func (p *Planner) checkStatement(stmt sql2.Statement) error {
	switch stmt := stmt.(type) {
	case *sql2.SelectStatement:
		return p.checkSelectStatement(stmt)
	default:
		return nil
	}
}

func (p *Planner) checkSelectStatement(stmt *sql2.SelectStatement) error {
	if err := p.expandSelectStatementWildcards(stmt); err != nil {
		return err
	}

	// Type check expressions in statement.
	for _, col := range stmt.Columns {
		if err := p.checkExpr(&col.Expr, stmt); err != nil {
			return err
		}
	}

	if err := p.checkExpr(&stmt.WhereExpr, stmt); err != nil {
		return err
	}

	for i := range stmt.GroupByExprs {
		if err := p.checkExpr(&stmt.GroupByExprs[i], stmt); err != nil {
			return err
		}
	}

	if err := p.checkExpr(&stmt.HavingExpr, stmt); err != nil {
		return err
	}

	for _, term := range stmt.OrderingTerms {
		if err := p.checkExpr(&term.X, stmt); err != nil {
			return err
		}
	}

	if err := p.checkExpr(&stmt.LimitExpr, stmt); err != nil {
		return err
	}

	if err := p.checkExpr(&stmt.OffsetExpr, stmt); err != nil {
		return err
	}

	return nil
}

func (p *Planner) expandSelectStatementWildcards(stmt *sql2.SelectStatement) error {
	if !stmt.HasWildcard() {
		return nil
	}

	indexName, err := statementTableName(stmt)
	if err != nil {
		return err
	}

	// Look up index.
	idx := p.executor.Holder.Index(indexName)
	if idx == nil {
		return newNotFoundError(ErrIndexNotFound, indexName)
	}

	// Replace wildcards with column references.
	columns := make([]*sql2.ResultColumn, 0, len(stmt.Columns))
	for _, col := range stmt.Columns {
		// Unqualified wildcard.
		isWildcard := col.Star.IsValid()
		if ref, ok := col.Expr.(*sql2.QualifiedRef); ok && ref.Star.IsValid() {
			if ref.Table.Name != indexName {
				return fmt.Errorf("no such table: %q", ref.Table.Name)
			}
			isWildcard = true
		}

		// Simply add column as-is if it is not a wildcard.
		if !isWildcard {
			columns = append(columns, col)
			continue
		}

		// Add identifier field first.
		columns = append(columns, &sql2.ResultColumn{
			Expr: &sql2.QualifiedRef{
				Table:  &sql2.Ident{Name: idx.Name()},
				Column: &sql2.Ident{Name: "_id"},
			},
		})

		// Then add all fields besides the existence bit.
		for _, field := range idx.Fields() {
			if field.Name() == "_exists" {
				continue
			}
			columns = append(columns, &sql2.ResultColumn{
				Expr: &sql2.QualifiedRef{
					Table:  &sql2.Ident{Name: idx.Name()},
					Column: &sql2.Ident{Name: field.Name()},
				},
			})
		}
	}
	stmt.Columns = columns

	return nil
}
func (p *Planner) checkExpr(expr *sql2.Expr, stmt sql2.Statement) error {
	if e, err := sql2.Walk(&sqlExprTypeChecker{
		holder: p.executor.Holder,
		stmt:   stmt,
	}, *expr); err != nil {
		return err
	} else if e != nil {
		*expr = e.(sql2.Expr)
	} else {
		*expr = nil
	}
	return nil
}

// sqlExprTypeChecker recursively performs type checking within an expression.
// Called by sqlTypeChecker. Implements sql2.Visitor.
type sqlExprTypeChecker struct {
	holder *Holder
	stmt   sql2.Statement // scope
}

var _ sql2.Visitor = (*sqlExprTypeChecker)(nil)

func (v *sqlExprTypeChecker) Visit(node sql2.Node) (_ sql2.Visitor, _ sql2.Node, err error) {
	switch n := node.(type) {
	case *sql2.Call:
		for i := range n.Args {
			if err := v.checkExpr(&n.Args[i]); err != nil {
				return nil, nil, err
			}
		}
		return nil, node, nil // skip
	case *sql2.Ident:
		if node, err = v.visitIdent(n); err != nil {
			return nil, nil, err
		}
		return nil, node, nil
	case *sql2.QualifiedRef:
		if node, err = v.visitQualifiedRef(n); err != nil {
			return nil, nil, err
		}
		return nil, node, nil
	default:
		return v, node, nil
	}
}

func (v *sqlExprTypeChecker) visitIdent(ident *sql2.Ident) (sql2.Node, error) {
	indexName, err := statementTableName(v.stmt)
	if err != nil {
		return nil, err
	}

	// Convert to a table qualified reference and validate through ref visit function.
	return v.visitQualifiedRef(&sql2.QualifiedRef{
		Table:  &sql2.Ident{Name: indexName},
		Column: &sql2.Ident{Name: ident.Name},
	})
}

func (v *sqlExprTypeChecker) visitQualifiedRef(ref *sql2.QualifiedRef) (sql2.Node, error) {
	idx := v.holder.Index(ref.Table.Name)
	if idx == nil {
		return nil, newNotFoundError(ErrIndexNotFound, ref.Table.Name)
	}

	switch name := ref.Column.Name; name {
	case "_id":
		ref.DataType = sql2.DataTypeInt
	default:
		field := idx.Field(ref.Column.Name)
		if field == nil {
			return nil, newNotFoundError(ErrFieldNotFound, ref.Column.Name)
		}
		ref.DataType = fieldSQLDataType(field)
	}

	return ref, nil
}

func (v *sqlExprTypeChecker) checkExpr(node *sql2.Expr) error {
	if expr, err := sql2.Walk(&sqlExprTypeChecker{
		holder: v.holder,
		stmt:   v.stmt,
	}, *node); err != nil {
		return err
	} else if expr != nil {
		*node = expr.(sql2.Expr)
	} else {
		*node = nil
	}
	return nil
}

func (v *sqlExprTypeChecker) VisitEnd(node sql2.Node) (sql2.Node, error) { return node, nil }

func fieldSQLDataType(f *Field) string {
	if f.Keys() {
		return sql2.DataTypeText
	}

	switch f.Type() {
	case FieldTypeInt, FieldTypeMutex, FieldTypeSet:
		return sql2.DataTypeInt
	case FieldTypeBool:
		return sql2.DataTypeBool
	case FieldTypeDecimal:
		return sql2.DataTypeDecimal
	case FieldTypeTime, FieldTypeTimestamp:
		return sql2.DataTypeTimestamp
	default:
		return ""
	}
}

type Stmt struct {
	node StmtNode
}

func (stmt *Stmt) Close() error { return nil }

func (stmt *Stmt) QueryRowContext(ctx context.Context, args ...interface{}) *StmtRow {
	rows, err := stmt.QueryContext(ctx, args...)
	if err != nil {
		return &StmtRow{err: err}
	}
	return &StmtRow{rows: rows}
}

func (stmt *Stmt) QueryContext(ctx context.Context, args ...interface{}) (*StmtRows, error) {
	// TODO: Handle bind arguments.

	rows := &StmtRows{
		ctx:  ctx,
		node: stmt.node,
	}

	// Initialize the node.
	if err := rows.node.First(ctx); err != nil {
		return nil, fmt.Errorf("Query: initialize statement: %w", err)
	}

	return rows, nil
}

type StmtRows struct {
	ctx  context.Context
	node StmtNode
	err  error
}

func (rs *StmtRows) Close() error {
	return nil
}

func (rs *StmtRows) Err() error {
	if rs.err != nil && rs.err != sql.ErrNoRows {
		return rs.err
	}
	return nil
}

func (rs *StmtRows) Columns() []*StmtColumn {
	return rs.node.Columns()
}

/*
func (rs *StmtRows) Row() int64 {
	return rs.node.Row()[0].(int64)
}
*/

func (rs *StmtRows) Next() bool {
	if rs.err != nil {
		return false
	}

	if rs.err = rs.node.Next(rs.ctx); rs.err != nil {
		return false
	}
	return true
}

func (rs *StmtRows) Scan(dst ...interface{}) error {
	if rs.err != nil {
		return rs.err
	}

	//  Check len(dest) against node row length.
	row := rs.node.Row()
	if len(dst) != len(row) {
		return fmt.Errorf("Scan(): expected %d values, received %d values", len(dst), len(row))
	}

	// Copy values from row to destination pointers.
	for i := range dst {
		// Handle null values.
		// TODO: Handle double pointers.
		if row[i] == nil {
			switch p := dst[i].(type) {
			case *int:
				*p = 0
			case *int64:
				*p = 0
			case *uint:
				*p = 0
			case *uint64:
				*p = 0
			case *interface{}:
				*p = nil
			default:
				return fmt.Errorf("cannot scan NULL value into %T destination at index %d", p, i)
			}
			continue
		}

		// Copy row value to scan destination.
		switch v := row[i].(type) {
		case bool:
			switch p := dst[i].(type) {
			case *bool:
				*p = v
			case *interface{}:
				*p = v
			default:
				return fmt.Errorf("cannot scan %T value into %T destination at index %d", v, p, i)
			}
		case int64:
			switch p := dst[i].(type) {
			case *int:
				*p = int(v)
			case *int64:
				*p = v
			case *uint:
				*p = uint(v)
			case *uint64:
				*p = uint64(v)
			case *interface{}:
				*p = v
			default:
				return fmt.Errorf("cannot scan %T value into %T destination at index %d", v, p, i)
			}
		case uint64:
			switch p := dst[i].(type) {
			case *int:
				*p = int(v)
			case *int64:
				*p = int64(v)
			case *uint:
				*p = uint(v)
			case *uint64:
				*p = uint64(v)
			case *interface{}:
				*p = v
			default:
				return fmt.Errorf("cannot scan %T value into %T destination at index %d", v, p, i)
			}
		case []uint64:
			switch p := dst[i].(type) {
			case *[]uint64:
				*p = []uint64(v)
			case *interface{}:
				*p = joinUint64Slice(v)
			default:
				return fmt.Errorf("cannot scan %T value into %T destination at index %d", v, p, i)
			}
		case string:
			switch p := dst[i].(type) {
			case *string:
				*p = v
			case *interface{}:
				*p = v
			default:
				return fmt.Errorf("cannot scan %T value into %T destination at index %d", v, p, i)
			}
		case []string:
			switch p := dst[i].(type) {
			case *[]string:
				*p = []string(v)
			case *interface{}:
				*p = strings.Join(v, ",")
			default:
				return fmt.Errorf("cannot scan %T value into %T destination at index %d", v, p, i)
			}
		default:
			return fmt.Errorf("unexpected %T value at index %d", v, i)
		}
	}

	return nil
}

type StmtRow struct {
	err  error
	rows *StmtRows
}

func (r *StmtRow) Scan(dest ...interface{}) error {
	if r.err != nil {
		return r.err
	}
	defer r.rows.Close()

	if !r.rows.Next() {
		if err := r.rows.Err(); err != nil {
			return err
		}
		return sql.ErrNoRows
	}

	if err := r.rows.Scan(dest...); err != nil {
		return err
	}
	return r.rows.Close()
}

func (r *StmtRow) Err() error {
	return r.err
}

type StmtColumn struct {
	Name string
	Type string
}

type StmtNode interface {
	// Initializes the node to its start.
	First(ctx context.Context) error

	// Moves the node to the next available row. Returns sql.ErrNoRows if done.
	Next(ctx context.Context) error

	// Returns the current row in the node.
	Row() []interface{}

	// Returns column definitions for the node.
	Columns() []*StmtColumn

	// Returns a reference to the value register for a named column.
	// Lookup(table, column string) (interface{}, error)
}

var _ StmtNode = (*ExtractNode)(nil)

// ExtractNode executes an Extract() query against a FeatureBase index.
type ExtractNode struct {
	executor  *executor
	indexName string
	srcs      []string
	columns   []*StmtColumn
	mapping   []int // map of output column indices to source column indices
	cond      *pql.Call

	result []ExtractedTableColumn
	row    []interface{}
}

func NewExtractNode(executor *executor, indexName string, srcs []string, columns []*StmtColumn, cond *pql.Call) *ExtractNode {
	if cond == nil {
		cond = &pql.Call{Name: "All"}
	}

	// Determine mapping between result elements & columns.
	// We'll exclude "_id" from the source columns here as well.
	mapping := make([]int, len(columns))
	srcs2 := make([]string, 0, len(srcs))
	for i := range mapping {
		if srcs[i] == "_id" {
			mapping[i] = -1
			continue
		}

		mapping[i] = len(srcs2)
		srcs2 = append(srcs2, srcs[i])
	}

	return &ExtractNode{
		executor:  executor,
		indexName: indexName,
		srcs:      srcs2,   // source column names (excluding "id")
		columns:   columns, // external column alias
		mapping:   mapping,
		cond:      cond,
		row:       make([]interface{}, len(srcs)),
	}
}

func (n *ExtractNode) Columns() []*StmtColumn {
	return n.columns
}

func (n *ExtractNode) First(ctx context.Context) error {
	n.result = nil
	return nil
}

func (n *ExtractNode) Next(ctx context.Context) error {
	// Fetch results if we haven't yet.
	if err := n.init(ctx); err != nil {
		return err
	}

	// Exit if no result rows remain.
	if len(n.result) == 0 {
		for i := range n.row {
			n.row[i] = nil
		}
		return sql.ErrNoRows
	}

	// Map result elements to row elements.
	for i, index := range n.mapping {
		result := n.result[0]

		// Map row array element to position in result row.
		if index >= 0 {
			n.row[i] = result.Rows[index]
			continue
		}

		// Otherwise use ID for value.
		if result.Column.Keyed {
			n.row[i] = result.Column.Key
		} else {
			n.row[i] = int64(result.Column.ID)
		}
	}

	// Move to next result element.
	n.result = n.result[1:]

	return nil
}

func (n *ExtractNode) init(ctx context.Context) error {
	if n.result != nil {
		return nil
	}

	// Generate PQL query with all specified rows.
	// Skip first column as it is the ID column.
	call := &pql.Call{Name: "Extract", Children: []*pql.Call{n.cond}}
	for _, src := range n.srcs {
		call.Children = append(call.Children,
			&pql.Call{
				Name: "Rows",
				Args: map[string]interface{}{"field": src},
			},
		)
	}

	// Execute Extract() against cluster.
	result, err := n.executor.Execute(ctx, n.indexName, &pql.Query{Calls: []*pql.Call{call}}, nil, nil)
	if err != nil {
		return err
	} else if result.Err != nil {
		return result.Err
	} else if len(result.Results) != 1 {
		return fmt.Errorf("expected single result table from Extract(), got %d results", len(result.Results))
	}

	// Extract out the column/row data from resultset.
	tbl, ok := result.Results[0].(ExtractedTable)
	if !ok {
		return fmt.Errorf("unexpected Extract() result type: %T", result.Results[0])
	}
	n.result = tbl.Columns

	return nil
}

func (n *ExtractNode) Row() []interface{} { return n.row }

var _ StmtNode = (*CountNode)(nil)

// CountNode executes a COUNT(*) against a FeatureBase index and returns a single row.
type CountNode struct {
	executor  *executor
	indexName string
	column    *StmtColumn
	call      *pql.Call

	row []interface{}
}

func NewCountNode(executor *executor, indexName string, column *StmtColumn, call *pql.Call) *CountNode {
	return &CountNode{
		executor:  executor,
		indexName: indexName,
		column:    column,
		call:      call,
	}
}

func (n *CountNode) Columns() []*StmtColumn {
	return []*StmtColumn{n.column}
}

func (n *CountNode) First(ctx context.Context) error {
	n.row = nil
	return nil
}

func (n *CountNode) Next(ctx context.Context) error {
	if n.row != nil {
		return sql.ErrNoRows
	}

	result, err := n.executor.Execute(ctx, n.indexName, &pql.Query{Calls: []*pql.Call{n.call}}, nil, nil)
	if err != nil {
		return err
	}

	n.row = []interface{}{int64(result.Results[0].(uint64))}
	return nil
}

func (n *CountNode) Row() []interface{} { return n.row }

// GroupByNode executes an aggregate with a GROUP BY against a FeatureBase index.
type GroupByNode struct {
	executor    *executor
	indexName   string
	groupByCols []string
	columns     []*StmtColumn
	mapping     []int
	aggregate   *pql.Call
	cond        *pql.Call

	result *GroupCounts
	index  int

	row []interface{}
}

func NewGroupByNode(executor *executor, indexName string, resultCols, groupByCols []string, columns []*StmtColumn, aggregate, cond *pql.Call) *GroupByNode {
	// Map result columns to output columns.
	mapping := make([]int, len(columns))
	for i := range mapping {
		if resultCols[i] == "_aggregate" {
			mapping[i] = -1
			continue
		}

		mapping[i] = stringSliceIndex(groupByCols, resultCols[i])
	}

	return &GroupByNode{
		executor:    executor,
		indexName:   indexName,
		groupByCols: groupByCols,
		columns:     columns,
		mapping:     mapping,
		aggregate:   aggregate,
		cond:        cond,
		row:         make([]interface{}, len(columns)),
	}
}

func (n *GroupByNode) Columns() []*StmtColumn {
	return n.columns
}

func (n *GroupByNode) First(ctx context.Context) error {
	n.result = nil
	return nil
}

func (n *GroupByNode) Next(ctx context.Context) (err error) {
	// Fetch resultset if it doesn't exist yet.
	if n.result == nil {
		if n.result, err = n.fetch(ctx); err != nil {
			return err
		}
	}

	// Exit if no more rows exist.
	if n.index >= len(n.result.groups) {
		return sql.ErrNoRows
	}

	// Copy results into current row.
	group := n.result.groups[n.index]
	n.index++

	for i, index := range n.mapping {
		// Assign aggregate to unmapped column.
		if index == -1 {
			if n.aggregate != nil {
				n.row[i] = int64(group.Agg)
			} else {
				n.row[i] = int64(group.Count)
			}
			continue
		}

		// Otherwise map from group value to result column index.
		g := group.Group[index]
		if g.Value != nil {
			n.row[i] = *g.Value
		} else if g.RowKey != "" {
			n.row[i] = g.RowKey
		} else {
			n.row[i] = int64(g.RowID)
		}
	}

	return nil
}

// fetch executes a call to compute the PQL results.
func (n *GroupByNode) fetch(ctx context.Context) (*GroupCounts, error) {
	call := &pql.Call{
		Name: "GroupBy",
		Args: map[string]interface{}{},
	}

	// Choose fields to group by.
	for _, name := range n.groupByCols {
		call.Children = append(call.Children, &pql.Call{
			Name: "Rows", Args: map[string]interface{}{"_field": name},
		})
	}

	// Apply filter & aggregate, if set.
	if n.aggregate != nil {
		call.Args["aggregate"] = n.aggregate
	}
	if n.cond != nil {
		call.Args["filter"] = n.cond
	}

	result, err := n.executor.Execute(ctx, n.indexName, &pql.Query{Calls: []*pql.Call{call}}, nil, nil)
	if err != nil {
		return nil, err
	}
	return result.Results[0].(*GroupCounts), nil
}

func (n *GroupByNode) Row() []interface{} { return n.row }

// statementTableName returns the table name for a single table SELECT statement.
//
// NOTE: This function is only temporary until we support more source types.
func statementTableName(stmt sql2.Statement) (string, error) {
	switch stmt := stmt.(type) {
	case *sql2.SelectStatement:
		return sourceTableName(stmt.Source)
	default:
		return "", fmt.Errorf("statement not currently supported")
	}
}

func sourceTableName(source sql2.Source) (string, error) {
	switch source := source.(type) {
	case *sql2.JoinClause:
		return "", fmt.Errorf("joins are not currently supported")
	case *sql2.ParenSource:
		return "", fmt.Errorf("parenthesized source is not currently supported")
	case *sql2.QualifiedTableName:
		return sql2.IdentName(source.Name), nil
	case *sql2.SelectStatement:
		return "", fmt.Errorf("sub-selects are not currently supported")
	default:
		return "", fmt.Errorf("unexpected source type: %T", source)
	}
}

// stringSliceIndex returns position of v in a. Returns -1 if not found.
func stringSliceIndex(a []string, v string) int {
	for i := range a {
		if a[i] == v {
			return i
		}
	}
	return -1
}

func joinUint64Slice(a []uint64) string {
	b := []byte("[")
	for i, v := range a {
		b = strconv.AppendUint(b, v, 10)
		if i < len(a)-1 {
			b = append(b, ',')
		}
	}
	b = append(b, ']')
	return string(b)
}

repository: vishalbelsare/pilosa

repo_name: vishalbelsare/pilosa

gha_license_id: NOASSERTION

gha_language: Go


text:
package esa

import (
	"reflect"
	"testing"
)

func TestTeamGetTeams(t *testing.T) {
	type TestCase struct {
		in  string
		out TeamsResponse
	}

	testCase := TestCase{
		in: "../tests/stubs/team_teams.json",
	}

	serve, client := Stub(testCase.in, &testCase.out)
	defer serve.Close()

	res, err := client.Team.GetTeams()
	if err != nil {
		t.Errorf("error Request %s\n", err)
	}

	if !reflect.DeepEqual(*res, testCase.out) {
		t.Errorf("error Response %s != %s", res, testCase.out)
	}
}

func TestTeamGetTeam(t *testing.T) {
	type TestCase struct {
		in  string
		out TeamResponse
	}

	testCase := TestCase{
		in: "../tests/stubs/team_team.json",
	}

	serve, client := Stub(testCase.in, &testCase.out)
	defer serve.Close()

	res, err := client.Team.GetTeam("docs")
	if err != nil {
		t.Errorf("error Request %s\n", err)
	}

	if !reflect.DeepEqual(*res, testCase.out) {
		t.Errorf("error Response %s != %s", res, testCase.out)
	}
}

repository: uobikiemukot/go-esa

repo_name: uobikiemukot/go-esa


text:
DESCRIPTION = "Gstreamer plugin for TI Davinci and OMAP processors"
DEPENDS = "ti-dmai gstreamer gst-plugins-base gst-plugins-good gst-plugins-ugly"

SRCREV = "459"
# Again, no '.' in PWD allowed :(
PV = "svnr${SRCREV}"
PR = "r37"

GST_TI_RC_SCRIPT_omap3 = "gstreamer-ti-omap3530-rc.sh"
GST_TI_RC_SCRIPT_dm6446="gstreamer-ti-dm6446-rc.sh"
GST_TI_RC_SCRIPT_dm355="gstreamer-ti-dm355-rc.sh"

SRC_URI = "svn://gforge.ti.com/svn/gstreamer_ti/trunk;module=gstreamer_ti;proto=https;user=anonymous;pswd='' \
           file://gstreamer-ti-tracker-462.patch;patch=1 \
           file://gstreamer-ti-remove-mp3-decode-support-from-auddec1.patch;patch=1 \
           file://${GST_TI_RC_SCRIPT} \
"

SRC_URI_append_omap3 = " \
           file://gstreamer-ti-add-omapfb.patch;patch=1 \
"

S = "${WORKDIR}/gstreamer_ti/ti_build/ticodecplugin"

inherit autotools update-rc.d

require ti-paths.inc

XDC_TARGET = "gnu.targets.arm.GCArmv5T"
XDC_PLATFORM_dm6446 = "ti.platforms.evmDM6446"
XDC_PLATFORM_omapl137 = "ti.platforms.omapl137"
PLATFORM_XDC = "${XDC_PLATFORM}"
PLATFORM_dm6446 = "dm6446"
PLATFORM_omapl137 = "ol137"

export XDC_TARGET
export XDC_PLATFORM
export PLATFORM_XDC
# export codec combo (or server) locations
export HMJCP_COMBO  = "${installdir}/codec-combo/hmjcp.accel"
export CODEC_SERVER = "${installdir}/codec-combo/cs.x64P"
export ENCODE_COMBO = "${installdir}/codec-combo/encodeCombo.x64P"
export DECODE_COMBO = "${installdir}/codec-combo/decodeCombo.x64P"

CPPFLAGS_append = " -DPlatform_${PLATFORM}"

do_install_prepend () {
        # install gstreamer demo scripts
        install -d ${D}/${installdir}/gst
        cp -r ${WORKDIR}/gstreamer_ti/gstreamer_demo/shared ${D}/${installdir}/gst
        cp -r ${WORKDIR}/gstreamer_ti/gstreamer_demo/${PLATFORM} ${D}/${installdir}/gst
        # default loadmodule script is hard-coded for insmod, change to modprobe
        sed -i 's/insmod/modprobe/g' ${D}/${installdir}/gst/${PLATFORM}/loadmodules.sh
        sed -i 's/.ko//g' ${D}/${installdir}/gst/${PLATFORM}/loadmodules.sh
        if [ "${PLATFORM}" = "omap3530" ]; then
                echo "modprobe sdmak" >> ${D}/${installdir}/gst/${PLATFORM}/loadmodules.sh
        fi
        chmod 0755 ${D}/${installdir}/gst -R
        install -d ${D}${sysconfdir}/init.d/
        install -m 0755  ${WORKDIR}/${GST_TI_RC_SCRIPT} ${D}${sysconfdir}/init.d/gstti-init
}

PACKAGE_ARCH = "${MACHINE_ARCH}"
PACKAGES += "gstreamer-ti-demo-script"

RDEPENDS_gstreamer-ti-demo-script = "${PN}"
RRECOMMENDS_${PN} = " \
gst-plugins-base-meta \
gst-plugins-good-meta \
gst-plugins-bad-meta \
gst-plugins-ugly-meta \
ti-dmai-apps"

FILES_gstreamer-ti-demo-script = "${installdir}/gst/*"
FILES_${PN} += "${libdir}/gstreamer-0.10/*.so ${sysconfdir}"
FILES_${PN}-dev += "${libdir}/gstreamer-0.10/*.a ${libdir}/gstreamer-0.10/*.la"
FILES_${PN}-dbg += "${libdir}/gstreamer-0.10/.debug"

pkg_postinst_gstreamer-ti-demo-script () {
        ln -sf ${installdir}/codec-combo/* ${installdir}/gst/${PLATFORM}/
}

INITSCRIPT_NAME = "gstti-init"
INITSCRIPT_PARAMS = "start 30 5 2 . stop 40 0 1 6 ."

repository: demsey/openembedded

repo_name: demsey/openembedded

branch_name: HEAD


text:
@inproceedings{ThoraviKumaravel:2019:LFR:3332165.3347872,
 acmid = {3347872},
 address = {New York, NY, USA},
 author = {Thoravi Kumaravel, Balasaravanan and Anderson, Fraser and Fitzmaurice, George and Hartmann, Bjoern and Grossman, Tovi},
 booktitle = {Proceedings of the 32Nd Annual ACM Symposium on User Interface Software and Technology},
 doi = {10.1145/3332165.3347872},
 isbn = {978-1-4503-6816-2},
 keywords = {learning, mixed reality, physical tasks, remote guidance},
 location = {New Orleans, LA, USA},
 numpages = {14},
 pages = {161--174},
 publisher = {ACM},
 series = {UIST '19},
 title = {Loki: Facilitating Remote Instruction of Physical Tasks Using Bi-Directional Mixed-Reality Telepresence},
 url = {http://doi.acm.org/10.1145/3332165.3347872},
 year = {2019}
}

repository: jmatejka/group-website

repo_name: jmatejka/group-website


text:
SUMMARY = "A standardized interface for interfacing with preemptable tasks."
HOMEPAGE = "http://www.ros.org/wiki/actionlib"
LICENSE  = "BSD"
LIC_FILES_CHKSUM = "file://git/stack.xml;md5=b52ee74310fc1172811835d61ca0ddef"

VCSDIR = "git"
inherit catkin

SRC_URI  = "git://github.com/wg-debs/actionlib-release.git;rev=debian/ros-fuerte-actionlib_1.8.6_lucid;protocol=git"

DEPENDS += "\
	ros-fuerte-ros \
	ros-fuerte-genmsg-native \
	ros-fuerte-gencpp-native \
	ros-fuerte-genpy-native \
	ros-fuerte-genlisp-native \
	ros-fuerte-ros-comm \
	ros-fuerte-common-msgs \
"

S = "${WORKDIR}"


text:
package main

import (
	"crypto/rsa"
	"encoding/gob"
	"fmt"
	"os"
)

func main() {
	var key rsa.PrivateKey
	loadKey("private.key", &key)

	fmt.Println("Private key primes", key.Primes[0].String(), key.Primes[1].String())
	fmt.Println("Private key exponent", key.D.String())

	var publicKey rsa.PublicKey
	loadKey("public.key", &publicKey)

	fmt.Println("Public key modulus", publicKey.N.String())
	fmt.Println("Public key exponent", publicKey.E)
}

func loadKey(filename string, key interface{}) {
	inFile, err := os.Open(filename)
	checkError(err)
	decoder := gob.NewDecoder(inFile)
	err = decoder.Decode(key)
	checkError(err)
	inFile.Close()
}

func checkError(err error) {
	if err != nil {
		fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
		os.Exit(1)
	}
}


text:
// Copyright 2018 Shift Devices AG
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package logging

import (
	"encoding/json"

	"github.com/digitalbitbox/bitbox-wallet-app/util/errp"
	"github.com/sirupsen/logrus"
)

// Configuration serializes and deserializes the logging parameters.
type Configuration struct {
	// Output location of the logger.
	// Can be either a path relative to the configuration directory, STDOUT or STDERR.
	Output string `json:"output"`

	// Level from which on the entries are logged.
	Level logrus.Level `json:"level"`
}

// MarshalJSON implements json.Marshaler.
func (configuration Configuration) MarshalJSON() ([]byte, error) {
	return json.Marshal(&map[string]string{
		"output": configuration.Output,
		"level":  configuration.Level.String(),
	})
}

// UnmarshalJSON implements json.Unmarshaler.
func (configuration *Configuration) UnmarshalJSON(bytes []byte) error {
	var encoding map[string]string
	if err := json.Unmarshal(bytes, &encoding); err != nil {
		return errp.Wrap(err, "Could not unmarshal the logging configuration.")
	}

	output, found := encoding["output"]
	if !found {
		return errp.New("The output was not found in the logging configuration.")
	}
	configuration.Output = output

	level, found := encoding["level"]
	if !found {
		return errp.New("The level was not found in the logging configuration.")
	}
	var err error
	configuration.Level, err = logrus.ParseLevel(level)
	if err != nil {
		return errp.Wrap(err, "Could not parse the level of the logging configuration.")
	}
	return nil
}

repository: digitalbitbox/bitbox-wallet-app

repo_name: digitalbitbox/bitbox-wallet-app


text:
literature 1

@InProceedings{syed2019copaal,
author="Syed, Zafar Habeeb and Röder, Michael and Ngomo, Axel-Cyrille Ngonga",
editor="Ghidini, Chiara and Hartig, Olaf and Maleshkova, Maria and Sv{\'a}tek, Vojt{\v{e}}ch and Cruz, Isabel and Hogan, Aidan and Song, Jie and Lefran{\c{c}}ois, Maxime and Gandon, Fabien",
title="Unsupervised Discovery of Corroborative Paths for Fact Validation",
booktitle="The Semantic Web -- ISWC 2019",
year="2019",
publisher="Springer International Publishing",
address="Cham",
doi="10.1007/978-3-030-30793-6_36",
pages="630--646",
isbn="978-3-030-30793-6",
keywords  = {sys:relevantFor:infai sys:relevantFor:bis sys:relevantFor:simba ngonga group_aksw dice roeder syed},
note = {https://papers.dice-research.org/2019/ISWC2019\_COPAAL/public.pdf}
}

@InProceedings{syed2019copaaldemo,
author="Syed, Zafar Habeeb and Röder, Michael and Ngomo, Axel-Cyrille Ngonga",
editor="Suárez-Figueroa, Mari Carmen and Cheng, Gong and Gentile, Anna Lisa and Guéret, Christophe and Keet, Maria and Bernstein, Abraham",
title="COPAAL -- An Interface for Explaining Facts using Corroborative Paths",
booktitle="Proceedings of the ISWC 2019 Satellite Tracks (Posters \& Demonstrations, Industry, and Outrageous Ideas)",
year="2019",
publisher="Springer International Publishing",
volume="2456",
keywords  = {sys:relevantFor:infai sys:relevantFor:bis sys:relevantFor:simba ngonga group_aksw dice roeder syed},
pages="201--204",
note={https://papers.dice-research.org/2019/ISWC2019\_COPAAL\_Demo/public.pdf}
}

@InProceedings{desouki2021synthg,
  author    = {Abdelmoneim Amer Desouki and Felix Conrads and Michael Röder and Axel-Cyrille Ngonga Ngomo},
  booktitle = {Proceedings of the 15th IEEE International Conference on Semantic Computing (ICSC)},
  title     = {SynthG: Mimicking RDF Graphs Using Tensor Factorization},
  year      = {2021},
  pages     = {76-79},
  publisher = {IEEE Computer Society},
  keywords  = {dice raki daikiri opal sys:relevantFor:opal group_aksw desouki fconrads roeder ngonga},
  note       = {https://papers.dice-research.org/2021/ICSC2021\_SynthG/ICSC\_SynthG\_public.pdf},
  doi       = {10.1109/ICSC50631.2021.00017}
}

@InProceedings{MWPD2020_ProBERT,
  author    = {Hamada M. Zahera and Mohamed Ahmed Sherif},
  booktitle = {Proceedings of Mining the Web of HTML-embedded Product Data Workshop (MWPD2020)},
  title     = {{ProBERT: Product Data Classification with Fine-tuning BERT Model}},
  year      = {2020},
  keywords  = {2020 dice zahera sherif knowgraphs sys:relevantFor:limboproject limboproject sys:relevantFor:infai sys:relevantFor:bis limes limbo opal},
  owner     = {zahera},
  timestamp = {2020.09.25},
  note       = {https://papers.dice-research.org/2020/MWPD2020\_ProBERT/public.pdf},
}

@inproceedings{OKE_2018,
	author = {René Speck and Michael Röder and Felix Conrads and Hyndavi Rebba and Catherine Camilla Romiyo and Gurudevi Salakki and Rutuja Suryawanshi and Danish Ahmed and Nikit Srivastava and Mohit Mahajan and Axel-Cyrille {Ngonga Ngomo}},
	booktitle = {Semantic Web Evaluation Challenge},
	keywords = {2018 dice sys:relevantFor:infai sys:relevantFor:bis ngonga simba roeder conrads group\_aksw speck projecthobbit fox rebba romiyo salakki suryawanshi ahmed srivastava mahajan},
	pages = {39–51},
	publisher = {Springer International Publishing},
	title = {Open Knowledge Extraction Challenge 2018},
	note = {https://papers.dice-research.org/2018/ESWC\_Challenge\_OKE/OKE\_18\_public.pdf},
	year = {2018}
}

@inproceedings{wilke-2021-recoda,
	author = {Wilke, Adrian and Bannoura, Arwa and Ngonga Ngomo, Axel-Cyrille},
	booktitle = {Proceedings of the 15th {IEEE} {International} {Conference} on {Semantic} {Computing} ({ICSC} 2021)},
	keywords = {dice opal knowgraphs wilke bannoura ngonga Open-Data Licenses ODRL ccREL DCAT RDF Creative-Commons ReCoDa Relicensing},
	title = {Relicensing {Combined} {Datasets}},
	note = {https://papers.dice-research.org/2021/ICSC2021\_ReCoDa/Relicensing-Combined-Datasets-ReCoDa-public.pdf},
	year = {2021},
}

@InProceedings{khanISWC2019,
  author    = {Hashim Khan},
  title     = {Towards More Intelligent SPARQL Querying Interfaces},
  booktitle = {International Semantic Web Conference},
  year      = {2019},
  keywords  = {sys:relevantFor:infai sys:relevantFor:bis sys:relevantFor:simba ngonga simba khan saleem group_aksw opal dice},
  note       = {https://papers.dice-research.org/2019/ISWC2019\_PhdConsortium/ISWC\_PhDConsortium\_hashim-public.pdf},
}

@Article{jalota2019approach,
  author   = {Rricha Jalota and Priyansh Trivedi and Gaurav Maheshwari and Axel-Cyrille Ngonga Ngomo and Ricardo Usbeck},
  journal  = {International Workshop on Chatbot Research and Design},
  title    = {{An Approach for Ex-Post-Facto Analysis of Knowledge Graph-Driven Chatbots -- the DBpedia Chatbot}},
  year     = {2019},
  pages    = {19--33},
  keywords = {sys:relevantFor:solide sys:relevantFor:limbo sys:relevantFor:opal jalota trivdei maheshwari ngonga usbeck dice},
  note      = {https://papers.dice-research.org/2019/Conversations2019\_DBpedia\_Chatlog/Chatlog\_Analysis\_public.pdf},
}

@article{roeder2020squirrel,
author="Röder, Michael and de Souza Jr, Geraldo and Ngonga Ngomo, Axel-Cyrille",
title="Squirrel – Crawling RDF Knowledge Graphs on the Web",
note="https://papers.dice-research.org/2020/ISWC\_Squirrel/public.pdf",
booktitle="The Semantic Web -- ISWC 2020",
year="2020",
publisher="Springer International Publishing",
keywords  = {sys:relevantFor:infai sys:relevantFor:bis sys:relevantFor:simba sys:relevantFor:limbo sys:relevantFor:opal ngonga group_aksw dice roeder gsjunior}
}

@inproceedings{LSVS_2019,
	author = {{Abdullah Fathi} Ahmed and {Mohamed Ahmed} Sherif and Axel-Cyrille {Ngonga Ngomo}},
	bdsk-url-1 = {http://svn.aksw.org/papers/2019/NLDB\_LSVS/public.pdf},
	booktitle = {24th International Conference on Applications of Natural Language to Information Systems (NLDB 2019)},
	keywords = {2019 sys:relevantFor:infai group\_aksw simba sherif ngonga ahmed slipo limes dice sage limbo opal},
	publisher = {Springer},
	title = {{LSVS}: Link Specification Verbalization and Summarization},
	note = {https://papers.dice-research.org/2019/NLDB\_LSVS/paper/public.pdf},
	year = {2019}
}

@InProceedings{demir2020physical,
  author    = {Demir, Caglar and Ngomo, Axel-Cyrille Ngonga},
  booktitle = {Semantic Technology},
  title     = {A Physical Embedding Model for Knowledge Graphs},
  year      = {2020},
  address   = {Cham},
  editor    = {Wang, Xin and Lisi, Francesca Alessandra and Xiao, Guohui and Botoeva, Elena},
  pages     = {192--209},
  publisher = {Springer International Publishing},
  isbn      = {978-3-030-41407-8},
  keywords  = {sys:relevantFor:infai sys:relevantFor:opal demir ngonga dice},
  note       = {https://papers.dice-research.org/2019/JIST2019\_PYKE/public.pdf},
}

@InProceedings{hecate_om_2020,
  author    = {Kleanthi Georgala and Michael Röder and Mohamed Ahmed Sherif and Axel-Cyrille {Ngonga Ngomo}},
  booktitle = {Proceedings of Ontology Matching Workshop 2020},
  title     = {{Applying edge-counting semantic similarities to Link Discovery: Scalability and Accuracy}},
  year      = {2020},
  keywords  = {2020 dice simba sherif hecate ngonga knowgraphs sys:relevantFor:limboproject limboproject sys:relevantFor:infai sys:relevantFor:bis limes limbo opal roeder georgala},
  owner     = {sherif},
  timestamp = {2020.09.23},
  note       = {https://papers.dice-research.org/2020/OM\_hECATE/public.pdf},
}

@inproceedings{desouki2019ranking,
  title={Ranking on Very Large Knowledge Graphs},
  author={Desouki, Abdelmoneim Amer and Röder, Michael and Ngonga Ngomo, Axel-Cyrille},
  booktitle={Proceedings of the 30th ACM Conference on Hypertext and Social Media},
  pages={163--171},
  year={2019},
  organization={ACM},
  keywords     = {ngonga desouki roeder solide limboproject opal group_aksw dice rankingrdf dhare},
  note          = {https://papers.dice-research.org/2019/HT\_DHARE/dhare\_public.pdf},
}

@InProceedings{roeder2021orca,
  author    = {Michael Röder and Geraldo de Souza Jr. and Denis Kuchelev and Abdelmoneim Amer Desouki and Axel-Cyrille Ngonga Ngomo},
  booktitle = {Proceedings of the 15th IEEE International Conference on Semantic Computing (ICSC)},
  title     = {ORCA – a Benchmark for Data Web Crawlers},
  year      = {2021},
  pages     = {62-69},
  publisher = {IEEE Computer Society},
  keywords  = {dice raki daikiri opal limbo sys:relevantFor:limbo sys:relevantFor:opal group_aksw roeder ngonga kuchelev gsjunior},
  note       = {https://papers.dice-research.org/2021/ICSC2021\_ORCA/ORCA\_public.pdf},
  doi       = {10.1109/ICSC50631.2021.00054}
}

@inproceedings{PhoneticSimilarity2019,
  keywords     = {sys:relevantFor:infai sys:relevantFor:bis sys:relevantFor:ngonga ahmed sherif solide limboproject opal group_aksw dice},
  note          = {https://papers.dice-research.org/2019/KCAP\_PHONETICSIMILARITY/public.pdf},
  title= {Do your Resources Sound Similar? On the Impact of Using Phonetic Similarity in Link Discovery},
  author = {Abdullah Fathi Ahmed and Mohamed Ahmed Sherif and Axel-Cyrille {Ngonga Ngomo}},
  booktitle = {K-CAP 2019: Knowledge Capture Conference},
	year = {2019}
}

@article{KI_LIMES_2021,
  title={{LIMES - A Framework for Link Discovery on the Semantic Web}},
  author={Axel-Cyrille {Ngonga Ngomo} and Mohamed Ahmed Sherif and Kleanthi Georgala and Mofeed Hassan and Kevin Dreßler and Klaus Lyko and Daniel Obraczka and Tommaso Soru},
  journal={KI - K{\"u}nstliche Intelligenz, German Journal of Artificial Intelligence - Organ des Fachbereichs "Künstliche Intelligenz" der Gesellschaft für Informatik e.V.},
  year={2021},
  note = {https://papers.dice-research.org/2021/KI\_LIMES/public.pdf},
  owner = {sherif},
  doi = {10.1007/s13218-021-00713-x},
  keywords  = {2021 dice simba sherif limes ngonga knowgraphs sys:relevantFor:limboproject limboproject sys:relevantFor:infai sys:relevantFor:bis limbo opal georgala kevin slipo sage},
  publisher={Springer}
}

@article{AHMED2021101874,
title = {Multilingual Verbalization and Summarization for Explainable Link Discovery},
journal = {Data \& Knowledge Engineering},
pages = {101874},
year = {2021},
issn = {0169-023X},
doi = {https://doi.org/10.1016/j.datak.2021.101874},
note = {https://papers.dice-research.org/2021/DATAK\_LSVS\_journal/public.pdf},
author = {Abdullah Fathi Ahmed and Mohamed Ahmed Sherif and Diego Moussallem and Axel-Cyrille Ngonga Ngomo},
keywords = {2021 sys:relevantFor:infai simba sherif ngonga ahmed limes dice raki moussallem libo opal knowgraphs},
}

literature 2

@inproceedings{DBLP:conf/www/AthreyaNU18,
  added-at = {2020-05-05T14:37:33.000+0200},
  author = {Athreya, Ram G. and Ngomo, Axel{-}Cyrille Ngonga and Usbeck, Ricardo},
  bibnote = {https://www.bibsonomy.org/bibtex/2c237c503743ed61965b4564bf5398966/dice-research},
  booktitle = {Companion of the The Web Conference 2018 on The Web Conference 2018, {WWW} 2018, Lyon , France, April 23-27, 2018},
  doi = {10.1145/3184558.3186964},
  interhash = {2cd5ff6a5cb88aae80dddf9c4b7fccf5},
  intrahash = {c237c503743ed61965b4564bf5398966},
  keywords = {2018 group\_aksw limbo limboproject ngonga opal simba solide usbeck},
  pages = {143–146},
  timestamp = {2020-05-05T14:37:33.000+0200},
  title = {Enhancing Community Interactions with Data-Driven Chatbots-The DBpedia Chatbot},
  note = {https://svn.aksw.org/papers/2018/WWW\_dbpedia\_chatbot/public.pdf},
  year = 2018
}

@inproceedings{moussallem2019thoth,
  added-at = {2019-11-04T14:11:11.000+0100},
  author = {Moussallem, Diego and Soru, Tommaso and Ngomo, Axel-Cyrille Ngonga},
  bibnote = {https://www.bibsonomy.org/bibtex/2efe7283615db9b4b8a115bf545d45b2c/dice-research},
  booktitle = {International Semantic Web Conference},
  doi = {https://doi.org/10.1007/978-3-030-30793-6_29},
  interhash = {75ce9cc27cff007755f0488d3fa1e1da},
  intrahash = {efe7283615db9b4b8a115bf545d45b2c},
  keywords = {dice group_aksw moussallem ngonga opal soru},
  organization = {Springer},
  pages = {505--522},
  timestamp = {2019-11-04T14:11:11.000+0100},
  title = {{THOTH: Neural Translation and Enrichment of Knowledge Graphs}},
  note = {https://link.springer.com/chapter/10.1007/978-3-030-30793-6\_29},
  year = 2019
}

@inproceedings{moussallem2018entity,
  added-at = {2020-06-18T18:41:43.000+0200},
  author = {Moussallem, Diego and Usbeck, Ricardo and Röder, Michael and Ngomo, Axel-Cyrille Ngonga},
  bibnote = {https://www.bibsonomy.org/bibtex/21c3ef7f799678b79f82687674eaab81c/dice-research},
  booktitle = {The Semantic Web, ESWC 2018, Lecture Notes in Computer Science},
  interhash = {5a55d0d619e086cffca8578c8fa7f91a},
  intrahash = {1c3ef7f799678b79f82687674eaab81c},
  keywords = {agdistis dice diesel group\_aksw limboproject moussallem ngonga opal qamel roeder simba solide usbeck},
  timestamp = {2020-06-18T18:41:43.000+0200},
  title = {Entity Linking in 40 Languages using MAG},
  note = {https://arxiv.org/abs/1805.11467},
  year = 2018
}

@inproceedings{Moussallem2017,
  added-at = {2020-06-18T18:41:43.000+0200},
  author = {Moussallem, Diego and Usbeck, Ricardo and Röder, Michael and {Ngonga Ngomo}, Axel-Cyrille},
  bibnote = {https://www.bibsonomy.org/bibtex/2530b7f35caee89b695131f3e45f9a673/dice-research},
  booktitle = {K-CAP 2017: Knowledge Capture Conference},
  interhash = {9a80b21f84b3b10e430d9e21a8ca2ded},
  intrahash = {530b7f35caee89b695131f3e45f9a673},
  keywords = {agdistis dice diesel group\_aksw limboproject moussallem ngonga opal project-hobbit projecthobbit qamel roeder simba solide usbeck},
  organization = {ACM},
  pages = 8,
  timestamp = {2020-06-18T18:41:43.000+0200},
  title = {MAG: A Multilingual, Knowledge-base Agnostic and Deterministic Entity Linking Approach},
  note = {https://svn.aksw.org/papers/2017/KCAP\_MAG/public.pdf},
  year = 2017
}

@inproceedings{moussallem2019swmt,
  added-at = {2019-11-04T15:29:20.000+0100},
  author = {Moussallem, Diego and Wauer, Matthias and Ngomo, Axel-Cyrille Ngonga},
  bibnote = {https://www.bibsonomy.org/bibtex/2debb2175d2efe6b58d1aa12cf52dd560/dice-research},
  booktitle = {International Semantic Web Conference},
  interhash = {33a551537672f5b74d270a7057f49de3},
  intrahash = {debb2175d2efe6b58d1aa12cf52dd560},
  keywords = {dice group_aksw moussallem ngonga opal wauer},
  organization = {Springer},
  pages = 8,
  timestamp = {2019-11-04T15:29:20.000+0100},
  title = {{Semantic Web for Machine Translation: Challenges and Directions}},
  note = {https://arxiv.org/pdf/1907.10676.pdf},
  year = 2019
}

@inproceedings{DBLP:conf/bigdataconf/Ngonga17,
  added-at = {2020-06-18T14:14:48.000+0200},
  author = {{Ngonga Ngomo}, Axel-Cyrille and Hoffmann, Michael and Usbeck, Ricardo and Jha, Kunal},
  bibnote = {https://www.bibsonomy.org/bibtex/27895943c3bb7d9521374961ccb865d20/dice-research},
  booktitle = {2017 {IEEE} International Conference on Big Data},
  interhash = {90a53863e32a226338f8eb5035c97c13},
  intrahash = {7895943c3bb7d9521374961ccb865d20},
  keywords = {dice diesel group\_aksw hare hoffmann kunaljha limboproject ngonga opal project-hobbit projecthobbit qamel simba usbeck},
  pages = 10,
  timestamp = {2020-06-18T14:14:48.000+0200},
  title = {Holistic and Scalable Ranking of RDF Data},
  note = {https://svn.aksw.org/papers/2017/ESWC\_HARE/public.pdf},
  year = 2017
}

@inproceedings{Ngonga2019,
  added-at = {2020-06-18T18:41:56.000+0200},
  author = {{Ngonga Ngomo}, Axel-Cyrille and Moussallem, Diego and Bühman, Lorenz},
  bibnote = {https://www.bibsonomy.org/bibtex/2a920c64111a6933af050e4a72cb4e3c7/dice-research},
  booktitle = {Proceedings of the International Conference Recent Advances in Natural Language Processing},
  interhash = {00e3817fc53a72652f02a1dbbff4b609},
  intrahash = {a920c64111a6933af050e4a72cb4e3c7},
  keywords = {dice group_aksw moussallem ngonga opal simba solide},
  organization = {ACL (Association for Computational Linguistics)},
  pages = 8,
  timestamp = {2020-06-18T18:41:56.000+0200},
  title = {{A Holistic Natural Language Generation Framework for the Semantic Web}},
  year = 2019,
  note = {https://arxiv.org/pdf/1911.01248.pdf}
}

@inproceedings{icwe_dragon,
  added-at = {2020-05-05T14:37:31.000+0200},
  author = {Obraczka, Daniel and {Ngonga Ngomo}, Axel-Cyrille},
  bibnote = {https://www.bibsonomy.org/bibtex/2f459215f0747b9281f6a22094e744dba/dice-research},
  booktitle = {ICWE},
  editor = {Bakaev, Maxim and Frasincar, Flavius and Ko, In-Young},
  ee = {https://doi.org/10.1007/978-3-030-19274-7_31},
  interhash = {ad9ec8623df5c85baab9c9cb6975f112},
  intrahash = {f459215f0747b9281f6a22094e744dba},
  isbn = {978-3-030-19274-7},
  keywords = {dice group\_aksw limboproject limes ngonga obraczka opal},
  pages = {441–456},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  timestamp = {2020-05-05T14:37:31.000+0200},
  title = {Dragon: Decision Tree Learning for Link Discovery.},
  note = {https://link.springer.com/chapter/10.1007%2F978-3-030-19274-7\_31},
  volume = 11496,
  year = 2019
}

@inproceedings{saleemnlidwod-iswc,
  added-at = {2020-06-18T14:14:50.000+0200},
  author = {Saleem, Muhammad and Dastjerdi, Samaneh Nazari and Usbeck, Ricardo and Ngomo, Axel-Cyrille Ngonga},
  bdsk-url-1 = {https://svn.aksw.org/papers/2017/NLIWOD_ISWC/public.pdf},
  bibnote = {https://www.bibsonomy.org/bibtex/25ef6de278c676a18088404a3e45ace8e/dice-research},
  booktitle = {Natural Language Interfaces workshop at ISWC},
  interhash = {a27fda38bce8b73b27943dc49b41cf23},
  intrahash = {5ef6de278c676a18088404a3e45ace8e},
  keywords = {dice diesel group_aksw limboproject ngonga opal projecthobbit qamel saleem saman simba solide usbeck},
  timestamp = {2020-06-18T14:14:50.000+0200},
  title = {Question Answering Over Linked Data: What is Difficult to Answer? What affects the F scores?},
  note = {https://svn.aksw.org/papers/2017/NLIWOD\_ISWC/public.pdf},
  year = 2017
}

@inproceedings{Saleem2017SQC,
  added-at = {2020-06-18T14:14:51.000+0200},
  author = {Saleem, Muhammad and Stadler, Claus and Mehmood, Qaiser and Lehmann, Jens and Ngomo, Axel-Cyrille Ngonga},
  bibnote = {https://www.bibsonomy.org/bibtex/2a4d1b8ca008f62987170266e6eae5f52/dice-research},
  booktitle = {K-CAP 2017: Knowledge Capture Conference},
  interhash = {52e674a10e916763bca3147fd8d4717e},
  intrahash = {a4d1b8ca008f62987170266e6eae5f52},
  keywords = {dice group_aksw lehmann ngonga opal project-hobbit saleem stadler},
  organization = {ACM},
  timestamp = {2020-06-18T14:14:51.000+0200},
  title = {{SQCFramework}: {SPARQL} Query Containment Benchmark Generation Framework},
  note = {http://jens-lehmann.org/files/2017/kcap\_sqc.pdf},
  year = 2017
}

@inproceedings{ligon_om_2020,
  added-at = {2020-09-17T16:15:31.000+0200},
  author = {Sherif, Mohamed Ahmed and {Kevin Dreßler} and {Ngonga Ngomo}, Axel-Cyrille},
  bibnote = {https://www.bibsonomy.org/bibtex/2140973fc6088a77c4dac384fc3b692d1/dice-research},
  booktitle = {Proceedings of Ontology Matching Workshop 2020},
  interhash = {3ba3350f60d01aa8baac9bc46faafb04},
  intrahash = {140973fc6088a77c4dac384fc3b692d1},
  keywords = {2020 dice kevin knowgraphs ligon limbo limboproject limes ngonga opal sherif simba},
  owner = {sherif},
  timestamp = {2021-03-09T14:04:03.000+0100},
  title = {{LIGON – Link Discovery with Noisy Oracles}},
  note = {https://papers.dice-research.org/2020/OM\_LIGON/public.pdf},
  year = 2020
}

@inproceedings{limesWebUI,
  added-at = {2020-06-18T18:41:24.000+0200},
  author = {Sherif, Mohamed Ahmed and Pestryakova, Svetlana and Dreßler, Kevin and Ngomo, Axel-Cyrille Ngonga},
  bdsk-url-1 = {http://svn.aksw.org/papers/2019/ISWC\_limesWebUI/public.pdf},
  bibnote = {https://www.bibsonomy.org/bibtex/2a2f07335440c89f1490ab40c8617369a/dice-research},
  booktitle = {18th International Semantic Web Conference (ISWC 2019)},
  interhash = {9ac361cfc47697e7581e04d8c708101d},
  intrahash = {a2f07335440c89f1490ab40c8617369a},
  keywords = {2019 Svetlana dice group\_aksw kevin limbo limes ngonga opal sage sherif simba slipo},
  publisher = {CEUR-WS.org},
  timestamp = {2020-06-18T18:41:24.000+0200},
  title = {LimesWebUI – Link Discovery Made Simple},
  note = {http://svn.aksw.org/papers/2019/ISWC\_limesWebUI/public.pdf},
  year = 2019
}

@inproceedings{JointModel2019,
  added-at = {2020-06-18T14:14:56.000+0200},
  author = {Zahera, Hamada M. and Sherif, Mohamed Ahmed and {Ngonga Ngomo}, Axel-Cyrille},
  bibnote = {https://www.bibsonomy.org/bibtex/275f99a868d0a21313f8cbae23c5ec1a0/dice-research},
  booktitle = {K-CAP 2019: Knowledge Capture Conference},
  interhash = {03fa7b1612f9a3a7b850bdd4033d4823},
  intrahash = {75f99a868d0a21313f8cbae23c5ec1a0},
  keywords = {dice group\_aksw limboproject ngonga opal sherif simba solide zahera},
  organization = {ACM},
  pages = 4,
  timestamp = {2020-09-17T07:59:57.000+0200},
  title = {Jointly Learning from Social Media and Environmental Data for Typhoon Intensity Prediction},
  note = {https://papers.dice-research.org/2019/KCAP2019\_Joint\_model/K-CAP19\_Joint-model-public.pdf},
  year = 2019
}

in bibsonomy, but not mentioned

inproceedings{liger_om_2020,
  abstract = {Modern data-driven frameworks often have to process large amounts of data periodically. Hence, they often operate under time or space constraints. This also holds for Linked Data-driven frameworks when processing RDF data, in particular, when they perform link discovery tasks. In this work, we present a novel approach for link discovery under constraints pertaining to the expected recall of a link discovery task. Given a link specification, the approach aims to find a subsumed link specification that achieves a lower run time than the input specification while abiding by a predefined constraint on the expected recall it has to achieve. Our approach, dubbed LIGER, combines downward refinement oper- ators with monotonicity assumptions to detect such specifications. We evaluate our approach on seven datasets. Our results suggest that the different implemen- tations of LIGER can detect subsumed specifications that abide by expected recall constraints efficiently, thus leading to significantly shorter overall run times than our baseline.},
  added-at = {2020-09-23T13:04:30.000+0200},
  author = {Georgala, Kleanthi and Sherif, Mohamed Ahmed and {Ngonga Ngomo}, Axel-Cyrille},
  bibnote = {https://www.bibsonomy.org/bibtex/25169da099f733641699194d39e76af74/dice-research},
  booktitle = {Proceedings of Ontology Matching Workshop 2020},
  interhash = {5f5fe11860b806ba3cb98c8775c1e51b},
  intrahash = {5169da099f733641699194d39e76af74},
  keywords = {2020 dice georgala hecate knowgraphs limbo limboproject limes ngonga opal sherif simba},
  owner = {sherif},
  timestamp = {2021-03-09T14:04:03.000+0100},
  title = {{LIGER – Link Discovery with Partial Recall}},
  note = {https://papers.dice-research.org/2020/OM\_LIGER/public.pdf},
  year = 2020
}

inproceedings{kaur2019offline,
  added-at = {2019-11-04T14:34:58.000+0100},
  author = {Kaur, Paramjot and Bl{\"u}cher, Vincent and Jalota, Rricha and Moussallem, Diego},
  bibnote = {https://www.bibsonomy.org/bibtex/2956a9421777e7846094eaa23a39623ef/dice-research},
  booktitle = {SEMANTiCS},
  interhash = {f69e9fde985cecc001e189748bc58125},
  intrahash = {956a9421777e7846094eaa23a39623ef},
  keywords = {dice group_aksw moussallem ngonga opal param usbeck},
  timestamp = {2019-11-04T14:34:58.000+0100},
  title = {{Offline Question Answering over Linked Data using Limited Resources}},
  year = 2019
}

inproceedings{moussallemkgnmt2019,
  added-at = {2019-11-04T14:11:11.000+0100},
  author = {Moussallem, Diego and {Ngonga Ngomo}, Axel-Cyrille and Buitelaar, Paul and Arcan, Mihael},
  bibnote = {https://www.bibsonomy.org/bibtex/2b95660f52731a95d9dd70a80b5eaeb18/dice-research},
  booktitle = {K-CAP 2019: Knowledge Capture Conference},
  interhash = {af837aa424a2f052b474a67408d83f98},
  intrahash = {b95660f52731a95d9dd70a80b5eaeb18},
  keywords = {dice group_aksw moussallem ngonga opal simba solide},
  organization = {ACM},
  pages = 8,
  timestamp = {2019-11-04T14:11:11.000+0100},
  title = {{Utilizing Knowledge Graphs for Neural Machine TranslationAugmentation}},
  note = {https://arxiv.org/pdf/1902.08816.pdf},
  year = 2019
}

inproceedings{Saleem2018SQCDmo,
  added-at = {2020-06-18T14:14:51.000+0200},
  author = {Saleem, Muhammad and Stadler, Claus and Mehmood, Qaiser and Lehmann, Jens and Ngomo, Axel-Cyrille Ngonga},
  bibnote = {https://www.bibsonomy.org/bibtex/2d6182da1c9d2d80b25133fc245d72017/dice-research},
  booktitle = {Demo at ISWC},
  interhash = {d429b6c45ffc603798b88824ab883469},
  intrahash = {d6182da1c9d2d80b25133fc245d72017},
  keywords = {dice group_aksw lehmann ngonga opal project-hobbit saleem stadler},
  timestamp = {2020-06-18T14:14:51.000+0200},
  title = {{SQCFramework}: Generating SPARQL Query Containment Benchmarks using the SQCFramework},
  note = {https://svn.aksw.org/papers/2018/ISWC-Demo-SQCFramework/public.pdf},
  year = 2018
}

article{DBLP:journals/corr/abs-1710-08634,
  added-at = {2020-06-18T18:41:51.000+0200},
  archiveprefix = {arXiv},
  author = {Usbeck, Ricardo and Hoffmann, Michael and Röder, Michael and Lehmann, Jens and Ngomo, Axel{-}Cyrille Ngonga},
  bibnote = {https://www.bibsonomy.org/bibtex/2961a5e7349306f4620755b588684dc07/dice-research},
  eprint = {1710.08634},
  interhash = {53008dc5512011e0f0d95b3d35d95e43},
  intrahash = {961a5e7349306f4620755b588684dc07},
  journal = {CoRR},
  keywords = {dice group\_aksw hoffmann lehmann limboproject ngonga opal qamel roeder simba solide usbeck},
  timestamp = {2020-06-18T18:41:51.000+0200},
  title = {Using Multi-Label Classification for Improved Question Answering},
  note = {http://arxiv.org/abs/1710.08634},
  volume = {abs/1710.08634},
  year = 2017
}

repository: projekt-opal/doc

repo_name: projekt-opal/doc

gha_language: JavaScript


text:
SUMMARY = "A pure-Python libconfig reader/writer with permissive license"
SECTION = "devel/python"
HOMEPAGE = "https://github.com/Grk0/python-libconf"
LICENSE = "MIT"

LIC_FILES_CHKSUM = "file://LICENSE;md5=05f696c084eaaf5d75bc150f70975758"

SRC_URI[md5sum] = "e212611cbf6a696e05742a983b3a0c57"
SRC_URI[sha256sum] = "2f907258953ba60a95a82d5633726b47c81f2d5cf8d8801b092579016d757f4a"

inherit pypi setuptools3

BBCLASSEXTEND = "native nativesdk"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded


text:
package main

import "C"

import (
	"bufio"
	"os"
	"fmt"
)

func shouldFetchMoreEntries() bool {
	fmt.Print("Fetch more logs or quit (m/q)? ")
	reader := bufio.NewReader(os.Stdin)
	input, _ := reader.ReadByte()
	return string(input) == "m"
}

repository: varlogs/logstasher-cli

repo_name: varlogs/logstasher-cli


text:
module.exports = {
	AudioOpus: require('./audioopus'),
	PacketCrypto: require('./packetcrypto'),
	PacketRTP: require('./packetrtp'),
	PacketRTPHeader: require('./packetrtpheader')
};

repository: SpencerSharkey/websocket

repo_name: SpencerSharkey/websocket

extension: js


text:
DESCRIPTION = "Xinerama library"
LICENSE = "MIT"
SECTION = "x11/libs"
PRIORITY = "optional"
DEPENDS = "panoramixext xproto x11 xext"
PV = "0.0+cvs${SRCDATE}"

SRC_URI = "cvs://anoncvs:anoncvs@pdx.freedesktop.org/cvs/xlibs;module=Xinerama"
S = "${WORKDIR}/Xinerama"

inherit autotools pkgconfig

do_stage() {
	autotools_stage_all
}

repository: BackupTheBerlios/openslug-svn

repo_name: BackupTheBerlios/openslug-svn


text:
SUMMARY = "Universal encoding detector for Python 2 and 3"
LICENSE = "LGPL-2.1"
LIC_FILES_CHKSUM = "file://LICENSE;md5=a6f89e2100d9b6cdffcea4f398e37343"

SRC_URI[sha256sum] = "0d6f53a15db4120f2b08c94f11e7d93d2c911ee118b6b30a04ec3ee8310179fa"

# setup.py of chardet needs this.
DEPENDS += "${PYTHON_PN}-pytest-runner-native"

inherit pypi setuptools3

PACKAGES =+ "${PN}-cli"
FILES_${PN}-cli += " \
    ${PYTHON_SITEPACKAGES_DIR}/chardet/cli \
"

RDEPENDS_${PN}-cli = "${PN} "

RDEPENDS_${PN}_class-target += " \
    ${PYTHON_PN}-logging \
"

BBCLASSEXTEND = "native nativesdk"

repository: ni/meta-openembedded

repo_name: ni/meta-openembedded

branch_name: refs/heads/nilrt/master/hardknott