text:
package framework

import (
	"strings"

	"github.com/google/uuid"
	"github.com/onsi/gomega"

	cdiv1 "kubevirt.io/containerized-data-importer-api/pkg/apis/core/v1beta1"
	"kubevirt.io/containerized-data-importer/pkg/common"
	"kubevirt.io/containerized-data-importer/tests/utils"
)

// CreateVddkWarmImportDataVolume fetches snapshot information from vcsim and returns a multi-stage VDDK data volume
func (f *Framework) CreateVddkWarmImportDataVolume(dataVolumeName, size, url string) *cdiv1.DataVolume {
	// Find vcenter-simulator pod
	pod, err := utils.FindPodByPrefix(f.K8sClient, f.CdiInstallNs, "vcenter-deployment", "app=vcenter")
	gomega.Expect(err).ToNot(gomega.HaveOccurred())
	gomega.Expect(pod).ToNot(gomega.BeNil())

	// Get test VM UUID
	id, err := f.RunKubectlCommand("exec", "-n", pod.Namespace, pod.Name, "--", "cat", "/tmp/vmid")
	gomega.Expect(err).ToNot(gomega.HaveOccurred())
	vmid, err := uuid.Parse(strings.TrimSpace(id))
	gomega.Expect(err).ToNot(gomega.HaveOccurred())

	// Get snapshot 1 ID
	previousCheckpoint, err := f.RunKubectlCommand("exec", "-n", pod.Namespace, pod.Name, "--", "cat", "/tmp/vmsnapshot1")
	gomega.Expect(err).ToNot(gomega.HaveOccurred())
	previousCheckpoint = strings.TrimSpace(previousCheckpoint)
	gomega.Expect(err).ToNot(gomega.HaveOccurred())

	// Get snapshot 2 ID
	currentCheckpoint, err := f.RunKubectlCommand("exec", "-n", pod.Namespace, pod.Name, "--", "cat", "/tmp/vmsnapshot2")
	gomega.Expect(err).ToNot(gomega.HaveOccurred())
	currentCheckpoint = strings.TrimSpace(currentCheckpoint)
	gomega.Expect(err).ToNot(gomega.HaveOccurred())

	// Get disk name
	disk, err := f.RunKubectlCommand("exec", "-n", pod.Namespace, pod.Name, "--", "cat", "/tmp/vmdisk")
	gomega.Expect(err).ToNot(gomega.HaveOccurred())
	disk = strings.TrimSpace(disk)
	gomega.Expect(err).ToNot(gomega.HaveOccurred())

	// Create VDDK login secret
	stringData := map[string]string{
		common.KeyAccess: "user",
		common.KeySecret: "pass",
	}
	backingFile := disk
	secretRef := "vddksecret"
	thumbprint := "testprint"
	finalCheckpoint := true
	s, _ := utils.CreateSecretFromDefinition(f.K8sClient, utils.NewSecretDefinition(nil, stringData, nil, f.Namespace.Name, secretRef))

	return utils.NewDataVolumeWithVddkWarmImport(dataVolumeName, size, backingFile, s.Name, thumbprint, url, vmid.String(), currentCheckpoint, previousCheckpoint, finalCheckpoint)
}

// CreateVddkWarmImportPopulatorSource fetches snapshot information from vcsim and returns a multi-stage VDDK volumeImportSource
func (f *Framework) CreateVddkWarmImportPopulatorSource(volumeImportName, pvcName, url string) *cdiv1.VolumeImportSource {
	// Find vcenter-simulator pod
	pod, err := utils.FindPodByPrefix(f.K8sClient, f.CdiInstallNs, "vcenter-deployment", "app=vcenter")
	gomega.Expect(err).ToNot(gomega.HaveOccurred())
	gomega.Expect(pod).ToNot(gomega.BeNil())

	// Get test VM UUID
	id, err := f.RunKubectlCommand("exec", "-n", pod.Namespace, pod.Name, "--", "cat", "/tmp/vmid")
	gomega.Expect(err).ToNot(gomega.HaveOccurred())
	vmid, err := uuid.Parse(strings.TrimSpace(id))
	gomega.Expect(err).ToNot(gomega.HaveOccurred())

	// Get snapshot 1 ID
	previousCheckpoint, err := f.RunKubectlCommand("exec", "-n", pod.Namespace, pod.Name, "--", "cat", "/tmp/vmsnapshot1")
	gomega.Expect(err).ToNot(gomega.HaveOccurred())
	previousCheckpoint = strings.TrimSpace(previousCheckpoint)
	gomega.Expect(err).ToNot(gomega.HaveOccurred())

	// Get snapshot 2 ID
	currentCheckpoint, err := f.RunKubectlCommand("exec", "-n", pod.Namespace, pod.Name, "--", "cat", "/tmp/vmsnapshot2")
	gomega.Expect(err).ToNot(gomega.HaveOccurred())
	currentCheckpoint = strings.TrimSpace(currentCheckpoint)
	gomega.Expect(err).ToNot(gomega.HaveOccurred())

	// Get disk name
	disk, err := f.RunKubectlCommand("exec", "-n", pod.Namespace, pod.Name, "--", "cat", "/tmp/vmdisk")
	gomega.Expect(err).ToNot(gomega.HaveOccurred())
	disk = strings.TrimSpace(disk)
	gomega.Expect(err).ToNot(gomega.HaveOccurred())

	// Create VDDK login secret
	stringData := map[string]string{
		common.KeyAccess: "user",
		common.KeySecret: "pass",
	}
	backingFile := disk
	secretRef := "vddksecret"
	thumbprint := "testprint"
	finalCheckpoint := true
	s, _ := utils.CreateSecretFromDefinition(f.K8sClient, utils.NewSecretDefinition(nil, stringData, nil, f.Namespace.Name, secretRef))

	return utils.NewVolumeImportSourceWithVddkWarmImport(volumeImportName, pvcName, backingFile, s.Name, thumbprint, url, vmid.String(), currentCheckpoint, previousCheckpoint, finalCheckpoint)
}

repository: kubevirt/containerized-data-importer

repo_name: kubevirt/containerized-data-importer


text:
@article{eichenseer2019jurassic,
  title={Jurassic shift from abiotic to biotic control on marine ecological success},
  author={Eichenseer, Kilian and Balthasar, Uwe and Smart, Christopher W and Stander, Julian and Haaga, Kristian A and Kiessling, Wolfgang},
  journal={Nature Geoscience},
  volume={12},
  pages={638-642},
  year={2019},
  publisher={Nature Publishing Group}
}

license: MIT

repository: earthsystemevolution/website

license_type: permissive

repo_name: earthsystemevolution/website

branch_name: refs/heads/master

gha_license_id: MIT

gha_language: Jupyter Notebook

extension: bib


text:
@article{opazo2019proposal,
  title={Proposal-free Temporal Moment Localization of a Natural-Language Query in Video using Guided Attention},
  author={Opazo, Cristian Rodriguez and Marrese-Taylor, Edison and Saleh, Fatemeh Sadat and Li, Hongdong and Gould, Stephen},
  journal={arXiv preprint arXiv:1908.07236},
  year={2019}
}

url: https://raw.githubusercontent.com/guojson/DL-NLP-Readings/e09b39b048ac027a53a7885389eb89c28ae03b1e/Bibtex/Proposal-free Temporal Moment Localization of a Natural-Language Query in Video using Guided Attention.bib

repository: guojson/DL-NLP-Readings

repo_name: guojson/DL-NLP-Readings


text:
@inproceedings{inproceedings,
author = {Mueller, Thomas and Schuetze, Hinrich},
year = {2011},
month = {01},
pages = {524-528},
title = {Improved Modeling of Out-Of-Vocabulary Words Using Morphological Classes.},
volume = {2}
}

