text:
package advisory_test

import (
	"context"
	"io"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/dgraph-io/travel/internal/feeds/advisory"
	"github.com/dgraph-io/travel/internal/platform/tests"
	"github.com/google/go-cmp/cmp"
)

// Success and failure markers.
const (
	success = "\u2713"
	failed  = "\u2717"
)

// TestAdvisory validates searches can be conducted against www.travel-advisory.info.
func TestAdvisory(t *testing.T) {
	t.Log("Given the need to retreve an advisory.")
	{
		testID := 0
		t.Logf("\tTest %d:\tWhen handling a single city.", testID)
		{
			server := mockServer()
			t.Cleanup(server.Close)

			countryCode := "AU"
			ctx := context.Background()

			found, err := advisory.Search(ctx, server.URL, countryCode)
			if err != nil {
				t.Fatalf("\t%s\tTest %d:\tShould be able to search for an advisory : %v", failed, testID, err)
			}
			t.Logf("\t%s\tTest %d:\tShould be able to search for an advisory.", success, testID)

			advisory := advisory.Advisory{
				Country:     "Australia",
				CountryCode: "AU",
				Continent:   "OC",
				Score:       2.8,
				LastUpdated: "2020-05-03 07:22:19",
				Message:     "none at this time",
				Source:      "https://www.travel-advisory.info/australia",
			}

			if diff := cmp.Diff(found, advisory); diff != "" {
				t.Fatalf("\t%s\tTest %d:\tShould get back the expected advisory. Diff:\n%s", tests.Failed, testID, diff)
			}
			t.Logf("\t%s\tTest %d:\tShould get back the expected advisory.", tests.Success, testID)
		}
	}
}

func mockServer() *httptest.Server {
	f := func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(200)
		io.WriteString(w, result)
	}

	return httptest.NewServer(http.HandlerFunc(f))
}

var result = `
{
	"api_status":{
	   "request":{
		  "item":"au"
	   },
	   "reply":{
		  "cache":"cached",
		  "code":200,
		  "status":"ok",
		  "note":"The api works, we could match requested country code.",
		  "count":1
	   }
	},
	"data":{
	   "AU":{
		  "iso_alpha2":"AU",
		  "name":"Australia",
		  "continent":"OC",
		  "advisory":{
			 "score":2.79999999999999982236431605997495353221893310546875,
			 "sources_active":6,
			 "message":"none at this time",
			 "updated":"2020-05-03 07:22:19",
			 "source":"https:\/\/www.travel-advisory.info\/australia"
		  }
	   }
	}
 }`

repository: praneelrathore/travel

repo_name: praneelrathore/travel


text:
@InProceedings{li11b,
  title = {Confidence Weighted Mean Reversion Strategy for On-Line Portfolio Selection},
  author = {Bin Li and Steven C.H. Hoi and Peilin Zhao and Vivekanand Gopalkrishnan},
  pages = {434--442},
  abstract = {This paper proposes a novel on-line portfolio selection strategy named ``Confidence Weighted Mean Reversion'' (CWMR). Inspired by the mean reversion principle and the confidence weighted online learning technique, CWMR models a portfolio vector as Gaussian distribution, and sequentially updates the distribution by following the mean reversion trading principle. The CWMR strategy is able to effectively exploit the power of mean reversion for on-line portfolio selection. Extensive experiments on various real markets demonstrate the effectiveness of our strategy in comparison to the state of the art.

[pdf]},
  pdf = {http://jmlr.org/proceedings/papers/v15/li11b/li11b.pdf},
}

license: MIT

repository: mreid/papersite

license_type: permissive

repo_name: mreid/papersite

branch_name: refs/heads/master

gha_license_id: MIT

gha_language: TeX

extension: bib


text:
SUMMARY = "Python Build Reasonableness"
DESCRIPTION = "PBR is a library that injects some useful and sensible default behaviors into your setuptools run"
HOMEPAGE = "https://pypi.python.org/pypi/pbr"
SECTION = "devel/python"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=1dece7821bf3fd70fe1309eaa37d52a2"

SRC_URI[md5sum] = "65cdc32e1a1ff56d481fc15aa8caf988"
SRC_URI[sha256sum] = "139d2625547dbfa5fb0b81daebb39601c478c21956dc57e2e07b74450a8c506b"

inherit pypi setuptools

RDEPENDS:${PN} += "${PYTHON_PN}-pip"

do_install:append() {
        if [ -f ${D}${bindir}/pbr ]; then
                mv ${D}${bindir}/pbr ${D}${bindir}/pbr-2
        fi
}

BBCLASSEXTEND = "native nativesdk"

SKIP_RECIPE[python-pbr] ?= "${@bb.utils.contains('I_SWEAR_TO_MIGRATE_TO_PYTHON3', 'yes', '', 'python2 is out of support for long time, read https://www.python.org/doc/sunset-python-2/ https://python3statement.org/ and if you really have to temporarily use this, then set I_SWEAR_TO_MIGRATE_TO_PYTHON3 to "yes"', d)}"

branch_name: refs/heads/jansa/master

gha_language: BitBake

extension: bb


text:
// Package dummy an E2E tester
//
// By taka@cmwang.net
//
package dummy

import route "github.com/taka-wang/mb-web/route"

func main() {
	route.Start()
}

repository: taka-wang/mb-web

repo_name: taka-wang/mb-web

extension: go


text:
# Copyright (c) 2019 Christophe Chapuis <chris.chapuis@gmail.com>

DESCRIPTION = "Library of glib utilities."
LICENSE = "BSD-3-Clause"
SECTION = "webos/support"
LIC_FILES_CHKSUM = "file://src/gutil_log.c;beginline=1;endline=31;md5=40385e1b2a8460ac86b9d4b2893c5c3f"

DEPENDS = "glib-2.0"

inherit pkgconfig

SRC_URI = "git://github.com/sailfishos/libglibutil.git;protocol=https;branch=master"
S = "${WORKDIR}/git"

PV = "1.0.61-1+git${SRCPV}"
SRCREV = "508e1255782e59725c25068874337e6309da04b2"

EXTRA_OEMAKE = "KEEP_SYMBOLS=1"
PARALLEL_MAKE = ""

do_install() {
    make install DESTDIR=${D}
    make install-dev DESTDIR=${D}
}

repository: webOS-ports/meta-webos-ports

repo_name: webOS-ports/meta-webos-ports

branch_name: refs/heads/kirkstone


text:
require recipes-security/optee/optee-client.inc

SRCREV = "dd2d39b49975d2ada7870fe2b7f5a84d0d3860dc"

inherit pkgconfig
DEPENDS += "util-linux"
EXTRA_OEMAKE += "PKG_CONFIG=pkg-config"

repository: openbmc/openbmc

repo_name: openbmc/openbmc

gha_license_id: NOASSERTION

gha_language: Python


text:
// Code generated by go-swagger; DO NOT EDIT.

package wifi_gateways

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"fmt"
	"io"

	"github.com/go-openapi/runtime"

	strfmt "github.com/go-openapi/strfmt"

	models "magma/orc8r/cloud/api/v1/go/models"
)

// GetWifiNetworkIDGatewaysReader is a Reader for the GetWifiNetworkIDGateways structure.
type GetWifiNetworkIDGatewaysReader struct {
	formats strfmt.Registry
}

// ReadResponse reads a server response into the received o.
func (o *GetWifiNetworkIDGatewaysReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
	switch response.Code() {
	case 200:
		result := NewGetWifiNetworkIDGatewaysOK()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return result, nil
	default:
		result := NewGetWifiNetworkIDGatewaysDefault(response.Code())
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		if response.Code()/100 == 2 {
			return result, nil
		}
		return nil, result
	}
}

// NewGetWifiNetworkIDGatewaysOK creates a GetWifiNetworkIDGatewaysOK with default headers values
func NewGetWifiNetworkIDGatewaysOK() *GetWifiNetworkIDGatewaysOK {
	return &GetWifiNetworkIDGatewaysOK{}
}

/*GetWifiNetworkIDGatewaysOK handles this case with default header values.

Map of all Wifi gateways inside the network by gatewayID
*/
type GetWifiNetworkIDGatewaysOK struct {
	Payload map[string]models.WifiGateway
}

func (o *GetWifiNetworkIDGatewaysOK) Error() string {
	return fmt.Sprintf("[GET /wifi/{network_id}/gateways][%d] getWifiNetworkIdGatewaysOK  %+v", 200, o.Payload)
}

func (o *GetWifiNetworkIDGatewaysOK) GetPayload() map[string]models.WifiGateway {
	return o.Payload
}

func (o *GetWifiNetworkIDGatewaysOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	// response payload
	if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

// NewGetWifiNetworkIDGatewaysDefault creates a GetWifiNetworkIDGatewaysDefault with default headers values
func NewGetWifiNetworkIDGatewaysDefault(code int) *GetWifiNetworkIDGatewaysDefault {
	return &GetWifiNetworkIDGatewaysDefault{
		_statusCode: code,
	}
}

/*GetWifiNetworkIDGatewaysDefault handles this case with default header values.

Unexpected Error
*/
type GetWifiNetworkIDGatewaysDefault struct {
	_statusCode int

	Payload *models.Error
}

// Code gets the status code for the get wifi network ID gateways default response
func (o *GetWifiNetworkIDGatewaysDefault) Code() int {
	return o._statusCode
}

func (o *GetWifiNetworkIDGatewaysDefault) Error() string {
	return fmt.Sprintf("[GET /wifi/{network_id}/gateways][%d] GetWifiNetworkIDGateways default  %+v", o._statusCode, o.Payload)
}

func (o *GetWifiNetworkIDGatewaysDefault) GetPayload() *models.Error {
	return o.Payload
}

func (o *GetWifiNetworkIDGatewaysDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	o.Payload = new(models.Error)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

repository: Mirantis/magma

repo_name: Mirantis/magma

gha_language: Go


text:
DESCRIPTION = "A tool to apply the data-recovery capability concepts of RAID-like systems \
to the posting & recovery of multi-part archives on Usenet."
SECTION = "libs"
LICENSE = "GPL"
HOMEPAGE = "http://parchive.sourceforge.net/"
DEPENDS = "libsigc++-2.0"

SRC_URI = "${SOURCEFORGE_MIRROR}/parchive/libpar2/libpar2-${PV}.tar.gz"

inherit autotools pkgconfig

SRC_URI[md5sum] = "94c6df4e38efe08056ecde2a04e0be91"
SRC_URI[sha256sum] = "074fbf840f73b1e13e0405fce261078c81c8c0a4859e30a7bba10510f9199908"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
package server

import (
	"embed"
	"fmt"
	"log"
	"net/http"
	"net/url"
	"os"
	"strconv"

	"github.com/gorilla/mux"
)

//go:embed static
var staticFS embed.FS
var router *mux.Router
var isLocalEnvironment bool

// Listen ...
func Listen(port int, isLocal bool) {
	isLocalEnvironment = isLocal

	router = mux.NewRouter().
		Schemes("http", "https").
		Host(getHost(isLocal, port)).
		Subrouter()

	registerRoutes(router, port)
}

func getHost(isLocal bool, port int) string {
	host, ok := os.LookupEnv("PLANETOCD_HOST")
	if ok {
		return host
	}

	if isLocal {
		return fmt.Sprintf("localhost:%v", port)
	}
	return Host
}

func registerRoutes(router *mux.Router, port int) {
	router.Path("/").HandlerFunc(handleEnglishIndex).Name("index_en")
	router.Path("/robots.txt").HandlerFunc(handleRobots)
	router.Path("/sitemap.xml").HandlerFunc(handleSitemap).Name("sitemap")
	router.PathPrefix("/static/").Handler(http.FileServer(http.FS(staticFS))).Name("static")

	s := router.PathPrefix("/{language}").Subrouter()
	s.HandleFunc("/about", handleAbout).Name("about")
	s.HandleFunc("/tag/{tag:[a-z-]+}", handleTag)
	s.HandleFunc("/tag/{tag:[a-z-]+}/", handleTag).Name("tag")
	s.HandleFunc("", handleArticles)
	s.HandleFunc("/", handleArticles).Name("articles")
	s.HandleFunc("/articles/{id:[0-9]+}/{slug}", handleArticle).Name("article")

	// Load articles
	ensureLoaded()

	// http.Error(w, "An internal error occurred", http.StatusInternalServerError)
	log.Println("Starting server")
	log.Fatal(http.ListenAndServe(fmt.Sprint(":", port), router))
	log.Println("Server started")
}

func getArticlesCanonicalURL(baseURL *url.URL, pageNumber int) *url.URL {
	res := *baseURL
	if pageNumber != 1 {
		res.RawQuery = fmt.Sprintf("page=%v", pageNumber)
	}
	return &res
}

func getPageNumber(query url.Values, maxPageNumber int) (int, bool) {
	pageNumberStr := query.Get("page")
	if pageNumberStr != "" {
		tmp, err := strconv.Atoi(pageNumberStr)
		if err == nil && tmp >= 1 && tmp <= maxPageNumber {
			return tmp, true
		} else {
			return 0, false
		}
	}
	return 1, true
}

func getViewModel(tmpl string, r *http.Request, canonicalURL *url.URL, title string, description string, socialImageURL *url.URL) *ViewModel {
	if socialImageURL == nil {
		var err error
		socialImageURL, err = router.Get("static").URL()
		if err != nil {
			panic(err)
		}
		socialImageURL.Path += "images/logo_social.webp"
	}
	lang := getLang(r)

	socialURL := *canonicalURL
	if socialURL.Host[:9] == "localhost" {
		socialURL.Host = "planetocd.org"
	}

	// _, err := r.Cookie(DismissBannerCookieName)
	// hasDismissBannerCookie := err == nil
	meta := &ViewModelMeta{
		TemplateName:          tmpl,
		Lang:                  lang,
		Title:                 title,
		Description:           description,
		CanonicalURL:          canonicalURL.String(),
		SocialURL:             socialURL.String(),
		RootURL:               getRootURL(lang).String(),
		SocialImageURL:        socialImageURL.String(),
		EnableGoogleAnalytics: !isLocalEnvironment,
		EnablePetitionBanner:  false,
	}

	return NewEmptyViewModel(Constants, meta)
}

func getLang(r *http.Request) string {
	vars := mux.Vars(r)
	return vars["language"]
}

repository: AurelienGasser/planetocd

repo_name: AurelienGasser/planetocd

branch_name: refs/heads/main

gha_language: HTML


text:
SUMMARY = "Checksec tool"
DESCRIPTION = "The checksec.sh script is designed to test what standard Linux OS and PaX security features are being used."
SECTION = "security"
LICENSE = "BSD-3-Clause"
HOMEPAGE="http://www.trapkit.de/tools/checksec.html"

LIC_FILES_CHKSUM = "file://checksec-${PV}.sh;beginline=3;endline=34;md5=6dab14470bfdf12634b866dbdd7a04b0"

SRC_URI = "http://www.trapkit.de/tools/checksec.sh;downloadfilename=checksec-${PV}.sh"

SRC_URI[md5sum] = "57cc3fbbbe48e8ebd4672c569954374d"
SRC_URI[sha256sum] = "05822cd8668589038d20650faa0e56f740911d8ad06f7005b3d12a5c76591b90"

S = "${WORKDIR}"

do_install() {
    install -d ${D}${bindir}
    install -m 0755 ${WORKDIR}/checksec-${PV}.sh    ${D}${bindir}/checksec.sh
    sed -i 's/\r//' ${D}${bindir}/checksec.sh
}

RDEPENDS_${PN} = "bash binutils"

BBCLASSEXTEND = "native"

repository: JonothanKane/meta-security-isafw

repo_name: JonothanKane/meta-security-isafw


text:
@article{zhou2015probing,
 abstract = {Exchange coupled CoFe/BiFeO3 thin-film heterostructures show great promise for power-efficient electric field-induced 180° magnetization switching. However, the coupling mechanism and precise qualification of the exchange coupling in CoFe/BiFeO3 heterostructures have been elusive. Here we show direct evidence for electric field control of the magnetic state in exchange coupled CoFe/BiFeO3 through electric field-dependent ferromagnetic resonance spectroscopy and nanoscale spatially resolved magnetic imaging. Scanning electron microscopy with polarization analysis images reveal the coupling of the magnetization in the CoFe layer to the canted moment in the BiFeO3 layer. Electric field-dependent ferromagnetic resonance measurements quantify the exchange coupling strength and reveal that the CoFe magnetization is directly and reversibly modulated by the applied electric field through a ∼180° switching of the canted moment in BiFeO3. This constitutes an important step towards robust repeatable and non-volatile voltage-induced 180° magnetization switching in thin-film multiferroic heterostructures and tunable RF/microwave devices.},
 author = {Zhou, Ziyao and Trassin, Morgan and Gao, Ya and Gao, Yuan and Qiu, Diana and Ashraf, Khalid and Nan, Tianxiang and Yang, Xi and Bowden, S. R. and Pierce, D. T. and Stiles, M. D. and Unguris, J. and Liu, Ming and Howe, Brandon M. and Brown, Gail J. and Salahuddin, S. and Ramesh, R. and Sun, Nian X.},
 doi = {10.1038/ncomms7082},
 issn = {20411723},
 journal = {Nat. Commun.},
 pages = {6082},
 publisher = {Nature Publishing Group},
 title = {Probing electric field control of magnetism using ferromagnetic resonance},
 volume = {6},
 year = {2015}
}


text:
@incollection{Benhaiem2018,
 address = {Singapore},
 author = {Benhaïem, Pierre and Schmehl, Roland},
 booktitle = {Airborne Wind Energy -- Advances in Technology Development and Research},
 chapter = {22},
 date = {2018-04-01},
 doi = {10.1007/978-981-10-1947-0_22},
 editor = {Schmehl, Roland},
 pages = {539--577},
 publisher = {Springer},
 series = {Green Energy and Technology},
 title = {Airborne Wind Energy Conversion Using a Rotating Reel System},
 year = {2018}
}


text:
//nolint:gochecknoinits
package cli

import (
	"github.com/spf13/cobra"
)

var resyncCmd = &cobra.Command{
	Use:   "resync",
	Short: "Triggers a resync of some resources",
	Long:  `Triggers a resync of some resources`,
	Args:  cobra.ExactArgs(0),
}

func init() {
	rootCmd.AddCommand(resyncCmd)
}

repository: gbvitrano/pdns-distribute

repo_name: gbvitrano/pdns-distribute


text:
// Copyright 2015 ChaiShushan <chaishushan{AT}gmail.com>. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package static

import (
	"github.com/chai2010/golangdoc/godoc/static"
	"github.com/chai2010/golangdoc/godoc/vfs/mapfs"
	"github.com/chai2010/golangdoc/local"
)

func Files(lang ...string) map[string]string {
	if len(lang) > 0 {
		if files, ok := StaticFilesTable[lang[0]]; ok && files != nil {
			return files
		}
	}
	return static.Files
}

func init() {
	for lang, files := range StaticFilesTable {
		local.RegisterStaticFS(lang, mapfs.New(files))
	}
}


text:
/**
 * Copyright 2017 IBM Corp.
 *
 * 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 utils

import (
	"fmt"
	"github.com/IBM/ubiquity/utils/logs"
	"sync"
	"time"
)

//go:generate counterfeiter -o ../fakes/fake_locker.go . Locker
type Locker interface {
	WriteLock(name string)
	WriteUnlock(name string)
	ReadLock(name string)
	ReadUnlock(name string)
}

func NewLocker() Locker {
	return &locker{locks: make(map[string]*sync.RWMutex), accessLock: &sync.Mutex{}, statsLock: &sync.Mutex{}, cleanupLock: &sync.Mutex{}, stats: make(map[string]time.Time), logger: logs.GetLogger()}
}

const (
	STALE_LOCK_TIMEOUT = 600 //in seconds
)

type locker struct {
	accessLock  *sync.Mutex
	locks       map[string]*sync.RWMutex
	statsLock   *sync.Mutex
	stats       map[string]time.Time
	cleanupLock *sync.Mutex
	logger      logs.Logger
}

func (l *locker) WriteLock(name string) {
	defer l.logger.Trace(logs.DEBUG, logs.Args{{"lockName", name}})()

	defer l.updateStats(name)
	l.accessLock.Lock()
	if lock, exists := l.locks[name]; exists {
		l.accessLock.Unlock()
		lock.Lock()
		return
	}

	lock := &sync.RWMutex{}
	lock.Lock()
	l.locks[name] = lock
	l.accessLock.Unlock()
}
func (l *locker) WriteUnlock(name string) {
	defer l.logger.Trace(logs.DEBUG, logs.Args{{"lockName", name}})()
	defer l.updateStats(name)
	l.accessLock.Lock()
	defer l.accessLock.Unlock()
	if lock, exists := l.locks[name]; exists {
		lock.Unlock()
		return
	}

}
func (l *locker) ReadLock(name string) {
	defer l.logger.Trace(logs.DEBUG, logs.Args{{"lockName", name}})()
	defer l.updateStats(name)
	l.accessLock.Lock()
	if lock, exists := l.locks[name]; exists {
		l.accessLock.Unlock()
		lock.RLock()
		return
	}

	lock := &sync.RWMutex{}
	lock.RLock()
	l.locks[name] = lock
	l.accessLock.Unlock()
}
func (l *locker) ReadUnlock(name string) {
	defer l.logger.Trace(logs.DEBUG, logs.Args{{"lockName", name}})()
	defer l.updateStats(name)
	l.accessLock.Lock()
	defer l.accessLock.Unlock()
	if lock, exists := l.locks[name]; exists {
		lock.RUnlock()
		return
	}
}
func (l *locker) updateStats(name string) {
	defer l.logger.Trace(logs.DEBUG, logs.Args{{"lockName", name}})()

	l.statsLock.Lock()
	defer l.statsLock.Unlock()
	defer l.cleanup()
	if stat, exists := l.stats[name]; exists {
		stat = time.Now()
		l.stats[name] = stat
		return
	}
	stat := time.Now()
	l.stats[name] = stat
}
func (l *locker) cleanup() {
	defer l.logger.Trace(logs.DEBUG)()

	l.cleanupLock.Lock()
	defer l.cleanupLock.Unlock()
	currentTime := time.Now()
	var statsToDelete []string
	for name, stat := range l.stats {
		if currentTime.Sub(stat).Seconds() > STALE_LOCK_TIMEOUT {
			msg := fmt.Sprint("Removing stalelock '%s' as it has exceeded configured timeout ('%d seconds')\n", name, STALE_LOCK_TIMEOUT)
			l.logger.Debug(msg)
			delete(l.locks, name)
			statsToDelete = append(statsToDelete, name)
		}
	}
	for _, name := range statsToDelete {
		delete(l.stats, name)
	}
}

repository: toms-home/ubiquity

repo_name: toms-home/ubiquity


text:
@inproceedings{zou2021role,
  title={The Role of Computer Security Customer Support in Helping Survivors of Intimate Partner Violence},
  author={Zou, Yixin and McDonald, Allison and Narakornpichit, Julia and Dell, Nicola and Ristenpart, Thomas and Roundy, Kevin and Schaub, Florian and Tamersoy, Acar},
  booktitle={USENIX Security Symposium},
  pages={429--446},
  year={2021},
  organization={USENIX Association},
  url={https://www.usenix.org/system/files/sec21-zou.pdf}
}


text:
DESCRIPTION = "Free PDF Creator for PHP"
SECTION = "libs"
DEPENDS = ""
RDEPENDS_${PN} = "php"
LICENSE = "FREEWARE"
PR = "r1"

SRC_URI = "http://www.fpdf.org/en/download/fpdf153.tgz \
	   "

S = "${WORKDIR}/fpdf153"
do_compile() {
    :
}

do_install() {
    install -d  ${D}/usr \
                ${D}/usr/fpdf \
                ${D}/usr/fpdf/font \
                ${D}/usr/fpdf/font/makefont

    install -m 644 ${S}/fpdf.php              ${D}/usr/fpdf/
    install -m 644 ${S}/fpdf.css              ${D}/usr/fpdf/
    install -m 644 ${S}/font/*.php            ${D}/usr/fpdf/font/
    install -m 644 ${S}/font/makefont/*       ${D}/usr/fpdf/font/makefont/
}

FILES_${PN} = "${exec_prefix}/fpdf/*.* \
               ${exec_prefix}/fpdf/font/*.* \
              "
FILES_${PN}-dev = "${exec_prefix}/fpdf/font/makefont/*"

SRC_URI[md5sum] = "6106c8d0aba37563b7ca9ccc94bc6c95"
SRC_URI[sha256sum] = "44b7e18ba9ae5667dd64c89f7b04627bda5807a3a90255a125702d63c0c4ee17"
# CHECKSUMS.INI MISMATCH: I've got this instead:
#SRC_URI[md5sum] = "2209595e96639eada95d0f4c20f00a5a"
#SRC_URI[sha256sum] = "6321c4b448459d556d3d88f21d44c9d4ec595cc14dbaf6aa6e33f69bd8e5fa6d"


text:
package comm

import (
	"strings"
)

// ErrorString is an error string
type ErrorString struct {
	S string
}

// Error returns the string of the error (wow!)
func (e *ErrorString) Error() string {
	return e.S
}

// ToJSONString converts error string to json string
func ToJSONString(e error) string {
	return "{\"code\": 1000, \"reason\":\"" + strings.ReplaceAll(e.Error(), "\"", "\\\"") + "\"}"
}

repository: riccardomanfrin/netconfd

repo_name: riccardomanfrin/netconfd


text:
@techreport{frey_technology_2015,
	type = {Citi {GPS} {Report}},
	title = {Technology at {Work}: {The} {Future} of {Innovation} and {Employment}},
	shorttitle = {Technology at {Work}},
	url = {http://www.oxfordmartin.ox.ac.uk/publications/view/1883},
	abstract = {Technology at Work: The Future of Innovation and Employment, is the latest Citi GPS report from the Oxford Martin School and Citi. It explores trends in automation and points to sluggish job creation caused partly by increasing automation, and argues that secular stagnation in the digital age can only be avoided by a shift towards inclusive growth.

The authors highlight the key challenges, explore some of the new technology brought on by the digital age and set out an agenda for change, calling for long term thinking to mitigate the negative effects of an ever more automated and digital economy.

Technology at Work marks the start of a new programme of research supported by Citi, the Oxford Martin Programme on Technology and Employment.},
	author = {Frey, Carl Benedikt and Osborne, Michael A},
	year = {2015},
	file = {1480/GPS_final.pdf}
}

@techreport{frey_agiletown_2014,
	title = {Agiletown : the relentless march of technology and {London}’s response},
	url = {http://www.deloitte.com/view/en_GB/uk/market-insights/uk-futures/london-futures/index.htm},
	abstract = {Our London Futures insights series focuses on the London economy and what it needs to do to maintain and reinforce its position as a leading global business hub. Our latest report in the programme, Agiletown: the relentless march of technology and London’s response, focuses on the challenges and opportunities that technology presents to London.

The findings indicate that a significant shift is occurring in the labour market. Jobs that do not need to be done in London, or can be fully replaced by technology, will continue to leave the city. However, the job losses will be outweighed by new jobs requiring skills that involve creativity, complex problem-solving and high technical content.

The report brings together research from Oxford Martin School academics Carl Benedikt Frey and Michael A Osborne on the potential impact of automation on jobs in the UK and London over the next two decades, and a Deloitte survey of 100 London based organisations, exploring the new jobs that will be created, the skills that will be needed, and the implications for current working practices.},
	institution = {Deloitte},
	author = {Frey, Carl Benedikt and Osborne, Michael A.},
	month = oct,
	year = {2014},
	file = {1892/uk-london-futures-agiletown-nov-14.pdf}
}

@techreport{bakhshi_creativity_2015,
	title = {Creativity {Vs} {Robots}},
	url = {http://www.nesta.org.uk/publications/creativity-vs-robots},
	abstract = {This report explores future automation and creativity in the UK and US workforces. We find that creative jobs will be much more resistant to automation than most other jobs.},
	urldate = {2015-04-24},
	institution = {Nesta},
	author = {Bakhshi, Hasan and Frey, Carl Benedikt and Osborne, Michael A.},
	year = {2015},
	file = {1866/creativity_vs._robots_wv.pdf}
}

@techreport{frey_technology_2016,
	type = {Citi {GPS} {Report}},
	title = {Technology at {Work} v2: {The} {Future} {Is} {Not} {What} {It} {Used} to {Be}},
	shorttitle = {Technology at {Work} v2.0},
	url = {http://www.oxfordmartin.ox.ac.uk/publications/view/2092},
	abstract = {Technology at Work v2.0: The Future Is Not What It Used to Be, produced by the Oxford Martin School and Citi, provides in-depth analysis of the vulnerabilities of countries and cities to job automation, explores what automation will mean for traditional models of economic growth, and considers how governments can prepare for the potentially disruptive impacts of job automation on society.

It builds on 2013 research by Carl Benedikt Frey and Michael Osborne which found that 47 per cent of US jobs were at risk of automation over the next two decades, and on the first Technology at Work Citi GPS report, published in 2015.

As well as collaborating on the Citi GPS series of reports, the School has partnered with Citi to create a new programme of research, the Oxford Martin Programme on Technology and Employment, to investigate the implications of a rapidly changing technological landscape for economies and societies.},
	author = {Frey, Carl Benedikt and Osborne, Michael A.},
	year = {2016},
	file = {1204/Citi_GPS_Technology_Work_2.pdf}
}

@techreport{bakhshi_future_2017,
	address = {United Kingdom},
	title = {The future of skills: employment in 2030},
	shorttitle = {The future of skills},
	url = {https://futureskills.pearson.com},
	abstract = {Recent debates about the future of jobs have mainly focused on whether or not they are at risk of automation. Studies have generally minimised the potential effects of automation on job creation, and have tended to ignore other relevant trends, including globalisation, population ageing, urbanisation, and the rise of the green economy. This study uses a novel and comprehensive method to map out how employment is likely to change, and the implications for skills. --Executive summary.},
	language = {English},
	institution = {Pearson},
	author = {Bakhshi, Hasan and Downing, Jonathan M and Osborne, Michael A and Schneider, Philippe},
	year = {2017},
	file = {2864/Bakhshi et al. - 2017 - The future of skills employment in 2030.pdf}
}

repository: mosb/robots-www

repo_name: mosb/robots-www


text:
var monads = require("monadjs");

var result = monads.doMonad(monads.maybeMonad,
    "a", function(scope) {
         if (typeof console === "object" && console.log)
             return 2;
         else
             return null;
         },
    "b", function(scope) {
          with (scope) {
                 return a * 3;
             }
         },
    function(scope) {
        with(scope) {
            return a + b;
        }
    }
);

console.log(result);

repository: lemonhall/monadjs

repo_name: lemonhall/monadjs

extension: js


text:
DESCRIPTION = "The Tcl UDP extension provides a simple library to support UDP socket in Tcl."
LICENSE = "Columbia University"
LIC_FILES_CHKSUM = "file://license.terms;md5=5f94cd289c546cf308271804775ddc10"
SECTION = "devel/tcltk"
HOMEPAGE = "http://sourceforge.net/projects/tcludp/"
DEPENDS = "tcl-native tcl tcllib"

PR = "r0"

SRC_URI = "http://sourceforge.net/projects/tcludp/files/tcludp/${PV}/${PN}-${PV}.tar.gz \
	file://no_dtplite.patch \
	"

SRC_URI[md5sum] = "945ea7afd1df9e46090733ffbfd724a1"
SRC_URI[sha256sum] = "a8a29d55a718eb90aada643841b3e0715216d27cea2e2df243e184edb780aa9d"

S = "${WORKDIR}/${PN}"

inherit autotools

EXTRA_OECONF = "--with-tcl=${STAGING_BINDIR_CROSS} --with-tclinclude=${STAGING_INCDIR}/tcl8.6"

FILES_${PN} += "/usr/bin /usr/lib/udp1.0.10/*.so*"
FILES_${PN} += "/usr/lib/udp1.0.10/*.tcl"
FILES_${PN}-dbg +="/usr/lib/udp1.0.10/.debug/*"


text:
package dojo

import (
	"testing"

	"github.com/stretchr/testify/assert"
)

func original() map[string]int {
	return map[string]int{
		"metric1": 1,
		"metric2": 2,
		"metric3": 3,
		"metric4": 4,
	}
}

func TestIsPointIn(t *testing.T) {
	assert := assert.New(t)
	assert.Equal(main(), true, "must be true")
}

func TestEqual(t *testing.T) {
	assert := assert.New(t)
	original := original()
	remoteMap := map[string]int{
		"metric1": 1,
		"metric2": 2,
		"metric3": 3,
		"metric4": 4,
	}
	ParseMetrics(&original, remoteMap)
	assert.Equal(original, remoteMap, "Should not modify anything")
}

func TestModifyOneMetric(t *testing.T) {
	assert := assert.New(t)
	org := original()
	remoteMap := map[string]int{
		"metric1": 1,
		"metric3": 3,
		"metric2": 30,
		"metric4": 4,
	}

	ParseMetrics(&org, remoteMap)
	assert.Equal(org, remoteMap, "Should change 1 metric")
}
func TestModifyTwoMetrics(t *testing.T) {
	assert := assert.New(t)
	org := original()
	remoteMap := map[string]int{
		"metric1": 10,
		"metric2": 30,
		"metric3": 3,
		"metric4": 4,
	}

	ParseMetrics(&org, remoteMap)
	assert.Equal(org, remoteMap, "Should change 2 metrics")

}
func TestModifyAllMetrics(t *testing.T) {
	assert := assert.New(t)
	org := original()
	remoteMap := map[string]int{
		"metric1": 10,
		"metric2": 30,
		"metric3": 25,
		"metric4": 42,
	}

	ParseMetrics(&org, remoteMap)
	assert.Equal(org, remoteMap, "Should change all metrics")
}
func TestModifyAllMetricsDifferentOrder(t *testing.T) {
	assert := assert.New(t)
	org := original()
	remoteMap := map[string]int{
		"metric3": 25,
		"metric1": 10,
		"metric4": 42,
		"metric2": 30,
	}

	ParseMetrics(&org, remoteMap)
	assert.Equal(org, remoteMap, "Should change all metrics on a different order")
}
func TestModifyAllMetricsPlusOne(t *testing.T) {
	assert := assert.New(t)
	org := original()
	remoteMap := map[string]int{
		"metric3": 25,
		"metric1": 10,
		"metric4": 42,
		"metric2": 30,
		"metric5": 50,
	}

	ParseMetrics(&org, remoteMap)
	assert.Equal(org, remoteMap, "Should change all metrics and add one")
}
func TestModifyAllMetricsPlusTwo(t *testing.T) {
	assert := assert.New(t)
	org := original()
	remoteMap := map[string]int{
		"metric3": 25,
		"metric1": 10,
		"metric4": 42,
		"metric2": 30,
		"metric5": 50,
		"metric6": 600,
	}

	ParseMetrics(&org, remoteMap)
	assert.Equal(org, remoteMap, "Should change all metrics and add one")

}
func TestRemoveOneMetric(t *testing.T) {
	assert := assert.New(t)
	original := original()
	remoteMap := map[string]int{
		"metric2": 2,
		"metric3": 3,
		"metric4": 4,
	}
	ParseMetrics(&original, remoteMap)
	assert.Equal(original, remoteMap, "Should remove one metric")
}

func TestRemoveTwoMetrics(t *testing.T) {
	assert := assert.New(t)
	original := original()
	remoteMap := map[string]int{
		"metric3": 3,
		"metric4": 4,
	}
	ParseMetrics(&original, remoteMap)
	assert.Equal(original, remoteMap, "Should remove 2 metrics")
}

func TestManyDifferentMetrics(t *testing.T) {
	assert := assert.New(t)
	org := original()
	remoteMap := map[string]int{
		"metric3":    25,
		"metric2":    30,
		"metric5":    50,
		"metric6":    60,
		"metric9000": 9001, //over 9000
	}

	ParseMetrics(&org, remoteMap)
	assert.Equal(org, remoteMap, "Should change all metrics and add two")
}

repository: globocom/dojo

repo_name: globocom/dojo

gha_language: JavaScript


text:
require recipes-connectivity/connman/connman.inc

# We use a known good version instead of some buggy point version.
SRCREV = "ea66bc2f59d2a3339ff07c5f556ee4876538115d"

SRC_URI = "\
	git://git.kernel.org/pub/scm/network/connman/connman.git \
	file://add_xuser_dbus_permission.patch \
	file://connman.service \
"
LIC_FILES_CHKSUM = "file://COPYING;md5=12f884d2ae1ff87c09e5b7ccc2c4ca7e \
                    file://src/main.c;beginline=1;endline=20;md5=486a279a6ab0c8d152bcda3a5b5edc36 \
"

# Enable debugging the easy way in systemd based distro.
# See 0001-doc-Debugging-in-host-that-uses-systemd.patch for usage.
SRC_URI += "\
    file://0003-systemd-Use-environment-file-for-connman-vpnd-debug-.patch \
"

S = "${WORKDIR}/git"
PR = "${INC_PR}.0"
PV = "1.30+git${SRCPV}"

# Override some options from poky connman recipe
EXTRA_OECONF += "\
    --enable-loopback=builtin \
    --enable-ethernet=builtin \
    --enable-test \
    --enable-client \
    --enable-tools \
    --disable-polkit \
    --enable-pacrunner \
    --enable-wispr \
"

# Make sure we will use bluez5 instead of older bluez4
PACKAGECONFIG[bluez5] = "--enable-bluetooth, --disable-bluetooth, bluez5"
RDEPENDS_${PN} = "\
	dbus \
	${@base_contains('PACKAGECONFIG', 'bluez5', 'bluez5', '', d)} \
	${@base_contains('PACKAGECONFIG', 'wifi','wpa-supplicant', '', d)} \
	${@base_contains('PACKAGECONFIG', '3g','ofono', '', d)} \
	"

do_install_append() {
	install -d ${D}${sysconfdir}/connman
	install -m 0644 ${S}/src/main.conf ${D}${sysconfdir}/connman/main.conf.example
	install -m 0755 ${WORKDIR}/connman.service ${D}${nonarch_base_libdir}/systemd/system
}

repository: olegcherpak/meta-eca

repo_name: olegcherpak/meta-eca


text:
@online{agda-stdlib-1.3-changelog-reasoning,
	url   = {https://github.com/agda/agda-stdlib/blob/v1.3/CHANGELOG.md#changes-to-how-equational-reasoning-is-implemented},
	title = {Agda std-lib Changelog},
	urldate  = {2020-02-28},
}

repository: neosimsim/merkdas

repo_name: neosimsim/merkdas


text:
@inproceedings{Harper2008wf,
 abstract = {The rapid advancement of World Wide Web (Web) technology and constant need for attractive Websites produce pages that hinder visually impaired users. We assert that understanding how sighted users browse Web pages can provide important information that will enhance Web Accessibility, especially for visually impaired users. We present an eye tracking study where sighted users' browsing behaviour on nine Web pages was investigated to determine how the page's visual clutter is related to sighted users' browsing patterns. The results show that salient elements attract users' attention first, users spend more time on the main content of the page and users tend to fixate on the first three or four items on the menu lists. Common gaze patterns begin at the salient elements of the page, move to the main content, header, right column and left column of the page and finish at the footer area. We argue that the results should be used as the initial step for proposing guidelines that assist in designing and transforming Web pages for an easier and faster access for visually impaired users.
},
 address = {New York, NY, USA},
 author = {Michailidou, Eleni and Harper, Simon and Bechhofer, Sean},
 booktitle = {Assets '08: Proceedings of the 10th international ACM SIGACCESS conference on Computers and accessibility},
 doi = {http://dx.doi.org/10.1145/1414471.1414495},
 isbn = {978-1-59593-976-0},
 keywords = {Accessibility,Human Centred Web,Visual Complexity},
 month = {oct},
 pages = {121--128},
 publisher = {ACM},
 title = {Investigating sighted users' browsing behaviour to assist web accessibility},
 url = {http://www.simonharper.info/publications/Harper2008wf.pdf},
 year = {2008}
}

repository: sharpic/academic-kickstart

repo_name: sharpic/academic-kickstart


text:
// START1 OMIT
package main

import (
	"fmt"
	"github.com/gorilla/mux"
	"log"
	"net/http"
)

func main() {
	log.Println("Setting up routes...")

	router := mux.NewRouter()

	router.HandleFunc("/", RootHandler)
	router.HandleFunc("/foo", FooHandler)

	log.Println("Starting server on port 8081")

	http.Handle("/", router)
	log.Fatal(http.ListenAndServe(":8081", nil))
}

// STOP1 OMIT

// START2 OMIT
func RootHandler(w http.ResponseWriter, httpRequest *http.Request) {
	fmt.Fprintln(w, "Welcome to my new website")
}

func FooHandler(w http.ResponseWriter, httpRequest *http.Request) {
	fmt.Fprintf(
		w,
		fmt.Sprintf("Your browser is: %s", httpRequest.UserAgent()),
	)
}

// STOP2 OMIT

repository: giefferre/introducing-golang

repo_name: giefferre/introducing-golang


text:
SECTION = "base"
DESCRIPTION = "modutils configuration files"
PR = "r4"
LICENSE = "MIT"

SRC_URI = "file://modules \
	   file://modules.conf"

do_compile () {
}

do_install () {
	install -d ${D}${sysconfdir}
	install -m 0644 ${WORKDIR}/modules ${D}${sysconfdir}/modules
        if [ ${MAJOR_KERNEL_VERSION}=2.6 ]; then
  	 install -d ${D}${sysconfdir}/modprobe.d
        else
 	 install -m 0644 ${WORKDIR}/modules.conf ${D}${sysconfdir}/modules.conf
        fi

}

repository: balister/openembedded

repo_name: balister/openembedded


text:
const arr = [1, 2, 3, 4];

export function printArr() {
  console.log('---array methods---');
  console.log(`arr:${arr}`);
}

function printVal(val) {
  console.log(val);
}

export function forEach() {
  console.log('forEach: print each value');
  arr.forEach(printVal);
}

function multiply(val) {
  return (val * 2);
}

export function map() {
  console.log('map: multiply by 2');
  const newArr = arr.map(multiply);
  console.log(`${newArr}`);
}

function evenNums(val) {
  return val % 2 === 0;
}

export function filter() {
  console.log('filter: even numbers only');
  const newArr = arr.filter(evenNums);
  console.log(`${newArr}`);
}

export function find() {
  console.log('find: first even number');
  const found = arr.find(evenNums);
  console.log(`${found}`);
}

export function every() {
  console.log('every: is every number even number?');
  const everyEven = arr.every(evenNums);
  console.log(`${everyEven}`);
}

function divByThree(num) {
  return num % 3 === 0;
}

export function some() {
  console.log('some: is some number divided by three?');
  const someDivByThree = arr.some(divByThree);
  console.log(someDivByThree);
}

function sum(acc, val) {
  return acc + val;
}

function prod(acc, val) {
  return acc * val;
}

export function reduce() {
  console.log('sum of array');
  const sumArr = arr.reduce(sum, 0);
  console.log(sumArr);
  console.log('product of array');
  const prodArr = arr.reduce(prod, 1);
  console.log(prodArr);
}


text:
@TechReport{RAVENuserManual,
author = {Cristian Rabiti and Andrea Alfonsi and Joshua Cogliati and Diego Mandelli and Robert Kinoshita and Sonat Sen},
title = {RAVEN User Manual},
institution = {Idaho National Laboratory},
year = {2015},
OPTkey = {NL/EXT-15-34123},
OPTtype = {•},
OPTnumber = {•},
OPTaddress = {•},
OPTmonth = {•},
OPTnote = {•},
OPTannote = {rev.4}
}


text:
package random

import (
	"context"
	"strconv"

	"github.com/irisnet/irishub-sdk-go/codec"
	cdctypes "github.com/irisnet/irishub-sdk-go/codec/types"
	sdk "github.com/irisnet/irishub-sdk-go/types"
)

type randomClient struct {
	sdk.BaseClient
	codec.Marshaler
}

func NewClient(baseClient sdk.BaseClient, marshaler codec.Marshaler) *randomClient {
	return &randomClient{
		BaseClient: baseClient,
		Marshaler:  marshaler,
	}
}

func (rc randomClient) Name() string {
	return ModuleName
}

func (rc randomClient) RegisterInterfaceTypes(registry cdctypes.InterfaceRegistry) {
	RegisterInterfaces(registry)
}

func (rc randomClient) RequestRandom(request RequestRandomRequest, basTx sdk.BaseTx) (RequestRandomResp, sdk.ResultTx, sdk.Error) {
	author, err := rc.QueryAddress(basTx.From, basTx.Password)
	if err != nil {
		return RequestRandomResp{}, sdk.ResultTx{}, nil
	}

	msg := &MsgRequestRandom{
		BlockInterval: request.BlockInterval,
		Consumer:      author.String(),
		Oracle:        request.Oracle,
		ServiceFeeCap: request.ServiceFeeCap,
	}
	result, err := rc.BuildAndSend([]sdk.Msg{msg}, basTx)
	if err != nil {
		return RequestRandomResp{}, sdk.ResultTx{}, err
	}

	reqID, e := result.Events.GetValue(eventTypeRequestRequestRandom, attributeKeyRequestID)
	if e != nil {
		return RequestRandomResp{}, result, sdk.Wrap(e)
	}
	generateHeight, e := result.Events.GetValue(eventTypeRequestRequestRandom, attributeKeyGenerateHeight)
	if e != nil {
		return RequestRandomResp{}, result, sdk.Wrap(e)
	}
	height, e := strconv.Atoi(generateHeight)
	if e != nil {
		return RequestRandomResp{}, result, sdk.Wrap(e)
	}

	res := RequestRandomResp{
		Height: int64(height),
		ReqID:  reqID,
	}
	return res, result, nil
}

func (rc randomClient) QueryRandom(reqID string) (QueryRandomResp, sdk.Error) {
	if len(reqID) == 0 {
		return QueryRandomResp{}, sdk.Wrapf("reqId is required")
	}

	conn, err := rc.GenConn()
	defer func() { _ = conn.Close() }()
	if err != nil {
		return QueryRandomResp{}, sdk.Wrap(err)
	}

	res, err := NewQueryClient(conn).Random(
		context.Background(),
		&QueryRandomRequest{ReqId: reqID},
	)
	if err != nil {
		return QueryRandomResp{}, sdk.Wrap(err)
	}
	return res.Random.Convert().(QueryRandomResp), nil
}

func (rc randomClient) QueryRandomRequestQueue(height int64) ([]QueryRandomRequestQueueResp, sdk.Error) {
	if height == 0 {
		return []QueryRandomRequestQueueResp{}, nil
	}

	conn, err := rc.GenConn()
	defer func() { _ = conn.Close() }()
	if err != nil {
		return []QueryRandomRequestQueueResp{}, sdk.Wrap(err)
	}
	res, err := NewQueryClient(conn).RandomRequestQueue(
		context.Background(),
		&QueryRandomRequestQueueRequest{Height: height},
	)
	if err != nil {
		return []QueryRandomRequestQueueResp{}, sdk.Wrap(err)
	}
	return Requests(res.Requests).Convert().([]QueryRandomRequestQueueResp), nil
}

repository: irisnet/irishub-sdk-go

repo_name: irisnet/irishub-sdk-go


text:
@Article{courcelles_occurrence_2012,
  title = {Occurrence and detection of phosphopeptide isomers in large-scale phosphoproteomics experiments},
  volume = {11},
  doi = {10.1021/pr300229m},
  number = {7},
  journal = {J Proteome Res},
  author = {M. Courcelles and G. Bridon and S. Lemieux and P. Thibault},
  year = {2012},
  note = {Type: Journal Article},
  pages = {3753--65},
  issn = {1535-3893},
  date = {2012-01-01},
}


text:
%% This BibTeX bibliography file was created using BibDesk.
%% http://bibdesk.sourceforge.net/

%% Created for David Meyer at 2017-04-19 08:26:04 -0700

%% Saved with string encoding Unicode (UTF-8)

@misc{Rosenblatt1958,
	Author = {Rosenblatt, F.},
	Citation_Abstract_Html_Url = {http://psycnet.apa.org/journals/rev/65/6/386},
	Citation_Authors = {Rosenblatt, F.},
	Citation_Date = {Nov   1958},
	Citation_Doi = {10.1037/h0042519},
	Citation_Firstpage = {386},
	Citation_Fulltext_Html_Url = {http://psycnet.apa.org/journals/rev/65/6/386.html},
	Citation_Issn = {0033-295X (Print)},
	Citation_Issue = {6},
	Citation_Journal_Title = {Psychological Review},
	Citation_Keywords = {probabilistic model; information storage; brain},
	Citation_Language = {English},
	Citation_Pdf_Url = {http://psycnet.apa.org/journals/rev/65/6/386.pdf},
	Citation_Publisher = {American Psychological Association},
	Citation_Reference = {von Neumann, J. (1951). The general and logical theory of automata. In L. A. Jeffress (Ed.), Cerebral mechanisms in behavior; the Hixon Symposium (pp. 1-41). Oxford, England: Wiley.},
	Citation_Title = {The perceptron: A probabilistic model for information storage and organization in the brain.},
	Citation_Volume = {65},
	Date-Added = {2017-04-19 15:23:35 +0000},
	Date-Modified = {2017-04-19 15:24:41 +0000},
	Month = {Nov},
	Robots = {noindex,nofollow},
	Title = {http://psycnet.apa.org/psycinfo/1959-09865-001},
	Year = {1958}}


text:
require ${PN}.inc

PR = "r1"

SRC_URI = "http://sources.openembedded.org/opie-1.2.4-split_core_applets_multikeyapplet.tar.bz2;name=split_core_applets_multikeyapplet \
           http://sources.openembedded.org/opie-1.2.4-split_apps.tar.bz2;name=split_apps"
SRC_URI[split_core_applets_multikeyapplet.md5sum] = "33d099206151cec653491033ce0fc5f6"
SRC_URI[split_core_applets_multikeyapplet.sha256sum] = "598576acef4f87dbe55d4fdbe6d0ba5fa9a65ae1ab40b9362c86087a111e1c9a"
SRC_URI[split_apps.md5sum] = "67a43e8e4bcd9e63b884ea25deea5b34"
SRC_URI[split_apps.sha256sum] = "a33a55efb4ae4c15a8c2c5d6faba6d671a5652da8e216ce35088896fe597215b"


text:
install(TARGETS pplnn_basic_static DESTINATION lib)

set(__PPLNN_CMAKE_CONFIG_FILE__ ${CMAKE_CURRENT_BINARY_DIR}/generated/pplnn-config.cmake)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pplnn-config.cmake.in
    ${__PPLNN_CMAKE_CONFIG_FILE__}
    @ONLY)
install(FILES ${__PPLNN_CMAKE_CONFIG_FILE__} DESTINATION lib/cmake/ppl)
unset(__PPLNN_CMAKE_CONFIG_FILE__)

install(DIRECTORY include/ppl/nn/common DESTINATION include/ppl/nn)
install(DIRECTORY include/ppl/nn/runtime DESTINATION include/ppl/nn)
install(DIRECTORY include/ppl/nn/utils DESTINATION include/ppl/nn)

install(FILES include/ppl/nn/engines/engine.h DESTINATION include/ppl/nn/engines)

if(PPLNN_ENABLE_PMX_MODEL)
    install(DIRECTORY include/ppl/nn/models/pmx DESTINATION include/ppl/nn/models)
endif()

extension: cmake


text:
@inproceedings{vvaquero2015rgbd,
author="Vaquero, Victor and Villamizar, Michael and Sanfeliu, Alberto",
title="Real Time People Detection Combining Appearance and Depth Image Spaces Using Boosted Random Ferns",
booktitle="Robot 2015: Second Iberian Robotics Conference",
year="2016",
publisher="Springer",
}


text:
package main

import (
	"fmt"
)

func main() {
	fmt.Println("main begin.")
	coNum := 3
	ch := make(chan int, coNum)
	for i := 0; i < 5; i++ {
		ch <- 1
		fmt.Printf("go: %d\n", i)
		go func(n int) {
			defer func() { <-ch }()
			fmt.Printf("handle: %d\n", n)
		}(i)
	}
	for i := 0; i < coNum; i++ {
		ch <- 1
	}
	fmt.Println("main exit.")
}

repository: kjfcpua/expert-programming

repo_name: kjfcpua/expert-programming


text:
require linux-omap3.inc

COMPATIBLE_MACHINE = "ti814x"

KVER = "2.6.37"
PSPREL = "04.01.00.06.patch2"

SRCREV = "v2.6.37_TI814XPSP_04.01.00.06.patch2"

SRC_URI += "file://0001-ti814x-added-code-for-disabling-the-least-significan.patch \
"


text:
DESCRIPTION = "A simple calculator which is elementary-themed"
HOMEPAGE = "http://github.com/spaetz/calc"
AUTHOR = "Sebastian Spaeth <Sebastian@SSpaeth.de>"
LICENSE  = "MIT"
RDEPENDS_${PN} = "python-elementary python python-edbus"
SECTION = "x11/application"
PR = "r1"

SRC_URI = "git://github.com/spaetz/calc.git;protocol=http;branch=master;tag=${PV}"
S = "${WORKDIR}/git"

do_install(){
        install -d ${D}${datadir}/applications
        install -m 0644 ${S}/data/elementary-calculator.desktop ${D}${datadir}/applications/
        install -d ${D}${datadir}/pixmaps
        install -m 0644 ${S}/data/calculator.png ${D}${datadir}/pixmaps/
        install -d ${D}${bindir}
        install -m 0744 ${S}/calc ${D}${bindir}/
}

FILES_${PN} += "${prefix}/share/pixmaps"
FILES_${PN} += "${prefix}/share/applications"


text:
package runner

import (
	"errors"
	"os"
	"os/exec"
	"time"
)

// runner is the task runnde
type runner struct {
	prog string
	args []string
	cmd  *exec.Cmd
}

var taskRunner *runner

// NewRunner creates new task runner if not exists
func NewRunner(prog string, args ...string) *runner {
	if taskRunner == nil {
		return &runner{
			prog: prog,
			args: args,
		}
	}

	return taskRunner
}

func newCommandRunner(prog string, args ...string) *exec.Cmd {
	cmd := exec.Command(prog, args...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	return cmd
}

// Run starts the runner
func (rn *runner) Run() error {
	if rn.IsCommandRunning() {
		err := rn.KillCommand()
		if err != nil {
			return err
		}
		rn.cmd = nil
	}

	// start the new one
	rn.cmd = newCommandRunner(rn.prog, rn.args...)
	err := rn.cmd.Start()
	if err != nil {
		return err
	}
	go func() {
		rn.cmd.Wait()
		rn.cmd = nil
	}()

	return nil
}

func (rn *runner) IsCommandRunning() bool {
	return rn.cmd != nil && rn.cmd.Process != nil
}

func (rn *runner) KillCommand() error {
	done := make(chan struct{})
	go func() {
		rn.cmd.Wait()
		close(done)
	}()

	// try soft kill
	rn.cmd.Process.Signal(os.Interrupt)
	select {
	case <-time.After(3 * time.Second):
		// go hard because soft is not always the solution
		err := rn.cmd.Process.Kill()
		if err != nil {
			return errors.New("Fail killing on going process")
		}
	case <-done:
	}

	return nil
}

repository: nattawitc/re

repo_name: nattawitc/re


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

inherit ros_distro_melodic
inherit ros_superflore_generated

DESCRIPTION = "This package contains a C++ parser for the Collada robot     description format. The parser reads a Collada XML robot     description, and creates a C++ URDF model. Although it is possible     to directly use this parser when working with Collada robot     descriptions, the preferred user API is found in the urdf package."
AUTHOR = "Chris Lalancette <clalancette@osrfoundation.org>"
ROS_AUTHOR = "Rosen Diankov"
HOMEPAGE = "http://ros.org/wiki/collada_parser"
SECTION = "devel"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://package.xml;beginline=19;endline=19;md5=d566ef916e9dedc494f5f793a6690ba5"

ROS_CN = "collada_urdf"
ROS_BPN = "collada_parser"

ROS_BUILD_DEPENDS = " \
    class-loader \
    collada-dom \
    rosconsole \
    urdf \
    urdf-parser-plugin \
    urdfdom-headers \
"

ROS_BUILDTOOL_DEPENDS = " \
    catkin-native \
"

ROS_EXPORT_DEPENDS = " \
    urdf \
    urdf-parser-plugin \
"

ROS_BUILDTOOL_EXPORT_DEPENDS = ""

ROS_EXEC_DEPENDS = " \
    class-loader \
    collada-dom \
    rosconsole \
    urdf-parser-plugin \
"

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

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

RDEPENDS_${PN} += "${ROS_EXEC_DEPENDS}"

# matches with: https://github.com/ros-gbp/collada_urdf-release/archive/release/melodic/collada_parser/1.12.13-1.tar.gz
ROS_BRANCH ?= "branch=release/melodic/collada_parser"
SRC_URI = "git://github.com/ros-gbp/collada_urdf-release;${ROS_BRANCH};protocol=https"
SRCREV = "cc08064830a276e3dde6e33a456f9fcf9c01494c"
S = "${WORKDIR}/git"

ROS_BUILD_TYPE = "catkin"

inherit ros_${ROS_BUILD_TYPE}

repository: jianchangfeng/meta-ros

repo_name: jianchangfeng/meta-ros


text:
# xfce-mcs-plugins OE build file
# Copyright (C) 2004, Advanced Micro Devices, Inc.  All Rights Reserved
# Released under the MIT license (see packages/COPYING)

PR="r1"

DESCRIPTION="XFCE4 Utilities"
SECTION = "x11/utils"

PACKAGES="xfce-utils xfce-utils-mcs-plugins"

FILES_xfce-utils-mcs-plugins="${libdir}/xfce4/mcs-plugins/*.so"
FILES_${PN} += " ${datadir}/xfce4/AUTHORS \
        ${datadir}/xfce4/BSD \
        ${datadir}/xfce4/COPYING \
        ${datadir}/xfce4/GPL \
	${datadir}/xfce4/INFO \
        ${datadir}/xfce4/LGPL \
        ${datadir}/xfce4/AUTHORS.html \
        ${datadir}/xfce4/BSD.html \
        ${datadir}/xfce4/COPYING.html \
        ${datadir}/xfce4/GPL.html \
	${datadir}/xfce4/INFO.html \
        ${datadir}/xfce4/LGPL.html \
	${datadir}/xfce4/doc/C"

DEPENDS="x11 libxfcegui4 xfce-mcs-manager"
inherit xfce

# NOTE:  This package takes a --with-browser for the default browser
# NOTE:  Works with gdm also gtkhtml

repository: BackupTheBerlios/openslug-svn

repo_name: BackupTheBerlios/openslug-svn


text:
@article{scipy,
  author  = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and
            Haberland, Matt and Reddy, Tyler and Cournapeau, David and
            Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and
            Bright, Jonathan and {van der Walt}, St{\'e}fan J. and
            Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and
            Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and
            Kern, Robert and Larson, Eric and Carey, C J and
            Polat, {\.I}lhan and Feng, Yu and Moore, Eric W. and
            {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and
            Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and
            Harris, Charles R. and Archibald, Anne M. and
            Ribeiro, Ant{\^o}nio H. and Pedregosa, Fabian and
            {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},
  title   = {{{SciPy} 1.0: Fundamental Algorithms for Scientific
            Computing in Python}},
  journal = {Nature Methods},
  year    = {2020},
  volume  = {17},
  pages   = {261--272},
  adsurl  = {https://rdcu.be/b08Wh},
  doi     = {10.1038/s41592-019-0686-2},
}

@article{oscode,
  title = {Efficient method for solving highly oscillatory ordinary differential equations with applications to physical systems},
  author = {Agocs, F. J. and Handley, W. J. and Lasenby, A. N. and Hobson, M. P.},
  journal = {Physical Review Research},
  volume = {2},
  issue = {1},
  pages = {013030},
  numpages = {16},
  year = {2020},
  month = {Jan},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevResearch.2.013030},
  url = {https://link.aps.org/doi/10.1103/PhysRevResearch.2.013030}
}

@article{beyond-rkwkb,
  title = {{Beyond the Runge-Kutta-Wentzel-Kramers-Brillouin method}},
  author = {Bamber, Jamie and Handley, Will},
  journal = {Physical Review D},
  volume = {101},
  issue = {4},
  pages = {043517},
  numpages = {13},
  year = {2020},
  month = {Feb},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevD.101.043517},
  url = {https://link.aps.org/doi/10.1103/PhysRevD.101.043517}
}

@article{pps-curved,
  title = {Primordial power spectra for curved inflating universes},
  author = {Handley, Will},
  journal = {Physical Review D},
  volume = {100},
  issue = {12},
  pages = {123517},
  numpages = {8},
  year = {2019},
  month = {Dec},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevD.100.123517},
  url = {https://link.aps.org/doi/10.1103/PhysRevD.100.123517}
}

@article{qic,
  title = {Quantum initial conditions for inflation and canonical invariance},
  author = {Agocs, F. J. and Hergt, L. T. and Handley, W. J. and Lasenby, A. N. and Hobson, M. P.},
  journal = {Physical Review D},
  volume = {102},
  issue = {2},
  pages = {023507},
  numpages = {20},
  year = {2020},
  month = {Jul},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevD.102.023507},
  url = {https://link.aps.org/doi/10.1103/PhysRevD.102.023507}
}

@article{petzold,
author = {Petzold, Linda R.},
title = {An Efficient Numerical Method for Highly Oscillatory Ordinary Differential Equations},
journal = {SIAM Journal on Numerical Analysis},
volume = {18},
number = {3},
pages = {455-479},
year = {1981},
doi = {10.1137/0718030},
URL = {https://doi.org/10.1137/0718030},
eprint = {https://doi.org/10.1137/0718030}
}

@article{petzold-review,
title={Numerical solution of highly oscillatory ordinary differential equations},
volume={6},
DOI={10.1017/S0962492900002750},
journal={Acta Numerica},
publisher={Cambridge University Press},
author={Petzold, Linda R. and Jay, Laurent O. and Yen, Jeng},
year={1997},
pages={437–483}
}

@article{bremer,
title = {{On the numerical solution of second order ordinary differential equations in the high-frequency regime}},
journal = {Applied {and} Computational Harmonic Analysis},
volume = {44},
number = {2},
pages = {312 - 349},
year = {2018},
issn = {1063-5203},
doi = {10.1016/j.acha.2016.05.002},
url = {http://www.sciencedirect.com/science/article/pii/S1063520316300185},
author = {Bremer, J.},
}

@article{condon-et-al-circuits,
issn = {0332-1649},
doi = {10.1108/03321640910999897},
journal = {{COMPEL - The international journal for computation {and} mathematics
    in electrical {and} electronic engineering}},
pages = {1607--1618},
volume = {28},
publisher = {Boole Press Limited},
number = {6},
year = {2009},
url = {https://doi.org/10.1108/03321640910999897},
title = {On numerical methods for highly oscillatory problems in circuit simulation},
author = {Condon, M. and Deaño, A. and Iserles, A. and Maczyński, K.},
}

@book{deano-integrals,
author = {Deaño, Alfredo and Huybrechs, Daan and Iserles, Arieh},
title = {Computing Highly Oscillatory Integrals},
publisher = {{Society for Industrial {and} Applied Mathematics}},
year = {2017},
doi = {10.1137/1.9781611975123},
address = {Philadelphia, PA},
edition   = {},
URL = {https://epubs.siam.org/doi/abs/10.1137/1.9781611975123},
eprint = {https://epubs.siam.org/doi/pdf/10.1137/1.9781611975123}
}

@article{condon-deano-iserles,
title={Asymptotic solvers for oscillatory systems of differential equations},
volume={53},
DOI={10.1007/bf03322583},
number={1},
journal={SeMA Journal},
author={Condon, M. and Deaño, A. and Iserles, A.},
year={2011},
pages={79–101}
}

@misc{bremer-code,
  author = {Bremer, J.},
  title = {{Phase functions: Fortran 90 code for solving highly oscillatory
  ordinary differential equations in O(1) time}},
  year = {2018},
  publisher = {GitHub},
  journal = {GitHub repository},
  url = {https://github.com/JamesCBremerJr/Phase-functions}
}

@misc{dense-output,
    title={Dense output for highly oscillatory numerical solutions},
    author={Agocs, F. J. and Hobson, M. P. and Handley, W. J. and Lasenby, A. N.},
    year={2020},
    eprint={2007.05013},
    archivePrefix={arXiv},
    primaryClass={physics.comp-ph}
}

@misc{rkwkb-handley,
    title={{The Runge-Kutta-Wentzel-Kramers-Brillouin Method}},
    author={Handley, W. J. and Lasenby, A. N. and Hobson, M. P.},
    year={2016},
    eprint={1612.02288},
    archivePrefix={arXiv},
    primaryClass={physics.comp-ph}
}

repository: fruzsinaagocs/oscode

repo_name: fruzsinaagocs/oscode


text:
@article{zarrinparAntibioticinducedMicrobiomeDepletion2018,
 abstract = {Antibiotic-induced microbiome depletion is one of the most common approaches to modulate the gut microbiome. Here the authors demonstrate that it affects gut homeostasis and glucose metabolism by decreasing luminal short chain fatty acids and leading to a shift of energy utilization by colonocytes.},
 author = {Zarrinpar, Amir and Chaix, Amandine and Xu, Zhenjiang Z. and Chang, Max W. and Marotz, Clarisse A. and Saghatelian, Alan and Knight, Rob and Panda, Satchidananda},
 copyright = {2018 The Author(s)},
 doi = {10.1038/s41467-018-05336-9},
 file = {/Users/zech/Zotero/storage/U2889XGV/2018_Zarrinpar_et_al_Antibiotic-induced_microbiome_depletion_alters_metabolic_homeostasis_by.pdf},
 issn = {2041-1723},
 journal = {Nature Communications},
 langid = {english},
 month = {July},
 number = {1},
 pages = {2872},
 title = {Antibiotic-Induced Microbiome Depletion Alters Metabolic Homeostasis by Affecting Gut Signaling and Colonic Metabolism},
 urldate = {2018-08-15},
 volume = {9},
 year = {2018}
}

repository: zxlab/lab-web

repo_name: zxlab/lab-web


text:
require gnash.inc

PR = "r5"

EXTRA_OECONF += " --without-included-ltdl \
                  --with-ltdl-include=${STAGING_INCDIR} \
                  --with-ltdl-lib=${STAGING_LIBDIR} \
"

SRC_URI += "file://libtool-2.2.patch;patch=1"


text:
package common

import (
	"fmt"
	"net"

	"github.com/robotalks/mqhub.go/mqhub"
)

// CastTarget defines a target to cast raw data to
type CastTarget interface {
	Cast([]byte) mqhub.Future
}

// DataPointCast casts to mqhub datapoint
type DataPointCast struct {
	DP *mqhub.DataPoint
}

// Cast implement CastTarget
func (c *DataPointCast) Cast(data []byte) mqhub.Future {
	return c.DP.Update(mqhub.StreamMessage(data))
}

// UDPCast casts via UDP broadcast/multicast
type UDPCast struct {
	BindAddr string
	Address  string
	Conn     *net.UDPConn

	remote *net.UDPAddr
}

// Dial creates the UDP socket
func (c *UDPCast) Dial() (err error) {
	var laddr *net.UDPAddr
	if c.BindAddr != "" {
		laddr, err = net.ResolveUDPAddr("udp", c.BindAddr)
		if err != nil {
			return fmt.Errorf("bind address: %v", err)
		}
	}
	if c.Address != "" {
		c.remote, err = net.ResolveUDPAddr("udp", c.Address)
		if err != nil {
			return fmt.Errorf("cast address: %v", err)
		}
		if c.remote != nil && c.remote.IP == nil || c.remote.Port == 0 {
			c.remote = nil
		}
	} else {
		c.remote = nil
	}
	c.Conn, err = net.ListenUDP("udp", laddr)
	return err
}

// Close implements io.Closer
func (c *UDPCast) Close() error {
	return c.Conn.Close()
}

// Cast implements CastTarget
func (c *UDPCast) Cast(data []byte) mqhub.Future {
	f := &mqhub.ImmediateFuture{}
	if c.remote != nil {
		_, f.Error = c.Conn.WriteToUDP(data, c.remote)
		if f.Error != nil {
			println(f.Error.Error(), len(data))
		}
	}
	return f
}

// HasTarget determines if remote address has been set
func (c *UDPCast) HasTarget() bool {
	return c.remote != nil
}

// SetRemoteAddr sets remote address
func (c *UDPCast) SetRemoteAddr(addr string) error {
	if addr == "" {
		c.remote = nil
		return nil
	}
	raddr, err := net.ResolveUDPAddr("udp", addr)
	if err != nil {
		return err
	}
	if raddr == nil || raddr.IP == nil || raddr.Port == 0 {
		c.remote = nil
	} else {
		c.remote = raddr
	}
	return nil
}

repository: robotalks/talk

repo_name: robotalks/talk


text:
%%% -*-BibTeX-*-
@article{Zhou2010FS,
    author  = {Luping Zhou  and Lei Wang and Chunhua Shen},
    title   = {Feature Selection With Redundancy-Constrained Class Separability},
    journal = {IEEE Transactions on Neural Networks},
    volume  = {21},
    year    = {2010},
    number  = {5},
    pages   = {853--858},
    pdf     = {},
    url     = {http://dx.doi.org/10.1109/TNN.2010.2044189},
    venue   = {TNN},
}


text:
Automatically generated by Mendeley Desktop 1.19.4
Any changes to this file will be lost if it is regenerated by Mendeley.

BibTeX export options can be customized via Preferences -> BibTeX in Mendeley Desktop

@article{Mustafa2015,
abstract = {Dengue fever is a re-emerging public health problem with two-fifths of the world population being at risk of infection. Till now, dengue fever was believed to be caused by four different serotypes. The fifth variant DENV-5 has been isolated in October 2013. This serotype follows the sylvatic cycle unlike the other four serotypes which follow the human cycle. The likely cause of emergence of the new serotype could be genetic recombination, natural selection and genetic bottlenecks. There is no indication of the presence of DENV-5 in India. Recent clinical trials with the promising Chimerivax tetravalent vaccine suffered a setback. Discovery of DENV-5 and more such sylvatic strains in future may further impede the Dengue Vaccine Initiative. Integrated Vector Management holds the key to sustainable dengue control. Further epidemiological and ecological studies are needed to detect additional sylvatic dengue strains.},
author = {Mustafa, M. S. and Rasotgi, V. and Jain, S. and Gupta, V.},
doi = {10.1016/j.mjafi.2014.09.011},
file = {:Users/sepmein/Qsync/Papers//Mustafa et al.{\_}2015{\_}Discovery of fifth serotype of dengue virus (denv-5) A new public health dilemma in dengue control.pdf:pdf},
isbn = {0377-1237},
issn = {03771237},
journal = {Medical Journal Armed Forces India},
keywords = {Dengue fever,Dengue vaccine,Serotype,Sylvatic},
number = {1},
pages = {67--70},
pmid = {25609867},
title = {{Discovery of fifth serotype of dengue virus (denv-5): A new public health dilemma in dengue control}},
volume = {71},
year = {2015}
}

license: Unlicense

repository: sepmein/references

repo_name: sepmein/references


text:
package datamodeling

import (
	"github.com/twhello/aws-to-go/services/dynamodb"
)

// Struct mapper for domain-object interaction with DynamoDB.
//
// Default configuration uses UPDATE behavior for saves and EVENTUALly consistent reads,
// with no table name override and lazy-loading strategy.
type DynamoDBMapper struct {
	DynamoDBService      *dynamodb.DynamoDBService
	DynamoDBMapperConfig DynamoDBMapperConfig
}

/*****************************************************************************/

// Deletes the given object from its DynamoDB table.
func (m *DynamoDBMapper) Delete(v interface{}) (*dynamodb.DeleteItemResult, error) {
	return m.DeleteWithExpression(v, nil)
}

// Deletes the given object from its DynamoDB table using the provided deleteExpression.
func (m *DynamoDBMapper) DeleteWithExpression(v interface{}, expression *DeleteExpression) (*dynamodb.DeleteItemResult, error) {

	model := Marshal(v)

	dir := dynamodb.NewDeleteItemRequest(model.TableName)

	if attr, ok := model.Item[model.HashKey]; ok && !attr.IsEmpty() {
		dir.AddKey(model.HashKey, attr)
	}
	if attr, ok := model.Item[model.RangeKey]; ok && !attr.IsEmpty() {
		dir.AddKey(model.RangeKey, attr)
	}

	if expression != nil {
		dir.ConditionalOperator = expression.ConditionalOperator
		dir.Expected = expression.Expected
	}

	result, err := m.DynamoDBService.DeleteItem(dir)
	if err != nil {
		return nil, err
	}

	return result, nil
}

/*****************************************************************************/

// Loads an object with a hash and, if provided, range key.
func (m *DynamoDBMapper) Load(v interface{}) (*dynamodb.GetItemResult, error) {

	model := Marshal(v)

	gir := dynamodb.NewGetItemRequest(model.TableName)
	gir.ConsistentRead = m.DynamoDBMapperConfig.ConsistentReads == CONSISTANT

	if attr, ok := model.Item[model.HashKey]; ok && !attr.IsEmpty() {
		gir.AddKey(model.HashKey, attr)
	}
	if attr, ok := model.Item[model.RangeKey]; ok && !attr.IsEmpty() {
		gir.AddKey(model.RangeKey, attr)
	}
	/*
		if attr, ok := model.Item[model.IndexHashKey]; ok && !attr.IsEmpty() {
			gir.AddKey(model.IndexHashKey, attr)
		}
		if attr, ok := model.Item[model.IndexRangeKey]; ok && !attr.IsEmpty() {
			gir.AddKey(model.IndexRangeKey, attr)
		}
	*/
	result, err := m.DynamoDBService.GetItem(gir)
	if err != nil {
		return nil, err
	}

	Unmarshal(result.Item, v)

	return result, nil
}

/*****************************************************************************

//
func (m *DynamoDBMapper) Query(request dynamodb.QueryRequest, v interface{}) ([]interface{}, dynamodb.QueryResult, error) {

	return nil, dynamodb.QueryResult{}, nil
}

//
func (m *DynamoDBMapper) QueryWithExpression(request dynamodb.QueryRequest, v interface{}) ([]interface{}, dynamodb.QueryResult, error) {

	return nil, dynamodb.QueryResult{}, nil
}

//
func (m *DynamoDBMapper) QueryCount(request dynamodb.QueryRequest) (int, error) {

	return 0, nil
}
*/
/*****************************************************************************/

// Saves the object given into DynamoDB.
func (m *DynamoDBMapper) Save(v interface{}) error {
	return m.SaveWithExpression(v, nil)
}

// Saves the object given into DynamoDB, the specified saveExpression.
func (m *DynamoDBMapper) SaveWithExpression(v interface{}, expression *SaveExpression) error {

	switch m.DynamoDBMapperConfig.SaveBehavior {
	case CLOBBER:
		return m.saveClobber(v, expression)
	case UPDATE_SKIP_NULL_ATTRIBUTES:
		return m.saveUpdateSkipNullAttributes(v, expression)
	default:
		return m.saveUpdate(v, expression)
	}
}

// CLOBBER will clear and replace all attributes, included unmodeled ones, (delete and recreate) on save.
func (m *DynamoDBMapper) saveClobber(v interface{}, expression *SaveExpression) error {

	model := Marshal(v)

	pir := dynamodb.NewPutItemRequest(model.TableName)

	for k, v := range model.Item {
		if !v.IsEmpty() {
			pir.AddItem(k, v)
		}
	}

	if expression != nil {
		pir.ConditionalOperator = expression.ConditionalOperator
		pir.Expected = expression.Expected
	}

	_, err := m.DynamoDBService.PutItem(pir)
	if err != nil {
		return err
	}

	return nil
}

// UPDATE will not affect unmodeled attributes on a save operation and a null value for the
// modeled attribute will remove it from that item in DynamoDB.
func (m *DynamoDBMapper) saveUpdate(v interface{}, expression *SaveExpression) error {

	model := Marshal(v)

	uir := dynamodb.NewUpdateItemRequest(model.TableName)
	uir.Key = model.Item

	if expression != nil {
		uir.ConditionalOperator = expression.ConditionalOperator
		uir.Expected = expression.Expected
	}

	_, err := m.DynamoDBService.UpdateItem(uir)
	if err != nil {
		return err
	}

	return nil
}

// UPDATE_SKIP_NULL_ATTRIBUTES is similar to UPDATE, except that it ignores any null value attribute(s)
// and will NOT remove them from that item in DynamoDB.
func (m *DynamoDBMapper) saveUpdateSkipNullAttributes(v interface{}, expression *SaveExpression) error {

	model := Marshal(v)

	uir := dynamodb.NewUpdateItemRequest(model.TableName)

	for k, v := range model.Item {
		if !v.IsEmpty() {
			uir.AddKey(k, v)
		}
	}

	if expression != nil {
		uir.ConditionalOperator = expression.ConditionalOperator
		uir.Expected = expression.Expected
	}

	_, err := m.DynamoDBService.UpdateItem(uir)
	if err != nil {
		return err
	}

	return nil
}

/*****************************************************************************

//
func (m *DynamoDBMapper) Scan(request dynamodb.ScanRequest, v interface{}) ([]interface{}, dynamodb.ScanResult, error) {

	return nil, dynamodb.ScanResult{}, nil
}

//
func (m *DynamoDBMapper) ScanWithExpression(request dynamodb.ScanRequest, v interface{}) ([]interface{}, dynamodb.ScanResult, error) {

	return nil, dynamodb.ScanResult{}, nil
}

//
func (m *DynamoDBMapper) ScanCount(request dynamodb.ScanRequest) (int, error) {

	return 0, nil
}
*/

repository: twhello/aws-to-go

repo_name: twhello/aws-to-go


text:
SUMMARY = "Network Appliance - Router packagegroup"
DESCRIPTION = "Network Appliance - Router packagegroup"

LICENSE = "MIT"

inherit packagegroup

PACKAGES = " \
  ${PN}-common \
  ${PN}-firmware \
  ${PN}-utils \
"

RDEPENDS_${PN}-common = " \
  ${PN}-firmware \
  ${PN}-utils \
  crda \
  dnsmasq \
  hostapd \
  iperf3 \
  iw \
  na-router-networkd-config \
  usb-modeswitch \
"

RDEPENDS_${PN}-firmware = " \
  linux-firmware-ath9k \
  linux-firmware-ath10k \
"

RDEPENDS_${PN}-utils = " \
  bind-utils \
  coreutils \
  findutils \
  iputils-ping \
  iputils-tracepath \
  iproute2 \
  less \
  ncurses-terminfo \
  net-tools \
  procps \
  util-linux \
"

repository: macpijan/meta-network-appliance

repo_name: macpijan/meta-network-appliance


text:
DESCRIPTION = "Packagegroup for ECA desktop packages"
LICENSE = "MIT"
PACKAGE_ARCH = "${MACHINE_ARCH}"
DEPENDS = "virtual/kernel"
PR = "r2"

inherit packagegroup

PACKAGES = "\
    ${@base_contains('DISTRO_FEATURES', 'desktop', 'packagegroup-eca-desktop', '', d)} \
"

# Graphical desktop support
# pcmanfm doesn't work on mips
FILEMANAGER ?= "pcmanfm"
FILEMANAGER_mips ?= ""
BROWSER = "chromium"
DESKTOP_APPS="\
    leafpad \
    gaku \
    x11vnc \
    matchbox-terminal \
    sato-screenshot \
    ${FILEMANAGER} \
    ${BROWSER} \
"

SUMMARY_packagegroup-eca-desktop = "ECA graphical desktop support"
RDEPENDS_packagegroup-eca-desktop = "\
    matchbox-desktop \
    matchbox-session-sato \
    matchbox-keyboard \
    matchbox-keyboard-applet \
    matchbox-keyboard-im \
    matchbox-config-gtk \
    xcursor-transparent-theme \
    sato-icon-theme \
    settings-daemon \
    gtk-sato-engine \
    shutdown-desktop \
    libsdl \
    connman-gnome \
    udev-extraconf \
    ${DESKTOP_APPS} \
"


text:
require dtc.inc

LIC_FILES_CHKSUM = "file://GPL;md5=94d55d512a9ba36caa9b7df079bae19f \
		    file://libfdt/libfdt.h;beginline=3;endline=52;md5=fb360963151f8ec2d6c06b055bcbb68c"

SRCREV = "22a65c5331c22979d416738eb756b9541672e00d"

S = "${WORKDIR}/git"

BBCLASSEXTEND = "native nativesdk"

repository: kraj/meta-rockchip

repo_name: kraj/meta-rockchip


text:
@misc{keras,
  title={Keras},
  author={Chollet, Fran\c{c}ois and others},
  year={2015},
  howpublished={\url{https://keras.io}},
}

@misc{T5,
      title={Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer},
      author={Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu},
      year={2020},
      eprint={1910.10683},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}

@misc{tf-survey,
      title={A Survey on Transfer Learning in Natural Language Processing},
      author={Zaid Alyafeai and Maged Saeed AlShaibani and Irfan Ahmad},
      year={2020},
      eprint={2007.04239},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}

@misc{webis_task,
    title= {Touché @ ArgMining21 Frame Identification},
    howpublished = {\url{https://webis.de/events/argmining-21/}},
    note = {Accessed: 2021-08-31},
    author={Khalid Al-Khatib and Yamen Ajjour and Shahbaz Syed and Martin Potthast and Benno Stein},
    year={2021}
}

@misc{bert,
      title={BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding},
      author={Jacob Devlin and Ming-Wei Chang and Kenton Lee and Kristina Toutanova},
      year={2019},
      eprint={1810.04805},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}

@InProceedings{webis_task_paper,
  author =              {Yamen Ajjour and Milad Alshomary and Henning Wachsmuth and Benno Stein},
  booktitle =           {2019 Conference on Empirical Methods in Natural Language Processing and 9th International Joint Conference on Natural Language Processing (EMNLP 2019)},
  editor =              {Kentaro Inui and Jing Jiang and Vincent Ng and Xiaojun Wan},
  ids =                 {stein:2019za},
  month =               nov,
  pages =               {2922-2932},
  publisher =           {ACL},
  site =                {Hong Kong},
  title =               {{Modeling Frames in Argumentation}},
  url =                 {https://www.aclweb.org/anthology/D19-1290},
  year =                2019
}

@inproceedings{rouge,
    title = "{ROUGE}: A Package for Automatic Evaluation of Summaries",
    author = "Lin, Chin-Yew",
    booktitle = "Text Summarization Branches Out",
    month = jul,
    year = "2004",
    address = "Barcelona, Spain",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/W04-1013",
    pages = "74--81",
}

@inproceedings{bert_frame_ident,
author = {Sikos, Jennifer and Padó, Sebastian},
year = {2019},
month = {04},
pages = {},
title = {Frame Identification as Categorization: Exemplars vs Prototypes in Embeddingland},
doi = {10.18653/v1/W19-0425}
}

@article{bert_dataset,
    author = {Das, Dipanjan and Chen, Desai and Martins, André F. T. and Schneider, Nathan and Smith, Noah A.},
    title = "{Frame-Semantic Parsing}",
    journal = {Computational Linguistics},
    volume = {40},
    number = {1},
    pages = {9-56},
    year = {2014},
    month = {03},
    abstract = "{Frame semantics is a linguistic theory that has been instantiated for English in the FrameNet lexicon. We solve the problem of frame-semantic parsing using a two-stage statistical model that takes lexical targets (i.e., content words and phrases) in their sentential contexts and predicts frame-semantic structures. Given a target in context, the first stage disambiguates it to a semantic frame. This model uses latent variables and semi-supervised learning to improve frame disambiguation for targets unseen at training time. The second stage finds the target's locally expressed semantic arguments. At inference time, a fast exact dual decomposition algorithm collectively predicts all the arguments of a frame at once in order to respect declaratively stated linguistic constraints, resulting in qualitatively better structures than naïve local predictors. Both components are feature-based and discriminatively trained on a small set of annotated frame-semantic parses. On the SemEval 2007 benchmark data set, the approach, along with a heuristic identifier of frame-evoking targets, outperforms the prior state of the art by significant margins. Additionally, we present experiments on the much larger FrameNet 1.5 data set. We have released our frame-semantic parser as open-source software.}",
    issn = {0891-2017},
    doi = {10.1162/COLI_a_00163},
    url = {https://doi.org/10.1162/COLI\_a\_00163},
    eprint = {https://direct.mit.edu/coli/article-pdf/40/1/9/1812895/coli\_a\_00163.pdf},
}

@inproceedings{wolf-etal-2020-transformers,
    title = "Transformers: State-of-the-Art Natural Language Processing",
    author = "Thomas Wolf and Lysandre Debut and Victor Sanh and Julien Chaumond and Clement Delangue and Anthony Moi and Pierric Cistac and Tim Rault and Rémi Louf and Morgan Funtowicz and Joe Davison and Sam Shleifer and Patrick von Platen and Clara Ma and Yacine Jernite and Julien Plu and Canwen Xu and Teven Le Scao and Sylvain Gugger and Mariama Drame and Quentin Lhoest and Alexander M. Rush",
    booktitle = "Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations",
    month = oct,
    year = "2020",
    address = "Online",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/2020.emnlp-demos.6",
    pages = "38--45"
}

@misc{chollet2015keras,
  title={Keras},
  author={Chollet, Fran\c{c}ois and others},
  year={2015},
  howpublished={\url{https://keras.io}},
}

@misc{kingma2017adam,
      title={Adam: A Method for Stochastic Optimization},
      author={Diederik P. Kingma and Jimmy Ba},
      year={2017},
      eprint={1412.6980},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}

@article{2019t5,
    author = {Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu},
    title = {Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer},
    journal = {arXiv e-prints},
    year = {2019},
    archivePrefix = {arXiv},
    eprint = {1910.10683},
}


text:
@article{IEEEITST22,
 author = {M. van den Ende and A. Ferrari and  A. Sladen and C. Richard},
 journal = {IEEE Transactions on Intelligent Transportation Systems Transactions},
 note = {Accepted, to be published},
 title = {Deep Deconvolution for Traffic Analysis with Distributed Acoustic Sensing Data},
 year = {2022}
}

repository: andferrari/academic-kickstart

repo_name: andferrari/academic-kickstart


text:
package utils

import (
	"bytes"
	"github.com/PuerkitoBio/goquery"
	"github.com/stretchr/testify/assert"
	"io/ioutil"
	"regexp"
	"testing"
)

func TestParseInt(t *testing.T) {
	assert.Equal(t, int64(1234567890), ParseInt("1.234.567.890"))
}

func TestParseInt2(t *testing.T) {
	pageHTMLBytes, _ := ioutil.ReadFile("../../samples/unversioned/deathstar_price.html")
	doc, _ := goquery.NewDocumentFromReader(bytes.NewReader(pageHTMLBytes))
	title := doc.Find("li.metal").AttrOr("title", "")
	metalStr := regexp.MustCompile(`([\d.]+)`).FindStringSubmatch(title)[1]
	metal := ParseInt(metalStr)
	assert.Equal(t, int64(5000000), metal)

	pageHTMLBytes, _ = ioutil.ReadFile("../../samples/unversioned/mrd_price.html")
	doc, _ = goquery.NewDocumentFromReader(bytes.NewReader(pageHTMLBytes))
	title = doc.Find("li.metal").AttrOr("title", "")
	metalStr = regexp.MustCompile(`([\d.]+)`).FindStringSubmatch(title)[1]
	metal = ParseInt(metalStr)
	assert.Equal(t, int64(1555733200), metal)
}

func TestToInt(t *testing.T) {
	assert.Equal(t, 1234567890, ToInt([]byte("1234567890")))
}

func TestMinInt(t *testing.T) {
	assert.Equal(t, int64(2), MinInt(5, 2, 3))
}

func TestI64Ptr(t *testing.T) {
	v := int64(6)
	assert.Equal(t, &v, I64Ptr(6))
}


text:
# Copyright (C) 2019 Witekio
# Released under the MIT license (see COPYING.MIT for the terms)
DESCRIPTION = "OCI container including the QT Electrical Vehicle Charging Station project and its dependencies"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

IMAGE_INSTALL = " \
    evcs \
    qtlocation \
    qtvirtualkeyboard \
    qtmultimedia \
    fontconfig \
    ttf-dejavu-sans \
    ttf-dejavu-sans-mono \
    ttf-dejavu-sans-condensed \
    ttf-dejavu-serif \
    ttf-dejavu-serif-condensed \
    ttf-dejavu-common \
"

# Container start up file
CONTAINER_STARTUP= "${THISDIR}/files/entry.sh"
# Runc container configuration
RUNC_CONFIG = "${THISDIR}/${MACHINE}/qt-evcs-config.json"
# systemd container configuration
SYSTEMD_CONFIG = "${THISDIR}/files/container-qt-evcs.service"

# Set autostart to 1 if the container should be started automatically by systemd
AUTOSTART = "1"

# Set autoremove to 1 if the container should be removed automatically from the targets for the next update
AUTOREMOVE = "0"

# Set screenused to 1 if the container uses the screen
SCREENUSED = "1"

inherit fullmetalupdate_package_container_image
inherit fullmetalupdate_push_container_to_ostree

branch_name: refs/heads/rocko


text:
// Code generated by go-swagger; DO NOT EDIT.

package smartapp

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"encoding/json"

	strfmt "github.com/go-openapi/strfmt"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/validate"
)

// BasicImagePosition Position of where the image should be rendered within card.
// swagger:model BasicImagePosition
type BasicImagePosition string

const (

	// BasicImagePositionLEFT captures enum value "LEFT"
	BasicImagePositionLEFT BasicImagePosition = "LEFT"

	// BasicImagePositionCENTER captures enum value "CENTER"
	BasicImagePositionCENTER BasicImagePosition = "CENTER"

	// BasicImagePositionRIGHT captures enum value "RIGHT"
	BasicImagePositionRIGHT BasicImagePosition = "RIGHT"
)

// for schema
var basicImagePositionEnum []interface{}

func init() {
	var res []BasicImagePosition
	if err := json.Unmarshal([]byte(`["LEFT","CENTER","RIGHT"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		basicImagePositionEnum = append(basicImagePositionEnum, v)
	}
}

func (m BasicImagePosition) validateBasicImagePositionEnum(path, location string, value BasicImagePosition) error {
	if err := validate.Enum(path, location, value, basicImagePositionEnum); err != nil {
		return err
	}
	return nil
}

// Validate validates this basic image position
func (m BasicImagePosition) Validate(formats strfmt.Registry) error {
	var res []error

	// value enum
	if err := m.validateBasicImagePositionEnum("", "body", m); err != nil {
		return err
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

repository: jeff-blaisdell/smartapp-go

repo_name: jeff-blaisdell/smartapp-go


text:
@inproceedings{ceylan_development_2018,
 address = {Florence},
 author = {Ceylan, Omer and Mishra, Geetesh K. and Yazici, Melik and Cakmakci, Riza C. and Niazi, Javed H. and Qureshi, Anjum and Gurbuz, Yasar},
 booktitle = {2018 IEEE International Symposium on Circuits and Systems (ISCAS)},
 doi = {10.1109/ISCAS.2018.8351593},
 isbn = {978-1-5386-4881-0},
 month = {May},
 pages = {1--5},
 publisher = {IEEE},
 title = {Development of Hand-Held Point-of-Care Diagnostic Device for Detection of Multiple Cancer and Cardiac Disease Biomarkers},
 url = {https://ieeexplore.ieee.org/document/8351593/},
 urldate = {2019-08-14},
 year = {2018}
}

repository: melikyazici/academic-kickstart

repo_name: melikyazici/academic-kickstart


text:
package db

import (
	"fmt"

	"github.com/aywa/goNotify/auth"
	"github.com/aywa/goNotify/config"
	"github.com/aywa/goUtil"
)

var schema = `CREATE TABLE users (
  id SERIAL PRIMARY KEY,
	password  TEXT,
  first_name TEXT,
  last_name TEXT,
  email TEXT UNIQUE NOT NULL
);`

// User is the struct of the user schema
type User struct {
	ID        int    `db:"id" json:"id,omitempty"`
	Password  string `db:"password" json:"password,omitempty"`
	FirstName string `db:"first_name" json:"firstName,omitempty"`
	LastName  string `db:"last_name" json:"lastName,omitempty"`
	Email     string `db:"email" json:"email"`
}

func init() {
	if *config.GetFlag().ShouldInitDb {
		fmt.Println("initialize user table")
		_, err := db.Exec(schema)
		goUtil.ErrorPanic(err)
		CreateUser(&User{FirstName: "Marc", LastName: "Hurabielle", Email: "marc.hurabielle@gmail.com", Password: "secret"})
		CreateUser(&User{FirstName: "Cho", LastName: "Hura", Email: "cho.hurabielle@gmail.com", Password: "secret"})
		people := []User{}
		err = db.Select(&people, "SELECT * FROM users ORDER BY first_name ASC")
		goUtil.ErrorPanic(err)
		for _, p := range people {
			fmt.Println(p)
		}
	}
}

// CreateUser create a user in a db (salt the password too)
func CreateUser(u *User) (err error) {
	u.Password, err = auth.SaltPassword(u.Password)
	goUtil.ErrorHandler(err, goUtil.ErrorLogger)
	tx := db.MustBegin()
	tx.NamedExec("INSERT INTO users (password, first_name, last_name, email) VALUES (:password, :first_name, :last_name, :email)", u)
	err = tx.Commit()
	goUtil.ErrorHandler(err, goUtil.ErrorLogger)
	return err
}

// CheckCredential take a user and check if the password is same as the bd
func CheckCredential(uToCheck User) (uFromBd User, err error) {
	err = db.Get(&uFromBd, "SELECT * FROM users WHERE email=$1", uToCheck.Email)
	goUtil.ErrorHandler(err, goUtil.ErrorLogger)
	return uFromBd, auth.CompareHashAndPassword([]byte(uFromBd.Password), []byte(uToCheck.Password))
}

// GetPrivateUser return a user with private info
func GetPrivateUser(email string) (uFromBd User, err error) {
	err = db.Get(&uFromBd, "SELECT first_name, last_name, email FROM users WHERE email=$1", email)
	return uFromBd, err
}

repository: AyWa/GoStarter

repo_name: AyWa/GoStarter