text:
SUMMARY = "The upstream project used to drive the Device Mapper multipathing driver"

DESCRIPTION = "It provides tools to manage multipath devices \
by instructing the device-mapper kernel module what to do. These \
tools include: \
1. multipath - Scan the system for multipath devices and assemble them.\
2. multipathd - Detects when paths fail and execs multipath to update \
things.\
3. mpathpersist - Persistent reservation management feature allows \
cluster management software to manage persistent reservation through \
mpath device. It processes management requests from callers and hides \
the management task details. It also handles persistent reservation \
management of data path life cycle and state changes.\
4. kpartx - This tool, derived from util-linux's partx, reads partition \
tables on specified device and create device maps over partitions \
segments detected. It is called from hotplug upon device maps creation \
and deletion"

HOMEPAGE = "http://christophe.varoqui.free.fr/"

DEPENDS = "libdevmapper \
           libaio \
           liburcu \
           readline \
           udev \
           json-c \
          "

LICENSE = "GPLv2"

SRC_URI = "git://git.opensvc.com/multipath-tools/.git;protocol=http \
           file://multipathd.oe \
           file://multipath.conf.example \
           file://0001-multipath-tools-add-RDAC-SUN-ArrayStorage-to-hwtable.patch \
           file://0002-multipath-tools-remove-c-from-__cpluscplus-misspelle.patch \
           file://0003-multipath-tools-remove-emacs-autoconfig-of-kpartx-gp.patch \
           file://0004-multipath-tools-replace-FSF-address-with-a-www-point.patch \
           file://0005-multipath-tools-Remove-trailing-leading-whitespaces-.patch \
           file://0006-multipath-tools-fix-compilation-with-musl-libc.patch \
           file://0007-multipath-tools-add-x-to-doc-preclean.pl-and-split-m.patch \
           file://0008-multipath-tools-refresh-kernel-doc-from-kernel-sourc.patch \
           file://0009-multipath-tools-configure-hitachi-ams2000-and-hus100.patch \
           file://0010-libmultipath-don-t-reject-maps-with-undefined-prio.patch \
           file://0011-multipathd-handle-errors-in-uxlsnr-as-fatal.patch \
           file://0012-libmultipath-fix-error-parsing-find_multipaths-stric.patch \
           file://0013-libmultipath-print-correct-default-for-delay_-_check.patch \
           file://0014-multipath.conf.5-clarify-property-whitelist-handling.patch \
           file://0015-mpathpersist-add-all_tg_pt-option.patch \
           file://0016-libmultipath-remove-rbd-code.patch \
           file://0017-mpathpersist-fix-aptpl-support.patch \
           file://0018-multipath-don-t-check-timestamps-without-a-path.patch \
           file://0019-libmultipath-fix-detect-alua-corner-case.patch \
           file://0020-multipath-fix-setting-conf-version.patch \
           file://0021-RH-fixup-udev-rules-for-redhat.patch \
           file://0022-RH-Remove-the-property-blacklist-exception-builtin.patch \
           file://0023-RH-don-t-start-without-a-config-file.patch \
           file://0024-RH-use-rpm-optflags-if-present.patch \
           file://0025-RH-add-mpathconf.patch \
           file://0026-RH-add-wwids-from-kernel-cmdline-mpath.wwids-with-A.patch \
           file://0027-RH-warn-on-invalid-regex-instead-of-failing.patch \
           file://0028-RH-reset-default-find_mutipaths-value-to-off.patch \
           file://0029-multipath-tools-modify-Makefile.inc-for-cross-compil.patch \
           file://0030-Always-use-devmapper.patch \
           file://0031-Always-use-devmapper-for-kpartx.patch \
           "

LIC_FILES_CHKSUM = "file://COPYING;md5=5f30f0716dfdd0d91eb439ebec522ec2"

SRCREV = "386d288b5595fc2c01dffe698b6eb306c6674908"

S = "${WORKDIR}/git"

inherit systemd pkgconfig

SYSTEMD_SERVICE_${PN} = "multipathd.service"

TARGET_CC_ARCH += "${LDFLAGS}"

# multipath-tools includes a copy of the valgrind.h header
# file and uses the macros to suppress some false positives. However,
# that only works on ARM when thumb is disabled. Otherwise one gets:
#   Error: shifts in CMP/MOV instructions are only supported in unified syntax -- `mov r12,r12,ror#3'
#   ../Makefile.inc:66: recipe for target 'debug.o' failed
ARM_INSTRUCTION_SET_armv4 = "arm"
ARM_INSTRUCTION_SET_armv5 = "arm"

# The exact version of SYSTEMD does not matter but should be greater than 209.
#
EXTRA_OEMAKE = 'MULTIPATH_VERSION=${PV} DESTDIR=${D} syslibdir=${base_libdir} \
                OPTFLAGS="${CFLAGS}" \
                bindir=${base_sbindir} \
                LIB=${base_libdir} libdir=${base_libdir}/multipath \
                unitdir=${systemd_system_unitdir} \
                ${@bb.utils.contains("DISTRO_FEATURES", "systemd", "SYSTEMD=216", "", d)} \
               '

do_install() {
    oe_runmake install

    # We copy an initscript, but do not start multipathd at init time.
    #
    if ${@bb.utils.contains('DISTRO_FEATURES','sysvinit','true','false',d)};then
        install -d ${D}${sysconfdir}/init.d
        cp ${WORKDIR}/multipathd.oe ${D}${sysconfdir}/init.d/multipathd
    fi

    install -d ${D}${sysconfdir}
    install -m 0644 ${WORKDIR}/multipath.conf.example \
    ${D}${sysconfdir}/multipath.conf.example
}

FILES_${PN}-dbg += "${base_libdir}/multipath/.debug"

PACKAGES =+ "${PN}-libs"
FILES_${PN}-libs = "${base_libdir}/lib*.so.* \
                    ${base_libdir}/multipath/lib*.so*"
RDEPENDS_${PN} += "${PN}-libs bash"

PROVIDES += "device-mapper-multipath"
RPROVIDES_${PN} += "device-mapper-multipath"
RPROVIDES_${PN}-libs += "device-mapper-multipath-libs"

FILES_${PN}-dev += "${base_libdir}/pkgconfig"

PACKAGES =+ "kpartx"
FILES_kpartx = "${base_sbindir}/kpartx \
                ${nonarch_libdir}/udev/kpartx_id \
               "

RDEPENDS_${PN} += "bash kpartx"

repository: astarche/meta-openembedded

repo_name: astarche/meta-openembedded

branch_name: refs/heads/nilrt/master/sumo


text:
#======================================#
#           SUMMARY/LICENCE            #
#--------------------------------------#
SUMMARY = "uEnv.txt for rodent flasher"

LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

#======================================#
#           REQUIRE/INHERIT            #
#--------------------------------------#
inherit deploy

#======================================#
#                SOURCE                #
#--------------------------------------#
SRC_URI = " file://uEnv.txt "

#======================================#
#           DEPENDS/PROVIDES           #
#--------------------------------------#

#======================================#
#         BUILD CONFIGURATIONS         #
#--------------------------------------#
PACKAGE_ARCH = "${MACHINE_ARCH}"

# Copied from u-boot.inc
UBOOT_ENV = "uEnv"
UBOOT_ENV_SUFFIX ?= "txt"
UBOOT_ENV_BINARY ?= "${UBOOT_ENV}.${UBOOT_ENV_SUFFIX}"
UBOOT_ENV_IMAGE ?= "${UBOOT_ENV}-${MACHINE}-${PV}-${PR}.${UBOOT_ENV_SUFFIX}"
UBOOT_ENV_SYMLINK ?= "${UBOOT_ENV}-${MACHINE}.${UBOOT_ENV_SUFFIX}"

DEPLOY_DIR_IMAGE_append = "/flasher"

#======================================#
#                TASKS                 #
#--------------------------------------#
do_patch[noexec] = "1"
do_configure[noexec] = "1"
do_compile[noexec] = "1"
do_install[noexec] = "1"
deltask do_populate_sysroot
do_package[noexec] = "1"
deltask do_package_qa
do_packagedata[noexec] = "1"
deltask do_package_write_ipk
deltask do_package_write_deb
deltask do_package_write_rpm

do_deploy () {
    install -m 644 ${WORKDIR}/${UBOOT_ENV_BINARY} ${DEPLOYDIR}/${UBOOT_ENV_IMAGE}
    rm -f ${DEPLOYDIR}/${UBOOT_ENV_BINARY} ${DEPLOYDIR}/${UBOOT_ENV_SYMLINK}
    ln -sf ${UBOOT_ENV_IMAGE} ${DEPLOYDIR}/${UBOOT_ENV_BINARY}
    ln -sf ${UBOOT_ENV_IMAGE} ${DEPLOYDIR}/${UBOOT_ENV_SYMLINK}
}

addtask deploy before do_build

#======================================#
#            PACKAGES/FILES            #
#--------------------------------------#

#======================================#
#            INSTALL SCRIPT            #
#--------------------------------------#

#======================================#
#             ALTERNATIVES             #
#--------------------------------------#

#======================================#
#           USERADD/SYSTEMD            #
#--------------------------------------#

#======================================#
#                 TEST                 #
#--------------------------------------#

license: MIT

license_type: permissive

branch_name: refs/heads/master

extension: bb


text:
package logger

import (
	"fmt"
	"github.com/rs/zerolog"
	"io"
	"strings"
	"time"
	"web-api-scaffold/internal/pkg/config"
)

const (
	colorBlack = iota + 30
	colorRed
	colorGreen
	colorYellow
	colorBlue
	colorMagenta
	colorCyan
	colorWhite

	colorBold     = 1
	colorDarkGray = 90
)

type Logger struct {
	*zerolog.Logger
}

func New(out io.Writer) *Logger {
	writer := zerolog.ConsoleWriter{Out: out}

	colorize := func(s interface{}, c int, bold bool) string {
		if config.IsReleaseLogMode() {
			return fmt.Sprintf("%v", s)
		}

		if bold {
			return fmt.Sprintf("\u001B[%dm\x1b[%dm%v\x1b[0m\u001B[0m",
				colorBold, c, s)
		}

		return fmt.Sprintf("\x1b[%dm%v\x1b[0m", c, s)
	}

	writer.FormatTimestamp = func(i interface{}) string {
		t := time.Now().Format("2006-01-02 15:04:05.000")
		return colorize(t, colorDarkGray, false)
	}

	writer.FormatLevel = func(i interface{}) string {
		var l string

		if ll, ok := i.(string); ok {
			switch ll {
			case "trace":
				l = colorize("[TRC]", colorMagenta, false)
			case "debug":
				l = colorize("[DBG]", colorYellow, false)
			case "info":
				l = colorize("[INF]", colorGreen, false)
			case "warn":
				l = colorize("[WRN]", colorRed, false)
			case "error":
				l = colorize("[ERR]", colorRed, true)
			case "fatal":
				l = colorize("[FTL]", colorRed, true)
			case "panic":
				l = colorize("[PNC]", colorRed, true)
			default:
				l = colorize("[???]", colorBold, true)
			}
		} else {
			if i == nil {
				l = colorize("[???]", colorBold, true)
			} else {
				l = strings.ToUpper(fmt.Sprintf("[%s]", i))[0:3]
			}
		}

		return l
	}

	writer.FormatCaller = func(i interface{}) string {
		return ""
	}

	writer.FormatMessage = func(i interface{}) string {
		return fmt.Sprintf("(%s)",
			colorize(fmt.Sprintf("%s", i), colorWhite, true))
	}

	writer.FormatFieldName = func(i interface{}) string {
		return colorize(fmt.Sprintf("%s", i), colorCyan, false) +
			colorize("=", colorBold, true)
	}

	writer.FormatFieldValue = func(i interface{}) string {
		return colorize(fmt.Sprintf("%s", i), colorWhite, false)
	}

	writer.FormatErrFieldName = func(i interface{}) string {
		return colorize(fmt.Sprintf("%s", i), colorRed, false) +
			colorize("=", colorBold, true)
	}

	writer.FormatErrFieldValue = func(i interface{}) string {
		return colorize(fmt.Sprintf("%s", i), colorRed, true)
	}

	logger := zerolog.New(writer).
		With().
		Timestamp().
		Logger()

	return &Logger{&logger}
}

//func Instance() *Logger {
//	//jack :=lumberjack.Logger{
//	//	Filename:   config.Instance().Logfile.Server,
//	//	MaxSize:    7,
//	//	MaxBackups: 30,
//	//	MaxAge:     30,
//	//	Compress:   false,
//	//}
//	//fmt.Println("once +++++++++++++++++++++++++++++++++++++")
//	once.Do(func() {
//		fmt.Println("once +++++++++++++++++++++++++++++++++++++")
//		log = New(os.Stdout)
//	})
//	return log
//}

branch_name: refs/heads/main

extension: go


text:
SUMMARY = "Enblend combines images that overlap like this into a single large image with no seams."

LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://COPYING;md5=b234ee4d69f5fce4486a80fdaf4a4263"

DEPENDS = "tiff lcms vigra gsl boost"