@article{DBLP:journals/corr/SakSB14,
  author    = {Hasim Sak and
               Andrew W. Senior and
               Fran{\c{c}}oise Beaufays},
  title     = {Long Short-Term Memory Based Recurrent Neural Network Architectures
               for Large Vocabulary Speech Recognition},
  journal   = {CoRR},
  volume    = {abs/1402.1128},
  year      = {2014},
  url       = {http://arxiv.org/abs/1402.1128},
  archivePrefix = {arXiv},
  eprint    = {1402.1128},
  timestamp = {Mon, 13 Aug 2018 16:47:37 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/SakSB14},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@proceedings{acl-2016-association,
    title = "Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)",
    author = "Erk, Katrin  and
      Smith, Noah A.",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/P16-1000",
    doi = "10.18653/v1/P16-1",
}

@inproceedings{lu-etal-2016-multi,
    title = "A Multi-media Approach to Cross-lingual Entity Knowledge Transfer",
    author = "Lu, Di  and
      Pan, Xiaoman  and
      Pourdamghani, Nima  and
      Chang, Shih-Fu  and
      Ji, Heng  and
      Knight, Kevin",
    booktitle = "Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/P16-1006",
    doi = "10.18653/v1/P16-1006",
    pages = "54--65",
}

repository: Olamyy/acleanbib

repo_name: Olamyy/acleanbib


text:
package math32

// Tolerance approximates equality between a and b within (absolute) epsilon.
func Tolerance(a, b, epsilon float32) bool {
	d := a - b
	if d < 0 {
		d = -d
	}

	if b != 0 {
		epsilon *= b
		if epsilon < 0 {
			epsilon = -epsilon
		}
	}

	return d < epsilon
}

// Close approximates equality between a and b with 1e-6 precision.
func Close(a, b float32) bool {
	return Tolerance(a, b, 1e-6)
}

repository: noddl-me/go-raytracing-tutorials

repo_name: noddl-me/go-raytracing-tutorials

extension: go


text:
SUMMARY = "RTL8192AU kernel driver (wifi)"
DESCRIPTION = "RTL8192AU kernel driver"
LICENSE = "GPL-2.0-only"
LIC_FILES_CHKSUM ?= "file://${COMMON_LICENSE_DIR}/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"

SRC_URI = "git://github.com/Mange/rtl8192eu-linux-driver.git;protocol=https;branch=realtek-4.4.x"
SRCREV = "528ae31705764d78cc117abd604d9b799bd52543"

S = "${WORKDIR}/git"

PV = "4.4.1-git"

DEPENDS = "virtual/kernel"

inherit module

EXTRA_OEMAKE  = "ARCH=${ARCH}"
EXTRA_OEMAKE += "KSRC=${STAGING_KERNEL_BUILDDIR}"

do_compile () {
    unset LDFLAGS
    oe_runmake
}

do_install () {
    install -d ${D}${nonarch_base_libdir}/modules/${KERNEL_VERSION}
    install -m 0755 ${B}/8192eu.ko ${D}${nonarch_base_libdir}/modules/${KERNEL_VERSION}/8192eu.ko
}

repository: EmbeddedAndroid/meta-rtlwifi

repo_name: EmbeddedAndroid/meta-rtlwifi

gha_language: BitBake

extension: bb


text:
package utils

import (
	"testing"

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

const (
	provisionOrgMsg = "disk size is not supported."
	attachOrgMsg1   = "aaa had volume node affinity conflict"
	attachOrgMsg2   = "xxxxxxxxxxx"
	attachOrgMsg3   = "instance does not support this disk category."
)

func TestFindSuggestionByErrorMessage(t *testing.T) {
	errMsgProvisionSample := map[string]string{
		provisionOrgMsg: provisionOrgMsg + "\n" + "faq：https://help.aliyun.com/document_detail/286495.htm?spm=a2c4g.11186623.0.0.77bc690cSyWVYM#section-r6k-e7i-l78",
	}

	errMsgAttachSample := map[string]string{
		attachOrgMsg1: attachOrgMsg1 + "\n" + "faq: https://help.aliyun.com/document_detail/286495.htm?spm=a2c4g.11186623.0.0.77bc690cSyWVYM#section-7o2-zf7-eff",
		attachOrgMsg2: attachOrgMsg2,
		attachOrgMsg3: attachOrgMsg3 + "\n" + "faq: https://help.aliyun.com/document_detail/286495.htm?spm=a2c4g.11186623.0.0.77bc690cSyWVYM#section-ihn-gds-9mm",
	}

	for origMsg, wrapperedMsg := range errMsgProvisionSample {
		assert.Equal(t, wrapperedMsg, FindSuggestionByErrorMessage(origMsg, DiskProvision))
	}

	for origMsg, wrapperedMsg := range errMsgAttachSample {
		assert.Equal(t, wrapperedMsg, FindSuggestionByErrorMessage(origMsg, DiskAttachDetach))
	}
}

gha_language: Go


text:
package types

type Metadata struct {
	Type        string
	Title       string `gorm:"type:text" binding:"required"`
	Language    string
	Category    string
	Created     float32
	Abstract    string `gorm:"type:text"`
	ContentHash string `gorm:"size:255"`
	DNA         string `gorm:"size:255;unique_index"`
	License     string `gorm:"type:text" binding:"required"`
	Signature   string `sql:"-" binding:"required"`
	Extra       string `gorm:"type:text" binding:"required"`
	BlockHash   string `gorm:"size:255"`
}


text:
SUMMARY = "IoT Reference OS Kit Bluetooth Audio"
LICENSE = "MIT"

inherit packagegroup

RDEPENDS_${PN} = " \
    pulseaudio \
    pulseaudio-server \
    pulseaudio-misc \
    pulseaudio-module-loopback \
    pulseaudio-module-bluetooth-discover \
    pulseaudio-module-bluetooth-policy \
    pulseaudio-module-bluez5-device \
    pulseaudio-module-bluez5-discover \
    sbc \
"

repository: intel/intel-iot-refkit

repo_name: intel/intel-iot-refkit

gha_language: Python


text:
DESCRIPTION = "A full featured personal video recorder system."
HOMEPAGE = "http://www.mythtv.org"
LICENSE = "GPL"
MAINTAINER = "Michael 'Mickey' Lauer <mickey@Vanille.de>"
SECTION = "x11/multimedia"
PR = "r1"

SRC_URI = "http://www.mythtv.org/mc/mythtv-${PV}.tar.bz2 \
	file://msmpeg-underscore-pic.patch;patch=1 \
	file://settings.pro"

DEPENDS = "xinerama lame libxv libxxf86vm libxvmc lirc"
RDEPENDS = "qt-x11-plugins"

inherit qmake qt3x11

# there is a -march=586 somewhere in the source tree
COMPATIBLE_HOST = 'i.86.*-linux'

QMAKE_PROFILES = "mythtv.pro"

def mythtv_arch(d):
        import bb, re
        arch = bb.data.getVar('TARGET_ARCH', d, 1)
        if re.match("^i.86$", arch):
                arch = "x86"
        elif arch == "x86_64":
                arch = "x86"
        elif arch == "arm":
                arch = "armv4l"
        return arch

MYTHTV_ARCH := "${@mythtv_arch(d)}"

do_configure_prepend() {
# it's not autotools anyway, so we call ./configure directly
	find . -name "Makefile"|xargs rm -f
	./configure	--prefix=/usr		\
			--mandir=/usr/man 	\
			--disable-mp3lame	\
			--enable-vorbis 	\
			--disable-faad		\
			--disable-faadbin 	\
			--disable-faac		\
			--disable-mingw32	\
			--enable-a52		\
			--disable-a52bin	\
			--enable-pp		\
			--enable-shared-pp	\
			--enable-shared		\
			--disable-amr_nb	\
			--disable-amr_nb-fixed	\
			--disable-sunmlib	\
						\
			--cpu=${MYTHTV_ARCH}	\
			--enable-mmx		\
			--disable-altivec	\
			--enable-v4l		\
			--enable-audio-oss	\
			--disable-audio-beos	\
			--enable-dv1394		\
			--enable-network	\
			--enable-zlib		\
			--enable-simple_idct	\
			--disable-vhook		\
			--disable-mpegaudio-hp	\
			--enable-ffserver	\
			--enable-ffplay		\
			--enable-risky

	install -m 0644 ${WORKDIR}/settings.pro ${S}/
	sed 's!PREFIX =.*!PREFIX = ${prefix}!' < settings.pro > settings.pro.new
	mv settings.pro.new settings.pro
}

do_install() {
	oe_runmake INSTALL_ROOT=${D} install
}

repository: Terentyev/familiar-linux

repo_name: Terentyev/familiar-linux


text:
@proceedings{ws-2018-joint,
    title = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    editor = "Alex, Beatrice  and
      Degaetano-Ortlieb, Stefania  and
      Feldman, Anna  and
      Kazantseva, Anna  and
      Reiter, Nils  and
      Szpakowicz, Stan",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4500",
}
@inproceedings{orlikowski-etal-2018-learning,
    title = "Learning Diachronic Analogies to Analyze Concept Change",
    author = "Orlikowski, Matthias  and
      Hartung, Matthias  and
      Cimiano, Philipp",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4501",
    pages = "1--11",
}
@inproceedings{feder-etal-2018-linked,
    title = "A Linked {C}optic Dictionary Online",
    author = "Feder, Frank  and
      Kupreyev, Maxim  and
      Manning, Emma  and
      Schroeder, Caroline T.  and
      Zeldes, Amir",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4502",
    pages = "12--21",
}
@inproceedings{degaetano-ortlieb-teich-2018-using,
    title = "Using relative entropy for detection and analysis of periods of diachronic linguistic change",
    author = "Degaetano-Ortlieb, Stefania  and
      Teich, Elke",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4503",
    pages = "22--33",
}
@inproceedings{van-cranenburgh-2018-cliche,
    title = "Cliche Expressions in Literary and Genre Novels",
    author = "van Cranenburgh, Andreas",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4504",
    pages = "34--43",
}
@inproceedings{baumann-etal-2018-analysis,
    title = "Analysis of Rhythmic Phrasing: Feature Engineering vs. Representation Learning for Classifying Readout Poetry",
    author = "Baumann, Timo  and
      Hussein, Hussein  and
      Meyer-Sickendiek, Burkhard",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4505",
    pages = "44--49",
}
@inproceedings{arnold-tilton-2018-cross,
    title = "Cross-Discourse and Multilingual Exploration of Textual Corpora with the {D}ual{N}eighbors Algorithm",
    author = "Arnold, Taylor  and
      Tilton, Lauren",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4506",
    pages = "50--59",
}
@inproceedings{underwood-2018-historical,
    title = "The Historical Significance of Textual Distances",
    author = "Underwood, Ted",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4507",
    pages = "60--69",
}
@inproceedings{do-dinh-etal-2018-one,
    title = "One Size Fits All? A simple {LSTM} for non-literal token and construction-level classification",
    author = "Do Dinh, Erik-L{\^a}n  and
      Eger, Steffen  and
      Gurevych, Iryna",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4508",
    pages = "70--80",
}
@inproceedings{haider-kuhn-2018-supervised,
    title = "Supervised Rhyme Detection with {S}iamese Recurrent Networks",
    author = "Haider, Thomas  and
      Kuhn, Jonas",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4509",
    pages = "81--86",
}
@inproceedings{hamalainen-etal-2018-normalizing,
    title = "Normalizing Early {E}nglish Letters to Present-day {E}nglish Spelling",
    author = {H{\"a}m{\"a}l{\"a}inen, Mika  and
      S{\"a}ily, Tanja  and
      Rueter, Jack  and
      Tiedemann, J{\"o}rg  and
      M{\"a}kel{\"a}, Eetu},
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4510",
    pages = "87--96",
}
@inproceedings{lam-etal-2018-power,
    title = "Power Networks: A Novel Neural Architecture to Predict Power Relations",
    author = "Lam, Michelle  and
      Xu, Catherina  and
      Prabhakaran, Vinodkumar",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4511",
    pages = "97--102",
}
@inproceedings{makarov-2018-automated,
    title = "Automated Acquisition of Patterns for Coding Political Event Data: Two Case Studies",
    author = "Makarov, Peter",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4512",
    pages = "103--112",
}
@inproceedings{moritz-etal-2018-method,
    title = "A Method for Human-Interpretable Paraphrasticality Prediction",
    author = {Moritz, Maria  and
      Hellrich, Johannes  and
      B{\"u}chel, Sven},
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4513",
    pages = "113--118",
}
@inproceedings{pilan-volodina-2018-exploring,
    title = "Exploring word embeddings and phonological similarity for the unsupervised correction of language learner errors",
    author = "Pil{\'a}n, Ildik{\'o}  and
      Volodina, Elena",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4514",
    pages = "119--128",
}
@inproceedings{roesiger-etal-2018-towards,
    title = "Towards Coreference for Literary Text: Analyzing Domain-Specific Phenomena",
    author = "Roesiger, Ina  and
      Schulz, Sarah  and
      Reiter, Nils",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4515",
    pages = "129--138",
}
@inproceedings{schmidt-burghardt-2018-evaluation,
    title = "An Evaluation of Lexicon-based Sentiment Analysis Techniques for the Plays of {G}otthold {E}phraim {L}essing",
    author = "Schmidt, Thomas  and
      Burghardt, Manuel",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4516",
    pages = "139--149",
}
@inproceedings{touileb-etal-2018-automatic,
    title = "Automatic identification of unknown names with specific roles",
    author = "Touileb, Samia  and
      Pedersen, Truls  and
      Sj{\o}vaag, Helle",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4517",
    pages = "150--158",
}
@inproceedings{opitz-etal-2018-induction,
    title = "Induction of a Large-Scale Knowledge Graph from the {R}egesta {I}mperii",
    author = "Opitz, Juri  and
      Born, Leo  and
      Nastase, Vivi",
    booktitle = "Proceedings of the Second Joint {SIGHUM} Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-4518",
    pages = "159--168",
}

repository: emorynlp/nlprankings

repo_name: emorynlp/nlprankings

gha_license_id: NOASSERTION

gha_language: TeX


text:
@conference{signaltrain,
  title = {Profiling Audio Compressors with Deep Neural Networks},
  author = {Hawley, Scott H. and Colburn, Benjamin and Mimilakis, Stylianos Ioannis},
  booktitle = {Audio Engineering Society Convention 147},
  month = {Oct},
  year = {2019},
  url = {http://www.aes.org/e-lib/browse.cfm?elib=20595}
}

@article{billy_signaltrain2,
  title={Exploring Quality and Generalizability in Parameterized Neural Audio Effects},
  author={William Mitchell and Scott H. Hawley},
  journal={ArXiv},
  year={2020},
  volume={abs/2006.05584},
  url = {https://arxiv.org/abs/2006.05584}
}

repository: augustobarreto/my-blog

repo_name: augustobarreto/my-blog


text:
SUMMARY = "GLib implementation of PEP 3156"
HOMEPAGE = "http://github.com/beeware/gbulb"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=edfe3d91d4b439ac8a8c23cebbf00501"

SRC_URI[sha256sum] = "da003c5b17d3a2ba15c7255bb174defaa0f6b77e8b23f229685eb2714ceaeeec"

PYPI_PACKAGE = "gbulb"

# python3-misc is needed for the signal module
RDEPENDS:${PN} = "python3-pygobject python3-asyncio python3-misc"

inherit pypi setuptools3

repository: rauc/meta-rauc

repo_name: rauc/meta-rauc


text:
@PACKAGE_INIT@

include("${CMAKE_CURRENT_LIST_DIR}/hdf5_exceptionsTargets.cmake")

include(CMakeFindDependencyMacro)

# CMake includes a script FindHDF5, while builds of HDF5 with CMake export
# a package called hdf5. We search for both.
find_package(HDF5 COMPONENTS Fortran QUIET)
find_package(hdf5 COMPONENTS Fortran QUIET)

if(HDF5_FOUND AND NOT TARGET hdf5::hdf5_fortran)
  # Older versions of FindHDF5 (before CMake 3.19) don't export any targets.
  # This package creates imported targets using the result variables populated
  # by FindHDF5.
  include("${CMAKE_CURRENT_LIST_DIR}/HDF5Targets.cmake")
endif()

if(NOT HDF5_FOUND AND NOT hdf5_FOUND
    AND NOT TARGET hdf5::hdf5_fortran
    AND NOT TARGET hdf5_fortran-static
    AND NOT TARGET hdf5_fortran-shared)
  message(FATAL_ERROR "No HDF5 package found")
endif()

if(NOT fortran_exceptions_FOUND AND NOT TARGET fortran_exceptions)
  find_dependency(fortran_exceptions REQUIRED)
endif()

check_required_components(hdf5_exceptions)

set(hdf5_exceptions_DOCDIR @CMAKE_INSTALL_PREFIX@/share/doc/hdf5_exceptions)

branch_name: refs/heads/main

extension: in


text:
@techreport{auclert2019using,
 author = {Auclert, Adrien and Bardóczy, Bence and Rognlie, Matthew and Straub, Ludwig},
 title = {Using the Sequence-Space Jacobian to Solve and Estimate Heterogeneous-Agent Models},
 type = {NBER Working Paper 26123},
 year = {2019}
}


text:
/*
Copyright 2020 The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package v1alpha4

import (
	apiconversion "k8s.io/apimachinery/pkg/conversion"
	"sigs.k8s.io/controller-runtime/pkg/conversion"

	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
	utilconversion "sigs.k8s.io/cluster-api/util/conversion"
)

func (src *Cluster) ConvertTo(dstRaw conversion.Hub) error {
	dst := dstRaw.(*clusterv1.Cluster)

	if err := Convert_v1alpha4_Cluster_To_v1beta1_Cluster(src, dst, nil); err != nil {
		return err
	}

	// Manually restore data.
	restored := &clusterv1.Cluster{}
	if ok, err := utilconversion.UnmarshalData(src, restored); err != nil || !ok {
		return err
	}

	if restored.Spec.Topology != nil {
		if dst.Spec.Topology == nil {
			dst.Spec.Topology = &clusterv1.Topology{}
		}
		dst.Spec.Topology.Variables = restored.Spec.Topology.Variables

		if restored.Spec.Topology.ControlPlane.MachineHealthCheck != nil {
			dst.Spec.Topology.ControlPlane.MachineHealthCheck = restored.Spec.Topology.ControlPlane.MachineHealthCheck
		}

		if restored.Spec.Topology.ControlPlane.NodeDrainTimeout != nil {
			dst.Spec.Topology.ControlPlane.NodeDrainTimeout = restored.Spec.Topology.ControlPlane.NodeDrainTimeout
		}

		if restored.Spec.Topology.ControlPlane.NodeVolumeDetachTimeout != nil {
			dst.Spec.Topology.ControlPlane.NodeVolumeDetachTimeout = restored.Spec.Topology.ControlPlane.NodeVolumeDetachTimeout
		}

		if restored.Spec.Topology.ControlPlane.NodeDeletionTimeout != nil {
			dst.Spec.Topology.ControlPlane.NodeDeletionTimeout = restored.Spec.Topology.ControlPlane.NodeDeletionTimeout
		}

		if restored.Spec.Topology.Workers != nil {
			if dst.Spec.Topology.Workers == nil {
				dst.Spec.Topology.Workers = &clusterv1.WorkersTopology{}
			}
			for i := range restored.Spec.Topology.Workers.MachineDeployments {
				dst.Spec.Topology.Workers.MachineDeployments[i].FailureDomain = restored.Spec.Topology.Workers.MachineDeployments[i].FailureDomain
				dst.Spec.Topology.Workers.MachineDeployments[i].Variables = restored.Spec.Topology.Workers.MachineDeployments[i].Variables
				dst.Spec.Topology.Workers.MachineDeployments[i].NodeDrainTimeout = restored.Spec.Topology.Workers.MachineDeployments[i].NodeDrainTimeout
				dst.Spec.Topology.Workers.MachineDeployments[i].NodeVolumeDetachTimeout = restored.Spec.Topology.Workers.MachineDeployments[i].NodeVolumeDetachTimeout
				dst.Spec.Topology.Workers.MachineDeployments[i].NodeDeletionTimeout = restored.Spec.Topology.Workers.MachineDeployments[i].NodeDeletionTimeout
				dst.Spec.Topology.Workers.MachineDeployments[i].MinReadySeconds = restored.Spec.Topology.Workers.MachineDeployments[i].MinReadySeconds
				dst.Spec.Topology.Workers.MachineDeployments[i].Strategy = restored.Spec.Topology.Workers.MachineDeployments[i].Strategy
				dst.Spec.Topology.Workers.MachineDeployments[i].MachineHealthCheck = restored.Spec.Topology.Workers.MachineDeployments[i].MachineHealthCheck
			}

			dst.Spec.Topology.Workers.MachinePools = restored.Spec.Topology.Workers.MachinePools
		}
	}

	return nil
}

func (dst *Cluster) ConvertFrom(srcRaw conversion.Hub) error {
	src := srcRaw.(*clusterv1.Cluster)

	if err := Convert_v1beta1_Cluster_To_v1alpha4_Cluster(src, dst, nil); err != nil {
		return err
	}

	// Preserve Hub data on down-conversion except for metadata
	if err := utilconversion.MarshalData(src, dst); err != nil {
		return err
	}

	return nil
}

func (src *ClusterList) ConvertTo(dstRaw conversion.Hub) error {
	dst := dstRaw.(*clusterv1.ClusterList)

	return Convert_v1alpha4_ClusterList_To_v1beta1_ClusterList(src, dst, nil)
}

func (dst *ClusterList) ConvertFrom(srcRaw conversion.Hub) error {
	src := srcRaw.(*clusterv1.ClusterList)

	return Convert_v1beta1_ClusterList_To_v1alpha4_ClusterList(src, dst, nil)
}

func (src *ClusterClass) ConvertTo(dstRaw conversion.Hub) error {
	dst := dstRaw.(*clusterv1.ClusterClass)

	if err := Convert_v1alpha4_ClusterClass_To_v1beta1_ClusterClass(src, dst, nil); err != nil {
		return err
	}

	// Manually restore data.
	restored := &clusterv1.ClusterClass{}
	if ok, err := utilconversion.UnmarshalData(src, restored); err != nil || !ok {
		return err
	}

	dst.Spec.Patches = restored.Spec.Patches
	dst.Spec.Variables = restored.Spec.Variables
	dst.Spec.ControlPlane.MachineHealthCheck = restored.Spec.ControlPlane.MachineHealthCheck
	dst.Spec.ControlPlane.NodeDrainTimeout = restored.Spec.ControlPlane.NodeDrainTimeout
	dst.Spec.ControlPlane.NodeVolumeDetachTimeout = restored.Spec.ControlPlane.NodeVolumeDetachTimeout
	dst.Spec.ControlPlane.NodeDeletionTimeout = restored.Spec.ControlPlane.NodeDeletionTimeout
	dst.Spec.Workers.MachinePools = restored.Spec.Workers.MachinePools

	for i := range restored.Spec.Workers.MachineDeployments {
		dst.Spec.Workers.MachineDeployments[i].MachineHealthCheck = restored.Spec.Workers.MachineDeployments[i].MachineHealthCheck
		dst.Spec.Workers.MachineDeployments[i].FailureDomain = restored.Spec.Workers.MachineDeployments[i].FailureDomain
		dst.Spec.Workers.MachineDeployments[i].NodeDrainTimeout = restored.Spec.Workers.MachineDeployments[i].NodeDrainTimeout
		dst.Spec.Workers.MachineDeployments[i].NodeVolumeDetachTimeout = restored.Spec.Workers.MachineDeployments[i].NodeVolumeDetachTimeout
		dst.Spec.Workers.MachineDeployments[i].NodeDeletionTimeout = restored.Spec.Workers.MachineDeployments[i].NodeDeletionTimeout
		dst.Spec.Workers.MachineDeployments[i].MinReadySeconds = restored.Spec.Workers.MachineDeployments[i].MinReadySeconds
		dst.Spec.Workers.MachineDeployments[i].Strategy = restored.Spec.Workers.MachineDeployments[i].Strategy
	}

	dst.Status = restored.Status

	return nil
}

func (dst *ClusterClass) ConvertFrom(srcRaw conversion.Hub) error {
	src := srcRaw.(*clusterv1.ClusterClass)

	if err := Convert_v1beta1_ClusterClass_To_v1alpha4_ClusterClass(src, dst, nil); err != nil {
		return err
	}

	// Preserve Hub data on down-conversion except for metadata
	if err := utilconversion.MarshalData(src, dst); err != nil {
		return err
	}

	return nil
}

func (src *ClusterClassList) ConvertTo(dstRaw conversion.Hub) error {
	dst := dstRaw.(*clusterv1.ClusterClassList)

	return Convert_v1alpha4_ClusterClassList_To_v1beta1_ClusterClassList(src, dst, nil)
}

func (dst *ClusterClassList) ConvertFrom(srcRaw conversion.Hub) error {
	src := srcRaw.(*clusterv1.ClusterClassList)

	return Convert_v1beta1_ClusterClassList_To_v1alpha4_ClusterClassList(src, dst, nil)
}

func (src *Machine) ConvertTo(dstRaw conversion.Hub) error {
	dst := dstRaw.(*clusterv1.Machine)

	if err := Convert_v1alpha4_Machine_To_v1beta1_Machine(src, dst, nil); err != nil {
		return err
	}

	// Manually restore data.
	restored := &clusterv1.Machine{}
	if ok, err := utilconversion.UnmarshalData(src, restored); err != nil || !ok {
		return err
	}

	dst.Spec.NodeDeletionTimeout = restored.Spec.NodeDeletionTimeout
	dst.Status.CertificatesExpiryDate = restored.Status.CertificatesExpiryDate
	dst.Spec.NodeVolumeDetachTimeout = restored.Spec.NodeVolumeDetachTimeout
	return nil
}

func (dst *Machine) ConvertFrom(srcRaw conversion.Hub) error {
	src := srcRaw.(*clusterv1.Machine)

	if err := Convert_v1beta1_Machine_To_v1alpha4_Machine(src, dst, nil); err != nil {
		return err
	}

	// Preserve Hub data on down-conversion except for metadata
	if err := utilconversion.MarshalData(src, dst); err != nil {
		return err
	}

	return nil
}

func (src *MachineList) ConvertTo(dstRaw conversion.Hub) error {
	dst := dstRaw.(*clusterv1.MachineList)

	return Convert_v1alpha4_MachineList_To_v1beta1_MachineList(src, dst, nil)
}

func (dst *MachineList) ConvertFrom(srcRaw conversion.Hub) error {
	src := srcRaw.(*clusterv1.MachineList)

	return Convert_v1beta1_MachineList_To_v1alpha4_MachineList(src, dst, nil)
}

func (src *MachineSet) ConvertTo(dstRaw conversion.Hub) error {
	dst := dstRaw.(*clusterv1.MachineSet)

	if err := Convert_v1alpha4_MachineSet_To_v1beta1_MachineSet(src, dst, nil); err != nil {
		return err
	}

	// Manually restore data.
	restored := &clusterv1.MachineSet{}
	if ok, err := utilconversion.UnmarshalData(src, restored); err != nil || !ok {
		return err
	}

	dst.Spec.Template.Spec.NodeDeletionTimeout = restored.Spec.Template.Spec.NodeDeletionTimeout
	dst.Spec.Template.Spec.NodeVolumeDetachTimeout = restored.Spec.Template.Spec.NodeVolumeDetachTimeout
	return nil
}

func (dst *MachineSet) ConvertFrom(srcRaw conversion.Hub) error {
	src := srcRaw.(*clusterv1.MachineSet)

	if err := Convert_v1beta1_MachineSet_To_v1alpha4_MachineSet(src, dst, nil); err != nil {
		return err
	}

	// Preserve Hub data on down-conversion except for metadata
	return utilconversion.MarshalData(src, dst)
}

func (src *MachineSetList) ConvertTo(dstRaw conversion.Hub) error {
	dst := dstRaw.(*clusterv1.MachineSetList)

	return Convert_v1alpha4_MachineSetList_To_v1beta1_MachineSetList(src, dst, nil)
}

func (dst *MachineSetList) ConvertFrom(srcRaw conversion.Hub) error {
	src := srcRaw.(*clusterv1.MachineSetList)

	return Convert_v1beta1_MachineSetList_To_v1alpha4_MachineSetList(src, dst, nil)
}

func (src *MachineDeployment) ConvertTo(dstRaw conversion.Hub) error {
	dst := dstRaw.(*clusterv1.MachineDeployment)

	if err := Convert_v1alpha4_MachineDeployment_To_v1beta1_MachineDeployment(src, dst, nil); err != nil {
		return err
	}

	// Manually restore data.
	restored := &clusterv1.MachineDeployment{}
	if ok, err := utilconversion.UnmarshalData(src, restored); err != nil || !ok {
		return err
	}

	dst.Spec.Template.Spec.NodeDeletionTimeout = restored.Spec.Template.Spec.NodeDeletionTimeout
	dst.Spec.Template.Spec.NodeVolumeDetachTimeout = restored.Spec.Template.Spec.NodeVolumeDetachTimeout
	dst.Spec.RolloutAfter = restored.Spec.RolloutAfter
	return nil
}

func (dst *MachineDeployment) ConvertFrom(srcRaw conversion.Hub) error {
	src := srcRaw.(*clusterv1.MachineDeployment)

	if err := Convert_v1beta1_MachineDeployment_To_v1alpha4_MachineDeployment(src, dst, nil); err != nil {
		return err
	}

	// Preserve Hub data on down-conversion except for metadata
	return utilconversion.MarshalData(src, dst)
}

func (src *MachineDeploymentList) ConvertTo(dstRaw conversion.Hub) error {
	dst := dstRaw.(*clusterv1.MachineDeploymentList)

	return Convert_v1alpha4_MachineDeploymentList_To_v1beta1_MachineDeploymentList(src, dst, nil)
}

func (dst *MachineDeploymentList) ConvertFrom(srcRaw conversion.Hub) error {
	src := srcRaw.(*clusterv1.MachineDeploymentList)

	return Convert_v1beta1_MachineDeploymentList_To_v1alpha4_MachineDeploymentList(src, dst, nil)
}

func (src *MachineHealthCheck) ConvertTo(dstRaw conversion.Hub) error {
	dst := dstRaw.(*clusterv1.MachineHealthCheck)

	return Convert_v1alpha4_MachineHealthCheck_To_v1beta1_MachineHealthCheck(src, dst, nil)
}

func (dst *MachineHealthCheck) ConvertFrom(srcRaw conversion.Hub) error {
	src := srcRaw.(*clusterv1.MachineHealthCheck)

	return Convert_v1beta1_MachineHealthCheck_To_v1alpha4_MachineHealthCheck(src, dst, nil)
}

func (src *MachineHealthCheckList) ConvertTo(dstRaw conversion.Hub) error {
	dst := dstRaw.(*clusterv1.MachineHealthCheckList)

	return Convert_v1alpha4_MachineHealthCheckList_To_v1beta1_MachineHealthCheckList(src, dst, nil)
}

func (dst *MachineHealthCheckList) ConvertFrom(srcRaw conversion.Hub) error {
	src := srcRaw.(*clusterv1.MachineHealthCheckList)

	return Convert_v1beta1_MachineHealthCheckList_To_v1alpha4_MachineHealthCheckList(src, dst, nil)
}

func Convert_v1alpha4_MachineStatus_To_v1beta1_MachineStatus(in *MachineStatus, out *clusterv1.MachineStatus, s apiconversion.Scope) error {
	// Status.version has been removed in v1beta1, thus requiring custom conversion function. the information will be dropped.
	return autoConvert_v1alpha4_MachineStatus_To_v1beta1_MachineStatus(in, out, s)
}

func Convert_v1beta1_ClusterClassSpec_To_v1alpha4_ClusterClassSpec(in *clusterv1.ClusterClassSpec, out *ClusterClassSpec, s apiconversion.Scope) error {
	// spec.{variables,patches} has been added with v1beta1.
	return autoConvert_v1beta1_ClusterClassSpec_To_v1alpha4_ClusterClassSpec(in, out, s)
}

func Convert_v1beta1_MachineSpec_To_v1alpha4_MachineSpec(in *clusterv1.MachineSpec, out *MachineSpec, s apiconversion.Scope) error {
	// spec.nodeDeletionTimeout has been added with v1beta1.
	return autoConvert_v1beta1_MachineSpec_To_v1alpha4_MachineSpec(in, out, s)
}

func Convert_v1beta1_MachineDeploymentSpec_To_v1alpha4_MachineDeploymentSpec(in *clusterv1.MachineDeploymentSpec, out *MachineDeploymentSpec, s apiconversion.Scope) error {
	return autoConvert_v1beta1_MachineDeploymentSpec_To_v1alpha4_MachineDeploymentSpec(in, out, s)
}

func Convert_v1beta1_Topology_To_v1alpha4_Topology(in *clusterv1.Topology, out *Topology, s apiconversion.Scope) error {
	// spec.topology.variables has been added with v1beta1.
	return autoConvert_v1beta1_Topology_To_v1alpha4_Topology(in, out, s)
}

// Convert_v1beta1_MachineDeploymentTopology_To_v1alpha4_MachineDeploymentTopology is an autogenerated conversion function.
func Convert_v1beta1_MachineDeploymentTopology_To_v1alpha4_MachineDeploymentTopology(in *clusterv1.MachineDeploymentTopology, out *MachineDeploymentTopology, s apiconversion.Scope) error {
	// MachineDeploymentTopology.FailureDomain has been added with v1beta1.
	return autoConvert_v1beta1_MachineDeploymentTopology_To_v1alpha4_MachineDeploymentTopology(in, out, s)
}

func Convert_v1beta1_MachineDeploymentClass_To_v1alpha4_MachineDeploymentClass(in *clusterv1.MachineDeploymentClass, out *MachineDeploymentClass, s apiconversion.Scope) error {
	// machineDeploymentClass.machineHealthCheck has been added with v1beta1.
	return autoConvert_v1beta1_MachineDeploymentClass_To_v1alpha4_MachineDeploymentClass(in, out, s)
}

func Convert_v1beta1_ControlPlaneClass_To_v1alpha4_ControlPlaneClass(in *clusterv1.ControlPlaneClass, out *ControlPlaneClass, s apiconversion.Scope) error {
	// controlPlaneClass.machineHealthCheck has been added with v1beta1.
	return autoConvert_v1beta1_ControlPlaneClass_To_v1alpha4_ControlPlaneClass(in, out, s)
}

func Convert_v1beta1_ControlPlaneTopology_To_v1alpha4_ControlPlaneTopology(in *clusterv1.ControlPlaneTopology, out *ControlPlaneTopology, s apiconversion.Scope) error {
	// controlPlaneTopology.nodeDrainTimeout has been added with v1beta1.
	return autoConvert_v1beta1_ControlPlaneTopology_To_v1alpha4_ControlPlaneTopology(in, out, s)
}

func Convert_v1beta1_MachineStatus_To_v1alpha4_MachineStatus(in *clusterv1.MachineStatus, out *MachineStatus, s apiconversion.Scope) error {
	// MachineStatus.CertificatesExpiryDate has been added in v1beta1.
	return autoConvert_v1beta1_MachineStatus_To_v1alpha4_MachineStatus(in, out, s)
}

func Convert_v1beta1_ClusterClass_To_v1alpha4_ClusterClass(in *clusterv1.ClusterClass, out *ClusterClass, s apiconversion.Scope) error {
	// ClusterClass.Status has been added in v1beta1.
	return autoConvert_v1beta1_ClusterClass_To_v1alpha4_ClusterClass(in, out, s)
}

func Convert_v1beta1_WorkersClass_To_v1alpha4_WorkersClass(in *clusterv1.WorkersClass, out *WorkersClass, s apiconversion.Scope) error {
	// WorkersClass.MachinePools has been added in v1beta1.
	return autoConvert_v1beta1_WorkersClass_To_v1alpha4_WorkersClass(in, out, s)
}

func Convert_v1beta1_WorkersTopology_To_v1alpha4_WorkersTopology(in *clusterv1.WorkersTopology, out *WorkersTopology, s apiconversion.Scope) error {
	// WorkersTopology.MachinePools has been added in v1beta1.
	return autoConvert_v1beta1_WorkersTopology_To_v1alpha4_WorkersTopology(in, out, s)
}

repository: kubernetes-sigs/cluster-api

repo_name: kubernetes-sigs/cluster-api


text:
DESCRIPTION = "User space daemon for extended IEEE 802.11 management"
HOMEPAGE = "http://hostap.epitest.fi"
SECTION = "kernel/userland"
PRIORITY = "optional"
LICENSE = "GPL"
DEPENDS = "libnl openssl ${@base_contains("COMBINED_FEATURES", "pci", "madwifi-ng", "",d)}"
PR = "r0"

DEFAULT_PREFERENCE = "-1"

#we introduce MY_ARCH to get 'armv5te' as arch instead of the misleading 'arm' on armv5te builds
MY_ARCH := "${PACKAGE_ARCH}"
PACKAGE_ARCH = "${@base_contains('COMBINED_FEATURES', 'pci', '${MACHINE_ARCH}', '${MY_ARCH}', d)}"

SRC_URI = "http://hostap.epitest.fi/releases/hostapd-${PV}.tar.gz \
	file://defconfig \
	file://init"

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

export HAS_PCI = "${@base_contains('COMBINED_FEATURES', 'pci', 1, 0,d)}"

inherit update-rc.d
INITSCRIPT_NAME=hostapd

do_configure() {
	install -m 0644 ${WORKDIR}/defconfig ${S}/.config
	if [ "x$HAS_PCI" = "x1" ] ; then
		echo "CONFIG_DRIVER_MADWIFI=y" >> .config
		echo "CFLAGS += -I${STAGING_INCDIR}/madwifi-ng" >> .config
	fi
}

do_compile() {
	make
}

do_install() {
	install -d ${D}${sbindir} ${D}${sysconfdir}/init.d
	install -m 0644 ${S}/hostapd.conf ${D}${sysconfdir}
	install -m 0755 ${S}/hostapd ${D}${sbindir}
	install -m 0755 ${S}/hostapd_cli ${D}${sbindir}
	install -m 755 ${WORKDIR}/init ${D}${sysconfdir}/init.d/hostapd
}


text:
/*
 * Cadence - The resource-oriented smart contract programming language
 *
 * Copyright 2019-2020 Dapper Labs, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package wasm

import (
	"io"
	"unicode/utf8"
)

// WASMReader allows reading WASM binaries
//
type WASMReader struct {
	buf    *buf
	Module Module
}

// readMagicAndVersion reads the magic byte sequence and version at the beginning of the WASM binary
//
// See https://webassembly.github.io/spec/core/binary/modules.html#binary-module:
//
// The encoding of a module starts with a preamble containing a 4-byte magic number [...] and a version field.
//
func (r *WASMReader) readMagicAndVersion() error {

	// Read the magic
	equal, err := r.buf.ReadBytesEqual(wasmMagic)
	if err != nil || !equal {
		return InvalidMagicError{
			Offset:    int(r.buf.offset),
			ReadError: err,
		}
	}

	// Read the version
	equal, err = r.buf.ReadBytesEqual(wasmVersion)
	if err != nil || !equal {
		return InvalidVersionError{
			Offset:    int(r.buf.offset),
			ReadError: err,
		}
	}

	return nil
}

// readSection reads a section in the WASM binary
//
func (r *WASMReader) readSection() error {
	// read the section ID
	sectionIDOffset := r.buf.offset
	b, err := r.buf.ReadByte()

	sectionID := sectionID(b)

	if err != nil {
		return InvalidSectionIDError{
			SectionID: sectionID,
			Offset:    int(sectionIDOffset),
			ReadError: err,
		}
	}

	invalidDuplicateSectionError := func() error {
		return InvalidDuplicateSectionError{
			SectionID: sectionID,
			Offset:    int(sectionIDOffset),
		}
	}

	switch sectionID {
	case sectionIDType:
		if r.Module.Types != nil {
			return invalidDuplicateSectionError()
		}

		err = r.readTypeSection()
		if err != nil {
			return err
		}

	case sectionIDFunction:
		if r.Module.functionTypeIDs != nil {
			return invalidDuplicateSectionError()
		}

		err = r.readFunctionSection()
		if err != nil {
			return err
		}

	case sectionIDCode:
		if r.Module.functionBodies != nil {
			return invalidDuplicateSectionError()
		}

		err = r.readCodeSection()
		if err != nil {
			return err
		}
	}

	return InvalidSectionIDError{
		SectionID: sectionID,
		Offset:    int(sectionIDOffset),
	}
}

// readSectionSize reads the content size of a section
//
func (r *WASMReader) readSectionSize() error {
	// read the size
	sizeOffset := r.buf.offset
	// TODO: use size
	_, err := r.buf.readULEB128()
	if err != nil {
		return InvalidSectionSizeError{
			Offset:    int(sizeOffset),
			ReadError: err,
		}
	}

	return nil
}

// readTypeSection reads the section that declares all function types
// so they can be referenced by index
//
func (r *WASMReader) readTypeSection() error {

	err := r.readSectionSize()
	if err != nil {
		return err
	}

	// read the number of types
	countOffset := r.buf.offset
	count, err := r.buf.readULEB128()
	if err != nil {
		return InvalidTypeSectionTypeCountError{
			Offset:    int(countOffset),
			ReadError: err,
		}
	}

	funcTypes := make([]*FunctionType, count)

	// read each type
	for i := uint32(0); i < count; i++ {
		funcType, err := r.readFuncType()
		if err != nil {
			return err
		}
		funcTypes[i] = funcType
	}

	r.Module.Types = funcTypes

	return nil
}

// readFuncType reads a function type
//
func (r *WASMReader) readFuncType() (*FunctionType, error) {
	// read the function type indicator
	funcTypeIndicatorOffset := r.buf.offset
	funcTypeIndicator, err := r.buf.ReadByte()
	if err != nil || funcTypeIndicator != functionTypeIndicator {
		return nil, InvalidFuncTypeIndicatorError{
			Offset:            int(funcTypeIndicatorOffset),
			FuncTypeIndicator: funcTypeIndicator,
			ReadError:         err,
		}
	}

	// read the number of parameters
	parameterCountOffset := r.buf.offset
	parameterCount, err := r.buf.readULEB128()
	if err != nil {
		return nil, InvalidFuncTypeParameterCountError{
			Offset:    int(parameterCountOffset),
			ReadError: err,
		}
	}

	// read the type of each parameter

	parameterTypes := make([]ValueType, parameterCount)

	for i := uint32(0); i < parameterCount; i++ {
		parameterType, err := r.readValType()
		if err != nil {
			return nil, InvalidFuncTypeParameterTypeError{
				Index:     int(i),
				ReadError: err,
			}
		}
		parameterTypes[i] = parameterType
	}

	// read the number of results
	resultCountOffset := r.buf.offset
	resultCount, err := r.buf.readULEB128()
	if err != nil {
		return nil, InvalidFuncTypeResultCountError{
			Offset:    int(resultCountOffset),
			ReadError: err,
		}
	}

	// read the type of each result

	resultTypes := make([]ValueType, resultCount)

	for i := uint32(0); i < resultCount; i++ {
		resultType, err := r.readValType()
		if err != nil {
			return nil, InvalidFuncTypeResultTypeError{
				Index:     int(i),
				ReadError: err,
			}
		}
		resultTypes[i] = resultType
	}

	return &FunctionType{
		Params:  parameterTypes,
		Results: resultTypes,
	}, nil
}

// readValType reads a value type
//
func (r *WASMReader) readValType() (ValueType, error) {
	valTypeOffset := r.buf.offset
	b, err := r.buf.ReadByte()

	valType := ValueType(b)

	if err != nil {
		return 0, InvalidValTypeError{
			Offset:    int(valTypeOffset),
			ValType:   valType,
			ReadError: err,
		}
	}

	switch valType {
	case ValueTypeI32, ValueTypeI64:
		return valType, nil
	}

	return 0, InvalidValTypeError{
		Offset:  int(valTypeOffset),
		ValType: valType,
	}
}

// readImportSection reads the section that declares the imports
//
func (r *WASMReader) readImportSection() error {

	err := r.readSectionSize()
	if err != nil {
		return err
	}

	// read the number of imports
	countOffset := r.buf.offset
	count, err := r.buf.readULEB128()
	if err != nil {
		return InvalidImportSectionImportCountError{
			Offset:    int(countOffset),
			ReadError: err,
		}
	}

	imports := make([]*Import, count)

	// read the function type ID for each function
	for i := uint32(0); i < count; i++ {
		im, err := r.readImport()
		if err != nil {
			return InvalidImportError{
				Index:     int(i),
				ReadError: err,
			}
		}
		imports[i] = im
	}

	r.Module.Imports = imports

	return nil
}

// readImport reads an import in the import section
//
func (r *WASMReader) readImport() (*Import, error) {

	// read the module
	module, err := r.readName()
	if err != nil {
		return nil, err
	}

	// read the name
	name, err := r.readName()
	if err != nil {
		return nil, err
	}

	// read the type indicator
	indicatorOffset := r.buf.offset
	b, err := r.buf.ReadByte()

	typeIndicator := importTypeIndicator(b)

	// TODO: add support for tables, memories, and globals

	if err != nil || typeIndicator != importTypeIndicatorFunction {
		return nil, InvalidImportTypeIndicatorError{
			TypeIndicator: typeIndicator,
			Offset:        int(indicatorOffset),
			ReadError:     err,
		}
	}

	// read the function type ID
	functionTypeIDOffset := r.buf.offset
	functionTypeID, err := r.buf.readULEB128()
	if err != nil {
		return nil, InvalidImportSectionFunctionTypeIDError{
			Offset:    int(functionTypeIDOffset),
			ReadError: err,
		}
	}

	return &Import{
		Module: module,
		Name:   name,
		TypeID: functionTypeID,
	}, nil
}

// readFunctionSection reads the section that declares the types of functions.
// The bodies of these functions will later be provided in the code section
//
func (r *WASMReader) readFunctionSection() error {

	err := r.readSectionSize()
	if err != nil {
		return err
	}

	// read the number of functions
	countOffset := r.buf.offset
	count, err := r.buf.readULEB128()
	if err != nil {
		return InvalidFunctionSectionFunctionCountError{
			Offset:    int(countOffset),
			ReadError: err,
		}
	}

	functionTypeIDs := make([]uint32, count)

	// read the function type ID for each function
	for i := uint32(0); i < count; i++ {
		functionTypeIDOffset := r.buf.offset
		functionTypeID, err := r.buf.readULEB128()
		if err != nil {
			return InvalidFunctionSectionFunctionTypeIDError{
				Index:     int(i),
				Offset:    int(functionTypeIDOffset),
				ReadError: err,
			}
		}
		functionTypeIDs[i] = functionTypeID
	}

	r.Module.functionTypeIDs = functionTypeIDs

	return nil
}

// readCodeSection reads the section that provides the function bodies for the functions
// declared by the function section (which only provides the function types)
//
func (r *WASMReader) readCodeSection() error {

	err := r.readSectionSize()
	if err != nil {
		return err
	}

	// read the number of functions
	countOffset := r.buf.offset
	count, err := r.buf.readULEB128()
	if err != nil {
		return InvalidCodeSectionFunctionCountError{
			Offset:    int(countOffset),
			ReadError: err,
		}
	}

	// read the code of each function

	functionBodies := make([]*Code, count)

	for i := uint32(0); i < count; i++ {
		functionBody, err := r.readFunctionBody()
		if err != nil {
			return InvalidFunctionCodeError{
				Index:     int(i),
				ReadError: err,
			}
		}
		functionBodies[i] = functionBody
	}

	r.Module.functionBodies = functionBodies

	return nil
}

// readFunctionBody reads the body (locals and instruction) of one function in the code section
//
func (r *WASMReader) readFunctionBody() (*Code, error) {

	// read the size
	sizeOffset := r.buf.offset
	// TODO: use size
	_, err := r.buf.readULEB128()
	if err != nil {
		return nil, InvalidCodeSizeError{
			Offset:    int(sizeOffset),
			ReadError: err,
		}
	}

	// read the locals
	locals, err := r.readLocals()
	if err != nil {
		return nil, err
	}

	// read the instructions
	instructions, err := r.readInstructions()
	if err != nil {
		return nil, err
	}

	return &Code{
		Locals:       locals,
		Instructions: instructions,
	}, nil
}

// readLocals reads the locals for one function in the code sections
//
func (r *WASMReader) readLocals() ([]ValueType, error) {
	// read the number of locals
	localsCountOffset := r.buf.offset
	localsCount, err := r.buf.readULEB128()
	if err != nil {
		return nil, InvalidCodeSectionLocalsCountError{
			Offset:    int(localsCountOffset),
			ReadError: err,
		}
	}

	locals := make([]ValueType, localsCount)

	// read each local
	for i := uint32(0); i < localsCount; {
		compressedLocalsCountOffset := r.buf.offset
		compressedLocalsCount, err := r.buf.readULEB128()
		if err != nil {
			return nil, InvalidCodeSectionCompressedLocalsCountError{
				Offset:    int(compressedLocalsCountOffset),
				ReadError: err,
			}
		}

		localTypeOffset := r.buf.offset
		localType, err := r.readValType()
		if err != nil {
			return nil, InvalidCodeSectionLocalTypeError{
				Offset:    int(localTypeOffset),
				ReadError: err,
			}
		}

		locals[i] = localType

		i += compressedLocalsCount

		if i > localsCount {
			return nil, CodeSectionLocalsCountMismatchError{
				Actual:   i,
				Expected: localsCount,
			}
		}
	}

	return locals, nil
}

// readInstructions reads the instructions for one function in the code sections
//
func (r *WASMReader) readInstructions() (instructions []Instruction, err error) {

	for {
		opcodeOffset := r.buf.offset
		b, err := r.buf.ReadByte()

		c := opcode(b)

		if err != nil {
			if err == io.EOF {
				return nil, MissingEndInstructionError{
					Offset: int(opcodeOffset),
				}
			} else {
				return nil, InvalidOpcodeError{
					Offset:    int(opcodeOffset),
					Opcode:    c,
					ReadError: err,
				}
			}
		}

		switch c {
		case opcodeLocalGet:
			indexOffset := r.buf.offset
			index, err := r.buf.readULEB128()
			if err != nil {
				return nil, InvalidInstructionArgumentError{
					Offset:    int(indexOffset),
					Opcode:    c,
					ReadError: err,
				}
			}
			instructions = append(instructions,
				InstructionLocalGet{Index: index},
			)

		case opcodeI32Add:
			instructions = append(instructions,
				InstructionI32Add{},
			)

		case opcodeEnd:
			return instructions, nil

		default:
			return nil, InvalidOpcodeError{
				Offset:    int(opcodeOffset),
				Opcode:    c,
				ReadError: err,
			}
		}
	}
}

// readName reads a name
//
func (r *WASMReader) readName() (string, error) {

	// read the length
	lengthOffset := r.buf.offset
	length, err := r.buf.readULEB128()
	if err != nil {
		return "", InvalidNameLengthError{
			Offset:    int(lengthOffset),
			ReadError: err,
		}
	}

	// read the name
	nameOffset := r.buf.offset
	name := make([]byte, length)
	n, err := r.buf.Read(name)
	if err != nil {
		return "", InvalidNameError{
			Offset:    int(nameOffset),
			ReadError: err,
		}
	}

	readCount := uint32(n)

	// ensure the full name was read
	if readCount != length {
		return "", IncompleteNameError{
			Offset:   int(nameOffset),
			Expected: length,
			Actual:   readCount,
		}
	}

	// ensure the name is valid UTF-8
	if !utf8.Valid(name) {
		return "", InvalidNonUTF8NameError{
			Offset: int(nameOffset),
			Name:   string(name),
		}
	}

	return string(name), nil
}

repository: lkamak/cadence

repo_name: lkamak/cadence


text:
@article{Rajulapati-2020-Assessment,
    title = "Assessment of Extremes in Global Precipitation Products: How Reliable Are They?",
    author = "Rajulapati, Chandra Rupa  and
      Papalexiou, Simon Michael  and
      Clark, Martyn P.  and
      Razavi, Saman  and
      Tang, Guoqiang  and
      Pomeroy, John W.",
    journal = "Journal of Hydrometeorology, Volume 21, Issue 12",
    volume = "21",
    number = "12",
    year = "2020",
    publisher = "American Meteorological Society",
    url = "https://aclanthology.org/G20-70001",
    doi = "10.1175/jhm-d-20-0040.1",
    pages = "2855--2873",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications


text:
DESCRIPTION = "FCL is a library for performing three types of proximity queries on a pair of geometric models composed of triangles and octrees."
HOMEPAGE = "https://github.com/flexible-collision-library/fcl"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://LICENSE;md5=7de20b14c33be61ee0c714b41e286d0b"

# Octomap dependency not included as it is optional.
DEPENDS = "boost libccd libeigen"

SRCREV = "97455a46de121fb7c0f749e21a58b1b54cd2c6be"
ROS_BRANCH ?= "branch=master"
SRC_URI = " \
    git://github.com/flexible-collision-library/fcl;${ROS_BRANCH};protocol=https \
"

S = "${WORKDIR}/git"

EXTRA_OECMAKE += "-DCMAKE_BUILD_TYPE=Release -DFCL_NO_DEFAULT_RPATH=OFF ${EXTRA_OECMAKE_SSE}"
EXTRA_OECMAKE_SSE = "-DFCL_USE_X64_SSE=OFF"
EXTRA_OECMAKE_SSE_x86-64 = ""

inherit pkgconfig cmake

repository: jianchangfeng/meta-ros

repo_name: jianchangfeng/meta-ros


text:
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: github.com/solo-io/service-mesh-hub/api/core/v1alpha1/settings.proto

package types

import (
	bytes "bytes"
	fmt "fmt"
	math "math"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// Top level SMH user configuration object.
type SettingsSpec struct {
	Aws                  *SettingsSpec_Aws `protobuf:"bytes,1,opt,name=aws,proto3" json:"aws,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *SettingsSpec) Reset()         { *m = SettingsSpec{} }
func (m *SettingsSpec) String() string { return proto.CompactTextString(m) }
func (*SettingsSpec) ProtoMessage()    {}
func (*SettingsSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_7ddcbb204c6694e4, []int{0}
}
func (m *SettingsSpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SettingsSpec.Unmarshal(m, b)
}
func (m *SettingsSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SettingsSpec.Marshal(b, m, deterministic)
}
func (m *SettingsSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SettingsSpec.Merge(m, src)
}
func (m *SettingsSpec) XXX_Size() int {
	return xxx_messageInfo_SettingsSpec.Size(m)
}
func (m *SettingsSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_SettingsSpec.DiscardUnknown(m)
}

var xxx_messageInfo_SettingsSpec proto.InternalMessageInfo

func (m *SettingsSpec) GetAws() *SettingsSpec_Aws {
	if m != nil {
		return m.Aws
	}
	return nil
}

type SettingsSpec_Aws struct {
	// If true, disable integration with AWS.
	Disabled bool `protobuf:"varint,1,opt,name=disabled,proto3" json:"disabled,omitempty"`
	// Per-account AWS settings.
	Accounts             []*SettingsSpec_AwsAccount `protobuf:"bytes,2,rep,name=accounts,proto3" json:"accounts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *SettingsSpec_Aws) Reset()         { *m = SettingsSpec_Aws{} }
func (m *SettingsSpec_Aws) String() string { return proto.CompactTextString(m) }
func (*SettingsSpec_Aws) ProtoMessage()    {}
func (*SettingsSpec_Aws) Descriptor() ([]byte, []int) {
	return fileDescriptor_7ddcbb204c6694e4, []int{0, 0}
}
func (m *SettingsSpec_Aws) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SettingsSpec_Aws.Unmarshal(m, b)
}
func (m *SettingsSpec_Aws) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SettingsSpec_Aws.Marshal(b, m, deterministic)
}
func (m *SettingsSpec_Aws) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SettingsSpec_Aws.Merge(m, src)
}
func (m *SettingsSpec_Aws) XXX_Size() int {
	return xxx_messageInfo_SettingsSpec_Aws.Size(m)
}
func (m *SettingsSpec_Aws) XXX_DiscardUnknown() {
	xxx_messageInfo_SettingsSpec_Aws.DiscardUnknown(m)
}

var xxx_messageInfo_SettingsSpec_Aws proto.InternalMessageInfo

func (m *SettingsSpec_Aws) GetDisabled() bool {
	if m != nil {
		return m.Disabled
	}
	return false
}

func (m *SettingsSpec_Aws) GetAccounts() []*SettingsSpec_AwsAccount {
	if m != nil {
		return m.Accounts
	}
	return nil
}

type SettingsSpec_AwsAccount struct {
	// AWS account ID.
	AccountId string `protobuf:"bytes,1,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
	// If unspecified, by default discovery will run for AppMesh in all regions.
	MeshDiscovery *SettingsSpec_AwsAccount_DiscoverySelector `protobuf:"bytes,2,opt,name=mesh_discovery,json=meshDiscovery,proto3" json:"mesh_discovery,omitempty"`
	// If unspecified, by default discovery will run for EKS clusters in all regions.
	EksDiscovery         *SettingsSpec_AwsAccount_DiscoverySelector `protobuf:"bytes,3,opt,name=eks_discovery,json=eksDiscovery,proto3" json:"eks_discovery,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                   `json:"-"`
	XXX_unrecognized     []byte                                     `json:"-"`
	XXX_sizecache        int32                                      `json:"-"`
}

func (m *SettingsSpec_AwsAccount) Reset()         { *m = SettingsSpec_AwsAccount{} }
func (m *SettingsSpec_AwsAccount) String() string { return proto.CompactTextString(m) }
func (*SettingsSpec_AwsAccount) ProtoMessage()    {}
func (*SettingsSpec_AwsAccount) Descriptor() ([]byte, []int) {
	return fileDescriptor_7ddcbb204c6694e4, []int{0, 1}
}
func (m *SettingsSpec_AwsAccount) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SettingsSpec_AwsAccount.Unmarshal(m, b)
}
func (m *SettingsSpec_AwsAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SettingsSpec_AwsAccount.Marshal(b, m, deterministic)
}
func (m *SettingsSpec_AwsAccount) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SettingsSpec_AwsAccount.Merge(m, src)
}
func (m *SettingsSpec_AwsAccount) XXX_Size() int {
	return xxx_messageInfo_SettingsSpec_AwsAccount.Size(m)
}
func (m *SettingsSpec_AwsAccount) XXX_DiscardUnknown() {
	xxx_messageInfo_SettingsSpec_AwsAccount.DiscardUnknown(m)
}

var xxx_messageInfo_SettingsSpec_AwsAccount proto.InternalMessageInfo

func (m *SettingsSpec_AwsAccount) GetAccountId() string {
	if m != nil {
		return m.AccountId
	}
	return ""
}

func (m *SettingsSpec_AwsAccount) GetMeshDiscovery() *SettingsSpec_AwsAccount_DiscoverySelector {
	if m != nil {
		return m.MeshDiscovery
	}
	return nil
}

func (m *SettingsSpec_AwsAccount) GetEksDiscovery() *SettingsSpec_AwsAccount_DiscoverySelector {
	if m != nil {
		return m.EksDiscovery
	}
	return nil
}

// Configure which AWS resources should be discovered by SMH. An AWS resource will be selected if any of the resource_selectors apply.
type SettingsSpec_AwsAccount_DiscoverySelector struct {
	// If true, disable discovery.
	Disabled             bool                                        `protobuf:"varint,1,opt,name=disabled,proto3" json:"disabled,omitempty"`
	ResourceSelectors    []*SettingsSpec_AwsAccount_ResourceSelector `protobuf:"bytes,2,rep,name=resource_selectors,json=resourceSelectors,proto3" json:"resource_selectors,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                    `json:"-"`
	XXX_unrecognized     []byte                                      `json:"-"`
	XXX_sizecache        int32                                       `json:"-"`
}

func (m *SettingsSpec_AwsAccount_DiscoverySelector) Reset() {
	*m = SettingsSpec_AwsAccount_DiscoverySelector{}
}
func (m *SettingsSpec_AwsAccount_DiscoverySelector) String() string {
	return proto.CompactTextString(m)
}
func (*SettingsSpec_AwsAccount_DiscoverySelector) ProtoMessage() {}
func (*SettingsSpec_AwsAccount_DiscoverySelector) Descriptor() ([]byte, []int) {
	return fileDescriptor_7ddcbb204c6694e4, []int{0, 1, 0}
}
func (m *SettingsSpec_AwsAccount_DiscoverySelector) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SettingsSpec_AwsAccount_DiscoverySelector.Unmarshal(m, b)
}
func (m *SettingsSpec_AwsAccount_DiscoverySelector) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SettingsSpec_AwsAccount_DiscoverySelector.Marshal(b, m, deterministic)
}
func (m *SettingsSpec_AwsAccount_DiscoverySelector) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SettingsSpec_AwsAccount_DiscoverySelector.Merge(m, src)
}
func (m *SettingsSpec_AwsAccount_DiscoverySelector) XXX_Size() int {
	return xxx_messageInfo_SettingsSpec_AwsAccount_DiscoverySelector.Size(m)
}
func (m *SettingsSpec_AwsAccount_DiscoverySelector) XXX_DiscardUnknown() {
	xxx_messageInfo_SettingsSpec_AwsAccount_DiscoverySelector.DiscardUnknown(m)
}

var xxx_messageInfo_SettingsSpec_AwsAccount_DiscoverySelector proto.InternalMessageInfo

func (m *SettingsSpec_AwsAccount_DiscoverySelector) GetDisabled() bool {
	if m != nil {
		return m.Disabled
	}
	return false
}

func (m *SettingsSpec_AwsAccount_DiscoverySelector) GetResourceSelectors() []*SettingsSpec_AwsAccount_ResourceSelector {
	if m != nil {
		return m.ResourceSelectors
	}
	return nil
}

// For a given resource_selector to apply to a resource, the resource must match all of the resource_selector's match criteria.
type SettingsSpec_AwsAccount_ResourceSelector struct {
	// Types that are valid to be assigned to MatcherType:
	//	*SettingsSpec_AwsAccount_ResourceSelector_Arn
	//	*SettingsSpec_AwsAccount_ResourceSelector_Matcher_
	MatcherType          isSettingsSpec_AwsAccount_ResourceSelector_MatcherType `protobuf_oneof:"matcher_type"`
	XXX_NoUnkeyedLiteral struct{}                                               `json:"-"`
	XXX_unrecognized     []byte                                                 `json:"-"`
	XXX_sizecache        int32                                                  `json:"-"`
}

func (m *SettingsSpec_AwsAccount_ResourceSelector) Reset() {
	*m = SettingsSpec_AwsAccount_ResourceSelector{}
}
func (m *SettingsSpec_AwsAccount_ResourceSelector) String() string { return proto.CompactTextString(m) }
func (*SettingsSpec_AwsAccount_ResourceSelector) ProtoMessage()    {}
func (*SettingsSpec_AwsAccount_ResourceSelector) Descriptor() ([]byte, []int) {
	return fileDescriptor_7ddcbb204c6694e4, []int{0, 1, 1}
}
func (m *SettingsSpec_AwsAccount_ResourceSelector) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SettingsSpec_AwsAccount_ResourceSelector.Unmarshal(m, b)
}
func (m *SettingsSpec_AwsAccount_ResourceSelector) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SettingsSpec_AwsAccount_ResourceSelector.Marshal(b, m, deterministic)
}
func (m *SettingsSpec_AwsAccount_ResourceSelector) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SettingsSpec_AwsAccount_ResourceSelector.Merge(m, src)
}
func (m *SettingsSpec_AwsAccount_ResourceSelector) XXX_Size() int {
	return xxx_messageInfo_SettingsSpec_AwsAccount_ResourceSelector.Size(m)
}
func (m *SettingsSpec_AwsAccount_ResourceSelector) XXX_DiscardUnknown() {
	xxx_messageInfo_SettingsSpec_AwsAccount_ResourceSelector.DiscardUnknown(m)
}

var xxx_messageInfo_SettingsSpec_AwsAccount_ResourceSelector proto.InternalMessageInfo

type isSettingsSpec_AwsAccount_ResourceSelector_MatcherType interface {
	isSettingsSpec_AwsAccount_ResourceSelector_MatcherType()
	Equal(interface{}) bool
}

type SettingsSpec_AwsAccount_ResourceSelector_Arn struct {
	Arn string `protobuf:"bytes,1,opt,name=arn,proto3,oneof" json:"arn,omitempty"`
}
type SettingsSpec_AwsAccount_ResourceSelector_Matcher_ struct {
	Matcher *SettingsSpec_AwsAccount_ResourceSelector_Matcher `protobuf:"bytes,2,opt,name=matcher,proto3,oneof" json:"matcher,omitempty"`
}

func (*SettingsSpec_AwsAccount_ResourceSelector_Arn) isSettingsSpec_AwsAccount_ResourceSelector_MatcherType() {
}
func (*SettingsSpec_AwsAccount_ResourceSelector_Matcher_) isSettingsSpec_AwsAccount_ResourceSelector_MatcherType() {
}

func (m *SettingsSpec_AwsAccount_ResourceSelector) GetMatcherType() isSettingsSpec_AwsAccount_ResourceSelector_MatcherType {
	if m != nil {
		return m.MatcherType
	}
	return nil
}

func (m *SettingsSpec_AwsAccount_ResourceSelector) GetArn() string {
	if x, ok := m.GetMatcherType().(*SettingsSpec_AwsAccount_ResourceSelector_Arn); ok {
		return x.Arn
	}
	return ""
}

func (m *SettingsSpec_AwsAccount_ResourceSelector) GetMatcher() *SettingsSpec_AwsAccount_ResourceSelector_Matcher {
	if x, ok := m.GetMatcherType().(*SettingsSpec_AwsAccount_ResourceSelector_Matcher_); ok {
		return x.Matcher
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*SettingsSpec_AwsAccount_ResourceSelector) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*SettingsSpec_AwsAccount_ResourceSelector_Arn)(nil),
		(*SettingsSpec_AwsAccount_ResourceSelector_Matcher_)(nil),
	}
}

// Selects all resources that exist in the specified AWS region and possess the specified tags.
type SettingsSpec_AwsAccount_ResourceSelector_Matcher struct {
	// AWS regions, e.g. us-east-2. If unspecified, select across all regions.
	Regions []string `protobuf:"bytes,1,rep,name=regions,proto3" json:"regions,omitempty"`
	// AWS resource tags. If unspecified, match any tags.
	Tags                 map[string]string `protobuf:"bytes,2,rep,name=tags,proto3" json:"tags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *SettingsSpec_AwsAccount_ResourceSelector_Matcher) Reset() {
	*m = SettingsSpec_AwsAccount_ResourceSelector_Matcher{}
}
func (m *SettingsSpec_AwsAccount_ResourceSelector_Matcher) String() string {
	return proto.CompactTextString(m)
}
func (*SettingsSpec_AwsAccount_ResourceSelector_Matcher) ProtoMessage() {}
func (*SettingsSpec_AwsAccount_ResourceSelector_Matcher) Descriptor() ([]byte, []int) {
	return fileDescriptor_7ddcbb204c6694e4, []int{0, 1, 1, 0}
}
func (m *SettingsSpec_AwsAccount_ResourceSelector_Matcher) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SettingsSpec_AwsAccount_ResourceSelector_Matcher.Unmarshal(m, b)
}
func (m *SettingsSpec_AwsAccount_ResourceSelector_Matcher) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SettingsSpec_AwsAccount_ResourceSelector_Matcher.Marshal(b, m, deterministic)
}
func (m *SettingsSpec_AwsAccount_ResourceSelector_Matcher) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SettingsSpec_AwsAccount_ResourceSelector_Matcher.Merge(m, src)
}
func (m *SettingsSpec_AwsAccount_ResourceSelector_Matcher) XXX_Size() int {
	return xxx_messageInfo_SettingsSpec_AwsAccount_ResourceSelector_Matcher.Size(m)
}
func (m *SettingsSpec_AwsAccount_ResourceSelector_Matcher) XXX_DiscardUnknown() {
	xxx_messageInfo_SettingsSpec_AwsAccount_ResourceSelector_Matcher.DiscardUnknown(m)
}

var xxx_messageInfo_SettingsSpec_AwsAccount_ResourceSelector_Matcher proto.InternalMessageInfo

func (m *SettingsSpec_AwsAccount_ResourceSelector_Matcher) GetRegions() []string {
	if m != nil {
		return m.Regions
	}
	return nil
}

func (m *SettingsSpec_AwsAccount_ResourceSelector_Matcher) GetTags() map[string]string {
	if m != nil {
		return m.Tags
	}
	return nil
}

type SettingsStatus struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SettingsStatus) Reset()         { *m = SettingsStatus{} }
func (m *SettingsStatus) String() string { return proto.CompactTextString(m) }
func (*SettingsStatus) ProtoMessage()    {}
func (*SettingsStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_7ddcbb204c6694e4, []int{1}
}
func (m *SettingsStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SettingsStatus.Unmarshal(m, b)
}
func (m *SettingsStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SettingsStatus.Marshal(b, m, deterministic)
}
func (m *SettingsStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SettingsStatus.Merge(m, src)
}
func (m *SettingsStatus) XXX_Size() int {
	return xxx_messageInfo_SettingsStatus.Size(m)
}
func (m *SettingsStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_SettingsStatus.DiscardUnknown(m)
}

var xxx_messageInfo_SettingsStatus proto.InternalMessageInfo

func init() {
	proto.RegisterType((*SettingsSpec)(nil), "core.zephyr.solo.io.SettingsSpec")
	proto.RegisterType((*SettingsSpec_Aws)(nil), "core.zephyr.solo.io.SettingsSpec.Aws")
	proto.RegisterType((*SettingsSpec_AwsAccount)(nil), "core.zephyr.solo.io.SettingsSpec.AwsAccount")
	proto.RegisterType((*SettingsSpec_AwsAccount_DiscoverySelector)(nil), "core.zephyr.solo.io.SettingsSpec.AwsAccount.DiscoverySelector")
	proto.RegisterType((*SettingsSpec_AwsAccount_ResourceSelector)(nil), "core.zephyr.solo.io.SettingsSpec.AwsAccount.ResourceSelector")
	proto.RegisterType((*SettingsSpec_AwsAccount_ResourceSelector_Matcher)(nil), "core.zephyr.solo.io.SettingsSpec.AwsAccount.ResourceSelector.Matcher")
	proto.RegisterMapType((map[string]string)(nil), "core.zephyr.solo.io.SettingsSpec.AwsAccount.ResourceSelector.Matcher.TagsEntry")
	proto.RegisterType((*SettingsStatus)(nil), "core.zephyr.solo.io.SettingsStatus")
}

func init() {
	proto.RegisterFile("github.com/solo-io/service-mesh-hub/api/core/v1alpha1/settings.proto", fileDescriptor_7ddcbb204c6694e4)
}

var fileDescriptor_7ddcbb204c6694e4 = []byte{
	// 500 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xcd, 0x6a, 0x1b, 0x31,
	0x10, 0xce, 0x7a, 0x9b, 0x3a, 0x9e, 0x38, 0xc6, 0x51, 0x73, 0x30, 0x0b, 0x2d, 0x21, 0x50, 0xf0,
	0xa1, 0xd6, 0x92, 0xf4, 0x90, 0x52, 0x68, 0xc1, 0x21, 0x01, 0xf7, 0xd0, 0x16, 0xe4, 0x9c, 0x7a,
	0x31, 0xb2, 0x3c, 0xec, 0x0a, 0xaf, 0xad, 0x45, 0xd2, 0xda, 0xb8, 0xef, 0xd2, 0x7b, 0x4f, 0x7d,
	0x87, 0x3e, 0x48, 0x2f, 0x7d, 0x89, 0x5e, 0x8b, 0xf6, 0x2f, 0xc1, 0x2d, 0x25, 0xa1, 0xb9, 0x69,
	0xbe, 0x99, 0xef, 0xfb, 0x46, 0x23, 0x31, 0x70, 0x19, 0x49, 0x1b, 0x67, 0x53, 0x2a, 0xd4, 0x22,
	0x34, 0x2a, 0x51, 0x03, 0xa9, 0x42, 0x83, 0x7a, 0x25, 0x05, 0x0e, 0x16, 0x68, 0xe2, 0x41, 0x9c,
	0x4d, 0x43, 0x9e, 0xca, 0x50, 0x28, 0x8d, 0xe1, 0xea, 0x94, 0x27, 0x69, 0xcc, 0x4f, 0x43, 0x83,
	0xd6, 0xca, 0x65, 0x64, 0x68, 0xaa, 0x95, 0x55, 0xe4, 0x89, 0xcb, 0xd2, 0xcf, 0x98, 0xc6, 0x1b,
	0x4d, 0x9d, 0x0c, 0x95, 0x2a, 0x38, 0x8a, 0x54, 0xa4, 0xf2, 0x7c, 0xe8, 0x4e, 0x45, 0xe9, 0xc9,
	0xb7, 0x26, 0xb4, 0xc7, 0x25, 0x7b, 0x9c, 0xa2, 0x20, 0xe7, 0xe0, 0xf3, 0xb5, 0xe9, 0x79, 0xc7,
	0x5e, 0x7f, 0xff, 0xec, 0x39, 0xfd, 0x8b, 0x12, 0xbd, 0x5d, 0x4f, 0x87, 0x6b, 0xc3, 0x1c, 0x23,
	0x98, 0x83, 0x3f, 0x5c, 0x1b, 0x12, 0xc0, 0xde, 0x4c, 0x1a, 0x3e, 0x4d, 0x70, 0x96, 0x8b, 0xec,
	0xb1, 0x3a, 0x26, 0x23, 0xd8, 0xe3, 0x42, 0xa8, 0x6c, 0x69, 0x4d, 0xaf, 0x71, 0xec, 0xf7, 0xf7,
	0xcf, 0x5e, 0xdc, 0xc9, 0x60, 0x58, 0x90, 0x58, 0xcd, 0x0e, 0x7e, 0xed, 0x02, 0xdc, 0x24, 0xc8,
	0x53, 0x80, 0x32, 0x35, 0x91, 0x85, 0x6d, 0x8b, 0xb5, 0x4a, 0xe4, 0xdd, 0x8c, 0x20, 0x74, 0xdc,
	0xf0, 0x26, 0x33, 0x69, 0x84, 0x5a, 0xa1, 0xde, 0xf4, 0x1a, 0xf9, 0xf5, 0xde, 0xde, 0xc7, 0x9d,
	0x5e, 0x56, 0xec, 0x31, 0x26, 0x28, 0xac, 0xd2, 0xec, 0xc0, 0xa9, 0xd6, 0x30, 0x11, 0x70, 0x80,
	0x73, 0x73, 0xcb, 0xc5, 0x7f, 0x10, 0x97, 0x36, 0xce, 0x4d, 0x8d, 0x06, 0x5f, 0x3c, 0x38, 0xfc,
	0xa3, 0xe6, 0x9f, 0x53, 0x4f, 0x80, 0x68, 0x34, 0x2a, 0xd3, 0x02, 0x27, 0xa6, 0x24, 0x54, 0xf3,
	0x7f, 0x73, 0xaf, 0xde, 0x58, 0x29, 0x53, 0xb7, 0x76, 0xa8, 0xb7, 0x10, 0x13, 0xfc, 0x68, 0x40,
	0x77, 0xbb, 0x8e, 0x10, 0xf0, 0xb9, 0x5e, 0x16, 0x0f, 0x33, 0xda, 0x61, 0x2e, 0x20, 0x1c, 0x9a,
	0x0b, 0x6e, 0x45, 0x8c, 0xba, 0x7c, 0x8d, 0xab, 0xff, 0xea, 0x85, 0xbe, 0x2f, 0xc4, 0x46, 0x3b,
	0xac, 0xd2, 0x0d, 0xbe, 0x7b, 0xd0, 0x2c, 0x61, 0xd2, 0x83, 0xa6, 0xc6, 0x48, 0xaa, 0xa5, 0xfb,
	0xdb, 0x7e, 0xbf, 0xc5, 0xaa, 0x90, 0x08, 0x78, 0x64, 0x79, 0x54, 0x4d, 0xe4, 0xe3, 0x83, 0x74,
	0x41, 0xaf, 0x79, 0x64, 0xae, 0x96, 0x56, 0x6f, 0x58, 0x2e, 0x1e, 0x9c, 0x43, 0xab, 0x86, 0x48,
	0x17, 0xfc, 0x39, 0x6e, 0xca, 0x7f, 0xea, 0x8e, 0xe4, 0x08, 0x76, 0x57, 0x3c, 0xc9, 0x30, 0x1f,
	0x45, 0x8b, 0x15, 0xc1, 0xeb, 0xc6, 0x2b, 0xef, 0xa2, 0x03, 0xed, 0xf2, 0x3a, 0x13, 0xbb, 0x49,
	0xf1, 0xa4, 0x0b, 0x9d, 0xba, 0x19, 0xcb, 0x6d, 0x66, 0x2e, 0xae, 0xbf, 0xfe, 0x7c, 0xe6, 0x7d,
	0xfa, 0x70, 0x97, 0xcd, 0x91, 0xce, 0xa3, 0x7a, 0x7b, 0x6c, 0x5d, 0xf1, 0x66, 0x99, 0x38, 0x1b,
	0x33, 0x7d, 0x9c, 0xef, 0x87, 0x97, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xa2, 0xa9, 0x6c, 0x74,
	0x92, 0x04, 0x00, 0x00,
}

func (this *SettingsSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SettingsSpec)
	if !ok {
		that2, ok := that.(SettingsSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Aws.Equal(that1.Aws) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *SettingsSpec_Aws) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SettingsSpec_Aws)
	if !ok {
		that2, ok := that.(SettingsSpec_Aws)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Disabled != that1.Disabled {
		return false
	}
	if len(this.Accounts) != len(that1.Accounts) {
		return false
	}
	for i := range this.Accounts {
		if !this.Accounts[i].Equal(that1.Accounts[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *SettingsSpec_AwsAccount) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SettingsSpec_AwsAccount)
	if !ok {
		that2, ok := that.(SettingsSpec_AwsAccount)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.AccountId != that1.AccountId {
		return false
	}
	if !this.MeshDiscovery.Equal(that1.MeshDiscovery) {
		return false
	}
	if !this.EksDiscovery.Equal(that1.EksDiscovery) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *SettingsSpec_AwsAccount_DiscoverySelector) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SettingsSpec_AwsAccount_DiscoverySelector)
	if !ok {
		that2, ok := that.(SettingsSpec_AwsAccount_DiscoverySelector)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Disabled != that1.Disabled {
		return false
	}
	if len(this.ResourceSelectors) != len(that1.ResourceSelectors) {
		return false
	}
	for i := range this.ResourceSelectors {
		if !this.ResourceSelectors[i].Equal(that1.ResourceSelectors[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *SettingsSpec_AwsAccount_ResourceSelector) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SettingsSpec_AwsAccount_ResourceSelector)
	if !ok {
		that2, ok := that.(SettingsSpec_AwsAccount_ResourceSelector)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.MatcherType == nil {
		if this.MatcherType != nil {
			return false
		}
	} else if this.MatcherType == nil {
		return false
	} else if !this.MatcherType.Equal(that1.MatcherType) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *SettingsSpec_AwsAccount_ResourceSelector_Arn) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SettingsSpec_AwsAccount_ResourceSelector_Arn)
	if !ok {
		that2, ok := that.(SettingsSpec_AwsAccount_ResourceSelector_Arn)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Arn != that1.Arn {
		return false
	}
	return true
}
func (this *SettingsSpec_AwsAccount_ResourceSelector_Matcher_) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SettingsSpec_AwsAccount_ResourceSelector_Matcher_)
	if !ok {
		that2, ok := that.(SettingsSpec_AwsAccount_ResourceSelector_Matcher_)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Matcher.Equal(that1.Matcher) {
		return false
	}
	return true
}
func (this *SettingsSpec_AwsAccount_ResourceSelector_Matcher) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SettingsSpec_AwsAccount_ResourceSelector_Matcher)
	if !ok {
		that2, ok := that.(SettingsSpec_AwsAccount_ResourceSelector_Matcher)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Regions) != len(that1.Regions) {
		return false
	}
	for i := range this.Regions {
		if this.Regions[i] != that1.Regions[i] {
			return false
		}
	}
	if len(this.Tags) != len(that1.Tags) {
		return false
	}
	for i := range this.Tags {
		if this.Tags[i] != that1.Tags[i] {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *SettingsStatus) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SettingsStatus)
	if !ok {
		that2, ok := that.(SettingsStatus)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}

repository: synuwxy/service-mesh-hub

repo_name: synuwxy/service-mesh-hub


text:
// Copyright 2021 vlorc. All rights reserved.
// Use of this source code is governed by an Apache 2.0 license that can be found in the LICENSE file at the root of this project.

package types

import (
	"context"
	"github.com/pkg/errors"
	"strconv"
	"strings"
	"time"
)

type ObjectClient interface {
	PutObject(ctx context.Context, key string, object []byte) error
	GetObject(ctx context.Context, key string) ([]byte, error)
	DeleteObject(ctx context.Context, key string) error
	Ping() error
}

func errInvalidChunkID(s string) error {
	return errors.Errorf("invalid chunk ID %q", s)
}

func ParseCheckId(key string) (*CheckInfo, error) {
	parts := strings.Split(key, "/")
	if len(parts) != 2 {
		return nil, errInvalidChunkID(key)
	}
	userID := parts[0]
	hexParts := strings.Split(parts[1], ":")
	if len(hexParts) != 4 {
		return nil, errInvalidChunkID(key)
	}
	fingerprint, err := strconv.ParseUint(hexParts[0], 16, 64)
	if err != nil {
		return nil, err
	}
	from, err := strconv.ParseInt(hexParts[1], 16, 64)
	if err != nil {
		return nil, err
	}
	through, err := strconv.ParseInt(hexParts[2], 16, 64)
	if err != nil {
		return nil, err
	}
	checksum, err := strconv.ParseUint(hexParts[3], 16, 32)
	if err != nil {
		return nil, err
	}
	return &CheckInfo{
		Id:          key,
		UserID:      userID,
		Fingerprint: fingerprint,
		From:        time.Unix(0, from),
		Through:     time.Unix(0, through),
		Checksum:    uint32(checksum),
		ChecksumSet: true,
	}, nil
}

type CheckInfo struct {
	Id          string
	UserID      string
	Fingerprint uint64
	From        time.Time
	Through     time.Time
	Checksum    uint32
	ChecksumSet bool
}

repository: vlorc/loki-grpc-storage

repo_name: vlorc/loki-grpc-storage


text:
# NIFTY_TOOLS cmake module
# This module sets the following variables in your project::
#
#   NIFTY_TOOLS_FOUND - true if NIFTY_TOOLS found on the system
#   NIFTY_TOOLS_INCLUDE_DIRS - the directory containing NIFTY_TOOLS headers
#   NIFTY_TOOLS_LIBRARY - EMPTY

@PACKAGE_INIT@

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


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

DEPENDS = "pkgconfig-native tegra-libraries tegra-mmapi libv4l2-minimal"
RDEPENDS_${PN} = "tegra-libraries libv4l2-minimal"

SRC_URI += "git://github.com/jocover/jetson-ffmpeg.git;protocol=https"
SRC_URI += "file://nv.patch"

PV = "1.0+git${SRCPV}"
SRCREV = "7baa3d8232478b82799a90c37b86a986e4df1df2"

FILES_${PN} += "/usr/include/nvmpi.h \
                /usr/lib/libnvmpi.so.1.0.0 \
                /usr/lib/libnvmpi.so \
                /usr/lib/pkgconfig/nvmpi.pc"

S = "${WORKDIR}/git"

inherit cmake

EXTRA_OECMAKE = "-DBITBAKE_SYSROOT=${WORKDIR}/recipe-sysroot"

do_install_append () {
    rm -fr ${D}/usr/share
}


text:
DESCRIPTION = "ARM Trusted Firmware Allwinner"
LICENSE = "BSD-3-Clause"
LIC_FILES_CHKSUM = "file://license.md;md5=829bdeb34c1d9044f393d5a16c068371"

SRC_URI = "git://github.com/apritzel/arm-trusted-firmware;nobranch=1;protocol=https"
SRCREV = "aa75c8da415158a94b82a430b2b40000778e851f"

SRC_URI:append = " file://0001-Use-same-type-as-in-declaration.patch"

S = "${WORKDIR}/git"
B = "${WORKDIR}/build"

COMPATIBLE_MACHINE = "(sun50i)"

PLATFORM:sun50i = "sun50iw1p1"

LDFLAGS[unexport] = "1"

do_compile() {
    oe_runmake -C ${S} BUILD_BASE=${B} \
      CROSS_COMPILE=${TARGET_PREFIX} \
      PLAT=${PLATFORM} \
      bl31 \
      all
}

do_install() {
    install -D -p -m 0644 ${B}/${PLATFORM}/release/bl31.bin ${DEPLOY_DIR_IMAGE}/bl31.bin
}

repository: lycheepi/meta-sunxi

repo_name: lycheepi/meta-sunxi


text:
@TECHREPORT{Solo1986,
  author = {David M. Solo},
  title = {Readable Layout of Unbalanced N-ary Trees},
  institution = {MIT Artificial Intelligence Laboratory},
  year = {1986},
  number = {WP-289},
  abstract = {The automatic layout of unbounded n-ary tree structures is a problem of subjectively meshing two independent goals: clarity and space efficiency. This paper presents a minimal set of subjective aesthetics which insures highly readable structures, without overly restricted flexibility in the layout of the tree. This flexibility underlies the algorithm's ability to produce readable trees with greater uniformity of node density throughout the display than achieved by previous algorithms, an especially useful characteristic where nodes are labelled with text.},
  url = {http://hdl.handle.net/1721.1/41166}
}

repository: vis-au/treevisnet

repo_name: vis-au/treevisnet