text:
@proceedings{ws-2013-brazilian,
    title = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4800",
}
@inproceedings{alvares-roman-2013-agreecalc,
    title = "{A}gree{C}alc: Uma Ferramenta para An{\'a}lise da Concord{\^a}ncia entre M{\'u}ltiplos Anotadores ({A}gree{C}alc: A Tool for the Analysis of Agreement Between Multiple Annotators) [in {P}ortuguese]",
    author = "Alvares, Alexandre Rossi  and
      Roman, Norton Trevisan",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4801",
}
@inproceedings{missao-roman-2013-metaann,
    title = "{M}eta{A}nn: Um Gerador de Ferramentas para Anota{\c{c}}{\~a}o de Textos ({M}eta{A}nn: a Generator of Text Annotation Tools) [in {P}ortuguese]",
    author = "Miss{\~a}o, Tiago Emanuel Infante  and
      Roman, Norton Trevisan",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4802",
}
@inproceedings{silva-finger-2013-improving,
    title = "Improving {C}o{G}r{OO}: the {B}razilian {P}ortuguese Grammar Checker",
    author = "Silva, William D. Colen M.  and
      Finger, Marcelo",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4803",
}
@inproceedings{de-souza-feltrim-2013-uma,
    title = "Uma Investiga{\c{c}}{\~a}o sobre Algoritmos de Diferentes Abordagens de Aprendizado Supervisionado na Classifica{\c{c}}{\~a}o de Pap{\'e}is Ret{\'o}ricos em Resumos Cient{\'\i}ficos (Investigating Algorithms from Different Approaches of Supervised Learning for the Classification of Rhetorical Roles in Scientific Abstracts) [in {P}ortuguese]",
    author = "de Souza, Vin{\'\i}cius M. A.  and
      Feltrim, Val{\'e}ria D.",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4804",
}
@inproceedings{minghelli-etal-2013-o,
    title = "O Subframe Senten{\c{c}}a no Complexo Frame Processo de Conhecimento no Direito Processual Civil (The Sentencing Subframe in the Complex Knowledge Process Frame in the Civil Procedural Law) [in {P}ortuguese]",
    author = "Minghelli, Tha{\'\i}s Dom{\^e}nica  and
      Bertoldi, Anderson  and
      Chishman, Rove",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4805",
}
@inproceedings{cardoso-etal-2013-subtopic,
    title = "Subtopic Annotation in a Corpus of News Texts: Steps Towards Automatic Subtopic Segmentation",
    author = "Cardoso, Paula C. F.  and
      Taboada, Maite  and
      Pardo, Thiago A. S.",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4806",
}
@inproceedings{do-amaral-vieira-2013-o,
    title = "O Reconhecimento de Entidades Nomeadas por meio de Conditional Random Fields para a L{\'\i}ngua Portuguesa (Named Entity Recognition with Conditional Random Fields for the {P}ortuguese Language) [in {P}ortuguese]",
    author = "do Amaral, Daniela O. F.  and
      Vieira, Renata",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4807",
}
@inproceedings{freitas-feltrim-2013-analise,
    title = "An{\'a}lise Autom{\'a}tica de Coer{\^e}ncia Usando o Modelo Grade de Entidades para o Portugu{\^e}s (Automatic Coherence Analysis Using the Entity-grid Model for {P}ortuguese) [in {P}ortuguese]",
    author = "Freitas, Alison R. P.  and
      Feltrim, Val{\'e}ria D.",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4808",
}
@inproceedings{lopes-vieira-2013-aplicando,
    title = "Aplicando Pontos de Corte para Listas de Termos Extra{\'\i}dos (Applying Cut-off Points to Lists of Extracted Terms) [in {P}ortuguese]",
    author = "Lopes, Lucelene  and
      Vieira, Renata",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4809",
}
@inproceedings{dos-santos-silva-paraboni-2013-geracao,
    title = "Gera{\c{c}}{\~a}o de Express{\~o}es de Refer{\^e}ncia usando Rela{\c{c}}{\~o}es Espaciais (Referring Expression Generation Using Spatial Relations) [in {P}ortuguese]",
    author = "dos Santos Silva, Diego  and
      Paraboni, Ivandr{\'e}",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4810",
}
@inproceedings{fonseca-rosa-2013-mac,
    title = "Mac-Morpho Revisited: Towards Robust Part-of-Speech Tagging",
    author = "Fonseca, Erick Rocha  and
      Rosa, Jo{\~a}o Lu{\'\i}s G.",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4811",
}
@inproceedings{rocha-neto-2013-implementacao,
    title = "Implementa{\c{c}}{\~a}o de um Separador Sil{\'a}bico Gratuito Baseado em Regras Lingu{\'\i}sticas para o Portugu{\^e}s Brasileiro (The Implementation of a Free Syllabification Algorithm Based on Linguistic Rules for {B}razilian {P}ortuguese) [in {P}ortuguese]",
    author = "Rocha, Willian  and
      Neto, Nelson",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4812",
}
@inproceedings{paetzold-specia-2013-text,
    title = "Text Simplification as Tree Transduction",
    author = "Paetzold, Gustavo H.  and
      Specia, Lucia",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4813",
}
@inproceedings{shulby-etal-2013-automatic,
    title = "Automatic Disambiguation of Homographic Heterophone Pairs Containing Open and Closed Mid Vowels",
    author = "Shulby, Christopher  and
      Mendon{\c{c}}a, Gustavo  and
      Marquiaf{\'a}vel, Vanessa",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4814",
}
@inproceedings{nobrega-pardo-2013-desambiguacao,
    title = "Desambigua{\c{c}}{\~a}o Lexical de Sentido com uso de Informa{\c{c}}{\~a}o Multidocumento por meio de Redes de Co-ocorr{\^e}ncia (Word Sense Disambiguation with the Use of Multi-document Information with Cooccurrence Nets) [in {P}ortuguese]",
    author = "N{\'o}brega, Fernando Ant{\^o}nio Asevedo  and
      Pardo, Thiago Alexandre Salgueiro",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4815",
}
@inproceedings{da-silva-junior-etal-2013-realizacao,
    title = "Realiza{\c{c}}{\~a}o Superficial baseada em Regras (Rule-based Surface Realisation) [in {P}ortuguese]",
    author = "da Silva Junior, Douglas F. P.  and
      de Novais, Eder M.  and
      Paraboni, Ivandr{\'e}",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4816",
}
@inproceedings{oliveira-roman-2013-jwn,
    title = "{JWN}-Br - Uma {API} {J}ava para a {W}ord{N}et.{B}r ({JWN}-Br - an {J}ava {API} for {W}ordnet.{B}r) [in {P}ortuguese]",
    author = "Oliveira, Vitor Machado  and
      Roman, Norton Trevisan",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4817",
}
@inproceedings{fonseca-etal-2013-geracao,
    title = "Gera{\c{c}}{\~a}o de features para resolu{\c{c}}{\~a}o de correfer{\^e}ncia: Pessoa, Local e Organiza{\c{c}}{\~a}o (Feature Generation for Coreference Resolution: Person, Location and Organization) [in {P}ortuguese]",
    author = "Fonseca, Evandro B.  and
      Vieira, Renata  and
      Vanin, Aline A.",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4818",
}
@inproceedings{cortes-mello-2013-modalidade,
    title = "Modalidade no Portugu{\^e}s Brasileiro: as estruturas condicionais (Modality in {B}razilian {P}ortuguese: the Conditional Structures) [in {P}ortuguese]",
    author = "C{\^o}rtes, Priscila Os{\'o}rio  and
      Mello, Heliana",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4819",
}
@inproceedings{duran-etal-2013-um,
    title = "Um reposit{\'o}rio de verbos para a anota{\c{c}}{\~a}o de pap{\'e}is sem{\^a}nticos dispon{\'\i}vel na web (A Verb Repository for Semantic Role Labeling Available in the Web) [in {P}ortuguese]",
    author = "Duran, Magali Sanches  and
      Martins, Jhonata Pereira  and
      Alu{\'\i}sio, Sandra Maria",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4820",
}
@inproceedings{souza-vieira-2013-entity,
    title = "Entity-centric Sentiment Analysis on Twitter data for the Potuguese Language",
    author = "Souza, Marlo  and
      Vieira, Renata",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4821",
}
@inproceedings{schuster-etal-2013-approaches,
    title = "Approaches for Helping {B}razilian Students Improve their Scientific Writings",
    author = "Schuster, Ethel  and
      Lizotte, Rick  and
      Alu{\'\i}sio, Sandra M.  and
      Dayrell, Carmen",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4822",
}
@inproceedings{de-alencar-2013-brgram,
    title = "{B}r{G}ram: uma gram{\'a}tica computacional de um fragmento do portugu{\^e}s brasileiro no formalismo da {LFG} ({B}r{G}ram: a Computational Grammar for a Fragment of {B}razilian {P}ortuguese in the {LFG} Formalism) [in {P}ortuguese]",
    author = "de Alencar, Leonel F.",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4823",
}
@inproceedings{sandrim-etal-2013-geracao,
    title = "Gera{\c{c}}{\~a}o de instru{\c{c}}{\~o}es em mundos virtuais: primeiros passos (Generation of Instructions in Virtual Worlds: First Steps) [in {P}ortuguese]",
    author = "Sandrim, Diego Cardozo  and
      Freire, Felipe  and
      Paraboni, Ivandr{\'e}",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4824",
}
@inproceedings{hilgert-vieira-2013-extracao,
    title = "Extra{\c{c}}{\~a}o de Vocabul{\'a}rio Multil{\'\i}ngue para Tradu{\c{c}}{\~a}o em Dom{\'\i}nios Especializados (Multilingual Vocabulary Extraction for Machine Translation in Specialized Domains) [in {P}ortuguese]",
    author = "Hilgert, Lucas Welter  and
      Vieira, Renata",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4825",
}
@inproceedings{martins-2013-corpus,
    title = "Corpus-amostra Coelho Netto: compila{\c{c}}{\~a}o, anota{\c{c}}{\~a}o e ocorr{\^e}ncias em textos liter{\'a}rios dos s{\'e}c. {XIX} e {XX} (Corpus-sample Coelho Netto: Compilation, Annotation and Occurrences in Literary Texts from {XIX} and {XX} Centuries) [in {P}ortuguese]",
    author = "Martins, Francimary Mac{\^e}do",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4826",
}
@inproceedings{proenca-etal-2013-acoustic,
    title = "Acoustic, Phonetic and Prosodic Features of {P}arkinson{'}s disease Speech",
    author = "Proen{\c{c}}a, Jorge  and
      Veiga, Arlindo  and
      Candeias, Sara  and
      Perdig{\~a}o, Fernando",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4827",
}
@inproceedings{pazzini-etal-2013-classificacao,
    title = "Classifica{\c{c}}{\~a}o de Prioridade de Tweets utilizando M{\'a}quinas de Vetor de Suporte (Tweet Priority Classification Using Support Vector Machines) [in {P}ortuguese]",
    author = "Pazzini, Vin{\'\i}cius  and
      Schenkel, Tiago  and
      Poetsch, Mikael  and
      Araujo, Ricardo Matsumura",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4828",
}
@inproceedings{filho-etal-2013-evaluation,
    title = "An Evaluation of the {B}razilian {P}ortuguese {LIWC} Dictionary for Sentiment Analysis",
    author = "Filho, Pedro P. Balage  and
      Pardo, Thiago Alexandre Salgueiro  and
      Alu{\'\i}sio, Sandra M.",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4829",
}
@inproceedings{mendes-etal-2013-uma,
    title = "Uma investiga{\c{c}}{\~a}o no apoio da avalia{\c{c}}{\~a}o da usabilidade em Sistemas Sociais usando Processamento da Linguagem Natural (An Investigation on the Support of the Usability Evaluation in Social Systems Using Natural Language Processing) [in {P}ortuguese]",
    author = "Mendes, Mar{\'\i}lia S.  and
      Furtado, Elizabeth  and
      Franklin, Miguel",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4830",
}
@inproceedings{filho-etal-2013-uma,
    title = "Uma Ferramenta para Projeto de Sistemas de Di{\'a}logos para Call Center Baseados em Asterisk (A Tool for the Design of Dialog Systems for Asterisk-based Call Centers) [in {P}ortuguese]",
    author = "Filho, Estillac Borges  and
      Batista, Pedro  and
      Klautau, Aldebaro",
    booktitle = "Proceedings of the 9th {B}razilian Symposium in Information and Human Language Technology",
    year = "2013",
    url = "https://www.aclweb.org/anthology/W13-4831",
}

repository: emorynlp/nlprankings

repo_name: emorynlp/nlprankings


text:
require xorg-app-common.inc
DEPENDS += " xcb-util"
PE = "1"
PR = "${INC_PR}.0"

# missing file from source archive, fixed just after release in http://cgit.freedesktop.org/xorg/app/xlsclients/commit/?id=f30f41b8dc37e775279835c97f2bea83a513dc10
SRC_URI += "file://strnlen.h"
SRC_URI[archive.md5sum] = "550a0fee047c5043f2cbf190b41f8a1b"
SRC_URI[archive.sha256sum] = "f95b51f55399f46ce5f597a68ccd04a0d68c5770b517428201262bff09bcfa0c"

do_compile_prepend() {
  mv ${WORKDIR}/strnlen.h ${S}
}

license: MIT

repository: libo/openembedded

license_type: permissive

repo_name: libo/openembedded

branch_name: HEAD

extension: bb


text:
// Copyright 2016 The Gosl Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// +build ignore

package main

import (
	"testing"

	"github.com/cpmech/gosl/chk"
	"github.com/cpmech/gosl/io"
	"github.com/cpmech/gosl/mpi"
)

func main() {

	mpi.Start()
	defer mpi.Stop()

	if mpi.WorldRank() == 0 {
		io.Pf("\n\n------------------ Test MPI 02 ------------------\n\n")
	}
	if mpi.WorldSize() != 3 {
		chk.Panic("this test needs 3 processors")
	}

	var myints []int
	var mydbls []float64
	switch mpi.WorldRank() {
	case 1:
		myints = []int{1, 2, 3, 4}
		mydbls = []float64{-1, -2, -3}
	case 2:
		myints = []int{20, 30, 40, 50, 60}
		mydbls = []float64{-20, -50}
	}

	comm := mpi.NewCommunicator(nil)

	if mpi.WorldRank() == 0 {
		v1 := make([]int, mpi.WorldSize())
		v2 := make([]int, mpi.WorldSize())
		allints := []int{}
		alldbls := []float64{}
		for proc := 1; proc < int(mpi.WorldSize()); proc++ {

			// RecvOneI
			val := comm.RecvOneI(proc)
			io.Pf("root received val=%d from proc=%d\n", val, proc)
			v1[proc] = val
			val = comm.RecvOneI(proc)
			io.Pf("root received val=%d from proc=%d\n", val, proc)
			v2[proc] = val

			// RecvI
			n := comm.RecvOneI(proc)
			io.Pf("root received n=%d from proc=%d\n", n, proc)
			ints := make([]int, n)
			comm.RecvI(ints, proc)
			io.Pf("root received ints=%v from proc=%d\n", ints, proc)
			allints = append(allints, ints...)

			// Recv
			n = comm.RecvOneI(proc)
			io.Pf("root received n=%d from proc=%d\n", n, proc)
			dbls := make([]float64, n)
			comm.Recv(dbls, proc)
			io.Pf("root received dbls=%v from proc=%d\n", dbls, proc)
			alldbls = append(alldbls, dbls...)
		}

		// check
		chk.Verbose = true
		var tst testing.T
		chk.Ints(&tst, "SingleIntRecv: vals", v1, []int{0, 1001, 1002})
		chk.Ints(&tst, "SingleIntRecv: vals", v2, []int{0, 2001, 2002})
		chk.Ints(&tst, "IntRecv: allints", allints, []int{1, 2, 3, 4, 20, 30, 40, 50, 60})
		chk.Array(&tst, "IntRecv: alldbls", 1e-17, alldbls, []float64{-1, -2, -3, -20, -50})

	} else {

		// SendOneI
		comm.SendOneI(1000+mpi.WorldRank(), 0)
		comm.SendOneI(2000+mpi.WorldRank(), 0)

		// SendI
		comm.SendOneI(len(myints), 0)
		comm.SendI(myints, 0)

		// Send
		comm.SendOneI(len(mydbls), 0)
		comm.Send(mydbls, 0)
	}
}

repository: EXAPPAI/gosl

repo_name: EXAPPAI/gosl

branch_name: refs/heads/main

extension: go


text:
package chapter15

import "testing"

var longestNondecreasingSubsequenceTests = []struct {
	arr      []int
	expected int
}{
	{[]int{0, 8, 4, 12, 2, 10, 6, 14, 1, 9}, 4},
	{[]int{1, 2, 3, 4}, 4},
	{[]int{2, 3, 1, 6}, 3},
	{[]int{8, 3, 1}, 1},
}

func TestLongestNondecreasingSubsequence(t *testing.T) {
	for _, tt := range longestNondecreasingSubsequenceTests {
		actual := LongestNondecreasingSubsequence(tt.arr)
		if actual != tt.expected {
			t.Errorf("LongestNondecreasingSubsequence(%v): expected %d, actual %d",
				tt.arr, tt.expected, actual)
		}
	}
}

branch_name: refs/heads/master


text:
FILE(REMOVE_RECURSE
  "CMakeFiles/boost_wave-mt-static-debug.dir/instantiate_cpp_exprgrammar.cpp.o"
  "CMakeFiles/boost_wave-mt-static-debug.dir/instantiate_cpp_grammar.cpp.o"
  "CMakeFiles/boost_wave-mt-static-debug.dir/instantiate_cpp_literalgrs.cpp.o"
  "CMakeFiles/boost_wave-mt-static-debug.dir/instantiate_defined_grammar.cpp.o"
  "CMakeFiles/boost_wave-mt-static-debug.dir/instantiate_predef_macros.cpp.o"
  "CMakeFiles/boost_wave-mt-static-debug.dir/instantiate_re2c_lexer.cpp.o"
  "CMakeFiles/boost_wave-mt-static-debug.dir/instantiate_re2c_lexer_str.cpp.o"
  "CMakeFiles/boost_wave-mt-static-debug.dir/token_ids.cpp.o"
  "CMakeFiles/boost_wave-mt-static-debug.dir/wave_config_constant.cpp.o"
  "CMakeFiles/boost_wave-mt-static-debug.dir/cpplexer/re2clex/aq.cpp.o"
  "CMakeFiles/boost_wave-mt-static-debug.dir/cpplexer/re2clex/cpp_re.cpp.o"
  "../../../lib/libboost_wave-mt-d.a"
)

# Per-language clean rules from dependency scanning.
FOREACH(lang CXX)
  INCLUDE(CMakeFiles/boost_wave-mt-static-debug.dir/cmake_clean_${lang}.cmake OPTIONAL)
ENDFOREACH(lang)

extension: cmake


text:
package main

import (
	"context"
	"flag"

	"os"
	"os/signal"
	"time"

	"github.com/yylt/rtspmux/pkg"
	"github.com/cenkalti/backoff/v4"
	"k8s.io/klog/v2"
)

const (
	MaxRetryM3u8Count = 10
)

var (
	ctx    context.Context
	cancle func()
)

func mergeWorker(ctx context.Context, mg *pkg.Merger, ch <-chan *pkg.DlItem) {
	var (
		cache = make(map[int64]struct{})
		err   error
	)
	for {
		select {
		case <-ctx.Done():
			return
		case v, ok := <-ch:
			if !ok {
				return
			}
			vt := v.Time()
			_, exist := cache[vt]
			if exist {
				continue
			}
			cache[vt] = struct{}{}

			err = mg.Merge(v)
			if err != nil {
				_, ishad := err.(*pkg.HadMergedError)
				if ishad {
					klog.Infof("item had merged, path:%v, time:%d", v.Path(), v.Time())
					continue
				}
				klog.Errorf("merge failed:%v, path:%v, time:%d", err, v.Path(), v.Time())
				continue
			}
			klog.Infof("merge success, path:%v, time:%d", v.Path(), v.Time())
		}
	}
}

func downloadWorker(ctx context.Context, m3u8url string, interval time.Duration, ch chan *pkg.Item) {
	var (
		cache = make(map[int64]struct{})
		err   error

		ebk = backoff.WithMaxRetries(backoff.NewExponentialBackOff(), MaxRetryM3u8Count)
	)

	for {
		select {
		case <-ctx.Done():
			return
		case <-time.NewTimer(interval).C:
			err = backoff.Retry(func() error {
				m38, err := pkg.Open(m3u8url)
				if err != nil {
					klog.Errorf("open url %v failed:%v", m3u8url, err)
					return err
				}
				return m38.Iter(func(i *pkg.Item) error {
					tu := i.Time().Unix()
					_, ok := cache[tu]
					if ok {
						return nil
					}
					cache[tu] = struct{}{}
					ch <- i
					return nil
				})
			}, ebk)
			if err != nil {
				panic(err)
			}
		}
	}
}

func main() {
	u8url := flag.String("m3u8", "", "m3u8 url address, mostly http://xxx or https://xxx ")
	workernum := flag.Int("workers", 5, "download worker number")
	fetchInterval := flag.Duration("feetch-interval", time.Second*2, "fetch m3u8 interval")
	mergeInterval := flag.Duration("merge-interval", time.Millisecond*300, "merge item interval, which is check directory duration")
	maxMbsize := flag.Int64("mb-max-size", 300, "the max Mb size in one merged file")
	dir := flag.String("dir", "/opt/dlm3u", "which directory saved all files")

	klog.InitFlags(flag.CommandLine)
	flag.Parse()
	done := make(chan struct{})

	ctx, cancle = context.WithCancel(context.Background())

	mr := pkg.NewMerge(ctx, *maxMbsize, *dir)
	dl := pkg.NewDownload(ctx, *workernum, *dir)
	dlitem := make(chan *pkg.Item, 16)

	rcvch := dl.Start(*mergeInterval, dlitem)

	go downloadWorker(ctx, *u8url, *fetchInterval, dlitem)
	go mergeWorker(ctx, mr, rcvch)

	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)
	go func() {
		<-c
		klog.Infof("graceful exit...")
		cancle()
		close(done)
	}()
	<-done
}

repository: yylt/rtspmux

repo_name: yylt/rtspmux


text:
@article{leshuk_petroleomic_2018,
	title = {Petroleomic analysis of the treatment of naphthenic organics in oil sands process-affected water with buoyant photocatalysts},
	volume = {141},
	issn = {0043-1354},
	url = {http://www.sciencedirect.com/science/article/pii/S0043135418303737},
	doi = {10.1016/j.watres.2018.05.011},
	abstract = {The persistence of toxicity associated with the soluble naphthenic organic compounds (NOCs) of oil sands process-affected water (OSPW) implies that a treatment solution may be necessary to enable safe return of this water to the environment. Due to recent advances in high-resolution mass spectrometry (HRMS), the majority of the toxicity of OSPW is currently understood to derive from a subset of toxic classes, comprising only a minority of the total NOCs. Herein, oxidative treatment of OSPW with buoyant photocatalysts was evaluated under a petroleomics paradigm: chemical changes across acid-, base- and neutral-extractable organic fractions were tracked throughout the treatment with both positive and negative ion mode electrospray ionization (ESI) Orbitrap MS. Elimination of detected OS+ and NO+ classes of concern in the earliest stages of the treatment, along with preferential degradation of high carbon-numbered O2− acids, suggest that photocatalysis may detoxify OSPW with higher efficiency than previously thought. Application of petroleomic level analysis offers unprecedented insights into the treatment of petroleum impacted water, allowing reaction trends to be followed across multiple fractions and thousands of compounds simultaneously.},
	urldate = {2018-11-21},
	journal = {Water Research},
	author = {Leshuk, Tim and Peru, Kerry M. and de Oliveira Livera, Diogo and Tripp, Austin and Bardo, Patrick and Headley, John V. and Gu, Frank},
	month = sep,
	year = {2018},
	keywords = {Advanced oxidation process, Floating, Naphthenic acid, Passive, Positive ion, Titanium dioxide},
	pages = {297--306}
}

repository: AustinT/latex-templates

repo_name: AustinT/latex-templates

extension: bib


text:
package goflow

import (
	"testing"
)

func TestDag(t *testing.T) {
	d := make(dag)

	d.addNode("a")
	d.addNode("b")
	d.addNode("c")
	d.addNode("d")
	d.setDownstream("a", "b")
	d.setDownstream("a", "c")
	d.setDownstream("b", "d")
	d.setDownstream("c", "d")

	if !d.validate() {
		t.Errorf("Valid dag failed validation check")
	}

	if !equal(d.dependencies("b"), []string{"a"}) {
		t.Errorf("d.dependencies() returned %s, expected %s",
			d.dependencies("b"),
			[]string{"a"})
	}

	if !equal(d.independentNodes(), []string{"a"}) {
		t.Errorf("d.independentNodes() returned %s, expected %s",
			d.dependencies("b"),
			[]string{"a"})
	}

	e := make(dag)

	e.addNode("a")
	e.addNode("b")
	e.setDownstream("a", "b")
	e.setDownstream("b", "a")

	if e.validate() {
		t.Errorf("Invalid dag passed validation check")
	}
}

func TestDagWithSingleNode(t *testing.T) {
	d := make(dag)
	d.addNode("a")
	res := d.isDownstream("a")

	if res {
		t.Errorf("isDownstream() returned true for an independent node")
	}

}

repository: fieldryand/goflow

repo_name: fieldryand/goflow

gha_license_id: MIT

gha_language: Go


text:
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: configurator.proto

package protos

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import protos "magma/orc8r/cloud/go/protos"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// 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.ProtoPackageIsVersion2 // please upgrade the proto package

// Magmad gateway configuration
type MagmadGatewayConfig struct {
	// Interval for the gateways to send checkin rpc calls to the cloud.
	CheckinInterval int32 `protobuf:"varint,1,opt,name=checkin_interval,json=checkinInterval,proto3" json:"checkin_interval,omitempty"`
	// Checkin rpc timeout
	CheckinTimeout int32 `protobuf:"varint,2,opt,name=checkin_timeout,json=checkinTimeout,proto3" json:"checkin_timeout,omitempty"`
	// Enables autoupgrading of the magma package
	AutoupgradeEnabled bool `protobuf:"varint,3,opt,name=autoupgrade_enabled,json=autoupgradeEnabled,proto3" json:"autoupgrade_enabled,omitempty"`
	// Interval to poll for package upgrades
	AutoupgradePollInterval int32 `protobuf:"varint,4,opt,name=autoupgrade_poll_interval,json=autoupgradePollInterval,proto3" json:"autoupgrade_poll_interval,omitempty"`
	// The tier the gateway belongs in
	Tier string `protobuf:"bytes,5,opt,name=tier,proto3" json:"tier,omitempty"`
	// Feature flags which turn off/on new features for limited roll-out
	FeatureFlags map[string]bool `protobuf:"bytes,6,rep,name=feature_flags,json=featureFlags,proto3" json:"feature_flags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	// List of dynamic_services
	DynamicServices      []string `protobuf:"bytes,7,rep,name=dynamic_services,json=dynamicServices,proto3" json:"dynamic_services,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MagmadGatewayConfig proto.InternalMessageInfo

func (m *MagmadGatewayConfig) GetCheckinInterval() int32 {
	if m != nil {
		return m.CheckinInterval
	}
	return 0
}

func (m *MagmadGatewayConfig) GetCheckinTimeout() int32 {
	if m != nil {
		return m.CheckinTimeout
	}
	return 0
}

func (m *MagmadGatewayConfig) GetAutoupgradeEnabled() bool {
	if m != nil {
		return m.AutoupgradeEnabled
	}
	return false
}

func (m *MagmadGatewayConfig) GetAutoupgradePollInterval() int32 {
	if m != nil {
		return m.AutoupgradePollInterval
	}
	return 0
}

func (m *MagmadGatewayConfig) GetTier() string {
	if m != nil {
		return m.Tier
	}
	return ""
}

func (m *MagmadGatewayConfig) GetFeatureFlags() map[string]bool {
	if m != nil {
		return m.FeatureFlags
	}
	return nil
}

func (m *MagmadGatewayConfig) GetDynamicServices() []string {
	if m != nil {
		return m.DynamicServices
	}
	return nil
}

// Network entity to be stored in networks table. Name is required.
type MagmadNetworkRecord struct {
	Name                 string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Features             map[string]string `protobuf:"bytes,2,rep,name=features,proto3" json:"features,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 *MagmadNetworkRecord) Reset()         { *m = MagmadNetworkRecord{} }
func (m *MagmadNetworkRecord) String() string { return proto.CompactTextString(m) }
func (*MagmadNetworkRecord) ProtoMessage()    {}
func (*MagmadNetworkRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_configurator_2d5fb78b6d60bdd8, []int{1}
}
func (m *MagmadNetworkRecord) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MagmadNetworkRecord.Unmarshal(m, b)
}
func (m *MagmadNetworkRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MagmadNetworkRecord.Marshal(b, m, deterministic)
}
func (dst *MagmadNetworkRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MagmadNetworkRecord.Merge(dst, src)
}
func (m *MagmadNetworkRecord) XXX_Size() int {
	return xxx_messageInfo_MagmadNetworkRecord.Size(m)
}
func (m *MagmadNetworkRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_MagmadNetworkRecord.DiscardUnknown(m)
}

var xxx_messageInfo_MagmadNetworkRecord proto.InternalMessageInfo

func (m *MagmadNetworkRecord) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *MagmadNetworkRecord) GetFeatures() map[string]string {
	if m != nil {
		return m.Features
	}
	return nil
}

type NetworkRecordRequest struct {
	Record               *MagmadNetworkRecord `protobuf:"bytes,1,opt,name=record,proto3" json:"record,omitempty"`
	Id                   string               `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

var xxx_messageInfo_NetworkRecordRequest proto.InternalMessageInfo

func (m *NetworkRecordRequest) GetRecord() *MagmadNetworkRecord {
	if m != nil {
		return m.Record
	}
	return nil
}

func (m *NetworkRecordRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type AccessGatewayRecord struct {
	HwId *protos.AccessGatewayID `protobuf:"bytes,1,opt,name=hw_id,json=hwId,proto3" json:"hw_id,omitempty"`
	Name string                  `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	Key  *protos.ChallengeKey    `protobuf:"bytes,5,opt,name=key,proto3" json:"key,omitempty"`
	// DEPRECATED
	Ip                   string   `protobuf:"bytes,2,opt,name=ip,proto3" json:"ip,omitempty"`
	Port                 int32    `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AccessGatewayRecord proto.InternalMessageInfo

func (m *AccessGatewayRecord) GetHwId() *protos.AccessGatewayID {
	if m != nil {
		return m.HwId
	}
	return nil
}

func (m *AccessGatewayRecord) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *AccessGatewayRecord) GetKey() *protos.ChallengeKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *AccessGatewayRecord) GetIp() string {
	if m != nil {
		return m.Ip
	}
	return ""
}

func (m *AccessGatewayRecord) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

type GatewayRecordRequest struct {
	GatewayId            *protos.Identity     `protobuf:"bytes,1,opt,name=gatewayId,proto3" json:"gatewayId,omitempty"`
	Record               *AccessGatewayRecord `protobuf:"bytes,2,opt,name=record,proto3" json:"record,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

var xxx_messageInfo_GatewayRecordRequest proto.InternalMessageInfo

func (m *GatewayRecordRequest) GetGatewayId() *protos.Identity {
	if m != nil {
		return m.GatewayId
	}
	return nil
}

func (m *GatewayRecordRequest) GetRecord() *AccessGatewayRecord {
	if m != nil {
		return m.Record
	}
	return nil
}

type MarshaledConfigs struct {
	Configs              []byte   `protobuf:"bytes,2,opt,name=configs,proto3" json:"configs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MarshaledConfigs proto.InternalMessageInfo

func (m *MarshaledConfigs) GetConfigs() []byte {
	if m != nil {
		return m.Configs
	}
	return nil
}

type GatewayConfigsRequestKey struct {
	GatewayId            *protos.Identity `protobuf:"bytes,1,opt,name=gatewayId,proto3" json:"gatewayId,omitempty"`
	ConfigKey            string           `protobuf:"bytes,2,opt,name=configKey,proto3" json:"configKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_GatewayConfigsRequestKey proto.InternalMessageInfo

func (m *GatewayConfigsRequestKey) GetGatewayId() *protos.Identity {
	if m != nil {
		return m.GatewayId
	}
	return nil
}

func (m *GatewayConfigsRequestKey) GetConfigKey() string {
	if m != nil {
		return m.ConfigKey
	}
	return ""
}

type GatewayConfigsRequest struct {
	Key                  *GatewayConfigsRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Configs              *MarshaledConfigs         `protobuf:"bytes,2,opt,name=configs,proto3" json:"configs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

var xxx_messageInfo_GatewayConfigsRequest proto.InternalMessageInfo

func (m *GatewayConfigsRequest) GetKey() *GatewayConfigsRequestKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *GatewayConfigsRequest) GetConfigs() *MarshaledConfigs {
	if m != nil {
		return m.Configs
	}
	return nil
}

type NetworkConfigRequestKey struct {
	NetworkId            *protos.Identity `protobuf:"bytes,1,opt,name=networkId,proto3" json:"networkId,omitempty"`
	ConfigKey            string           `protobuf:"bytes,2,opt,name=configKey,proto3" json:"configKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_NetworkConfigRequestKey proto.InternalMessageInfo

func (m *NetworkConfigRequestKey) GetNetworkId() *protos.Identity {
	if m != nil {
		return m.NetworkId
	}
	return nil
}

func (m *NetworkConfigRequestKey) GetConfigKey() string {
	if m != nil {
		return m.ConfigKey
	}
	return ""
}

type NetworkConfigRequest struct {
	Key                  *NetworkConfigRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Configs              *MarshaledConfigs        `protobuf:"bytes,2,opt,name=configs,proto3" json:"configs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

var xxx_messageInfo_NetworkConfigRequest proto.InternalMessageInfo

func (m *NetworkConfigRequest) GetKey() *NetworkConfigRequestKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *NetworkConfigRequest) GetConfigs() *MarshaledConfigs {
	if m != nil {
		return m.Configs
	}
	return nil
}

func init() {
	proto.RegisterType((*MagmadGatewayConfig)(nil), "magma.orc8r.magmad.MagmadGatewayConfig")
	proto.RegisterMapType((map[string]bool)(nil), "magma.orc8r.magmad.MagmadGatewayConfig.FeatureFlagsEntry")
	proto.RegisterType((*MagmadNetworkRecord)(nil), "magma.orc8r.magmad.MagmadNetworkRecord")
	proto.RegisterMapType((map[string]string)(nil), "magma.orc8r.magmad.MagmadNetworkRecord.FeaturesEntry")
	proto.RegisterType((*NetworkRecordRequest)(nil), "magma.orc8r.magmad.NetworkRecordRequest")
	proto.RegisterType((*AccessGatewayRecord)(nil), "magma.orc8r.magmad.AccessGatewayRecord")
	proto.RegisterType((*GatewayRecordRequest)(nil), "magma.orc8r.magmad.GatewayRecordRequest")
	proto.RegisterType((*MarshaledConfigs)(nil), "magma.orc8r.magmad.MarshaledConfigs")
	proto.RegisterType((*GatewayConfigsRequestKey)(nil), "magma.orc8r.magmad.GatewayConfigsRequestKey")
	proto.RegisterType((*GatewayConfigsRequest)(nil), "magma.orc8r.magmad.GatewayConfigsRequest")
	proto.RegisterType((*NetworkConfigRequestKey)(nil), "magma.orc8r.magmad.NetworkConfigRequestKey")
	proto.RegisterType((*NetworkConfigRequest)(nil), "magma.orc8r.magmad.NetworkConfigRequest")
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// MagmadConfiguratorClient is the client API for MagmadConfigurator service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MagmadConfiguratorClient interface {
	// RegisterGateway adds new records for AG with HW ID specified by
	// record.hw_id into all corresponding tables using gatewayId.logical_id as
	// the the newly registered gateway's logical ID, initializes the newly
	// created AG's configs to defaults
	// Will return error if a device with the given HW ID or requested by
	// gatewayId.logical_id logical id is already registered if
	// gatewayId.logical_id is empty - will register the network with a new
	// unique ID
	RegisterGateway(ctx context.Context, in *GatewayRecordRequest, opts ...grpc.CallOption) (*protos.Identity, error)
	// Lists all registered logical device Identities for the network specified
	// by Identity parameter
	ListGateways(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*protos.Identity_List, error)
	// FindGatewayId returns AG Identity with set logical_id
	// (Identity.Gateway.logical_id) for the given
	// registered HW Id (Identity.Gateway.hardware_id) on the network
	// (Identity.Gateway.network_id)
	FindGatewayId(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*protos.Identity, error)
	// FindGatewayRecord returns AG Record for a given registered logical ID
	// (Identity:Gateway.logical_id)
	FindGatewayRecord(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*AccessGatewayRecord, error)
	// Finds and Updates the GW record, the record's HwId must be either omitted
	// or must match the GW's registered HW ID, the HwId is not mutable
	UpdateGatewayRecord(ctx context.Context, in *GatewayRecordRequest, opts ...grpc.CallOption) (*protos.Void, error)
	// FindGatewayNetworkId returns Network Id of the network, the Gatway HW ID
	// is registered on
	FindGatewayNetworkId(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*protos.Identity, error)
	// RemoveGateway deletes all logical device & corresponding HW ID records &
	// configs and effectively performs de-registration of the AG with the cloud
	RemoveGateway(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*protos.Void, error)
	// RegisterNetwork registers new network with ID specified by
	// NetworkRecordRequest.networkId, it will return error if the network with
	// the ID already exist
	// RegisterNetwork Returns the registered network Identity
	// If NetworkRecordRequest.networkId is not set, RegisterNetwork will
	// generate a new, unique network ID and use it for registration
	RegisterNetwork(ctx context.Context, in *NetworkRecordRequest, opts ...grpc.CallOption) (*protos.Identity, error)
	// ListNetworks returns a list of all registered network Identities
	ListNetworks(ctx context.Context, in *protos.Void, opts ...grpc.CallOption) (*protos.Identity_List, error)
	// Returns the network record for a network ID
	GetNetwork(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*MagmadNetworkRecord, error)
	// Deletes given network if its Gateway & Subscriber tables are empty
	RemoveNetwork(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*protos.Void, error)
	// Update a network record
	UpdateNetwork(ctx context.Context, in *NetworkRecordRequest, opts ...grpc.CallOption) (*protos.Void, error)
	// Deletes given network and its Gateway & Subscriber tables
	ForceRemoveNetwork(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*protos.Void, error)
}

type magmadConfiguratorClient struct {
	cc *grpc.ClientConn
}

func NewMagmadConfiguratorClient(cc *grpc.ClientConn) MagmadConfiguratorClient {
	return &magmadConfiguratorClient{cc}
}

func (c *magmadConfiguratorClient) RegisterGateway(ctx context.Context, in *GatewayRecordRequest, opts ...grpc.CallOption) (*protos.Identity, error) {
	out := new(protos.Identity)
	err := c.cc.Invoke(ctx, "/magma.orc8r.magmad.MagmadConfigurator/RegisterGateway", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *magmadConfiguratorClient) ListGateways(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*protos.Identity_List, error) {
	out := new(protos.Identity_List)
	err := c.cc.Invoke(ctx, "/magma.orc8r.magmad.MagmadConfigurator/ListGateways", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *magmadConfiguratorClient) FindGatewayId(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*protos.Identity, error) {
	out := new(protos.Identity)
	err := c.cc.Invoke(ctx, "/magma.orc8r.magmad.MagmadConfigurator/FindGatewayId", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *magmadConfiguratorClient) FindGatewayRecord(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*AccessGatewayRecord, error) {
	out := new(AccessGatewayRecord)
	err := c.cc.Invoke(ctx, "/magma.orc8r.magmad.MagmadConfigurator/FindGatewayRecord", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *magmadConfiguratorClient) UpdateGatewayRecord(ctx context.Context, in *GatewayRecordRequest, opts ...grpc.CallOption) (*protos.Void, error) {
	out := new(protos.Void)
	err := c.cc.Invoke(ctx, "/magma.orc8r.magmad.MagmadConfigurator/UpdateGatewayRecord", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *magmadConfiguratorClient) FindGatewayNetworkId(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*protos.Identity, error) {
	out := new(protos.Identity)
	err := c.cc.Invoke(ctx, "/magma.orc8r.magmad.MagmadConfigurator/FindGatewayNetworkId", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *magmadConfiguratorClient) RemoveGateway(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*protos.Void, error) {
	out := new(protos.Void)
	err := c.cc.Invoke(ctx, "/magma.orc8r.magmad.MagmadConfigurator/RemoveGateway", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *magmadConfiguratorClient) RegisterNetwork(ctx context.Context, in *NetworkRecordRequest, opts ...grpc.CallOption) (*protos.Identity, error) {
	out := new(protos.Identity)
	err := c.cc.Invoke(ctx, "/magma.orc8r.magmad.MagmadConfigurator/RegisterNetwork", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *magmadConfiguratorClient) ListNetworks(ctx context.Context, in *protos.Void, opts ...grpc.CallOption) (*protos.Identity_List, error) {
	out := new(protos.Identity_List)
	err := c.cc.Invoke(ctx, "/magma.orc8r.magmad.MagmadConfigurator/ListNetworks", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *magmadConfiguratorClient) GetNetwork(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*MagmadNetworkRecord, error) {
	out := new(MagmadNetworkRecord)
	err := c.cc.Invoke(ctx, "/magma.orc8r.magmad.MagmadConfigurator/GetNetwork", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *magmadConfiguratorClient) RemoveNetwork(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*protos.Void, error) {
	out := new(protos.Void)
	err := c.cc.Invoke(ctx, "/magma.orc8r.magmad.MagmadConfigurator/RemoveNetwork", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *magmadConfiguratorClient) UpdateNetwork(ctx context.Context, in *NetworkRecordRequest, opts ...grpc.CallOption) (*protos.Void, error) {
	out := new(protos.Void)
	err := c.cc.Invoke(ctx, "/magma.orc8r.magmad.MagmadConfigurator/UpdateNetwork", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *magmadConfiguratorClient) ForceRemoveNetwork(ctx context.Context, in *protos.Identity, opts ...grpc.CallOption) (*protos.Void, error) {
	out := new(protos.Void)
	err := c.cc.Invoke(ctx, "/magma.orc8r.magmad.MagmadConfigurator/ForceRemoveNetwork", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MagmadConfiguratorServer is the server API for MagmadConfigurator service.
type MagmadConfiguratorServer interface {
	// RegisterGateway adds new records for AG with HW ID specified by
	// record.hw_id into all corresponding tables using gatewayId.logical_id as
	// the the newly registered gateway's logical ID, initializes the newly
	// created AG's configs to defaults
	// Will return error if a device with the given HW ID or requested by
	// gatewayId.logical_id logical id is already registered if
	// gatewayId.logical_id is empty - will register the network with a new
	// unique ID
	RegisterGateway(context.Context, *GatewayRecordRequest) (*protos.Identity, error)
	// Lists all registered logical device Identities for the network specified
	// by Identity parameter
	ListGateways(context.Context, *protos.Identity) (*protos.Identity_List, error)
	// FindGatewayId returns AG Identity with set logical_id
	// (Identity.Gateway.logical_id) for the given
	// registered HW Id (Identity.Gateway.hardware_id) on the network
	// (Identity.Gateway.network_id)
	FindGatewayId(context.Context, *protos.Identity) (*protos.Identity, error)
	// FindGatewayRecord returns AG Record for a given registered logical ID
	// (Identity:Gateway.logical_id)
	FindGatewayRecord(context.Context, *protos.Identity) (*AccessGatewayRecord, error)
	// Finds and Updates the GW record, the record's HwId must be either omitted
	// or must match the GW's registered HW ID, the HwId is not mutable
	UpdateGatewayRecord(context.Context, *GatewayRecordRequest) (*protos.Void, error)
	// FindGatewayNetworkId returns Network Id of the network, the Gatway HW ID
	// is registered on
	FindGatewayNetworkId(context.Context, *protos.Identity) (*protos.Identity, error)
	// RemoveGateway deletes all logical device & corresponding HW ID records &
	// configs and effectively performs de-registration of the AG with the cloud
	RemoveGateway(context.Context, *protos.Identity) (*protos.Void, error)
	// RegisterNetwork registers new network with ID specified by
	// NetworkRecordRequest.networkId, it will return error if the network with
	// the ID already exist
	// RegisterNetwork Returns the registered network Identity
	// If NetworkRecordRequest.networkId is not set, RegisterNetwork will
	// generate a new, unique network ID and use it for registration
	RegisterNetwork(context.Context, *NetworkRecordRequest) (*protos.Identity, error)
	// ListNetworks returns a list of all registered network Identities
	ListNetworks(context.Context, *protos.Void) (*protos.Identity_List, error)
	// Returns the network record for a network ID
	GetNetwork(context.Context, *protos.Identity) (*MagmadNetworkRecord, error)
	// Deletes given network if its Gateway & Subscriber tables are empty
	RemoveNetwork(context.Context, *protos.Identity) (*protos.Void, error)
	// Update a network record
	UpdateNetwork(context.Context, *NetworkRecordRequest) (*protos.Void, error)
	// Deletes given network and its Gateway & Subscriber tables
	ForceRemoveNetwork(context.Context, *protos.Identity) (*protos.Void, error)
}

func RegisterMagmadConfiguratorServer(s *grpc.Server, srv MagmadConfiguratorServer) {
	s.RegisterService(&_MagmadConfigurator_serviceDesc, srv)
}

func _MagmadConfigurator_RegisterGateway_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GatewayRecordRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MagmadConfiguratorServer).RegisterGateway(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.orc8r.magmad.MagmadConfigurator/RegisterGateway",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MagmadConfiguratorServer).RegisterGateway(ctx, req.(*GatewayRecordRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MagmadConfigurator_ListGateways_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(protos.Identity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MagmadConfiguratorServer).ListGateways(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.orc8r.magmad.MagmadConfigurator/ListGateways",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MagmadConfiguratorServer).ListGateways(ctx, req.(*protos.Identity))
	}
	return interceptor(ctx, in, info, handler)
}

func _MagmadConfigurator_FindGatewayId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(protos.Identity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MagmadConfiguratorServer).FindGatewayId(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.orc8r.magmad.MagmadConfigurator/FindGatewayId",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MagmadConfiguratorServer).FindGatewayId(ctx, req.(*protos.Identity))
	}
	return interceptor(ctx, in, info, handler)
}

func _MagmadConfigurator_FindGatewayRecord_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(protos.Identity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MagmadConfiguratorServer).FindGatewayRecord(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.orc8r.magmad.MagmadConfigurator/FindGatewayRecord",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MagmadConfiguratorServer).FindGatewayRecord(ctx, req.(*protos.Identity))
	}
	return interceptor(ctx, in, info, handler)
}

func _MagmadConfigurator_UpdateGatewayRecord_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GatewayRecordRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MagmadConfiguratorServer).UpdateGatewayRecord(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.orc8r.magmad.MagmadConfigurator/UpdateGatewayRecord",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MagmadConfiguratorServer).UpdateGatewayRecord(ctx, req.(*GatewayRecordRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MagmadConfigurator_FindGatewayNetworkId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(protos.Identity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MagmadConfiguratorServer).FindGatewayNetworkId(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.orc8r.magmad.MagmadConfigurator/FindGatewayNetworkId",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MagmadConfiguratorServer).FindGatewayNetworkId(ctx, req.(*protos.Identity))
	}
	return interceptor(ctx, in, info, handler)
}

func _MagmadConfigurator_RemoveGateway_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(protos.Identity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MagmadConfiguratorServer).RemoveGateway(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.orc8r.magmad.MagmadConfigurator/RemoveGateway",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MagmadConfiguratorServer).RemoveGateway(ctx, req.(*protos.Identity))
	}
	return interceptor(ctx, in, info, handler)
}

func _MagmadConfigurator_RegisterNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkRecordRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MagmadConfiguratorServer).RegisterNetwork(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.orc8r.magmad.MagmadConfigurator/RegisterNetwork",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MagmadConfiguratorServer).RegisterNetwork(ctx, req.(*NetworkRecordRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MagmadConfigurator_ListNetworks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(protos.Void)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MagmadConfiguratorServer).ListNetworks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.orc8r.magmad.MagmadConfigurator/ListNetworks",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MagmadConfiguratorServer).ListNetworks(ctx, req.(*protos.Void))
	}
	return interceptor(ctx, in, info, handler)
}

func _MagmadConfigurator_GetNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(protos.Identity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MagmadConfiguratorServer).GetNetwork(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.orc8r.magmad.MagmadConfigurator/GetNetwork",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MagmadConfiguratorServer).GetNetwork(ctx, req.(*protos.Identity))
	}
	return interceptor(ctx, in, info, handler)
}

func _MagmadConfigurator_RemoveNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(protos.Identity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MagmadConfiguratorServer).RemoveNetwork(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.orc8r.magmad.MagmadConfigurator/RemoveNetwork",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MagmadConfiguratorServer).RemoveNetwork(ctx, req.(*protos.Identity))
	}
	return interceptor(ctx, in, info, handler)
}

func _MagmadConfigurator_UpdateNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkRecordRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MagmadConfiguratorServer).UpdateNetwork(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.orc8r.magmad.MagmadConfigurator/UpdateNetwork",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MagmadConfiguratorServer).UpdateNetwork(ctx, req.(*NetworkRecordRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MagmadConfigurator_ForceRemoveNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(protos.Identity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MagmadConfiguratorServer).ForceRemoveNetwork(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.orc8r.magmad.MagmadConfigurator/ForceRemoveNetwork",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MagmadConfiguratorServer).ForceRemoveNetwork(ctx, req.(*protos.Identity))
	}
	return interceptor(ctx, in, info, handler)
}

var _MagmadConfigurator_serviceDesc = grpc.ServiceDesc{
	ServiceName: "magma.orc8r.magmad.MagmadConfigurator",
	HandlerType: (*MagmadConfiguratorServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RegisterGateway",
			Handler:    _MagmadConfigurator_RegisterGateway_Handler,
		},
		{
			MethodName: "ListGateways",
			Handler:    _MagmadConfigurator_ListGateways_Handler,
		},
		{
			MethodName: "FindGatewayId",
			Handler:    _MagmadConfigurator_FindGatewayId_Handler,
		},
		{
			MethodName: "FindGatewayRecord",
			Handler:    _MagmadConfigurator_FindGatewayRecord_Handler,
		},
		{
			MethodName: "UpdateGatewayRecord",
			Handler:    _MagmadConfigurator_UpdateGatewayRecord_Handler,
		},
		{
			MethodName: "FindGatewayNetworkId",
			Handler:    _MagmadConfigurator_FindGatewayNetworkId_Handler,
		},
		{
			MethodName: "RemoveGateway",
			Handler:    _MagmadConfigurator_RemoveGateway_Handler,
		},
		{
			MethodName: "RegisterNetwork",
			Handler:    _MagmadConfigurator_RegisterNetwork_Handler,
		},
		{
			MethodName: "ListNetworks",
			Handler:    _MagmadConfigurator_ListNetworks_Handler,
		},
		{
			MethodName: "GetNetwork",
			Handler:    _MagmadConfigurator_GetNetwork_Handler,
		},
		{
			MethodName: "RemoveNetwork",
			Handler:    _MagmadConfigurator_RemoveNetwork_Handler,
		},
		{
			MethodName: "UpdateNetwork",
			Handler:    _MagmadConfigurator_UpdateNetwork_Handler,
		},
		{
			MethodName: "ForceRemoveNetwork",
			Handler:    _MagmadConfigurator_ForceRemoveNetwork_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "configurator.proto",
}

func init() { proto.RegisterFile("configurator.proto", fileDescriptor_configurator_2d5fb78b6d60bdd8) }

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

repository: abelviageiro/magma

repo_name: abelviageiro/magma

gha_license_id: NOASSERTION


text:
@BOOK{HinzeEtAl2009,
	title = {Optimization with {PDE} constraints},
	publisher = {Springer},
	year = {2009},
	author = {Hinze, Michael and Pinnau, Rene and Ulbrich, Michael and Ulbrich,
	Stefan},
	address = {Berlin}
}

@BOOK{NocedalWright2006,
  title = {Numerical Optimization},
  publisher = {Springer},
  year = {2006},
  author = {Nocedal, Jorge and Wright, Stephen J.},
  address = {New York}
}

@BOOK{HinzeEtAl2009,
	title = {Optimization with {PDE} constraints},
	publisher = {Springer},
	year = {2009},
	author = {Hinze, Michael and Pinnau, Rene and Ulbrich, Michael and Ulbrich,
	Stefan},
	address = {Berlin}
}

@BOOK{Troeltzsch2010,
	title = {Optimal Control of Partial Differential Equations: Theory, Methods and Applications},
	publisher = {AMS},
	year = {2010},
	author = {Tr\"{o}ltzsch, Fredi},
}

@article{KassamTrefethen2005,
	title={Fourth-order time-stepping for stiff PDEs},
	author={Kassam, Aly-Khan and Trefethen, Lloyd N},
	journal={SIAM J. Sci. Comput.},
	volume={26},
	number={4},
	pages={1214--1233},
	year={2005},
	publisher={SIAM}
}

repository: libpfasst/LibPFASST

repo_name: libpfasst/LibPFASST

gha_language: Jupyter Notebook


text:
SUMMARY = "Framework for discovery and browsing of network accessible media"
HOMEPAGE = "https://wiki.gnome.org/Projects/Grilo"
LICENSE = "LGPLv2.1"
LIC_FILES_CHKSUM = "file://COPYING;md5=fbc093901857fcd118f065f900982c24"

SRC_URI[archive.md5sum] = "a15a92a903aeb7579e1b0f6e8b4b0fb1"
SRC_URI[archive.sha256sum] = "7c6964053b42574c2f14715d2392a02ea5cbace955eb73e067c77aa3e43b066e"

DEPENDS = "glib-2.0 gtk+3 libsoup-2.4 intltool-native libxml2 gnome-common-native"

inherit gettext gobject-introspection gnome

EXTRA_OECONF = "--disable-grl-net --disable-grl-pls --disable-test-ui --disable-vala"

repository: nicepixels/citadel

repo_name: nicepixels/citadel


text:
require recipes-images/angstrom/console-image.bb

PV = '1.0'
PR = 'r0'

DEPENDS += "bash perl gcc i2c-tools"

IMAGE_INSTALL += " \
	kernel-image \
	kernel-modules \
	kernel-dev \
	linux-firmware \
	vim vim-vimrc \
	gcc \
	gdb gdbserver \
	lighttpd \
	lighttpd-module-cgi \
	bash gcc i2c-tools ethtool \
	packagegroup-xfce-base \
	packagegroup-sdk-target \
	packagegroup-core-x11-xserver \
	x11vnc \
	xserver-xorg-xvfb \
	xterm \
	synergy \
	imagemagick \
	ne10 \
	ne10-dev \
	qtbase \
	bluez5 \
	epiphany \
	vim \
	gedit \
	curl \
	e2fsprogs \
	nodejs \
	nodejs-npm \
	mraa \
	mraa-dev \
	node-mraa \
	python-mraa \
	upm \
	upm-dev \
	node-upm \
	python-upm \
	python-multiprocessing \
	python-compiler \
	python-misc \
	packagegroup-tools-bluetooth \
	de10-nano-xfce-pointers \
	de10-nano-adxl-apps \
	de10-nano-x11vnc-init \
	de10-nano-lighttpd-conf \
	de10-nano-webcontent \
	de10-nano-gpio-apps \
	de10-nano-fpga-init \
	de10-nano-fpga-leds \
	de10-nano-usb-gadget \
	de10-nano-qt-usb-gadget-app \
	de10-nano-linux-firmware \
	de10-nano-fftsw-apps \
	de10-nano-fftdriver-mod \
	de10-nano-synergy-init \
	de10-nano-xfce-init \
	"

export IMAGE_BASENAME = "de10-nano-image"

gha_language: C


text:
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.23.0
// 	protoc        v3.11.4
// source: queue.proto

package queue

import (
	proto "github.com/golang/protobuf/proto"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
)

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

// This is a compile-time assertion that a sufficiently up-to-date version
// of the legacy proto package is being used.
const _ = proto.ProtoPackageIsVersion4

type Recipient_Type int32

const (
	Recipient_EMAIL Recipient_Type = 0
	Recipient_PIPE  Recipient_Type = 1
)

// Enum value maps for Recipient_Type.
var (
	Recipient_Type_name = map[int32]string{
		0: "EMAIL",
		1: "PIPE",
	}
	Recipient_Type_value = map[string]int32{
		"EMAIL": 0,
		"PIPE":  1,
	}
)

func (x Recipient_Type) Enum() *Recipient_Type {
	p := new(Recipient_Type)
	*p = x
	return p
}

func (x Recipient_Type) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Recipient_Type) Descriptor() protoreflect.EnumDescriptor {
	return file_queue_proto_enumTypes[0].Descriptor()
}

func (Recipient_Type) Type() protoreflect.EnumType {
	return &file_queue_proto_enumTypes[0]
}

func (x Recipient_Type) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Recipient_Type.Descriptor instead.
func (Recipient_Type) EnumDescriptor() ([]byte, []int) {
	return file_queue_proto_rawDescGZIP(), []int{1, 0}
}

type Recipient_Status int32

const (
	Recipient_PENDING Recipient_Status = 0
	Recipient_SENT    Recipient_Status = 1
	Recipient_FAILED  Recipient_Status = 2
)

// Enum value maps for Recipient_Status.
var (
	Recipient_Status_name = map[int32]string{
		0: "PENDING",
		1: "SENT",
		2: "FAILED",
	}
	Recipient_Status_value = map[string]int32{
		"PENDING": 0,
		"SENT":    1,
		"FAILED":  2,
	}
)

func (x Recipient_Status) Enum() *Recipient_Status {
	p := new(Recipient_Status)
	*p = x
	return p
}

func (x Recipient_Status) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Recipient_Status) Descriptor() protoreflect.EnumDescriptor {
	return file_queue_proto_enumTypes[1].Descriptor()
}

func (Recipient_Status) Type() protoreflect.EnumType {
	return &file_queue_proto_enumTypes[1]
}

func (x Recipient_Status) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Recipient_Status.Descriptor instead.
func (Recipient_Status) EnumDescriptor() ([]byte, []int) {
	return file_queue_proto_rawDescGZIP(), []int{1, 1}
}

type Message struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Message ID. Uniquely identifies this message, it is used for
	// auditing and troubleshooting.
	ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	// The envelope for this message.
	From string       `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
	To   []string     `protobuf:"bytes,3,rep,name=To,proto3" json:"To,omitempty"`
	Rcpt []*Recipient `protobuf:"bytes,4,rep,name=rcpt,proto3" json:"rcpt,omitempty"`
	Data []byte       `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
	// Creation timestamp.
	CreatedAtTs *timestamp.Timestamp `protobuf:"bytes,6,opt,name=created_at_ts,json=createdAtTs,proto3" json:"created_at_ts,omitempty"`
}

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

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

func (*Message) ProtoMessage() {}

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

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

func (x *Message) GetID() string {
	if x != nil {
		return x.ID
	}
	return ""
}

func (x *Message) GetFrom() string {
	if x != nil {
		return x.From
	}
	return ""
}

func (x *Message) GetTo() []string {
	if x != nil {
		return x.To
	}
	return nil
}

func (x *Message) GetRcpt() []*Recipient {
	if x != nil {
		return x.Rcpt
	}
	return nil
}

func (x *Message) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

func (x *Message) GetCreatedAtTs() *timestamp.Timestamp {
	if x != nil {
		return x.CreatedAtTs
	}
	return nil
}

type Recipient struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Address to send the message to.
	// This is the final one, after expanding aliases.
	Address            string           `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	Type               Recipient_Type   `protobuf:"varint,2,opt,name=type,proto3,enum=queue.Recipient_Type" json:"type,omitempty"`
	Status             Recipient_Status `protobuf:"varint,3,opt,name=status,proto3,enum=queue.Recipient_Status" json:"status,omitempty"`
	LastFailureMessage string           `protobuf:"bytes,4,opt,name=last_failure_message,json=lastFailureMessage,proto3" json:"last_failure_message,omitempty"`
	// Address that this recipient was originally intended to.
	// This is before expanding aliases and only used in very particular
	// cases.
	OriginalAddress string `protobuf:"bytes,5,opt,name=original_address,json=originalAddress,proto3" json:"original_address,omitempty"`
}

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

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

func (*Recipient) ProtoMessage() {}

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

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

func (x *Recipient) GetAddress() string {
	if x != nil {
		return x.Address
	}
	return ""
}

func (x *Recipient) GetType() Recipient_Type {
	if x != nil {
		return x.Type
	}
	return Recipient_EMAIL
}

func (x *Recipient) GetStatus() Recipient_Status {
	if x != nil {
		return x.Status
	}
	return Recipient_PENDING
}

func (x *Recipient) GetLastFailureMessage() string {
	if x != nil {
		return x.LastFailureMessage
	}
	return ""
}

func (x *Recipient) GetOriginalAddress() string {
	if x != nil {
		return x.OriginalAddress
	}
	return ""
}

var File_queue_proto protoreflect.FileDescriptor

var file_queue_proto_rawDesc = []byte{
	0x0a, 0x0b, 0x71, 0x75, 0x65, 0x75, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x05, 0x71,
	0x75, 0x65, 0x75, 0x65, 0x1a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
	0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
	0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d,
	0x70, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x22, 0xb7, 0x01, 0x0a, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x0e, 0x0a,
	0x02, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x49, 0x44, 0x12, 0x12, 0x0a,
	0x04, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x66, 0x72, 0x6f,
	0x6d, 0x12, 0x0e, 0x0a, 0x02, 0x54, 0x6f, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x02, 0x54,
	0x6f, 0x12, 0x24, 0x0a, 0x04, 0x72, 0x63, 0x70, 0x74, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32,
	0x10, 0x2e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x2e, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e,
	0x74, 0x52, 0x04, 0x72, 0x63, 0x70, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18,
	0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3e, 0x0a, 0x0d, 0x63,
	0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x5f, 0x74, 0x73, 0x18, 0x06, 0x20, 0x01,
	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b,
	0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x54, 0x73, 0x22, 0xa8, 0x02, 0x0a, 0x09,
	0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64,
	0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72,
	0x65, 0x73, 0x73, 0x12, 0x29, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
	0x0e, 0x32, 0x15, 0x2e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x2e, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69,
	0x65, 0x6e, 0x74, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x2f,
	0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x17,
	0x2e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x2e, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74,
	0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12,
	0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f,
	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x6c,
	0x61, 0x73, 0x74, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
	0x65, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x61, 0x64,
	0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x6f, 0x72, 0x69,
	0x67, 0x69, 0x6e, 0x61, 0x6c, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x1b, 0x0a, 0x04,
	0x54, 0x79, 0x70, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x45, 0x4d, 0x41, 0x49, 0x4c, 0x10, 0x00, 0x12,
	0x08, 0x0a, 0x04, 0x50, 0x49, 0x50, 0x45, 0x10, 0x01, 0x22, 0x2b, 0x0a, 0x06, 0x53, 0x74, 0x61,
	0x74, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x00,
	0x12, 0x08, 0x0a, 0x04, 0x53, 0x45, 0x4e, 0x54, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x46, 0x41,
	0x49, 0x4c, 0x45, 0x44, 0x10, 0x02, 0x42, 0x2b, 0x5a, 0x29, 0x62, 0x6c, 0x69, 0x74, 0x69, 0x72,
	0x69, 0x2e, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x72, 0x2f, 0x67, 0x6f, 0x2f, 0x63, 0x68, 0x61, 0x73,
	0x71, 0x75, 0x69, 0x64, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x71, 0x75,
	0x65, 0x75, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_queue_proto_rawDescOnce sync.Once
	file_queue_proto_rawDescData = file_queue_proto_rawDesc
)

func file_queue_proto_rawDescGZIP() []byte {
	file_queue_proto_rawDescOnce.Do(func() {
		file_queue_proto_rawDescData = protoimpl.X.CompressGZIP(file_queue_proto_rawDescData)
	})
	return file_queue_proto_rawDescData
}

var file_queue_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_queue_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_queue_proto_goTypes = []interface{}{
	(Recipient_Type)(0),         // 0: queue.Recipient.Type
	(Recipient_Status)(0),       // 1: queue.Recipient.Status
	(*Message)(nil),             // 2: queue.Message
	(*Recipient)(nil),           // 3: queue.Recipient
	(*timestamp.Timestamp)(nil), // 4: google.protobuf.Timestamp
}
var file_queue_proto_depIdxs = []int32{
	3, // 0: queue.Message.rcpt:type_name -> queue.Recipient
	4, // 1: queue.Message.created_at_ts:type_name -> google.protobuf.Timestamp
	0, // 2: queue.Recipient.type:type_name -> queue.Recipient.Type
	1, // 3: queue.Recipient.status:type_name -> queue.Recipient.Status
	4, // [4:4] is the sub-list for method output_type
	4, // [4:4] is the sub-list for method input_type
	4, // [4:4] is the sub-list for extension type_name
	4, // [4:4] is the sub-list for extension extendee
	0, // [0:4] is the sub-list for field type_name
}

func init() { file_queue_proto_init() }
func file_queue_proto_init() {
	if File_queue_proto != nil {
		return
	}
	if !protoimpl.UnsafeEnabled {
		file_queue_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Message); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_queue_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Recipient); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_queue_proto_rawDesc,
			NumEnums:      2,
			NumMessages:   2,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_queue_proto_goTypes,
		DependencyIndexes: file_queue_proto_depIdxs,
		EnumInfos:         file_queue_proto_enumTypes,
		MessageInfos:      file_queue_proto_msgTypes,
	}.Build()
	File_queue_proto = out.File
	file_queue_proto_rawDesc = nil
	file_queue_proto_goTypes = nil
	file_queue_proto_depIdxs = nil
}