text:
@InProceedings{rao12,
  title = {Universal Measurement Bounds for Structured Sparse Signal Recovery},
  author = {Nikhil Rao and Ben Recht and Robert Nowak},
  pages = {942--950},
  abstract = {Standard compressive sensing results state that to exactly recover an s sparse signal in Rp, one requires O(s log p) measurements. While this bound is extremely useful in practice, often real world signals are not only sparse, but also exhibit structure in the sparsity pattern. We focus on group-structured patterns in this paper. Under this model, groups of signal coefficients are active (or inactive) together. The groups are prede- fined, but the particular set of groups that are active (i.e., in the signal support) must be learned from measurements. We show that exploiting knowledge of groups can further reduce the number of measurements required for exact signal recovery, and derive universal bounds for the number of measurements needed. The bound is universal in the sense that it only depends on the number of groups under consideration, and not the particulars of the groups (e.g., compositions, sizes, ex- tents, overlaps, etc.). Experiments show that our result holds for a variety of overlapping group configurations.},
  pdf = {http://jmlr.org/proceedings/papers/v22/rao12/rao12.pdf},
}

repository: mreid/papersite

repo_name: mreid/papersite


text:
package main

import "container/list"
import "fmt"

func lcs(s0, s1 string) *list.List {
	// build a matrix to score the counts
	var m [][]int= make([][]int, len(s0))
	for i := 0; i < len(s0); i++ {
		m[i] = make([]int, len(s1))
	}
	var b0, b1 []byte = []byte(s0), []byte(s1)
	var l *list.List = list.New()
	var max int
	for i := 0; i < len(b0); i++ {
		for j := 0; j < len(b1); j++ {
			if b0[i] == b1[j] {
				if i == 0 || j == 0 {
					m[i][j] = 1
				} else {
					m[i][j] = m[i-1][j-1] + 1
				}
				if m[i][j] >= max {
					if m[i][j] > max {
						l = list.New()
					}
					l.PushBack(buildSubstring(b0, max, i))
					max = m[i][j]
				}
			}
		}
	}
	return l
}

func buildSubstring(b []byte, max, i int) string {
	var o []byte = make([]byte, max)
	for k, n := i-max+1, 0; k <= i; k, n = k+1, n+1 {
		o[n] = b[k]
	}
	return string(o)
}

func main() {
	var s0, s1 string = "cats and dogs", "dogs and cats"
	l := lcs(s0, s1)
	e := l.Front()
	for e != nil {
		fmt.Println(e.Value.(string))
		e = e.Next()
	}
}

repository: adammorley/go-practice

license_type: permissive

repo_name: adammorley/go-practice

branch_name: refs/heads/master

extension: go


text:
@inproceedings{2000-PBM+,
 address = {Los Alamitos, CA},
 author = {Rob Pennington and David A. Bader and Barney Maccabe and Patricia A. Kovatch and Stephen L. Scott},
 bibsource = {dblp computer science bibliography, https://dblp.org},
 biburl = {https://dblp.org/rec/bib/conf/cluster/PenningtonBMKS00},
 booktitle = {2000 IEEE International Conference on Cluster Computing (CLUSTER 2000), November 28th - December 1st, 2000, Technische Universität Chemnitz, Saxony, Germany},
 doi = {10.1109/CLUSTER.2000.10029},
 groups = {Edited},
 pages = {1--2},
 publisher = {IEEE Computer Society},
 timestamp = {Fri, 24 Oct 2014 13:41:23 +0200},
 title = {Tutorial A: Design and Analysis of High Performance Clusters},
 url = {http://doi.ieeecomputersociety.org/10.1109/CLUSTER.2000.10029},
 year = {2000}
}

license: MIT

gha_license_id: MIT

gha_language: Shell

extension: bib


text:
# base recipe: meta/recipes-support/libyaml/libyaml_0.2.1.bb
# base branch: warrior
# base commit: c441b34e42b097ec6eeeeacacd7e95c36322b258

SUMMARY = "LibYAML is a YAML 1.1 parser and emitter written in C."
DESCRIPTION = "LibYAML is a C library for parsing and emitting data in YAML 1.1, \
a human-readable data serialization format. "
HOMEPAGE = "http://pyyaml.org/wiki/LibYAML"
SECTION = "libs/devel"

LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=5591701d32590f9fa94f3bfee820b634"

inherit debian-package
require recipes-debian/sources/${BPN}.inc
DEBIAN_UNPACK_DIR = "${WORKDIR}/${BPN}-dist-${PV}"
DEBIAN_QUILT_PATCHES = ""

inherit autotools

BBCLASSEXTEND = "native nativesdk"

repository: mozoko/meta-debian-extended

repo_name: mozoko/meta-debian-extended

branch_name: refs/heads/warrior

extension: bb


text:
@InProceedings{GK2015,
  author        = {Jens Groth and Markulf Kohlweiss},
  editor        = {Elisabeth Oswald and Marc Fischlin},
  title         = {One-out-of-Many Proofs: Or How to Leak a Secret and Spend a Coin},
  booktitle     = {Advances in Cryptology - EUROCRYPT 2015},
  year          = {2015},
  publisher     = {Springer Berlin Heidelberg},
  pages         = {253--280},
  abstract = {We construct a 3-move public coin special honest verifier zero-knowledge proof, a so-called Sigma-protocol, for a list of commitments having at least one commitment that opens to 0. It is not required for the prover to know openings of the other commitments. The proof system is efficient, in particular in terms of communication requiring only the transmission of a logarithmic number of commitments.},
  isbn          = {978-3-662-46803-6},
  url           = {https://eprint.iacr.org/2014/764},
  note          = {IACR ePrint Archive 2014/764},
}

@InProceedings{Groth16,
  author        = {Groth, Jens},
  editor        = {Fischlin, Marc and Coron, Jean-S{\'e}bastien},
  title         = {On the Size of Pairing-Based Non-interactive Arguments},
  booktitle     = {Advances in Cryptology -- EUROCRYPT 2016},
  year          = {2016},
  publisher     = {Springer Berlin Heidelberg},
  address       = {Berlin, Heidelberg},
  pages         = {305--326},
  isbn          = {978-3-662-49896-5},
  url           = {https://eprint.iacr.org/2016/260},
  note          = {IACR ePrint Archive 2016/260},
}

@InProceedings{RandomizationGroth16,
    author       = {Karim Baghery and Markulf Kohlweiss and Janno Siim and Mikhail Volkhov},
    title        = {Another Look at Extraction and Randomization of Groth's zk-SNARK},
    editor = "Borisov, Nikita and Diaz, Claudia",
    booktitle = "Financial Cryptography and Data Security",
    year = "2021",
    publisher = "Springer Berlin Heidelberg",
    address = "Berlin, Heidelberg",
    pages = "457--475",
    abstract = "Due to the simplicity and performance of zk-SNARKs they are widely used in real-world cryptographic protocols, including blockchain and smart contract systems. Simulation Extractability (SE) is a necessary security property for a NIZK argument to achieve Universal Composability (UC), a common requirement for such protocols. Most of the works that investigate SE focus on its strong variant which implies proof non-malleability. In this work we investigate a relaxed weaker notion, that allows proof randomization, while guaranteeing statement non-malleability, which we argue to be a more natural security property. First, we show that it is already achievable by Groth16, arguably the most efficient and widely deployed SNARK nowadays. Second, we show that because of this, Groth16 can be efficiently transformed into a black-box weakly SE NIZK, which is sufficient for UC protocols.",
    isbn = "978-3-662-64322-8",
    note = {\url{https://ia.cr/2020/811}},
    url = {https://ia.cr/2020/811},
}

@InProceedings{cryptoeprint:2019/1162,
    title={Subversion-Resistant Simulation (Knowledge) Sound NIZKs},
    author={Karim Baghery},
    editor="Albrecht, Martin",
    booktitle="Cryptography and Coding",
    year="2019",
    publisher="Springer International Publishing",
    address="Cham",
    pages="42--63",
    abstract="In ASIACRYPT 2016, Bellare, Fuchsbauer and Scafuro studied security of non-interactive zero-knowledge (NIZK) arguments in the face of parameter subversion. They showed that achieving subversion soundness (soundness without trusting to the third party) and standard zero-knowledge is impossible at the same time. On the positive side, in the best case, they showed that one can achieve subversion zero-knowledge (zero-knowledge without trusting to the third party) and soundness at the same time. In this paper, we show that one can amplify their best positive result and construct NIZK arguments that can achieve subversion zero-knowledge and simulation (knowledge) soundness at the same time. Simulation (knowledge) soundness is a stronger notion in comparison with (knowledge) soundness, as it also guarantees non-malleability of proofs. Such stronger security guarantee is a must in practical systems. To prove the result, we show that given a NIZK argument that achieves Sub-ZK and (knowledge) soundness, one can use an OR-based construction to define a new language and build a NIZK argument that will guarantee Sub-ZK and simulation (knowledge) soundness at the same time. We instantiate the construction with the state-of-the-art zk-SNARK proposed by Groth [Eurocrypt 2016] and obtain an efficient SNARK that guarantees Sub-ZK and simulation knowledge soundness.",
      doi = "10.1007/978-3-030-35199-1_3",
      isbn="978-3-030-35199-1",
      note = {\url{https://eprint.iacr.org/2019/1162}},
      url = {https://eprint.iacr.org/2019/1162}
}

@InProceedings{cryptoeprint:2019/641,
      author = {Shahla Atapoor and Karim Baghery},
      title = {Simulation Extractability in Groth's zk-SNARK},
      editor="P{\'e}rez-Sol{\`a}, Cristina and Navarro-Arribas, Guillermo and Biryukov, Alex and Garcia-Alfaro, Joaquin",
      title="Simulation Extractability in Groth's zk-SNARK",
      booktitle="Data Privacy Management, Cryptocurrencies and Blockchain Technology",
      year="2019",
      publisher="Springer International Publishing",
      address="Cham",
      pages="336--354",
      abstract="A Simulation Extractable (SE) zk-SNARK enables a prover to prove that she knows a witness for an instance in a way that the proof: (1) is succinct and can be verified very efficiently; (2) does not leak information about the witness; (3) is simulation-extractable -an adversary cannot come out with a new valid proof unless it knows a witness, even if it has already seen arbitrary number of simulated proofs. Non-malleable succinct proofs and very efficient verification make SE zk-SNARKs an elegant tool in various privacy-preserving applications such as cryptocurrencies, smart contracts and etc. In Eurocrypt 2016, Groth proposed the most efficient pairing-based zk-SNARK in the CRS model, but its proof is vulnerable to the malleability attacks. In this paper, we show that one can efficiently achieve simulation extractability in Groth's zk-SNARK by some changes in the underlying language using an OR construction. Analysis and implementations show that in practical cases overload has minimal effects on the efficiency of original scheme which currently is the most efficient zk-SNARK. In new construction, proof size is extended with one element from {\$}{\$}{\{}{\backslash}mathbb {\{}G{\}}{\}}{\_}1{\$}{\$}, one element from {\$}{\$}{\{}{\backslash}mathbb {\{}G{\}}{\}}{\_}2{\$}{\$}, plus a bit string that totally is less than 256 bytes for 128-bit security. Its verification is dominated with 4 pairings which is the most efficient verification among current SE zk-SNARKs.",
      doi="10.1007/978-3-030-31500-9_22",
      isbn="978-3-030-31500-9",
      note = {\url{https://eprint.iacr.org/2019/641}},
      url = {https://eprint.iacr.org/2019/641},
}

@InProceedings{cryptoeprint:2020/1306,
      author = {Oussama Amine and Karim Baghery and Zaira Pindado and Carla R{\`a}fols},
      title = {Simulation Extractable Versions of Groth’s zk-SNARK Revisited},
      booktitle="Cryptology and Network Security",
      year="2020",
      publisher="Springer International Publishing",
      address="Cham",
      pages="453--461",
      abstract="Among various NIZK arguments, zk-SNARKs are the most efficient constructions in terms of proof size and verification which are two critical criteria for large scale applications. Currently, Groth's construction, {\$}{\$}{\backslash}textsf {\{}Groth16{\}}{\$}{\$}Groth16, from Eurocrypt'16 is the most efficient and widely deployed one. However, it is proven to achieve only knowledge soundness, which does not prevent attacks from the adversaries who have seen simulated proofs. There has been considerable progress in modifying {\$}{\$}{\backslash}textsf {\{}Groth16{\}}{\$}{\$}Groth16to achieve simulation extractability to guarantee the non-malleability of proofs. We revise the Simulation Extractable (SE) version of {\$}{\$}{\backslash}textsf {\{}Groth16{\}}{\$}{\$}Groth16proposed by Bowe and Gabizon that has the most efficient prover and {\$}{\$}{\backslash}mathsf {\{}crs{\}}{\$}{\$}crssize among the candidates, although it adds Random Oracle (RO) to the original construction. We present a new version which requires 4 parings in the verification, instead of 5. We also get rid of the RO at the cost of a collision resistant hash function and a single new element in the {\$}{\$}{\backslash}mathsf {\{}crs{\}}{\$}{\$}crs. Our construction is proven in the generic group model and seems to result in the most efficient SE variant of {\$}{\$}{\backslash}textsf {\{}Groth16{\}}{\$}{\$}Groth16in most dimensions.",
      isbn="978-3-030-65411-5",
      doi = "10.1007/978-3-030-65411-5_22",
      note = {\url{https://eprint.iacr.org/2020/1306}},
      url = {https://eprint.iacr.org/2020/1306},
}

@inproceedings{10.1007/11818175_5,
    author = {Melissa Chase and Anna Lysyanskaya},
    title = {On Signatures of Knowledge},
    editor="Dwork, Cynthia",
    booktitle="Advances in Cryptology - CRYPTO 2006",
    year = {2006},
    month = {08},
    pages = {78-96},
    publisher="Springer Berlin Heidelberg",
    address="Berlin, Heidelberg",
abstract="In a traditional signature scheme, a signature $\sigma$ on a message $m$ is issued under a public key PK, and can be interpreted as follows: ``The owner of the public key PK and its corresponding secret key has signed message $m$.'' In this paper we consider schemes that allow one to issue signatures on behalf of any NP statement, that can be interpreted as follows: ``A person in possession of a witness $w$ to the statement that $x \in L$ has signed message $m$.'' We refer to such schemes as signatures of knowledge.",
    isbn = {978-3-540-37432-9},
    doi = {10.1007/11818175_5},
    note = {\url{https://eprint.iacr.org/2006/184}},
    url = {https://eprint.iacr.org/2006/184}
}

@InProceedings{   bccgp2016,
  author        = {Bootle, Jonathan and Cerulli, Andrea and Chaidos, Pyrros
                  and Groth, Jens and Petit, Christophe},
  editor        = {Fischlin, Marc and Coron, Jean-S{\'e}bastien},
  title         = {Efficient Zero-Knowledge Arguments for Arithmetic Circuits
                  in the Discrete Log Setting},
  booktitle     = {Advances in Cryptology -- EUROCRYPT 2016},
  year          = {2016},
  publisher     = {Springer Berlin Heidelberg},
  address       = {Berlin, Heidelberg},
  pages         = {327--357},
  isbn          = {978-3-662-49896-5},
  url           = {https://eprint.iacr.org/2016/263},
  note          = {IACR ePrint Archive 2016/263},
}

@InProceedings{   bulletproofs,
  author        = {B{\"u"}nz, Benedikt and Bootle, Jonathan and Boneh, Dan and
                  Poelstra, Andrew and Wuille, Pieter and Maxwell, Greg},
  booktitle     = {2018 IEEE Symposium on Security and Privacy (SP)},
  title         = {Bulletproofs: Short Proofs for Confidential Transactions
                  and More},
  year          = {2018},
  month         = {May},
  pages         = {319--338},
  doi           = {10.1109/SP.2018.00020},
  issn          = {2375-1207},
  url           = {https://eprint.iacr.org/2017/1066},
  note          = {IACR ePrint Archive 2017/1066},
}

@phdthesis{  RyanHenryPhD,
  author        = {Ryan Henry},
  title         = {Efficient Zero-Knowledge Proofs and Applications},
  school        = {University of Waterloo},
  year          = {2014},
  month         = {August},
  note          = {http://hdl.handle.net/10012/8621},
  url           = {https://uwspace.uwaterloo.ca/bitstream/handle/10012/8621/Henry_Ryan.pdf},
}

@inproceedings{HenryGoldberg13,
  author = {Henry, Ryan and Goldberg, Ian},
  year = {2013},
  month = {06},
  pages = {502-517},
  title = {Batch Proofs of Partial Knowledge},
  doi = {10.1007/978-3-642-38980-1_32}
}

@inproceedings{ZEXE,
  booktitle={2020 IEEE Symposium on Security and Privacy (SP)},   title={ZEXE: Enabling Decentralized Private Computation},
  year={2020},
  volume={},
  number={},
  pages={947--964},
  doi={10.1109/SP40000.2020.00050},
  author = {Sean Bowe and Alessandro Chiesa and Matthew Green and Ian Miers and Pratyush Mishra and Howard Wu},
  title = {Zexe: Enabling Decentralized Private Computation},
}

@misc{plonk,
      author = {Ariel Gabizon and Zachary J.  Williamson and Oana Ciobotaru},
      title = {PLONK: Permutations over Lagrange-bases for Oecumenical Noninteractive arguments of Knowledge},
      howpublished = {Cryptology ePrint Archive, Paper 2019/953},
      year = {2019},
      note = {\url{https://eprint.iacr.org/2019/953}},
      url = {https://eprint.iacr.org/2019/953}
}

@misc{plookup,
    author = {Ariel Gabizon and Zachary J. Williamson},
    title = {plookup: A simplified polynomial protocol for lookup tables},
    howpublished = {Cryptology ePrint Archive, Report 2020/315},
    year = {2020},
    url = {https://eprint.iacr.org/2020/315},
}

@misc{poseidon,
      author = {Lorenzo Grassi and Dmitry Khovratovich and Christian Rechberger and Arnab Roy and Markus Schofnegger},
      title = {Poseidon: A New Hash Function for Zero-Knowledge Proof Systems},
      howpublished = {Cryptology ePrint Archive, Paper 2019/458},
      year = {2019},
      note = {\url{https://eprint.iacr.org/2019/458}},
      url = {https://eprint.iacr.org/2019/458}
}

@misc{cryptoeprint:2019:1185,
  title = {Formalising $\Sigma$-Protocols and Commitment Schemes using CryptHOL},
  author = {David Butler and Andreas Lochbihler and David Aspinall and Adri{\`a} Gasc{\'o}n},
  howpublished = {Cryptology ePrint Archive, Report 2019/1185},
  year = {2019},
  note = {\url{https://ia.cr/2019/1185}},
  url = {https://ia.cr/2019/1185},
}

@article{zkfunc,
	title={New techniques for noninteractive zero-knowledge},
	author={Groth, Jens and Ostrovsky, Rafail and Sahai, Amit},
	journal={Journal of the ACM (JACM)},
	volume={59},
	number={3},
	pages={1--35},
	year={2012},
	publisher={ACM New York, NY, USA}
}

@misc{LegoSNARK,
      author = {Matteo Campanelli and Dario Fiore and Ana\"{\i}s Querol},
      title = {LegoSNARK: Modular Design and Composition of Succinct Zero-Knowledge Proofs},
      howpublished = {Cryptology ePrint Archive, Paper 2019/142},
      year = {2019},
      doi = {10.1145/3319535.3339820},
      note = {\url{https://eprint.iacr.org/2019/142}},
      url = {https://eprint.iacr.org/2019/142}
}

@misc{zcash_protocol,
  title = {{ZCash} Protocol Specification},
  author = {Daira Hopwood and Sean Bowe and Taylor Hornby and Nathan Wilcox},
  howpublished = {\url{https://zips.z.cash/protocol/protocol.pdf}},
  note = {Version 2022.3.8 [NU5], 15 September 2022.}
}

@misc{GGPR13,
author= {Rosario Gennaro and Craig Gentry and Bryan Parno and Mariana Raykova},
title = {Quadratic Span Programs and Succinct NIZKs without PCPs},
howpublished = {Cryptology ePrint Archive, Paper 2012/215, 2012},
year= {2012},
note = {\url{https://eprint.iacr.org/2012/215}},
url = {https://eprint.iacr.org/2012/215}
}

@misc{subversion_zk,
author = {Behzad Abdolmaleki and Karim Baghery and Helger Lipmaa and Michal Zajac},
title = {A Subversion-Resistant SNARK},
howpublished = {Cryptology ePrint Archive, Paper 2017/599, 2017},
year = {2017},
note = {\url{https://eprint.iacr.org/2017/599}},
url = {https://eprint.iacr.org/2017/599}
}

@misc{Fuchs_AGM,
author = {Georg Fuchsbauer and Eike Kiltz and Julian Loss},
title = {The Algebraic Group Model and its Applications},
howpublished = {Cryptology ePrint Archive, Paper 2017/620, 2017},
year = {2017},
note = {\url{https://eprint.iacr.org/2017/620}},
url = {https://eprint.iacr.org/2017/620}
}

@inproceedings{bening_auxiliary,
author = {Bitansky, Nir and Canetti, Ran and Paneth, Omer and Rosen, Alon},
title = {On the Existence of Extractable One-Way Functions},
booktitle = {Proceedings of the Forty-Sixth Annual ACM Symposium on Theory of Computing},
year = {2014},
url = {https://doi.org/10.1145/2591796.2591859},
doi = {10.1145/2591796.2591859},
}

@misc{Kilian1990UsesOR,
  title={Uses of randomness in algorithms and protocols},
  author={Joe Kilian},
  howpublished = {PhD Thesis. Massachusetts Institute of Technology},
  year={1990}
}

@article{CLOS02,
author = {Canetti, Ran and Lindell, Yehuda and Ostrovsky, Rafail and Sahai, Amit},
title = {Universally Composable Two-Party and Multi-Party Secure Computation},
journal = {Conference Proceedings of the Annual ACM Symposium on Theory of Computing},
year = {2003}
}

gha_language: TeX


text:
# Copyright (C) 2014 O.S. Systems Software LTDA.

DESCRIPTION = "Target packages for Qt5 SDK"
LICENSE = "MIT"

inherit packagegroup

PACKAGEGROUP_DISABLE_COMPLEMENTARY = "1"

# Requires meta-ruby to work
USE_RUBY = " \
    qtquick1-dev \
    qtquick1-mkspecs \
    qtquick1-plugins \
    qtquick1-qmlplugins \
    qttranslations-qtquick1 \
    qtwebkit-dev \
    qtwebkit-mkspecs \
    qtwebkit-qmlplugins \
"

# Requires Wayland to work
USE_WAYLAND = " \
    qtwayland-dev \
    qtwayland-mkspecs \
    qtwayland-plugins \
    qtwayland-tools \
"

# Requires X11 to work
USE_X11 = " \
    qtx11extras-dev \
    qtx11extras-mkspecs \
"

RDEPENDS_${PN} += " \
    packagegroup-core-standalone-sdk-target \
    qtbase-dev \
    qtbase-fonts \
    qtbase-mkspecs \
    qtbase-plugins \
    qtbase-staticdev \
    qtconnectivity-dev \
    qtconnectivity-mkspecs \
    qttranslations-qtconnectivity \
    qtimageformats-dev \
    qtimageformats-plugins \
    qtmultimedia-dev \
    qtmultimedia-mkspecs \
    qtmultimedia-plugins \
    qtserialport-dev \
    qtserialport-mkspecs \
    qtsvg-dev \
    qtsvg-mkspecs \
    qtsvg-plugins \
    qtsystems-dev \
    qtsystems-mkspecs \
    qttools-dev \
    qttools-mkspecs \
    qttools-staticdev \
    qttools-tools \
    qtwebsockets-dev \
    qtwebsockets-mkspecs \
    qtwebchannel-dev \
    qtwebchannel-mkspecs \
    qtxmlpatterns-dev \
    qtxmlpatterns-mkspecs \
    qttranslations-qtxmlpatterns \
"

RRECOMMENDS_${PN} += " \
    qtquickcontrols-qmlplugins \
"


text:
# base recipe: meta/recipes-graphics/startup-notification/startup-notification_0.12.bb
# base branch: warrior
# base commit: ba78a365ee97e2b4c6eddbf603ca6f0eb2bc8e17

SUMMARY = "Enables monitoring and display of application startup"
HOMEPAGE = "http://www.freedesktop.org/wiki/Software/startup-notification/"
BUGTRACKER = "https://bugs.freedesktop.org/enter_bug.cgi?product=Specifications"

inherit debian-package
require recipes-debian/sources/startup-notification.inc
DEBIAN_QUILT_PATCHES = ""
FILESPATH_append = ":${COREBASE}/meta/recipes-graphics/startup-notification/startup-notification-0.12"

# most files are under MIT, but libsn/sn-util.c is under LGPL, the
# effective license is LGPL
LICENSE = "LGPLv2+"
LIC_FILES_CHKSUM = "file://COPYING;md5=a2ae2cd47d6d2f238410f5364dfbc0f2 \
                    file://libsn/sn-util.c;endline=18;md5=18a14dc1825d38e741d772311fea9ee1 \
                    file://libsn/sn-common.h;endline=23;md5=6d05bc0ebdcf5513a6e77cb26e8cd7e2 \
                    file://test/test-boilerplate.h;endline=23;md5=923e706b2a70586176eead261cc5bb98"

SECTION = "libs"

DEPENDS = "virtual/libx11 libsm xcb-util"

inherit autotools pkgconfig distro_features_check
# depends on virtual/libx11
REQUIRED_DISTRO_FEATURES = "x11"

SRC_URI += "\
           file://obsolete_automake_macros.patch \
"

repository: miraclelinux/meta-debian-extended

repo_name: miraclelinux/meta-debian-extended

gha_language: BitBake


text:
LICENSE     = "LiPS"
DESCRIPTION = "Extended widget library for GPE phone environment."
SECTION = "gpe/libs"
PRIORITY    = "optional"
DEPENDS     = "gtk+ libiac libgpephone"
PR          = "r1"

GPE_TARBALL_SUFFIX = "bz2"
inherit gpephone pkgconfig autotools

# This really is not angstrom specific, but gtk 2.10 specific
# for a better solution: "patches accepted"
SRC_URI_append_angstrom = " file://gemfilechooser-NULL-callback.patch"

SRC_URI[md5sum] = "95d269ad7e7cb7d3032498ad2e47643b"
SRC_URI[sha256sum] = "b8a1da871aa34362caf0c76dcbd3df42aef7313a4ed08f38eddcb159b80302c5"
# CHECKSUMS.INI MISMATCH: I got this:
#SRC_URI[md5sum] = "f5ac1c6a22120581659588a9d507dc06"
#SRC_URI[sha256sum] = "4d98b3999a79244856edabf8d99874f7fb665e5eb129af1360529c41df29dc4c"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
@article{tao2020nnd,
  title = {Neural Network Deconvolution Method for Resolving Pathway-Level Progression of Tumor Clonal Expression Programs with Application to Breast Cancer Brain Metastases},
  author = {Tao, Yifeng and Lei, Haoyun and Lee, Adrian V. and Ma, Jian and Schwartz, Russell},
  journal = {Frontiers in Physiology},
  volume = {11},
  pages = {1055},
  year = {2020},
  url = {https://www.frontiersin.org/article/10.3389/fphys.2020.01055},
  doi = {10.3389/fphys.2020.01055},
  issn = {1664-042X},
}


text:
@article{MR3299285,
 author = {Manzano, José M. and Rodríguez, M. Magdalena},
 doi = {10.1007/s12220-013-9431-8},
 fjournal = {Journal of Geometric Analysis},
 issn = {1050-6926},
 journal = {J. Geom. Anal.},
 mrclass = {53A10 (49Q05 53C30 53C42)},
 mrnumber = {3299285},
 mrreviewer = {Eugene V. Petrov},
 number = {1},
 pages = {336--346},
 title = {On complete constant mean curvature vertical multigraphs in
$\BbbE(ąppa,τ)$},
 url = {https://doi.org/10.1007/s12220-013-9431-8},
 volume = {25},
 year = {2015}
}

repository: torralbofco/geometric-analysis-fork

repo_name: torralbofco/geometric-analysis-fork


text:
package config

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

// Command is a combination of config and command line
type Command struct {
	Conf      *viper.Viper
	Cmd       *cobra.Command
	EnvPrefix string
}

repository: Orange-OpenSource/optisam-backend

repo_name: Orange-OpenSource/optisam-backend

gha_language: Go


text:
package resize

import (
	"github.com/astaxie/beego/logs"
	"github.com/nfnt/resize"
	"image/jpeg"
	"image/png"
	"os"
)

func ResizePng(open string, filepath string) {
	log := logs.GetLogger()
	file, err := os.Open(open)
	if err != nil {
		log.Println(err.Error())
		return
	}
	// decode png into image.Image
	img, err := png.Decode(file)
	if err != nil {
		log.Println(err.Error())
		return
	}

	// resize to width 60 using Lanczos resampling
	// and preserve aspect ratio
	m := resize.Thumbnail(200, 0, img, resize.Lanczos3)

	out, err := os.Create(filepath)
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer out.Close()

	// write new image to file
	png.Encode(out, m)
}

func ResizeJpg(open string, filepath string) {
	log := logs.GetLogger()
	file, err := os.Open(open)
	if err != nil {
		log.Println(err.Error())
		return
	}

	// decode jpeg into image.Image
	img, err := jpeg.Decode(file)
	if err != nil {
		log.Println(err.Error())
		return
	}
	file.Close()

	// and preserve aspect ratio
	m := resize.Thumbnail(200, 0, img, resize.Lanczos3)

	out, err := os.Create(filepath)
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer out.Close()

	// write new image to file
	jpeg.Encode(out, m, nil)
}

repository: ewasion/manga

repo_name: ewasion/manga


text:
package ladybug

// ladybug
type ClusterList struct {
	Kind     string        `json:"kind"`
	Clusters []ClusterInfo `json:"items"`
}

repository: cloud-barista/cb-webtool

repo_name: cloud-barista/cb-webtool

gha_language: JavaScript


text:
KBRANCH ?= "dev-5.4"
LINUX_VERSION ?= "5.4.26"

SRCREV="1440369fcdef35f5b30dde253032188fd9611af8"

require linux-aspeed.inc


text:
package mailer

func TransmitRoutineTxTryR(mailer *Mailer) TransmitRoutineResult {

	/* Check The Queue */
	if mailer.queue.IsEmpty() {

		/* TheQueue is empty */
		mailer.txState = TxReadS
		return TxContinue

	} else {

		/* TheQueue is not empty */
		ProcessTheQueue(mailer)
		return TxContinue

	}

	panic("unknown case or memory corruption")

}


text:
//* Responsible for attesting the physical nodes identity.  The plugin
//will be responsible to retrieve an identity document or data associated
//with the physical node.  This data will be used when attesting to the server.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.26.0
// 	protoc        v3.14.0
// source: spire/plugin/agent/nodeattestor/v0/nodeattestor.proto

package nodeattestorv0

import (
	common "github.com/spiffe/spire/proto/spire/common"
	plugin "github.com/spiffe/spire/proto/spire/common/plugin"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

//* Represents an empty request
type FetchAttestationDataRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Challenge []byte `protobuf:"bytes,1,opt,name=challenge,proto3" json:"challenge,omitempty"`
}

func (x *FetchAttestationDataRequest) Reset() {
	*x = FetchAttestationDataRequest{}
	if protoimpl.UnsafeEnabled {
		mi := &file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *FetchAttestationDataRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FetchAttestationDataRequest) ProtoMessage() {}

func (x *FetchAttestationDataRequest) ProtoReflect() protoreflect.Message {
	mi := &file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_msgTypes[0]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FetchAttestationDataRequest.ProtoReflect.Descriptor instead.
func (*FetchAttestationDataRequest) Descriptor() ([]byte, []int) {
	return file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_rawDescGZIP(), []int{0}
}

func (x *FetchAttestationDataRequest) GetChallenge() []byte {
	if x != nil {
		return x.Challenge
	}
	return nil
}

//* Represents the attested data and base SPIFFE ID
type FetchAttestationDataResponse struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	//* A type which contains attestation data for specific platform
	AttestationData *common.AttestationData `protobuf:"bytes,1,opt,name=attestation_data,json=attestationData,proto3" json:"attestation_data,omitempty"`
	//* response to the challenge (if challenge was present) *
	Response []byte `protobuf:"bytes,3,opt,name=response,proto3" json:"response,omitempty"`
}

func (x *FetchAttestationDataResponse) Reset() {
	*x = FetchAttestationDataResponse{}
	if protoimpl.UnsafeEnabled {
		mi := &file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *FetchAttestationDataResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FetchAttestationDataResponse) ProtoMessage() {}

func (x *FetchAttestationDataResponse) ProtoReflect() protoreflect.Message {
	mi := &file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_msgTypes[1]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FetchAttestationDataResponse.ProtoReflect.Descriptor instead.
func (*FetchAttestationDataResponse) Descriptor() ([]byte, []int) {
	return file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_rawDescGZIP(), []int{1}
}

func (x *FetchAttestationDataResponse) GetAttestationData() *common.AttestationData {
	if x != nil {
		return x.AttestationData
	}
	return nil
}

func (x *FetchAttestationDataResponse) GetResponse() []byte {
	if x != nil {
		return x.Response
	}
	return nil
}

var File_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto protoreflect.FileDescriptor

var file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_rawDesc = []byte{
	0x0a, 0x35, 0x73, 0x70, 0x69, 0x72, 0x65, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2f, 0x61,
	0x67, 0x65, 0x6e, 0x74, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x6f,
	0x72, 0x2f, 0x76, 0x30, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x6f,
	0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x73, 0x70, 0x69, 0x72, 0x65, 0x2e, 0x61,
	0x67, 0x65, 0x6e, 0x74, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x6f,
	0x72, 0x1a, 0x19, 0x73, 0x70, 0x69, 0x72, 0x65, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f,
	0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x73, 0x70,
	0x69, 0x72, 0x65, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69,
	0x6e, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x3b,
	0x0a, 0x1b, 0x46, 0x65, 0x74, 0x63, 0x68, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69,
	0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a,
	0x09, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c,
	0x52, 0x09, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x22, 0x8a, 0x01, 0x0a, 0x1c,
	0x46, 0x65, 0x74, 0x63, 0x68, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
	0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x48, 0x0a, 0x10,
	0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x61, 0x74, 0x61,
	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x73, 0x70, 0x69, 0x72, 0x65, 0x2e, 0x63,
	0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f,
	0x6e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x0f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69,
	0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e,
	0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e,
	0x73, 0x65, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x32, 0xde, 0x02, 0x0a, 0x0c, 0x4e, 0x6f, 0x64,
	0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x12, 0x89, 0x01, 0x0a, 0x14, 0x46, 0x65,
	0x74, 0x63, 0x68, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61,
	0x74, 0x61, 0x12, 0x35, 0x2e, 0x73, 0x70, 0x69, 0x72, 0x65, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74,
	0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x2e, 0x46, 0x65,
	0x74, 0x63, 0x68, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61,
	0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x73, 0x70, 0x69, 0x72,
	0x65, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x61, 0x74, 0x74, 0x65,
	0x73, 0x74, 0x6f, 0x72, 0x2e, 0x46, 0x65, 0x74, 0x63, 0x68, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74,
	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
	0x65, 0x28, 0x01, 0x30, 0x01, 0x12, 0x5a, 0x0a, 0x09, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75,
	0x72, 0x65, 0x12, 0x25, 0x2e, 0x73, 0x70, 0x69, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f,
	0x6e, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75,
	0x72, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x73, 0x70, 0x69, 0x72,
	0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2e,
	0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
	0x65, 0x12, 0x66, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x49, 0x6e,
	0x66, 0x6f, 0x12, 0x29, 0x2e, 0x73, 0x70, 0x69, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f,
	0x6e, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x6c, 0x75, 0x67,
	0x69, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e,
	0x73, 0x70, 0x69, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x6c, 0x75,
	0x67, 0x69, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x49, 0x6e, 0x66,
	0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x51, 0x5a, 0x4f, 0x67, 0x69, 0x74,
	0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x70, 0x69, 0x66, 0x66, 0x65, 0x2f, 0x73,
	0x70, 0x69, 0x72, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x73, 0x70, 0x69, 0x72, 0x65,
	0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2f, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2f, 0x6e, 0x6f,
	0x64, 0x65, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x2f, 0x76, 0x30, 0x3b, 0x6e, 0x6f,
	0x64, 0x65, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x76, 0x30, 0x62, 0x06, 0x70, 0x72,
	0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_rawDescOnce sync.Once
	file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_rawDescData = file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_rawDesc
)

func file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_rawDescGZIP() []byte {
	file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_rawDescOnce.Do(func() {
		file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_rawDescData = protoimpl.X.CompressGZIP(file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_rawDescData)
	})
	return file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_rawDescData
}

var file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_goTypes = []interface{}{
	(*FetchAttestationDataRequest)(nil),  // 0: spire.agent.nodeattestor.FetchAttestationDataRequest
	(*FetchAttestationDataResponse)(nil), // 1: spire.agent.nodeattestor.FetchAttestationDataResponse
	(*common.AttestationData)(nil),       // 2: spire.common.AttestationData
	(*plugin.ConfigureRequest)(nil),      // 3: spire.common.plugin.ConfigureRequest
	(*plugin.GetPluginInfoRequest)(nil),  // 4: spire.common.plugin.GetPluginInfoRequest
	(*plugin.ConfigureResponse)(nil),     // 5: spire.common.plugin.ConfigureResponse
	(*plugin.GetPluginInfoResponse)(nil), // 6: spire.common.plugin.GetPluginInfoResponse
}
var file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_depIdxs = []int32{
	2, // 0: spire.agent.nodeattestor.FetchAttestationDataResponse.attestation_data:type_name -> spire.common.AttestationData
	0, // 1: spire.agent.nodeattestor.NodeAttestor.FetchAttestationData:input_type -> spire.agent.nodeattestor.FetchAttestationDataRequest
	3, // 2: spire.agent.nodeattestor.NodeAttestor.Configure:input_type -> spire.common.plugin.ConfigureRequest
	4, // 3: spire.agent.nodeattestor.NodeAttestor.GetPluginInfo:input_type -> spire.common.plugin.GetPluginInfoRequest
	1, // 4: spire.agent.nodeattestor.NodeAttestor.FetchAttestationData:output_type -> spire.agent.nodeattestor.FetchAttestationDataResponse
	5, // 5: spire.agent.nodeattestor.NodeAttestor.Configure:output_type -> spire.common.plugin.ConfigureResponse
	6, // 6: spire.agent.nodeattestor.NodeAttestor.GetPluginInfo:output_type -> spire.common.plugin.GetPluginInfoResponse
	4, // [4:7] is the sub-list for method output_type
	1, // [1:4] is the sub-list for method input_type
	1, // [1:1] is the sub-list for extension type_name
	1, // [1:1] is the sub-list for extension extendee
	0, // [0:1] is the sub-list for field type_name
}

func init() { file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_init() }
func file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_init() {
	if File_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto != nil {
		return
	}
	if !protoimpl.UnsafeEnabled {
		file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*FetchAttestationDataRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*FetchAttestationDataResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_rawDesc,
			NumEnums:      0,
			NumMessages:   2,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_goTypes,
		DependencyIndexes: file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_depIdxs,
		MessageInfos:      file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_msgTypes,
	}.Build()
	File_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto = out.File
	file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_rawDesc = nil
	file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_goTypes = nil
	file_spire_plugin_agent_nodeattestor_v0_nodeattestor_proto_depIdxs = nil
}

repository: lumjjb/spire

repo_name: lumjjb/spire

branch_name: refs/heads/main


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{Torstensson2012,
abstract = {This study investigates the applicability of node.js for developing web services. Node.js is a software platform for developing event-driven networking applica- tions using JavaScript. Moreover, the language JavaScript is discussed regarding features that facilitate development of event-driven software.},
author = {Torstensson, Erik Eloff {\&} Daniel},
file = {:Users/sepmein/Qsync/Papers/Torstensson{\_}2012{\_}An Investigation into the Applicability of Node . js as a Platform for Web Services.pdf:pdf},
pages = {14},
title = {{An Investigation into the Applicability of Node . js as a Platform for Web Services}},
url = {http://www.diva-portal.org/smash/get/diva2:550993/FULLTEXT01.pdf},
year = {2012}
}

license: Unlicense

repository: sepmein/references

repo_name: sepmein/references


text:
package hash_test

import (
	"encoding/json"
	"fmt"
	"math/rand"
	"testing"
	"time"

	"github.com/postfinance/store"
	"github.com/postfinance/store/hash"
	"github.com/stretchr/testify/require"
)

// nolint: gochecknoglobals
var (
	entries []*store.Entry
	data    []*A
)

// nolint: gochecknoinits
func init() {
	entries = []*store.Entry{}
	data = generate(100000)

	for i, a := range data {
		value, err := json.Marshal(a)
		if err != nil {
			panic(err)
		}

		entries = append(entries, &store.Entry{
			Key:   fmt.Sprintf("key%d", i),
			Value: value,
		})
	}
}

/*
go test -bench . -benchtime=10s
goos: linux
goarch: amd64
pkg: github.com/postfinance/store/hash
BenchmarkUnmarshal100-4            30000            583465 ns/op           81328 B/op       1024 allocs/op
BenchmarkIterate100-4              30000            652154 ns/op           81328 B/op       1024 allocs/op
BenchmarkHandler100-4              30000            489527 ns/op           79736 B/op        832 allocs/op
BenchmarkUnmarshal1000-4            3000           5177122 ns/op          757408 B/op      10030 allocs/op
BenchmarkIterate1000-4              3000           6228008 ns/op          757408 B/op      10030 allocs/op
BenchmarkHandler1000-4              2000           5758885 ns/op          748264 B/op       8041 allocs/op
BenchmarkUnmarshal10000-4            200          69585925 ns/op        11000336 B/op     100050 allocs/op
BenchmarkIterate10000-4              200          69515481 ns/op        11000335 B/op     100050 allocs/op
BenchmarkHandler10000-4              200          66994008 ns/op        11600472 B/op      80069 allocs/op
BenchmarkUnmarshal100000-4            20         731059321 ns/op        109470739 B/op   1000070 allocs/op
BenchmarkIterate100000-4              20         736711026 ns/op        109470740 B/op   1000070 allocs/op
BenchmarkHandler100000-4              20         746221662 ns/op        118637666 B/op    800099 allocs/op
PASS
ok      github.com/postfinance/store/hash       227.357s
*/

func BenchmarkUnmarshal100(b *testing.B)    { benchmarkUnmarshal(100, b) }
func BenchmarkIterate100(b *testing.B)      { benchmarkIterate(100, b) }
func BenchmarkHandler100(b *testing.B)      { benchmarkHandler(100, b) }
func BenchmarkUnmarshal1000(b *testing.B)   { benchmarkUnmarshal(1000, b) }
func BenchmarkIterate1000(b *testing.B)     { benchmarkIterate(1000, b) }
func BenchmarkHandler1000(b *testing.B)     { benchmarkHandler(1000, b) }
func BenchmarkUnmarshal10000(b *testing.B)  { benchmarkUnmarshal(10000, b) }
func BenchmarkIterate10000(b *testing.B)    { benchmarkIterate(10000, b) }
func BenchmarkHandler10000(b *testing.B)    { benchmarkHandler(10000, b) }
func BenchmarkUnmarshal100000(b *testing.B) { benchmarkUnmarshal(100000, b) }
func BenchmarkIterate100000(b *testing.B)   { benchmarkIterate(100000, b) }
func BenchmarkHandler100000(b *testing.B)   { benchmarkHandler(100000, b) }

func benchmarkUnmarshal(max int, b *testing.B) {
	b.StopTimer()

	back, err := hash.New()
	require.NoError(b, err)

	for i := 0; i < max; i++ {
		_, err := back.Put(entries[i])
		require.NoError(b, err)
	}
	b.ReportAllocs()
	b.StartTimer()

	for n := 0; n < b.N; n++ {
		result := []A{}

		_, err := back.Get("key", store.WithPrefix(), store.WithUnmarshal(&result))
		if err != nil {
			b.Error(err)
		}

		if len(result) != max {
			b.Errorf("wrong result %d", len(result))
		}
	}
}

func benchmarkIterate(max int, b *testing.B) {
	b.StopTimer()

	back, err := hash.New()
	require.NoError(b, err)

	for i := 0; i < max; i++ {
		_, err := back.Put(entries[i])
		require.NoError(b, err)
	}
	b.ReportAllocs()
	b.StartTimer()

	for n := 0; n < b.N; n++ {
		result := []A{}

		values, err := back.Get("key", store.WithPrefix(), store.WithUnmarshal(&result))
		if err != nil {
			b.Error(err)
		}

		for _, e := range values {
			a := A{}
			if err := json.Unmarshal(e.Value, &a); err != nil {
				b.Error(err)
			}

			result = append(result, a)
		}

		if len(result) != max {
			b.Errorf("wrong result %d", len(result))
		}
	}
}

func benchmarkHandler(max int, b *testing.B) {
	b.StopTimer()

	back, err := hash.New()
	require.NoError(b, err)

	for i := 0; i < max; i++ {
		_, err := back.Put(entries[i])
		require.NoError(b, err)
	}
	b.ReportAllocs()
	b.StartTimer()

	for n := 0; n < b.N; n++ {
		result := []A{}
		a := A{}

		_, err := back.Get("key", store.WithPrefix(), store.WithHandler(func(k, v []byte) error {
			if err := json.Unmarshal(v, &a); err != nil {
				return err
			}
			result = append(result, a)
			return nil
		}))
		if err != nil {
			b.Error(err)
		}

		if len(result) != max {
			b.Errorf("wrong result %d", len(result))
		}
	}
}

func randString(l int) string {
	buf := make([]byte, l)
	for i := 0; i < (l+1)/2; i++ {
		buf[i] = byte(rand.Intn(256)) // nolint: gosec // G404: Use of weak random number generator (math/rand instead of crypto/rand)
	}

	return fmt.Sprintf("%x", buf)[:l]
}

type A struct {
	Name     string
	BirthDay time.Time
	Phone    string
	Siblings int
	Spouse   bool
	Money    float64
}

func generate(max int) []*A {
	a := make([]*A, 0, max)
	for i := 0; i < max; i++ {
		a = append(a, &A{
			Name:     randString(16),
			BirthDay: time.Now(),
			Phone:    randString(10),
			Siblings: rand.Intn(5),      // nolint: gosec // G404: Use of weak random number generator (math/rand instead of crypto/rand)
			Spouse:   rand.Intn(2) == 1, // nolint: gosec // G404: Use of weak random number generator (math/rand instead of crypto/rand)
			Money:    rand.Float64(),    // nolint: gosec // G404: Use of weak random number generator (math/rand instead of crypto/rand)
		})
	}

	return a
}

repository: rvichery/store

repo_name: rvichery/store


text:
require elfkickers_${PV}.bb
inherit native

ELFPKGS = "sstrip"

do_stage () {
	for d in ${ELFPKGS}; do
		install -m 0755 $d/$d ${bindir}/ || exit 1
	done
}


text:
package utils

import (
	"crypto/rand"
	"encoding/base64"
)

// RandStringBytes Generate random string of n bytes
func RandStringBytes(n int) (string, error) {
	b := make([]byte, n)
	_, err := rand.Read(b)
	if err != nil {
		return "", err
	}
	return base64.StdEncoding.EncodeToString(b), nil
}

repository: codesmith-gmbh/cli

repo_name: codesmith-gmbh/cli


text:
# -*- mode: cmake; -*-
# vi: set ft=cmake:

# BSD 3-Clause License
#
# Copyright (c) 2019, Massachusetts Institute of Technology.
# Copyright (c) 2019, Toyota Research Institute.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
#    list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
#    this list of conditions and the following disclaimer in the documentation
#    and/or other materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its
#    contributors may be used to endorse or promote products derived from
#    this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

if(DASHBOARD_FAILURE OR DASHBOARD_UNSTABLE)
  notice("CTest Status: NOT PUSHING DOCKER IMAGE BECAUSE BAZEL BUILD WAS NOT SUCCESSFUL")
else()
  notice("CTest Status: PUSHING DOCKER IMAGE")

  if(NOT DASHBOARD_UNSTABLE)
    set(DOCKER_LOGIN_ARGS "login --username $ENV{DOCKER_USERNAME} --password-stdin")
    separate_arguments(DOCKER_LOGIN_ARGS_LIST UNIX_COMMAND "${DOCKER_LOGIN_ARGS}")
    execute_process(COMMAND "sudo" "${DASHBOARD_DOCKER_COMMAND}" ${DOCKER_LOGIN_ARGS_LIST}
      RESULT_VARIABLE DOCKER_LOGIN_RESULT_VARIABLE
      INPUT_FILE "$ENV{DOCKER_PASSWORD_FILE}"
      COMMAND_ECHO STDERR)
    if(NOT DOCKER_LOGIN_RESULT_VARIABLE EQUAL 0)
      append_step_status("BAZEL PUSHING DOCKER IMAGE (DOCKER LOGIN)" UNSTABLE)
    endif()
  endif()

  if(NOT DASHBOARD_UNSTABLE)
    set(DOCKER_PUSH_IMAGE_DISTRIBUTION_DATE_ARGS "push robotlocomotion/drake:${DASHBOARD_UNIX_DISTRIBUTION_CODE_NAME}-${DATE}")
    separate_arguments(DOCKER_PUSH_IMAGE_DISTRIBUTION_DATE_ARGS_LIST UNIX_COMMAND "${DOCKER_PUSH_IMAGE_DISTRIBUTION_DATE_ARGS}")
    foreach(RETRIES RANGE 3)
      execute_process(COMMAND "sudo" "${DASHBOARD_DOCKER_COMMAND}" ${DOCKER_PUSH_IMAGE_DISTRIBUTION_DATE_ARGS_LIST}
        RESULT_VARIABLE DOCKER_PUSH_IMAGE_DISTRIBUTION_DATE_RESULT_VARIABLE
        COMMAND_ECHO STDERR)
      if(DOCKER_PUSH_IMAGE_DISTRIBUTION_DATE_RESULT_VARIABLE EQUAL 0)
        break()
      endif()
      sleep(15)
    endforeach()
    if(NOT DOCKER_PUSH_IMAGE_DISTRIBUTION_DATE_RESULT_VARIABLE EQUAL 0)
      append_step_status("BAZEL PUSHING DOCKER IMAGE (ROBOTLOCOMOTION/DRAKE:${DASHBOARD_UNIX_DISTRIBUTION_CODE_NAME}-${DATE})" UNSTABLE)
    endif()
  endif()

  if(NOT DASHBOARD_UNSTABLE)
    set(DOCKER_PUSH_IMAGE_DISTRIBUTION_ARGS "push robotlocomotion/drake:${DASHBOARD_UNIX_DISTRIBUTION_CODE_NAME}")
    separate_arguments(DOCKER_PUSH_IMAGE_DISTRIBUTION_ARGS_LIST UNIX_COMMAND "${DOCKER_PUSH_IMAGE_DISTRIBUTION_ARGS}")
    foreach(RETRIES RANGE 3)
      execute_process(COMMAND "sudo" "${DASHBOARD_DOCKER_COMMAND}" ${DOCKER_PUSH_IMAGE_DISTRIBUTION_ARGS_LIST}
        RESULT_VARIABLE DOCKER_PUSH_IMAGE_DISTRIBUTION_RESULT_VARIABLE
        COMMAND_ECHO STDERR)
      if(DOCKER_PUSH_IMAGE_DISTRIBUTION_RESULT_VARIABLE EQUAL 0)
        break()
      endif()
      sleep(15)
    endforeach()
    if(NOT DOCKER_PUSH_IMAGE_DISTRIBUTION_RESULT_VARIABLE EQUAL 0)
      append_step_status("BAZEL PUSHING DOCKER IMAGE (ROBOTLOCOMOTION/DRAKE:${DASHBOARD_UNIX_DISTRIBUTION_CODE_NAME})" UNSTABLE)
    endif()
  endif()

  if(DASHBOARD_UNIX_DISTRIBUTION_CODE_NAME STREQUAL "focal")
    if(NOT DASHBOARD_UNSTABLE)
      set(DOCKER_PUSH_IMAGE_DATE_ARGS "push robotlocomotion/drake:${DATE}")
      separate_arguments(DOCKER_PUSH_IMAGE_DATE_ARGS_LIST UNIX_COMMAND "${DOCKER_PUSH_IMAGE_DATE_ARGS}")
      foreach(RETRIES RANGE 3)
        execute_process(COMMAND "sudo" "${DASHBOARD_DOCKER_COMMAND}" ${DOCKER_PUSH_IMAGE_DATE_ARGS_LIST}
          RESULT_VARIABLE DOCKER_PUSH_IMAGE_DATE_RESULT_VARIABLE
          COMMAND_ECHO STDERR)
        if(DOCKER_PUSH_IMAGE_DATE_RESULT_VARIABLE EQUAL 0)
          break()
        endif()
        sleep(15)
      endforeach()
      if(NOT DOCKER_PUSH_IMAGE_DATE_RESULT_VARIABLE EQUAL 0)
        append_step_status("BAZEL PUSHING DOCKER IMAGE (ROBOTLOCOMOTION/DRAKE:${DATE})" UNSTABLE)
      endif()
    endif()

    if(NOT DASHBOARD_UNSTABLE)
      set(DOCKER_PUSH_IMAGE_LATEST_ARGS "push robotlocomotion/drake:latest")
      separate_arguments(DOCKER_PUSH_IMAGE_LATEST_ARGS_LIST UNIX_COMMAND "${DOCKER_PUSH_IMAGE_LATEST_ARGS}")
      foreach(RETRIES RANGE 3)
        execute_process(COMMAND "sudo" "${DASHBOARD_DOCKER_COMMAND}" ${DOCKER_PUSH_IMAGE_LATEST_ARGS_LIST}
          RESULT_VARIABLE DOCKER_PUSH_IMAGE_LATEST_RESULT_VARIABLE
          COMMAND_ECHO STDERR)
        if(DOCKER_PUSH_IMAGE_LATEST_RESULT_VARIABLE EQUAL 0)
          break()
        endif()
        sleep(15)
      endforeach()
      if(NOT DOCKER_PUSH_IMAGE_LATEST_RESULT_VARIABLE EQUAL 0)
        append_step_status("BAZEL PUSHING DOCKER IMAGE (ROBOTLOCOMOTION/DRAKE:LATEST)" UNSTABLE)
      endif()
    endif()
  endif()
endif()

repository: jwnimmer-tri/drake-ci

repo_name: jwnimmer-tri/drake-ci

gha_language: CMake

extension: cmake


text:
package dao

import (
	"github.com/teambition/gear"
	"github.com/tidwall/buntdb"
)

func dbError(err error) error {
	if err == nil {
		return nil
	}
	if err == buntdb.ErrNotFound {
		return &gear.Error{Code: 404, Msg: err.Error()}
	}
	if _, ok := err.(*gear.Error); ok {
		return err
	}
	return &gear.Error{Code: 500, Msg: err.Error()}
}

repository: SuneBear/kpass

repo_name: SuneBear/kpass


text:
@article{Steel-Duncan2004,
 abstract = {BACKGROUND: In a few Caribbean islands, prevention of mother-to-child transmission (pMTCT) of HIV with zidovudine prophylaxis has reduced transmission rates from 27 - 44% to 5.5 - 9 %. OBJECTIVES: To highlight the uptake of interventions, preliminary outcomes and challenges in caring for HIV-exposed infants in a pMTCT HIVprogramme in a resource-limited setting. METHOD: A cohort of HIV-infected pregnant women were identified at the leading maternity centres in Greater Kingston through HIV counselling and testing and enrolled in the Kingston Paediatric and Perinatal HIV/AIDS Programme. Antiretroviralprophylaxis with zidovudine or nevirapine was given to the HIV-positive women and their newborns along with formula feeding. Some infants were enrolled retrospectively and followed irrespective of whether they had or had not received antiretroviral prophylaxis. A multidisciplinary team at the paediatric centres supervised protocol-driven management of the infants. Infants were followed for clinical progress and definitive HIV-infection status was to be confirmed at 18 months of age by ELISA or the Determine Rapid Test. RESULTS: During September 1, 2002 through August 31, 2003, 132 HIV-exposed infants were identified. For those infants prospectively enrolled (78), 97% received antiretroviral prophylaxis and 90% were not breastfed For all HIV-exposed children, 90% received cotrimoxazole prophylaxis and 88% continued follow-up care. Ninety-two per cent of all the infants remained asymptomatic and five died; of these deaths one is possibly HIV-related (severe sepsis at 11 weeks). This infant was retrospectively identified, had received no antiretroviral prophylaxis and was breastfed The main programme challenges, which were overcome, included the impact of stigma, compliance with antiretroviral chemoprophylaxis, breast-milk substitution and follow-up care. Financial constraints and laboratory quality assurance issues limited early diagnosis of HIV infection. CONCLUSION: Despite the challenges, the expected outcome is to prevent 50 new cases of HIV/AIDS in children living in Greater Kingston per year (300 over six years).},
 address = {Jamaica},
 author = {Steel-Duncan, J. C. and Pierre, R. and Evans-Gilbert, T. and Rodriquez, B. and Smikle, M. F. and Palmer, P. and Whorms, S. and Hambleton, I. and Figueroa, J. P. and Christie, C. D. C.},
 completed = {20050228},
 history = {2005/01/29 09:00 [entrez]},
 issue = {5},
 journal = {The West Indian medical journal},
 keywords = {*Antibiotic Prophylaxis, Female, HIV Infections/epidemiology/*prevention & control/transmission, Humans, Infant, *Infant Care, Infant, Newborn, Infectious Disease Transmission, Vertical/*prevention & control, Jamaica/epidemiology, Nevirapine/*therapeutic use, *Patient Acceptance of Health Care, Pregnancy, *Prenatal Care, Prospective Studies, Retrospective Studies, *Treatment Outcome, Zidovudine/*therapeutic use},
 language = {eng},
 linking-issn = {0043-3144},
 month = {Oct},
 nlm-unique-id = {0417410},
 owner = {NLM},
 pages = {308-14},
 print-issn = {0043-3144},
 publication-status = {ppublish},
 registry-number = {99DK7FVK1H (Nevirapine)},
 revised = {20131121},
 source = {West Indian Med J. 2004 Oct;53(5):308-14.},
 status = {MEDLINE},
 subset = {IM},
 title = {Uptake of interventions, outcomes and challenges in caring for HIV-exposed infants in Kingston, Jamaica.},
 title-abbreviation = {West Indian Med J},
 volume = {53},
 year = {2004}
}


text:
@InProceedings{flacco:ro-man:2017,
  author    = {Flacco, Fabrizio and Kheddar, Abderrahmane},
  title     = {Contact Detection and Physical Interaction on Low Cost Personal Robot},
  booktitle = {International Symposium on Robot and Human Interactive Communication},
  year      = {2017},
  address   = {Lisbon, Portugal},
  month     = {August 28-September 1},
  url       = {https://www.cs.cmu.edu/\textasciitilde cga/tmp-public/ral.pdf},
  keywords  = {Friction, Torque, Robot kinematics, Robot sensing systems, Computational modeling},
  doi       = {10.1109/ROMAN.2017.8172348},
  abstract  = {In this paper we present a methodology for estimating joints torque due to external forces applied to a robot with large joints backlash. This undesired non-linearity is common in personal robot, due to the use of low cost mechanical components. This method enables collision detection and physical interaction capabilities without using extra sensors. The effectiveness of the new method is shown with experiments on a Romeo robot arm from SoftBank robotics.}
}


text:
package scheduler

import (
	"context"
	"testing"
	"time"

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

	"github.com/cybertec-postgresql/pg_timetable/internal/config"
	"github.com/cybertec-postgresql/pg_timetable/internal/log"
	"github.com/cybertec-postgresql/pg_timetable/internal/pgengine"
)

var pge *pgengine.PgEngine

//SetupTestCase used to connect and to initialize test PostgreSQL database
func SetupTestCase(t *testing.T) func(t *testing.T) {
	cmdOpts := config.NewCmdOptions("-c", "pgengine_unit_test", "--password=somestrong")
	t.Log("Setup test case")
	timeout := time.After(6 * time.Second)
	done := make(chan bool)
	go func() {
		pge, _ = pgengine.New(context.Background(), *cmdOpts, log.Init(config.LoggingOpts{LogLevel: "error"}))
		done <- true
	}()
	select {
	case <-timeout:
		t.Fatal("Cannot connect and initialize test database in time")
	case <-done:
	}
	return func(t *testing.T) {
		_, _ = pge.ConfigDb.Exec(context.Background(), "DROP SCHEMA IF EXISTS timetable CASCADE")
		t.Log("Test schema dropped")
	}
}

func TestRun(t *testing.T) {
	teardownTestCase := SetupTestCase(t)
	defer teardownTestCase(t)

	require.NotNil(t, pge.ConfigDb, "ConfigDB should be initialized")

	err := pge.ExecuteCustomScripts(context.Background(), "../../samples/Interval.sql")
	assert.NoError(t, err, "Creating interval tasks failed")
	err = pge.ExecuteCustomScripts(context.Background(), "../../samples/Basic.sql")
	assert.NoError(t, err, "Creating sql tasks failed")
	err = pge.ExecuteCustomScripts(context.Background(), "../../samples/NoOp.sql")
	assert.NoError(t, err, "Creating built-in tasks failed")
	err = pge.ExecuteCustomScripts(context.Background(), "../../samples/Shell.sql")
	assert.NoError(t, err, "Creating program tasks failed")
	err = pge.ExecuteCustomScripts(context.Background(), "../../samples/SelfDestruct.sql")
	assert.NoError(t, err, "Creating program tasks failed")
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	assert.Equal(t, New(pge, log.Init(config.LoggingOpts{LogLevel: "error"})).Run(ctx), ContextCancelled)

}

license: PostgreSQL,MIT

detected_licenses: PostgreSQL MIT


text:
require cups14.inc

SRC_URI += "file://use_echo_only_in_init.patch \
		    file://skip_tools.patch \
		    file://configure.patch \
			"

SRC_URI[md5sum] = "e70b1c3f60143d7310c1d74c111a21ab"
SRC_URI[sha256sum] = "47a559b1c50192b94479ae7dab132ea0008727045d4993501cf0a6df0c64db97"

PR = "r3"

DEFAULT_PREFERENCE = "-1"

EXTRA_OECONF += " --disable-gssapi --disable-largefile --enable-debug --disable-relro "

repository: trini/openembedded

repo_name: trini/openembedded


text:
package opencv3

import (
	"testing"
)

func TestIMRead(t *testing.T) {
	img := IMRead("images/face-detect.png", IMReadColor)
	if img.Empty() {
		t.Error("Invalid Mat in IMRead")
	}
}

func TestIMWrite(t *testing.T) {
	t.Skip("Tests needed")
}

repository: maruel/gocv

repo_name: maruel/gocv


text:
@article{hbf,
  title={"An Efficient Implementation of the Bellman-Ford Algorithm for Kepler GPU Architectures"},
  author={Busato, Federico and Bombieri, Nicola},
  journal={IEEE Transactions on Parallel and Distributed System},
  volume={27},
  number={8},
  pages={2222--2223},
  year={2016},
  publisher={IEEE}
}

@article{stringdb,
  title={STRING v9. 1: protein-protein interaction networks, with increased coverage and integration},
  author={Franceschini, Andrea and Szklarczyk, Damian and Frankild, Sune and Kuhn, Michael and Simonovic, Milan and Roth, Alexander and Lin, Jianyi and Minguez, Pablo and Bork, Peer and Von Mering, Christian and others},
  journal={Nucleic acids research},
  volume={41},
  number={D1},
  pages={D808--D815},
  year={2012},
  publisher={Oxford University Press}
}

repository: InfOmics/cuRnet

repo_name: InfOmics/cuRnet


text:
package rpc

import "testing"

func TestInterfaceImplemented(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping test in short mode.")
	}
	var req AppendEntriesReq
	var reqData = NewA
}


text:
@article{VanHees2014,
abstract = {Copyright {\textcopyright} 2014 the American Physiological Society. Wearable acceleration sensors are increasingly used for the assessment of free-living physical activity. Acceleration sensor calibration is a potential source of error. This study aims to describe and evaluate an autocalibration method to minimize calibration error using segments within the free-living records (no extra experiments needed). The autocalibration method entailed the extraction of nonmovement periods in the data, for which the measured vector magnitude should ideally be the gravitational acceleration (1 g); this property was used to derive calibration correction factors using an iterative closest-point fitting process. The reduction in calibration error was evaluated in data from four cohorts: UK (n = 921), Kuwait (n = 120), Cameroon (n = 311), and Brazil (n = 200). Our method significantly reduced calibration error in all cohorts (P  {\textless}  0.01), ranging from 16.6 to 3.0 mg in the Kuwaiti cohort to 76.7 to 8.0 mg error in the Brazil cohort. Utilizing temperature sensor data resulted in a small nonsignificant additional improvement (P  {\textgreater}  0.05). Temperature correction coefficients were highest for the z-axis, e.g., 19.6-mg offset per 5°C. Further, application of the autocalibration method had a significant impact on typical metrics used for describing human physical activity, e.g., in Brazil average wrist acceleration was 0.2 to 51{\%} lower than uncalibrated values depending on metric selection (P  {\textless}  0.01). The autocalibration method as presented helps reduce the calibration error in wearable acceleration sensor data and improves comparability of physical activity measures across study locations. Temperature ultization seems essential when temperature deviates substantially from the average temperature in the record but not for multiday summary measures.},
author = {van Hees, Vincent T. and Fang, Zhou and Langford, Joss and Assah, Felix and Mohammad, Anwar and da Silva, Inacio C. M. and Trenell, Michael I. and White, Tom and Wareham, Nicholas J. and Brage, S{\o}ren},
doi = {10.1152/japplphysiol.00421.2014},
file = {:Users/chrisy/Library/Application Support/Mendeley Desktop/Downloaded/van Hees et al. - 2014 - Autocalibration of accelerometer data for free-living physical activity assessment using local gravity and temp.pdf:pdf},
issn = {8750-7587},
journal = {Journal of Applied Physiology},
month = {oct},
number = {7},
pages = {738--744},
title = {{Autocalibration of accelerometer data for free-living physical activity assessment using local gravity and temperature: an evaluation on four continents}},
url = {http://www.physiology.org/doi/10.1152/japplphysiol.00421.2014},
volume = {117},
year = {2014}
}
@article{VanHees2015,
abstract = {{\textcopyright} 2015 van Heeset al. This is an open access article distributed under the terms of the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original author and source are credited. Wrist-worn accelerometers are increasingly being used for the assessment of physical activity in population studies, but little is known about their value for sleep assessment. We developed a novel method of assessing sleep duration using data from 4,094 Whitehall II Study (United Kingdom, 2012-2013) participants aged 60-83 who wore the accelerometer for 9 consecutive days, filled in a sleep log and reported sleep duration via questionnaire. Our sleep detection algorithm defined (nocturnal) sleep as a period of sustained inactivity, itself detected as the absence of change in arm angle greater than 5 degrees for 5 minutes or more, during a period recorded as sleep by the participant in their sleep log. The resulting estimate of sleep duration had a moderate (but similar to previous findings) agreement with questionnaire based measures for time in bed, defined as the difference between sleep onset and waking time (kappa = 0.32, 95{\%}CI:0.29,0.34) and total sleep duration (kappa = 0.39, 0.36,0.42). This estimate was lower for time in bed for women, depressed participants, those reporting more insomnia symptoms, and on weekend days. No such group differences were found for total sleep duration. Our algorithm was validated against data from a polysomnography study on 28 persons which found a longer time window and lower angle threshold to have better sensitivity to wakefulness, while the reverse was true for sensitivity to sleep. The novelty of our method is the use of a generic algorithm that will allow comparison between studies rather than a "count" based, device specific method.},
author = {{Van Hees}, Vincent T. and Sabia, S{\'{e}}verine and Anderson, Kirstie N. and Denton, Sarah J. and Oliver, James and Catt, Michael and Abell, Jessica G. and Kivim{\"{a}}ki, Mika and Trenell, Michael I. and Singh-Manoux, Archana},
doi = {10.1371/journal.pone.0142533},
file = {:Users/chrisy/Library/Application Support/Mendeley Desktop/Downloaded/Van Hees et al. - 2015 - A novel, open access method to assess sleep duration using a wrist-worn accelerometer.pdf:pdf},
issn = {19326203},
journal = {PLoS ONE},
month = {nov},
number = {11},
publisher = {Public Library of Science},
title = {{A novel, open access method to assess sleep duration using a wrist-worn accelerometer}},
volume = {10},
year = {2015}
}
@article{Bai2016,
abstract = {Accelerometers have been widely deployed in public health studies in recent years. While they collect high-resolution acceleration signals (e.g., 10-100 Hz), research has mainly focused on summarized metrics provided by accelerometers manufactures, such as the activity count (AC) by ActiGraph or Actical. Such measures do not have a publicly available formula, lack a straightforward interpretation, and can vary by software implementation or hardware type. To address these problems, we propose the physical activity index (AI), a new metric for summarizing raw tri-axial accelerometry data. We compared this metric with the AC and another recently proposed metric for raw data, Euclidean Norm Minus One (ENMO), against energy expenditure. The comparison was conducted using data from the Objective Physical Activity and Cardiovascular Health Study, in which 194 women 60-91 years performed 9 lifestyle activities in the laboratory, wearing a tri-axial accelerometer (ActiGraph GT3X+) on the hip set to 30 Hz and an Oxycon portable calorimeter, to record both tri-axial acceleration time series (converted into AI, AC, and ENMO) and oxygen uptake during each activity (converted into metabolic equivalents (METs)) at the same time. Receiver operating characteristic analyses indicated that both AI and ENMO were more sensitive to moderate and vigorous physical activities than AC, while AI was more sensitive to sedentary and light activities than ENMO. AI had the highest coefficients of determination for METs (0.72) and was a better classifier of physical activity intensity than both AC (for all intensity levels) and ENMO (for sedentary and light intensity). The proposed AI provides a novel and transparent way to summarize densely sampled raw accelerometry data, and may serve as an alternative to AC. The AI's largely improved sensitivity on sedentary and light activities over AC and ENMO further demonstrate its advantage in studies with older adults.},
author = {Bai, Jiawei and Di, Chongzhi and Xiao, Luo and Evenson, Kelly R. and LaCroix, Andrea Z. and Crainiceanu, Ciprian M. and Buchner, David M.},
doi = {10.1371/journal.pone.0160644},
file = {:Users/chrisy/Library/Application Support/Mendeley Desktop/Downloaded/Bai et al. - 2016 - An activity index for raw accelerometry data and its comparison with other activity metrics.pdf:pdf},
issn = {19326203},
journal = {PLoS ONE},
month = {aug},
number = {8},
publisher = {Public Library of Science},
title = {{An activity index for raw accelerometry data and its comparison with other activity metrics}},
volume = {11},
year = {2016}
}
@techreport{Cole1992,
abstract = {The purpose of this study was to develop and validate automatic scoring methods to distinguish sleep from wakefulness based on wrist activity. Forty-one subjects (l8 normals and 23 with sleep or psychiatric disorders) wore a wrist actigraph during overnight polysomnography. In a randomly selected subsample of 20 subjects, candidate sleep/wake prediction algorithms were iteratively optimized against standard sleep/wake scores. The optimal algorithms obtained for various data collection epoch lengths were then prospectively tested on the remaining 21 subjects. The final algorithms correctly distinguished sleep from wakefulness approximately 88{\%} of the time. Actigraphic sleep percentage and sleep latency estimates correlated 0.82 and 0.90, respectively, with corresponding parameters scored from the polysomnogram (p {\textless} 0.0001). Automatic scoring of wrist activity provides valuable information about sleep and wakefulness that could be useful in both clinical and research applications.},
author = {Cole, Roger J and Kripke, Daniel F and Gruen, Twilliam and Mullaney, Daniel J and Gillin, J Christian},
file = {:Users/chrisy/Library/Application Support/Mendeley Desktop/Downloaded/Cole et al. - 1992 - Automatic SleepWake Identification From Wrist Activity.pdf:pdf},
isbn = {15/5/461/2749332},
keywords = {Activity-,Automatic scoring,Sleep-,Wrist actigraph-},
number = {5},
doi = {10.1093/sleep/15.5.461},
pages = {461--469},
title = {{Automatic Sleep/Wake Identification From Wrist Activity}},
url = {https://academic.oup.com/sleep/article-abstract/15/5/461/2749332},
volume = {15},
year = {1992}
}
@article{VanHees2018,
abstract = {Wrist worn raw-data accelerometers are used increasingly in large scale population research. We examined whether sleep parameters can be estimated from these data in the absence of sleep diaries, which are common in sleep actigraphy. Our heuristic algorithm uses the variance in estimated z-axis angle and makes basic assumptions about sleep interruptions. Detected sleep period time window (SPT-window), was compared against sleep diary in 3741 participants (range=60-83years) and polysomnography in sleep clinic patients (N=28) and in healthy good sleepers (N=22). The SPT-window derived from the algorithm was 10.9 and 2.9 minutes longer compared with sleep diary in men and women, respectively. Average c-statistic to detect the SPT-window compared to polysomnography was 0.86 and 0.83 in clinic and healthy sleepers, respectively. We demonstrated the accuracy of our algorithm to detect the SPT-window. The value of this algorithm lies in studies such as UK Biobank where a sleep diary was not used.},
author = {van Hees, Vincent Theodoor and Sabia, S. and Jones, S. E. and Wood, A. R. and Anderson, K. N. and Kivim{\"{a}}ki, M. and Frayling, T. M. and Pack, A. I. and Bucan, M. and Trenell, M. I. and Mazzotti, Diego R. and Gehrman, P. R. and Singh-Manoux, B. A. and Weedon, M. N.},
doi = {10.1038/s41598-018-31266-z},
file = {:Users/chrisy/Library/Application Support/Mendeley Desktop/Downloaded/van Hees et al. - 2018 - Estimating sleep parameters using an accelerometer without sleep diary.pdf:pdf},
issn = {20452322},
journal = {Scientific Reports},
month = {dec},
number = {1},
publisher = {Nature Publishing Group},
title = {{Estimating sleep parameters using an accelerometer without sleep diary}},
volume = {8},
year = {2018}
}
@misc{VanHees2019,
title = {{GGIR: Raw Accelerometer Data Analysis}},
doi = {10.5281/zenodo.1051064},
url={https://crantastic.org/packages/GGIR},
year={2019},
author={Hees, V.T. Van and Fang, Z. and Zhao, J. and Heywood, J. and Mirkes, E. and Sabia, S. and Migueles, J.}
}

repository: joshsalvi/sleeppy

repo_name: joshsalvi/sleeppy

gha_language: Python


text:
package utils

// Remove - formula a = a - b
func Remove(a []int, b []int) []int {
AGAIN:
	for i := 0; i < len(a); i++ {
		for j := 0; j < len(b); j++ {
			if a[i] == b[j] {
				// remove
				a = append(a[:i], a[i+1:]...)
				goto AGAIN
			}
		}
	}
	return a
}


text:
require python-pyqtchart.inc

inherit pythonnative python-dir

DEPENDS += "sip sip-native python python-pyqt5"

RDEPENDS_${PN} += "python-core python-sip python-pyqt5"


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

S	= "${WORKDIR}/git"
SRCREV	= "dae225a0d64235780e09bb699afa101aeab6cc94"
PV	= "1.16+git${SRCPV}"

SRC_URI = "\
	git://git.kernel.org/pub/scm/network/ofono/ofono.git;protocol=git \
	file://ofono \
"

# We want to use bluez5
DEPENDS := "${@oe_filter_out('bluez4', '${DEPENDS}', d)}"
DEPENDS += "${@base_contains('DISTRO_FEATURES', 'bluetooth','bluez5', '', d)}"

# Test scripts use python3, the dbus module is still missing so the scripts
# do not work as expected.
RDEPENDS_${PN} = "\
	python3 \
	python3-codecs \
	python3-math \
	python3-io \
	python3-misc \
"

do_install_append() {
	# Because python3-dbus module is currently not there, just use
	# python 2.x in the ofono test scripts
	for PYTHSCRIPT in `grep -rIl ${bindir}/python3 ${D}${libdir}/${PN}`; do
		sed -i -e '1s|^#!.*|#!/usr/bin/env python|' $PYTHSCRIPT
	done
}

repository: olegcherpak/meta-eca

repo_name: olegcherpak/meta-eca


text:
// Copyright 2019 yhyzgn gog
//
// 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.

// author : 颜洪毅
// e-mail : yhyzgn@gmail.com
// time   : 2019-11-04 8:44 下午
// version: 1.0.0
// desc   : 对外日志工具

package gog

import (
	"fmt"
	"os"
	"testing"
	"time"
)

func Test(t *testing.T) {
	_ = os.Setenv("ENV", "dev")

	env := os.Getenv("ENV")
	if env == "prod" {
		SetFormatter(NewJSONFormatter())
		// 开发环境
		AddWriter(&testWriter{})
	}

	SetLevel(INFO)

	Async(true)

	Trace("Trace", 1, 3, 345, true)
	Debug("Debug")
	Info("Info")
	Warn("Warn")
	Error("Error")

	time.Sleep(3 * time.Second)

	TraceTag("TagTrace", "Trace", 1, 3, 345, true)
	DebugTag("TagDebug", "Debug")
	InfoTag("TagInfo", "Info")
	WarnTag("TagWarn", "Warn")
	ErrorTagF("TagErrorF", "Error {}", "err...")

	//Fatal("Fatal")

	test()

	time.Sleep(6 * time.Second)
}

func test() {
	TraceF("Hello, {} !", "gog")
}

type testWriter struct {
	ConsoleWriter
}

func (tw *testWriter) Write(info *LogInfo, data []byte) (n int, err error) {
	if info.Level >= INFO {
		fmt.Print("test writer -- ", string(data))
	}
	return
}

repository: yhyzgn/gog

repo_name: yhyzgn/gog


text:
//Package heartbeat msg type = 0.
package heartbeat

import (
	"github.com/quickfixgo/quickfix"
	"github.com/quickfixgo/quickfix/enum"
	"github.com/quickfixgo/quickfix/fixt11"
)

//Message is a Heartbeat FIX Message
type Message struct {
	FIXMsgType string `fix:"0"`
	fixt11.Header
	//TestReqID is a non-required field for Heartbeat.
	TestReqID *string `fix:"112"`
	fixt11.Trailer
}

//Marshal converts Message to a quickfix.Message instance
func (m Message) Marshal() quickfix.Message { return quickfix.Marshal(m) }

//New returns an initialized Heartbeat instance
func New() *Message {
	var m Message
	return &m
}

func (m *Message) SetTestReqID(v string) { m.TestReqID = &v }

//A RouteOut is the callback type that should be implemented for routing Message
type RouteOut func(msg Message, sessionID quickfix.SessionID) quickfix.MessageRejectError

//Route returns the beginstring, message type, and MessageRoute for this Message type
func Route(router RouteOut) (string, string, quickfix.MessageRoute) {
	r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError {
		m := new(Message)
		if err := quickfix.Unmarshal(msg, m); err != nil {
			return err
		}
		return router(*m, sessionID)
	}
	return enum.BeginStringFIXT11, "0", r
}

repository: bwlee/quickfix

repo_name: bwlee/quickfix


text:
package main

import (
	"testing"

	"github.com/gofrs/uuid"
)

type MockNotifyConn struct {
	Called       bool
	CloseHandler func(int, string) error
}

func (c MockNotifyConn) SetCloseHandler(fn func(int, string) error) {}

func (c *MockNotifyConn) WriteMessage(t int, p []byte) error {
	c.Called = true
	return nil
}

func TestNewEvent(t *testing.T) {
	_, err := NewEvent([]byte(`{"kind": "test"`))
	if err == nil {
		t.Fatal("expected json parse error")
	}
	_, err = NewEvent([]byte(`{"kind": "test"}`))
	if err != nil {
		t.Fatal(err)
	}
}

func TestNewObserver(t *testing.T) {
	_, err := NewObserver([]byte(`"events": ["test",`), nil)
	if err == nil {
		t.Fatal("expected json parse error")
	}
	observer, err := NewObserver([]byte(`{"events": ["test"]}`), nil)
	if err != nil {
		t.Fatal(err)
	}
	id, err := uuid.FromString(observer.Id)
	if err != nil {
		t.Fatal(err)
	}
	if id.Version() != 1 {
		t.Fatal("expected observer id to be uuid version 1")
	}
}

func TestObserverNotify(t *testing.T) {
	conn := &MockNotifyConn{}
	evt, err := NewEvent([]byte(`{"kind": "test", "created": "2017-01-01T00:00:00Z", "meta": {}}`))
	if err != nil {
		t.Fatal(err)
	}
	observer, err := NewObserver([]byte(`{"events": ["test"], "id": "123"}`), conn)
	if err != nil {
		t.Fatal(err)
	}
	if err = observer.Notify(evt); err != nil {
		t.Fatal(err)
	}
	if conn.Called != true {
		t.Fatal("expected observer write message to have been called")
	}
}


text:
DESCRIPTION = "A utility belt for advanced users of python-requests."
HOMEPAGE = "https://toolbelt.readthedocs.org"
AUTHOR = "Ian Cordasco, Cory Benfield"

LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=6f14302a4b4099009ab38b4dde5f1075"

SRC_URI = "file://run-ptest \
	   file://090856f4159c40a2927fb88546419f2e1697ad5f.patch \
	   file://720240501dca0b4eacc3295665d7ced8719e11d2.patch \
          "

SRC_URI[sha256sum] = "7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6"

inherit pypi setuptools3 ptest

RDEPENDS:${PN} += " \
    ${PYTHON_PN}-requests (>=2.0.1) \
"

RDEPENDS:${PN}-ptest += " \
	${PYTHON_PN}-pytest \
	${PYTHON_PN}-betamax \
	${PYTHON_PN}-mock \
	${PYTHON_PN}-multiprocessing \
	${PYTHON_PN}-trustme \
"

do_install_ptest() {
	install -d ${D}${PTEST_PATH}/tests
	cp -rf ${S}/tests/* ${D}${PTEST_PATH}/tests/
	cp -rf ${S}/setup.py ${D}${PTEST_PATH}
	# remove test test_multipart_encoder.py as it fails,
	# downloaded file is not supported
	rm -f ${D}${PTEST_PATH}/tests/test_multipart_encoder.py
}

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded


text:
DESCRIPTION = "GNU tar saves many files together into a single tape \
or disk archive, and can restore individual files from the archive."
SECTION = "base"
LICENSE = "GPLv3"

SRC_URI = "${GNU_MIRROR}/tar/tar-${PV}.tar.bz2"

inherit autotools

do_install () {
	autotools_do_install
	install -d ${D}${base_bindir}
	mv ${D}${bindir}/tar ${D}${base_bindir}/tar.${PN}
	mv ${D}${libexecdir}/rmt ${D}${libexecdir}/rmt.${PN}
}

pkg_postinst_${PN} () {
	update-alternatives --install ${base_bindir}/tar tar tar.${PN} 100
	update-alternatives --install ${libexecdir}/rmt rmt rmt.${PN} 100
}

pkg_prerm_${PN} () {
	update-alternatives --remove tar tar.${PN}
	update-alternatives --remove rmt rmt.${PN}
}


text:
PR = "r10"

SRC_URI = \
    "${GNU_MIRROR}/binutils/binutils-${PV}.tar.bz2 \
     file://ld_makefile.patch \
     file://better_file_error.patch \
     file://signed_char_fix.patch \
     file://binutils-2.16-objcopy-rename-errorcode.patch \
     file://binutils-100_cflags_for_build.patch"

# uclibc patches
SRC_URI += "file://binutils-2.16-linux-uclibc.patch"

# arm thumb support patches
SRC_URI += "file://binutils-2.16-thumb-trampoline.patch"
SRC_URI += "file://binutils-2.16-thumb-glue.patch"

# powerpc patches
SRC_URI += "file://binutils-2.16.1-e300c2c3.patch"

require binutils.inc
PR = "${INC_PR}.0"

SRC_URI[md5sum] = "bcb9fabaf0eaf91bd38c4ee148658df8"
SRC_URI[sha256sum] = "5645c3371aac47cbbcc1354eab10ec32777837d7cb4ba47b94c9043612b12f36"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty


text:
require rust.inc
require rust-source-${PV}.inc
require rust-snapshot-${PV}.inc

SRC_URI += "file://rust-${PV}/0001-librustc-always-allow-unstable-options.patch"
SRC_URI += "file://rust-${PV}/0001-Don-t-use-remapped-path-when-loading-modules-and-inc.patch"

# These are extracted from rustc/src/bootstrap/Cargo.toml via cargo-bitbake
SRC_URI += " \
crate://crates.io/advapi32-sys/0.2.0 \
crate://crates.io/aho-corasick/0.5.3 \
crate://crates.io/aho-corasick/0.6.3 \
crate://crates.io/ansi_term/0.9.0 \
crate://crates.io/ar/0.3.0 \
crate://crates.io/atty/0.2.2 \
crate://crates.io/backtrace-sys/0.1.12 \
crate://crates.io/backtrace/0.3.2 \
crate://crates.io/bitflags/0.7.0 \
crate://crates.io/bitflags/0.8.2 \
crate://crates.io/bitflags/0.9.1 \
crate://crates.io/bufstream/0.1.3 \
crate://crates.io/cfg-if/0.1.2 \
crate://crates.io/clap/2.26.0 \
crate://crates.io/cmake/0.1.24 \
crate://crates.io/core-foundation-sys/0.4.4 \
crate://crates.io/core-foundation/0.4.4 \
crate://crates.io/crossbeam/0.2.10 \
crate://crates.io/curl-sys/0.3.14 \
crate://crates.io/curl/0.4.8 \
crate://crates.io/dbghelp-sys/0.2.0 \
crate://crates.io/derive-new/0.3.0 \
crate://crates.io/diff/0.1.10 \
crate://crates.io/docopt/0.8.1 \
crate://crates.io/dtoa/0.4.1 \
crate://crates.io/enum_primitive/0.1.1 \
crate://crates.io/env_logger/0.3.5 \
crate://crates.io/env_logger/0.4.3 \
crate://crates.io/error-chain/0.10.0 \
crate://crates.io/error-chain/0.11.0-rc.2 \
crate://crates.io/filetime/0.1.10 \
crate://crates.io/flate2/0.2.19 \
crate://crates.io/fnv/1.0.5 \
crate://crates.io/foreign-types/0.2.0 \
crate://crates.io/fs2/0.4.2 \
crate://crates.io/futures/0.1.14 \
crate://crates.io/gcc/0.3.51 \
crate://crates.io/getopts/0.2.14 \
crate://crates.io/git2-curl/0.7.0 \
crate://crates.io/git2/0.6.6 \
crate://crates.io/glob/0.2.11 \
crate://crates.io/globset/0.2.0 \
crate://crates.io/hamcrest/0.1.1 \
crate://crates.io/handlebars/0.26.2 \
crate://crates.io/hex/0.2.0 \
crate://crates.io/home/0.3.0 \
crate://crates.io/idna/0.1.4 \
crate://crates.io/ignore/0.2.2 \
crate://crates.io/itoa/0.3.1 \
crate://crates.io/jobserver/0.1.6 \
crate://crates.io/jsonrpc-core/7.1.0 \
crate://crates.io/kernel32-sys/0.2.2 \
crate://crates.io/languageserver-types/0.12.0 \
crate://crates.io/lazy_static/0.2.8 \
crate://crates.io/libc/0.2.29 \
crate://crates.io/libgit2-sys/0.6.12 \
crate://crates.io/libssh2-sys/0.2.6 \
crate://crates.io/libz-sys/1.0.16 \
crate://crates.io/log/0.3.8 \
crate://crates.io/lzma-sys/0.1.8 \
crate://crates.io/matches/0.1.6 \
crate://crates.io/mdbook/0.0.22 \
crate://crates.io/memchr/0.1.11 \
crate://crates.io/memchr/1.0.1 \
crate://crates.io/miniz-sys/0.1.9 \
crate://crates.io/miow/0.2.1 \
crate://crates.io/net2/0.2.31 \
crate://crates.io/num-bigint/0.1.40 \
crate://crates.io/num-complex/0.1.40 \
crate://crates.io/num-integer/0.1.35 \
crate://crates.io/num-iter/0.1.34 \
crate://crates.io/num-rational/0.1.39 \
crate://crates.io/num-traits/0.1.40 \
crate://crates.io/num/0.1.40 \
crate://crates.io/num_cpus/1.6.2 \
crate://crates.io/open/1.2.0 \
crate://crates.io/openssl-probe/0.1.1 \
crate://crates.io/openssl-sys/0.9.17 \
crate://crates.io/openssl/0.9.17 \
crate://crates.io/owning_ref/0.3.3 \
crate://crates.io/percent-encoding/1.0.0 \
crate://crates.io/pest/0.3.3 \
crate://crates.io/pkg-config/0.3.9 \
crate://crates.io/psapi-sys/0.1.0 \
crate://crates.io/pulldown-cmark/0.0.14 \
crate://crates.io/quick-error/1.2.0 \
crate://crates.io/quote/0.2.3 \
crate://crates.io/quote/0.3.15 \
crate://crates.io/racer/2.0.10 \
crate://crates.io/rand/0.3.15 \
crate://crates.io/regex-syntax/0.3.9 \
crate://crates.io/regex-syntax/0.4.1 \
crate://crates.io/regex/0.1.80 \
crate://crates.io/regex/0.2.2 \
crate://crates.io/rls-analysis/0.6.5 \
crate://crates.io/rls-data/0.10.0 \
crate://crates.io/rls-rustc/0.1.0 \
crate://crates.io/rls-span/0.4.0 \
crate://crates.io/rls-vfs/0.4.4 \
crate://crates.io/rustc-demangle/0.1.5 \
crate://crates.io/rustc-serialize/0.3.24 \
crate://crates.io/rustfmt-nightly/0.2.2 \
crate://crates.io/same-file/0.1.3 \
crate://crates.io/scoped-tls/0.1.0 \
crate://crates.io/scopeguard/0.1.2 \
crate://crates.io/semver-parser/0.7.0 \
crate://crates.io/semver/0.7.0 \
crate://crates.io/serde/1.0.11 \
crate://crates.io/serde_derive/1.0.11 \
crate://crates.io/serde_derive_internals/0.15.1 \
crate://crates.io/serde_ignored/0.0.3 \
crate://crates.io/serde_json/1.0.2 \
crate://crates.io/shell-escape/0.1.3 \
crate://crates.io/socket2/0.2.2 \
crate://crates.io/stable_deref_trait/1.0.0 \
crate://crates.io/strings/0.1.0 \
crate://crates.io/strsim/0.6.0 \
crate://crates.io/syn/0.11.11 \
crate://crates.io/syn/0.8.7 \
crate://crates.io/synom/0.11.3 \
crate://crates.io/syntex_errors/0.52.0 \
crate://crates.io/syntex_pos/0.52.0 \
crate://crates.io/syntex_syntax/0.52.0 \
crate://crates.io/tar/0.4.13 \
crate://crates.io/tempdir/0.3.5 \
crate://crates.io/term/0.4.6 \
crate://crates.io/term_size/0.3.0 \
crate://crates.io/termcolor/0.3.2 \
crate://crates.io/textwrap/0.7.0 \
crate://crates.io/thread-id/2.0.0 \
crate://crates.io/thread_local/0.2.7 \
crate://crates.io/thread_local/0.3.4 \
crate://crates.io/toml/0.2.1 \
crate://crates.io/toml/0.4.5 \
crate://crates.io/typed-arena/1.3.0 \
crate://crates.io/unicode-bidi/0.3.4 \
crate://crates.io/unicode-normalization/0.1.5 \
crate://crates.io/unicode-segmentation/1.2.0 \
crate://crates.io/unicode-width/0.1.4 \
crate://crates.io/unicode-xid/0.0.3 \
crate://crates.io/unicode-xid/0.0.4 \
crate://crates.io/unreachable/1.0.0 \
crate://crates.io/url/1.5.1 \
crate://crates.io/url_serde/0.2.0 \
crate://crates.io/userenv-sys/0.2.0 \
crate://crates.io/utf8-ranges/0.1.3 \
crate://crates.io/utf8-ranges/1.0.0 \
crate://crates.io/vcpkg/0.2.2 \
crate://crates.io/vec_map/0.8.0 \
crate://crates.io/void/1.0.2 \
crate://crates.io/walkdir/1.0.7 \
crate://crates.io/winapi-build/0.1.1 \
crate://crates.io/winapi/0.2.8 \
crate://crates.io/wincolor/0.1.4 \
crate://crates.io/ws2_32-sys/0.2.1 \
crate://crates.io/xattr/0.1.11 \
crate://crates.io/xz2/0.1.3 \
crate://crates.io/yaml-rust/0.3.5 \
"

DEPENDS += "rust-llvm (=${PV})"

# Otherwise we'll depend on what we provide
INHIBIT_DEFAULT_RUST_DEPS_class-native = "1"
# We don't need to depend on gcc-native because yocto assumes it exists
PROVIDES_class-native = "virtual/${TARGET_PREFIX}rust"

BBCLASSEXTEND = "native"

repository: agherzan/meta-rust

repo_name: agherzan/meta-rust


text:
COLLIE_MEMORY_SIZE = "58"
COLLIE_RAMDISK_SIZE = "6"
KERNEL_CONSOLE = "tty0"

require ../linux/openzaurus-sa_2.4.18-rmk7-pxa3-embedix20030509.bb

KERNEL_IMAGE_BASE_NAME = "${KERNEL_IMAGETYPE}-${MACHINE}-${COLLIE_MEMORY_SIZE}-${COLLIE_RAMDISK_SIZE}-DEBUG-${DATETIME}.bin"
KERNEL_IMAGE_SYMLINK_NAME = "${KERNEL_IMAGETYPE}-${MACHINE}-${COLLIE_MEMORY_SIZE}-${COLLIE_RAMDISK_SIZE}-DEBUG.bin"