text:
@article{hanifin2008,
  title={Phenotypic mismatches reveal escape from arms-race coevolution},
  author={Hanifin, Charles T and Brodie Jr, Edmund D and Brodie III, Edmund D},
  journal={PLoS Biology},
  volume={6},
  number={3},
  pages={e60},
  year={2008},
  publisher={Public Library of Science}
}

@article{thompson2017,
  title={Diversification of Trait Combinations in Coevolving Plant and Insect Lineages},
  author={Thompson, John N and Schwind, Christopher and Friberg, Magne},
  journal={The American Naturalist},
  volume={190},
  number={2},
  pages={171--184},
  year={2017},
  publisher={University of Chicago Press Chicago, IL}
}

@article{thompson2002,
  title={Geographic structure and dynamics of coevolutionary selection},
  author={Thompson, John N and Cunningham, Bradley M},
  journal={Nature},
  volume={417},
  number={6890},
  pages={735},
  year={2002},
  publisher={Nature Publishing Group}
}

@article{guimaraes2017,
  title={Indirect effects drive coevolution in mutualistic networks},
  author={Guimar{\~a}es Jr, Paulo R and Pires, Mathias M and Jordano, Pedro and Bascompte, Jordi and Thompson, John N},
  journal={Nature},
  volume={550},
  number={7677},
  pages={511},
  year={2017},
  publisher={Nature Publishing Group}
}

@book{mccann2011,
  title={Food webs},
  author={McCann, Kevin S},
  volume={57},
  year={2011},
  publisher={Princeton University Press}
}

@book{bascompte2013,
  title={Mutualistic networks},
  author={Bascompte, Jordi and Jordano, Pedro},
  volume={70},
  year={2013},
  publisher={Princeton University Press}
}