SRC_URI = "http://netcologne.dl.sourceforge.net/project/enblend/enblend-enfuse/enblend-enfuse-4.1/enblend-enfuse-${PV}.tar.gz"
SRC_URI[md5sum] = "a025137ba53fc8a355347fe721c6267c"
SRC_URI[sha256sum] = "1c00ae95cd05502759d7d47f99e6ba1150f8807f8f4f46c800cd46c5ad0df9ac"

inherit autotools pkgconfig

repository: koenkooi/meta-photography

repo_name: koenkooi/meta-photography

gha_language: C


text:
package stgcommon

// TopicFilterType Topic过滤方式，默认为单Tag过滤
// Author gaoyanlei
// Since 2017/8/9
type TopicFilterType int

const (
	SINGLE_TAG TopicFilterType = iota // 每个消息只能有一个Tag
	MULTI_TAG                         // (1)每个消息可以有多个Tag（暂时不支持，后续视情况支持)(2)为什么暂时不支持?(3)此功能可能会对用户造成困扰，且方案并不完美，所以暂不支持
)

func (self TopicFilterType) ToString() string {
	switch self {
	case SINGLE_TAG:
		return "SINGLE_TAG"
	case MULTI_TAG:
		return "MULTI_TAG"
	default:
		return ""
	}
}

repository: ttstringiot/golangiot

repo_name: ttstringiot/golangiot


text:
require xfce4-music-image.bb

export IMAGE_BASENAME = "xfce4-music-dev-image"

XFCE_DM = "sddm sddm-morona-autologin"

IMAGE_INSTALL += " \
    packagegroup-gui-dev \
    \
    xfce4-dev-tools \
    libxfce4ui-glade \
    \
    jack-dev \
    lv2-dev \
    libvorbis-dev \
    aubio-dev \
    libmad-dev \
    libsamplerate0-dev \
    rubberband-dev \
    liblo-dev \
    lilv-dev \
    suil-dev \
    serd-dev \
    sord-dev \
"

repository: ZeraGmbH/meta-mortsgna

repo_name: ZeraGmbH/meta-mortsgna

gha_license_id: MIT


