text:
@misc{ford_lost_2018,
	address = {University of Bergen},
	type = {Extended abstract},
	title = {Lost futures: in the presence of long-lost civilisations in \textit{{The} {Legend} of {Zelda}: {Breath} of the {Wild}}},
	copyright = {All rights reserved},
	shorttitle = {Lost futures},
	url = {http://rgdoi.net/10.13140/RG.2.2.32490.57286},
	abstract = {The long-lost, ancient civilisation that somehow had technology that far surpasses the current level is a common trope in videogames that feature large, open worlds. The \textit{Mass Effect} trilogy (2007; 2010; 2012) features the Protheans, whose unparalleled feats of technology and engineering such as the mass relays laid the foundations for the galaxy Shepard steps into. \textit{Horizon Zero Dawn} (2017) explores a primitive world littered with technological marvels left by the Old Ones. \textit{The Legend of Zelda: Breath of the Wild} (2017) is centred around the Ancient Sheikah society, who 10,000 years prior to the game’s setting had developed teleportation between towers and shrines, powerful runes, and even a motorbike. Their technology was later used to build the giant mechanical Divine Beasts and Guardians. All this while the warriors of the day are still using steel swords. In this paper, I explore the reasons for and the effect of this trope in \textit{The Legend of Zelda: Breath of the Wild}, particularly how it changes the configuration of the gameworld, and how the player’s experience is shaped by it. My examination is framed around five intertwined terms and their theoretical context: Hauntology, presence, absence, lost futures, and nostalgia.},
	language = {en},
	urldate = {2019-03-12},
	author = {Ford, Dom},
	month = nov,
	year = {2018}
}

@misc{ford_speedrunning:_2018,
	address = {University of Bergen},
	type = {Extended abstract},
	title = {Speedrunning: transgressive play in digital space},
	copyright = {All rights reserved},
	shorttitle = {Speedrunning},
	url = {http://rgdoi.net/10.13140/RG.2.2.12357.91369},
	abstract = {In \textit{How To Do Things With Videogames}, Ian Bogost argues that videogames offer “an experience of the ‘space between points’ that had been reduced or eliminated by the transportation technologies that began with the train” (2011, 49). But when we watch a speedrun of a game such as \textit{The Legend of Zelda: Ocarina of Time} (Nintendo EAD 1998), what we instead see is a player determined to destroy as much of that ‘space between points’ as possible. It is a game that takes most players tens of hours to complete, but is finished in just over 17 minutes by the best speedrunners, utilizing glitches that manipulate the game’s code to skip enormous chunks of both the narrative and the gameworld. Once an underground hobby conducted between users swapping footage on obscure internet forums, speedrunning has shot into the mainstream in recent years following the rise of livestreaming platforms and livestreamed events such as Games Done Quick and the European Speedsters Assembly. So what does speedrunning mean as a mode of play, and what can it reveal about the relationship between player and gameworld? This paper examines speedrunning as a transgressive mode of play. Building on previous work on this topic by scholars such as Rainforest Scully-Blaker, I first aim to define speedrunning as a practice and then to explore its relationship with the space in the gameworld, the game’s narrative, and with the ideological and representational implications that arise from them. To do this, I bring in spatial, digital and videogame theorists such as Paul Virilio, Tom Apperley and Espen Aarseth, as well as work on other transgressive spatial practices such as parkour in order to see if and how they relate.},
	language = {en},
	urldate = {2019-03-12},
	author = {Ford, Dom},
	month = nov,
	year = {2018}
}

@article{ford_explore_2016,
	title = {"{eXplore}, {eXpand}, {eXploit}, {eXterminate}": affective writing of postcolonial history and education in \textit{{Civilization} {V}}},
	volume = {16},
	copyright = {Creative Commons Attribution-ShareAlike 4.0 International License (CC-BY-SA)},
	issn = {1604-7982},
	shorttitle = {"{eXplore}, {eXpand}, {eXploit}, {eXterminate}"},
	url = {http://gamestudies.org/1602/articles/ford},
	abstract = {\textit{Civilization V} as one of the most successful and definitive works of the 4X videogame genre presents a clear narrative of empire-building that, I will argue, is problematic when set against postcolonial theory. With many studies lauding the series for its educational capacities I argue that with an affective turn to the role of the player, the game’s homogenization of narratives of societal progression reinforces a Western-centric notion of history. This co-opts non-colonial societies into imperialism, while in the process silencing their histories. For this study, I will read the game’s goals and mechanics through postcolonial theorists such as Gayatri Chakravorty Spivak and Michel-Rolph Trouillot, and then turn to affect theory to consider what role the player takes in writing this history. To conclude, I will consider what implications this has on the use of 4X games like Civilization V for education and the conception of history in the minds of the players, drawing on other recent scholars who have similarly problematized the series.},
	language = {en},
	number = {2},
	urldate = {2018-06-28},
	journal = {Game Studies},
	author = {Ford, Dom},
	month = dec,
	year = {2016},
	keywords = {affect, Civilisation V, education, empire, history, homogeny, imperialism, postcolonialism, technological determinism, videogames},
	file = {Snapshot:C\:\\Users\\dofo\\Zotero\\storage\\SEGBV7K3\\ford.html:text/html}
}

@mastersthesis{ford_gods_2016,
	address = {Exeter, England},
	title = {Gods from the machine: godhood and morality in roleplaying videogames},
	copyright = {All rights reserved},
	shorttitle = {Gods from the machine},
	url = {http://rgdoi.net/10.13140/RG.2.2.29690.75206},
	abstract = {This dissertation aims to situate moral play under a structure of godhood. This comprise two distinct but intertwining elements: the player-as-god and diegetic gods. The player-as-god is a concept I will outline that describes the player-avatar relationship as a dualistic notion that encompasses the avatar as a distinct, diegetic character, and the player as a controlling being who transcends the gameworld. The two collide in player-avatar relationships to create a ‘fantasy self’, as Katherine Isbister terms, that is neither solely player nor avatar. The player-as-god, as both transcendental but simultaneously native to the gameworld, must forge new moral and social frameworks according to the different ontological and cosmological fundamentals of the created gameworld. These frameworks, I will argue, are predicated on higher diegetic powers that guide and inform the player-as-god. I will examine this topic through four case studies. In \textit{Grand Theft Auto V}, I will illustrate the player-as-god as part of a player-avatar relationship that involves a pre-characterised avatar, in the form of \textit{GTA V}'s playable protagonists. In \textit{The Elder Scrolls V: Skyrim}, I will analyse a more ‘blank slate’ avatar in the player-avatar relationship, and consider how the player-as-god is directed by diegetic gameworld gods and higher powers. In \textit{Diablo III}, I will explore the highly intertextual nature of its moral framework, as it borrows extensively from Judeo-Christian tradition. Finally, in \textit{Dark Souls} I will add a moral dimension to Daniel Vella’s notion of the ludic sublime, examine how moral futility is instituted in the game’s lore and mechanics.},
	language = {en},
	urldate = {2018-12-12},
	school = {University of Exeter},
	author = {Ford, Dom},
	month = aug,
	year = {2016}
}

@mastersthesis{ford_giant_2019,
	address = {Denmark},
	title = {The giant in digital roleplaying games},
	copyright = {All rights reserved},
	url = {http://rgdoi.net/10.13140/RG.2.2.32717.90089},
	abstract = {Too monstrous to be truly accepted, too human to be entirely and comfortably cast out. The giant has traditionally held a unique position amongst monsters, an "Intimate Stranger" (Cohen, 1999, p. xi) who threatens the boundaries of the categories we impose upon the self, society and culture. In this thesis, I consider what the position of the giant is in digital roleplaying games and how digital games provide a new and particular arena for the giant. A familiar figure in myth and legend and no less familiar in digital games, I combine traditional monster theory and scholarship on giants with work on videogame monsters and digital game research more broadly. To do this, I first introduce the figure of the giant and its definition and then undertake a brief literature review, summing up the present state of videogame monster research and other theories which are relevant to my thinking and arguments. Then, I consider the giant in digital roleplaying games through three lenses. First, as monsters of excess, a perspective that considers giants as an exaggerated manifestation of those traits which we deem monstrous when taken to their extremes. Second, as technological giants: giant robots, cyborgs and so on whose appearance as giants links the age-old figure of the giant with our more current anxieties regarding our future and our increasingly intimate relationship with technology. Finally, as aspects of nature: giants that seem to be more a living part of the gameworld than as a horrifying and excessive human monster. I explore how these giants seem to relate more to how we think of and understand our relationship with nature, from its sublime beauty to its hostile wildernesses. To conclude, I attempt to draw these perspectives together to gain an oversight on what role the giant plays within digital roleplaying games, arguing that the giant is a particular figure used to consider and work through our socio-cultural anxieties at the most fundamental level and is one that requires medium-specific consideration within game studies.},
	language = {en},
	urldate = {2019-06-18},
	school = {IT University of Copenhagen},
	author = {Ford, Dom},
	month = jun,
	year = {2019}
}

@inproceedings{ford_beyond_2019,
	address = {Kyoto, Japan},
	title = {Beyond the wall: the boundaries of the neomedieval town in singleplayer roleplaying games},
	copyright = {All rights reserved},
	shorttitle = {Beyond the wall},
	url = {http://www.digra.org/wp-content/uploads/digital-library/DiGRA_2019_paper_97.pdf},
	abstract = {The cities of the ever prevalent neomedieval fantasy roleplaying game are integral to their gameworlds. They act as quest hubs, goals, centres for action and places of safety. Much of the loop of the game revolves around leaving the city to complete quests, then returning to the city again, and repeat. In this paper, I take a closer look at the boundaries of the city. I begin by proposing a model to help define what a city’s boundary is and how it is expressed to the player. Then, I look at how and why players cross those borders back and forth. Through this, I hope to facilitate a better understanding of how the city functions in roleplaying games, and how the ways in which it produces boundaries alters and affects how players interact with the gameworld.},
	language = {en},
	urldate = {2019-09-27},
	booktitle = {Proceedings of the 2019 {DiGRA} {International} {Conference}: {Game}, {Play} and the {Emerging} {Ludo}-{Mix}},
	publisher = {DiGRA},
	author = {Ford, Dom},
	month = aug,
	year = {2019},
	pages = {15},
	file = {Beyond the Wall\: The Boundaries of the Neomedieval Town in Singleplayer Roleplaying Games | DiGRA:C\:\\Users\\dofo\\Zotero\\storage\\RE8FWAR2\\beyond-the-wall-the-boundaries-of-the-neomedieval-town-in-singleplayer-roleplaying-games.html:text/html}
}

@inproceedings{fordTechnogiantsGiantMachine2020,
  title = {Techno-Giants: The Giant, the Machine and the Human},
  shorttitle = {Techno-Giants},
  booktitle = {Proceedings of the 2020 {{DiGRA International Conference}}: {{Play Everywhere}}},
  author = {Ford, Dom},
  year = {2020},
  publisher = {{DiGRA}},
  address = {{Tampere, Finland}},
  abstract = {The relationship between humankind and technology is fundamental, but also a longstanding source of unease, particularly as that relationship has become ever more intimate and irreversible. In this paper, I connect this age-old anxiety with the age-old figure of the giant, a monster similarly intertwined with ancient questions on the boundaries of humanity. I focus on two examples: the Human-Reaper larva in Mass Effect 2 and Liberty Prime in Fallout 3 and 4. Although different in approach, these examples demonstrate a use of a phenomenon I call the `techno-giant' to explore and reflect the powerful anxieties in our cultures to do with the future of the human\textendash{} technology relationship. In particular, both examples expose the human\textendash nonhuman boundary as being exceeding difficult to define and place, despite a constant desire to. The figure of the giant offers a powerful focal point for these representations.},
  copyright = {All rights reserved},
  file = {C\:\\Users\\Dom\\Zotero\\storage\\K6D7AEU2\\techno-giants-the-giant-the-machine-and-the-human.html},
  keywords = {abject,androids,cyborgs,Fallout,giants,Mass Effect,mechas,monsters,nostalgia,posthumanism,retrofuture,robots,satire,technology,transhumanism},
  language = {en}
}

@inproceedings{fordGiantnessExcessDark2020,
  title = {Giantness and Excess in {{Dark Souls}}},
  booktitle = {Proceedings of the {{International Conference}} on the {{Foundations}} of {{Digital Games}} ({{FDG}} '20)},
  author = {Ford, Dom},
  year = {2020},
  month = sep,
  pages = {4},
  publisher = {{Association for Computing Machinery}},
  address = {{Bugibba, Malta}},
  doi = {10.1145/3402942.3402966},
  abstract = {Using the Dark Souls series as an example, I examine how a frame of `monster of excess' can be used to read giantness in digital games. The monster of excess finds a paradigmatic example in the giant, an age-old mythic figure still prevalent within digital games. Many elements are directly borrowed or translated from other artistic forms such as film and literature. But, in this paper, I focus on how excess is encoded ludically, and how that links with the more representational and aesthetic depictions of excess within the games. I find that elements such as the camera and the game's interface, along with the player-character are all affected by giantness, with giants seeming to exist in excess of the games' established frames.},
  copyright = {All rights reserved},
  isbn = {978-1-4503-8807-8},
  keywords = {abject,Dark Souls,excess,giants,monsters,sublime},
  language = {en},
  series = {{{FDG}} '20}
}

repository: DomFord/starter-academic

repo_name: DomFord/starter-academic

gha_license_id: MIT


text:
#include <tins/dot11/dot11_control.h>

#ifdef TINS_HAVE_DOT11

#include <gtest/gtest.h>
#include <tins/detail/smart_ptr.h>
#include "tests/dot11.h"

using namespace std;
using namespace Tins;

typedef Dot11::address_type address_type;

class Dot11BlockAckRequestTest : public testing::Test {
public:
    static const address_type empty_addr, hwaddr;
    static const uint8_t expected_packet[];
};

const uint8_t Dot11BlockAckRequestTest::expected_packet[] = {
    132, 0, 176, 1, 0, 33, 107, 2, 154, 230, 0, 28, 223, 215, 13, 85, 4,
    0, 176, 33
};

void test_equals(const Dot11BlockAckRequest& dot1, const Dot11BlockAckRequest& dot2) {
    EXPECT_EQ(dot1.fragment_number(), dot2.fragment_number());
    EXPECT_EQ(dot1.start_sequence(), dot2.start_sequence());
    EXPECT_EQ(dot1.bar_control(), dot2.bar_control());
}

void test_equals_expected(const Dot11BlockAckRequest& dot11) {
    EXPECT_EQ(dot11.type(), Dot11::CONTROL);
    EXPECT_EQ(dot11.subtype(), Dot11::BLOCK_ACK_REQ);
    EXPECT_EQ(dot11.bar_control(), 4);
    EXPECT_EQ(dot11.start_sequence(), 539);
    EXPECT_EQ(dot11.fragment_number(), 0);
}

TEST_F(Dot11BlockAckRequestTest, Constructor) {
    Dot11BlockAckRequest dot11;
    test_equals_empty(static_cast<const Dot11ControlTA&>(dot11));
    EXPECT_EQ(dot11.subtype(), Dot11::BLOCK_ACK_REQ);
    EXPECT_EQ(dot11.fragment_number(), 0);
    EXPECT_EQ(dot11.start_sequence(), 0);
    EXPECT_EQ(dot11.bar_control(), 0);
}

TEST_F(Dot11BlockAckRequestTest, ConstructorFromBuffer) {
    Dot11BlockAckRequest dot11(expected_packet, sizeof(expected_packet));
    test_equals_expected(dot11);
}

TEST_F(Dot11BlockAckRequestTest, CopyConstructor) {
    Dot11BlockAckRequest dot1;
    dot1.fragment_number(6);
    dot1.start_sequence(0x294);
    dot1.bar_control(0x9);
    Dot11BlockAckRequest dot2(dot1);
    test_equals(dot1, dot2);
}

TEST_F(Dot11BlockAckRequestTest, CopyAssignmentOperator) {
    Dot11BlockAckRequest dot1;
    dot1.fragment_number(6);
    dot1.start_sequence(0x294);
    dot1.bar_control(0x9);
    Dot11BlockAckRequest dot2;
    dot2 = dot1;
    test_equals(dot1, dot2);
}

TEST_F(Dot11BlockAckRequestTest, ClonePDU) {
    Dot11BlockAckRequest dot1;
    dot1.fragment_number(6);
    dot1.start_sequence(0x294);
    dot1.bar_control(0x9);
    Internals::smart_ptr<Dot11BlockAckRequest>::type dot2(dot1.clone());
    test_equals(dot1, *dot2);
}

TEST_F(Dot11BlockAckRequestTest, FromBytes) {
    Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
    ASSERT_TRUE(dot11.get() != NULL);
    const Dot11BlockAckRequest* inner = dot11->find_pdu<Dot11BlockAckRequest>();
    ASSERT_TRUE(inner != NULL);
    test_equals_expected(*inner);
}

TEST_F(Dot11BlockAckRequestTest, Serialize) {
    Dot11BlockAckRequest pdu(expected_packet, sizeof(expected_packet));
    PDU::serialization_type buffer = pdu.serialize();
    ASSERT_EQ(sizeof(expected_packet), buffer.size());
    EXPECT_TRUE(std::equal(buffer.begin(), buffer.end(), expected_packet));
}

#endif // TINS_HAVE_DOT11

repository: mfontanini/libtins

license_type: permissive

repo_name: mfontanini/libtins

branch_name: refs/heads/master

extension: cpp


text:
HOMEPAGE = "http://linux.duke.edu/projects/yum/"
PR = "r7"

SRC_URI = "http://linux.duke.edu/projects/yum/download/3.2/yum-${PV}.tar.gz \
           file://paths.patch \
           file://paths2.patch \
	   file://yum-install-recommends.py \
	   file://extract-postinst.awk"

RDEPENDS_${PN} = "python-rpm python-core python-iniparse python-urlgrabber \
            python-shell python-re python-logging python-pickle \
	    python-netserver python-compression \
	    python-unixadmin python-xml python-sqlite3 \
	    python-textutils python-fcntl python-email \
	    yum-metadata-parser"

S = "${WORKDIR}/yum-${PV}"

inherit autotools

do_compile_append () {
	sed -e 's#!/usr/bin/python#!${bindir}/python#' -e 's#/usr/share#${datadir}#' -i ${S}/bin/yum.py
	sed -e 's#!/usr/bin/python#!${bindir}/python#' -e 's#/usr/share#${datadir}#' -i ${S}/bin/yum-updatesd.py
}

do_install_append () {
	install -d ${D}${bindir}/
	install ${WORKDIR}/extract-postinst.awk ${D}${bindir}/
	install ${WORKDIR}/yum-install-recommends.py ${D}${bindir}/
}

FILES_${PN} += "${libdir}/python* ${datadir}/yum-cli"

SRC_URI[md5sum] = "711f518cb72a698ed98a21a374a4585e"
SRC_URI[sha256sum] = "8b3f300602ce021bf5202496b98271814935f45f3bf3c6730ba4e789b2f323c8"

license: MIT

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD

extension: bb


text:
@misc{balka_jbstatistics:_2013,
	title = {{JBStatistics}: {Making} {Statistics} {Make} {Sense}},
	url = {http://www.jbstatistics.com},
	author = {Balka, Jeremy},
	year = {2013}
}

@misc{yau_r_2018,
	title = {R tutorial: an {R} introduction to statistics},
	url = {http://www.r-tutor.com},
	author = {Yau, Chi},
	year = {2018}
}

@misc{lane_online_2018,
	title = {Online {Statistics} {Education}: {An} {Interactive} {Multimedia} {Course} of {Study}},
	url = {http://onlinestatbook.com/},
	author = {Lane, David M.},
	year = {2018}
}

@misc{taylor_math5741m:_2017,
	title = {{MATH}5741M: {Statistical} {Theory} and {Methods}},
	publisher = {School of Mathematics - University of Leeds},
	author = {Taylor, Charles},
	year = {2017}
}

extension: bib


text:
require ${BPN}.inc

SRC_URI = "\
    ${E_RELEASES}/libs/${SRCNAME}/${SRCNAME}-${SRCVER}.tar.gz \
"

SRC_URI[md5sum] = "68627c1aabf5b7fe084299adcc0b73c1"
SRC_URI[sha256sum] = "10bad633480a691585b0ba470c573b14da0a010008d9d59d0792cea8c621d423"

PNBLACKLIST[emotion-generic-players] ?= "Depends on blacklisted emotion - the recipe will be removed on 2017-09-01 unless the issue is fixed"

PNBLACKLIST[emotion-generic-players] ?= "Runtime depends on blacklisted emotion-generic-players - the recipe will be removed on 2017-09-01 unless the issue is fixed"

PNBLACKLIST[emotion-generic-players] ?= "Runtime depends on blacklisted emotion-generic-players-dev - the recipe will be removed on 2017-09-01 unless the issue is fixed"

repository: nedap/meta-openembedded

repo_name: nedap/meta-openembedded

gha_language: BitBake


text:
@article{ec43a84949eb421d8545c57d5476cd77,
 abstract = {Recent leaks (such as Conti) have provided greater insights on the working of cybercriminal organisations. Just like any other business, these malicious actors strategically manage their processes in order to maximise their revenues. Coordinating different types of cybercrimes as part of a single attack campaign provides another opportunity to these criminal groups to improve the efficiency of their attacks. To investigate the promise of this “coordination” between cybercrimes in improving the financial gains realised by cybercriminals, we take a two-step approach. First, we perform a bibliometric analysis of past scientific literature discussing the concept of “coordination” w.r.t to cybercrime. Second, as a case study, analysing the attack chains of DDoS, phishing and ransomware attacks, we identify vantage points for potential coordination from an attacker\textquoterights perspective. Based on our findings, we propose a model (COORDINATE) to identify the types of potential cybercrime “coordinations”. COORDINATE considers three relevant types of coordination: direct collaborated coordination, indirect collaborated coordination, and opportunistic coordination. Given the advantages of coordinated attacks, our results suggest that one crime may provide opportunities for the next one. Coordinated attacks will become more prevalent, and that we may witness the development of a dynamic that leads to more online crime.},
 author = {Tom Meurs and Marianne Junger and Abhishta Abhishta and Erik Tews and Emma Ratia},
 day = {1},
 doi = {10.58346/JISIS.2022.I4.001},
 issn = {2182-2069},
 journal = {Journal of internet services and information security},
 language = {English},
 month = {November},
 number = {4},
 publisher = {Instituto Superior de Engenharia do Porto},
 title = {COORDINATE: A model to analyse the benefits and costs of coordinating cybercrime},
 volume = {12},
 year = {2022}
}


text:
package main

import (
	"flag"
	"fmt"
	"log"
	"net/http"
	"os"
	"strings"
	"time"

	"github.com/DataDog/datadog-go/statsd"
	"github.com/gorilla/mux"
	"github.com/hashicorp/faas-nomad/consul"
	"github.com/hashicorp/faas-nomad/handlers"
	"github.com/hashicorp/faas-nomad/metrics"
	"github.com/hashicorp/faas-nomad/nomad"
	fntypes "github.com/hashicorp/faas-nomad/types"
	"github.com/hashicorp/faas-nomad/vault"
	hclog "github.com/hashicorp/go-hclog"
	"github.com/hashicorp/nomad/api"
	"github.com/mitchellh/mapstructure"
	bootstrap "github.com/openfaas/faas-provider"
	"github.com/openfaas/faas-provider/types"
)

var version = "notset"

var (
	port                  = flag.Int("port", 8080, "Port to bind the server to")
	statsdServer          = flag.String("statsd_addr", "localhost:8125", "Location for the statsd collector")
	nodeURI               = flag.String("node_addr", "localhost", "URI of the current Nomad node, this address is used for reporting and logging")
	nomadAddr             = flag.String("nomad_addr", "localhost:4646", "Address for Nomad API endpoint")
	nomadTLSCA            = flag.String("nomad_tls_ca", "", "The TLS ca certificate file location")
	nomadTLSCert          = flag.String("nomad_tls_cert", "", "The TLS client certifcate file location")
	nomadTLSKey           = flag.String("nomad_tls_key", "", "The TLS private key file location")
	nomadTLSSkipVerify    = flag.Bool("nomad_tls_skip_verify", false, "Skips TLS verification for Nomad API. Not recommend for production")
	enableNomadTLS        = flag.Bool("enable_nomad_tls", false, "Toggles tls on Nomad endpoint/client")
	nomadACL              = flag.String("nomad_acl", "", "The ACL token for faas-nomad if Nomad ACLs are enabled")
	consulAddr            = flag.String("consul_addr", "http://localhost:8500", "Address for Consul API endpoint")
	consulACL             = flag.String("consul_acl", "", "ACL token for Consul API, only required if ACL are enabled in Consul")
	enableConsulDNS       = flag.Bool("enable_consul_dns", false, "Uses the consul_addr as a default DNS server. Assumes DNS interface is listening on port 53")
	nomadRegion           = flag.String("nomad_region", "global", "Default region to schedule functions in")
	enableBasicAuth       = flag.Bool("enable_basic_auth", false, "Flag for enabling basic authentication on gateway endpoints")
	basicAuthSecretPath   = flag.String("basic_auth_secret_path", "/secrets", "The directory path to the basic auth secret file")
	vaultAddrOverride     = flag.String("vault_addr", "", "Vault address override. Default Vault address is returned from the Nomad agent")
	vaultTLSSkipVerify    = flag.Bool("vault_tls_skip_verify", false, "Skips TLS verification for calls to Vault. Not recommend for production")
	vaultDefaultPolicy    = flag.String("vault_default_policy", "openfaas", "The default policy used when secrets are deployed with a function")
	vaultSecretPathPrefix = flag.String("vault_secret_path_prefix", "secret/openfaas", "The Vault k/v path prefix used when secrets are deployed with a function")
	vaultAppRoleID        = flag.String("vault_app_role_id", "", "A valid Vault AppRole role_id")
	vaultAppRoleSecretID  = flag.String("vault_app_secret_id", "", "A valid Vault AppRole secret_id derived from the role")
	cpuArchConstraint     = flag.String("cpu_arch_constraint", "amd64", "CPU architecture to constraint deployed functions to")
)

var functionTimeout = flag.Duration("function_timeout", 30*time.Second, "Timeout for function execution")

var (
	loggerFormat = flag.String("logger_format", "text", "Format for log output text | json")
	loggerLevel  = flag.String("logger_level", "INFO", "Log output level INFO | ERROR | DEBUG | TRACE")
	loggerOutput = flag.String("logger_output", "", "Filepath to write log file, if omitted stdOut is used")
)

func main() {
	flag.Parse()

	nomadConfig := &fntypes.NomadConfig{
		TLSEnabled:    *enableNomadTLS,
		Address:       *nomadAddr,
		ACLToken:      *nomadACL,
		TLSCA:         *nomadTLSCA,
		TLSCert:       *nomadTLSCert,
		TLSPrivateKey: *nomadTLSKey,
		TLSSkipVerify: *nomadTLSSkipVerify,
	}
	logger, stats, nomadClient, consulResolver := makeDependencies(
		*statsdServer,
		*nodeURI,
		*nomadConfig,
		*consulAddr,
		*consulACL,
		*nomadRegion,
	)

	logger.Info("Started version: " + version)
	stats.Incr("started", nil, 1)

	handlers := createFaaSHandlers(nomadClient, consulResolver, stats, logger)

	config := &types.FaaSConfig{}
	config.ReadTimeout = *functionTimeout
	config.WriteTimeout = *functionTimeout
	config.TCPPort = port
	config.EnableHealth = true
	config.EnableBasicAuth = *enableBasicAuth
	config.SecretMountPath = *basicAuthSecretPath

	logger.Info("Started Nomad provider", "port", *config.TCPPort)
	logger.Info("Basic authentication", "enabled", fmt.Sprintf("%t", config.EnableBasicAuth))

	bootstrap.Serve(handlers, config)
}

func createFaaSHandlers(nomadClient *api.Client, consulResolver *consul.Resolver, stats *statsd.Client, logger hclog.Logger) *types.FaaSHandlers {

	datacenter, err := nomadClient.Agent().Datacenter()
	if err != nil {
		logger.Error("Error returning the agent's datacenter", err.Error())
		datacenter = "dc1"
	}
	logger.Info("Datacenter from agent: " + datacenter)

	agentSelf, err := nomadClient.Agent().Self()
	var vaultConfig fntypes.VaultConfig
	if err != nil {
		logger.Error("/agent/self returned error. Unable to fetch Vault config.", err.Error())
	} else {
		mapstructure.Decode(agentSelf.Config["Vault"], &vaultConfig)
		if len(*vaultAddrOverride) > 0 {
			vaultConfig.Addr = *vaultAddrOverride
		}
	}

	logger.Info("Vault address: " + vaultConfig.Addr)
	vaultConfig.DefaultPolicy = *vaultDefaultPolicy
	vaultConfig.SecretPathPrefix = *vaultSecretPathPrefix
	vaultConfig.AppRoleID = *vaultAppRoleID
	vaultConfig.AppSecretID = *vaultAppRoleSecretID
	vaultConfig.TLSSkipVerify = *vaultTLSSkipVerify

	providerConfig := &fntypes.ProviderConfig{
		Vault:             vaultConfig,
		Datacenter:        datacenter,
		ConsulAddress:     *consulAddr,
		ConsulDNSEnabled:  *enableConsulDNS,
		CPUArchConstraint: *cpuArchConstraint,
	}

	vs := vault.NewVaultService(&vaultConfig, logger)

	_, loginErr := vs.Login()
	if loginErr != nil {
		logger.Error("Unable to login to Vault. Secrets will not work properly", loginErr.Error())
	} else {
		logger.Info("Vault authentication successful!")
	}

	return &types.FaaSHandlers{
		FunctionReader: handlers.MakeReader(nomadClient.Jobs(), logger, stats),
		DeployHandler:  handlers.MakeDeploy(nomadClient.Jobs(), *providerConfig, logger, stats),
		DeleteHandler:  handlers.MakeDelete(consulResolver, nomadClient.Jobs(), logger, stats),
		ReplicaReader:  makeReplicationReader(nomadClient.Jobs(), logger, stats),
		ReplicaUpdater: makeReplicationUpdater(nomadClient.Jobs(), logger, stats),
		FunctionProxy:  makeFunctionProxyHandler(consulResolver, logger, stats, *functionTimeout),
		UpdateHandler:  handlers.MakeDeploy(nomadClient.Jobs(), *providerConfig, logger, stats),
		InfoHandler:    handlers.MakeInfo(logger, stats, version),
		Health:         handlers.MakeHealthHandler(),
		SecretHandler:  handlers.MakeSecretHandler(vs, logger.Named("secrets_handler")),
	}
}

func makeDependencies(statsDAddr string, thisAddr string, nomadConfig fntypes.NomadConfig, consulAddr string, consulACL string, region string) (hclog.Logger, *statsd.Client, *api.Client, *consul.Resolver) {
	logger := setupLogging()

	logger.Info("Using StatsD server:" + statsDAddr)
	stats, err := statsd.New(statsDAddr)
	if err != nil {
		logger.Error("Error creating statsd client", err)
	}

	// prefix every metric with the app name
	stats.Namespace = "faas.nomadd."
	stats.Tags = append(stats.Tags, "instance:"+strings.Replace(thisAddr, ":", "_", -1))

	c := api.DefaultConfig()
	logger.Info("create nomad client", "addr", nomadConfig.Address)
	clientConfig := c.ClientConfig(region, nomadConfig.Address, nomadConfig.TLSEnabled)
	clientConfig.SecretID = nomadConfig.ACLToken
	if nomadConfig.TLSEnabled {
		clientConfig.TLSConfig = &api.TLSConfig{
			CACert:     nomadConfig.TLSCA,
			ClientCert: nomadConfig.TLSCert,
			ClientKey:  nomadConfig.TLSPrivateKey,
			Insecure:   nomadConfig.TLSSkipVerify,
		}
		clientConfig.ConfigureTLS()
	}

	nomadClient, err := api.NewClient(clientConfig)
	if err != nil {
		logger.Error("Unable to create nomad client", err)
	}

	cr := consul.NewResolver(consulAddr, consulACL, logger.Named("consul_resolver"))

	return logger, stats, nomadClient, cr
}

func setupLogging() hclog.Logger {
	logJSON := false
	if *loggerFormat == "json" {
		logJSON = true
	}

	appLogger := hclog.New(&hclog.LoggerOptions{
		Name:       "nomadd",
		Level:      hclog.LevelFromString(*loggerLevel),
		JSONFormat: logJSON,
		Output:     createLogFile(),
	})

	return appLogger
}

func createLogFile() *os.File {
	if logFile := os.Getenv("logger_output"); logFile != "" {
		f, err := os.OpenFile(logFile, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
		if err == nil {
			return f
		}

		log.Printf("Unable to open file for output, defaulting to std out: %s\n", err.Error())
	}

	return os.Stdout
}
func makeFunctionProxyHandler(r consul.ServiceResolver, logger hclog.Logger, s *statsd.Client, timeout time.Duration) http.HandlerFunc {
	return handlers.MakeExtractFunctionMiddleWare(
		func(r *http.Request) map[string]string {
			return mux.Vars(r)
		},
		handlers.MakeProxy(
			handlers.ProxyConfig{
				Client:   handlers.MakeProxyClient(timeout, logger),
				Resolver: r,
				Logger:   logger,
				StatsD:   s,
				Timeout:  timeout,
			},
		),
	)
}

func makeReplicationReader(client nomad.Job, logger hclog.Logger, stats metrics.StatsD) http.HandlerFunc {
	return handlers.MakeExtractFunctionMiddleWare(
		func(r *http.Request) map[string]string {
			return mux.Vars(r)
		},
		handlers.MakeReplicationReader(client, logger, stats),
	)
}

func makeReplicationUpdater(client nomad.Job, logger hclog.Logger, stats metrics.StatsD) http.HandlerFunc {
	return handlers.MakeExtractFunctionMiddleWare(
		func(r *http.Request) map[string]string {
			return mux.Vars(r)
		},
		handlers.MakeReplicationWriter(client, logger, stats),
	)
}

extension: go


text:
%% This document is a bibtex export of HAL publication
%% Date of the export : 02/05/2012
%% Criteria : Author : 'friggeri'

%%
%% inria-00490195, version 2
%% http://hal.inria.fr/inria-00490195
%%

@article{friggeri:2011:inria-00490195:2,
  AUTHOR = {Friggeri, Adrien and Chelius, Guillaume and Fleury, Eric and Fraboulet, Antoine and Mentr{\'e}, France and Lucet, Jean-Christophe},
  TITLE = {{Reconstructing Social Interactions Using an unreliable Wireless Sensor Network}},
  JOURNAL = {{Computer Communications}},
  PUBLISHER = {Elsevier},
  VOLUME = {34},
  NUMBER = {5},
  PAGES = {609--618},
  YEAR = {2011},
  MONTH = Apr,
  KEYWORDS = {complex networks; interaction networks; wireless sensor networks; medical applications},
  DOI = {10.1016/j.comcom.2010.06.005},
  URL = {http://hal.inria.fr/inria-00490195}
}
%% inria-00597448, version 1
%% http://hal.inria.fr/inria-00597448
%%

@article{friggeri:2011:inria-00597448:1,
  AUTHOR = {Friggeri, Adrien and Cointet, Jean-Philippe and Latapy, Matthieu, Matthieu},
  TITLE = {{A Real-World Spreading Experiment in the Blogosphere}},
  JOURNAL = {{Complex Systems}},
  PUBLISHER = {Complex Systems Publications, Inc.},
  VOLUME = {19},
  NUMBER = {3},
  YEAR = {2011},
  URL = {http://hal.inria.fr/inria-00597448}
}
%% inria-00475921, version 1
%% http://hal.inria.fr/inria-00475921
%%

@inproceedings{friggeri:2010:inria-00475921:1,
  AUTHOR = {Friggeri, Adrien and Chelius, Guillaume},
  TITLE = {{Biais dans les mesures obtenues par un r{\'e}seau de capteurs sans fil}},
  BOOKTITLE = {{12{\`e}mes Rencontres Francophones sur les Aspects Algorithmiques de T{\'e}l{\'e}communications (AlgoTel)}},
  YEAR = {2010},
  EDITOR = {Maria Gradinariu Potop-Butucaru and Herv{\'e} Rivano},
  KEYWORDS = {france},
  ADDRESS = {Belle Dune, France},
  MONTH = Jun,
  URL = {http://hal.inria.fr/inria-00475921}
}
%% inria-00587942, version 1
%% http://hal.inria.fr/inria-00587942
%%

@inproceedings{friggeri:2011:inria-00587942:1,
  AUTHOR = {Friggeri, Adrien and Chelius, Guillaume and Fleury, Eric},
  TITLE = {{Communaut{\'e}s : Arr{\^e}tons de ne compter que les ar{\^e}tes}},
  BOOKTITLE = {{13es Rencontres Francophones sur les Aspects Algorithmiques de T{\'e}l{\'e}communications (AlgoTel)}},
  YEAR = {2011},
  EDITOR = {Ducourthial, Bertrand and Felber, Pascal},
  MONTH = Jun,
  KEYWORDS = {france},
  ADDRESS = {Cap Est{\'e}rel, France},
  URL = {http://hal.inria.fr/inria-00587942}
}
%% inria-00597446, version 1
%% http://hal.inria.fr/inria-00597446
%%

@inproceedings{friggeri:2011:inria-00597446:1,
  AUTHOR = {Friggeri, Adrien and Chelius, Guillaume and Fleury, Eric},
  TITLE = {{Fellows: Crowd-sourcing the evaluation of an overlapping community model based on the cohesion measure}},
  BOOKTITLE = {{Interdisciplinary Workshop on Information and Decision in Social Networks}},
  YEAR = {2011},
  MONTH = May,
  NOTE = {31 accept{\'e}/140 soumis +250 participants},
  ADDRESS = {Cambridge, {\'E}tats-Unis},
  URL = {http://hal.inria.fr/inria-00597446}
}
%% inria-00597447, version 1
%% http://hal.inria.fr/inria-00597447
%%

@inproceedings{friggeri:2011:inria-00597447:1,
  AUTHOR = {Friggeri, Adrien and Chelius, Guillaume and Fleury, Eric},
  TITLE = {{Egomunities, Exploring Socially Cohesive Person-based Communities}},
  BOOKTITLE = {{NetSci 2011 The International School and Conference on Network Science}},
  YEAR = {2011},
  MONTH = Jun,
  ADDRESS = {Budapest, Hongrie},
  URL = {http://hal.inria.fr/inria-00597447}
}
%% inria-00619092, version 1
%% http://hal.inria.fr/inria-00619092
%%

@inproceedings{friggeri:2011:inria-00619092:1,
  AUTHOR = {Friggeri, Adrien and Chelius, Guillaume and Fleury, Eric},
  TITLE = {{Triangles to Capture Social Cohesion}},
  BOOKTITLE = {{Third IEEE International Conference on Social Computing}},
  YEAR = {2011},
  MONTH = Sep,
  ADDRESS = {Cambridge, {\'E}tats-Unis},
  URL = {http://hal.inria.fr/inria-00619092}
}
%% inria-00626064, version 1
%% http://hal.inria.fr/inria-00626064
%%

@inproceedings{friggeri:2011:inria-00626064:1,
  AUTHOR = {Friggeri, Adrien and Chelius, Guillaume and Fleury, Eric},
  TITLE = {{Fellows: Crowd-sourcing the evaluation of an overlapping community model based on the cohesion measure}},
  BOOKTITLE = {{Complex Dynamics of Human Interactions}},
  YEAR = {2011},
  MONTH = Sep,
  ADDRESS = {Vienna, Autriche},
  URL = {http://hal.inria.fr/inria-00626064}
}
%% inria-00507447, version 1
%% http://hal.inria.fr/inria-00507447
%%

@inproceedings{lucet:2010:inria-00507447:1,
  AUTHOR = {Lucet, Jean-Christophe and Chelius, Guillaume and Laouenan, C{\'e}dric and Friggeri, Adrien and Veziris, N. and Lepelletier, D. and Abiteboul, D. and Bouvet, Elisabeth and Fleury, Eric and Mentr{\'e}, France},
  TITLE = {{Electronic Sensors for Measuring Interactions between Healthcare Workers (HCWs) and Patients (Pts): the Case of Tuberculosis (TB)}},
  YEAR = {2010},
  MONTH = Sep,
  BOOKTITLE = {{2010 Interscience Conference on Antimicrobial Agents and Chemotherapy}},
  ORGANIZATION = {American Society for Microbiology},
  ADDRESS = {Boston, {\'E}tats-Unis},
  URL = {http://hal.inria.fr/inria-00507447}
}
%% inria-00630363, version 1
%% http://hal.inria.fr/inria-00630363
%%

@inproceedings{friggeri:2011:inria-00630363:1,
  AUTHOR = {Friggeri, Adrien and Chelius, Guillaume and Fleury, Eric},
  TITLE = {{Trouver des communaut{\'e}s socialement coh{\'e}sives est NP-dur}},
  YEAR = {2011},
  MONTH = Oct,
  KEYWORDS={france},
  BOOKTITLE = {{13emes journ{\'e}es Graphes et Algorithmes}},
  ADDRESS = {Lyon, France},
  URL = {http://hal.inria.fr/inria-00630363}
}
%% inria-00605673, version 1
%% http://hal.inria.fr/inria-00605673
%%

@misc{friggeri:2011:inria-00605673:1,
  AUTHOR = {Friggeri, Adrien and Fleury, Eric},
  TITLE = {{Des triangles pour mesurer la coh{\'e}sion sociale : Fellows, une exp{\'e}rimentation sur Facebook}},
  YEAR = {2011},
  MONTH = Jun,
  KEYWORDS = {france},
  NOTE = {S{\'e}minaire w2s @ La Cantine},
  URL = {http://hal.inria.fr/inria-00605673}
}
%% hal-00692548, version 1
%% http://hal.inria.fr/hal-00692548
%%

@techreport{friggeri:2012:hal-00692548:1,
  AUTHOR = {Friggeri, Adrien and Fleury, Eric},
  TITLE = {{Finding cohesive communities with C³}},
  TYPE = {Rapport de recherche},
  YEAR = {2012},
  MONTH = Apr,
  INSTITUTION = {INRIA},
  NUMBER = {RR-7947},
  URL = {http://hal.inria.fr/hal-00692548}
}
%% inria-00565336, version 2
%% http://hal.inria.fr/inria-00565336
%%

@techreport{friggeri:2011:inria-00565336:2,
  AUTHOR = {Friggeri, Adrien and Chelius, Guillaume and Fleury, Eric},
  TITLE = {{Egomunities, Exploring Socially Cohesive Person-based Communities}},
  TYPE = {Rapport de recherche},
  YEAR = {2011},
  MONTH = Feb,
  KEYWORDS = {social networks, complex networks, real-world graphs, community detection, overlapping communities, data mining, modelisation},
  INSTITUTION = {INRIA},
  NUMBER = {RR-7535},
  URL = {http://hal.inria.fr/inria-00565336}
}
%% inria-00608889, version 1
%% http://hal.inria.fr/inria-00608889
%%

@techreport{friggeri:2011:inria-00608889:1,
  AUTHOR = {Friggeri, Adrien and Chelius, Guillaume and Fleury, Eric},
  TITLE = {{Triangles to Capture Social Cohesion}},
  TYPE = {Rapport de recherche},
  YEAR = {2011},
  MONTH = Jul,
  INSTITUTION = {INRIA},
  NUMBER = {RR-7686},
  URL = {http://hal.inria.fr/inria-00608889}
}
%% inria-00621065, version 2
%% http://hal.inria.fr/inria-00621065
%%

@techreport{friggeri:2011:inria-00621065:2,
  AUTHOR = {Friggeri, Adrien and Fleury, Eric},
  TITLE = {{Maximizing the Cohesion is NP-hard}},
  TYPE = {Rapport de recherche},
  YEAR = {2011},
  MONTH = Sep,
  INSTITUTION = {INRIA},
  NUMBER = {RR-7734},
  URL = {http://hal.inria.fr/inria-00621065}
}

@article{Lucet:2012gl,
author = {Lucet, Jean-Christophe and Laouenan, Cédric and Chelius, Guillaume and Veziris, Nicolas and Lepelletier, Didier and Friggeri, Adrien and Abiteboul, Dominique and Bouvet, Elisabeth and Mentré, France and Fleury, Eric},
title = {{Electronic Sensors for Assessing Interactions between Healthcare Workers and Patients under Airborne Precautions}},
journal = {PLoS ONE},
year = {2012},
volume = {7},
number = {5},
pages = {e37893},
month = may
}

@book{allsopp07,
author = {John Allsop},
title = {Microformats: Empowering Your Markup for Web 2.0},
isbn = {1-59059-814-8},
publisher = {Publisher},
address = {London},
month = mar,
year = {2007},
}

gha_language: SCSS


text:
PD = "Out of the Linux source tree, packaging of the kconfig infrastructure, ready for use by third party projects"
PV = "4.11.0.1"

HOMEPAGE = "http://ymorin.is-a-geek.org/projects/kconfig-frontends"
LICENSE = "GPL"

SRC_URI = " \
  http://ymorin.is-a-geek.org/download/${P}/${S}.tar.xz;md5sum=ee0d3718b83b519f384ef5f7eae980c5 \
"

HOST_DEPENDS = "flex bison gperf"
HOST_DEPENDS_native = "${HOST_DEPENDS} gcc"

DEPENDS = "crosstool-ng"
DEPENDS_native = ""

step_build() {
  cd "${SRCDIR}"/${S}

  ./configure \
    --host=${TARGET_SYS} \
    --prefix=/ \
    --enable-frontends=conf,mconf

  rm libs/parser/hconf.c
  make
}

step_install() {
  cd "${SRCDIR}"/${S}

  if [ "${PN}" = "${P}-native" ]; then
    make DESTDIR="${FILES_DEV}" install
    return
  fi

  make DESTDIR="${FILES_PKG}" install
  rm -r "${FILES_PKG}"/{share,include}
  rm "${FILES_PKG}"/bin/kconfig-{gettext,diff,merge}
  rm "${FILES_PKG}"/lib/pkgconfig/*.pc

  install_license COPYING "${FILES_LICENSE}"
}

BBCLASSEXTEND = "native"

repository: typedivision/pacstage

repo_name: typedivision/pacstage


text:
package gaze

import (
	"fmt"
	"testing"
)

func TestFind(t *testing.T) {
	ds := &DisjointSet{}
	ds.Items = make(map[string]*Item)
	c1 := &Cell{15, 0, 0, nil, nil, nil, 0.0, 0.0}
	c2 := &Cell{15, 0, 1, nil, nil, nil, 0.0, 0.0}
	item1 := &Item{c1, nil}
	item2 := &Item{c2, nil}
	ds.Items["00"] = item1
	ds.Items["01"] = item2
	result := ds.Find(item1)
	if result.Data.X != 0 && result.Data.Y != 0 {
		t.Errorf("Find(), want [0,0], got [%d,%d]", result.Data.X, result.Data.Y)
	}
}

func TestUnion(t *testing.T) {
	ds := &DisjointSet{}
	ds.Items = make(map[string]*Item)
	c1 := &Cell{15, 0, 0, nil, nil, nil, 0.0, 0.0}
	c2 := &Cell{15, 0, 1, nil, nil, nil, 0.0, 0.0}
	item1 := &Item{c1, nil}
	item2 := &Item{c2, nil}
	ds.Items["00"] = item1
	ds.Items["01"] = item2
	result := ds.Union(item1, item2)
	if result.Data.X != 0 && result.Data.Y != 1 {
		t.Errorf("Union(), want [0,1], got [%d,%d]", result.Data.X, result.Data.Y)
	}
	root := ds.Find(item1)
	if result.Data.X != 0 && result.Data.Y != 1 {
		t.Errorf("Union(), merged item1 & item2, Find(item1) should return item2 as root, got %v", root.Data)
	}
}

func BenchmarkDisjointSetFind(b *testing.B) {
	size := uint16(1000)
	ds := &DisjointSet{}
	ds.Items = make(map[string]*Item)
	for i := uint16(0); i < size; i++ {
		cell := &Cell{15, 0, i, nil, nil, nil, 0.0, 0.0}
		item := &Item{cell, nil}
		ds.Items[fmt.Sprintf("%d", i)] = item
	}
	for i := uint16(0); i < size-1; i++ {
		ds.Items[fmt.Sprintf("%d", i)].Parent = ds.Items[fmt.Sprintf("%d", i+1)]
	}
	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		_ = ds.Find(ds.Items["0"])
	}
}

func BenchmarkDisjointSetUnion(b *testing.B) {
	for i := 0; i < b.N; i++ {
		size := uint16(1000)
		ds := &DisjointSet{}
		ds.Items = make(map[string]*Item)
		for i := uint16(0); i < size; i++ {
			cell := &Cell{15, 0, i, nil, nil, nil, 0.0, 0.0}
			item := &Item{cell, nil}
			ds.Items[fmt.Sprintf("%d", i)] = item
		}
		for i := uint16(0); i < size/2; i++ {
			ds.Items[fmt.Sprintf("%d", i)].Parent = ds.Items[fmt.Sprintf("%d", i+1)]
		}
		root1 := ds.Find(ds.Items["0"])
		root2 := ds.Find(ds.Items["501"])
		_ = ds.Union(root1, root2)
	}
}

gha_language: Go


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

inherit ros_distro_melodic
inherit ros_superflore_generated

DESCRIPTION = "eband_local_planner implements a plugin to the     base_local_planner. It implements the Elastic Band method on the     SE2 manifold."
AUTHOR = "Piyush Khandelwal <piyushk@gmail.com>"
ROS_AUTHOR = "Christian Connette"
HOMEPAGE = "http://ros.org/wiki/eband_local_planner"
SECTION = "devel"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://package.xml;beginline=13;endline=13;md5=d566ef916e9dedc494f5f793a6690ba5"

ROS_CN = "eband_local_planner"
ROS_BPN = "eband_local_planner"

ROS_BUILD_DEPENDS = " \
    base-local-planner \
    cmake-modules \
    control-toolbox \
    costmap-2d \
    dynamic-reconfigure \
    geometry-msgs \
    nav-core \
    nav-msgs \
    pluginlib \
    roscpp \
    tf2-eigen \
    tf2-geometry-msgs \
    tf2-ros \
"

ROS_BUILDTOOL_DEPENDS = " \
    catkin-native \
"

ROS_EXPORT_DEPENDS = " \
    base-local-planner \
    control-toolbox \
    costmap-2d \
    dynamic-reconfigure \
    geometry-msgs \
    nav-core \
    nav-msgs \
    pluginlib \
    roscpp \
    tf2-eigen \
    tf2-geometry-msgs \
    tf2-ros \
"

ROS_BUILDTOOL_EXPORT_DEPENDS = ""

ROS_EXEC_DEPENDS = " \
    base-local-planner \
    control-toolbox \
    costmap-2d \
    dynamic-reconfigure \
    geometry-msgs \
    nav-core \
    nav-msgs \
    pluginlib \
    roscpp \
    tf2-eigen \
    tf2-geometry-msgs \
    tf2-ros \
"

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

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

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

# matches with: https://github.com/utexas-bwi-gbp/eband_local_planner-release/archive/release/melodic/eband_local_planner/0.4.0-1.tar.gz
ROS_BRANCH ?= "branch=release/melodic/eband_local_planner"
SRC_URI = "git://github.com/utexas-bwi-gbp/eband_local_planner-release;${ROS_BRANCH};protocol=https"
SRCREV = "d48dd752dbfdbbe1a4da3c821609200ddaadfd91"
S = "${WORKDIR}/git"

ROS_BUILD_TYPE = "catkin"

inherit ros_${ROS_BUILD_TYPE}

repository: jianchangfeng/meta-ros

repo_name: jianchangfeng/meta-ros


text:
@incollection{Rojas:11d,
 address = {Berlin},
 author = {C. R. Rojas and J. Mårtensson and H. Hjalmarsson},
 booktitle = {Identification for Automotive Systems},
 editor = {D Alberer and H. Hjalmarsson and L. del Re},
 pages = {},
 publisher = {Springer Verlag},
 series = {Lecture Notes in Control and Information Sciences},
 title = {A Tutorial on Applications-Oriented Optimal Experiment Design},
 year = {2012}
}

repository: hhjalmars/academic-kickstart

repo_name: hhjalmars/academic-kickstart


text:
---
---

@string{aps = {American Physical Society,}}

@article{ali2021evaluating,
  title={Evaluating very deep convolutional neural networks for nucleus segmentation from brightfield cell microscopy images},
  author={Ali, Mohammed AS and Misko, Oleg and Salumaa, Sten-Oliver and Papkov, Mikhail and Palo, Kaupo and Fishman, Dmytro and Parts, Leopold},
  journal={SLAS DISCOVERY: Advancing the Science of Drug Discovery},
  volume={26},
  number={9},
  pages={1125--1137},
  year={2021},
  publisher={SAGE Publications Sage CA: Los Angeles, CA},
  html={https://www.sciencedirect.com/science/article/pii/S2472555222067557}
}

@inproceedings{papkov2021noise2stack,
  title={Noise2Stack: Improving image restoration by learning from volumetric data},
  author={Papkov, Mikhail and Roberts, Kenny and Madissoon, Lee Ann and Shilts, Jarrod and Bayraktar, Omer and Fishman, Dmytro and Palo, Kaupo and Parts, Leopold},
  booktitle={Machine Learning for Medical Image Reconstruction: 4th International Workshop, MLMIR 2021, Held in Conjunction with MICCAI 2021, Strasbourg, France, October 1, 2021, Proceedings 4},
  pages={99--108},
  year={2021},
  organization={Springer},
  arxiv={2011.05105},
  pdf={https://arxiv.org/pdf/2011.05105.pdf},
  html={https://link.springer.com/chapter/10.1007/978-3-030-88552-6_10},
  slides={https://docs.google.com/presentation/d/1-_xTHEN3Q72m5yhXzkIZEfLdfUeM2hWq/edit?usp=sharing&ouid=100466478700099638748&rtpof=true&sd=true}
}

@misc{kaliuzhnyi2023reducing,
  title={Reducing the Effect of Incomplete Annotations in Object Detection for Histopathology},
  author={Denys Kaliuzhnyi and Dmytro Fishman and Mikhail Papkov},
  year={2023},
  url={https://openreview.net/forum?id=PIfJnq9kpdw},
  html={https://openreview.net/forum?id=PIfJnq9kpdw},
  pdf={https://openreview.net/pdf?id=PIfJnq9kpdw},
  slides={https://docs.google.com/presentation/d/1-OO1SzawVIHetPSLsCybtXzpKMX9FWWJXvpbKkOfiXw/edit?usp=sharing}
}

@misc{chizhov2023selfsupervised,
  title={Self-Supervised Image Denoising with Swin Transformer},
  author={Pavel Chizhov and Mikhail Papkov},
  year={2023},
  url={https://openreview.net/forum?id=EARgl3EH-nq},
  html={https://openreview.net/forum?id=EARgl3EH-nq},
  pdf={https://openreview.net/pdf?id=EARgl3EH-nq}
}

@misc{ariva2023fast,
  title={Fast Fourier Convolutions in Self-Supervised Neural Networks for Image Denoising},
  author={Joonas Ariva and Mikhail Papkov},
  year={2023},
  url={https://openreview.net/forum?id=ghfL1e2rOd},
  html={https://openreview.net/forum?id=ghfL1e2rOd},
  pdf={https://openreview.net/pdf?id=ghfL1e2rOd}
}

@misc{papkov2023swinia,
  title={SwinIA: Self-Supervised Blind-Spot Image Denoising with Zero Convolutions},
  author={Mikhail Papkov and Pavel Chizhov},
  year={2023},
  eprint={2305.05651},
  archivePrefix={arXiv},
  primaryClass={cs.CV},
  arxiv={2305.05651}
}


text:
file(REMOVE_RECURSE
  "CMakeFiles/FindTheCelebrity.dir/main.cpp.o"
  "FindTheCelebrity.pdb"
  "FindTheCelebrity"
)

# Per-language clean rules from dependency scanning.
foreach(lang CXX)
  include(CMakeFiles/FindTheCelebrity.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

extension: cmake


text:
SUMMARY = "Trusty secure OS with Keystore application"
DESCRIPTION = "Static keystore TA running in Trusty for Tegra platforms."

require keystore.inc
require recipes-bsp/trusty/trusty-l4t.inc

LIC_FILES_CHKSUM_remove = " \
    file://app/sample/hwkey-agent/LICENSE;md5=0f2184456a07e1ba42a53d9220768479 \
    file://app/sample/LICENSE;md5=86d3f3a95c324c9479bd8986968f4327 \
"

S = "${WORKDIR}/git"

repository: danielwangksu/test-distro

repo_name: danielwangksu/test-distro


text:
file(REMOVE_RECURSE
  "CMakeFiles/Board_Game.dir/lib/mymath.c.o"
  "CMakeFiles/Board_Game.dir/lib/printf.c.o"
  "CMakeFiles/Board_Game.dir/lib/prng.c.o"
  "CMakeFiles/Board_Game.dir/lib/stdlib.c.o"
  "CMakeFiles/Board_Game.dir/src/board.c.o"
  "CMakeFiles/Board_Game.dir/src/moves.c.o"
  "CMakeFiles/Board_Game.dir/src/service.c.o"
  "Board_Game.pdb"
  "Board_Game"
)

# Per-language clean rules from dependency scanning.
foreach(lang C)
  include(CMakeFiles/Board_Game.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

repository: siddk/driller-lite

repo_name: siddk/driller-lite


text:
macro(add_target_properties _target _name)
	set(_properties)
	foreach(_prop ${ARGN})
		set(_properties "${_properties} ${_prop}")
	endforeach(_prop)
	get_target_property(_old_properties ${_target} ${_name})
	if(NOT _old_properties)
		# in case it's NOTFOUND
		set(_old_properties)
	endif(NOT _old_properties)
	set_target_properties(${_target} PROPERTIES ${_name} "${_old_properties} ${_properties}")
endmacro(add_target_properties)

repository: LARG/spl-release

repo_name: LARG/spl-release

gha_license_id: NOASSERTION


text:
@inproceedings{hanna-healthsec11,
  author = {Steve Hanna and Rolf Rolles and Andres Molina-Markham and Pongsin Poosankam and Kevin Fu and Dawn Song},
  title = {Take two software updates and see me in the morning: The Case for Software Security Evaluations of Medical Devices},
  booktitle = {Proceedings of 2nd USENIX Workshop on Health Security and Privacy (HealthSec)},
  conference_url = {http://www.usenix.org/events/healthsec11/},
  url = {https://spqr.eecs.umich.edu/papers/hanna-aed-healthsec11.pdf},
  note = {\\\url{https://spqr.eecs.umich.edu/papers/hanna-aed-healthsec11.pdf}},
  slides_url = {http://www.usenix.org/events/healthsec11/tech/slides/hanna.pdf},
  keywords = {Security, Health},
  venue = {HealthSec (USENIX Workshop on Health Security and Privacy)},
  month = aug,
  monthnum = 8,
  year = 2011
}


text:
package chunks

import (
	e "errors"
)

var (
	BadDatum                    = e.New("bad datum - doesn't match content hash")
	BadDatumLength              = e.New("bad datum - length must be 20")
	ChunkTooLong                = e.New("chunk too long")
	EmptyTitle                  = e.New("empty title parameter")
	MismatchedPublicPrivateKeys = e.New("public and private keys don't match")
	NilData                     = e.New("nil data parameter")
	NilDatum                    = e.New("nil datum (content hash) parameter")
	NilReader                   = e.New("nil io.Reader")
	NilRSAPrivKey               = e.New("nil RSA private key parameter")
	NilSubClass                 = e.New("nil subClass parameter")
	NoDigSig                    = e.New("no digital signature: the list is not signed")
	NoNthItem                   = e.New("no Nth item")
	TooShortForDigiList         = e.New("too short to be a DigiList")
	WriteReturnsWrongHash       = e.New("write returns wrong hash")
	WrongNumberBytesWritten     = e.New("wrong number of bytes written")
	ZeroLengthChunk             = e.New("zero length chunk")
	ZeroLengthInput             = e.New("zero length input")
)


text:
@misc{QuantumAlgebra.jl,
	author  = {Johannes Feist and contributors},
	title   = {QuantumAlgebra.jl},
	url     = {https://github.com/jfeist/QuantumAlgebra.jl},
	version = {v1.1.0},
	year    = {2021},
	month   = {9},
	doi     = {10.5281/zenodo.3525845}
}

@article{Sanchez-Barquilla2020,
  title = {Cumulant Expansion for the Treatment of Light-Matter Interactions in Arbitrary Material Structures},
  author = {{S{\'a}nchez-Barquilla}, M. and Silva, R. E. F. and Feist, J.},
  year = {2020},
  month = jan,
  volume = {152},
  pages = {034108},
  issn = {0021-9606},
  doi = {10.1063/1.5138937},
  abstract = {Strong coupling of quantum emitters with confined electromagnetic modes of nanophotonic structures may be used to change optical, chemical, and transport properties of materials, with significant theoretical effort invested toward a better understanding of this phenomenon. However, a full theoretical description of both matter and light is an extremely challenging task. Typical theoretical approaches simplify the description of the photonic environment by describing it as a single mode or few modes. While this approximation is accurate in some cases, it breaks down strongly in complex environments, such as within plasmonic nanocavities, and the electromagnetic environment must be fully taken into account. This requires the quantum description of a continuum of bosonic modes, a problem that is computationally hard. We here investigate a compromise where the quantum character of light is taken into account at modest computational cost. To do so, we focus on a quantum emitter that interacts with an arbitrary photonic spectral density and employ the cumulant, or cluster, expansion method to the Heisenberg equations of motion up to first, second, and third order. We benchmark the method by comparing it with exact solutions for specific situations and show that it can accurately represent dynamics for many parameter ranges.},
  copyright = {All rights reserved},
  journal = {J. Chem. Phys.},
  number = {3}
}

branch_name: refs/heads/main

gha_language: Julia


text:
// Package models implements models.
package models

import (
	"fmt"
	"reflect"

	"gitlab.com/tirava/image-previewer/internal/domain/entities"
)

// implementer's constants.
const (
	LogStd        = "logstd"
	LogRus        = "logrus"
	XDraw         = "xdraw"
	NfntCrop      = "nfnt_crop"
	MD5           = "md5"
	SHA1          = "sha1"
	SHA256        = "sha256"
	LRU           = "lru"
	NoLimit       = "nolimit"
	Disk          = "disk"
	InMemory      = "inmemory"
	maxCacheItems = 128
)

// Configer is the main interface for configs.
type Configer interface {
	GetConfig() Config
	SetConfig(Config)
}

// Config is the base config struct.
type Config struct {
	Source           string                 `yaml:"-"`
	Logger           string                 `yaml:"logger"`
	LogFile          string                 `yaml:"log_file"`
	LogLevel         string                 `yaml:"log_level"`
	ListenHTTP       string                 `yaml:"http_listen"`
	ListenPrometheus string                 `yaml:"prometheus_listen"`
	ListenPprof      string                 `yaml:"pprof_listen"`
	Previewer        string                 `yaml:"previewer"`
	Interpolation    entities.Interpolation `yaml:"interpolation"`
	NoProxyHeaders   []string               `yaml:"no_proxy_headers"`
	ImageURLEncoder  string                 `yaml:"img_url_encoder"`
	Cacher           string                 `yaml:"cache"`
	MaxCacheItems    int                    `yaml:"max_cache_items"`
	Storager         string                 `yaml:"storage"`
	StoragePath      string                 `yaml:"storage_path"`
}

// ConfigDefaults is for default parameters.
type ConfigDefaults map[string]interface{}

// GetDefaults returns default config fields.
func (c Config) GetDefaults() ConfigDefaults {
	config := make(ConfigDefaults)
	config["Source"] = ""
	config["Logger"] = LogStd
	config["LogFile"] = "previewer.log"
	config["LogLevel"] = "info"
	config["ListenHTTP"] = ":8080"
	config["ListenPrometheus"] = ":9180"
	config["ListenPprof"] = ":8181"
	config["Previewer"] = XDraw
	config["ImageURLEncoder"] = MD5
	config["Cacher"] = LRU
	config["MaxCacheItems"] = int64(maxCacheItems)
	config["Storager"] = Disk
	config["StoragePath"] = "cache"

	return config
}

// FillConfig fills empty config's fields.
func (c Config) FillConfig(inConfig Config) (Config, error) {
	defConfig := c.GetDefaults()

	v := reflect.ValueOf(inConfig)
	vPtr := reflect.ValueOf(&inConfig)
	configType := v.Type()

	for i := 0; i < v.NumField(); i++ {
		value := v.Field(i).Interface()
		name := configType.Field(i).Name

		if value == "" || value == 0 {
			switch v := defConfig[name].(type) {
			case string:
				vPtr.Elem().FieldByName(name).SetString(defConfig[name].(string))
			case int64:
				vPtr.Elem().FieldByName(name).SetInt(defConfig[name].(int64))
			default:
				return inConfig, fmt.Errorf("unexpected type '%T' while parsing config parameter '%s'",
					v, name)
			}
		}
	}

	if inConfig.MaxCacheItems < 0 {
		inConfig.MaxCacheItems = maxCacheItems
	}

	return inConfig, nil
}

repository: tirava/GoOtus

repo_name: tirava/GoOtus


text:
@InProceedings{rolet16,
  supplementary = {Supplementary:rolet16-supp.pdf},
  title = {Fast Dictionary Learning with a Smoothed Wasserstein Loss},
  author = {Rolet, Antoine and Cuturi, Marco and Peyré, Gabriel},
  pages = {630-638},
  abstract = {We consider in this paper the dictionary learning problem when the observations are normalized histograms of features. This problem can be tackled using non-negative matrix factorization approaches, using typically Euclidean or Kullback-Leibler fitting errors. Because these fitting errors are separable and treat each feature on equal footing, they are blind to any similarity the features may share. We assume in this work that we have prior knowledge on these features. To leverage this side-information, we propose to use the Wasserstein (\textit{a.k.a.} earth mover's or optimal transport) distance as the fitting error between each original point and its reconstruction, and we propose scalable algorithms to to so. Our methods build upon Fenchel duality and entropic regularization of Wasserstein distances, which improves not only speed but also computational stability. We apply these techniques on face images and text documents. We show in particular that we can learn dictionaries (topics) for bag-of-word representations of texts using words that may not have appeared in the original texts, or even words that come from a different language than that used in the texts.},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX


text:
@article{Mueller2017a,
 abstract = {Background: Delays to diagnosis in lung cancer can lead to reduced chance of survival, and patients often wait for several months before presenting symptoms. The time between first symptom recognition until diagnosis has been theorized into three intervals: symptom appraisal, help-seeking, and diagnostic interval (here: "pathway to diagnosis"). Interventions are needed to reduce delays to diagnosis in lung cancer. The Web has become an important lay health information source and could potentially play a role in this pathway to diagnosis. Objective: Our overall aim was to gain a preliminary insight into whether Web-based information plays a role in the pathway to diagnosis in lung cancer in order to assess whether it may be possible to leverage this information source to reduce delays to diagnosis. Methods: Patients diagnosed with lung cancer in the 6 months before study entry completed a survey about whether (and how, if yes) they had used the Web to appraise their condition prior to diagnosis. Based on survey responses, we purposively sampled patients and their next-of-kin for semistructured interviews (24 interviews; 33 participants). Interview data were analyzed qualitatively using Framework Analysis in the context of the pathway to diagnosis model. Results: A total of 113 patients completed the survey (age: mean 67.0, SD 8.8 years). In all, 20.4% (23/113) reported they or next-of-kin had researched their condition online before the diagnosis. The majority of searches (20/23, 87.0%) were conducted by or with the help of next-of-kin. Interview results suggest that patients and next-of-kin perceived an impact of the information found online on all three intervals in the time to diagnosis. In the appraisal interval, participants used online information to evaluate symptoms and possible causes. In the help-seeking interval, the Web was used to inform the decision of whether to present to health services. In the diagnostic interval, it was used to evaluate health care professionals' advice, to support requests for further investigation of symptoms, and to understand medical jargon. Within this interval, we identified two distinct subintervals (before/after relevant diagnostic tests were initiated), in which the Web reportedly played different roles. Conclusions: Because only 20.4% of the sample reported prediagnosis Web searches, it seems the role of the Web before diagnosis of lung cancer is at present still limited, but this proportion is likely to increase in the future, when barriers such as unfamiliarity with technology and unwillingness to be informed about one's own health are likely to decrease. Participants' perceptions suggest that the Web can have an impact on all three intervals in the pathway to diagnosis. Thus, the Web may hold the potential to reduce delays in the diagnostic process, and this should be explored in future research and interventions. Our results also suggest a division of the diagnostic interval into two subintervals may be useful.},
 author = {Mueller, J. and Jay, C. and Harper, S. and Todd, C.},
 doi = {10.2196/jmir.6336},
 issn = {14388871},
 journal = {Journal of Medical Internet Research},
 keywords = {Health information seeking,Help seeking,Lung cancer,Online health information,Symptom appraisal},
 number = {6},
 title = {The role of web-based health information in help-seeking behavior prior to a diagnosis of lung cancer: A mixed-methods study},
 volume = {19},
 year = {2017}
}

repository: sharpic/academic-kickstart

repo_name: sharpic/academic-kickstart


text:
@article{Bolibar-2020-Deep,
    title = "Deep learning applied to glacier evolution modelling",
    author = "Bolibar, Jordi  and
      Rabatel, Antoine  and
      Gouttevin, Isabelle  and
      Galiez, Clovis  and
      Condom, Thomas  and
      Sauquet, Eric",
    journal = "The Cryosphere, Volume 14, Issue 2",
    volume = "14",
    number = "2",
    year = "2020",
    publisher = "Copernicus GmbH",
    url = "https://aclanthology.org/G20-101001",
    doi = "10.5194/tc-14-565-2020",
    pages = "565--584",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications

gha_language: Python


text:
@InProceedings{zhang15,
  title = {Random Decision Hashing for Massive Data Learning},
  author = {Zhang, Xiatian and Fan, Wei and Du, Nan},
  pages = {65-80},
  abstract = {In the era of Big Data, the iterative nature of most traditional learning algorithms renders them increasingly
    inefficient to address large learning problems. Random decision trees algorithm is an efficient and decent learning algorithm,
    but the complexity of tree structure makes the algorithm inefficient for the big data problems. Inspired by the theoretical
    analyses of random decision trees, we propose a randomized algorithm for big data classification tasks based on unsupervised
    locality sensitive hashing. Our algorithm is essentially non-iterative, very flexible to deploy over clusters of machines,
    and thus able to handle large datasets efficiently. Experiments on real datasets demonstrate that the proposed algorithm can
    easily scale up to millions of data samples and features while still achieves at most 17\% and 800\% improvement in accuracy
    and efficiency respectively with moderate memory consumption over existing algorithms.},
}


text:
include(${CMAKE_CURRENT_LIST_DIR}/config.cmake)

function(link_project PROJECT_DIR)

    include_directories(${PROJECT_DIR}/include)

    if (MSVC)
        if (MSVC12)
            link_directories("${PROJECT_DIR}/lib/vs2013/$(PlatformShortName)")
        elseif (MSVC11)
            link_directories("${PROJECT_DIR}/lib/vs2012/$(PlatformShortName)")
        elseif (MSVC10)
            link_directories("${PROJECT_DIR}/lib/vs2010/$(PlatformShortName)")
        else()
            message(FATAL_ERROR "Unsupported MSVC version")
        endif()
    else()
        link_directories(${PROJECT_DIR}/lib)
    endif()

endfunction()

repository: fuse-open/legacy-cpp-framework

repo_name: fuse-open/legacy-cpp-framework


text:
@article{liToxicantSubstitutesImmunological2021,
 abstract = {Recurring mycotoxins contamination has posedaseriousthreatto food safety worldwide. Competitive immunoassays are widely used techniques for high-throughput mycotoxins detection in agricultural products and foods. However, the inevitable introduction of mycotoxin conjugates produced by chemical conjugation usually results in complicated by-products, large batch errors and threats to operators and environment. Biologically derived surrogates of mycotoxin conjugates or mycotoxin standards are renewable immunoreagents. They can serve the same function as the responding counterparts in the immunoassays. The substitute-based immunoassays exhibit satisfactory sensitivity, pose less health threats to operators and environment, and contribute to the standardization of immunoassays for mycotoxins. This review focuses on the current applications of substitute-based immunoassays, clarifies their underlying mechanisms and provides a careful comparison. Challenges and future prospects are discussed.},
 author = {Li, Ping and Deng, Shengliang and Xu, Zhenjiang Zech},
 copyright = {All rights reserved},
 doi = {10.1016/j.foodchem.2020.128589},
 file = {/Users/zech/Zotero/storage/9SXYZ85Y/2021_Li_et_al_Toxicant_substitutes_in_immunological_assays_for_mycotoxins_detection.pdf},
 issn = {0308-8146},
 journal = {Food Chemistry},
 keywords = {Anti-idiotypic antibody,Immunoassay,Mimotope,Mycotoxin,Nanobody,Toxicant substitutes},
 langid = {english},
 month = {May},
 pages = {128589},
 shorttitle = {Toxicant Substitutes in Immunological Assays for Mycotoxins Detection},
 title = {Toxicant Substitutes in Immunological Assays for Mycotoxins Detection: A Mini Review},
 urldate = {2021-02-22},
 volume = {344},
 year = {2021}
}

repository: zxlab/lab-web

repo_name: zxlab/lab-web