@article{bascompte2003,
  title={The nested assembly of plant--animal mutualistic networks},
  author={Bascompte, Jordi and Jordano, Pedro and Meli{\'a}n, Carlos J and Olesen, Jens M},
  journal={Proceedings of the National Academy of Sciences},
  volume={100},
  number={16},
  pages={9383--9387},
  year={2003},
  publisher={National Acad Sciences}
}

@article{bezerra2009,
  title={Pollination networks of oil-flowers: a tiny world within the smallest of all worlds},
  author={Bezerra, Elis{\^a}ngela LS and Machado, Isabel C and Mello, Marco AR},
  journal={Journal of Animal Ecology},
  volume={78},
  number={5},
  pages={1096--1101},
  year={2009},
  publisher={Wiley Online Library}
}

@article{almeida2008,
  title={A consistent metric for nestedness analysis in ecological systems: reconciling concept and measurement},
  author={Almeida-Neto, M{\'a}rio and Guimaraes, Paulo and Guimaraes Jr, Paulo R and Loyola, Rafael D and Ulrich, Werner},
  journal={Oikos},
  volume={117},
  number={8},
  pages={1227--1239},
  year={2008},
  publisher={Wiley Online Library}
}

@article{olesen2007,
  title={The modularity of pollination networks},
  author={Olesen, Jens M and Bascompte, Jordi and Dupont, Yoko L and Jordano, Pedro},
  journal={Proceedings of the National Academy of Sciences},
  volume={104},
  number={50},
  pages={19891--19896},
  year={2007},
  publisher={National Acad Sciences}
}

@article{davidson1989,
  title={Competition among ants for myrmecophytes and the significance of plant trichomes},
  author={Davidson, Diane W and Snelling, Roy R and Longino, John T},
  journal={Biotropica},
  pages={64--73},
  year={1989},
  publisher={JSTOR}
}

@article{barber2007,
  title={Modularity and community detection in bipartite networks},
  author={Barber, Michael J},
  journal={Physical Review E},
  volume={76},
  number={6},
  pages={066102},
  year={2007},
  publisher={APS}
}

@article{brockhurst2013,
  title={Experimental coevolution of species interactions},
  author={Brockhurst, Michael A and Koskella, Britt},
  journal={Trends in Ecology \& Evolution},
  volume={28},
  number={6},
  pages={367--375},
  year={2013},
  publisher={Elsevier}
}

@article{gomez2010,
  title={Ecological interactions are evolutionarily conserved across the entire tree of life},
  author={G{\'o}mez, Jos{\'e} M and Verd{\'u}, Miguel and Perfectti, Francisco},
  journal={Nature},
  volume={465},
  number={7300},
  pages={918},
  year={2010},
  publisher={Nature Publishing Group}
}

@article{guimaraes2011,
  title={Evolution and coevolution in mutualistic networks},
  author={Guimar{\~a}es Jr, Paulo R and Jordano, Pedro and Thompson, John N},
  journal={Ecology Letters},
  volume={14},
  number={9},
  pages={877--885},
  year={2011},
  publisher={Wiley Online Library}
}

@article{nuismer2013,
  title={Coevolution and the architecture of mutualistic networks},
  author={Nuismer, Scott L and Jordano, Pedro and Bascompte, Jordi},
  journal={Evolution},
  volume={67},
  number={2},
  pages={338--354},
  year={2013},
  publisher={Wiley Online Library}
}

@article{andreazzi2017,
  title={Network structure and selection asymmetry drive coevolution in species-rich antagonistic interactions},
  author={Andreazzi, Cecilia S and Thompson, John N and Guimar{\~a}es Jr, Paulo R},
  journal={The American Naturalist},
  volume={190},
  number={1},
  pages={99--115},
  year={2017},
  publisher={University of Chicago Press Chicago, IL}
}

@article{nuismer2018,
  title={Coevolution Slows the Disassembly of Mutualistic Networks},
  author={Nuismer, Scott L and Week, Bob and Aizen, Marcelo A},
  journal={The American Naturalist},
  volume={192},
  number={4},
  pages={490--502},
  year={2018},
  publisher={University of Chicago Press Chicago, IL}
}

@article{medeiros2018,
  title={The geographic mosaic of coevolution in mutualistic networks},
  author={Medeiros, Lucas P and Garcia, Guilherme and Thompson, John N and Guimar{\~a}es Jr, Paulo R},
  journal={Proceedings of the National Academy of Sciences},
  volume={},
  number={},
  pages={},
  year={2018},
  publisher={National Acad Sciences}
}

@article{lande1976,
  title={Natural selection and random genetic drift in phenotypic evolution},
  author={Lande, Russell},
  journal={Evolution},
  volume={30},
  number={2},
  pages={314--334},
  year={1976},
  publisher={Wiley Online Library}
}

@article{santamaria2007,
  title={Linkage rules for plant--pollinator networks: trait complementarity or exploitation barriers?},
  author={Santamar{\'i}a, Luis and Rodr{\'i}guez-Giron{\'e}s, Miguel A},
  journal={PLoS Biology},
  volume={5},
  number={2},
  pages={e31},
  year={2007},
  publisher={Public Library of Science}
}

@article{nuismer2010,
  title={When is correlation coevolution?},
  author={Nuismer, Scott L and Gomulkiewicz, Richard and Ridenhour, Benjamin J},
  journal={The American Naturalist},
  volume={175},
  number={5},
  pages={525--537},
  year={2010},
  publisher={The University of Chicago Press}
}

@article{beckett2016,
  title={Improved community detection in weighted bipartite networks},
  author={Beckett, Stephen J},
  journal={Royal Society open science},
  volume={3},
  number={1},
  pages={140536},
  year={2016},
  publisher={The Royal Society Publishing}
}


text:
// Code generated by SQLBoiler 3.6.0 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT.
// This file is meant to be re-generated in place and/or deleted at any time.

package models

import "testing"

// This test suite runs each operation test in parallel.
// Example, if your database has 3 tables, the suite will run:
// table1, table2 and table3 Delete in parallel
// table1, table2 and table3 Insert in parallel, and so forth.
// It does NOT run each operation group in parallel.
// Separating the tests thusly grants avoidance of Postgres deadlocks.
func TestParent(t *testing.T) {
	t.Run("Accounts", testAccounts)
	t.Run("Deposits", testDeposits)
	t.Run("Periods", testPeriods)
	t.Run("Students", testStudents)
	t.Run("Subjects", testSubjects)
	t.Run("Subscriptions", testSubscriptions)
	t.Run("Teachers", testTeachers)
	t.Run("Users", testUsers)
}

func TestDelete(t *testing.T) {
	t.Run("Accounts", testAccountsDelete)
	t.Run("Deposits", testDepositsDelete)
	t.Run("Periods", testPeriodsDelete)
	t.Run("Students", testStudentsDelete)
	t.Run("Subjects", testSubjectsDelete)
	t.Run("Subscriptions", testSubscriptionsDelete)
	t.Run("Teachers", testTeachersDelete)
	t.Run("Users", testUsersDelete)
}

func TestQueryDeleteAll(t *testing.T) {
	t.Run("Accounts", testAccountsQueryDeleteAll)
	t.Run("Deposits", testDepositsQueryDeleteAll)
	t.Run("Periods", testPeriodsQueryDeleteAll)
	t.Run("Students", testStudentsQueryDeleteAll)
	t.Run("Subjects", testSubjectsQueryDeleteAll)
	t.Run("Subscriptions", testSubscriptionsQueryDeleteAll)
	t.Run("Teachers", testTeachersQueryDeleteAll)
	t.Run("Users", testUsersQueryDeleteAll)
}

func TestSliceDeleteAll(t *testing.T) {
	t.Run("Accounts", testAccountsSliceDeleteAll)
	t.Run("Deposits", testDepositsSliceDeleteAll)
	t.Run("Periods", testPeriodsSliceDeleteAll)
	t.Run("Students", testStudentsSliceDeleteAll)
	t.Run("Subjects", testSubjectsSliceDeleteAll)
	t.Run("Subscriptions", testSubscriptionsSliceDeleteAll)
	t.Run("Teachers", testTeachersSliceDeleteAll)
	t.Run("Users", testUsersSliceDeleteAll)
}

func TestExists(t *testing.T) {
	t.Run("Accounts", testAccountsExists)
	t.Run("Deposits", testDepositsExists)
	t.Run("Periods", testPeriodsExists)
	t.Run("Students", testStudentsExists)
	t.Run("Subjects", testSubjectsExists)
	t.Run("Subscriptions", testSubscriptionsExists)
	t.Run("Teachers", testTeachersExists)
	t.Run("Users", testUsersExists)
}

func TestFind(t *testing.T) {
	t.Run("Accounts", testAccountsFind)
	t.Run("Deposits", testDepositsFind)
	t.Run("Periods", testPeriodsFind)
	t.Run("Students", testStudentsFind)
	t.Run("Subjects", testSubjectsFind)
	t.Run("Subscriptions", testSubscriptionsFind)
	t.Run("Teachers", testTeachersFind)
	t.Run("Users", testUsersFind)
}

func TestBind(t *testing.T) {
	t.Run("Accounts", testAccountsBind)
	t.Run("Deposits", testDepositsBind)
	t.Run("Periods", testPeriodsBind)
	t.Run("Students", testStudentsBind)
	t.Run("Subjects", testSubjectsBind)
	t.Run("Subscriptions", testSubscriptionsBind)
	t.Run("Teachers", testTeachersBind)
	t.Run("Users", testUsersBind)
}

func TestOne(t *testing.T) {
	t.Run("Accounts", testAccountsOne)
	t.Run("Deposits", testDepositsOne)
	t.Run("Periods", testPeriodsOne)
	t.Run("Students", testStudentsOne)
	t.Run("Subjects", testSubjectsOne)
	t.Run("Subscriptions", testSubscriptionsOne)
	t.Run("Teachers", testTeachersOne)
	t.Run("Users", testUsersOne)
}

func TestAll(t *testing.T) {
	t.Run("Accounts", testAccountsAll)
	t.Run("Deposits", testDepositsAll)
	t.Run("Periods", testPeriodsAll)
	t.Run("Students", testStudentsAll)
	t.Run("Subjects", testSubjectsAll)
	t.Run("Subscriptions", testSubscriptionsAll)
	t.Run("Teachers", testTeachersAll)
	t.Run("Users", testUsersAll)
}

func TestCount(t *testing.T) {
	t.Run("Accounts", testAccountsCount)
	t.Run("Deposits", testDepositsCount)
	t.Run("Periods", testPeriodsCount)
	t.Run("Students", testStudentsCount)
	t.Run("Subjects", testSubjectsCount)
	t.Run("Subscriptions", testSubscriptionsCount)
	t.Run("Teachers", testTeachersCount)
	t.Run("Users", testUsersCount)
}

func TestInsert(t *testing.T) {
	t.Run("Accounts", testAccountsInsert)
	t.Run("Accounts", testAccountsInsertWhitelist)
	t.Run("Deposits", testDepositsInsert)
	t.Run("Deposits", testDepositsInsertWhitelist)
	t.Run("Periods", testPeriodsInsert)
	t.Run("Periods", testPeriodsInsertWhitelist)
	t.Run("Students", testStudentsInsert)
	t.Run("Students", testStudentsInsertWhitelist)
	t.Run("Subjects", testSubjectsInsert)
	t.Run("Subjects", testSubjectsInsertWhitelist)
	t.Run("Subscriptions", testSubscriptionsInsert)
	t.Run("Subscriptions", testSubscriptionsInsertWhitelist)
	t.Run("Teachers", testTeachersInsert)
	t.Run("Teachers", testTeachersInsertWhitelist)
	t.Run("Users", testUsersInsert)
	t.Run("Users", testUsersInsertWhitelist)
}

// TestToOne tests cannot be run in parallel
// or deadlocks can occur.
func TestToOne(t *testing.T) {
	t.Run("AccountToUserUsingBillingUser", testAccountToOneUserUsingBillingUser)
	t.Run("AccountToUserUsingSignupUser", testAccountToOneUserUsingSignupUser)
	t.Run("DepositToStudentUsingStudent", testDepositToOneStudentUsingStudent)
	t.Run("SubscriptionToPeriodUsingPeriod", testSubscriptionToOnePeriodUsingPeriod)
	t.Run("SubscriptionToStudentUsingStudent", testSubscriptionToOneStudentUsingStudent)
	t.Run("SubscriptionToSubjectUsingSubject", testSubscriptionToOneSubjectUsingSubject)
}

// TestOneToOne tests cannot be run in parallel
// or deadlocks can occur.
func TestOneToOne(t *testing.T) {}

// TestToMany tests cannot be run in parallel
// or deadlocks can occur.
func TestToMany(t *testing.T) {
	t.Run("PeriodToStudents", testPeriodToManyStudents)
	t.Run("PeriodToSubscriptions", testPeriodToManySubscriptions)
	t.Run("StudentToDeposits", testStudentToManyDeposits)
	t.Run("StudentToPeriods", testStudentToManyPeriods)
	t.Run("StudentToSubjects", testStudentToManySubjects)
	t.Run("StudentToSubscriptions", testStudentToManySubscriptions)
	t.Run("SubjectToTeachers", testSubjectToManyTeachers)
	t.Run("SubjectToStudents", testSubjectToManyStudents)
	t.Run("SubjectToSubscriptions", testSubjectToManySubscriptions)
	t.Run("TeacherToSubjects", testTeacherToManySubjects)
	t.Run("UserToBillingUserAccounts", testUserToManyBillingUserAccounts)
	t.Run("UserToSignupUserAccounts", testUserToManySignupUserAccounts)
}

// TestToOneSet tests cannot be run in parallel
// or deadlocks can occur.
func TestToOneSet(t *testing.T) {
	t.Run("AccountToUserUsingBillingUserAccounts", testAccountToOneSetOpUserUsingBillingUser)
	t.Run("AccountToUserUsingSignupUserAccounts", testAccountToOneSetOpUserUsingSignupUser)
	t.Run("DepositToStudentUsingDeposits", testDepositToOneSetOpStudentUsingStudent)
	t.Run("SubscriptionToPeriodUsingSubscriptions", testSubscriptionToOneSetOpPeriodUsingPeriod)
	t.Run("SubscriptionToStudentUsingSubscriptions", testSubscriptionToOneSetOpStudentUsingStudent)
	t.Run("SubscriptionToSubjectUsingSubscriptions", testSubscriptionToOneSetOpSubjectUsingSubject)
}

// TestToOneRemove tests cannot be run in parallel
// or deadlocks can occur.
func TestToOneRemove(t *testing.T) {
	t.Run("AccountToUserUsingBillingUserAccounts", testAccountToOneRemoveOpUserUsingBillingUser)
	t.Run("AccountToUserUsingSignupUserAccounts", testAccountToOneRemoveOpUserUsingSignupUser)
}

// TestOneToOneSet tests cannot be run in parallel
// or deadlocks can occur.
func TestOneToOneSet(t *testing.T) {}

// TestOneToOneRemove tests cannot be run in parallel
// or deadlocks can occur.
func TestOneToOneRemove(t *testing.T) {}

// TestToManyAdd tests cannot be run in parallel
// or deadlocks can occur.
func TestToManyAdd(t *testing.T) {
	t.Run("PeriodToStudents", testPeriodToManyAddOpStudents)
	t.Run("PeriodToSubscriptions", testPeriodToManyAddOpSubscriptions)
	t.Run("StudentToDeposits", testStudentToManyAddOpDeposits)
	t.Run("StudentToPeriods", testStudentToManyAddOpPeriods)
	t.Run("StudentToSubjects", testStudentToManyAddOpSubjects)
	t.Run("StudentToSubscriptions", testStudentToManyAddOpSubscriptions)
	t.Run("SubjectToTeachers", testSubjectToManyAddOpTeachers)
	t.Run("SubjectToStudents", testSubjectToManyAddOpStudents)
	t.Run("SubjectToSubscriptions", testSubjectToManyAddOpSubscriptions)
	t.Run("TeacherToSubjects", testTeacherToManyAddOpSubjects)
	t.Run("UserToBillingUserAccounts", testUserToManyAddOpBillingUserAccounts)
	t.Run("UserToSignupUserAccounts", testUserToManyAddOpSignupUserAccounts)
}

// TestToManySet tests cannot be run in parallel
// or deadlocks can occur.
func TestToManySet(t *testing.T) {
	t.Run("PeriodToStudents", testPeriodToManySetOpStudents)
	t.Run("StudentToPeriods", testStudentToManySetOpPeriods)
	t.Run("StudentToSubjects", testStudentToManySetOpSubjects)
	t.Run("SubjectToTeachers", testSubjectToManySetOpTeachers)
	t.Run("SubjectToStudents", testSubjectToManySetOpStudents)
	t.Run("TeacherToSubjects", testTeacherToManySetOpSubjects)
	t.Run("UserToBillingUserAccounts", testUserToManySetOpBillingUserAccounts)
	t.Run("UserToSignupUserAccounts", testUserToManySetOpSignupUserAccounts)
}

// TestToManyRemove tests cannot be run in parallel
// or deadlocks can occur.
func TestToManyRemove(t *testing.T) {
	t.Run("PeriodToStudents", testPeriodToManyRemoveOpStudents)
	t.Run("StudentToPeriods", testStudentToManyRemoveOpPeriods)
	t.Run("StudentToSubjects", testStudentToManyRemoveOpSubjects)
	t.Run("SubjectToTeachers", testSubjectToManyRemoveOpTeachers)
	t.Run("SubjectToStudents", testSubjectToManyRemoveOpStudents)
	t.Run("TeacherToSubjects", testTeacherToManyRemoveOpSubjects)
	t.Run("UserToBillingUserAccounts", testUserToManyRemoveOpBillingUserAccounts)
	t.Run("UserToSignupUserAccounts", testUserToManyRemoveOpSignupUserAccounts)
}

func TestReload(t *testing.T) {
	t.Run("Accounts", testAccountsReload)
	t.Run("Deposits", testDepositsReload)
	t.Run("Periods", testPeriodsReload)
	t.Run("Students", testStudentsReload)
	t.Run("Subjects", testSubjectsReload)
	t.Run("Subscriptions", testSubscriptionsReload)
	t.Run("Teachers", testTeachersReload)
	t.Run("Users", testUsersReload)
}

func TestReloadAll(t *testing.T) {
	t.Run("Accounts", testAccountsReloadAll)
	t.Run("Deposits", testDepositsReloadAll)
	t.Run("Periods", testPeriodsReloadAll)
	t.Run("Students", testStudentsReloadAll)
	t.Run("Subjects", testSubjectsReloadAll)
	t.Run("Subscriptions", testSubscriptionsReloadAll)
	t.Run("Teachers", testTeachersReloadAll)
	t.Run("Users", testUsersReloadAll)
}

func TestSelect(t *testing.T) {
	t.Run("Accounts", testAccountsSelect)
	t.Run("Deposits", testDepositsSelect)
	t.Run("Periods", testPeriodsSelect)
	t.Run("Students", testStudentsSelect)
	t.Run("Subjects", testSubjectsSelect)
	t.Run("Subscriptions", testSubscriptionsSelect)
	t.Run("Teachers", testTeachersSelect)
	t.Run("Users", testUsersSelect)
}

func TestUpdate(t *testing.T) {
	t.Run("Accounts", testAccountsUpdate)
	t.Run("Deposits", testDepositsUpdate)
	t.Run("Periods", testPeriodsUpdate)
	t.Run("Students", testStudentsUpdate)
	t.Run("Subjects", testSubjectsUpdate)
	t.Run("Subscriptions", testSubscriptionsUpdate)
	t.Run("Teachers", testTeachersUpdate)
	t.Run("Users", testUsersUpdate)
}

func TestSliceUpdateAll(t *testing.T) {
	t.Run("Accounts", testAccountsSliceUpdateAll)
	t.Run("Deposits", testDepositsSliceUpdateAll)
	t.Run("Periods", testPeriodsSliceUpdateAll)
	t.Run("Students", testStudentsSliceUpdateAll)
	t.Run("Subjects", testSubjectsSliceUpdateAll)
	t.Run("Subscriptions", testSubscriptionsSliceUpdateAll)
	t.Run("Teachers", testTeachersSliceUpdateAll)
	t.Run("Users", testUsersSliceUpdateAll)
}

repository: raphaelint/smarthead

license_type: permissive

repo_name: raphaelint/smarthead

branch_name: refs/heads/master

extension: go


text:
/*!minions.css*/
@media @print-query {
.lst-d\@print{list-style-type:disc}
.lst-c\@print{list-style-type:circle}
.lst-s\@print{list-style-type:square}
.lst-l\@print{list-style-type:decimal}
.lst-g\@print{list-style-type:georgian}
.lst-ci\@print{list-style-type:cjk-ideographic}
.lst-k\@print{list-style-type:kannada}
.lst-n\@print{list-style-type:none}
}

license: MIT

extension: css


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{Le2013,
abstract = {We consider the problem of building high-level, class-specific feature detectors from only unlabeled data. For example, is it possible to learn a face detector using only unlabeled images? To answer this, we train a deep sparse autoencoder on a large dataset of images (the model has 1 billion connections, the dataset has 10 million 200×200 pixel images downloaded from the Internet). We train this network using model parallelism and asynchronous SGD on a cluster with 1,000 machines (16,000 cores) for three days. Contrary to what appears to be a widely-held intuition, our experimental results reveal that it is possible to train a face detector without having to label images as containing a face or not. Control experiments show that this feature detector is robust not only to translation but also to scaling and out-of-plane rotation. We also find that the same network is sensitive to other high-level concepts such as cat faces and human bodies. Starting from these learned features, we trained our network to recognize 22,000 object categories from ImageNet and achieve a leap of 70{\%} relative improvement over the previous state-of-the-art.},
archivePrefix = {arXiv},
arxivId = {1112.6209v5},
author = {Le, Quoc V.},
doi = {10.1109/ICASSP.2013.6639343},
eprint = {1112.6209v5},
file = {:Users/sepmein/Qsync/Papers/Le{\_}2013{\_}Building high-level features using large scale unsupervised learning.pdf:pdf},
isbn = {978-1-4799-0356-6},
issn = {1520-6149},
journal = {2013 IEEE International Conference on Acoustics, Speech and Signal Processing},
pages = {8595--8598},
pmid = {20957573},
title = {{Building high-level features using large scale unsupervised learning}},
url = {http://ieeexplore.ieee.org/document/6639343/},
year = {2013}
}

license: Unlicense

repository: sepmein/references

repo_name: sepmein/references

extension: bib


text:
package oauth2client

import (
	"time"
)

// Definition for OAuth2 token type.
// Referenced from https://godoc.org/golang.org/x/oauth2#Token
type Token struct {
	// AccessToken is the token that authorizes and authenticates
	// the requests.
	AccessToken string `json:"access_token"`

	// TokenType is the type of token.
	// The Type method returns either this or "Bearer", the default.
	TokenType string `json:"token_type,omitempty"`

	// RefreshToken is a token that's used by the application
	// (as opposed to the user) to refresh the access token
	// if it expires.
	RefreshToken string `json:"refresh_token,omitempty"`

	// Expiry is the optional expiration time of the access token.
	//
	// If zero, TokenSource implementations will reuse the same
	// token forever and RefreshToken or equivalent
	// mechanisms for that TokenSource will not be used.
	Expiry time.Time `json:"expiry,omitempty"`
	// contains filtered or unexported fields

	// ExpiresIn is the optional expiration time in seconds.
	ExpiresIn *int `json:"expires_in,omitempty"`
}


text:
@article{PhysRevB.77.014511,
 author = {Lamacraft, A. and Marchetti, F. M.},
 bdsk-url-1 = {https://link.aps.org/doi/10.1103/PhysRevB.77.014511},
 bdsk-url-2 = {https://doi.org/10.1103/PhysRevB.77.014511},
 date-added = {2019-11-02 22:08:03 +0000},
 date-modified = {2019-11-02 22:08:03 +0000},
 doi = {10.1103/PhysRevB.77.014511},
 issue = {1},
 journal = {Phys. Rev. B},
 month = {Jan},
 numpages = {5},
 pages = {014511},
 publisher = {American Physical Society},
 title = {Spinodal decomposition in polarized Fermi superfluids},
 url = {https://link.aps.org/doi/10.1103/PhysRevB.77.014511},
 volume = {77},
 year = {2008}
}

repository: AustenLamacraft/dooftown

repo_name: AustenLamacraft/dooftown


text:
package updater

import (
	"context"
	"errors"
	"testing"

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

type mockReleaseLocator struct {
	mock.Mock
}

func (m *mockReleaseLocator) ListReleases(ctx context.Context, amount int) ([]Release, error) {
	args := m.Called(ctx, amount)
	arg0 := args.Get(0)
	if arg0 == nil {
		return nil, args.Error(1)
	}

	return arg0.([]Release), args.Error(1)
}

func TestStableRelease(t *testing.T) {
	assert.False(t, StableRelease("foo", true, false))
	assert.False(t, StableRelease("foo", false, true))
	assert.False(t, StableRelease("foo", true, true))
	assert.True(t, StableRelease("foo", false, false))
}

func TestLatestRelease(t *testing.T) {
	locator := new(mockReleaseLocator)
	locator.On("ListReleases", mock.Anything, mock.Anything).Return(nil, ErrNoRepository)

	_, err := LatestRelease(context.Background(), locator)
	require.Error(t, err)
	assert.NotEqual(t, ErrNoRepository, err)
	assert.Equal(t, ErrNoRepository, errors.Unwrap(err))
}

repository: hellofresh/updater-go

repo_name: hellofresh/updater-go

gha_license_id: MIT

gha_language: Go


text:
require xorg-lib-common.inc
DESCRIPTION = "X11 Resize and Rotate extension library"
LICENSE = "BSD-X"
DEPENDS += "randrproto libxrender libxext"
PE = "1"
PR = "${INC_PR}.0"

SRC_URI[archive.md5sum] = "7785c3f7cff2735c94657e8f87ed8ad3"
SRC_URI[archive.sha256sum] = "62bba708649c04cbbc2f5de910942a01cc727b27225bc06169af8a89b957c661"

BBCLASSEXTEND = "nativesdk"

XORG_PN = "libXrandr"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD

extension: bb


text:
package doc

import (
	"strings"

	"github.com/bwmarrin/discordgo"
	"github.com/ikkerens/gophbot/wizard"
)

type CommandList struct {
}

func (*CommandList) Embed(*wizard.Session) *discordgo.MessageEmbed {
	panic("implement me")
}

func (*CommandList) Buttons(*wizard.Session) []string {
	panic("implement me")
}

func (*CommandList) FireButton(*wizard.Session, string) {
	panic("implement me")
}

type CommandDetail struct {
	Command     string
	Description string
	Aliases     []string
	Usage       string
	Flags       map[string]string
}

func (c *CommandDetail) Embed(s *wizard.Session) *discordgo.MessageEmbed {
	fields := make([]*discordgo.MessageEmbedField, 0, len(c.Flags)+1)
	if len(c.Aliases) != 0 {
		fields = append(fields, &discordgo.MessageEmbedField{
			Name:  "Aliases",
			Value: strings.Join(c.Aliases, ", "),
		})
	}

	if c.Flags != nil {
		for f, d := range c.Flags {
			fields = append(fields, &discordgo.MessageEmbedField{
				Inline: true,
				Name:   f,
				Value:  d,
			})
		}
	}

	return makeDefaultHelpPage(&discordgo.MessageEmbed{
		Title:       "Command " + c.Command,
		Description: c.Description,
		Fields:      fields,
	})
}

func (*CommandDetail) Buttons(*wizard.Session) []string {
	return noButtons
}

func (*CommandDetail) FireButton(*wizard.Session, string) {}

repository: ikkerens/gophbot

repo_name: ikkerens/gophbot


text:
DESCRIPTION = "Tau Labs SPI simple logger"
AUTHOR = "James Cotton"
LICENSE = "GPLv3"
LIC_FILES_CHKSUM = "file://COPYING;md5=f27defe1e96c2e1ecd4e0c9be8967949"
PR = "r1"
SRC_URI = "git://github.com/TauLabs/overo-datalogger.git;protocol=git"
SRCREV = "master"

S = "${WORKDIR}/git"

do_compile () {
  ${CC} ${CFLAGS} -I${S}/simple_logger ${LDFLAGS} -o ${S}/simple_logger/simple_logger ${S}/simple_logger/*.c
}

do_install () {
  install -d ${D}${bindir}/
  install -m 0755 ${S}/simple_logger/simple_logger ${D}${bindir}/
}
FILES_${PN} = "${bindir}/simple_logger"

repository: rghunter/meta-taulabs-datalogger

repo_name: rghunter/meta-taulabs-datalogger


text:
PR = "r1"
LICENSE = "GPL"
inherit gpe pkgconfig

DEPENDS = "gtk+ libgpewidget libxsettings libxsettings-client pcmcia-cs xst xset ipaq-sleep ntp"
RDEPENDS = "xset xst ipaq-sleep ntpdate"
SECTION = "gpe"
PRIORITY = "optional"
FILES_${PN} = "${sysconfdir} ${bindir} ${datadir}/pixmaps ${datadir}/applications"
FILES_${PN} += " ${datadir}/gpe/pixmaps"

do_compile () {
	oe_runmake PREFIX=${prefix}
	oe_runmake all-desktop PREFIX=${prefix}
}

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

repository: Terentyev/familiar-linux

repo_name: Terentyev/familiar-linux


text:
package cpu

// Register8 is a 8bit register
type Register8 struct {
	data byte
}

// rotateLeft rotates the register to the left
func (r *Register8) rotateLeft() {
	r.data = (r.data << 1) | (r.data >> 7)
}

// rotateRight rotates the register to the right
func (r *Register8) rotateRight() {
	r.data = (r.data >> 1) | (r.data << 7)
}

// set the register's data
func (r *Register8) set(data byte) {
	r.data = data
}

// get the register's data
func (r *Register8) get() byte {
	return r.data
}

// increment by 1
func (r *Register8) increment() {
	r.data++
}

// decrement by 1
func (r *Register8) decrement() {
	r.data--
}

repository: moshenahmias/gopherboy

repo_name: moshenahmias/gopherboy


text:
require gpe-nmf.inc

RDEPENDS_${PN} += "gst-plugin-decodebin"
RRECOMMENDS_${PN} += "gst-plugin-ivorbis gst-plugin-tcp"
PR = "r4"

SRC_URI += " file://playlist-segfault.patch;striplevel=0 \
             file://fix-includepath.patch"

do_compile() {
        oe_runmake PREFIX=${prefix} GST_VERSION="0.8"
}

SRC_URI[md5sum] = "c19ffe9fc19508c4b4fe82d322e926e2"
SRC_URI[sha256sum] = "5ec530b1b0dc1b68d455106cf5b40e82bbda92448171a56c13b939e06701ac21"


text:
package main

import (
	"errors"
	"net/http"

	"github.com/Sirupsen/logrus"
	"github.com/fsnotify/fsnotify"
	"github.com/gorilla/mux"
)

// GalleryServer
type GalleryServer struct {
	dispatcher *mux.Router
	watcher    *fsnotify.Watcher
	dirs       []string
}

func NewGalleryServer() (*GalleryServer, error) {
	watcher, err := fsnotify.NewWatcher()
	if err != nil {
		return nil, err
	}
	return &GalleryServer{
		dispatcher: mux.NewRouter(),
		watcher:    watcher,
		dirs:       make([]string, 0, 4),
	}, nil
}

// ServeHTTP implements an http.Handler that answers HTTP requests
func (s *GalleryServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	s.dispatcher.ServeHTTP(w, r)
}

// TODO(arkbriar@gmail.com) Provide a function to register JS file, like hugo.
// Or we can just use hugo as our engine.

func (s *GalleryServer) WatchGalleryDir(dir string) error {
	s.dirs = append(s.dirs, dir)
	return s.watcher.Add(dir)
}

func (s *GalleryServer) handleFSEvents() {
	defer s.watcher.Close()
	for {
		select {
		case event := <-s.watcher.Events:
			logrus.Debugln("fs event: ", event)
			if err := s.scanDirs(); err != nil {
				logrus.Errorln(err)
			}
		case err := <-s.watcher.Errors:
			logrus.Errorln("error: ", err)
		}
	}
}

func (s *GalleryServer) scanDirs() error {
	if len(s.dirs) == 0 {
		return errors.New("no dirs watched")
	}
	// TODO(arkbriar@gmail.com) Register js file and render the photo list.
}

func (s *GalleryServer) Start() error {
	if err := s.scanDirs(); err != nil {
		return err
	}
	done := make(chan bool)
	go s.handleFSEvents()
	<-done
}

repository: arkbriar/gallery

repo_name: arkbriar/gallery


text:
package models
import (
    "errors"
)
// Indicates the type of app that a VPN traffic rule is associated with.
type VpnTrafficRuleAppType int

const (
    // The traffic rule is not associated with an app.
    NONE_VPNTRAFFICRULEAPPTYPE VpnTrafficRuleAppType = iota
    // The traffic rule is associated with a desktop app.
    DESKTOP_VPNTRAFFICRULEAPPTYPE
    // The traffic rule is associated with a Universal app.
    UNIVERSAL_VPNTRAFFICRULEAPPTYPE
)

func (i VpnTrafficRuleAppType) String() string {
    return []string{"none", "desktop", "universal"}[i]
}
func ParseVpnTrafficRuleAppType(v string) (any, error) {
    result := NONE_VPNTRAFFICRULEAPPTYPE
    switch v {
        case "none":
            result = NONE_VPNTRAFFICRULEAPPTYPE
        case "desktop":
            result = DESKTOP_VPNTRAFFICRULEAPPTYPE
        case "universal":
            result = UNIVERSAL_VPNTRAFFICRULEAPPTYPE
        default:
            return 0, errors.New("Unknown VpnTrafficRuleAppType value: " + v)
    }
    return &result, nil
}
func SerializeVpnTrafficRuleAppType(values []VpnTrafficRuleAppType) []string {
    result := make([]string, len(values))
    for i, v := range values {
        result[i] = v.String()
    }
    return result
}

repository: microsoftgraph/msgraph-beta-sdk-go

repo_name: microsoftgraph/msgraph-beta-sdk-go

branch_name: refs/heads/main


text:
package models

import (
	"encoding/json"
	"fmt"
	"time"

	"github.com/jinzhu/gorm"
	"github.com/netlify/gocommerce/calculator"
	"github.com/pborman/uuid"
	"github.com/pkg/errors"
	"github.com/sirupsen/logrus"
)

// PendingState is the pending state of an Order
const PendingState = "pending"

// PaidState is the paid state of an Order
const PaidState = "paid"

// ShippingState is the shipping state of an order
const ShippingState = "shipping"

// ShippedState is the shipped state of an Order
const ShippedState = "shipped"

// FailedState is the failed state of an Order
const FailedState = "failed"

// PaymentState are the possible values for the PaymentState field
var PaymentStates = []string{
	PendingState,
	PaidState,
	FailedState,
}

// FulfillmentStates are the possible values for the FulfillmentState field
var FulfillmentStates = []string{
	PendingState,
	ShippingState,
	ShippedState,
}

// NumberType | StringType | BoolType are the different types supported in custom data for orders
const (
	NumberType = iota
	StringType
	BoolType
)

// Order model
type Order struct {
	InstanceID    string `json:"-" sql:"index"`
	ID            string `json:"id"`
	InvoiceNumber int64  `json:"invoice_number,omitempty"`

	IP string `json:"ip"`

	User      *User  `json:"user,omitempty"`
	UserID    string `json:"user_id,omitempty"`
	SessionID string `json:"-"`

	Email string `json:"email"`

	LineItems []*LineItem `json:"line_items"`

	Downloads []Download `json:"downloads"`

	Currency string `json:"currency"`
	Taxes    float64 `json:"taxes"`
	Shipping float64 `json:"shipping"`
	SubTotal float64 `json:"subtotal"`
	Discount float64 `json:"discount"`
	NetTotal float64 `json:"net_total"`

	Total float64 `json:"total"`

	PaymentState     string `json:"payment_state"`
	FulfillmentState string `json:"fulfillment_state"`
	State            string `json:"state"`

	PaymentProcessor string `json:"payment_processor"`

	Transactions []*Transaction `json:"transactions"`
	Notes        []*OrderNote   `json:"notes"`

	ShippingAddress   Address `json:"shipping_address" gorm:"ForeignKey:ShippingAddressID"`
	ShippingAddressID string  `json:"shipping_address_id"`

	BillingAddress   Address `json:"billing_address" gorm:"ForeignKey:BillingAddressID"`
	BillingAddressID string  `json:"billing_address_id"`

	VATNumber string `json:"vatnumber"`

	MetaData    map[string]interface{} `sql:"-" json:"meta"`
	RawMetaData string                 `json:"-" sql:"type:text"`

	CouponCode string `json:"coupon_code,omitempty"`

	Coupon    *Coupon `json:"coupon,omitempty" sql:"-"`
	RawCoupon string  `json:"-" sql:"type:text"`

	CreatedAt time.Time  `json:"created_at" sql:"index"`
	UpdatedAt time.Time  `json:"updated_at"`
	DeletedAt *time.Time `json:"-" sql:"index"`
}

// TableName returns the database table name for the Order model.
func (Order) TableName() string {
	return tableName("orders")
}

// AfterFind database callback.
func (o *Order) AfterFind() error {
	if o.RawMetaData != "" {
		err := json.Unmarshal([]byte(o.RawMetaData), &o.MetaData)
		if err != nil {
			return err
		}
	}
	if o.RawCoupon != "" {
		o.Coupon = &Coupon{}
		err := json.Unmarshal([]byte(o.RawCoupon), &o.Coupon)
		if err != nil {
			return err
		}
	}

	return nil
}

// BeforeSave database callback.
func (o *Order) BeforeSave() error {
	if o.MetaData != nil {
		data, err := json.Marshal(o.MetaData)
		if err != nil {
			return err
		}
		o.RawMetaData = string(data)
	}
	if o.Coupon != nil {
		data, err := json.Marshal(o.Coupon)
		if err != nil {
			return err
		}
		o.RawCoupon = string(data)
	}

	return nil
}

// NewOrder creates a new pending Order.
func NewOrder(instanceID, sessionID, email, currency string) *Order {
	order := &Order{
		InstanceID: instanceID,
		ID:         uuid.NewRandom().String(),
		SessionID:  sessionID,
		Email:      email,
		Currency:   currency,
	}
	order.PaymentState = PendingState
	order.FulfillmentState = PendingState
	order.State = PendingState
	return order
}

// CalculateTotal calculates the total price of an Order.
func (o *Order) CalculateTotal(settings *calculator.Settings, claims map[string]interface{}, log logrus.FieldLogger) {
	items := make([]calculator.Item, len(o.LineItems))
	for i, item := range o.LineItems {
		items[i] = item
	}

	params := calculator.PriceParameters{o.ShippingAddress.Country, o.Currency, o.Coupon, items}
	price := calculator.CalculatePrice(settings, claims, params, log)

	o.SubTotal = price.Subtotal
	o.Taxes = price.Taxes
	o.Discount = price.Discount
	o.NetTotal = price.NetTotal

	// apply price details to line items
	for i, item := range price.Items {
		o.LineItems[i].CalculationDetail = &CalculationDetail{
			Discount: item.Discount,
			Subtotal: item.Subtotal,
			NetTotal: item.NetTotal,
			Taxes:    item.Taxes,
			Total:    item.Total,
		}

		for _, discount := range item.DiscountItems {
			discount := DiscountItem{
				DiscountItem: discount,
			}
			o.LineItems[i].CalculationDetail.DiscountItems = append(o.LineItems[i].CalculationDetail.DiscountItems, discount)
		}
	}

	if price.Total > 0 {
		o.Total = float64(price.Total)
	}
}

func (o *Order) BeforeDelete(tx *gorm.DB) error {
	cascadeModels := map[string]interface{}{
		"line item": &[]LineItem{},
	}
	for name, cm := range cascadeModels {
		if err := cascadeDelete(tx, "order_id = ?", o.ID, name, cm); err != nil {
			return err
		}
	}

	delModels := map[string]interface{}{
		"event":       Event{},
		"transaction": Transaction{},
		"download":    Download{},
	}
	for name, dm := range delModels {
		if result := tx.Delete(dm, "order_id = ?", o.ID); result.Error != nil {
			return errors.Wrap(result.Error, fmt.Sprintf("Error deleting %s records", name))
		}
	}
	return nil
}

repository: divyashie/gocommerce

repo_name: divyashie/gocommerce


text:
############################################################################
# Copyright (c) 2016, Johan Mabille and Sylvain Corlay                     #
# xtensor-fftw: Copyright (c) 2017, Patrick Bos                            #
#                                                                          #
# Distributed under the terms of the BSD 3-Clause License.                 #
#                                                                          #
# The full license is in the file LICENSE, distributed with this software. #
############################################################################

# xtensor-fftw cmake module
# This module sets the following variables in your project::
#
#   xtensor-fftw_FOUND - true if xtensor-fftw found on the system
#   xtensor-fftw_INCLUDE_DIRS - the directory containing xtensor-fftw headers
#   xtensor-fftw_LIBRARY - empty

@PACKAGE_INIT@

if(FFTW_USE_FLOAT)
    add_definitions(-DXTENSOR_FFTW_USE_FLOAT)
endif()

if(FFTW_USE_DOUBLE)
    add_definitions(-DXTENSOR_FFTW_USE_DOUBLE)
endif()

if(FFTW_USE_LONG_DOUBLE AND NOT MSVC)
    add_definitions(-DXTENSOR_FFTW_USE_LONG_DOUBLE)
endif()

if(NOT FFTW_USE_FLOAT AND NOT FFTW_USE_DOUBLE AND NOT FFTW_USE_LONG_DOUBLE)
    message(FATAL_ERROR "Please, select at least one of the available FFTW type libraries")
endif()

set(PN xtensor-fftw)
set_and_check(${PN}_INCLUDE_DIRS "${PACKAGE_PREFIX_DIR}/@CMAKE_INSTALL_INCLUDEDIR@")
set(${PN}_LIBRARY "")
check_required_components(${PN})

repository: xtensor-stack/xtensor-fftw

repo_name: xtensor-stack/xtensor-fftw

gha_language: Jupyter Notebook

extension: in


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

%% Created for Songqing Chen at 2014-01-30 09:38:14 -0500

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

@misc{skype,
title="{Skype}",
howpublished={\url{http://www.skype.com/en/}}
}

@misc{qq,
title="{Tencent QQ}",
howpublished={\url{http://www.qq.com/}}
}

@misc{facetime,
title="{Apple Facetime}",
howpublished={\url{https://www.apple.com/mac/facetime/}}
}

@misc{monsoon,
title="{Monsoon Power Monitor}",
howpublished={\url{http://www.msoon.com/LabEquipment/PowerMonitor/}}
}

@misc{ffmpeg,
title="{FFmpeg}",
howpublished={\url{http://www.ffmpeg.org/}}
}

@misc{opengles,
title="{OpenGL ES}",
howpublished={\url{http://www.khronos.org/opengles/}}
}

@misc{webrtcstandard,
title="{WebRTC Standard}",
howpublished={\url{http://w3c.github.io/webrtc-pc/}}
}

@misc{webrtcproject,
title="{WebRTC Project}",
howpublished={\url{http://www.webrtc.org/}}
}

@misc{youtube-watch-mobile,
title="{YouTube Statistics}",
howpublished={\url{http://www.youtube.com/yt/press/statistics.html}}
}

@misc{youtube-storyboard,
title="{YouTube player adds Netflix-like storyboard feature for easier navigation}",
howpublished={\url{http://venturebeat.com/2012/01/13/youtube-player-storyboard-thumbnail-feature/}}
}

@misc{yuv2rgb,
 title = {{C}olor {C}onversion},
 howpublished = {\url{http://www.equasys.de/colorconversion.html}},
}

@article{pasricha2004dynamic,
	title={Dynamic backlight adaptation for low-power handheld devices},
	author={Pasricha, Sudeep and Luthra, Manev and Mohapatra, Shivajit and Dutt, Nikil and Venkatasubramanian, Nalini},
	journal={IEEE design \& test of computers},
	number={5},
	pages={398--405},
	year={2004},
	publisher={IEEE}
}

@article{iranli2006hvs,
	title={HVS-aware dynamic backlight scaling in TFT-LCDs},
	author={Iranli, Ali and Lee, Wonbok and Pedram, Massoud},
	journal={Very Large Scale Integration (VLSI) Systems, IEEE Transactions on},
	volume={14},
	number={10},
	pages={1103--1116},
	year={2006},
	publisher={IEEE}
}

@INPROCEEDINGS{6848080,
	author={Chenguang Yu and Yang Xu and Bo Liu and Yong Liu},
	booktitle={INFOCOM, 2014 Proceedings IEEE},
	title={``Can you SEE me now?'' A measurement study of mobile video calls},
	year={2014},
	month={April},
	pages={1456-1464},
	keywords={cellular radio;mobile radio;teleconferencing;telephony;wireless LAN;Face-Time;Google Plus Hangout;Skype;WiFi;cellular links;mobile video calls;video conferencing;video telephony;Computers;Delays;IEEE 802.11 Standards;Mobile communication;Packet loss;Smart phones},
	doi={10.1109/INFOCOM.2014.6848080},
	url={}}

@inproceedings{AG10,
 author = {Carroll, Aaron and Heiser, Gernot},
 title = {An Analysis of Power Consumption in a Smartphone},
 booktitle = {Proceedings of the 2010 USENIX Conference on USENIX Annual Technical Conference},
 series = {USENIXATC'10},
 year = {2010},
 location = {Boston, MA},
 pages = {21--21},
 numpages = {1},
 url = {http://dl.acm.org/citation.cfm?id=1855840.1855861},
 acmid = {1855861},
 publisher = {USENIX Association},
 address = {Berkeley, CA, USA},
}

@article{CAD,
  author = {Liu, Yao and Xiao, Mengbai and Zhang, Ming and Li, Xin and Dong, Mian and Ma, Zhan and Li, Zhenhua and Chen, Songqing},
  date = {2015-03-20},
  journal = {NOSSDAV 2015},
  title = {Content-Adaptive Display Power Saving in Internet Mobile Streaming},
  year = 2015
}

@article{CCS06,
  added-at = {2006-08-23T00:00:00.000+0200},
  author = {Chang, Naehyuck and Choi, Inseok and Shim, Hojun},
  biburl = {http://www.bibsonomy.org/bibtex/2841858e3af84495977d6460797047c47/dblp},
  date = {2006-08-23},
  description = {dblp},
  ee = {http://doi.ieeecomputersociety.org/10.1109/TVLSI.2004.831472},
  interhash = {ac3d63ce3eab7ddaa385a4f10a34a930},
  intrahash = {841858e3af84495977d6460797047c47},
  journal = {IEEE Trans. VLSI Syst.},
  keywords = {dblp},
  number = 8,
  pages = {837-846},
  timestamp = {2006-08-23T00:00:00.000+0200},
  title = {DLS: dynamic backlight luminance scaling of liquid crystal display.},
  url = {http://dblp.uni-trier.de/db/journals/tvlsi/tvlsi12.html#ChangCS04},
  volume = 12,
  year = 2004
}

@inproceedings{CHP07,
  added-at = {2007-04-12T13:20:31.000+0200},
  author = {Cheng, W. and Hou, Y. and Pedram, M.},
  biburl = {http://www.bibsonomy.org/bibtex/2545f26d1070b95d2299d81ee03222665/derkling},
  booktitle = {Design Automation Conference},
  interhash = {bad2b5ecf2e33c19f669bf37590857bd},
  intrahash = {545f26d1070b95d2299d81ee03222665},
  keywords = {Case DATE Embedded Low Power Software study},
  local = {./AllPapers/2004_DATE_cheng2004power.pdf},
  timestamp = {2007-04-12T13:20:31.000+0200},
  title = {Power Minimization in a Backlit TFT-LCD Display by Concurrent Brightness and Contrast Scaling},
  url = {http://date.eda-online.co.uk/proceedings/papers/2004/date04/pdffiles/03a_4.pdf},
  year = 2004
}

@inproceedings{CSC02,
 author = {Choi, Inseok and Shim, Hojun and Chang, Naehyuck},
 title = {Low-power Color TFT LCD Display for Hand-held Embedded Systems},
 booktitle = {Proceedings of the 2002 International Symposium on Low Power Electronics and Design},
 series = {ISLPED '02},
 year = {2002},
 isbn = {1-58113-475-4},
 location = {Monterey, California, USA},
 pages = {112--117},
 numpages = {6},
 url = {http://doi.acm.org/10.1145/566408.566440},
 doi = {10.1145/566408.566440},
 acmid = {566440},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {LCD, embedded system, low energy, low power},
}

@INPROCEEDINGS{PMLDV03,
    author = {Sudeep Pasricha and Shivajit Mohapatra and Manev Luthra and Nikil Dutt and Nalini Venkatasubramanian},
    title = {Reducing Backlight Power Consumption for Streaming Video Applications on Mobile Handheld Devices},
    booktitle = {In Proc. First Workshop Embedded Systems for Real-Time Multimedia},
    year = {2003},
    pages = {11--17}
}

@article{LHH14,
  author    = {Chun-Han Lin and Pi-Cheng Hsiu and Cheng-Kang Hsieh},
  title     = {Dynamic Backlight Scaling Optimization: {A} Cloud-Based Energy-Saving
               Service for Mobile Streaming Applications},
  journal   = {{IEEE} Trans. Computers},
  volume    = {63},
  number    = {2},
  pages     = {335--348},
  year      = {2014},
  url       = {http://doi.ieeecomputersociety.org/10.1109/TC.2012.210},
  doi       = {10.1109/TC.2012.210},
  timestamp = {Wed, 20 Nov 4449709 19:44:16 +},
  biburl    = {http://dblp.uni-trier.de/rec/bib/journals/tc/LinHH14},
  bibsource = {dblp computer science bibliography, http://dblp.org}
}

@inproceedings{RBB08,
 author = {Ruggiero, Martino and Bartolini, Andrea and Benini, Luca},
 title = {DBS4Video: Dynamic Luminance Backlight Scaling Based on Multi-histogram Frame Characterization for Video Streaming Application},
 booktitle = {Proceedings of the 8th ACM International Conference on Embedded Software},
 series = {EMSOFT '08},
 year = {2008},
 isbn = {978-1-60558-468-3},
 location = {Atlanta, GA, USA},
 pages = {109--118},
 numpages = {10},
 url = {http://doi.acm.org/10.1145/1450058.1450074},
 doi = {10.1145/1450058.1450074},
 acmid = {1450074},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {backlight scaling, display, lcd, power management, video streaming},
}

@article{CMEDV07,
 author = {Cheng, Liang and Mohapatra, Shivajit and El Zarki, Magda and Dutt, Nikil and Venkatasubramanian, Nalini},
 title = {Quality-based Backlight Optimization for Video Playback on Handheld Devices},
 journal = {Adv. MultiMedia},
 issue_date = {January 2007},
 volume = {2007},
 number = {1},
 month = jan,
 year = {2007},
 issn = {1687-5680},
 pages = {4--4},
 numpages = {1},
 url = {http://dx.doi.org/10.1155/2007/83715},
 doi = {10.1155/2007/83715},
 acmid = {1317013},
 publisher = {Hindawi Publishing Corp.},
 address = {New York, NY, United States},
}

@ARTICLE{LR12,
  author={Loreto, S. and Romano, Simon Pietro},
  journal={Internet Computing, IEEE},
  title={Real-Time Communications in the Web: Issues, Achievements, and Ongoing Standardization Efforts},
  year={2012},
  month={Sept},
  volume={16},
  number={5},
  pages={68-73},
  keywords={Internet;application program interfaces;online front-ends;peer-to-peer computing;protocols;API;IETF RTCWeb working group;W3C WebRTC working groups;Web real-time communication;communication protocols;next-generation Web browsers;peer-to-peer fashion;Communication systems;Internet telephony;Next generation networking;Protocols;Real-time systems;Web services;P2P;VoIP;WebRTC},
  doi={10.1109/MIC.2012.115},
  ISSN={1089-7801},
}
@INPROCEEDINGS{HLH11,
  author={Pi-Cheng Hsiu and Chun-Han Lin and Cheng-Kang Hsieh},
  booktitle={Low Power Electronics and Design (ISLPED) 2011 International Symposium on},
  title={Dynamic backlight scaling optimization for mobile streaming applications},
  year={2011},
  month={Aug},
  pages={309-314},
  keywords={dynamic programming;mobile radio;video streaming;dynamic backlight scaling optimization;dynamic-programming algorithm;mobile devices;mobile streaming;multimedia streaming;video streaming;Energy consumption;Heuristic algorithms;Indexes;Mobile communication;Mobile handsets;Servers;Streaming media;Energy-efficient optimization;dynamic backlight scaling;mobile devices;multimedia streaming applications},
  doi={10.1109/ISLPED.2011.5993655},
  ISSN={Pending},
}

repository: xiaomengbai/DisplayPaper

repo_name: xiaomengbai/DisplayPaper


text:
package cmd

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

var readManifestCmd = &cobra.Command{
	Use:   "read-manifest",
	Short: "Print a JSON representation of a Cargo.toml manifest.",
	Run:   func(cmd *cobra.Command, args []string) {},
}

func init() {
	carapace.Gen(readManifestCmd).Standalone()

	readManifestCmd.Flags().BoolP("help", "h", false, "Print help")
	readManifestCmd.Flags().String("manifest-path", "", "Path to Cargo.toml")
	readManifestCmd.Flags().BoolP("quiet", "q", false, "Do not print cargo log messages")
	rootCmd.AddCommand(readManifestCmd)

	carapace.Gen(readManifestCmd).FlagCompletion(carapace.ActionMap{
		"manifest-path": carapace.ActionFiles(),
	})
}

repository: rsteube/carapace-bin

repo_name: rsteube/carapace-bin


text:
@InProceedings{herman16,
  supplementary = {Supplementary:herman16-supp.pdf},
  title = {Inverse Reinforcement Learning with Simultaneous Estimation of Rewards and Dynamics},
  author = {Herman, Michael and Gindele, Tobias and Wagner, Jörg and Schmitt, Felix and Burgard, Wolfram},
  pages = {102-110},
  abstract = {Inverse Reinforcement Learning (IRL) describes the problem of learning an unknown reward function of a Markov Decision Process (MDP) from observed behavior of an agent. Since the agent's behavior originates in its policy and MDP policies depend on both the stochastic system dynamics as well as the reward function, the solution of the inverse problem is significantly influenced by both. Current IRL approaches assume that if the transition model is unknown, additional samples from the system's dynamics are accessible, or the observed behavior provides enough samples of the system's dynamics to solve the inverse problem accurately. These assumptions are often not satisfied. To overcome this, we present a gradient-based IRL approach that simultaneously estimates the system's dynamics. By solving the combined optimization problem, our approach takes into account the bias of the demonstrations, which stems from the generating policy. The evaluation on a synthetic MDP and a transfer learning task shows improvements regarding the sample efficiency as well as the accuracy of the estimated reward functions and transition models.},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX


text:
@InProceedings{cisneros:robio:2012,
  author    = {Cisneros, Rafael and Yoshida, Eiichi and Yokoi, Kazuhito},
  title     = {Ball dynamics simulation on OpenHRP3},
  booktitle = {International Conference on Robotics and Biomimetics},
  year      = {2012},
  pages     = {871--877},
  address   = {Guangzhou, China},
  month     = {December 11-December 14},
  keywords  = {collision avoidance, digital simulation, humanoid robots, human-robot interaction, mesh generation, mobile robots, public domain software},
  doi       = {10.1109/ROBIO.2012.6491078},
  abstract  = {This paper describes an improvement on Open-HRP3, an integrated software platform for robot simulations and software developments, in order to achieve realistic simulations with the dynamics of a ball interacting with the environment and with a humanoid robot. Previously, the only way to simulate the dynamics of a ball was by using the model of a polyhedron consisting of many faces and vertices. As a consequence, the ball rolled erratically and bounced in a unnatural way. The improvement consists in treating this polyhedron as a sphere when it comes to detect its collision with the environment modeled by meshes. We have developed a different algorithm, so that the dynamics engine of OpenHRP3 can simulate realistically the ball\textquotesingle s dynamics, by using an original method capable of showing much more accurate results than the previous one used by this software platform, which used the model of a polyhedron.}
}


text:
// Copyright (c) 2012 Uwe Hoffmann. All rights reserved.

package kindi

import (
	"net/http"
)

func init() {
	http.HandleFunc("/manage", manageHandler)
	http.HandleFunc("/jot", jotHandler)
	http.HandleFunc("/coins", coinsHandler)
	http.HandleFunc("/buy", buyHandler)
	http.HandleFunc("/upload", uploadHandler)
	http.HandleFunc("/delete", deleteHandler)
	http.HandleFunc("/invite", inviteHandler)
	http.HandleFunc("/lookup", lookupHandler)
	http.HandleFunc("/rpc/v1", rpcHandler)
}

repository: uwedeportivo/kindimonster

repo_name: uwedeportivo/kindimonster


text:
set(_CATKIN_CURRENT_PACKAGE "camera_pseudo")
set(camera_pseudo_VERSION "1.0.0")
set(camera_pseudo_MAINTAINER "Patrick Baumann <baumannpa@gmail.com>")
set(camera_pseudo_PACKAGE_FORMAT "1")
set(camera_pseudo_BUILD_DEPENDS "sensor_msgs" "rospy" "roscpp" "numpy" "cv_bridge")
set(camera_pseudo_BUILD_EXPORT_DEPENDS "sensor_msgs" "rospy" "roscpp" "numpy" "cv_bridge")
set(camera_pseudo_BUILDTOOL_DEPENDS "catkin")
set(camera_pseudo_BUILDTOOL_EXPORT_DEPENDS )
set(camera_pseudo_EXEC_DEPENDS "sensor_msgs" "rospy" "roscpp" "numpy" "cv_bridge")
set(camera_pseudo_RUN_DEPENDS "sensor_msgs" "rospy" "roscpp" "numpy" "cv_bridge")
set(camera_pseudo_TEST_DEPENDS )
set(camera_pseudo_DOC_DEPENDS )
set(camera_pseudo_URL_WEBSITE "")
set(camera_pseudo_URL_BUGTRACKER "")
set(camera_pseudo_URL_REPOSITORY "")
set(camera_pseudo_DEPRECATED "")

extension: cmake


text:
# Copyright (C) 2008, Ovidiu Sas - VoIP Embedded Inc., All Rights Reserved
# Copyright (C) 2008, Stelios Koroneos - Digital OPSiS, All Rights Reserved
# Released under the MIT license (see packages/COPYING)
DESCRIPTION = "The Asterisk open source software PBX"
HOMEPAGE = "http://www.asterisk.org"
LICENSE = "GPLv2"
PRIORITY = "optional"
SECTION = "console/telephony"
DEPENDS = "speex readline zlib openssl curl popt gnutls sqlite libogg libvorbis"
#RRECOMMENDS_${PN} = "logrotate"
PV = "1.5.0+1.6.0beta8"
PR = "r2"

DEFAULT_PREFERENCE = "-1"

SRC_URI="http://ftp.digium.com/pub/asterisk/releases/asterisk-${PV}.tar.gz\
	file://sounds.xml.patch\
	file://Makefile.patch\
	file://logrotate \
	file://volatiles \
	file://init"

ARCH_efika="powerpc"
ARCH_dht-walnut="powerpc"
ARCH_magicbox="powerpc"
ARCH_sequoia="powerpc"

INITSCRIPT_NAME = "asterisk"
INITSCRIPT_PARAMS = "defaults 60"

inherit autotools update-rc.d

EXTRA_OECONF =  "--with-ssl=${STAGING_EXECPREFIXDIR}\
			--with-z=${STAGING_EXECPREFIXDIR}\
			--with-curl=${STAGING_EXECPREFIXDIR}\
			--with-termcap=${STAGING_EXECPREFIXDIR}\
			--with-ogg=${STAGING_EXECPREFIXDIR}\
			--with-vorbis=${STAGING_EXECPREFIXDIR}\
			--with-sqlite=${STAGING_EXECPREFIXDIR}\
			--with-popt=${STAGING_EXECPREFIXDIR}\
			--with-gnutls=${STAGING_EXECPREFIXDIR}\
			--without-curses\
			--with-ncurses=${STAGING_EXECPREFIXDIR}\
			--without-imap\
			--without-netsnmp\
			--without-odbc\
			--without-osptk\
			--without-nbs\
			--without-pwlib\
			--without-radius\
			--without-tds\
			--without-postgres\
			--without-zaptel\
			"

#export NOISY_BUILD=yes

export ASTCFLAGS = "-fsigned-char -I${STAGING_INCDIR} -DPATH_MAX=4096"
export ASTLDFLAGS="${LDFLAGS} -lpthread -ldl -lresolv "
export PROC="${ARCH}"

do_configure_prepend () {
	sed -i 's:/var:${localstatedir}:' ${WORKDIR}/logrotate
	sed -i 's:/etc/init.d:${sysconfdir}/init.d:' ${WORKDIR}/logrotate
	sed -i 's:/var:${localstatedir}:' ${WORKDIR}/volatiles
}

do_configure () {
	# Looks like rebuilding configure doesn't work, so we are skipping
	# that and are just using the shipped one
	gnu-configize
	libtoolize --force
	oe_runconf
}

do_compile() {
        (
         #make sure that menuselect gets build using host toolchain
         unset CC LD CXX CCLD CFLAGS CPPFLAGS LDFLAGS CXXFLAGS RANLIB
         cd menuselect
         ./configure
         oe_runmake
         cd ../
        ) || exit 1
        oe_runmake
}

do_stage() {
	autotools_stage_includes
}

do_install_append() {
        install -d ${D}${sysconfdir}/init.d/
	install -m 755 ${WORKDIR}/init ${D}${sysconfdir}/init.d/asterisk
	install -c -D -m 644 ${WORKDIR}/logrotate ${D}${sysconfdir}/logrotate.d/asterisk
	install -c -D -m 644 ${WORKDIR}/volatiles ${D}${sysconfdir}/default/volatiles/asterisk
}

pkg_postinst_prepend() {
	grep -q asterisk  ${sysconfdir}/group || addgroup --system asterisk
	grep -q asterisk ${sysconfdir}/passwd || adduser --system --home ${localstatedir}/run/asterisk --no-create-home --disabled-password --ingroup asterisk -s ${base_bindir}/false asterisk
	chown -R asterisk:asterisk ${libdir}/asterisk ${localstatedir}/lib/asterisk ${localstatedir}/spool/asterisk ${localstatedir}/log/asterisk ${localstatedir}/run/asterisk ${sysconfdir}/asterisk
}

FILES_${PN} += "${libdir}/asterisk/modules/*"
FILES_${PN}-dbg += "${libdir}/asterisk/modules/.debug \
                    ${localstatedir}/lib/asterisk/*/.debug"

CONFFILES_${PN} += "${sysconfdir}/asterisk/adsi.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/adtranvofr.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/agents.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/alarmreceiver.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/alsa.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/amd.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/asterisk.adsi"
CONFFILES_${PN} += "${sysconfdir}/asterisk/asterisk.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/cdr.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/cdr_adaptive_odbc.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/cdr_custom.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/cdr_manager.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/cdr_odbc.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/cdr_pgsql.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/cdr_sqlite3_custom.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/cdr_tds.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/cli.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/codecs.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/console.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/dnsmgr.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/dundi.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/enum.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/extconfig.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/extensions.ael"
CONFFILES_${PN} += "${sysconfdir}/asterisk/extensions.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/extensions.lua"
CONFFILES_${PN} += "${sysconfdir}/asterisk/extensions_minivm.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/features.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/festival.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/followme.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/func_odbc.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/gtalk.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/h323.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/http.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/iax.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/iaxprov.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/indications.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/jabber.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/jingle.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/logger.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/manager.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/meetme.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/mgcp.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/minivm.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/misdn.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/modules.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/musiconhold.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/muted.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/osp.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/oss.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/phone.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/phoneprov.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/queuerules.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/queues.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/res_ldap.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/res_odbc.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/res_pgsql.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/res_snmp.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/rpt.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/rtp.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/say.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/sip.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/sip_notify.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/skinny.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/sla.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/smdi.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/telcordia-1.adsi"
CONFFILES_${PN} += "${sysconfdir}/asterisk/udptl.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/unistim.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/usbradio.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/users.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/voicemail.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/vpb.conf"
CONFFILES_${PN} += "${sysconfdir}/asterisk/zapata.conf"
CONFFILES_${PN} += "${sysconfdir}/logrotate.d/asterisk"


text:
@article{hatch_visbol2improving_2021,
 abstract = {VisBOL is a web-based visualization tool used to depict genetic circuit designs. This tool depicts simple DNA circuits adequately, but it has become increasingly outdated as new versions of SBOL Visual were released. This paper introduces VisBOL2, a heavily redesigned version of VisBOL that makes a number of improvements to the original VisBOL, including proper functional interaction rendering, dynamic viewing, a more maintainable code base, and modularity that facilitates compatibility with other software tools. This modularity is demonstrated by incorporating VisBOL2 into a sequence visualization plugin for SynBioHub.},
 author = {Hatch, Benjamin and Meng, Linhao and Mante, Jeanet and McLaughlin, James A. and Scott-Brown, James and Myers, Chris J.},
 doi = {10.1021/acssynbio.1c00147},
 journal = {ACS Synthetic Biology},
 month = {August},
 number = {8},
 pages = {2111--2115},
 title = {VisBOL2—Improving Web-Based Visualization for Synthetic Biology Designs},
 url = {https://doi.org/10.1021/acssynbio.1c00147},
 urldate = {2023-02-21},
 volume = {10},
 year = {2021}
}


text:
@article{white2004criticizing,
 author = {White, Ethan and Dougher, Michael},
 journal = {International Journal of Psychology and Psychological Therapy},
 number = {2},
 publisher = {Universidad de Almer{\'\i}a},
 title = {Criticizing the tendency for evolutionary psychologists to adopt cognitive paradigms when discussing language},
 volume = {4},
 year = {2004}
}

repository: weecology/website

repo_name: weecology/website


text:
package wego

// PaymentOption ...
type PaymentOption func(obj *Payment)

// PaymentBodyType ...
func PaymentBodyType(s BodyType) PaymentOption {
	return func(obj *Payment) {
		obj.BodyType = s
	}
}

// PaymentSubID ...
func PaymentSubID(mch, app string) PaymentOption {
	return func(obj *Payment) {
		obj.subAppID = app
		obj.subMchID = mch
	}
}

// PaymentKey ...
func PaymentKey(public, privite string) PaymentOption {
	return func(obj *Payment) {
		obj.publicKey = public
		obj.privateKey = privite
	}
}

// PaymentRemote ...
func PaymentRemote(remote string) PaymentOption {
	return func(obj *Payment) {
		obj.remoteHost = remote
	}
}

// PaymentLocal ...
func PaymentLocal(local string) PaymentOption {
	return func(obj *Payment) {
		obj.localHost = local
	}
}

// PaymentSandbox ...
func PaymentSandbox(property *SandboxProperty) PaymentOption {
	return func(obj *Payment) {
		obj.useSandbox = true
		obj.sandbox = NewSandbox(property)
	}
}

// PaymentNotifyURL ...
func PaymentNotifyURL(s string) PaymentOption {
	return func(obj *Payment) {
		obj.notifyURL = s
	}
}

// PaymentRefundedURL ...
func PaymentRefundedURL(s string) PaymentOption {
	return func(obj *Payment) {
		obj.refundedURL = s
	}
}

// PaymentScannedURL ...
func PaymentScannedURL(s string) PaymentOption {
	return func(obj *Payment) {
		obj.scannedURL = s
	}
}

// PaymentOptions ...
type PaymentOptions struct {
	BodyType   BodyType         `xml:"body_type"`
	SubMchID   string           `xml:"sub_mch_id"`
	SubAppID   string           `xml:"sub_app_id"`
	PublicKey  string           `xml:"public_key"`
	PrivateKey string           `xml:"private_key"`
	RemoteHost string           `xml:"remote_host"`
	LocalHost  string           `xml:"local_host"`
	UseSandbox bool             `xml:"use_sandbox"`
	Sandbox    *SandboxProperty `xml:"sandbox"`

	NotifyURL   string `xml:"notify_url"`
	RefundedURL string `xml:"refunded_url"`
	ScannedURL  string `xml:"scanned_url"`
}

repository: isgasho/wego

repo_name: isgasho/wego


text:
package main

import (
    "bufio"
    "database/sql"
    "flag"
    "log"
    "net"
    "fmt"
    "encoding/json"
    "os"
    "strconv"
    "time"

    "github.com/apcera/nats"
    _ "github.com/go-sql-driver/mysql"
)

var cfg Configuration
var natsc *nats.Conn
var mdb MetricDB
var mdb_conn *sql.DB

type Configuration struct {
    MetricDB map[string]string
    MonitorHost string
    MonitorPort string
    Nats string
}

type Metric struct {
    App_uuid string
    Cpu float64
    Mem float64
}

type AvgRequest struct {
    App_uuid string
    Measurement_period int
}

func handleMonitor(conn net.Conn) {
    scanner := bufio.NewScanner(conn)
    for scanner.Scan() {
        elements := strings.Split(scanner.Text(), " ")

        var m Metric
        m.App_uuid = elements[0]
        m.Cpu = strconv.ParseFloat(elements[2], 64)
        m.Mem = strconv.ParseFloat(elements[3], 64)

        avger.AddMetric(m)
    }

    if err := scanner.Err(); err != nil {
        log.Println("Cannot read the input from monitor:", err)
    }
}

func HandleEngine(msg *nats.Msg) {
    log.Printf("Received on [%s]: '%s'\n", msg.Subject, string(msg.Data))

    var req AvgRequest
    err := json.Unmarshal(msg.Data, &req)
    if err != nil {
        log.Println("Error occurs when decoding avg response", err)
        return
    }

    start := time.Now()
    avgMetric := GetAvgMetric(req.App_uuid, req.Measurement_period)
    end := time.Now()
    log.Println("Averaging time", end.Sub(start))
    avgMetric_json, err := json.Marshal(avgMetric)
    if err != nil {
        log.Println("Error occurs when encoding avg request:", err)
        return
    }

    natsc.Publish(msg.Reply, avgMetric_json)
}

func GetAvgMetric(app_uuid string, measurement_period int) Metric {
    // metric, err := mdb.AvgMetric(app_uuid, measurement_period)

    var r AvgRequest
    r.App_uuid = app_uuid
    r.Measurement_period = measurement_period

    metric, err := avger.GetAvgMetric(r)
    if err != nil {
        log.Println("Error occurs when getting avg metric:", err)
        return Metric{}
    }

    return metric
}

func init() {
    cfgPtr := flag.String("config", "config/avger.json", "Path to the config file")
    flag.Parse()

    f, err := os.Open(*cfgPtr)
    if err != nil {
        fmt.Println("Cannot open the config file:", err)
        os.Exit(1)
    }

    err = json.NewDecoder(f).Decode(&cfg)
    if err != nil {
        fmt.Println("Cannot decode the config file:", err)
        os.Exit(1)
    }

    natsc, err = nats.Connect(cfg.Nats)
    if err != nil {
        fmt.Println("Cannot connect to the gnatsd:", err)
        os.Exit(1)
    }

    var avger Avger

    // // MetricDB connection
    // mdb_dsn :=  cfg.MetricDB["Username"]+":"+
    //             cfg.MetricDB["Password"]+"@tcp("+
    //             cfg.MetricDB["Host"]+":"+
    //             cfg.MetricDB["Port"]+")/"+
    //             cfg.MetricDB["Database"]
    // mdb_conn, err = sql.Open("mysql", mdb_dsn)
    // if err != nil {
    //     fmt.Println("Cannot connect to the Policy database:", err)
    //     os.Exit(1)
    // }
    // mdb = MetricDB {db: mdb_conn}
}

func main() {
    l, err := net.Listen("tcp", cfg.MonitorHost + ":" + cfg.MonitorPort)
    if err != nil {
        log.Fatal("Cannot listen to: ", cfg.MonitorHost, cfg.MonitorPort, err)
    }
    defer l.Close()
    log.Println("Listening to monitor connection on", cfg.MonitorHost, cfg.MonitorPort)

    natsc.Subscribe("avg", HandleEngine)

    for {
        conn, err := l.Accept()
        if err != nil {
            log.Println("Accept connection from monitor failed: ", err)
        } else {
            log.Println("Accept connection from monitor: ", conn.RemoteAddr().String())
            go handleMonitor(conn)
        }
    }
}

repository: cloudfoundry-community/cfscaler

repo_name: cloudfoundry-community/cfscaler


text:
package main

import (
	"code.google.com/p/goauth2/oauth"
	"encoding/json"
	"fmt"
	"github.com/google/go-github/github"
	c "govcode.org/common"
	"io/ioutil"
	"net/http"
	"os"
	"sync"
	"time"
)

func getStr(str *string) string {
	if str == nil {
		return ""
	}
	return *str
}

func findOrCreateUser(user *c.User) int64 {

	var new_user c.User
	c.DB.Where("gh_id = ?", user.GhId).First(&new_user)

	if new_user.Id == 0 {
		new_user.Login = user.Login
		new_user.AvatarUrl = user.AvatarUrl
		new_user.GhId = user.GhId
		new_user.CommitCount = 0
		c.DB.Save(&new_user)
	}

	return new_user.Id
}

func runImport() (err error) {
	gh_key := os.Getenv("GH_KEY")

	t := &oauth.Transport{
		Token: &oauth.Token{AccessToken: gh_key},
	}

	client := github.NewClient(t.Client())

	orgs := getAccounts()
	importOrgs(orgs, client)

	return nil
}

func getAccounts() (orgs []string) {
	url := "http://registry.usa.gov/accounts.json?service_id=github"
	res, err := http.Get(url)
	c.PanicOn(err)

	defer res.Body.Close()

	body, err := ioutil.ReadAll(res.Body)
	c.PanicOn(err)

	var data AccountData

	err = json.Unmarshal(body, &data)
	c.PanicOn(err)

	orgs = append(orgs, []string{"MeasureAuthoringTool", "blue-button", "ngageoint", "afrl",
		"virtual-world-framework", "usnistgov", "govxteam", "commercegov",
		"ncats", "missioncommand"}...)

	for _, e := range data.Accounts {
		orgs = append(orgs, e.Account)
	}

	return orgs
}

func importOrgs(orgs []string, client *github.Client) {
	// Query github for org info and save to db if it doesn't exist
	var wg sync.WaitGroup
	for _, e := range orgs {
		wg.Add(1)

		go func(org_name string, wg *sync.WaitGroup) {
			gh_org, res, err := client.Organizations.Get(org_name)
			fmt.Println("Getting Org", org_name)
			fmt.Println(res)
			// Do not panic, probably 404 error
			if err != nil {
				fmt.Println(err)
				wg.Done()
				return
			}

			var org c.Organization

			c.DB.Where("login = ?", gh_org.Login).First(&org)

			if org.Id == 0 {
				org.Login = *gh_org.Login
				if gh_org.Name != nil {
					org.Name = *gh_org.Name
				}
				org.Ignore = false

				c.DB.Save(&org)
			}
			// Import repos
			importRepos(&org, client, 1)

			wg.Done()
		}(e, &wg)
	}
	wg.Wait()
}

func importRepos(org *c.Organization, client *github.Client, page int) {
	// Load the repos for a given org
	opt := &github.RepositoryListByOrgOptions{}
	opt.ListOptions = github.ListOptions{Page: page, PerPage: 100}

	repos, response, err := client.Repositories.ListByOrg(org.Login, opt)
	fmt.Println("Getting Repos", org.Login, page)
	fmt.Println(response)
	if err != nil {
		fmt.Println("Error with org: ", org.Login)
		return
	}

	// There are more pages, lets fetch the next one
	if response.NextPage > 0 {
		importRepos(org, client, response.NextPage)
	}

	concurrency := 4

	sem := make(chan bool, concurrency)

	for _, r := range repos {
		if !*r.Fork {
			var repo c.Repository
			c.DB.Where("name = ? and organization_id = ?", *r.Name, org.Id).First(&repo)

			if repo.Id == 0 {
				repo.GhId = int64(*r.ID)
				repo.Name = *r.Name
				if r.Description != nil {
					repo.Description = *r.Description
				}
				repo.OrganizationId = org.Id
			}
			repo.Forks = int64(*r.ForksCount)
			repo.Watchers = int64(*r.WatchersCount)
			repo.Stargazers = int64(*r.StargazersCount)
			repo.Size = int64(*r.Size)
			repo.OpenIssues = int64(*r.OpenIssuesCount)
			repo.Language = getStr(r.Language)

			c.DB.Save(&repo)

			sem <- true
			go importStats(&repo, org, client, &sem)

			importPulls(&repo, org, client, 1)
		}
	}

	for i := 0; i < cap(sem); i++ {
		sem <- true
	}
}

func importStats(repo *c.Repository, org *c.Organization, client *github.Client, sem *chan bool) {
	stats, res, err := client.Repositories.ListContributorsStats(org.Login, repo.Name)
	fmt.Println("Getting stats", repo.Name)
	fmt.Println(res)
	if err != nil {
		if res != nil && res.StatusCode == 202 {
			fmt.Println("Sleeping")
			time.Sleep(4 * time.Second)
			importStats(repo, org, client, sem)
			return
		}
	}

	for _, s := range stats {
		for _, w := range s.Weeks {
			if *w.Commits == 0 {
				continue
			}

			var stat c.RepoStat
			var user c.User
			user.FromGhContrib(s.Author)

			user_id := findOrCreateUser(&user)
			// Does it exist?
			timeStr := fmt.Sprintf("%4d%02d%02d", w.Week.Time.Year(), w.Week.Time.Month(), w.Week.Time.Day())
			c.DB.Where("user_id = ? and repository_id = ? and to_char(week, 'YYYYMMDD') = ?",
				user_id,
				repo.Id,
				timeStr).First(&stat)

			if stat.Id == 0 || stat.Commits != int64(*w.Commits) {
				stat.UserId = user_id
				stat.RepositoryId = repo.Id
				stat.Week = w.Week.Time
				stat.Add = int64(*w.Additions)
				stat.Del = int64(*w.Deletions)
				stat.Commits = int64(*w.Commits)
				c.DB.Save(&stat)
			}
		}
	}

	<-*sem
}

func importPulls(repo *c.Repository, org *c.Organization, client *github.Client, page int) {
	// Import pulls for a given repo
	opt := &github.PullRequestListOptions{}
	opt.State = "all"
	opt.ListOptions = github.ListOptions{Page: page, PerPage: 100}

	pulls, response, err := client.PullRequests.List(org.Login, repo.Name, opt)
	fmt.Println("Getting pulls", repo.Name, page)
	fmt.Println(response)
	if err != nil {
		fmt.Println("Error with repo pulls: ", repo.Name)
		fmt.Println(err)
		return
	}

	// There are more pages, lets fetch the next one
	if response.NextPage > 0 {
		importPulls(repo, org, client, response.NextPage)
	}

	for _, gh_pull := range pulls {
		var pull c.Pull

		// Does the commit exist?
		c.DB.Where("number = ? and repository_id = ?", *gh_pull.Number, repo.Id).First(&pull)

		if pull.Id == 0 {
			pull.RepositoryId = repo.Id
			pull.Title = *gh_pull.Title
			pull.Body = getStr(gh_pull.Body)
			pull.Admin = *gh_pull.User.SiteAdmin
			pull.Number = int64(*gh_pull.Number)
			pull.GhCreatedAt.Time = *gh_pull.CreatedAt
			pull.GhCreatedAt.Valid = true

			var user c.User
			user.FromGhUser(gh_pull.User)

			pull.UserId = findOrCreateUser(&user)
		}

		// If the pull has not been updated go to the next one
		if pull.GhUpdatedAt.Time == *gh_pull.UpdatedAt {
			continue
		}

		pull.GhUpdatedAt.Time = *gh_pull.UpdatedAt
		pull.GhUpdatedAt.Valid = true

		if gh_pull.MergedAt != nil {
			pull.MergedAt.Time = *gh_pull.MergedAt
			pull.MergedAt.Valid = true
		}

		c.DB.Save(&pull)
	}
}

repository: gbinal/govcode

repo_name: gbinal/govcode


text:
package main

import "fmt"

func main() {
	mySlice := make([]string, 3)
	fmt.Println("Empty slice: ", mySlice)

	mySlice[0] = "yo"
	mySlice[1] = "im"
	mySlice[2] = "ahad"
	fmt.Println("set: ", mySlice)
	fmt.Println("get: ", mySlice[2])
	fmt.Println("length: ", len(mySlice))

	mySlice = append(mySlice, "how are")
	mySlice = append(mySlice, "you?")
	fmt.Println("append: ", mySlice)

	copySlice := make([]string, len(mySlice))
	copy(copySlice, mySlice)
	fmt.Println("copy slice:", copySlice)

	lice := mySlice[2:5]
	fmt.Println("slice 1: ", lice)

	temp := []string{"the", "quick", "brown", "fox"}
	fmt.Println("Declare and init: ", temp)

	twoD := make([][]int, 3)
	for i := 0; i < 3; i++ {
		innerLen := i + 1
		twoD[i] = make([]int, innerLen)
		for j := 0; j < innerLen; j++ {
			twoD[i][j] = i + j
		}
	}
	fmt.Println("2d: ", twoD)

}


text:
package board

import (
	"errors"

	"github.com/TTRSQ/CircleCrossGame/domain/constants"
	"github.com/TTRSQ/CircleCrossGame/domain/game/action"
)

/*
task:
- 状態管理
- 遷移可能状態列挙
- 現状調査
*/

const (
	WIDTH  = 3
	HEIGHT = 3
)

type Board struct {
	status []*constants.Symbol
}

func NewBoard() Board {
	return Board{
		status: []*constants.Symbol{
			nil, nil, nil,
			nil, nil, nil,
			nil, nil, nil,
		},
	}
}

func (b *Board) Act(act action.Item) error {
	if b.status[act.Y()*WIDTH+act.X()] != nil {
		return errors.New("already placed")
	}
	symbol := act.Symbol()
	b.status[act.Y()*WIDTH+act.X()] = &symbol
	return nil
}

func lineBinaryList() []int {
	return []int{
		448, // 111,000,000
		56,  // 000,111,000
		7,   // 000,000,111
		292, // 100,100,100
		146, // 010,010,010
		73,  // 001,001,001
		273, // 100,010,001
		84,  // 001,010,100
	}
}

func (b *Board) binary(symbol constants.Symbol) (int, error) {
	stamp := []int{
		256, 128, 64,
		32, 16, 8,
		4, 2, 1,
	}
	sum := 0
	for i := range b.status {
		if b.status[i] != nil && *b.status[i] == symbol {
			sum += stamp[i]
		}
	}
	return sum, nil
}

func (b *Board) CountLine(symbol constants.Symbol) (int, error) {
	binary, _ := b.binary(symbol)
	count := 0
	for _, line := range lineBinaryList() {
		if binary&line == line {
			count += 1
		}
	}
	return count, nil
}

func (b *Board) CanPutPoints() [][]int {
	ret := [][]int{}
	for i := range b.status {
		if b.status[i] == nil {
			ret = append(ret, []int{i % WIDTH, i / WIDTH})
		}
	}
	return ret
}

func (b *Board) Status() [][]*constants.Symbol {
	ret := [][]*constants.Symbol{}

	for y := 0; y < HEIGHT; y++ {
		row := []*constants.Symbol{}
		for x := 0; x < WIDTH; x++ {
			row = append(row, b.status[y*WIDTH+x])
		}
		ret = append(ret, row)
	}

	return ret
}

func (b *Board) CountSymbol(symbol constants.Symbol) int {
	sum := 0
	for i := range b.status {
		if b.status[i] != nil && *b.status[i] == symbol {
			sum++
		}
	}
	return sum
}

repository: TTRSQ/CircleCrossGame

repo_name: TTRSQ/CircleCrossGame


text:
require u-boot-socfpga-common.inc
require ${COREBASE}/meta/recipes-bsp/u-boot/u-boot.inc

LICENSE = "GPLv2+"
LIC_FILES_CHKSUM = "file://Licenses/README;md5=30503fd321432fc713238f582193b78e"

PR = "2"

FILESEXTRAPATHS =. "${THISDIR}/files/v2019.07:"

SRCREV = "7e090b466c5ba874d31c1bf22c3a130d516cdc32"

SRC_URI_append = "\
	file://0001-ARM-socfpga-stratix10-Enable-PSCI-system-reset.patch \
	file://0002-ARM-socfpga-stratix10-Enable-PSCI-CPU_ON.patch \
	file://0003-ARM-socfpga-stratix10-Enable-PSCI-support-for-Strati.patch \
	file://0004-ARM-socfpga-stratix10-Enable-SMC-PSCI-calls-from-sla.patch \
	file://0005-ARM-socfpga-stratix10-Add-SOCFPGA-bridges-reset-supp.patch \
	file://0006-ARM-socfpga-stratix10-Add-Stratix10-FPGA-configurati.patch \
	file://0007-mmc-dwmmc-Enable-small-delay-before-returning-error.patch \
	file://0008-ARM-socfpga-stratix10-Enable-DMA330-DMA-controller.patch \
	file://0009-ARM-socfpga-Stratix10-Fix-el3_exception_vectors-relo.patch \
	file://0010-Makefile-Add-target-to-generate-hex-output-for-combi.patch \
	file://0011-ARM-socfpga-stratix10-Remove-CONFIG_OF_EMBED.patch \
	file://0012-ARM-socfpga-stratix10-Temporarily-revert-to-2GB-DRAM.patch \
	file://0001-ARM-socfpga-Stratix10-Disable-CONFIG_PSCI_RESET.patch \
    "

DEPENDS += "dtc-native bc-native bison-native u-boot-mkimage-native"

repository: crispycookies/ssl-build

repo_name: crispycookies/ssl-build


text:
set(TESTS_RESOURCE_LOCATION ${CMAKE_CURRENT_SOURCE_DIR}/resources)

set(TEST_RESOURCE_HEADER ${CMAKE_CURRENT_BINARY_DIR}/test_resources.h)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/test_resources.in.h ${TEST_RESOURCE_HEADER})

repository: cellml/libcellml

repo_name: cellml/libcellml


text:
/*
Copyright (c) Microsoft Corporation.
Licensed under the MIT license.
*/

// Code generated by azure-service-operator-codegen. DO NOT EDIT.

// Package v1beta20210501 contains API Schema definitions for the dbformysql v1beta20210501 API group
// +groupName=dbformysql.azure.com
package v1beta20210501

repository: Azure/azure-service-operator

repo_name: Azure/azure-service-operator


text:
require libwpe.inc
require conf/include/devupstream.inc

LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://COPYING;md5=371a616eb4903c6cb79e9893a5f615cc"

SRC_URI[sha256sum] = "2415e270d45e3595ed4052bc105f733744dc2d3677e12ff4a831e5029841084d"

SRC_URI_class-devupstream = "git://github.com/WebPlatformForEmbedded/libwpe.git;protocol=https;branch=master"
SRCREV_class-devupstream = "4bdc57a8de3675aa0fa4a033f1ac89f792d36b94"


text:
// Copyright © 2017 NAME HERE <EMAIL ADDRESS>
//
// 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 cmd

import (
	"github.com/James-Yip/Agenda/service"

	"github.com/spf13/cobra"
)

// changeParticipatorsCmd represents the changeParticipators command
var changeParticipatorsCmd = &cobra.Command{
	Use:   "changeParticipators",
	Short: "Change(add/delete) meeting participators.",
	Long:  `Change(add/delete) participators of a meeting created by current login user.`,
	Run: func(cmd *cobra.Command, args []string) {
		title, _ := cmd.Flags().GetString("title")
		delete_participators_str, _ := cmd.Flags().GetString("delete")
		add_participators_str, _ := cmd.Flags().GetString("add")
		// fmt.Println("title: " + title)
		// fmt.Println("delete_participators: " + delete_participators_str)
		// fmt.Println("add_participators: " + add_participators_str)

		if add_participators_str != "" {
			service.AddParticipators(title, add_participators_str)
		} else {
			service.DeleteParticipators(title, delete_participators_str)
		}
	},
}

func init() {
	RootCmd.AddCommand(changeParticipatorsCmd)

	// Here you will define your flags and configuration settings.

	// Cobra supports Persistent Flags which will work for this command
	// and all subcommands, e.g.:
	// changeParticipatorsCmd.PersistentFlags().String("foo", "", "A help for foo")

	// local flags for changeParticipatorsCmd
	changeParticipatorsCmd.Flags().StringP("title", "t", "", "title")
	changeParticipatorsCmd.Flags().StringP("delete", "d", "", "participators that you intend to delete")
	changeParticipatorsCmd.Flags().StringP("add", "a", "", "participators that you intend to add")
}

repository: James-Yip/Agenda

repo_name: James-Yip/Agenda


text:
@article{kots2016modelirovanie11633632,
 address = {Москва},
 author = {Хренова, М. Г. and Коц, Е. Д. and Кулакова, А. М. and Поляков, И. В.},
 doi = {10.3103/S0027131416010065},
 issn = {0579-9384},
 journal = {Вестник Московского университета. Серия 2: Химия},
 language = {russian},
 number = {1},
 pages = {7--10},
 publisher = {Москва},
 title = {Моделирование реакции гидролиза гуанозинтрифосфата белковом комплексе RAS GAP},
 volume = {57},
 year = {2016}
}

repository: polyakoviv/LCC

repo_name: polyakoviv/LCC


text:
@article{kolt_using_2017,
 abstract = {Background/Aim Web 2.0 internet technology has great potential in promoting physical activity. This trial investigated the effectiveness of a Web 2.0-based intervention on physical activity behaviour, and the impact on website usage and engagement. Methods 504 (328 women, 126 men) insufficiently active adult participants were randomly allocated to one f two web-based interventions or a paper-based Logbook group. The Web 1.0 group participated in the existing 10 000 Steps programme, while the Web 2.0 group participated in a Web 2.0-enabled physical activity intervention including user-to-user interaction through social networking capabilities. ActiGraph GT3X activity monitors were used to assess physical activity at four points across the intervention (0, 3, 12 and 18 months), and usage and engagement were assessed continuously through website usage statistics. Results Treatment groups differed significantly in trajectories of minutes/day of physical activity (p=0.0198), through a greater change at 3 months fo Web 2.0 than Web 1.0 (7.3 min/day, 95% CI 2.4 to 12.3). In the Web 2.0 group, physical activity increased at 3 (mean change 6.8 min/day, 95% CI 3.9 to 9.6) and 12 months (3.8 min/day, 95% CI 0.5 to 7.0), but not 18 months. The Logbook group also increased physical activity at 3 (4.8 min/day, 95% CI 1.8 to 7.7) and 12 months (4.9 min/day, 95% CI 0.7 to 9.1), but not 18 months. The Web 1.0 group increased physical activity at 12 months only (4.9 min/day, 95% CI 0.5 to 9.3). The Web 2.0 group demonstrated higher levels of website engagement (p=0.3964).Conclusions In comparison to a Web 1.0 intervention, a more interactive Web 2.0 intervention, as well as the paper-based Logbook intervention, improved physicalactivity in the short term, but that effect reduced over time, despite higher levels of engagement of the Web 2.0 group. Trial registration number ACTRN12611000157976.},
 author = {Kolt, G.S. and Rosenkranz, R.R. and Vandelanotte, C. and Caperchione, C.M. and Maeder, A.J. and Tague, R. and Savage, T.N. and Van Itallie, A. and Mummery, W.K. and Oldmeadow, C. and Duncan, M.J.},
 doi = {10.1136/bjsports-2016-096890},
 issn = {1473-0480},
 journal = {British Journal of Sports Medicine},
 month = {October},
 number = {19},
 pages = {1433--1440},
 title = {Using web 2.0 applications to promote health-related physical activity: Findings from the WALK 2.0 randomised controlled trial},
 volume = {51},
 year = {2017}
}

repository: ChrisOldmeadow/academic-kickstart

repo_name: ChrisOldmeadow/academic-kickstart


text:
@phdthesis{Uhlmann1995,
author={Jeffrey Uhlmann},
title={Dynamic Map Building and Localization: New Theoretical Foundations},
institution={University of Oxford},
year={1995}
}

@article{Dempster1977,
author = {A. P. Dempster and N. M. Laird and D. B. Rubin},
title = {Maximum Likelihood from Incomplete Data via the EM Algorithm},
ISSN = {00359246},
URL = {http://www.jstor.org/stable/2984875},
journal = {Journal of the Royal Statistical Society. Series B (Methodological)},
number = {1},
pages = {1--38},
publisher = {Royal Statistical Society, Wiley},
volume = {39},
year = {1977}
}

@inproceedings{Ghahramani1994,
author = {Zoubin Ghahramani and Michael Jordan},
title = {Supervised learning from incomplete data via an EM approach},
booktitle = {Advances in Neural Information Processing Systems},
editor = {J. Cowan and G. Tesauro and J. Alspector},
pages = {120--127},
publisher = {Morgan-Kaufmann},
url = {https://proceedings.neurips.cc/paper/1993/file/f2201f5191c4e92cc5af043eebfd0946-Paper.pdf},
volume = {6},
year = {1994}
}

@ARTICLE{Calinon2007,
author={Sylcain Calinon and Florent Guenter and Aude Billard},
title={On Learning, Representing, and Generalizing a Task in a Humanoid Robot},
journal={IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics)},
year={2007},
volume={37},
number={2},
pages={286--298},
doi={10.1109/TSMCB.2006.886952}
}

@article{Stulp2015,
author = "Freek Stulp and Olivier Sigaud",
title = "Many regression algorithms, one unified model: A review",
journal = "Neural Networks",
volume = "69",
pages = "60--79",
year = "2015",
issn = "0893-6080",
doi = {10.1016/j.neunet.2015.05.005},
url = {http://www.sciencedirect.com/science/article/pii/S0893608015001185}
}

@article{Pedregosa2011,
title={Scikit-learn: Machine Learning in {P}ython},
author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
journal={Journal of Machine Learning Research},
volume={12},
pages={2825--2830},
year={2011}
}

@incollection{Billard2008,
author="Billard, Aude and Calinon, Sylvain and Dillmann, R{\"u}diger and Schaal, Stefan",
title="Robot Programming by Demonstration",
editor="Siciliano, Bruno and Khatib, Oussama",
booktitle="Springer Handbook of Robotics",
year="2008",
publisher="Springer Berlin Heidelberg",
address="Berlin, Heidelberg",
pages="1371--1394",
isbn="978-3-540-30301-5",
doi="10.1007/978-3-540-30301-5_60"
}

@techreport{Bishop1994,
author = {Christopher M. Bishop},
title = {Mixture Density Networks},
institution = {Aston University},
year = {1994}
}

repository: AlexanderFabisch/gmr

repo_name: AlexanderFabisch/gmr

gha_language: Python


text:
DESCRIPTION = "Simple Qt web display using webkit"
HOMEPAGE = "https://gitorious.org/matrix-gui-v2/matrix_browser"
LICENSE = "BSD"
SECTION = "multimedia"
PRIORITY = "optional"

PR = "r4"

SRCREV = "5857a24ef0eaa0835f9e9c5a5f80ce681a1e801e"
BRANCH ?= "master"

SRC_URI = "git://gitorious.org/matrix-gui-v2/matrix_browser.git;protocol=git;branch=${BRANCH}"

S = "${WORKDIR}/git"

inherit qt4e

do_install() {
	install -d ${D}/${bindir}
	install -m 0755 ${S}/matrix_browser ${D}/${bindir}
}


text:
package main

import (
	"context"
	"encoding/json"
	"io"
	"net/http"
	"os"
	"time"

	"cloud.google.com/go/storage"
	"google.golang.org/api/iterator"
	"google.golang.org/appengine"
	"google.golang.org/appengine/log"
)

var (
	bucketName string
	projectId  string
)

type urlResponse struct {
	Url string `json:"url"`
}

func init() {
	projectId = os.Getenv("PROJECT_ID")
	bucketName = os.Getenv("BUCKET_NAME")

	http.HandleFunc("/_ah/start", handleStartup)
	http.HandleFunc("/api/upload-via-appengine", uploadThroughAppEngineHandler)
	http.HandleFunc("/api/client-url", uploadWithSignedUrlHandler)
}

// Check that the bucket exists. If it does not, provision it with the correct
// permissions. NOTE: all objects stored in this bucket will be publicly accessible by default.
func getOrCreateBucket(ctx context.Context) (*storage.BucketHandle, error) {
	var bucket *storage.BucketHandle

	client, err := storage.NewClient(ctx)
	if err != nil {
		log.Errorf(ctx, "Failed to create client: %v", err)
		return nil, err
	}

	// Check if the bucket already exists
	it := client.Buckets(ctx, projectId)
	it.Prefix = bucketName
	for {
		attrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return nil, err
		}
		if attrs.Name == bucketName {
			// Bucket exists, capture reference and return
			log.Debugf(ctx, "bucket already exists")
			bucket = client.Bucket(bucketName)
			return bucket, nil
		}
	}

	// Configure the attributes of our bucket.
	bucketAttrs := storage.BucketAttrs{}
	// Because we're providing direct client access to images, we'll
	// use Multi-Regional Storage to improve read times.
	bucketAttrs.StorageClass = "MULTI_REGIONAL"
	bucketAttrs.Location = "us"
	// Configure CORS to enable direct client uploads via signed URLs.
	bucketAttrs.CORS = []storage.CORS{
		{
			MaxAge:          time.Hour,
			Methods:         []string{"GET", "PUT"},
			Origins:         []string{"*"},
			ResponseHeaders: []string{"Access-Control-Allow-Origin", "Content-Type"},
		},
	}
	// Alow public access to this bucket so users can view images
	bucketAttrs.DefaultObjectACL = []storage.ACLRule{
		{storage.AllUsers, storage.RoleReader},
	}

	// We always want to ensure the bucket exists early on due to the fact
	// that bucket names must be globally unique. If the bucket name is already
	// taken by another project, the application should fail to start.
	bucket = client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectId, &bucketAttrs); err != nil {
		log.Errorf(ctx, "Failed to get or create bucket: %v", err)
		return nil, err
	}

	log.Debugf(ctx, "bucket created")
	return bucket, nil
}

// For use in manual and basic scaling. This allows us to eagerly provision our
// bucket before accepting user requests. Note that for automatic scaling, this
// endpoint will not be called.
func handleStartup(w http.ResponseWriter, r *http.Request) {
	ctx := appengine.NewContext(r)
	log.Infof(ctx, "Starting application with project %s, bucket %s", projectId, bucketName)

	if _, err := getOrCreateBucket(ctx); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.Write([]byte("bucket provisioned"))
}

// Method 1: Allow users to upload images directly to our service. Upon receiving
// an image, this handler will write it into Cloud Storage (not a great use of resources).
func uploadThroughAppEngineHandler(w http.ResponseWriter, r *http.Request) {
	ctx := appengine.NewContext(r)

	log.Infof(ctx, "in upload handler")

	if r.Method != "POST" {
		http.Error(w, "uploads must use POST", http.StatusMethodNotAllowed)
		return
	}

	// Pull the image file out of the client's request
	file, header, err := r.FormFile("gae-image")
	if err != nil {
		log.Errorf(ctx, "Failed to process request form: %v", err)
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
	defer file.Close()
	// Determine the image format. We're only allowing .jpeg and .png, though others would work.
	contentType := header.Header.Get("Content-Type")
	if contentType != "image/png" && contentType != "image/jpeg" {
		http.Error(w, "image must be .png or .jpeg", http.StatusBadRequest)
		return
	}

	// Get or create a reference to our bucket
	bucket, err := getOrCreateBucket(ctx)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// Create an object writer for the bucket
	wc := bucket.Object(header.Filename).NewWriter(ctx)
	// Allow public access to image
	wc.ACL = []storage.ACLRule{{storage.AllUsers, storage.RoleReader}}

	log.Infof(ctx, "Saving file to Cloud Storage: %s", header.Filename)

	// Write the uploaded file to Cloud Storage
	if _, err := io.Copy(wc, file); err != nil {
		log.Errorf(ctx, "Failed to write file to bucket: %v, %s", err, bucketName)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	if err := wc.Close(); err != nil {
		log.Errorf(ctx, "Failed to commit object to bucket: %v, %s", err, wc.Attrs().Name)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// Return the image's public URL in the response body
	log.Infof(ctx, "Returning URL to client")
	json, err := json.Marshal(urlResponse{wc.Attrs().MediaLink})
	if err != nil {
		log.Errorf(ctx, "Failed to process UrlResponse: %v", err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.Write(json)
}

// Method 2: Provide clients with a Signed URL for the given filename and type.
// Users can then load their image directly into Cloud Storage from their browser,
// saving us the resource overhead and improving performance for them.
func uploadWithSignedUrlHandler(w http.ResponseWriter, r *http.Request) {
	ctx := appengine.NewContext(r)

	opts := &storage.SignedURLOptions{}
	// Only allow PUT requests for this URL
	opts.Method = "PUT"
	// Set the URL to expire one hour after creation
	opts.Expires = time.Now().Local().Add(time.Hour)
	opts.ContentType = r.URL.Query().Get("content-type")
	// Set this URL's access ID to the default App Engine service account
	acc, _ := appengine.ServiceAccount(ctx)
	opts.GoogleAccessID = acc
	// Use the provided App Engine SignBytes function to sign the URL
	opts.SignBytes = func(b []byte) ([]byte, error) {
		_, signedBytes, err := appengine.SignBytes(ctx, b)
		return signedBytes, err
	}
	// Get a reference to our bucket, or create it
	if _, err := getOrCreateBucket(ctx); err != nil {
		log.Errorf(ctx, "Failed to get or create bucket: %v", err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}
	// Generate the signed URL
	url, err := storage.SignedURL(bucketName, r.URL.Query().Get("name"), opts)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	// Return the resulting URL to the client. The can then use this URL
	// to upload the specified file for up to one hour.
	json, err := json.Marshal(urlResponse{url})
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.Write(json)
}


text:
@techreport{jacq2017expressing,
 author = {Jacq, Alexis David and Johal, Wafa and Paiva, Ana and Dillenbourg, Pierre},
 institution = {Instituto Superiro Technico},
 title = {Expressing Motivations By Facilitating Other’s Inverse Reinforcement Learning},
 year = {2017}
}

repository: estella-a/research-group-website-src

repo_name: estella-a/research-group-website-src


text:
@article{sessegolo_transcriptome_2019,
 abstract = {Our vision of DNA transcription and splicing has changed dramatically with the introduction of short-read sequencing. These high-throughput sequencing technologies promised to unravel the complexity of any transcriptome. Generally gene expression levels are well-captured using these technologies, but there are still remaining caveats due to the limited read length and the fact that RNA molecules had to be reverse transcribed before sequencing. Oxford Nanopore Technologies has recently launched a portable sequencer which offers the possibility of sequencing long reads and most importantly RNA molecules. Here we generated a full mouse transcriptome from brain and liver using the Oxford Nanopore device. As a comparison, we sequenced RNA (RNA-Seq) and cDNA (cDNA-Seq) molecules using both long and short reads technologies and tested the TeloPrime preparation kit, dedicated to the enrichment of full-length transcripts. Using spike-in data, we confirmed that expression levels are efficiently captured by cDNA-Seq using short reads. More importantly, Oxford Nanopore RNA-Seq tends to be more efficient, while cDNA-Seq appears to be more biased. We further show that the cDNA library preparation of the Nanopore protocol induces read truncation for transcripts containing internal runs of T's. This bias is marked for runs of at least 15 T's, but is already detectable for runs of at least 9 T's and therefore concerns more than 20% of expressed transcripts in mouse brain and liver. Finally, we outline that bioinformatics challenges remain ahead for quantifying at the transcript level, especially when reads are not full-length. Accurate quantification of repeat-associated genes such as processed pseudogenes also remains difficult, and we show that current mapping protocols which map reads to the genome largely over-estimate their expression, at the expense of their parent gene.},
 author = {Sessegolo, Camille and Cruaud, Corinne and Da Silva, Corinne and Cologne, Audric and Dubarry, Marion and Derrien, Thomas and Lacroix, Vincent and Aury, J.-M. Jean-Marc},
 doi = {10.1038/s41598-019-51470-9},
 file = {Attachment:/Users/admin/Zotero/storage/LWB3AYNV/Sessegolo et al. - Unknown - Transcriptome profiling of mouse samples using nanopore sequencing of cDNA and RNA molecules.pdf:application/pdf},
 issn = {2045-2322},
 journal = {Scientific reports},
 month = {October},
 number = {1},
 pages = {14908},
 pmid = {31624302},
 title = {Transcriptome profiling of mouse samples using nanopore sequencing of cDNA and RNA molecules.},
 url = {https://doi.org/10.1038/s41598-019-51470-9 http://www.nature.com/articles/s41598-019-51470-9 http://www.ncbi.nlm.nih.gov/pubmed/31624302 http://www.pubmedcentral.nih.gov/articlerender.fcgi?artid=PMC6797730},
 volume = {9},
 year = {2019}
}