text:
@online{noauthor_top_nodate-1,
	title = {Top 5 Mistakes in Predictive Modeling - Jigsaw Academy Training for careers in Analytics},
	url = {http://analyticstraining.com/2013/top-5-mistakes-in-predictive-modeling/},
	abstract = {Top 5 Mistakes in Predictive Modeling Using data to build predictive models is an exciting and interesting field to be in. And while many of us are caught up in the excitement of generating models using the latest techniques and algorithms, we should not forget that there could be severe},
	titleaddon = {Jigsaw Academy Training for careers in Analytics},
	urldate = {2013-06-29}
}

repository: pmean/build-website

repo_name: pmean/build-website

extension: bib


text:
SUMMARY = "python3 compatibility library"

LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=6f00d4a50713fa859858dd9abaa35b21"

SRC_URI[md5sum] = "34eed507548117b2ab523ab14b2f8b55"
SRC_URI[sha256sum] = "105f8d68616f8248e24bf0e9372ef04d3cc10104f1980f54d57b2ce73a5ad56a"

RDEPENDS_${PN} += "${PYTHON_PN}-io"

inherit pypi setuptools3 distutils3 python3native python3-dir

BBCLASSEXTEND = "native nativesdk"

repository: y-ashiduka/meta-spdxscanner

repo_name: y-ashiduka/meta-spdxscanner


text:
package expreduce

import "bytes"

func ToStringInfix(parts []Ex, delim string, form string) (bool, string) {
	if form != "InputForm" && form != "OutputForm" {
		return false, ""
	}
	if len(parts) < 2 {
		return false, ""
	}
	var buffer bytes.Buffer
	buffer.WriteString("(")
	for i := 0; i < len(parts); i++ {
		buffer.WriteString(parts[i].StringForm(form))
		if i != len(parts)-1 {
			buffer.WriteString(delim)
		}
	}
	buffer.WriteString(")")
	return true, buffer.String()
}

func (this *Expression) ToStringInfix(form string) (bool, string) {
	if len(this.Parts) != 3 {
		return false, ""
	}
	expr, isExpr := this.Parts[1].(*Expression)
	delim, delimIsStr := this.Parts[2].(*String)
	if !isExpr || !delimIsStr {
		return false, ""
	}
	return ToStringInfix(expr.Parts[1:], delim.Val, form)
}

func ToStringInfixAdvanced(parts []Ex, delim string, surroundEachArg bool, start string, end string, form string) (bool, string) {
	if form != "InputForm" && form != "OutputForm" {
		return false, ""
	}
	if len(parts) < 2 {
		return false, ""
	}
	var buffer bytes.Buffer
	if !surroundEachArg {
		buffer.WriteString(start)
	}
	for i := 0; i < len(parts); i++ {
		if surroundEachArg {
			buffer.WriteString("(")
			buffer.WriteString(parts[i].String())
			buffer.WriteString(")")
		} else {
			buffer.WriteString(parts[i].String())
		}
		if i != len(parts)-1 {
			buffer.WriteString(delim)
		}
	}
	if !surroundEachArg {
		buffer.WriteString(end)
	}
	return true, buffer.String()
}

func (this *String) NeedsEval() bool {
	return false
}

repository: abduld/expreduce

repo_name: abduld/expreduce


text:
package main

import (
	"bytes"
	"errors"
	"github.com/concourse-sonarqube-notifier/assets/shared/sharedfakes"
	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

var _ = Describe("Check", func() {
	var (
		stdin            *bytes.Buffer
		stdout           *bytes.Buffer
		fakeResultSource *sharedfakes.FakeResultSource
	)

	const mockResponse = `{
		  "paging": {
		    "pageIndex": 1,
		    "pageSize": 100,
		    "total": 12
		  },
		  "analyses": [
		    {
		      "key": "AWKa7VV9drIzrRaH-p_z",
		      "date": "2018-04-06T14:27:06+0200",
		      "events": [
		        {
		          "key": "AWKa7VsYdrIzrRaH-p_0",
		          "category": "VERSION",
		          "name": "0.0.1-SNAPSHOT"
		        }
		      ]
		    },
		    {
		      "key": "AWKQ3B6rdrIzrRaH-Rt3",
		      "date": "2018-04-04T15:32:28+0200",
		      "events": []
		    },
		    {
		      "key": "AWJhuKRVdrIzrRaH-JD8",
		      "date": "2018-03-26T11:51:30+0200",
		      "events": [
		        {
		          "key": "AWJhuKoddrIzrRaH-JD-",
		          "category": "QUALITY_GATE",
		          "name": "Green (was Red)",
		          "description": ""
		        }
		      ]
		    },
		    {
		      "key": "AWJOESP5NZwlownmr1uo",
		      "date": "2018-03-22T15:15:48+0100",
		      "events": []
		    },
		    {
		      "key": "AWIFz6Qd0iGqzMJL9y73",
		      "date": "2018-03-08T14:31:37+0100",
		      "events": []
		    }
		  ]
		}`

	BeforeEach(func() {
		stdin = new(bytes.Buffer)
		stdout = new(bytes.Buffer)
		fakeResultSource = new(sharedfakes.FakeResultSource)
	})

	It("returns the versions of the last results", func() {
		stdin.WriteString(`{
			"source": {
    			"target": "https://my.sonar.server",
				"sonartoken": "token",
    			"component": "my:component",
    			"metrics": "ncloc,complexity,violations,coverage"
  			},
  			"version": {
				"ref": "61cebf"
			}
		}`)
		fakeResultSource.GetVersionsReturns([]byte(mockResponse), nil)

		err := run(stdin, stdout, fakeResultSource)

		Expect(err).NotTo(HaveOccurred())

		Expect(fakeResultSource.GetVersionsCallCount()).To(Equal(1))
		url, token, component := fakeResultSource.GetVersionsArgsForCall(0)
		Expect(url).To(Equal("https://my.sonar.server"))
		Expect(token).To(Equal("token"))
		Expect(component).To(Equal("my:component"))

		expectedResponse := `[{"timestamp":"2018-03-08T14:31:37+0100"},{"timestamp":"2018-03-22T15:15:48+0100"},{"timestamp":"2018-03-26T11:51:30+0200"},{"timestamp":"2018-04-04T15:32:28+0200"},{"timestamp":"2018-04-06T14:27:06+0200"}]`
		response := make([]byte, len(expectedResponse), len(expectedResponse))
		stdout.Read(response)
		Expect(string(response)).To(Equal(expectedResponse))
	})

	It("returns an error if the content could not be fetched", func() {
		stdin.WriteString(`{
			"source": {
    			"target": "https://my.sonar.server",
				"sonartoken": "token",
    			"component": "my-component",
    			"metrics": "ncloc,complexity,violations,coverage"
  			},
  			"version": {
				"ref": "61cebf"
			}
		}`)
		fakeResultSource.GetResultReturns(nil, errors.New("something serious"))

		err := run(stdin, stdout, fakeResultSource)

		Expect(err).To(HaveOccurred())
	})

	Describe("mandatory check", func() {
		It("errors when target is missing", func() {
			stdin.WriteString(`{
				"source": {
    				"missing_target": "https://my.sonar.server",
    				"sonartoken": "token",
    				"component": "my-component",
    				"metrics": "ncloc,complexity,violations,coverage"
  				},
  				"version": {
					"ref": "61cebf"
				}
			}`)
			fakeResponse := make([]byte, 36, 36)
			fakeResultSource.GetResultReturns(fakeResponse, nil)

			err := run(stdin, stdout, fakeResultSource)

			Expect(err).To(HaveOccurred())
		})

		It("errors when component is missing", func() {
			stdin.WriteString(`{
				"source": {
    				"target": "https://my.sonar.server",
    				"sonartoken": "token",
    				"missing_component": "my-component",
    				"metrics": "ncloc,complexity,violations,coverage"
  				},
  				"version": {
					"ref": "61cebf"
				}
			}`)
			fakeResponse := make([]byte, 36, 36)
			fakeResultSource.GetResultReturns(fakeResponse, nil)

			err := run(stdin, stdout, fakeResultSource)

			Expect(err).To(HaveOccurred())
		})

		It("errors when metrics are missing", func() {
			stdin.WriteString(`{
				"source": {
    				"target": "https://my.sonar.server",
    				"sonartoken": "token",
    				"component": "my-component",
    				"missing_metrics": "ncloc,complexity,violations,coverage"
  				},
  				"version": {
					"ref": "61cebf"
				}
			}`)
			fakeResponse := make([]byte, 36, 36)
			fakeResultSource.GetResultReturns(fakeResponse, nil)

			err := run(stdin, stdout, fakeResultSource)

			Expect(err).To(HaveOccurred())
		})

		It("errors when sonartoken is missing", func() {
			stdin.WriteString(`{
				"source": {
    				"target": "https://my.sonar.server",
    				"missing_sonartoken": "token",
    				"component": "my-component",
    				"metrics": "ncloc,complexity,violations,coverage"
  				},
  				"version": {
					"ref": "61cebf"
				}
			}`)
			fakeResponse := make([]byte, 36, 36)
			fakeResultSource.GetResultReturns(fakeResponse, nil)

			err := run(stdin, stdout, fakeResultSource)

			Expect(err).To(HaveOccurred())
		})
	})
})

repository: fossabot/concourse-sonarqube-notifier

repo_name: fossabot/concourse-sonarqube-notifier


text:
package obinary

import (
	"fmt"
	"os"
	"path/filepath"
	"runtime"
)

// func validStorageType(storageType constants.StorageType) bool {
// 	return storageType == constants.Persistent || storageType == constants.Volatile
// }

// func validDbType(dbtype constants.DatabaseType) bool {
// 	return dbtype == constants.DocumentDb || dbtype == constants.GraphDbT
// }

//
// Should only be used during development of the library.
// TODO: remove me
//
func fatal(err error) {
	_, file, line, _ := runtime.Caller(1)
	fmt.Printf("\033[31mFATAL: %s:%d: "+err.Error()+"\033[39m\n\n",
		append([]interface{}{filepath.Base(file), line})...)
	os.Exit(1)
}

repository: yanfali/ogonori

repo_name: yanfali/ogonori


text:
SUMMARY = "KWriteD: Listen to traditional system notifications"
LICENSE = "GPLv2"
LIC_FILES_CHKSUM = " \
    file://COPYING;md5=5c213a7de3f013310bd272cdb6eb7a24 \
"

inherit kde-plasma gettext

DEPENDS += " \
    kcoreaddons \
    kcoreaddons-native \
    ki18n \
    kpty \
    knotifications \
    kdbusaddons \
"

PV = "${PLASMA_VERSION}"
SRC_URI[md5sum] = "202a9dafb70e7ff547eaf7e56240b893"
SRC_URI[sha256sum] = "caabc136af8bede8232484a23da7bd9d06f4121813f725b2d02fb24da6841694"

SRC_URI += " \
    file://0001-fix-build-for-qtbase-without-session-management.patch \
"

FILES_${PN} += " \
    ${datadir}/knotifications5 \
"


text:
/*
 *    Copyright 2020 opensourceai
 *
 *    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 upload

import (
	"fmt"
	"log"
	"mime/multipart"
	"os"
	"path"
	"strings"

	"github.com/opensourceai/go-api-service/pkg/file"
	"github.com/opensourceai/go-api-service/pkg/logging"
	"github.com/opensourceai/go-api-service/pkg/setting"
	"github.com/opensourceai/go-api-service/pkg/util"
)

// GetImageFullUrl get the full access path
func GetImageFullUrl(name string) string {
	return setting.AppSetting.PrefixUrl + "/" + GetImagePath() + name
}

// GetImageName get image name
func GetImageName(name string) string {
	ext := path.Ext(name)
	fileName := strings.TrimSuffix(name, ext)
	fileName = util.EncodeMD5(fileName)

	return fileName + ext
}

// GetImagePath get save path
func GetImagePath() string {
	return setting.AppSetting.ImageSavePath
}

// GetImageFullPath get full save path
func GetImageFullPath() string {
	return setting.AppSetting.RuntimeRootPath + GetImagePath()
}

// CheckImageExt check image file ext
func CheckImageExt(fileName string) bool {
	ext := file.GetExt(fileName)
	for _, allowExt := range setting.AppSetting.ImageAllowExts {
		if strings.ToUpper(allowExt) == strings.ToUpper(ext) {
			return true
		}
	}

	return false
}

// CheckImageSize check image size
func CheckImageSize(f multipart.File) bool {
	size, err := file.GetSize(f)
	if err != nil {
		log.Println(err)
		logging.Warn(err)
		return false
	}

	return size <= setting.AppSetting.ImageMaxSize
}

// CheckImage check if the file exists
func CheckImage(src string) error {
	dir, err := os.Getwd()
	if err != nil {
		return fmt.Errorf("os.Getwd err: %v", err)
	}

	err = file.IsNotExistMkDir(dir + "/" + src)
	if err != nil {
		return fmt.Errorf("file.IsNotExistMkDir err: %v", err)
	}

	perm := file.CheckPermission(src)
	if perm == true {
		return fmt.Errorf("file.CheckPermission Permission denied src: %s", src)
	}

	return nil
}


text:
@inproceedings{Hoelzl2017IFIPShort,
    author = "Hölzl, Michael and Roland, Michael and Mayrhofer, René",
    title = "{An Extensible and Privacy-preserving Mobile eID System for Real-world Identification and Offline Verification}",
    booktitle = "{The Smart World Revolution - 12th International {IFIP} Summer School on Privacy and Identity Management (Pre-proceedings)}",
    abstract = "There is a broad range of existing electronic identity (eID) systems which provide methods to sign documents or authenticate to online services (e.g. governmental eIDs, FIDO). However, these solutions mainly focus on the validation of an identity to a backend infrastructure. That is, they lack in providing proper techniques to use them as regular ID cards to digitally authenticate an eID holder to another physical person in the real world. We envision a mobile eID which provides such a functionality and enables extensibility for its use with numerous different public and private services (e.g. for loyalty programs, public transport tickets, students cards), while protecting the privacy of the eID holder. In this paper, we present a general architecture for such a privacy-preserving mobile eID that allows identity validation in a similar fashion as regular ID cards and makes carrying around various physical cards unnecessary.",
    year = "2017",
    month = "08"
}

repository: mihoelzl/public-web-page

repo_name: mihoelzl/public-web-page


text:
package utmpx

// #include <utmpx.h>
// #include <string.h>
import "C"

func closeutmpx() {
	C.endutxent()
}

func resetutmpx() {
	C.setutxent()
}

func toStr(b *C.char, max C.size_t) string {
	if b == nil || max == 0 {
		return ""
	}
	l := C.strnlen(b, max)
	if l == 0 {
		return ""
	}
	return C.GoStringN(b, C.int(l))
}

repository: eoof/skewer

repo_name: eoof/skewer


text:
package config

import (
	"testing"

	"github.com/workfit/tester/assert"
)

func TestFieldFromString(t *testing.T) {
	tests := []struct {
		in  string
		out ModeField
	}{
		{
			"Firebase",
			FieldFirebase,
		},
		{
			" FireBASE ",
			FieldFirebase,
		},
		{
			" F1REBAS3",
			FieldInvalid,
		},
	}

	for i, test := range tests {
		result := FieldFromString(test.in)
		assert.For(t, i).ThatActual(result).Equals(test.out)

	}
}

repository: jkomoros/boardgame

repo_name: jkomoros/boardgame

gha_language: Go


text:
package algorithms

import (
	"github.com/stretchr/testify/assert"
	"testing"
)

var tcs = []struct {
	n   int
	ans string
}{

	{
		100,
		"CV",
	},

	{
		1000,
		"ALL",
	},

	{
		53,
		"BA",
	},

	{
		52,
		"AZ",
	},

	{
		26,
		"Z",
	},

	{
		1,
		"A",
	},

	{
		28,
		"AB",
	},
}

func Test168(t *testing.T) {
	ast := assert.New(t)

	for _, tc := range tcs {
		ast.Equal(tc.ans, convertToTitle(tc.n), "输入:%v", tc)
	}
}

repository: longrnt/workspace-go

repo_name: longrnt/workspace-go


text:
@misc{github_sportvu_data,
    title = {Basketball data GitHub repository},
    author = {Neil M. Johnson},
    year = {2015},
    note = {Accessed: 2017-06-21},
    howpublished = {\url{https://github.com/neilmj/BasketballData/tree/master/2016.NBA.Raw.SportVU.Game.Logs}},
  }

@misc{danielforsyth_api,
    title = {Exploring NBA data in Python},
    author = {Daniel Forsyth},
    year = {2015},
    note = {Accessed: 2017-06-21},
    howpublished = {\url{http://www.danielforsyth.me/exploring_nba_data_in_python/}},
  }

@misc{gregreda_api,
    title = {Web Scraping 201: finding the API},
    author = {Greg Reda},
    year = {2015},
    note = {Accessed: 2017-06-21},
    howpublished = {\url{http://www.gregreda.com/2015/02/15/web-scraping-finding-the-api/}},
  }

@misc{tjortjoglou_api,
    title = {How to Track NBA Player Movements in Python},
    author = {Savvas Tjortjoglou},
    year = {2015},
    note = {Accessed: 2017-06-21},
    howpublished = {\url{http://savvastjortjoglou.com/nba-play-by-play-movements.html}},
  }

@Manual{counterpoints,
    title = {Counterpoints: Advanced Defensive Metrics for NBA Basketball},
    author = {A. Franks and A. Miller and L. Bornn and K. Goldsberry},
    year = {2015},
    note = {},
    url = {http://www.lukebornn.com/papers/franks_ssac_2015.pdf},
  }

@Manual{moveordie,
    title = {Move or Die: How Ball Movement Creates Open Shots in the NBA},
    author = {A. D`Amour and D. Cervone and L. Bornn and K. Goldsberry},
    year = {2015},
    note = {},
    url = {http://www.lukebornn.com/papers/damour_ssac_2015.pdf},
  }

@Manual{defensiveskill,
    title = {Characterizing the Spatial Structure of Defensive Skill in Professional Basketball},
    author = {A. Franks and A. Miller and L. Bornn and K. Goldsberry},
    year = {2015},
    note = {},
    url = {http://www.lukebornn.com/papers/franks_aoas_2015.pdf},
  }

@Manual{EPV,
    title = {A Multiresolution Stochastic Process Model for Predicting Basketball Possession Outcomes},
    author = {D. Cervone and A. D`Amour and L. Bornn and K. Goldsberry},
    year = {2016},
    note = {},
    url = {http://arxiv.org/pdf/1408.0777.pdf},
  }

@misc{rastervignette,
    title = {Introduction to the `raster` package},
    author = {R. J. Hijmans},
    year = {2016},
    note = {R package version 2.5-8},
    howpublished = {\url{https://cran.r-project.org/web/packages/raster/vignettes/Raster.pdf}},
  }

@misc{plotcourt,
    title = {Drawing a basketball court with R},
    author = {Ewen Gallic},
    year = {2014},
    note = {Accessed: 2017-06-21},
    howpublished = {\url{http://egallic.fr/drawing-a-basketball-court-with-r/}},
  }


text:
---
---
References
==========

@article{ISLAM2019154,
title = {A heuristic aided Stochastic Beam Search algorithm for solving the transit network design problem},
journal = {Swarm and Evolutionary Computation},
volume = {46},
pages = {154-170},
year = {2019},
issn = {2210-6502},
doi = {https://doi.org/10.1016/j.swevo.2019.02.007},
url = {https://www.sciencedirect.com/science/article/pii/S2210650218302414},
author = {Kazi Ashik Islam and Ibraheem Muhammad Moosa and Jaiaid Mobin and Muhammad Ali Nayeem and M. Sohel Rahman},
abstract = {Designing efficient routes for a transit network is one of the main problems faced by city planners of the world. Due to the largeness and complexity of modern day road networks it is impossible to make a good route design manually. So, at present computer algorithms are used to design the routes. Designing routes for transit network is a multi-criteria decision making problem which has to search a large solution space to find an optimal solution. This paper presents a novel heuristic that can quickly generate good solutions. Also we propose a Stochastic Beam Search algorithm with a heuristic inspired successor operator. We conduct extensive experiments on some benchmark datasets and perform statistical tests on the results. We show that our algorithm can successfully explore the search space. Also we compare our results with previous studies and show that our algorithms produce superior results. In particular, for large datasets, the solutions generated by our heuristic in less than a second turn out to be better than solutions generated in two hours by the state of the art algorithm.}
}

@misc{https://doi.org/10.48550/arxiv.2201.12501,
  doi = {10.48550/ARXIV.2201.12501},

  url = {https://arxiv.org/abs/2201.12501},

  author = {Moosa, Ibraheem Muhammad and Akhter, Mahmud Elahi and Habib, Ashfia Binte},

  keywords = {Computation and Language (cs.CL), FOS: Computer and information sciences, FOS: Computer and information sciences},

  title = {Does Transliteration Help Multilingual Language Modeling?},

  publisher = {arXiv},

  year = {2022},

  selected={true},

  copyright = {Creative Commons Attribution Non Commercial No Derivatives 4.0 International}
}


text:
package authentication

import (
	"github.com/AyokunlePaul/crud-pay-api/src/domain/entity/user"
	"github.com/AyokunlePaul/crud-pay-api/src/pkg/response"
)

type UseCase interface {
	Create(*user.User) *response.BaseResponse
	LogIn(*user.User) *response.BaseResponse
	Update(string, user.User) (*user.User, *response.BaseResponse)
	ForgotPassword(string, string) *response.BaseResponse
	RefreshToken(string) (*user.User, *response.BaseResponse)
}

repository: IgweDaniel/crud-pay-api

repo_name: IgweDaniel/crud-pay-api


text:
require ${PN}.inc

PR = "r1"

SRC_URI = "http://sources.openembedded.org/opie-1.2.4-split_noncore_games_kpacman.tar.bz2;name=split_noncore_games_kpacman \
           http://sources.openembedded.org/opie-1.2.4-split_pics.tar.bz2;name=split_pics \
           http://sources.openembedded.org/opie-1.2.4-split_share.tar.bz2;name=split_share \
           http://sources.openembedded.org/opie-1.2.4-split_apps.tar.bz2;name=split_apps"
SRC_URI[split_noncore_games_kpacman.md5sum] = "1e3d37bbb4667915551e2c8a2f694ad4"
SRC_URI[split_noncore_games_kpacman.sha256sum] = "878c732f97192652613617f7a1df33cfd3959415445eac07b32fa2c2e5524c3f"
SRC_URI[split_pics.md5sum] = "5499dc84b65395ab99bda6ed9d01ff0f"
SRC_URI[split_pics.sha256sum] = "f22781f36e84e12d51fff1eb68cc3fb98221c7d807a82226813b7e974a604109"
SRC_URI[split_share.md5sum] = "d2c49981de19317e14f23b68672d118d"
SRC_URI[split_share.sha256sum] = "f2c6930ff0aea7045fc4e37a1e1d8a54a2c9205c60e2f15f64ab31011b7893fc"
SRC_URI[split_apps.md5sum] = "67a43e8e4bcd9e63b884ea25deea5b34"
SRC_URI[split_apps.sha256sum] = "a33a55efb4ae4c15a8c2c5d6faba6d671a5652da8e216ce35088896fe597215b"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
HOMEPAGE = "http://live.gnome.org/TwitterGlib"
SRC_URI = "git://github.com/ebassi/${PN}.git;protocol=git"
PV = "0.0+git${SRCREV}"
PR = "r0"

DEPENDS = "glib-2.0 gtk+ json-glib"

S = "${WORKDIR}/git"

EXTRA_OECONF = "--disable-shave --disable-introspection"

inherit autotools

do_configure_prepend () {
	 echo "EXTRA_DIST=" > ${S}/gtk-doc.make
}


text:
DESCRIPTION = "Dom0 scripts used for AOS provisioning"

LICENSE = "CLOSED"

SRCREV = "${AUTOREV}"
SRC_URI = "git://git@gitpct.epam.com/epmd-aepr/aos_provisioning.git;protocol=ssh"

S = "${WORKDIR}/git"

FILES_${PN} = " \
    /xt/scripts/aos-provisioning.step1.sh \
    /xt/scripts/aos-provisioning.step2.sh \
"

RDEPENDS_${PN} = "bash"

do_install() {
    install -d ${D}/xt/scripts
    install -m 0755 ${S}/aos-provisioning.step1.sh ${D}/xt/scripts
    install -m 0755 ${S}/aos-provisioning.step2.sh ${D}/xt/scripts
}

repository: varder/meta-aos-minimal

repo_name: varder/meta-aos-minimal


text:
// *** WARNING: this file was generated by the Pulumi SDK Generator. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***

package v1beta1

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// Returns a Certificate.
func LookupCertificate(ctx *pulumi.Context, args *LookupCertificateArgs, opts ...pulumi.InvokeOption) (*LookupCertificateResult, error) {
	var rv LookupCertificateResult
	err := ctx.Invoke("google-native:privateca/v1beta1:getCertificate", args, &rv, opts...)
	if err != nil {
		return nil, err
	}
	return &rv, nil
}

type LookupCertificateArgs struct {
	CertificateAuthorityId string `pulumi:"certificateAuthorityId"`
	CertificateId          string `pulumi:"certificateId"`
	Location               string `pulumi:"location"`
	Project                string `pulumi:"project"`
}

type LookupCertificateResult struct {
	// A structured description of the issued X.509 certificate.
	CertificateDescription CertificateDescriptionResponse `pulumi:"certificateDescription"`
	// Immutable. A description of the certificate and key that does not require X.509 or ASN.1.
	Config CertificateConfigResponse `pulumi:"config"`
	// The time at which this Certificate was created.
	CreateTime string `pulumi:"createTime"`
	// Optional. Labels with user-defined metadata.
	Labels map[string]string `pulumi:"labels"`
	// Required. Immutable. The desired lifetime of a certificate. Used to create the "not_before_time" and "not_after_time" fields inside an X.509 certificate. Note that the lifetime may be truncated if it would extend past the life of any certificate authority in the issuing chain.
	Lifetime string `pulumi:"lifetime"`
	// The resource path for this Certificate in the format `projects/*/locations/*/certificateAuthorities/*/certificates/*`.
	Name string `pulumi:"name"`
	// The pem-encoded, signed X.509 certificate.
	PemCertificate string `pulumi:"pemCertificate"`
	// The chain that may be used to verify the X.509 certificate. Expected to be in issuer-to-root order according to RFC 5246.
	PemCertificateChain []string `pulumi:"pemCertificateChain"`
	// Immutable. A pem-encoded X.509 certificate signing request (CSR).
	PemCsr string `pulumi:"pemCsr"`
	// Details regarding the revocation of this Certificate. This Certificate is considered revoked if and only if this field is present.
	RevocationDetails RevocationDetailsResponse `pulumi:"revocationDetails"`
	// The time at which this Certificate was updated.
	UpdateTime string `pulumi:"updateTime"`
}

repository: TheJaySmith-Google/pulumi-google-native

repo_name: TheJaySmith-Google/pulumi-google-native


text:
find_path(NTL_INCLUDE_DIR
  NAMES NTL/ZZ.h
  HINTS ENV NTL_INC_DIR
  ENV NTL_DIR
  PATH_SUFFIXES include
  DOC "The directory containing the NTL include files"
)

find_library(NTL_LIBRARY
  NAMES ntl
  HINTS ENV NTL_LIB_DIR
  ENV NTL_DIR
  PATH_SUFFIXES lib
  DOC "Path to the NTL library"
)

include(FindPackageHandleStandardArgs)

find_package_handle_standard_args(NTL
  DEFAULT_MSG
  NTL_LIBRARY
  NTL_INCLUDE_DIR
)

if(NTL_FOUND)

  set(NTL_VERSION_H "${NTL_INCLUDE_DIR}/NTL/version.h")

  if (EXISTS ${NTL_VERSION_H})

    file(READ "${NTL_VERSION_H}" NTL_VERSION_H_CONTENTS)
    string(REGEX MATCH "[0-9]+(\\.[0-9]+)+" NTL_VERSION "${NTL_VERSION_H_CONTENTS}")
    message(STATUS "NTL VERSION ${NTL_VERSION}")

  endif (EXISTS ${NTL_VERSION_H})

  set(NTL_INCLUDE_DIRS ${NTL_INCLUDE_DIR})
  set(NTL_LIBRARIES ${NTL_LIBRARY})

endif(NTL_FOUND)

repository: ZoltanDalmadi/lattice-fitting

repo_name: ZoltanDalmadi/lattice-fitting

extension: cmake


text:
package ledgerstate

import (
	"testing"
	"time"

	"github.com/iotaledger/hive.go/crypto/ed25519"
	"github.com/iotaledger/hive.go/identity"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

var sampleColor = Color{2}

func TestTransaction_Bytes(t *testing.T) {
	branchDAG, utxoDAG := setupDependencies(t)
	defer branchDAG.Shutdown()

	wallets := createWallets(2)
	input := generateOutput(utxoDAG, wallets[0].address, 0)
	tx, _ := singleInputTransaction(utxoDAG, wallets[0], wallets[1], input, false)
	bytes := tx.Bytes()
	_tx, _, err := TransactionFromBytes(bytes)
	assert.NoError(t, err)
	assert.Equal(t, tx.ID(), _tx.ID())
}

func TestTransaction_Complex(t *testing.T) {
	// setup variables representing keys and outputs for the two parties that wants to trade tokens
	party1KeyChain, party1SrcAddress, party1DestAddress, party1RemainderAddress := setupKeyChainAndAddresses(t)
	party1ControlledOutputID := NewOutputID(GenesisTransactionID, 1)
	party2KeyChain, party2SrcAddress, party2DestAddress, party2RemainderAddress := setupKeyChainAndAddresses(t)
	party2ControlledOutputID := NewOutputID(GenesisTransactionID, 2)

	// initialize fake ledger state with unspent Outputs
	unspentOutputsDB := setupUnspentOutputsDB(map[Address]map[OutputID]map[Color]uint64{
		party1SrcAddress: {
			party1ControlledOutputID: {
				sampleColor: 200,
			},
		},
		party2SrcAddress: {
			party2ControlledOutputID: {
				ColorIOTA: 2337,
			},
		},
	})

	// party1 prepares a TransactionEssence that party2 is supposed to complete for the exchange of tokens
	sentParty1Essence := NewTransactionEssence(0, time.Now(), identity.ID{}, identity.ID{},
		// he consumes 200 tokens of Color2
		NewInputs(unspentOutputsDB[party1ControlledOutputID].Input()),

		NewOutputs(
			// he wants to receive 1337 IOTA on his destination address
			NewSigLockedSingleOutput(1337, party1DestAddress),

			// he sends only 100 of the consumed tokens to the remainder leaving 100 unspent
			NewSigLockedColoredOutput(NewColoredBalances(map[Color]uint64{
				sampleColor: 100,
			}), party1RemainderAddress),
		),
	).Bytes()

	// party2 unmarshals the prepared TransactionEssence he received from party1
	receivedParty1Essence, _, err := TransactionEssenceFromBytes(sentParty1Essence)
	require.NoError(t, err)

	// party2 completes the prepared TransactionEssence by adding his Inputs and his Outputs
	completedEssence := NewTransactionEssence(0,
		receivedParty1Essence.Timestamp(),
		receivedParty1Essence.AccessPledgeID(),
		receivedParty1Essence.ConsensusPledgeID(),
		NewInputs(append(receivedParty1Essence.Inputs(), unspentOutputsDB[party2ControlledOutputID].Input())...),
		NewOutputs(append(receivedParty1Essence.Outputs(),
			// he wants to receive 100 tokens of Color2 on his destination address
			NewSigLockedColoredOutput(NewColoredBalances(map[Color]uint64{
				sampleColor: 100,
			}), party2DestAddress),

			// he sends only 1000 of the 2337 consumed IOTA to the remainder (leaving 1337 unspent)
			NewSigLockedSingleOutput(1000, party2RemainderAddress),
		)...),
	)

	// party2 prepares the signing process by creating the final transaction with empty UnlockBlocks
	unlockBlocks := make([]UnlockBlock, len(completedEssence.Inputs()))
	for i := range completedEssence.Inputs() {
		unlockBlocks[i] = NewSignatureUnlockBlock(NewED25519Signature(ed25519.PublicKey{}, ed25519.Signature{}))
	}
	transaction := NewTransaction(completedEssence, unlockBlocks)

	// both parties sign the transaction
	signTransaction(transaction, unspentOutputsDB, party2KeyChain)
	signTransaction(transaction, unspentOutputsDB, party1KeyChain)

	// TODO: ADD VALIDITY CHECKS ONCE WE ADDED THE UTXO DAG.
	// assert.True(t, utxoDAG.TransactionValid(transaction))
}

// setupKeyChainAndAddresses generates keys and addresses that are used by the test case.
func setupKeyChainAndAddresses(t *testing.T) (keyChain map[Address]ed25519.KeyPair, sourceAddr Address, destAddr Address, remainderAddr Address) {
	keyChain = make(map[Address]ed25519.KeyPair)

	sourceAddrPublicKey, sourceAddrPrivateKey, err := ed25519.GenerateKey()
	require.NoError(t, err)
	sourceAddr = NewED25519Address(sourceAddrPublicKey)
	keyChain[sourceAddr] = ed25519.KeyPair{PrivateKey: sourceAddrPrivateKey, PublicKey: sourceAddrPublicKey}

	destAddrPublicKey, destAddrPrivateKey, err := ed25519.GenerateKey()
	require.NoError(t, err)
	destAddr = NewED25519Address(destAddrPublicKey)
	keyChain[destAddr] = ed25519.KeyPair{PrivateKey: destAddrPrivateKey, PublicKey: destAddrPublicKey}

	remainderAddrPublicKey, remainderAddrPrivateKey, err := ed25519.GenerateKey()
	require.NoError(t, err)
	remainderAddr = NewED25519Address(remainderAddrPublicKey)
	keyChain[destAddr] = ed25519.KeyPair{PrivateKey: remainderAddrPrivateKey, PublicKey: remainderAddrPublicKey}

	return
}

// setupUnspentOutputsDB creates a fake database with Outputs.
func setupUnspentOutputsDB(outputs map[Address]map[OutputID]map[Color]uint64) (unspentOutputsDB OutputsByID) {
	unspentOutputsDB = make(OutputsByID)
	for address, outputs := range outputs {
		for outputID, balances := range outputs {
			unspentOutputsDB[outputID] = NewSigLockedColoredOutput(NewColoredBalances(balances), address).SetID(outputID)
		}
	}

	return
}

// addressFromInput retrieves the Address belonging to an Input by looking it up in the outputs that we have created for
// the tests.
func addressFromInput(input Input, outputsByID OutputsByID) Address {
	typeCastedInput, ok := input.(*UTXOInput)
	if !ok {
		panic("unexpected Input type")
	}

	switch referencedOutput := outputsByID[typeCastedInput.ReferencedOutputID()]; referencedOutput.Type() {
	case SigLockedSingleOutputType:
		typeCastedOutput, ok := referencedOutput.(*SigLockedSingleOutput)
		if !ok {
			panic("failed to type cast SigLockedSingleOutput")
		}

		return typeCastedOutput.Address()
	case SigLockedColoredOutputType:
		typeCastedOutput, ok := referencedOutput.(*SigLockedColoredOutput)
		if !ok {
			panic("failed to type cast SigLockedColoredOutput")
		}

		return typeCastedOutput.Address()
	default:
		panic("unexpected Output type")
	}
}

// signTransaction is a utility function that iterates through a transactions inputs and signs the addresses that are
// part of the signers key chain.
func signTransaction(transaction *Transaction, unspentOutputsDB OutputsByID, keyChain map[Address]ed25519.KeyPair) {
	essenceBytesToSign := transaction.Essence().Bytes()

	for i, input := range transaction.Essence().Inputs() {
		if keyPair, keyPairExists := keyChain[addressFromInput(input, unspentOutputsDB)]; keyPairExists {
			transaction.UnlockBlocks()[i] = NewSignatureUnlockBlock(NewED25519Signature(keyPair.PublicKey, keyPair.PrivateKey.Sign(essenceBytesToSign)))
		}
	}
}

repository: capossele/goshimmer

repo_name: capossele/goshimmer

branch_name: refs/heads/develop


text:
// Code generated by smithy-go-codegen DO NOT EDIT.

package ecs

import (
	"context"
	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
	"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
	"github.com/aws/aws-sdk-go-v2/service/ecs/types"
	"github.com/aws/smithy-go/middleware"
	smithyhttp "github.com/aws/smithy-go/transport/http"
)

// Modifies the settings to use for a cluster.
func (c *Client) UpdateClusterSettings(ctx context.Context, params *UpdateClusterSettingsInput, optFns ...func(*Options)) (*UpdateClusterSettingsOutput, error) {
	if params == nil {
		params = &UpdateClusterSettingsInput{}
	}

	result, metadata, err := c.invokeOperation(ctx, "UpdateClusterSettings", params, optFns, addOperationUpdateClusterSettingsMiddlewares)
	if err != nil {
		return nil, err
	}

	out := result.(*UpdateClusterSettingsOutput)
	out.ResultMetadata = metadata
	return out, nil
}

type UpdateClusterSettingsInput struct {

	// The name of the cluster to modify the settings for.
	//
	// This member is required.
	Cluster *string

	// The setting to use by default for a cluster. This parameter is used to enable
	// CloudWatch Container Insights for a cluster. If this value is specified, it will
	// override the containerInsights value set with PutAccountSetting or
	// PutAccountSettingDefault.
	//
	// This member is required.
	Settings []types.ClusterSetting
}

type UpdateClusterSettingsOutput struct {

	// A regional grouping of one or more container instances on which you can run task
	// requests. Each account receives a default cluster the first time you use the
	// Amazon ECS service, but you may also create other clusters. Clusters may contain
	// more than one instance type simultaneously.
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

func addOperationUpdateClusterSettingsMiddlewares(stack *middleware.Stack, options Options) (err error) {
	err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateClusterSettings{}, middleware.After)
	if err != nil {
		return err
	}
	err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateClusterSettings{}, middleware.After)
	if err != nil {
		return err
	}
	if err = addSetLoggerMiddleware(stack, options); err != nil {
		return err
	}
	if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
		return err
	}
	if err = addResolveEndpointMiddleware(stack, options); err != nil {
		return err
	}
	if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
		return err
	}
	if err = addRetryMiddlewares(stack, options); err != nil {
		return err
	}
	if err = addHTTPSignerV4Middleware(stack, options); err != nil {
		return err
	}
	if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
		return err
	}
	if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
		return err
	}
	if err = addClientUserAgent(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = addOpUpdateClusterSettingsValidationMiddleware(stack); err != nil {
		return err
	}
	if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateClusterSettings(options.Region), middleware.Before); err != nil {
		return err
	}
	if err = addRequestIDRetrieverMiddleware(stack); err != nil {
		return err
	}
	if err = addResponseErrorMiddleware(stack); err != nil {
		return err
	}
	if err = addRequestResponseLogging(stack, options); err != nil {
		return err
	}
	return nil
}

func newServiceMetadataMiddleware_opUpdateClusterSettings(region string) *awsmiddleware.RegisterServiceMetadata {
	return &awsmiddleware.RegisterServiceMetadata{
		Region:        region,
		ServiceID:     ServiceID,
		SigningName:   "ecs",
		OperationName: "UpdateClusterSettings",
	}
}


text:
@article{Dong_2016,
 author = {Dong, Fang and Wang, Jinwen and Deng, Riqiang and Wang, Xunzhang},
 title = {Autographa californica multiple nucleopolyhedrovirus gene ac81 is required for nucleocapsid envelopment},
 journal = {Virus Research},
 publisher = {Elsevier {BV}},
 year = {2016},
 month = {aug},
 volume = {221},
 pages = {47--57},
 url = {https://doi.org/10.1016%2Fj.virusres.2016.05.005},
 doi = {10.1016/j.virusres.2016.05.005}
}


text:
package main

import (
	"encoding/json"
	"fmt"
	"github.com/harshvladha/hasty"
	"net/http"
)

func main() {
	myMux := hasty.New()
	myMux.Get("/test", http.HandlerFunc(get2Handler))
	myMux.Get("/test/:var1", http.HandlerFunc(get2Handler))
	myMux.Get("/test/:var1/info", http.HandlerFunc(get2InfoHandler))
	myMux.GetFunc("/home/:var2", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Value of var2: "+hasty.GetValue(r, "var2"))
	})
	fmt.Println("Registered...")
	err := myMux.ListenAndServe("8080")
	if err != nil {
		fmt.Println("Error: ", err)
	}
}

func get2Handler(rw http.ResponseWriter, req *http.Request) {
	var queryId string
	if query := hasty.GetValue(req, "var1"); query != "" {
		queryId = query
	}
	var myJson = struct {
		First  string
		Second string
		Third  string
	}{"Hello", "World!", queryId}

	json.NewEncoder(rw).Encode(&myJson)
}

func get2InfoHandler(rw http.ResponseWriter, req *http.Request) {
	var queryId string
	if query := hasty.GetValue(req, "var1"); query != "" {
		queryId = query
	}
	var myJson = struct {
		First string
		Third string
	}{"Info", queryId}

	json.NewEncoder(rw).Encode(&myJson)
}

repository: harshvladha/hasty

repo_name: harshvladha/hasty


text:
# Added by Denis Kerzhemanov, 2015

if(DEFINED HUNTER_CMAKE_PROJECTS_LUA_HUNTER_CMAKE_)
  return()
else()
  set(HUNTER_CMAKE_PROJECTS_LUA_HUNTER_CMAKE_ 1)
endif()

include(hunter_add_version)
include(hunter_cacheable)
include(hunter_configuration_types)
include(hunter_download)
include(hunter_pick_scheme)

hunter_add_version(
    PACKAGE_NAME
    Lua
    VERSION
    "5.3.2"
    URL
    "https://github.com/hunter-packages/lua/archive/eabd8c173dab151e2dd5763e2d67c6dc5c9dc5f7.zip"
    SHA1
    ace46557838fd56221e362a0ce49d25726c7f94b
)

hunter_configuration_types(Lua CONFIGURATION_TYPES Release)
hunter_cacheable(Lua)
hunter_pick_scheme(DEFAULT url_sha1_cmake)
hunter_download(PACKAGE_NAME Lua)

repository: Banderi/hunter

repo_name: Banderi/hunter


text:
DESCRIPTION = "Common code for XSETTINGS"
SECTION = "gpe/libs"
LICENSE = "BSD-X"
PRIORITY = "optional"
DEPENDS = "virtual/libx11"

PR = "r3"

inherit gpe

headers = "xsettings-common.h"

do_compile_prepend() {
        sed -i -e 's: -s : :g' Makefile
}

do_install () {
        gpe_do_install
        oe_runmake PREFIX=${prefix} DESTDIR=${D} install-devel

        oe_libinstall -so libXsettings ${D}${libdir}

        install -d ${D}${includedir}/gpe
        for h in ${headers}; do
                install -m 0644 ${S}/$h ${D}${includedir}/$h
        done
}

SRC_URI[md5sum] = "ea623deae839c41ef68c9a31233157ef"
SRC_URI[sha256sum] = "4cae17ea07445660cedb34a8a0222055954ed67de3d5a527850d8b9e923e3543"


text:
% Encoding: UTF-8
@STRING{LNCS = {Lect. Notes Comp. Sci.}}

@INPROCEEDINGS{Leupolz2017,
	author="Leupolz, Johannes and Knapp, Alexander and Habermaier, Axel and Reif, Wolfgang",
	title={{Qualitative and Quantitative Analysis of Safety-Critical Systems with S\#}},
	bookTitle="International Journal on Software Tools for Technology Transfer",
	year="2017",
	issn    = {1433-2779},
	OPTdoi     = {10.1007/s10009-017-0464-3},
	publisher="Springer"
}
@PhdThesis{BaierHabil,
  author = 	 {Baier, Christel},
  title = 	 {On the Algorithmic Verification of Probabilistic Systems},
  school = 	 {Universit\"at Mannheim},
  year = 	 1998,
  type =	 {Habilitation}
}
@Book{BaierKatoen,
  author      = {Baier, Christel and Katoen, Joost-Pieter},
  title       = {Principles of Model Checking},
  year        = {2008},
  publisher   = {{MIT Press}},
  isbn        = {978-0-262-02649-9},
  address     = {Cambridge, MA},
  hyphenation = {american},
}

@online{SSharpGitRepo,
  author = {{Institute of Software and Systems Engineering}},
  title = {{S\# Source Repository}},
  howpublished = "\url{https://github.com/isse-augsburg/ssharp/}",
  year = {2018},
  URLDATE ="2018-01-30",
  OPTnote = "Online; accessed Jan 30th 2018"
}
@online{SSharpRepo,
  author = {{Institute of Software and Systems Engineering}},
  title = {{S\# Source Repository and Wiki}},
  howpublished = "\url{https://safetysharp.isse.de/}",
  year = {2018},
  URLDATE ="2018-01-30",
  OPTnote = "Online; accessed Jan 30th 2018",
  shorthand = {ISSE18},
}
@online{SSharpWiki,
  author = {{Institute of Software and Systems Engineering}},
  title = {{S\# Source Repository and Wiki}},
  howpublished = "\url{https://github.com/isseaugsburg/ssharp/wiki}",
  year = {2018},
  URLDATE ="2018-01-30",
  OPTnote = "Online; accessed Jan 30th 2018"
}

@PhDThesis{ParkerPhD,
	author={D. Parker},
	title={Implementation of Symbolic Model Checking for Probabilistic Systems},
	school={University of Birmingham},
	year={2002},
}

@PhDThesis{LeupolzPhD,
	author="Leupolz, Johannes",
	title={{Probabilistic Safety Analysis of Executable Models}},
	school={University of Augsburg},
	type = {Dissertation},
	year={2018},
}

repository: joleuger/pemc

repo_name: joleuger/pemc


text:
@article{vance-2015,
  annote = {Over the years, some academic consulting centers have prospered and others have sputtered and faltered. Dr. Vance offers some thoughts on what consulting centers need to do in order to thrive in a changing world.},
  author = {Eric A. Vance},
  title = {Recent Developments and Their Implications for the Future of Academic Statistical Consulting Centers},
  journal = {The American Statistician},
  volume = {69},
  number = {2},
  pages = {127-137},
  year  = {2015},
  publisher = {Taylor & Francis},
  doi = {10.1080/00031305.2015.1033990},
  URL = {https://doi.org/10.1080/00031305.2015.1033990},
  eprint = {https://doi.org/10.1080/00031305.2015.1033990},
  html = {},
  pdf = {https://www.tandfonline.com/doi/abs/10.1080/00031305.2015.1033990},
  source = {19/06/vance-2015},
  mendeley-tags = {Human side of statistics}
  urldate = {2019-06-08}
}

repository: pmean/build-website

repo_name: pmean/build-website


text:
// Code generated by smithy-go-codegen DO NOT EDIT.

package ssm

import (
	"context"
	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
	"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
	"github.com/aws/aws-sdk-go-v2/service/ssm/types"
	"github.com/aws/smithy-go/middleware"
	smithyhttp "github.com/aws/smithy-go/transport/http"
)

// Adds or overwrites one or more tags for the specified resource. Tags are
// metadata that you can assign to your documents, managed instances, maintenance
// windows, Parameter Store parameters, and patch baselines. Tags enable you to
// categorize your resources in different ways, for example, by purpose, owner, or
// environment. Each tag consists of a key and an optional value, both of which you
// define. For example, you could define a set of tags for your account's managed
// instances that helps you track each instance's owner and stack level. For
// example: Key=Owner and Value=DbAdmin, SysAdmin, or Dev. Or Key=Stack and
// Value=Production, Pre-Production, or Test. Each resource can have a maximum of
// 50 tags. We recommend that you devise a set of tag keys that meets your needs
// for each resource type. Using a consistent set of tag keys makes it easier for
// you to manage your resources. You can search and filter the resources based on
// the tags you add. Tags don't have any semantic meaning to and are interpreted
// strictly as a string of characters. For more information about using tags with
// EC2 instances, see Tagging your Amazon EC2 resources
// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html) in the
// Amazon EC2 User Guide.
func (c *Client) AddTagsToResource(ctx context.Context, params *AddTagsToResourceInput, optFns ...func(*Options)) (*AddTagsToResourceOutput, error) {
	if params == nil {
		params = &AddTagsToResourceInput{}
	}

	result, metadata, err := c.invokeOperation(ctx, "AddTagsToResource", params, optFns, addOperationAddTagsToResourceMiddlewares)
	if err != nil {
		return nil, err
	}

	out := result.(*AddTagsToResourceOutput)
	out.ResultMetadata = metadata
	return out, nil
}

type AddTagsToResourceInput struct {

	// The resource ID you want to tag. Use the ID of the resource. Here are some
	// examples: ManagedInstance: mi-012345abcde MaintenanceWindow: mw-012345abcde
	// PatchBaseline: pb-012345abcde OpsMetadata object: ResourceID for tagging is
	// created from the Amazon Resource Name (ARN) for the object. Specifically,
	// ResourceID is created from the strings that come after the word opsmetadata in
	// the ARN. For example, an OpsMetadata object with an ARN of
	// arn:aws:ssm:us-east-2:1234567890:opsmetadata/aws/ssm/MyGroup/appmanager has a
	// ResourceID of either aws/ssm/MyGroup/appmanager or /aws/ssm/MyGroup/appmanager.
	// For the Document and Parameter values, use the name of the resource. The
	// ManagedInstance type for this API action is only for on-premises managed
	// instances. You must specify the name of the managed instance in the following
	// format: mi-ID_number. For example, mi-1a2b3c4d5e6f.
	//
	// This member is required.
	ResourceId *string

	// Specifies the type of resource you are tagging. The ManagedInstance type for
	// this API action is for on-premises managed instances. You must specify the name
	// of the managed instance in the following format: mi-ID_number. For example,
	// mi-1a2b3c4d5e6f.
	//
	// This member is required.
	ResourceType types.ResourceTypeForTagging

	// One or more tags. The value parameter is required. Do not enter personally
	// identifiable information in this field.
	//
	// This member is required.
	Tags []types.Tag
}

type AddTagsToResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

func addOperationAddTagsToResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
	err = stack.Serialize.Add(&awsAwsjson11_serializeOpAddTagsToResource{}, middleware.After)
	if err != nil {
		return err
	}
	err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpAddTagsToResource{}, middleware.After)
	if err != nil {
		return err
	}
	if err = addSetLoggerMiddleware(stack, options); err != nil {
		return err
	}
	if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
		return err
	}
	if err = addResolveEndpointMiddleware(stack, options); err != nil {
		return err
	}
	if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
		return err
	}
	if err = addRetryMiddlewares(stack, options); err != nil {
		return err
	}
	if err = addHTTPSignerV4Middleware(stack, options); err != nil {
		return err
	}
	if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
		return err
	}
	if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
		return err
	}
	if err = addClientUserAgent(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = addOpAddTagsToResourceValidationMiddleware(stack); err != nil {
		return err
	}
	if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAddTagsToResource(options.Region), middleware.Before); err != nil {
		return err
	}
	if err = addRequestIDRetrieverMiddleware(stack); err != nil {
		return err
	}
	if err = addResponseErrorMiddleware(stack); err != nil {
		return err
	}
	if err = addRequestResponseLogging(stack, options); err != nil {
		return err
	}
	return nil
}

func newServiceMetadataMiddleware_opAddTagsToResource(region string) *awsmiddleware.RegisterServiceMetadata {
	return &awsmiddleware.RegisterServiceMetadata{
		Region:        region,
		ServiceID:     ServiceID,
		SigningName:   "ssm",
		OperationName: "AddTagsToResource",
	}
}


text:
package main

import (
	"fmt"
	"go/build"
	"log"
)

type searchAction func(pkg goPkg)
type searchPostProcess func()

type search struct {
	conf        config
	strsCache   []string
	byImport    importGroups
	action      searchAction
	postProcess searchPostProcess
}

func newSearch(conf config) *search {
	s := &search{
		conf: conf,
	}

	s.action = s.printPkg

	if conf.impRegex != nil || conf.txtRegex != nil {
		if conf.group && conf.txtRegex == nil {
			s.action = s.groupByMatchedImports
			s.byImport = makeImportGroups()

			s.postProcess = s.postGroupByMatchedImports
		} else {
			s.action = s.printMatchedPkgs
			s.strsCache = make([]string, 0, 100)
		}
	}

	return s
}

func (s *search) processDir(path string) {
	p, err := build.ImportDir(path, 0)
	if err != nil {
		if _, ok := err.(*build.NoGoError); !ok {
			log.Print(err)
		}

		return
	}

	s.action(makeGoPkg(trimPath(path, s.conf.dir), p))
}

func (s *search) printPkg(pkg goPkg) {
	fmt.Println(pkg)
}

func (s *search) printMatchedPkgs(pkg goPkg) {
	strs := s.getStrsFormCache()
	defer s.updateStrsCache(strs)

	if s.conf.impRegex != nil {
		strs = s.matchImpRegex(pkg, strs)
	}

	if s.conf.txtRegex != nil {
		strs = s.matchTxtRegex(pkg, strs)
	}

	if len(strs) > 0 {
		fmt.Println(pkg)
		for _, s := range strs {
			fmt.Printf("\t%s\n", s)
		}
		fmt.Println()
	}
}

func (s *search) matchImpRegex(pkg goPkg, strs []string) []string {
	for _, imp := range pkg.pkg.Imports {
		if s.conf.impRegex.MatchString(imp) {
			strs = append(strs, imp)
		}
	}

	return strs
}

func (s *search) matchTxtRegex(pkg goPkg, strs []string) []string {
	for _, file := range pkg.pkg.GoFiles {
		strs = appendMatchedStrings(s.conf.txtRegex, pkg.pkg.Dir, file, strs)
	}

	for _, file := range pkg.pkg.CFiles {
		strs = appendMatchedStrings(s.conf.txtRegex, pkg.pkg.Dir, file, strs)
	}

	for _, file := range pkg.pkg.CXXFiles {
		strs = appendMatchedStrings(s.conf.txtRegex, pkg.pkg.Dir, file, strs)
	}

	for _, file := range pkg.pkg.MFiles {
		strs = appendMatchedStrings(s.conf.txtRegex, pkg.pkg.Dir, file, strs)
	}

	for _, file := range pkg.pkg.HFiles {
		strs = appendMatchedStrings(s.conf.txtRegex, pkg.pkg.Dir, file, strs)
	}

	for _, file := range pkg.pkg.FFiles {
		strs = appendMatchedStrings(s.conf.txtRegex, pkg.pkg.Dir, file, strs)
	}

	for _, file := range pkg.pkg.SFiles {
		strs = appendMatchedStrings(s.conf.txtRegex, pkg.pkg.Dir, file, strs)
	}

	for _, file := range pkg.pkg.SwigFiles {
		strs = appendMatchedStrings(s.conf.txtRegex, pkg.pkg.Dir, file, strs)
	}

	for _, file := range pkg.pkg.SwigCXXFiles {
		strs = appendMatchedStrings(s.conf.txtRegex, pkg.pkg.Dir, file, strs)
	}

	return strs
}

func (s *search) groupByMatchedImports(pkg goPkg) {
	for _, imp := range pkg.pkg.Imports {
		if s.conf.impRegex.MatchString(imp) {
			s.byImport[imp] = s.byImport.append(imp, pkg)
		}
	}
}

func (s *search) postGroupByMatchedImports() {
	for k, v := range s.byImport {
		fmt.Printf("%s:\n", k)
		for _, s := range v {
			fmt.Printf("\t%s\n", s)
		}

		fmt.Println()
	}
}

func (s *search) getStrsFormCache() []string {
	return s.strsCache
}

func (s *search) updateStrsCache(strs []string) {
	if cap(strs) > cap(s.strsCache) {
		s.strsCache = strs[:0]
	}
}

repository: vasili-v/gofind

repo_name: vasili-v/gofind


text:
DESCRIPTION = "Task to build and install header and libs into the sdk"
LICENSE = "MIT"
PR = "r6"

inherit packagegroup

PACKAGE_ARCH = "${MACHINE_ARCH}"

QT_TOOLCHAIN_TARGET = "\
    packagegroup-arago-qte-toolchain-target \
"

QT_TOOLCHAIN_TARGET_keystone = ""

RDEPENDS_${PN} = "\
    ${QT_TOOLCHAIN_TARGET} \
    packagegroup-arago-tisdk-multimedia-sdk-target \
    packagegroup-arago-tisdk-connectivity-sdk-target \
    packagegroup-arago-tisdk-crypto-sdk-target \
    ${@base_contains('MACHINE_FEATURES','sgx','packagegroup-arago-tisdk-graphics-sdk-target','',d)} \
    packagegroup-arago-tisdk-addons-sdk-target \
"

repository: varigit/meta-arago-var

repo_name: varigit/meta-arago-var


text:
require boost-${PV}.inc
require boost.inc

SRC_URI += "\
           file://arm-intrinsics.patch \
           file://boost-CVE-2012-2677.patch \
           file://boost-math-disable-pch-for-gcc.patch \
           file://0001-Apply-boost-1.62.0-no-forced-flags.patch.patch \
           file://0003-Don-t-set-up-arch-instruction-set-flags-we-do-that-o.patch \
           file://reproducibility-add-file-directive-to-assembler.patch \
           "

repository: danieltarnu/meta-marlin

repo_name: danieltarnu/meta-marlin

gha_language: PHP


text:
@InProceedings{yang54,
  title = {Enhancing Topic Modeling on Short Texts with Crowdsourcing},
  author = {Yang, Xiaoyan and Ying, Shanshan and Yu, Wenzhe and Zhang, Rong and Zhang, Zhenjie},
  pages = {33--48},
  abstract = {Topic modeling is nowadays widely used in text archive analytics, to find significant topics in news articles and important aspects of product comments available on the Internet. While statistical approaches, e.g. Latent Dirichlet Allocation (LDA) and its variants, are effective on building topic models on long texts, it remains difficult to identify meaningful topics over short texts, e.g. news titles and social-media messages. With the emergence and prosperity of crowdsourcing platforms, it becomes possible and easier for analytical systems to incorporate human intelligence into text analytics. \  \ Different from traditional active learning techniques, the combination of crowdsourcing and machine learning poses new challenges on the design of simple tasks for non-experts to finish in seconds. In this paper, we design a new topic modeling technique, fully exploiting the basic intuitions of humans on short text reading. By requesting human labors to subjectively measure the similarity between short text pairs, the accuracy of the topic modeling algorithms could be greatly enhanced, regardless of the prior used in the graphical model. We present well-designed short text pair selection strategies for crowdsourcing and provide analysis on the convergence property of the inference algorithm. Empirical studies show that our proposed approaches improve the result topics on English tweets and Chinese microblogs, by requesting only a small number of labels from crowd.},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX


text:
@article{nguyen2020toward,
  title={Toward Scalable Video Analytics Using Compressed-Domain Features at the Edge},
  author={Nguyen, Dien Van and Choi, Jaehyuk},
  journal={Applied Sciences},
  volume={10},
  number={18},
  pages={6391},
  year={2020},
  publisher={Multidisciplinary Digital Publishing Institute}
}
@article{krizhevsky2017imagenet,
  title={Imagenet classification with deep convolutional neural networks},
  author={Krizhevsky, Alex and Sutskever, Ilya and Hinton, Geoffrey E},
  journal={Communications of the ACM},
  volume={60},
  number={6},
  pages={84--90},
  year={2017},
  publisher={AcM New York, NY, USA}
}

@article{canel2019scaling,
  title={Scaling video analytics on constrained edge nodes},
  author={Canel, Christopher and Kim, Thomas and Zhou, Giulio and Li, Conglong and Lim, Hyeontaek and Andersen, David G and Kaminsky, Michael and Dulloor, Subramanya R},
  journal={arXiv preprint arXiv:1905.13536},
  year={2019}
}
@article{kang2017noscope,
  title={Noscope: optimizing neural network queries over video at scale},
  author={Kang, Daniel and Emmons, John and Abuzaid, Firas and Bailis, Peter and Zaharia, Matei},
  journal={arXiv preprint arXiv:1703.02529},
  year={2017}
}
@inproceedings{chen2015glimpse,
  title={Glimpse: Continuous, real-time object recognition on mobile devices},
  author={Chen, Tiffany Yu-Han and Ravindranath, Lenin and Deng, Shuo and Bahl, Paramvir and Balakrishnan, Hari},
  booktitle={Proceedings of the 13th ACM Conference on Embedded Networked Sensor Systems},
  pages={155--168},
  year={2015}
}
@article{canel2019scaling,
  title={Scaling video analytics on constrained edge nodes},
  author={Canel, Christopher and Kim, Thomas and Zhou, Giulio and Li, Conglong and Lim, Hyeontaek and Andersen, David G and Kaminsky, Michael and Dulloor, Subramanya R},
  journal={arXiv preprint arXiv:1905.13536},
  year={2019}
}
@inproceedings{chen2015glimpse,
  title={Glimpse: Continuous, real-time object recognition on mobile devices},
  author={Chen, Tiffany Yu-Han and Ravindranath, Lenin and Deng, Shuo and Bahl, Paramvir and Balakrishnan, Hari},
  booktitle={Proceedings of the 13th ACM Conference on Embedded Networked Sensor Systems},
  pages={155--168},
  year={2015}
}
@inproceedings{hsieh2018focus,
  title={Focus: Querying large video datasets with low latency and low cost},
  author={Hsieh, Kevin and Ananthanarayanan, Ganesh and Bodik, Peter and Venkataraman, Shivaram and Bahl, Paramvir and Philipose, Matthai and Gibbons, Phillip B and Mutlu, Onur},
  booktitle={13th $\{$USENIX$\}$ Symposium on Operating Systems Design and Implementation ($\{$OSDI$\}$ 18)},
  pages={269--286},
  year={2018}
}
@inproceedings{jiang2018chameleon,
  title={Chameleon: scalable adaptation of video analytics},
  author={Jiang, Junchen and Ananthanarayanan, Ganesh and Bodik, Peter and Sen, Siddhartha and Stoica, Ion},
  booktitle={Proceedings of the 2018 Conference of the ACM Special Interest Group on Data Communication},
  pages={253--266},
  year={2018}
}

@inproceedings{cai2015learning,
  title={Learning complexity-aware cascades for deep pedestrian detection},
  author={Cai, Zhaowei and Saberian, Mohammad and Vasconcelos, Nuno},
  booktitle={Proceedings of the IEEE International Conference on Computer Vision},
  pages={3361--3369},
  year={2015}
}
@article{krizhevsky2017imagenet,
  title={Imagenet classification with deep convolutional neural networks},
  author={Krizhevsky, Alex and Sutskever, Ilya and Hinton, Geoffrey E},
  journal={Communications of the ACM},
  volume={60},
  number={6},
  pages={84--90},
  year={2017},
  publisher={ACM New York, NY, USA}
}
@inproceedings{li2015convolutional,
  title={A convolutional neural network cascade for face detection},
  author={Li, Haoxiang and Lin, Zhe and Shen, Xiaohui and Brandt, Jonathan and Hua, Gang},
  booktitle={Proceedings of the IEEE conference on computer vision and pattern recognition},
  pages={5325--5334},
  year={2015}
}

@inproceedings{chen2015glimpse,
  title={Glimpse: Continuous, real-time object recognition on mobile devices},
  author={Chen, Tiffany Yu-Han and Ravindranath, Lenin and Deng, Shuo and Bahl, Paramvir and Balakrishnan, Hari},
  booktitle={Proceedings of the 13th ACM Conference on Embedded Networked Sensor Systems},
  pages={155--168},
  year={2015}
}
@inproceedings{li2020reducto,
  title={Reducto: On-Camera Filtering for Resource-Efficient Real-Time Video Analytics},
  author={Li, Yuanqi and Padmanabhan, Arthi and Zhao, Pengzhan and Wang, Yufei and Xu, Guoqing Harry and Netravali, Ravi},
  booktitle={Proceedings of the Annual conference of the ACM Special Interest Group on Data Communication on the applications, technologies, architectures, and protocols for computer communication},
  pages={359--376},
  year={2020}
}
@article{canel2019scaling,
  title={Scaling video analytics on constrained edge nodes},
  author={Canel, Christopher and Kim, Thomas and Zhou, Giulio and Li, Conglong and Lim, Hyeontaek and Andersen, David G and Kaminsky, Michael and Dulloor, Subramanya R},
  journal={arXiv preprint arXiv:1905.13536},
  year={2019}
}
@incollection{chen2017smart,
  title={Smart city surveillance in fog computing},
  author={Chen, Ning and Chen, Yu and Ye, Xinyue and Ling, Haibin and Song, Sejun and Huang, Chin-Tser},
  booktitle={Advances in Mobile Cloud Computing and Big Data in the 5G Era},
  pages={203--226},
  year={2017},
  publisher={Springer}
}

@article{thanh2019efficient,
  title={Efficient Transcoding and Encryption for Live 360 CCTV System},
  author={Thanh Le, Tuan and Jeong, JongBeom and Ryu, Eun-Seok},
  journal={Applied Sciences},
  volume={9},
  number={4},
  pages={760},
  year={2019},
  publisher={Multidisciplinary Digital Publishing Institute}
}

@article{sullivan2012overview,
  title={Overview of the high efficiency video coding (HEVC) standard},
  author={Sullivan, Gary J and Ohm, Jens-Rainer and Han, Woo-Jin and Wiegand, Thomas},
  journal={IEEE Transactions on circuits and systems for video technology},
  volume={22},
  number={12},
  pages={1649--1668},
  year={2012},
  publisher={IEEE}
}

@article{ohm2012comparison,
  title={Comparison of the coding efficiency of video coding standards—including high efficiency video coding (HEVC)},
  author={Ohm, Jens-Rainer and Sullivan, Gary J and Schwarz, Heiko and Tan, Thiow Keng and Wiegand, Thomas},
  journal={IEEE Transactions on circuits and systems for video technology},
  volume={22},
  number={12},
  pages={1669--1684},
  year={2012},
  publisher={IEEE}
}
@inproceedings{ananthanarayanan2019demo,
  title={Demo: Video Analytics-Killer App for Edge Computing},
  author={Ananthanarayanan, Ganesh and Bahl, Victor and Cox, Landon and Crown, Alex and Nogbahi, Shadi and Shu, Yuanchao},
  booktitle={ACM MobiSys},
  year={2019}
}
@manual{oliverreport,
  author = {Oliver Philippou},
  title = {Video Surveillance Installed Base Report – 2019},
  note   = "\url{https://technology.informa.com/607069/video-surveillance-installed-base-report-2019}",
  year   = "2020 (accessed September 3, 2020)"
}
@inproceedings{stone2019towards,
  title={Towards Scalable Video Analytics at the Edge},
  author={Stone, Theodore and Stone, Nathaniel and Jain, Puneet and Jiang, Yurong and Kim, Kyu-Han and Nelakuditi, Srihari},
  booktitle={2019 16th Annual IEEE International Conference on Sensing, Communication, and Networking (SECON)},
  pages={1--9},
  year={2019},
  organization={IEEE}
}
@inproceedings{lu2014moving,
  title={Moving vehicle detection based on fuzzy background subtraction},
  author={Lu, Xiaofeng and Izumi, Takashi and Takahashi, Tomoaki and Wang, Lei},
  booktitle={2014 IEEE International Conference on Fuzzy Systems (FUZZ-IEEE)},
  pages={529--532},
  year={2014},
  organization={IEEE}
}
@article{kumar2016segmentation,
  title={Segmentation of moving objects using background subtraction method in complex environments},
  author={Kumar, Satrughan and Yadav, J Sen},
  journal={Radioengineering},
  volume={25},
  number={2},
  pages={399--408},
  year={2016}
}
@inproceedings{gujrathi2014detecting,
  title={Detecting moving object using background subtraction algorithm in FPGA},
  author={Gujrathi, Poonam and Priya, R Arokia and Malathi, P},
  booktitle={2014 Fourth International Conference on Advances in Computing and Communications},
  pages={117--120},
  year={2014},
  organization={IEEE}
}
@article{wang2019ground,
  title={Ground moving target indication based on optical flow in single-channel SAR},
  author={Wang, Zhirui and Sun, Xian and Diao, Wenhui and Zhang, Yue and Yan, Menglong and Lan, Lan},
  journal={IEEE Geoscience and Remote Sensing Letters},
  volume={16},
  number={7},
  pages={1051--1055},
  year={2019},
  publisher={IEEE}
}

@article{favalli2000object,
  title={Object tracking for retrieval applications in MPEG-2},
  author={Favalli, Lorenzo and Mecocci, Alessandro and Moschetti, Fulvio},
  journal={IEEE Transactions on Circuits and Systems for Video Technology},
  volume={10},
  number={3},
  pages={427--432},
  year={2000},
  publisher={IEEE}
}
@inproceedings{yoneyama1999moving,
  title={Moving object detection and identification from MPEG coded data},
  author={Yoneyama, Akio and Nakajima, Yasuyuki and Yanagihara, Hiromasa and Sugano, Masaru},
  booktitle={Proceedings 1999 International Conference on Image Processing (Cat. 99CH36348)},
  volume={2},
  pages={934--938},
  year={1999},
  organization={IEEE}
}
@inproceedings{dong2006object,
  title={Object tracking in compressed video with confidence measures},
  author={Dong, Lan and Zoghlami, Imad and Schwartz, Stuart C},
  booktitle={2006 IEEE International Conference on Multimedia and Expo},
  pages={753--756},
  year={2006},
  organization={IEEE}
}
@inproceedings{achanta2002compressed,
  title={Compressed domain object tracking for automatic indexing of objects in MPEG home video},
  author={Achanta, Radhakrishna and Kankanhalli, Mohan and Mulhem, Philippe},
  booktitle={Proceedings. IEEE International Conference on Multimedia and Expo},
  volume={2},
  pages={61--64},
  year={2002},
  organization={IEEE}
}

@article{laroche2008rd,
  title={RD optimized coding for motion vector predictor selection},
  author={Laroche, Guillaume and Jung, Joel and Pesquet-Popescu, Beatrice},
  journal={IEEE Transactions on Circuits and Systems for Video Technology},
  volume={18},
  number={9},
  pages={1247--1257},
  year={2008},
  publisher={IEEE}
}
@article{jiang2019spatial,
  title={Spatial Correlation-Based Motion-Vector Prediction for Video-Coding Efficiency Improvement},
  author={Jiang, Xiantao and Song, Tian and Katayama, Takafumi and Leu, Jenq-Shiou},
  journal={Symmetry},
  volume={11},
  number={2},
  pages={129},
  year={2019},
  publisher={Multidisciplinary Digital Publishing Institute}
}
@incollection{bross2014inter,
  title={Inter-picture prediction in HEVC},
  author={Bross, Benjamin and Helle, Philipp and Lakshman, Haricharan and Ugur, Kemal},
  booktitle={High Efficiency Video Coding (HEVC)},
  pages={113--140},
  year={2014},
  publisher={Springer}
}
@inproceedings{bombardelli2018efficient,
  title={Efficient Object Tracking in Compressed Video Streams with Graph Cuts},
  author={Bombardelli, Fernando and G{\"u}l, Serhan and Becker, Daniel and Schmidt, Matthias and Hellge, Cornelius},
  booktitle={2018 IEEE 20th International Workshop on Multimedia Signal Processing (MMSP)},
  pages={1--6},
  year={2018},
  organization={IEEE}
}
@article{khatoonabadi2012video,
  title={Video object tracking in the compressed domain using spatio-temporal Markov random fields},
  author={Khatoonabadi, Sayed Hossein and Bajic, Ivan V},
  journal={IEEE transactions on image processing},
  volume={22},
  number={1},
  pages={300--313},
  year={2012},
  publisher={IEEE}
}

@article{boykov2001fast,
  title={Fast approximate energy minimization via graph cuts},
  author={Boykov, Yuri and Veksler, Olga and Zabih, Ramin},
  journal={IEEE Transactions on pattern analysis and machine intelligence},
  volume={23},
  number={11},
  pages={1222--1239},
  year={2001},
  publisher={IEEE}
}
@article{zeng2018background,
  title={Background subtraction using multiscale fully convolutional network},
  author={Zeng, Dongdong and Zhu, Ming},
  journal={IEEE Access},
  volume={6},
  pages={16010--16021},
  year={2018},
  publisher={IEEE}
}

@article{chen2017pixel,
  title={Pixel-wise deep sequence learning for moving object detection},
  author={Chen, Yingying and Wang, Jinqiao and Zhu, Bingke and Tang, Ming and Lu, Hanqing},
  journal={IEEE Transactions on Circuits and Systems for Video Technology},
  year={2017},
  publisher={IEEE}
}

@article{babaee2018deep,
  title={A deep convolutional neural network for video sequence background subtraction},
  author={Babaee, Mohammadreza and Dinh, Duc Tung and Rigoll, Gerhard},
  journal={Pattern Recognition},
  volume={76},
  pages={635--649},
  year={2018},
  publisher={Elsevier}
}

@article{wang2017interactive,
  title={Interactive deep learning method for segmenting moving objects},
  author={Wang, Yi and Luo, Zhiming and Jodoin, Pierre-Marc},
  journal={Pattern Recognition Letters},
  volume={96},
  pages={66--75},
  year={2017},
  publisher={Elsevier}
}

@article{patil2018msfgnet,
  title={Msfgnet: A novel compact end-to-end deep network for moving object detection},
  author={Patil, Prashant W and Murala, Subrahmanyam},
  journal={IEEE Transactions on Intelligent Transportation Systems},
  volume={20},
  number={11},
  pages={4066--4077},
  year={2018},
  publisher={IEEE}
}

@article{ou2019moving,
  title={Moving object detection method via ResNet-18 with encoder--decoder structure in complex scenes},
  author={Ou, Xianfeng and Yan, Pengcheng and Zhang, Yiming and Tu, Bing and Zhang, Guoyun and Wu, Jianhui and Li, Wujing},
  journal={IEEE Access},
  volume={7},
  pages={108152--108160},
  year={2019},
  publisher={IEEE}
}
@article{acevedo2016linked,
  title={A linked list-based algorithm for blob detection on embedded vision-based sensors},
  author={Acevedo-Avila, Ricardo and Gonzalez-Mendoza, Miguel and Garcia-Garcia, Andres},
  journal={Sensors},
  volume={16},
  number={6},
  pages={782},
  year={2016},
  publisher={Multidisciplinary Digital Publishing Institute}
}

@article{lee2012adaptive,
  title={An adaptive background subtraction method based on kernel density estimation},
  author={Lee, Jeisung and Park, Mignon},
  journal={Sensors},
  volume={12},
  number={9},
  pages={12279--12300},
  year={2012},
  publisher={Molecular Diversity Preservation International}
}
@inproceedings{stauffer1999adaptive,
  title={Adaptive background mixture models for real-time tracking},
  author={Stauffer, Chris and Grimson, W Eric L},
  booktitle={Proceedings. 1999 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (Cat. No PR00149)},
  volume={2},
  pages={246--252},
  year={1999},
  organization={IEEE}
}
@article{lu2008improved,
  title={An Improved Motion Detection Method for Real-Time Surveillance.},
  author={Lu, Nan and Wang, Jihong and Wu, QH and Yang, Li},
  journal={IAENG International Journal of Computer Science},
  volume={35},
  number={1},
  year={2008},
  publisher={Citeseer}
}

@inproceedings{lecun2010convolutional,
  title={Convolutional networks and applications in vision},
  author={LeCun, Yann and Kavukcuoglu, Koray and Farabet, Cl{\'e}ment},
  booktitle={Proceedings of 2010 IEEE International Symposium on Circuits and Systems},
  pages={253--256},
  year={2010},
  organization={IEEE}
}

@inproceedings{jarrett2009best,
  title={What is the best multi-stage architecture for object recognition?},
  author={Jarrett, Kevin and Kavukcuoglu, Koray and LeCun, Yann and others},
  booktitle={2009 IEEE 12th International Conference on Computer Vision (ICCV)},
  pages={2146--2153},
  year={2009},
  organization={IEEE}
}

@inproceedings{lee2009convolutional,
  title={Convolutional deep belief networks for scalable unsupervised learning of hierarchical representations},
  author={Lee, Honglak and Grosse, Roger and Ranganath, Rajesh and Ng, Andrew Y},
  booktitle={Proceedings of the 26th annual international conference on machine learning},
  pages={609--616},
  year={2009},
  organization={ACM}
}

@inproceedings{hussain2018study,
  title={A Study on CNN Transfer Learning for Image Classification},
  author={Hussain, Mahbub and Bird, Jordan J and Faria, Diego R},
  booktitle={UK Workshop on Computational Intelligence},
  pages={191--202},
  year={2018},
  organization={Springer}
}

@techreport{krizhevsky2009learning,
  title={Learning multiple layers of features from tiny images},
  author={Krizhevsky, Alex and Hinton, Geoffrey},
  year={2009},
  institution={Citeseer}
}

@inproceedings{girshick2014rich,
  title={Rich feature hierarchies for accurate object detection and semantic segmentation},
  author={Girshick, Ross and Donahue, Jeff and Darrell, Trevor and Malik, Jitendra},
  booktitle={Proceedings of the IEEE conference on computer vision and pattern recognition},
  pages={580--587},
  year={2014}
}

@article{uijlings2013selective,
  title={Selective search for object recognition},
  author={Uijlings, Jasper RR and Van De Sande, Koen EA and Gevers, Theo and Smeulders, Arnold WM},
  journal={International journal of computer vision},
  volume={104},
  number={2},
  pages={154--171},
  year={2013},
  publisher={Springer}
}

@inproceedings{girshick2015fast,
  title={Fast r-cnn},
  author={Girshick, Ross},
  booktitle={Proceedings of the IEEE international conference on computer vision},
  pages={1440--1448},
  year={2015}
}

@inproceedings{ren2015faster,
  title={Faster r-cnn: Towards real-time object detection with region proposal networks},
  author={Ren, Shaoqing and He, Kaiming and Girshick, Ross and Sun, Jian},
  booktitle={Advances in neural information processing systems},
  pages={91--99},
  year={2015}
}

@inproceedings{redmon2016you,
  title={You only look once: Unified, real-time object detection},
  author={Redmon, Joseph and Divvala, Santosh and Girshick, Ross and Farhadi, Ali},
  booktitle={Proceedings of the IEEE conference on computer vision and pattern recognition},
  pages={779--788},
  year={2016}
}

@inproceedings{liu2016ssd,
  title={Ssd: Single shot multibox detector},
  author={Liu, Wei and Anguelov, Dragomir and Erhan, Dumitru and Szegedy, Christian and Reed, Scott and Fu, Cheng-Yang and Berg, Alexander C},
  booktitle={European conference on computer vision},
  pages={21--37},
  year={2016},
  organization={Springer}
}

@article{redmon2018yolov3,
  title={Yolov3: An incremental improvement},
  author={Redmon, Joseph and Farhadi, Ali},
  journal={arXiv preprint arXiv:1804.02767},
  year={2018}
}

@inproceedings{ester1996density,
  title={A density-based algorithm for discovering clusters in large spatial databases with noise.},
  author={Ester, Martin and Kriegel, Hans-Peter and Sander, J{\"o}rg and Xu, Xiaowei and others},
  booktitle={Kdd},
  volume={96},
  number={34},
  pages={226--231},
  year={1996}
}

@article{sheu2019stam,
  title={STAM-CCF: Suspicious Tracking Across Multiple Camera Based on Correlation Filters},
  author={Sheu, Ruey-Kai and Pardeshi, Mayuresh and Chen, Lun-Chi and Yuan, Shyan-Ming},
  journal={Sensors},
  volume={19},
  number={13},
  pages={3016},
  year={2019},
  publisher={Multidisciplinary Digital Publishing Institute}
}

@article{li2020hksiamfc,
  title={HKSiamFC: Visual-Tracking Framework Using Prior Information Provided by Staple and Kalman Filter},
  author={Li, Chenpu and Xing, Qianjian and Ma, Zhenguo},
  journal={Sensors},
  volume={20},
  number={7},
  pages={2137},
  year={2020},
  publisher={Multidisciplinary Digital Publishing Institute}
}

@manual{VIRAT,
  title = {Available Online},
  note   = "\url{https://viratdata.org}",
  year   = "2020 (accessed September 3, 2020)"
}
@manual{testvideo,
  title = {Available Online},
  note   = "\url{https://youtu.be/v24ldT1AGRw}",
  year   = "2020 (accessed September 3, 2020)"
}

@manual{source,
  title = {Available Online},
  note   = "\url{https://github.com/diennv/MotionVectorAnalysis}",
  year   = "2020 (accessed September 3, 2020)"
}
@manual{convential,
  title = {Available Online},
  note   = "\url{https://www.youtube.com/watch?v=Cz_zxr_ElTU}",
  year   = "2020 (accessed September 3, 2020)"
}
@manual{proposed,
  title = {Available Online},
  note   = "\url{https://www.youtube.com/watch?v=-fRc36HAduI&feature=youtu.b}",
  year   = "2020 (accessed September 3, 2020)"
}

@manual{ref0,
  title = {Available Online},
  note   = "\url{https://www.nytimes.com/2018/05/26/us/chicago-police-surveillance.html}",
  year   = "2020 (accessed September 3, 2020)"
}
@manual{ref1,
  title = {Available Online},
  note   = "\url{https://www.telegraph.co.uk/technology/10172298/One-surveillance-camera-for-every-11-people-in-Britain-says-CCTV-survey.html}",
  year   = "2020 (accessed September 3, 2020)"
}
@manual{ref2,
  title = {Available Online},
  note   = "\url{https://www.wsj.com/articles/BL-CJB-22562}",
  year   = "2020 (accessed September 3, 2020)"
}

repository: diennv/phd-thesis

repo_name: diennv/phd-thesis


text:
package callertest

import (
	"runtime"
)

func Call() string {
	_, file, _, _ := runtime.Caller(1)
	return file
}

func IndirectCall() string {
	return Call()
}

repository: sbuss/callertest

repo_name: sbuss/callertest


text:
# Copyright (C) 2015 GENIVI Alliance
# Released under the MIT license (see COPYING.MIT for the terms)

include genivi-demo-platform-hmi.inc

SUMMARY = "GENIVI Demo Platform HMI - Panel"
DEPENDS = "qtbase qtdeclarative"

SRC_URI_append ="\
    file://gdp-hmi-panel.service \
    "

SRC_URI_append_qemux86-64 ="\
    file://0003-panel-Make-Graphic-working-on-Qemu-machine.patch \
    "

S = "${WORKDIR}/git/app/gdp-hmi-panel"

inherit qmake5

FILES_${PN} += "\
    ${datadir}/gdp/* \
    ${libdir}/systemd/user/* \
    "

do_install_append() {
	install -d ${D}${libdir}/systemd/user
	install -m 0444 ${WORKDIR}/gdp-hmi-panel.service \
	                ${D}${libdir}/systemd/user
	install -d ${D}${datadir}/gdp
	install -m 0444 ${S}/assets/GDP_Quadrat.png \
					${D}${datadir}/gdp/GDP_Quadrat.png
	install -m 0444 ${S}/assets/GDP_Panel.png ${D}${datadir}/gdp/GDP_Panel.png
}

repository: TizenTeam/meta-genivi-demo

repo_name: TizenTeam/meta-genivi-demo

branch_name: refs/heads/GENIVI-AMM-handson


text:
package commands

import (
	"fmt"
	"github.com/linuzilla/go-cmdline"
	"github.com/linuzilla/google-license-manager/services/license_manager"
)

type AddUserCommand struct {
	LicenseManager license_manager.LicenseManager `inject:"*"`
}

var _ cmdline_service.CommandInterface = (*AddUserCommand)(nil)

func (AddUserCommand) PostSummerConstruct() {
}

func (AddUserCommand) ImplementCommandInterface() {
}

func (AddUserCommand) Command() string {
	return `add-user`
}

func (cmd *AddUserCommand) Execute(args ...string) int {
	if len(args) == 0 {
		fmt.Println("usage: add-user user ...")
	} else {
		for _, user := range args {
			cmd.LicenseManager.AddLicenseToUser(user)
		}
	}
	return 0
}

repository: linuzilla/google-license-manager

repo_name: linuzilla/google-license-manager


text:
package main

import (
	"fmt"

	"github.com/tzdybal/go-disk-usage/du"
)

// KiB is a number of bytes in Kibibyte
const KiB = uint64(1024)

func main() {
	usage := du.NewDiskUsage("/")
	fmt.Println("Free:", usage.Free()/(KiB*KiB))
	fmt.Println("Available:", usage.Available()/(KiB*KiB))
	fmt.Println("Size:", usage.Size()/(KiB*KiB))
	fmt.Println("Used:", usage.Used()/(KiB*KiB))
	fmt.Println("Usage:", usage.Usage()*100, "%")
}

license: Unlicense

repository: tzdybal/go-disk-usage

repo_name: tzdybal/go-disk-usage


text:
// (C) Copyright IBM Corp. 2018. All Rights Reserved.
//
// 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 agent

import ()

const (
	// ConnectionModeKey is the labels key within the RemoteServiceBinding that
	// holds the mode for handling the Istio configs (from below modes)
	ConnectionModeKey = "connection"

	// ConnectionModeLive will imply that the reconciler will be called
	// automatically whenever a change in an RemoteServiceBinding has been
	// determined
	ConnectionModeLive = "live"

	// ConnectionModePotential will imply that the reconciler will NOT be
	// called whenever a change in an RemoteServiceBinding has been determined.
	// Istio configs will be generated once the mode is switched to 'live'.
	ConnectionModePotential = "potential"
)

// ExposedServices is a struct that holds list of entries each holding the
// information about an exposed service. JSON format of this struct is being
// sent back from a remote cluster's agent in response to an exposition request.
type ExposedServices struct {
	Services []*ExposedService
}

// ExposedService holds description of an exposed service that is visible to
// remote clusters.
type ExposedService struct {
	Name      string
	Namespace string
	Port      uint32
}

// ClusterConfig holds all the configuration information about the local
// cluster as well as the peered remote clusters.
type ClusterConfig struct {
	ID string `yaml:"ID"`

	GatewayIP   string `yaml:"GatewayIP"`
	GatewayPort uint16 `yaml:"GatewayPort"`

	AgentIP   string `yaml:"AgentIP"`
	AgentPort uint16 `yaml:"AgentPort"`

	ConnectionMode string `yaml:"ConnectionMode"`

	WatchedPeers []ClusterConfig `yaml:"WatchedPeers,omitempty"`
	TrustedPeers []string        `yaml:"TrustedPeers,omitempty"`
}

// Gateway is implementing the model.ClusterInfo interface
func (cc ClusterConfig) Gateway() (string, uint32) {
	return cc.GatewayIP, uint32(cc.GatewayPort)
}

// IP is implementing the model.ClusterInfo interface
func (cc ClusterConfig) IP(name string) string {
	if name == cc.ID {
		return cc.GatewayIP
	}
	for _, peer := range cc.WatchedPeers {
		if name == peer.ID {
			return peer.GatewayIP
		}
	}
	return "255.255.255.255" // dummy value for unknown clusters
}

// Port is implementing the model.ClusterInfo interface
func (cc ClusterConfig) Port(name string) uint32 {
	if name == cc.ID {
		return uint32(cc.GatewayPort)
	}
	for _, peer := range cc.WatchedPeers {
		if name == peer.ID {
			return uint32(peer.GatewayPort)
		}
	}
	return 8080 // dummy value for unknown clusters
}

repository: istio-ecosystem/wharf-multicluster-sync

repo_name: istio-ecosystem/wharf-multicluster-sync


text:
@article{Beven-2019-Developing,
    title = "Developing observational methods to drive future hydrological science: Can we make a start as a community?",
    author = "Beven, Keith  and
      Asadullah, Anita  and
      Bates, Paul  and
      Blyth, Eleanor  and
      Chappell, Nick  and
      Child, Stewart  and
      Cloke, Hannah  and
      Dadson, Simon  and
      Everard, Nick  and
      Fowler, Hayley J.  and
      Freer, Jim  and
      Hannah, David M.  and
      Heppell, Kate  and
      Holden, Joseph  and
      Lamb, Rob  and
      Lewis, Huw  and
      Morgan, Gerald  and
      Parry, Louise  and
      Wagener, Thorsten",
    journal = "Hydrological Processes, Volume 34, Issue 3",
    volume = "34",
    number = "3",
    year = "2019",
    publisher = "Wiley",
    url = "https://aclanthology.org/G19-3001",
    doi = "10.1002/hyp.13622",
    pages = "868--873",
    abstract = "Hydrology is still, and for good reasons, an inexact science, even if evolving hydrological understanding has provided a basis for improved water management for at least the last three millennia. The limitations of that understanding have, however, become much more apparent and important in the last century as the pressures of increasing populations, and the anthropogenic impacts on catchment forcing and responses, have intensified. At the same time, the sophistication of hydrological analyses and models has been developing rapidly, often driven more by the availability of computational power and geographical data sets than any real increases in understanding of hydrological processes. This sophistication has created an illusion of real progress but a case can be made that we are still rather muddling along, limited by the significant uncertainties in hydrological observations, knowledge of catchment characteristics and related gaps in conceptual understanding, particularly of the sub-surface. These knowledge gaps are illustrated by the fact that for many catchments we cannot close the water balance without significant uncertainty, uncertainty that is often neglected in evaluating models for practical applications.",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications

gha_language: Python