text:
% Encoding: UTF-8

@article{DBLP:journals/corr/abs-1203-3099,
  author    = {Otman Abdoun and
               Jaafar Abouchabaka and
               Chakir Tajani},
  title     = {Analyzing the Performance of Mutation Operators to Solve the Travelling
               Salesman Problem},
  journal   = {CoRR},
  volume    = {abs/1203.3099},
  year      = {2012},
  url       = {http://arxiv.org/abs/1203.3099},
  archivePrefix = {arXiv},
  eprint    = {1203.3099},
  timestamp = {Mon, 13 Aug 2018 16:48:44 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/abs-1203-3099},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{DBLP:journals/corr/abs-1203-5028,
  author    = {Otman Abdoun and
               Chakir Tajani and
               Jaafar Abouchabaka},
  title     = {Hybridizing {PSM} and {RSM} Operator for Solving NP-Complete Problems:
               Application to Travelling Salesman Problem},
  journal   = {CoRR},
  volume    = {abs/1203.5028},
  year      = {2012},
  url       = {http://arxiv.org/abs/1203.5028},
  archivePrefix = {arXiv},
  eprint    = {1203.5028},
  timestamp = {Mon, 13 Aug 2018 16:48:40 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/abs-1203-5028},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}
@Book{Ackley:1987:CMG:40713,
  Title                    = {A Connectionist Machine for Genetic Hillclimbing},
  Author                   = {David H. Ackley},
  Publisher                = {Kluwer Academic Publishers},
  Year                     = {1987},

  Address                  = {Norwell, MA, USA},

  ISBN                     = {0-89838-236-X}
}

@Book{back1996evolutionary,
  Title                    = {Evolutionary Algorithms in Theory and Practice},
  Author                   = {Thomas Back},
  Publisher                = {Oxford Univiversity Press},
  Year                     = {1996},

  Timestamp                = {2012.02.11}
}

@Article{baker1987selection,
  Title                    = {Reducing Bias and Inefficiency in the Selection Algorithm},
  Author                   = {James E. Baker},
  Journal                  = {Proceedings of the Second International Conference on Genetic Algorithms and their Application},
  Year                     = {1987},
  Pages                    = {14-21},

  Timestamp                = {2012.02.11}
}

@InProceedings{Baluja95removingthe,
  Title                    = {Removing the Genetics from the Standard Genetic Algorithm},
  Author                   = {Shumeet Baluja and Rich Caruana},
  Year                     = {1995},
  Pages                    = {38--46},
  Publisher                = {Morgan Kaufmann Publishers}
}

@InCollection{Bandaru2016,
  author    = {Bandaru, Sunith and Deb, Kalyanmoy},
  title     = {Metaheuristic Techniques},
  booktitle = {Decision Sciences},
  publisher = {CRC Press},
  year      = {2016},
  pages     = {693-750},
  month     = nov,
  comment   = {doi:10.1201/9781315183176-12},
  doi       = {10.1201/9781315183176-12},
  issn      = {978-1-4665-6430-5},
  timestamp = {2016.12.06},
}

@Article{Tina2011,
  author  = {Heiko Bauke},
  title   = {Tina's Random Number Generator Library},
  journal = {https://github.com/rabauke/trng4/blob/master/doc/trng.pdf},
  year    = {2011},
  url     = {https://www.numbercrunch.de/trng/trng.pdf},
}

@Article{Blickle97acomparison,
  Title                    = {A Comparison of Selection Schemes used in Evolutionary Algorithms},
  Author                   = {Tobias Blickle and Lothar Thiele},
  Journal                  = {Evolutionary Computation},
  Year                     = {1997},
  Pages                    = {361--394},
  Volume                   = {4}
}

@Book{chawdhry1998soft,
  Title                    = {Soft Computing in Engineering Design and Manufacturing},
  Author                   = {Chawdhry, P.K. and Roy, R. and Pant, R.K.},
  Publisher                = {Springer London},
  Year                     = {1998},

  Doi                      = {10.1007/978-1-4471-0427-8},
  ISBN                     = {9783540762140},
  Lccn                     = {97031959},
  Url                      = {https://books.google.at/books?id=mxcP1mSjOlsC}
}

@Book{dawkins1986,
  Title                    = {The Blind Watchmaker},
  Author                   = {Dawkins, Richard},
  Publisher                = {New York: W. W. Norton \& Company},
  Year                     = {1986},

  ISBN                     = {0-393-31570-3},
  Url                      = {https://books.google.at/books?id=-EDHRX3YYwgC}
}

@Book{Luke2013Metaheuristics,
  title     = {Essentials of Metaheuristics},
  publisher = {Lulu},
  year      = {2013},
  author    = {Sean Luke},
  edition   = {second},
  note      = {Available for free at http://cs.gmu.edu/$\sim$sean/book/metaheuristics/},
  abstract  = {This is an open set of lecture notes on metaheuristics algorithms, intended for undergraduate students, practitioners, programmers, and other non-experts. It was developed as a series of lecture notes for an undergraduate course I taught at GMU. The chapters are designed to be printable separately if necessary. As it's lecture notes, the topics are short and light on examples and theory. It's best when complementing other texts. With time, I might remedy this.},
}

@Book{michalewicz1996genetic,
  Title                    = {Genetic Algorithms + Data Structures = Evolution},
  Author                   = {Zbigniew Michalewicz},
  Publisher                = {Springer},
  Year                     = {1996},

  ISBN                     = {9783540606765},
  Lccn                     = {95048027},
  Url                      = {http://books.google.at/books?id=vlhLAobsK68C}
}

@Book{Mitchell1998,
  Title                    = {An Introduction to Genetic Algorithms},
  Author                   = {Melanie Mitchell},
  Publisher                = {MIT Press},
  Year                     = {1998},

  Address                  = {Cambridge, MA, USA},

  ISBN                     = {0262631857}
}

@Book{Nijenhuis1978,
  Title                    = {Combinatorial Algorithms for Computers and Calculators},
  Author                   = {Albert Nijenhuis and Herbert Wilf},
  Publisher                = {Academic Press},
  Year                     = {1978},
  Edition                  = {Second},

  ISBN                     = {0-12-519260-6}
}

@Article{OracleJDKValueBasedClasses,
  Title                    = {Value-based classes},
  Author                   = {Oracle},
  Journal                  = {https://docs.oracle.com/javase/8/docs/api/-java/lang/doc-files/ValueBased.html},
  Year                     = {2014},

  Timestamp                = {2014.11.12}
}

@Article{Palmer1995,
  author    = {Palmer, Charles C. and Kershenbaum, Aaron},
  title     = {An approach to a problem in network design using genetic algorithms},
  journal   = {Networks},
  year      = {1995},
  volume    = {26},
  number    = {3},
  pages     = {151--163},
  issn      = {1097-0037},
  abstract  = {This paper describes a new approach to finding solutions to the optimal communication spanning tree problem (OCSTP) using a genetic algorithm. The difficulties posed by this problem are reviewed and a genetic algorithm that consistently finds very good, if not optimal, solutions to it is presented. Finally, a comparison of the genetic algorithm's solutions to those produced by a good heuristic is given that demonstrates the genetic algorithm's ability to find solutions at least equivalent to, if not superior to, those found by the heuristic.},
  doi       = {10.1002/net.3230260305},
  publisher = {Wiley Subscription Services, Inc., A Wiley Company},
}

@Book{Rothlauf2006,
  Title                    = {Representations for Genetic and Evolutionary Algorithms},
  Author                   = {Franz Rothlauf},
  Publisher                = {Springer},
  Year                     = {2006},
  Edition                  = {2},

  ISBN                     = {978-3-540-32444-7}
}

@Book{Shiffman2012,
  Title                    = {The Nature of Code},
  Author                   = {Daniel Shiffman},
  Publisher                = {The Nature of Code},
  Year                     = {2012},
  Edition                  = {1},
  Month                    = {12},

  Pages                    = {520},
  Quality                  = {1},
  Timestamp                = {2013.06.17},
  Url                      = {http://natureofcode.com/book/}
}

@Book{Sivanandam2010,
  Title                    = {Introduction to Genetic Algorithms},
  Author                   = {S. N. Sivanandam and S. N. Deepa},
  Publisher                = {Springer},
  Year                     = {2010}
}

@Article{FEDR:FEDR19750860506,
  author    = {Vent, W.},
  title     = {Rechenberg, Ingo, Evolutionsstrategie — Optimierung technischer Systeme nach Prinzipien der biologischen Evolution. 170 S. mit 36 Abb. Frommann-Holzboog-Verlag. Stuttgart 1973. Broschiert},
  journal   = {Feddes Repertorium},
  year      = {1975},
  volume    = {86},
  number    = {5},
  pages     = {337--337},
  issn      = {1522-239X},
  doi       = {10.1002/fedr.19750860506},
  publisher = {Wiley-VCH Verlag},
}

@Article{MathWorld_Weisstein,
  Title                    = {Scalar Function},
  Author                   = {Weisstein, Eric W.},
  Journal                  = {http://mathworld.wolfram.com/-ScalarFunction.html},
  Year                     = {2015},

  Abstract                 = {A function f(x_1,...,x_n) of one or more variables whose range is one-dimensional, as compared to a vector function, whose range is three-dimensional (or, in general, n-dimensional).},
  HowPublished             = {MathWorld},
  Url                      = {http://mathworld.wolfram.com/ScalarFunction.html}
}

@Article{MathWorld_Weisstein2,
  Title                    = {Vector Function},
  Author                   = {Weisstein, Eric W.},
  Journal                  = {http://mathworld.wolfram.com/-VectorFunction.html},
  Year                     = {2015},

  Abstract                 = {A function of one or more variables whose range is three-dimensional (or, in general, n-dimensional), as compared to a scalar function, whose range is one-dimensional. Vector functions are also called vector-valued functions. },
  HowPublished             = {MathWorld},
  Url                      = {http://mathworld.wolfram.com/VectorFunction.html}
}

@Article{Whitley94agenetic,
  Title                    = {A Genetic Algorithm Tutorial},
  Author                   = {Darrell Whitley},
  Journal                  = {Statistics and Computing},
  Year                     = {1994},
  Pages                    = {65--85},
  Volume                   = {4},

  Citeseerurl              = {http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.129.179}
}

@Article{WikipediaWeaselProgram,
  Title                    = {Weasel program --- {W}ikipedia{,} The Free Encyclopedia},
  Author                   = {Wikipedia},
  Journal                  = {https://en.wikipedia.org/wiki/Weasel_program},
  Year                     = {2015},
  Note                     = {[Online; accessed 04-01-2004]},

  Url                      = {https://en.wikipedia.org/wiki/Weasel_program}
}

@Article{Wikipedi2012,
  Title                    = {Genetic algorithm --- {W}ikipedia{,} The Free Encyclopedia},
  Author                   = {Wikipedia},
  Journal                  = {https://en.wikipedia.org/wiki/Genetic_algorithm},
  Year                     = {2012},
  Note                     = {[Online; accessed 04-01-2004]},

  Url                      = {https://en.wikipedia.org/wiki/Genetic_algorithm}
}

@Article{JSSv068c01,
  Title                    = {A Genetic Algorithm for Selection of Fixed-Size Subsets with Application to Design Problems},
  Author                   = {Mark Wolters},
  Journal                  = {Journal of Statistical Software},
  Year                     = {2015},
  Number                   = {1},
  Pages                    = {1--18},
  Volume                   = {68},

  Abstract                 = {The R function kofnGA conducts a genetic algorithm search for the best subset of k items from a set of n alternatives, given an objective function that measures the quality of a subset. The function fills a gap in the presently available subset selection software, which typically searches over a range of subset sizes, restricts the types of objective functions considered, or does not include freely available code. The new function is demonstrated on two types of problem where a fixed-size subset search is desirable: design of environmental monitoring networks, and D-optimal design of experiments. Additionally, the performance is evaluated on a class of constructed test problems with a novel design that is interesting in its own right.},
  Doi                      = {10.18637/jss.v068.c01},
  ISSN                     = {1548-7660},
  Keywords                 = {discrete optimization; heuristics; evolutionary computation; network design; D-optimal design; optimization test problems},
  Url                      = {http://www.jstatsoft.org/index.php/jss/article/view/v068c01}
}

@Article{Muhlenbein:1993:PMB:1326623.1326626,
  author       = {M\"{u}hlenbein, Heinz and Schlierkamp-Voosen, Dirk},
  title        = {Predictive Models for the Breeder Genetic Algorithm I. Continuous Parameter Optimization},
  volume       = {1},
  number       = {1},
  pages        = {25--49},
  issn         = {1063-6560},
  abstract     = {In this paper a new genetic algorithm called the Breeder Genetic Algorithm (BGA) is introduced. The BGA is based on artificial selection similar to that used by human breeders. A predictive model for the BGA is presented that is derived from quantitative genetics. The model is used to predict the behavior of the BGA for simple test functions. Different mutation schemes are compared by computing the expected progress to the solution. The numerical performance of the BGA is demonstrated on a test suite of multimodal functions. The number of function evaluations needed to locate the optimum scales only as n ln(n) where n is the number of parameters. Results up to n = 1000 are reported.},
  acmid        = {1326626},
  date         = {1993-03},
  doi          = {10.1162/evco.1993.1.1.25},
  issue_date   = {Spring 1993},
  journaltitle = {Evol. Comput.},
  location     = {Cambridge, MA, USA},
  numpages     = {25},
  publisher    = {MIT Press},
}

@Book{Koza:1992:GPP:138936,
  title     = {Genetic Programming: On the Programming of Computers by Means of Natural Selection},
  publisher = {MIT Press},
  year      = {1992},
  author    = {Koza, John R.},
  address   = {Cambridge, MA, USA},
  isbn      = {0-262-11170-5},
  timestamp = {2017.07.24},
}

@Book{Koza:1999:GPI:553446,
  title     = {Genetic Programming III: Darwinian Invention \& Problem Solving},
  publisher = {Morgan Kaufmann Publishers Inc.},
  year      = {1999},
  author    = {Koza, John R. and Andre, David and Bennett, Forrest H. and Keane, Martin A.},
  address   = {San Francisco, CA, USA},
  edition   = {1st},
  isbn      = {1558605436},
  owner     = {fwilhelm},
  timestamp = {2017.07.25},
}

@Book{Koza:1994:GPI:183460,
  title     = {Genetic Programming II: Automatic Discovery of Reusable Programs},
  publisher = {MIT Press},
  year      = {1994},
  author    = {Koza, John R.},
  address   = {Cambridge, MA, USA},
  isbn      = {0-262-11189-6},
  owner     = {fwilhelm},
  timestamp = {2017.07.25},
}

@InProceedings{Koza:2008:IGP:1388969.1389057,
  author    = {Koza, John R.},
  title     = {Introduction to Genetic Programming: Tutorial},
  booktitle = {Proceedings of the 10th Annual Conference Companion on Genetic and Evolutionary Computation},
  year      = {2008},
  series    = {GECCO '08},
  pages     = {2299--2338},
  address   = {New York, NY, USA},
  publisher = {ACM},
  acmid     = {1389057},
  doi       = {10.1145/1388969.1389057},
  isbn      = {978-1-60558-131-6},
  keywords  = {genetic programming},
  location  = {Atlanta, GA, USA},
  numpages  = {40},
  owner     = {fwilhelm},
  timestamp = {2017.07.25},
}

@Book{Koza:2003:GPI:945774,
  title     = {Genetic Programming IV: Routine Human-Competitive Machine Intelligence},
  publisher = {Kluwer Academic Publishers},
  year      = {2003},
  author    = {Koza, John R.},
  address   = {Norwell, MA, USA},
  isbn      = {1402074468},
  owner     = {fwilhelm},
  timestamp = {2017.07.25},
}

@Article{Deb99self-adaptivegenetic,
  author    = {Kalyanmoy Deb and Hans-Georg Beyer},
  title     = {Self-Adaptive Genetic Algorithms with Simulated Binary Crossover},
  journal   = {COMPLEX SYSTEMS},
  year      = {1999},
  volume    = {9},
  pages     = {431--454},
  owner     = {fwilhelm},
  timestamp = {2017.07.27},
}

@Misc{GoodPRNGPractice,
  author               = {Jones, David},
  title                = {Good Practice in (Pseudo) Random Number Generation for Bioinformatics Applications},
  month                = may,
  year                 = {2010},
  citeulike-article-id = {12238550},
  citeulike-linkout-0  = {http://www.cs.ucl.ac.uk/staff/d.jones/GoodPracticeRNG.pdf},
  day                  = {7},
  institution          = {University College London},
  keywords             = {rng, simulation},
  owner                = {fwilhelm},
  posted-at            = {2013-04-03 11:49:52},
  timestamp            = {2017.07.28},
  url                  = {http://www.cs.ucl.ac.uk/staff/d.jones/GoodPracticeRNG.pdf},
}

@Book{hughes2014computer,
  title     = {Computer Graphics: Principles and Practice},
  publisher = {Addison-Wesley},
  year      = {2014},
  author    = {Hughes, J.F. and Foley, J.D.},
  series    = {The systems programming series},
  isbn      = {9780321399526},
  lccn      = {2012045569},
  url       = {https://books.google.at/books?id=OVpsAQAAQBAJ},
}

@Article{Deb:2002:FEM:2221359.2221582,
  author     = {Deb, K. and Pratap, A. and Agarwal, S. and Meyarivan, T.},
  title      = {A Fast and Elitist Multiobjective Genetic Algorithm: NSGA-II},
  journal    = {Trans. Evol. Comp},
  year       = {2002},
  volume     = {6},
  number     = {2},
  pages      = {182--197},
  month      = apr,
  issn       = {1089-778X},
  acmid      = {2221582},
  address    = {Piscataway, NJ, USA},
  doi        = {10.1109/4235.996017},
  issue_date = {April 2002},
  numpages   = {16},
  publisher  = {IEEE Press},
}

@Book{CoelloCoello2007,
  title     = {Evolutionary Algorithms for Solving Multi-Objective Problems},
  publisher = {Springer},
  year      = {2007},
  author    = {Carlos A. Coello Coello, Gary B. Lamont, David A. Van Veldhuizen},
  series    = {Genetic and Evolutionary Computation},
  address   = {Berlin, Heidelberg},
  edition   = {2nd},
  added-at  = {2009-12-14T10:56:13.000+0100},
  biburl    = {https://www.bibsonomy.org/bibtex/2069f53236f428965116e5b5017442b29/danfunky},
  doi       = {10.1007/978-0-387-36797-2},
  interhash = {9e01931bd73c14005547b22cf888f33a},
  intrahash = {069f53236f428965116e5b5017442b29},
  keywords  = {algorithms, evolutionary multi-objective, optimization},
  owner     = {D047718},
  timestamp = {2009-12-14T10:56:16.000+0100},
  url       = {http://books.google.com/books?id=rXIuAMw3lGAC},
}

@InProceedings{Fortin2013,
  author    = {Fortin, F{\'e}lix-Antoine and Parizeau, Marc},
  title     = {Revisiting the NSGA-II Crowding-distance Computation},
  booktitle = {Proceedings of the 15th Annual Conference on Genetic and Evolutionary Computation},
  year      = {2013},
  series    = {GECCO '13},
  pages     = {623--630},
  address   = {New York, NY, USA},
  publisher = {ACM},
  acmid     = {2463456},
  doi       = {10.1145/2463372.2463456},
  isbn      = {978-1-4503-1963-8},
  keywords  = {crowding distance, multi-objective evolutionary algorithms, nsga-ii},
  location  = {Amsterdam, The Netherlands},
  numpages  = {8},
}

@Article{Konak2006,
  author    = {Konak, Abdullah and Coit, David W. and Smith, Alice E.},
  title     = {Multi-objective optimization using genetic algorithms: A tutorial.},
  journal   = {Rel. Eng. \& Sys. Safety},
  year      = {2006},
  volume    = {91},
  number    = {9},
  pages     = {992-1007},
  added-at  = {2012-06-20T00:00:00.000+0200},
  biburl    = {https://www.bibsonomy.org/bibtex/28a293983a13e46a6acf0b157c05e85cb/dblp},
  doi       = {10.1016/j.ress.2005.11.018},
  interhash = {3a1e5f8c2a4f2f6cd649841072c9e3c1},
  intrahash = {8a293983a13e46a6acf0b157c05e85cb},
  keywords  = {dblp},
  timestamp = {2012-06-21T11:35:16.000+0200},
  url       = {http://dblp.uni-trier.de/db/journals/ress/ress91.html#KonakCS06},
}

@Article{Osyczka1985,
  author    = {A. Osyczka},
  title     = {Multicriteria optimization for engineering design},
  journal   = {Design Optimization},
  year      = {1985},
  pages     = {193–227},
  owner     = {fwilhelm},
  timestamp = {2017.12.15},
}

@InBook{Deb2001,
  title     = {Scalable test problems for evolutionary multi-objective optimization},
  publisher = {ETH-Zentrum},
  year      = {2001},
  author    = {Kalyanmoy Deb and Lothar Thiele and Marco Laumanns and Eckart Zitzler},
  number    = {112},
  series    = {TIK-Technical Report},
  address   = {ETH-Zentrum Switzerland},
  month     = jul,
  abstract  = {After adequately demonstrating the ability to solve different two-objective optimization
problems, multi-objective evolutionary algorithms (MOEAs) must now show their efficacy in
handling problems having more than two objectives. In this paper, we have suggested three
different approaches for systematically designing test problems for this purpose. The simplicity
of construction, scalability to any number of decision variables and objectives, knowledge of
exact shape and location of the resulting Pareto-optimal front, and introduction of controlled
difficulties in both converging to the true Pareto-optimal front and maintaining a widely
distributed set of solutions are the main features of the suggested test problems. Because
of the above features, they should be found useful in various research activities on MOEAs,
such as testing the performance of a new MOEA, comparing different MOEAs, and better
understanding of the working principles of MOEAs.},
  doi       = {10.3929/ethz-a-004284199},
}

@Book{Bloch2018,
  title     = {Effective Java},
  publisher = {Addison-Wesley Professional},
  year      = {2018},
  author    = {Joshua Bloch},
  edition   = {3rd},
  isbn      = {978-0134685991},
  url       = {https://www.pearson.com/us/higher-education/program/Bloch-Effective-Java-3rd-Edition/PGM1763855.html},
}

@Article{Jain:1985:PAD:4372.4378,
  author     = {Jain, Raj and Chlamtac, Imrich},
  title      = {The P2 Algorithm for Dynamic Calculation of Quantiles and Histograms Without Storing Observations},
  journal    = {Commun. ACM},
  year       = {1985},
  volume     = {28},
  number     = {10},
  pages      = {1076--1085},
  month      = oct,
  issn       = {0001-0782},
  acmid      = {4378},
  address    = {New York, NY, USA},
  doi        = {10.1145/4372.4378},
  issue_date = {Oct. 1985},
  numpages   = {10},
  publisher  = {ACM},
}
@book{baader_nipkow_1998, place={Cambridge}, title={Term Rewriting and All That}, DOI={10.1017/CBO9781139172752}, publisher={Cambridge University Press}, author={Baader, Franz and Nipkow, Tobias}, year={1998}}

@inproceedings{Michalewicz1995ASO,
  title={A Survey of Constraint Handling Techniques in Evolutionary Computation Methods},
  author={Zbigniew Michalewicz},
  booktitle={Evolutionary Programming},
  year={1995}
}

@Book{Datta2014,
  title  = {Evolutionary Constrained Optimization},
  year   = {2014},
  author = {Datta, Rituparna and Deb, Kalyanmoy},
  month  = {12},
  isbn   = {978-81-322-2183-8},
  doi    = {10.1007/978-81-322-2184-5},
}

@Book{Mezura-Montes2009,
  title  = {Constraint-Handling in Evolutionary Optimization},
  year   = {2009},
  author = {Mezura-Montes, Efrén},
  volume = {198},
  month  = {01},
  isbn   = {978-3-642-00618-0},
  doi    = {10.1007/978-3-642-00619-7},
}

@Article{Coello2002,
  author  = {Coello, Carlos},
  title   = {Coello, A.C.: Theoretical and Numerical Constraint-Handling Techniques Used with Evolutionary Algorithms: A Survey of the State of the Art. Comput. Methods Appl. Mech. Engrg. 191(11-12), 1245-1287},
  journal = {Computer Methods in Applied Mechanics and Engineering},
  year    = {2002},
  volume  = {191},
  pages   = {1245-1287},
  month   = {01},
  doi     = {10.1016/S0045-7825(01)00323-1},
}

@InProceedings{ryan1998grammatical,
  author            = {Conor Ryan and J. J. Collins and Michael O'Neill},
  title             = {Grammatical Evolution: Evolving Programs for an Arbitrary Language},
  booktitle         = {Proceedings of the First European Workshop on Genetic Programming},
  year              = {1998},
  editor            = {Wolfgang Banzhaf and Riccardo Poli and Marc Schoenauer and Terence C. Fogarty},
  volume            = {1391},
  series            = {LNCS},
  pages             = {83--96},
  address           = {Paris},
  month             = {14-15 } # apr,
  publisher         = {Springer-Verlag},
  abstract          = {We describe a Genetic Algorithm that can evolve complete programs. Using a variable length linear genome to govern how a Backus Naur Form grammar definition is mapped to a program, expressions and programs of arbitrary complexity may be evolved. Other automatic programming methods are described, before our system, Grammatical Evolution, is applied to a symbolic regression problem.},
  affiliation       = {University of Limerick Dept. Of Computer Science and Information Systems Ireland Ireland},
  doi               = {doi:10.1007/BFb0055930},
  isbn              = {3-540-64360-5},
  keywords          = {genetic algorithms, genetic programming, grammatical evolution},
  notes             = {EuroGP'98},
  publisher_address = {Berlin},
  size              = {14 pages},
  url               = {http://www.lania.mx/~ccoello/eurogp98.ps.gz},
}

@InProceedings{Lourenco2016,
  author    = {Louren{\c{c}}o, Nuno and Pereira, Francisco B. and Costa, Ernesto},
  title     = {SGE: A Structured Representation for Grammatical Evolution},
  booktitle = {Artificial Evolution},
  year      = {2016},
  editor    = {Bonnevay, St{\'e}phane and Legrand, Pierrick and Monmarch{\'e}, Nicolas and Lutton, Evelyne and Schoenauer, Marc},
  pages     = {136--148},
  address   = {Cham},
  publisher = {Springer International Publishing},
  abstract  = {This paper introduces Structured Grammatical Evolution, a new genotypic representation for Grammatical Evolution, where each gene is explicitly linked to a non-terminal of the grammar being used. This one-to-one correspondence ensures that the modification of a gene does not affect the derivation options of other non-terminals, thereby increasing locality. The performance of the new representation is accessed on a set of benchmark problems. The results obtained confirm the effectiveness of the proposed approach, as it is able to outperform standard grammatical evolution on all selected optimization problems.},
  isbn      = {978-3-319-31471-6},
  owner     = {fwilhelm},
  timestamp = {2022.04.03},
}

@InProceedings{Assuncao2017,
  author    = {Assun\c{c}\~{a}o, Filipe and Louren\c{c}o, Nuno and Machado, Penousal and Ribeiro, Bernardete},
  title     = {Towards the Evolution of Multi-Layered Neural Networks: A Dynamic Structured Grammatical Evolution Approach},
  booktitle = {Proceedings of the Genetic and Evolutionary Computation Conference},
  year      = {2017},
  series    = {GECCO '17},
  pages     = {393–400},
  address   = {New York, NY, USA},
  publisher = {Association for Computing Machinery},
  abstract  = {Current grammar-based NeuroEvolution approaches have several shortcomings. On the one hand, they do not allow the generation of Artificial Neural Networks (ANNs) composed of more than one hidden-layer. On the other, there is no way to evolve networks with more than one output neuron. To properly evolve ANNs with more than one hidden-layer and multiple output nodes there is the need to know the number of neurons available in previous layers. In this paper we introduce Dynamic Structured Grammatical Evolution (DSGE): a new genotypic representation that overcomes the aforementioned limitations. By enabling the creation of dynamic rules that specify the connection possibilities of each neuron, the methodology enables the evolution of multi-layered ANNs with more than one output neuron. Results in different classification problems show that DSGE evolves effective single and multi-layered ANNs, with a varying number of output neurons.},
  doi       = {10.1145/3071178.3071286},
  isbn      = {9781450349208},
  keywords  = {NeuroEvolution, Artificial Neural Networks, Grammar-based Genetic Programming, Classification},
  location  = {Berlin, Germany},
  numpages  = {8},
  owner     = {fwilhelm},
  timestamp = {2022.04.03},
  url       = {https://doi.org/10.1145/3071178.3071286},
}

@Article{Bartoli2019,
  author    = {Alberto Bartoli and Andrea {De Lorenzo} and Eric Medvet and Giovanni Squillero},
  title     = {Multi-level diversity promotion strategies for Grammar-guided Genetic Programming},
  journal   = {Applied Soft Computing},
  year      = {2019},
  volume    = {83},
  pages     = {105599},
  issn      = {1568-4946},
  abstract  = {Grammar-guided Genetic Programming (G3P) is a family of Evolutionary Algorithms that can evolve programs in any language described by a context-free grammar. The most widespread members of this family are based on an indirect representation: a sequence of bits or integers (the genotype) is transformed into a string of the language (the phenotype) by means of a mapping function, and eventually into a fitness value. Unfortunately, the flexibility brought by this mapping is also likely to introduce non-locality phenomena, reduce diversity, and hamper the effectiveness of the algorithm. In this paper, we experimentally characterize how population diversity, measured at different levels, varies for four popular G3P approaches. We then propose two strategies for promoting diversity which are general, independent both from the specific problem being tackled and from the other components of the Evolutionary Algorithm, such as genotype–phenotype mapping, selection criteria, and genetic operators. We experimentally demonstrate their efficacy in a wide range of conditions and from different points of view. The results also confirm the preponderant importance of the phenotype-level analyzes in diversity promotion.},
  doi       = {10.1016/j.asoc.2019.105599},
  keywords  = {Representation, Grammatical evolution, CFGGP, SGE, WHGE},
  owner     = {fwilhelm},
  timestamp = {2022.04.03},
  url       = {https://www.sciencedirect.com/science/article/pii/S1568494619303795},
}

@Book{ONeil2003,
  title     = {Grammatical Evolution: Evolutionary Automatic Programming in an Arbitrary Language},
  publisher = {Springer US},
  year      = {2003},
  author    = {O'Neil, Michael and Ryan, Conor},
  address   = {Boston, MA},
  isbn      = {978-1-4615-0447-4},
  abstract  = {This book is about Grammatical Evolution (GE), an approach to Genetic Programming that allows the generation of computer programs in an arbitrary language. GE exploits a rich modularity in its design that results in a highly flexible and easy to use system. GE owes this design and, consequently, its most powerful features to inspiration from biological systems. There are two main themes to the book; the first being the adoption of phenomena from molecular biology in a simple and useful manner, and the second being the use of grammars to specify legal structures in a search.},
  booktitle = {Grammatical Evolution: Evolutionary Automatic Programming in an Arbitrary Language},
  doi       = {10.1007/978-1-4615-0447-4},
  timestamp = {2022.04.03},
  url       = {https://doi.org/10.1007/978-1-4615-0447-4},
}

@InProceedings{backus1959syntax,
  author       = {Backus, J},
  title        = {The syntax and semantics of the proposed international algorithmic language},
  year         = {1959},
  series       = {Proceedings of the International Conference on Information Processing–IFIP Congress},
  pages        = {125-132},
  month        = jun,
  organization = {ACM-GAMM},
  abstract     = {This paper gives a tutorial summary of the syntax and interpretation
rules of the proposed international algebraic language put forward by
the Zurich ACM-GAMM Conference, followed by a formal, complete
presentation of the same information. Notations are presented for
numbers, numerical variables, Boolean variables, relations, n-dimen-
sional arrays, functi ons, operator s and algebraic expre s sions. Means
are provided in the language for specifying assignment of values to.
variables, conditional execution of statements, iterative proce<i;ures,
formation of compound statements from sequences of statements,
definition of new statements for arbitrary procedures, reuse and
alteration of program segments.
The proposed language is intended to provide convenient and concise
means for expressing virtually all procedures of numericaL compu-
tation while employing relatively few syntactical rules and statement
types.},
}

@InCollection{Greenlaw1998,
  author    = {Raymond Greenlaw},
  title     = {Grammars},
  booktitle = {Fundamentals of the Theory of Computation: Principles and Practice},
  publisher = {Morgan Kaufmann},
  year      = {1998},
  editor    = {Raymond Greenlaw},
  pages     = {195-220},
  address   = {Oxford},
  isbn      = {978-1-55860-547-3},
  doi       = {10.1016/B978-1-55860-547-3.50011-X},
  url       = {https://www.sciencedirect.com/science/article/pii/B978155860547350011X},
}

@InBook{Ryan2018,
  pages     = {1--21},
  title     = {Introduction to 20 Years of Grammatical Evolution},
  publisher = {Springer International Publishing},
  year      = {2018},
  author    = {Ryan, Conor and O'Neill, Michael and Collins, JJ},
  editor    = {Ryan, Conor and O'Neill, Michael and Collins, JJ},
  address   = {Cham},
  isbn      = {978-3-319-78717-6},
  abstract  = {Grammatical Evolution (GE) is a Evolutionary Algorithm (EA) that takes inspiration from the biological evolutionary process to search for solutions to problems. This chapter gives a brief introduction to EAs, paying particular attention to those involved in automatic program generation. We then describe grammars, the core building blocks of programs, before detailing how GE's usage of them is one of the key differentiators between it and other EAs.},
  booktitle = {Handbook of Grammatical Evolution},
  doi       = {10.1007/978-3-319-78717-6_1},
  owner     = {fwilhelm},
  timestamp = {2022.04.16},
  url       = {https://doi.org/10.1007/978-3-319-78717-6_1},
}

@Comment{jabref-meta: databaseType:bibtex;}

repository: jenetics/jenetics

repo_name: jenetics/jenetics

gha_language: Java


text:
if (MSVC)
  # For MSVC, CMake sets certain flags to defaults we want to override.
  # This replacement code is taken from sample in the CMake Wiki at
  # http://www.cmake.org/Wiki/CMake_FAQ#Dynamic_Replace.
  foreach (flag_var
           CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
           CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
    # In hermetic build environments, tests may not have access to MS runtime
    # DLLs, so this replaces /MD (CRT libraries in DLLs) with /MT (static CRT
    # libraries).
    #string(REPLACE "/MD" "-MT" ${flag_var} "${${flag_var}}")
    # We prefer more strict warning checking for building Google Test.
    # Replaces /W3 with /W4 in defaults.
    string(REPLACE "/W3" "-W4" ${flag_var} "${${flag_var}}")
  endforeach()
endif()

# Defines the compiler/linker flags used to build cetty.  You can
# tweak these definitions to suit your need.  A variable's value is
# empty before it's explicitly assigned to.

if (MSVC)
  # Newlines inside flags variables break CMake's NMake generator.
  #set(cxx_base_flags "-GS -W4 -WX -wd4275 -nologo -J -Zi")
  set(cxx_base_flags "-GS -W3 -wd4275 -wd4996 -nologo -Zi")
  set(cxx_base_flags "${cxx_base_flags} -D_UNICODE -DUNICODE -DWIN32 -D_WIN32 -DWIN32_LEAN_AND_MEAN -D_WIN32_WINNT=0x0501")
  #set(cxx_base_flags "${cxx_base_flags} -DSTRICT")
  set(cxx_base_flags "${cxx_base_flags} -D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS -Dinline=__inline")
  set(cxx_exception_flags "-EHsc -D_HAS_EXCEPTIONS=1")
  set(cxx_no_exception_flags "-D_HAS_EXCEPTIONS=0")
  set(cxx_no_rtti_flags "-GR-")
elseif (CMAKE_COMPILER_IS_GNUCXX)
  set(cxx_base_flags "-Wall -Wno-shadow")
  set(cxx_exception_flags "-fexceptions")
  set(cxx_no_exception_flags "-fno-exceptions")
  # Until version 4.3.2, GCC doesn't define a macro to indicate
  # whether RTTI is enabled.  Therefore we define CETTY _HAS_RTTI
  # explicitly.
  set(cxx_no_rtti_flags "-fno-rtti -DCETTY_HAS_RTTI=0")
  set(cxx_strict_flags "-Wextra")
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "SunPro")
  set(cxx_exception_flags "-features=except")
  # Sun Pro doesn't provide macros to indicate whether exceptions and
  # RTTI are enabled, so we define CETTY_HAS_* explicitly.
  set(cxx_no_exception_flags "-features=no%except -DCETTY_HAS_EXCEPTIONS=0")
  set(cxx_no_rtti_flags "-features=no%rtti -DCETTY_HAS_RTTI=0")
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "VisualAge" OR
        CMAKE_CXX_COMPILER_ID STREQUAL "XL")
  # CMake 2.8 changes Visual Age's compiler ID to "XL".
  set(cxx_exception_flags "-qeh")
  set(cxx_no_exception_flags "-qnoeh")
  # Until version 9.0, Visual Age doesn't define a macro to indicate
  # whether RTTI is enabled.  Therefore we define CETTY_HAS_RTTI
  # explicitly.
  set(cxx_no_rtti_flags "-qnortti -DCETTY_HAS_RTTI=0")
endif()

if (CMAKE_USE_PTHREADS_INIT)  # The pthreads library is available.
  set(cxx_base_flags "${cxx_base_flags} -DCETTY_HAS_PTHREAD=1")
endif()

# For building cetty's own tests and samples.
set(cxx_exception "${CMAKE_CXX_FLAGS} ${cxx_base_flags} ${cxx_exception_flags}")
set(cxx_no_exception
    "${CMAKE_CXX_FLAGS} ${cxx_base_flags} ${cxx_no_exception_flags}")
set(cxx_default "${cxx_exception}")
set(cxx_no_rtti "${cxx_default} ${cxx_no_rtti_flags}")

# For building the cetty libraries.
set(cxx_strict "${cxx_default} ${cxx_strict_flags}")

if (CMAKE_COMPILER_IS_GNUCXX)
  set(CXX_FLAGS
    -g
    # -DVALGRIND
    -D_FILE_OFFSET_BITS=64
    -Wall
    -Wextra
    #-Werror
    -Wconversion
    -Wno-unused-parameter
    -Wold-style-cast
    -Woverloaded-virtual
    -Wpointer-arith
    #-Wshadow
    -Wwrite-strings
    #-march=native
    # -MMD
    # -std=c++0x
    -rdynamic
    )
  if(CMAKE_BUILD_BITS EQUAL 32)
    list(APPEND CXX_FLAGS "-m32")
  endif()
  string(REPLACE ";" " " CMAKE_CXX_FLAGS "${CXX_FLAGS}")

  set(CMAKE_CXX_FLAGS_DEBUG "-O0")
  set(CMAKE_CXX_FLAGS_RELEASE "-O2 -finline-limit=1000 -DNDEBUG")
endif()

license_type: permissive

branch_name: refs/heads/master

extension: cmake


text:
DESCRIPTION = "libspf2 is a complete and robust implementation of SPF which \
provides support for many MTAs."
SECTION = "libs/network"
LICENSE = "LGPL"
HOMEPAGE = "http://spf.anarres.org/index.html"
SRC_URI = "http://spf.anarres.org/spf/libspf2-${PV}.tar.gz"
S = "${WORKDIR}/libspf2-${PV}"

SRC_URI[md5sum] = "3305df4d1b13ca964d80b23bb5e4e2b6"
SRC_URI[sha256sum] = "4837f6b063b1431673754cbf6bef8979de5ffc4d7f26f6b93abd42787ba04862"

inherit autotools

PACKAGES =+ "${PN}-bin-dbg ${PN}-bin"
FILES_${PN}-bin = "${bindir}"
FILES_${PN}-bin-dbg = "${bindir}/.debug"
FILES_${PN} = "${libdir}/lib*.so.*"

license: MIT

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD

extension: bb


text:
DESCRIPTION = "Wt is a C++ library for developing web applications"
HOMEPAGE = "http://www.webtoolkit.eu/wt"
DEPENDS = "boost openssl sqlite3 zlib"

LICENSE = "GPL-2.0-with-OpenSSL-exception"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/GPL-2.0-with-OpenSSL-exception;md5=d9e4412f125e3e6f14efba8ce7b4604f"

inherit cmake

PR = "5"

SRCREV = "${AUTOREV}"
SRC_URI = "git://github.com/kdeforche/wt.git \
           file://custom-cmakelists.patch \
           file://default-log-level.patch \
          "

S = "${WORKDIR}/git"

EXTRA_OECMAKE = "-DCMAKE_INSTALL_PREFIX=${D}${prefix} \
		-DCONFIGDIR=${D}${sysconfdir}/wt"

do_install() {
    export INSTALL_ROOT=${D}
    make install
}

FILES_${PN} = "${libdir} ${bindir} ${datadir} ${prefix} ${sysconfdir}"

repository: Pansenti/meta-pansenti

repo_name: Pansenti/meta-pansenti


text:
package framework

import (
	"context"
	"encoding/json"
	"io/ioutil"
	"net/http"

	"github.com/ghodss/yaml"
	"github.com/rh-messaging/shipshape/pkg/framework/log"
	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	"k8s.io/apimachinery/pkg/runtime/schema"
)

type ResourceType int

const (
	Issuers ResourceType = iota
	Certificates
	Deployments
)

var (
	resourceMap = map[ResourceType]schema.GroupVersionResource{
		Issuers: {
			Group:    "certmanager.k8s.io",
			Version:  "v1alpha1",
			Resource: "issuers",
		},
		Certificates: {
			Group:    "certmanager.k8s.io",
			Version:  "v1alpha1",
			Resource: "certificates",
		},
		Deployments: {Group: "apps", Version: "v1", Resource: "deployments"},
	}
)

// GetResource returns the given resource type, identified by its given name
func (c *ContextData) GetResource(resourceType ResourceType, name string) (*unstructured.Unstructured, error) {
	return c.Clients.DynClient.Resource(resourceMap[resourceType]).Namespace(c.Namespace).Get(context.TODO(), name, v1.GetOptions{})
}
func (c *ContextData) GetResourceGroupVersion(gv schema.GroupVersionResource, name string) (*unstructured.Unstructured, error) {
	return c.Clients.DynClient.Resource(gv).Namespace(c.Namespace).Get(context.TODO(), name, v1.GetOptions{})
}

// ListResources returns a list of resources found in the related Framework's namespace,
// for the given resource type
func (c *ContextData) ListResources(resourceType ResourceType) (*unstructured.UnstructuredList, error) {
	return c.Clients.DynClient.Resource(resourceMap[resourceType]).Namespace(c.Namespace).List(context.TODO(), v1.ListOptions{})
}
func (c *ContextData) ListResourcesGroupVersion(gv schema.GroupVersionResource) (*unstructured.UnstructuredList, error) {
	return c.Clients.DynClient.Resource(gv).Namespace(c.Namespace).List(context.TODO(), v1.ListOptions{})
}

// CreateResource creates a resource based on provided (known) resource type and unstructured data
func (c *ContextData) CreateResource(resourceType ResourceType, obj *unstructured.Unstructured, options v1.CreateOptions, subresources ...string) (*unstructured.Unstructured, error) {
	return c.Clients.DynClient.Resource(resourceMap[resourceType]).Namespace(c.Namespace).Create(context.TODO(), obj, options, subresources...)
}
func (c *ContextData) CreateResourceGroupVersion(gv schema.GroupVersionResource, obj *unstructured.Unstructured, options v1.CreateOptions, subresources ...string) (*unstructured.Unstructured, error) {
	return c.Clients.DynClient.Resource(gv).Namespace(c.Namespace).Create(context.TODO(), obj, options, subresources...)
}

// DeleteResource deletes a resource based on provided (known) resource type and name
func (c *ContextData) DeleteResource(resourceType ResourceType, name string, options v1.DeleteOptions, subresources ...string) error {
	return c.Clients.DynClient.Resource(resourceMap[resourceType]).Namespace(c.Namespace).Delete(context.TODO(), name, options, subresources...)
}
func (c *ContextData) DeleteResourceGroupVersion(gv schema.GroupVersionResource, name string, options v1.DeleteOptions, subresources ...string) error {
	return c.Clients.DynClient.Resource(gv).Namespace(c.Namespace).Delete(context.TODO(), name, options, subresources...)
}

func LoadYamlFromUrl(url string) (*unstructured.Unstructured, error) {
	var unsObj unstructured.Unstructured

	resp, err := http.Get(url) //load yaml body from url
	if err != nil {
		log.Logf("error during loading %s: %v", url, err)
		return nil, err
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Logf("error during loading %s: %v", url, err)
		return nil, err
	}
	jsonBody, err := yaml.YAMLToJSON(body)
	if err != nil {
		log.Logf("error during parsing %s: %v", url, err)
		return nil, err
	}

	err = json.Unmarshal(jsonBody, &unsObj)
	return &unsObj, err
}

repository: rh-messaging/shipshape

repo_name: rh-messaging/shipshape

gha_language: Go

extension: go


text:
/*
 * Copyright (c) 2017-2019 THL A29 Limited, a Tencent company. All Rights Reserved.
 *
 * 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.
 */

#ifndef TENCENTCLOUD_MPS_V20190612_MODEL_MEDIAPROCESSTASKRESULT_H_
#define TENCENTCLOUD_MPS_V20190612_MODEL_MEDIAPROCESSTASKRESULT_H_

#include <string>
#include <vector>
#include <map>
#include <tencentcloud/core/utils/rapidjson/document.h>
#include <tencentcloud/core/utils/rapidjson/writer.h>
#include <tencentcloud/core/utils/rapidjson/stringbuffer.h>
#include <tencentcloud/core/AbstractModel.h>
#include <tencentcloud/mps/v20190612/model/MediaProcessTaskTranscodeResult.h>
#include <tencentcloud/mps/v20190612/model/MediaProcessTaskAnimatedGraphicResult.h>
#include <tencentcloud/mps/v20190612/model/MediaProcessTaskSnapshotByTimeOffsetResult.h>
#include <tencentcloud/mps/v20190612/model/MediaProcessTaskSampleSnapshotResult.h>
#include <tencentcloud/mps/v20190612/model/MediaProcessTaskImageSpriteResult.h>
#include <tencentcloud/mps/v20190612/model/MediaProcessTaskAdaptiveDynamicStreamingResult.h>

namespace TencentCloud
{
    namespace Mps
    {
        namespace V20190612
        {
            namespace Model
            {
                /**
                * 任务查询结果类型
                */
                class MediaProcessTaskResult : public AbstractModel
                {
                public:
                    MediaProcessTaskResult();
                    ~MediaProcessTaskResult() = default;
                    void ToJsonObject(rapidjson::Value &value, rapidjson::Document::AllocatorType& allocator) const;
                    CoreInternalOutcome Deserialize(const rapidjson::Value &value);

                    /**
                     * 获取任务的类型，可以取的值有：

Transcode：转码

AnimatedGraphics：转动图

SnapshotByTimeOffset：时间点截图

SampleSnapshot：采样截图

ImageSprites：雪碧图

CoverBySnapshot：截图做封面

AdaptiveDynamicStreaming：自适应码流

                     * @return Type 任务的类型，可以取的值有：

Transcode：转码

AnimatedGraphics：转动图

SnapshotByTimeOffset：时间点截图

SampleSnapshot：采样截图

ImageSprites：雪碧图

CoverBySnapshot：截图做封面

AdaptiveDynamicStreaming：自适应码流

                     *
                     */
                    std::string GetType() const;

                    /**
                     * 设置任务的类型，可以取的值有：

Transcode：转码

AnimatedGraphics：转动图

SnapshotByTimeOffset：时间点截图

SampleSnapshot：采样截图

ImageSprites：雪碧图

CoverBySnapshot：截图做封面

AdaptiveDynamicStreaming：自适应码流

                     * @param _type 任务的类型，可以取的值有：

Transcode：转码

AnimatedGraphics：转动图

SnapshotByTimeOffset：时间点截图

SampleSnapshot：采样截图

ImageSprites：雪碧图

CoverBySnapshot：截图做封面

AdaptiveDynamicStreaming：自适应码流

                     *
                     */
                    void SetType(const std::string& _type);

                    /**
                     * 判断参数 Type 是否已赋值
                     * @return Type 是否已赋值
                     *
                     */
                    bool TypeHasBeenSet() const;

                    /**
                     * 获取视频转码任务的查询结果，当任务类型为 Transcode 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     * @return TranscodeTask 视频转码任务的查询结果，当任务类型为 Transcode 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     *
                     */
                    MediaProcessTaskTranscodeResult GetTranscodeTask() const;

                    /**
                     * 设置视频转码任务的查询结果，当任务类型为 Transcode 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     * @param _transcodeTask 视频转码任务的查询结果，当任务类型为 Transcode 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     *
                     */
                    void SetTranscodeTask(const MediaProcessTaskTranscodeResult& _transcodeTask);

                    /**
                     * 判断参数 TranscodeTask 是否已赋值
                     * @return TranscodeTask 是否已赋值
                     *
                     */
                    bool TranscodeTaskHasBeenSet() const;

                    /**
                     * 获取视频转动图任务的查询结果，当任务类型为 AnimatedGraphics 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     * @return AnimatedGraphicTask 视频转动图任务的查询结果，当任务类型为 AnimatedGraphics 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     *
                     */
                    MediaProcessTaskAnimatedGraphicResult GetAnimatedGraphicTask() const;

                    /**
                     * 设置视频转动图任务的查询结果，当任务类型为 AnimatedGraphics 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     * @param _animatedGraphicTask 视频转动图任务的查询结果，当任务类型为 AnimatedGraphics 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     *
                     */
                    void SetAnimatedGraphicTask(const MediaProcessTaskAnimatedGraphicResult& _animatedGraphicTask);

                    /**
                     * 判断参数 AnimatedGraphicTask 是否已赋值
                     * @return AnimatedGraphicTask 是否已赋值
                     *
                     */
                    bool AnimatedGraphicTaskHasBeenSet() const;

                    /**
                     * 获取对视频按时间点截图任务的查询结果，当任务类型为 SnapshotByTimeOffset 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     * @return SnapshotByTimeOffsetTask 对视频按时间点截图任务的查询结果，当任务类型为 SnapshotByTimeOffset 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     *
                     */
                    MediaProcessTaskSnapshotByTimeOffsetResult GetSnapshotByTimeOffsetTask() const;

                    /**
                     * 设置对视频按时间点截图任务的查询结果，当任务类型为 SnapshotByTimeOffset 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     * @param _snapshotByTimeOffsetTask 对视频按时间点截图任务的查询结果，当任务类型为 SnapshotByTimeOffset 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     *
                     */
                    void SetSnapshotByTimeOffsetTask(const MediaProcessTaskSnapshotByTimeOffsetResult& _snapshotByTimeOffsetTask);

                    /**
                     * 判断参数 SnapshotByTimeOffsetTask 是否已赋值
                     * @return SnapshotByTimeOffsetTask 是否已赋值
                     *
                     */
                    bool SnapshotByTimeOffsetTaskHasBeenSet() const;

                    /**
                     * 获取对视频采样截图任务的查询结果，当任务类型为 SampleSnapshot 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     * @return SampleSnapshotTask 对视频采样截图任务的查询结果，当任务类型为 SampleSnapshot 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     *
                     */
                    MediaProcessTaskSampleSnapshotResult GetSampleSnapshotTask() const;

                    /**
                     * 设置对视频采样截图任务的查询结果，当任务类型为 SampleSnapshot 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     * @param _sampleSnapshotTask 对视频采样截图任务的查询结果，当任务类型为 SampleSnapshot 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     *
                     */
                    void SetSampleSnapshotTask(const MediaProcessTaskSampleSnapshotResult& _sampleSnapshotTask);

                    /**
                     * 判断参数 SampleSnapshotTask 是否已赋值
                     * @return SampleSnapshotTask 是否已赋值
                     *
                     */
                    bool SampleSnapshotTaskHasBeenSet() const;

                    /**
                     * 获取对视频截雪碧图任务的查询结果，当任务类型为 ImageSprite 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     * @return ImageSpriteTask 对视频截雪碧图任务的查询结果，当任务类型为 ImageSprite 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     *
                     */
                    MediaProcessTaskImageSpriteResult GetImageSpriteTask() const;

                    /**
                     * 设置对视频截雪碧图任务的查询结果，当任务类型为 ImageSprite 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     * @param _imageSpriteTask 对视频截雪碧图任务的查询结果，当任务类型为 ImageSprite 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     *
                     */
                    void SetImageSpriteTask(const MediaProcessTaskImageSpriteResult& _imageSpriteTask);

                    /**
                     * 判断参数 ImageSpriteTask 是否已赋值
                     * @return ImageSpriteTask 是否已赋值
                     *
                     */
                    bool ImageSpriteTaskHasBeenSet() const;

                    /**
                     * 获取转自适应码流任务查询结果，当任务类型为 AdaptiveDynamicStreaming 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     * @return AdaptiveDynamicStreamingTask 转自适应码流任务查询结果，当任务类型为 AdaptiveDynamicStreaming 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     *
                     */
                    MediaProcessTaskAdaptiveDynamicStreamingResult GetAdaptiveDynamicStreamingTask() const;

                    /**
                     * 设置转自适应码流任务查询结果，当任务类型为 AdaptiveDynamicStreaming 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     * @param _adaptiveDynamicStreamingTask 转自适应码流任务查询结果，当任务类型为 AdaptiveDynamicStreaming 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     *
                     */
                    void SetAdaptiveDynamicStreamingTask(const MediaProcessTaskAdaptiveDynamicStreamingResult& _adaptiveDynamicStreamingTask);

                    /**
                     * 判断参数 AdaptiveDynamicStreamingTask 是否已赋值
                     * @return AdaptiveDynamicStreamingTask 是否已赋值
                     *
                     */
                    bool AdaptiveDynamicStreamingTaskHasBeenSet() const;

                private:

                    /**
                     * 任务的类型，可以取的值有：

Transcode：转码

AnimatedGraphics：转动图

SnapshotByTimeOffset：时间点截图

SampleSnapshot：采样截图

ImageSprites：雪碧图

CoverBySnapshot：截图做封面

AdaptiveDynamicStreaming：自适应码流

                     */
                    std::string m_type;
                    bool m_typeHasBeenSet;

                    /**
                     * 视频转码任务的查询结果，当任务类型为 Transcode 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     */
                    MediaProcessTaskTranscodeResult m_transcodeTask;
                    bool m_transcodeTaskHasBeenSet;

                    /**
                     * 视频转动图任务的查询结果，当任务类型为 AnimatedGraphics 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     */
                    MediaProcessTaskAnimatedGraphicResult m_animatedGraphicTask;
                    bool m_animatedGraphicTaskHasBeenSet;

                    /**
                     * 对视频按时间点截图任务的查询结果，当任务类型为 SnapshotByTimeOffset 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     */
                    MediaProcessTaskSnapshotByTimeOffsetResult m_snapshotByTimeOffsetTask;
                    bool m_snapshotByTimeOffsetTaskHasBeenSet;

                    /**
                     * 对视频采样截图任务的查询结果，当任务类型为 SampleSnapshot 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     */
                    MediaProcessTaskSampleSnapshotResult m_sampleSnapshotTask;
                    bool m_sampleSnapshotTaskHasBeenSet;

                    /**
                     * 对视频截雪碧图任务的查询结果，当任务类型为 ImageSprite 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     */
                    MediaProcessTaskImageSpriteResult m_imageSpriteTask;
                    bool m_imageSpriteTaskHasBeenSet;

                    /**
                     * 转自适应码流任务查询结果，当任务类型为 AdaptiveDynamicStreaming 时有效。
注意：此字段可能返回 null，表示取不到有效值。
                     */
                    MediaProcessTaskAdaptiveDynamicStreamingResult m_adaptiveDynamicStreamingTask;
                    bool m_adaptiveDynamicStreamingTaskHasBeenSet;

                };
            }
        }
    }
}

#endif // !TENCENTCLOUD_MPS_V20190612_MODEL_MEDIAPROCESSTASKRESULT_H_

repository: TencentCloud/tencentcloud-sdk-cpp

repo_name: TencentCloud/tencentcloud-sdk-cpp

extension: h


text:
// Copyright 2016 Google 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 parts

import (
	"fmt"
	"html/template"
	"net/http"
)

const textFileReaderEditTemplateSrc = `

	Wait for
	<select name="WaitFor">
		<option value="" {{if eq "" $.Node.Part.WaitFor}}selected{{end}}>[None]</option>
		{{range .Graph.Channels -}}
		<option value="{{.Name}}" {{if eq .Name $.Node.Part.WaitFor}}selected{{end}}>{{.Name}}</option>
		{{- end}}
	</select>

	File path
	<input type="text" name="FilePath" value="{{$.Node.Part.Path}}" required></input>

	Output
	<select name="Output">
		{{range .Graph.Channels -}}
		{{if eq .Type "string" }}
		<option value="{{.Name}}" {{if eq .Name $.Node.Part.Output}}selected{{end}}>{{.Name}}</option>
		{{- end}}
		{{- end}}
	</select>

	Error
	<select name="Error">
		{{range .Graph.Channels -}}
		{{if eq .Type "error"}}
		<option value="{{.Name}}" {{if eq .Name $.Node.Part.Error}}selected{{end}}>{{.Name}}</option>
		{{- end}}
		{{- end}}
	</select>

`

// TextFileReader waits for an input channel to close or send a value, then
// reads a file, and streams the lines of text to an output channel typed string,
// closing the output channel when done. If an error occurs, it stops reading and
// the error is sent to an error channel, which is not closed.
type TextFileReader struct {
	WaitFor string `json:"wait_for"`
	Path    string `json:"path"`
	Output  string `json:"output"`
	Error   string `json:"errors"`
}

// AssociateEditor associates a template called "part_view" with the given template.
func (r *TextFileReader) AssociateEditor(t *template.Template) error {
	_, err := t.New("part_view").Parse(textFileReaderEditTemplateSrc)
	return err
}

// Channels returns any channels used. Anything returned that is not a channel is ignored.
func (r *TextFileReader) Channels() (read, written []string) {
	if r.WaitFor == "" {
		read = []string{r.WaitFor}
	}
	return read, []string{r.Output, r.Error}
}

// Clone returns a copy of this part.
func (r *TextFileReader) Clone() interface{} {
	s := *r
	return &s
}

// Impl returns Go source code implementing the part.
func (r *TextFileReader) Impl() (head, body, tail string) {
	if r.WaitFor != "" {
		head = fmt.Sprintf("<-%s", r.WaitFor)
	}
	body = fmt.Sprintf(`partlib.StreamTextFile("%s", %s, %s)`, r.Path, r.Output, r.Error)
	tail = fmt.Sprintf("close(%s)", r.Output)
	return head, body, tail
}

// Imports returns any extra import lines needed.
func (*TextFileReader) Imports() []string {
	return []string{
		`"github.com/google/shenzhen-go/parts/partlib"`,
	}
}

// Update sets fields in the part based on info in the given Request.
func (r *TextFileReader) Update(req *http.Request) error {
	if req == nil {
		return nil
	}
	if err := req.ParseForm(); err != nil {
		return err
	}
	r.WaitFor = req.FormValue("WaitFor")
	r.Output = req.FormValue("Output")
	r.Error = req.FormValue("Error")
	r.Path = req.FormValue("FilePath")
	return nil
}

// TypeKey returns the string "TextFileReader"
func (*TextFileReader) TypeKey() string {
	return "TextFileReader"
}

repository: aknysh/shenzhen-go

repo_name: aknysh/shenzhen-go


text:
package main

import (
	"html/template"
	"io"
	"log"
	"net/http"
	"strconv"
	"time"

	"github.com/shurcooL/home/component"
	"github.com/shurcooL/home/httputil"
	"github.com/shurcooL/home/internal/exp/service/notification"
	"github.com/shurcooL/home/internal/page/resume"
	"github.com/shurcooL/httperror"
	"github.com/shurcooL/reactions"
	"github.com/shurcooL/users"
)

var resumeHTML = template.Must(template.New("").Funcs(template.FuncMap{"noescape": func(s string) template.HTML { return template.HTML(s) }}).Parse(`<html>
	<head>
{{.AnalyticsHTML}}		<title>Dmitri Shuralyov - Resume</title>
		<link href="/icon.svg" rel="icon" type="image/svg+xml">
		<meta name="viewport" content="width=device-width">
		<link href="/assets/fonts/fonts.css" rel="stylesheet" type="text/css">
		<link href="/assets/resume/style.css" rel="stylesheet" type="text/css">
		<script>var RedLogo = {{.RedLogo}};</script>

		{{noescape "<!-- Unminified source is at https://github.com/shurcooL/resume. -->"}}
		<script async src="/assets/resume/resume.js"></script>
	</head>
	<body>`))

func initResume(reactions reactions.Service, notification notification.Service, usersService users.Service) {
	http.Handle("/resume", cookieAuth{httputil.ErrorHandler(usersService, func(w http.ResponseWriter, req *http.Request) error {
		if req.Method != "GET" {
			return httperror.Method{Allowed: []string{"GET"}}
		}

		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		data := struct {
			AnalyticsHTML template.HTML
			RedLogo       bool
		}{analyticsHTML, component.RedLogo}
		err := resumeHTML.Execute(w, data)
		if err != nil {
			return err
		}

		// Optional (still experimental) server-side rendering.
		prerender, _ := strconv.ParseBool(req.URL.Query().Get("prerender"))
		if prerender {
			authenticatedUser, err := usersService.GetAuthenticated(req.Context())
			if err != nil {
				log.Println(err)
				authenticatedUser = users.User{} // THINK: Should it be a fatal error or not? What about on frontend vs backend?
			}
			returnURL := req.RequestURI
			err = resume.RenderBodyInnerHTML(req.Context(), w, reactions, notification, usersService, time.Now(), authenticatedUser, returnURL)
			if err != nil {
				return err
			}
		}

		_, err = io.WriteString(w, `</body></html>`)
		return err
	})})
}

repository: shurcooL/home

repo_name: shurcooL/home

gha_license_id: MIT


text:
DESCRIPTION = "USB Device Firmware Upgrade utility"
SECTION = "devel"
AUTHOR = "Harald Welte <laforge@openmoko.org>"
LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://COPYING;md5=94d55d512a9ba36caa9b7df079bae19f"

S = "${WORKDIR}/git"

SRC_URI = "git://gitorious.org/dfu-util/dfu-util.git \
    file://0001-configure.ac-Don-t-check-for-usbpath.patch \
"
SRCREV="a0a3668e0571a9b007f7d62b01e7dcfd7754ce50"

inherit autotools pkgconfig

DEPENDS = "libusb1"

SRC_URI[md5sum] = "1de724551604bce1962960b7a301cc08"
SRC_URI[sha256sum] = "5d253f924fd29bc13054b664bba9aa86b865299971195969478253c1775b7e56"

branch_name: refs/heads/fido

gha_language: BitBake


text:
# Copyright (C) 2016 WinSystems, Inc.
# Released under the MIT license (see COPYING.MIT for the terms)

SUMMARY = "Linux Kernel provided and supported by WinSYstems"

require recipes-kernel/linux/linux-imx.inc
require recipes-kernel/linux/linux-dtb.inc

DEPENDS += "lzop-native bc-native"

SRCBRANCH = "imx_3.14.28_1.0.0_ga"
LOCALVERSION = "-1.0.0_ga"
SRCREV = "91cf351a2afc17ac4a260e4d2ad1e32d00925a1b"

SRC_URI = "git://git.freescale.com/imx/linux-2.6-imx.git;protocol=git;branch=${SRCBRANCH} \
           file://0001-imx6dl-c420-Add-device-tree.patch \
           file://0002-imx6dl-c420-Add-gpio-panel-select-support.patch \
           file://0003-imx6dl-c420-Add-rs422-rs485-support.patch \
           file://defconfig \
"

DEFAULT_PREFERENCE = "1"

COMPATIBLE_MACHINE = "(mx6)"
COMPATIBLE_MACHINE = "(imx6dlc420)"


text:
SUMMARY = "Start the mender daemon"

LICENSE = "GPL-2.0"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/GPL-2.0;md5=801f80980d171dd6425610833a22dbe6"

SRC_URI = "file://init"

S = "${WORKDIR}"

inherit update-rc.d

INITSCRIPT_NAME = "mender.sh"
INITSCRIPT_PARAMS = "start 99 5 .  stop 10 0 6 ."

do_install_append () {
    install -d ${D}${sysconfdir}/init.d
    install -m 0755 init ${D}${sysconfdir}/init.d/mender.sh
}

FILES_${PN} = "${sysconfdir}"


text:
package main

import (
	"fmt"
	"log"
	"net/http"
)

// Server Structura del servidor
type Server struct {
	port   string
	router *Router
}

// NewServer Crea un nuevo Servidor
func NewServer(port string) *Server {
	return &Server{
		port:   port,
		router: NewRouter(),
	}
}

// Listen Pone a escuchar el servidor
func (s *Server) Listen() error {
	http.Handle("/", s.router)
	err := http.ListenAndServe(s.port, nil)

	if err != nil {
		log.Fatal("[!] Inposible de lanzar el servidor", err)
		fmt.Println("[!] Inposible de lanzar el servidor", err)
		return err
	}
	fmt.Println("[+] Server Activo", s.port)
	log.Print("[+] Server Activo", s.port)
	return nil
}

// Handle Pone a escuchar
func (s *Server) Handle(path string, method string, handler http.HandlerFunc) {
	//Check if the path already exists
	if !s.router.FindPath(path) {
		//If not path then create a new one
		s.router.rules[path] = make(map[string]http.HandlerFunc)
	}
	s.router.rules[path][method] = handler
}

// AddMiddleware AddMiddleware
func (s *Server) AddMiddleware(f http.HandlerFunc, middlewares ...Middleware) http.HandlerFunc {
	for _, m := range middlewares {
		f = m(f)
	}
	return f
}

// Handler Handler
type Handler func(w http.ResponseWriter, r *http.Request)

// Middleware Middleware
type Middleware func(http.HandlerFunc) http.HandlerFunc

repository: Fatake/Go

repo_name: Fatake/Go


text:
@article{camposbehavioraladaptationsheat2009,
 abstract = {We examined thermoregulatory behaviors in a wild
population of white-faced capuchins (Cebus capucinus)
inhabiting a highly seasonal dry forest in Santa Rosa
National Park (SRNP), Costa Rica. The dry season in SRNP
lasts approximately 5 months and is characterized by high
ambient temperatures regularly exceeding 37 degrees C, low
relative humidity, and the near absence of precipitation.
This study demonstrates that capuchins rest more and travel
shorter distances during the hottest and driest hours of
the day, and suggests that they extend their tongues to
lower body temperature via evaporative cooling. Seasonal
weather patterns and group movement data reported here are
based on 940 h of observations on three social groups of
capuchins (wet season: 370 h, dry season: 570 h). In the
dry season, the proportion of time spent resting increased
at higher temperatures whereas the proportion of time spent
traveling decreased. Distance traveled between location
points taken at half-hour intervals decreased significantly
as temperature increased, although the correlation was not
strong. Capuchins exposed their tongues during hot, dry,
windy conditions, and this behavior was much more frequent
in the dry season. Temperature was significantly higher and
humidity significantly lower for "tongue-out" events than
expected for a random event in the dry season. Finally, as
surface water became scarce, home-range areas of heavy use
became increasingly centered on the remaining permanent
water sources. These results suggest that heat stress and
water scarcity are significant influences on the behavior
of capuchins in hot, dry conditions.},
 author = {Campos, Fernando A. and Fedigan, Linda M.},
 doi = {10.1002/ajpa.20908},
 issn = {0002-9483},
 journal = {American Journal of Physical Anthropology},
 keywords = {Acclimatization,Acclimatization: physiology,Animal,Animal:
physiology,Animals,Behavior,Cebus,Cebus:
physiology,Climate,costa rica,Face,Face: anatomy &
histology,Face: physiology,Hot
Temperature,Humidity,Seasons,Temperature,Water Supply},
 month = {January},
 number = {1},
 pages = {101--111},
 title = {Behavioral Adaptations to Heat Stress and Water Scarcity
in White-Faced Capuchins (\emphCebus\emph
Capucinus) in Santa Rosa National Park, Costa
Rica},
 volume = {138},
 year = {2009}
}

repository: camposfa/academic-website

repo_name: camposfa/academic-website

extension: bib


text:
@inproceedings{Nacenta:2008,
 author = {Nacenta, Miguel A. and Mandryk, Regan L. and Gutwin, Carl},
 title = {Targeting Across Displayless Space},
 booktitle = {Proceedings of the SIGCHI Conference on Human Factors in Computing Systems},
 series = {CHI '08},
 year = {2008},
 isbn = {978-1-60558-011-1},
 location = {Florence, Italy},
 pages = {777--786},
 numpages = {10},
 url = {http://doi.acm.org/10.1145/1357054.1357178},
 doi = {10.1145/1357054.1357178},
 acmid = {1357178},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {displayless space, halo, mouse ether, multi-display environments, multi-monitor, off-screen feedback, stitching},
}

@article{Shoemaker:2012,
 author = {Shoemaker, Garth and Tsukitani, Takayuki and Kitamura, Yoshifumi and Booth, Kellogg S.},
 title = {Two-Part Models Capture the Impact of Gain on Pointing Performance},
 journal = {ACM Trans. Comput.-Hum. Interact.},
 issue_date = {December 2012},
 volume = {19},
 number = {4},
 month = dec,
 year = {2012},
 issn = {1073-0516},
 pages = {28:1--28:34},
 articleno = {28},
 numpages = {34},
 url = {http://doi.acm.org/10.1145/2395131.2395135},
 doi = {10.1145/2395131.2395135},
 acmid = {2395135},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {Fitts, Welford, gain, interaction techniques, large displays, pointing},
}

@inproceedings{Wilson:2011,
 author = {Wilson, Max L. and Mackay, Wendy and Chi, Ed and Bernstein, Michael and Russell, Dan and Thimbleby, Harold},
 title = {RepliCHI - CHI Should Be Replicating and Validating Results More: Discuss},
 booktitle = {CHI '11 Extended Abstracts on Human Factors in Computing Systems},
 series = {CHI EA '11},
 year = {2011},
 isbn = {978-1-4503-0268-5},
 location = {Vancouver, BC, Canada},
 pages = {463--466},
 numpages = {4},
 url = {http://doi.acm.org/10.1145/1979742.1979491},
 doi = {10.1145/1979742.1979491},
 acmid = {1979491},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {hci, replication, research, science},
}

@inproceedings{Wilson:2012,
 author = {Wilson, Max and Mackay, Wendy and Chi, Ed and Bernstein, Michael and Nichols, Jeffrey},
 title = {RepliCHI SIG: From a Panel to a New Submission Venue for Replication},
 booktitle = {CHI '12 Extended Abstracts on Human Factors in Computing Systems},
 series = {CHI EA '12},
 year = {2012},
 isbn = {978-1-4503-1016-1},
 location = {Austin, Texas, USA},
 pages = {1185--1188},
 numpages = {4},
 url = {http://doi.acm.org/10.1145/2212776.2212419},
 doi = {10.1145/2212776.2212419},
 acmid = {2212419},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {replication, reproducing results, research methods},
}

@inproceedings{Wilson:2013,
 author = {Wilson, Max L. L. and Resnick, Paul and Coyle, David and Chi, Ed H.},
 title = {RepliCHI: The Workshop},
 booktitle = {CHI '13 Extended Abstracts on Human Factors in Computing Systems},
 series = {CHI EA '13},
 year = {2013},
 isbn = {978-1-4503-1952-2},
 location = {Paris, France},
 pages = {3159--3162},
 numpages = {4},
 url = {http://doi.acm.org/10.1145/2468356.2479636},
 doi = {10.1145/2468356.2479636},
 acmid = {2479636},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {evaluation, methodology, replication},
}

@inproceedings{Wilson:2014,
 author = {Wilson, Max L. and Chi, Ed H. and Reeves, Stuart and Coyle, David},
 title = {RepliCHI: The Workshop II},
 booktitle = {CHI '14 Extended Abstracts on Human Factors in Computing Systems},
 series = {CHI EA '14},
 year = {2014},
 isbn = {978-1-4503-2474-8},
 location = {Toronto, Ontario, Canada},
 pages = {33--36},
 numpages = {4},
 url = {http://doi.acm.org/10.1145/2559206.2559233},
 doi = {10.1145/2559206.2559233},
 acmid = {2559233},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {evaluation, methodology, replication},
}

@inproceedings{Mackay:2007,
 author = {Mackay, Wendy E. and Appert, Caroline and Beaudouin-Lafon, Michel and Chapuis, Olivier and Du, Yangzhou and Fekete, Jean-Daniel and Guiard, Yves},
 title = {Touchstone: Exploratory Design of Experiments},
 booktitle = {Proceedings of the SIGCHI Conference on Human Factors in Computing Systems},
 series = {CHI '07},
 year = {2007},
 isbn = {978-1-59593-593-9},
 location = {San Jose, California, USA},
 pages = {1425--1434},
 numpages = {10},
 url = {http://doi.acm.org/10.1145/1240624.1240840},
 doi = {10.1145/1240624.1240840},
 acmid = {1240840},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {benchmarking, experimental design, interaction techniques, touchstone},
}

@misc{Nacenta:memorability_data,
	title = {Memorability of pre-designed and user-defined gesture sets: experimental dataset},
	url = {http://research-repository.st-andrews.ac.uk/handle/10023/3486},
	urldate = {2014-09-01},
	journal = {University of St Andrews Research Repository},
	author = {Nacenta, Miguel A. and Kamber, Yemliha and Qiang, Yizhou and Kristensson, Per Ola}
}

@book{hartson:2012,
  title={The UX book: process and guidelines for ensuring a quality user experience},
  author={Hartson, Rex and Pyla, Pardha S},
  year={2012},
  publisher={Elsevier}
}

@inproceedings{Grijincu:2014,
 author = {Grijincu, Daniela and Nacenta, Miguel A. and Kristensson, Per Ola},
 title = {User-defined Interface Gestures: a Dataset and Analysis},
 booktitle = {Proceedings of the ACM conference on Interactive Tabletops and Surfaces},
 series = {ITS'14},
 year = {2014 (in press)},
 location = {Dresden, Germany},
 pages = {},
 numpages = {10},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {Gesture design, user-defined gestures, gesture elicitation, gesture analysis methodology, gesture annotation, gesture memorability, gesture datasets},
}

repository: larskotthoff/recomputation-ss-paper

repo_name: larskotthoff/recomputation-ss-paper

gha_language: TeX


text:
/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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
 *
 *   https://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 model

import (
	"context"
	"fmt"
	"github.com/apache/plc4x/plc4go/spi/utils"
	"github.com/pkg/errors"
	"github.com/rs/zerolog"
	"io"
)

// Code generated by code-generation. DO NOT EDIT.

// ConfirmedPrivateTransferError is the corresponding interface of ConfirmedPrivateTransferError
type ConfirmedPrivateTransferError interface {
	fmt.Stringer
	utils.LengthAware
	utils.Serializable
	BACnetError
	// GetErrorType returns ErrorType (property field)
	GetErrorType() ErrorEnclosed
	// GetVendorId returns VendorId (property field)
	GetVendorId() BACnetVendorIdTagged
	// GetServiceNumber returns ServiceNumber (property field)
	GetServiceNumber() BACnetContextTagUnsignedInteger
	// GetErrorParameters returns ErrorParameters (property field)
	GetErrorParameters() BACnetConstructedData
}

// ConfirmedPrivateTransferErrorExactly can be used when we want exactly this type and not a type which fulfills ConfirmedPrivateTransferError.
// This is useful for switch cases.
type ConfirmedPrivateTransferErrorExactly interface {
	ConfirmedPrivateTransferError
	isConfirmedPrivateTransferError() bool
}

// _ConfirmedPrivateTransferError is the data-structure of this message
type _ConfirmedPrivateTransferError struct {
	*_BACnetError
	ErrorType       ErrorEnclosed
	VendorId        BACnetVendorIdTagged
	ServiceNumber   BACnetContextTagUnsignedInteger
	ErrorParameters BACnetConstructedData
}

///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
/////////////////////// Accessors for discriminator values.
///////////////////////

func (m *_ConfirmedPrivateTransferError) GetErrorChoice() BACnetConfirmedServiceChoice {
	return BACnetConfirmedServiceChoice_CONFIRMED_PRIVATE_TRANSFER
}

///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////

func (m *_ConfirmedPrivateTransferError) InitializeParent(parent BACnetError) {}

func (m *_ConfirmedPrivateTransferError) GetParent() BACnetError {
	return m._BACnetError
}

///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
/////////////////////// Accessors for property fields.
///////////////////////

func (m *_ConfirmedPrivateTransferError) GetErrorType() ErrorEnclosed {
	return m.ErrorType
}

func (m *_ConfirmedPrivateTransferError) GetVendorId() BACnetVendorIdTagged {
	return m.VendorId
}

func (m *_ConfirmedPrivateTransferError) GetServiceNumber() BACnetContextTagUnsignedInteger {
	return m.ServiceNumber
}

func (m *_ConfirmedPrivateTransferError) GetErrorParameters() BACnetConstructedData {
	return m.ErrorParameters
}

///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////

// NewConfirmedPrivateTransferError factory function for _ConfirmedPrivateTransferError
func NewConfirmedPrivateTransferError(errorType ErrorEnclosed, vendorId BACnetVendorIdTagged, serviceNumber BACnetContextTagUnsignedInteger, errorParameters BACnetConstructedData) *_ConfirmedPrivateTransferError {
	_result := &_ConfirmedPrivateTransferError{
		ErrorType:       errorType,
		VendorId:        vendorId,
		ServiceNumber:   serviceNumber,
		ErrorParameters: errorParameters,
		_BACnetError:    NewBACnetError(),
	}
	_result._BACnetError._BACnetErrorChildRequirements = _result
	return _result
}

// Deprecated: use the interface for direct cast
func CastConfirmedPrivateTransferError(structType any) ConfirmedPrivateTransferError {
	if casted, ok := structType.(ConfirmedPrivateTransferError); ok {
		return casted
	}
	if casted, ok := structType.(*ConfirmedPrivateTransferError); ok {
		return *casted
	}
	return nil
}

func (m *_ConfirmedPrivateTransferError) GetTypeName() string {
	return "ConfirmedPrivateTransferError"
}

func (m *_ConfirmedPrivateTransferError) GetLengthInBits(ctx context.Context) uint16 {
	lengthInBits := uint16(m.GetParentLengthInBits(ctx))

	// Simple field (errorType)
	lengthInBits += m.ErrorType.GetLengthInBits(ctx)

	// Simple field (vendorId)
	lengthInBits += m.VendorId.GetLengthInBits(ctx)

	// Simple field (serviceNumber)
	lengthInBits += m.ServiceNumber.GetLengthInBits(ctx)

	// Optional Field (errorParameters)
	if m.ErrorParameters != nil {
		lengthInBits += m.ErrorParameters.GetLengthInBits(ctx)
	}

	return lengthInBits
}

func (m *_ConfirmedPrivateTransferError) GetLengthInBytes(ctx context.Context) uint16 {
	return m.GetLengthInBits(ctx) / 8
}

func ConfirmedPrivateTransferErrorParse(ctx context.Context, theBytes []byte, errorChoice BACnetConfirmedServiceChoice) (ConfirmedPrivateTransferError, error) {
	return ConfirmedPrivateTransferErrorParseWithBuffer(ctx, utils.NewReadBufferByteBased(theBytes), errorChoice)
}

func ConfirmedPrivateTransferErrorParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, errorChoice BACnetConfirmedServiceChoice) (ConfirmedPrivateTransferError, error) {
	positionAware := readBuffer
	_ = positionAware
	log := zerolog.Ctx(ctx)
	_ = log
	if pullErr := readBuffer.PullContext("ConfirmedPrivateTransferError"); pullErr != nil {
		return nil, errors.Wrap(pullErr, "Error pulling for ConfirmedPrivateTransferError")
	}
	currentPos := positionAware.GetPos()
	_ = currentPos

	// Simple Field (errorType)
	if pullErr := readBuffer.PullContext("errorType"); pullErr != nil {
		return nil, errors.Wrap(pullErr, "Error pulling for errorType")
	}
	_errorType, _errorTypeErr := ErrorEnclosedParseWithBuffer(ctx, readBuffer, uint8(uint8(0)))
	if _errorTypeErr != nil {
		return nil, errors.Wrap(_errorTypeErr, "Error parsing 'errorType' field of ConfirmedPrivateTransferError")
	}
	errorType := _errorType.(ErrorEnclosed)
	if closeErr := readBuffer.CloseContext("errorType"); closeErr != nil {
		return nil, errors.Wrap(closeErr, "Error closing for errorType")
	}

	// Simple Field (vendorId)
	if pullErr := readBuffer.PullContext("vendorId"); pullErr != nil {
		return nil, errors.Wrap(pullErr, "Error pulling for vendorId")
	}
	_vendorId, _vendorIdErr := BACnetVendorIdTaggedParseWithBuffer(ctx, readBuffer, uint8(uint8(1)), TagClass(TagClass_CONTEXT_SPECIFIC_TAGS))
	if _vendorIdErr != nil {
		return nil, errors.Wrap(_vendorIdErr, "Error parsing 'vendorId' field of ConfirmedPrivateTransferError")
	}
	vendorId := _vendorId.(BACnetVendorIdTagged)
	if closeErr := readBuffer.CloseContext("vendorId"); closeErr != nil {
		return nil, errors.Wrap(closeErr, "Error closing for vendorId")
	}

	// Simple Field (serviceNumber)
	if pullErr := readBuffer.PullContext("serviceNumber"); pullErr != nil {
		return nil, errors.Wrap(pullErr, "Error pulling for serviceNumber")
	}
	_serviceNumber, _serviceNumberErr := BACnetContextTagParseWithBuffer(ctx, readBuffer, uint8(uint8(2)), BACnetDataType(BACnetDataType_UNSIGNED_INTEGER))
	if _serviceNumberErr != nil {
		return nil, errors.Wrap(_serviceNumberErr, "Error parsing 'serviceNumber' field of ConfirmedPrivateTransferError")
	}
	serviceNumber := _serviceNumber.(BACnetContextTagUnsignedInteger)
	if closeErr := readBuffer.CloseContext("serviceNumber"); closeErr != nil {
		return nil, errors.Wrap(closeErr, "Error closing for serviceNumber")
	}

	// Optional Field (errorParameters) (Can be skipped, if a given expression evaluates to false)
	var errorParameters BACnetConstructedData = nil
	{
		currentPos = positionAware.GetPos()
		if pullErr := readBuffer.PullContext("errorParameters"); pullErr != nil {
			return nil, errors.Wrap(pullErr, "Error pulling for errorParameters")
		}
		_val, _err := BACnetConstructedDataParseWithBuffer(ctx, readBuffer, uint8(3), BACnetObjectType_VENDOR_PROPRIETARY_VALUE, BACnetPropertyIdentifier_VENDOR_PROPRIETARY_VALUE, nil)
		switch {
		case errors.Is(_err, utils.ParseAssertError{}) || errors.Is(_err, io.EOF):
			log.Debug().Err(_err).Msg("Resetting position because optional threw an error")
			readBuffer.Reset(currentPos)
		case _err != nil:
			return nil, errors.Wrap(_err, "Error parsing 'errorParameters' field of ConfirmedPrivateTransferError")
		default:
			errorParameters = _val.(BACnetConstructedData)
			if closeErr := readBuffer.CloseContext("errorParameters"); closeErr != nil {
				return nil, errors.Wrap(closeErr, "Error closing for errorParameters")
			}
		}
	}

	if closeErr := readBuffer.CloseContext("ConfirmedPrivateTransferError"); closeErr != nil {
		return nil, errors.Wrap(closeErr, "Error closing for ConfirmedPrivateTransferError")
	}

	// Create a partially initialized instance
	_child := &_ConfirmedPrivateTransferError{
		_BACnetError:    &_BACnetError{},
		ErrorType:       errorType,
		VendorId:        vendorId,
		ServiceNumber:   serviceNumber,
		ErrorParameters: errorParameters,
	}
	_child._BACnetError._BACnetErrorChildRequirements = _child
	return _child, nil
}

func (m *_ConfirmedPrivateTransferError) Serialize() ([]byte, error) {
	wb := utils.NewWriteBufferByteBased(utils.WithInitialSizeForByteBasedBuffer(int(m.GetLengthInBytes(context.Background()))))
	if err := m.SerializeWithWriteBuffer(context.Background(), wb); err != nil {
		return nil, err
	}
	return wb.GetBytes(), nil
}

func (m *_ConfirmedPrivateTransferError) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
	positionAware := writeBuffer
	_ = positionAware
	log := zerolog.Ctx(ctx)
	_ = log
	ser := func() error {
		if pushErr := writeBuffer.PushContext("ConfirmedPrivateTransferError"); pushErr != nil {
			return errors.Wrap(pushErr, "Error pushing for ConfirmedPrivateTransferError")
		}

		// Simple Field (errorType)
		if pushErr := writeBuffer.PushContext("errorType"); pushErr != nil {
			return errors.Wrap(pushErr, "Error pushing for errorType")
		}
		_errorTypeErr := writeBuffer.WriteSerializable(ctx, m.GetErrorType())
		if popErr := writeBuffer.PopContext("errorType"); popErr != nil {
			return errors.Wrap(popErr, "Error popping for errorType")
		}
		if _errorTypeErr != nil {
			return errors.Wrap(_errorTypeErr, "Error serializing 'errorType' field")
		}

		// Simple Field (vendorId)
		if pushErr := writeBuffer.PushContext("vendorId"); pushErr != nil {
			return errors.Wrap(pushErr, "Error pushing for vendorId")
		}
		_vendorIdErr := writeBuffer.WriteSerializable(ctx, m.GetVendorId())
		if popErr := writeBuffer.PopContext("vendorId"); popErr != nil {
			return errors.Wrap(popErr, "Error popping for vendorId")
		}
		if _vendorIdErr != nil {
			return errors.Wrap(_vendorIdErr, "Error serializing 'vendorId' field")
		}

		// Simple Field (serviceNumber)
		if pushErr := writeBuffer.PushContext("serviceNumber"); pushErr != nil {
			return errors.Wrap(pushErr, "Error pushing for serviceNumber")
		}
		_serviceNumberErr := writeBuffer.WriteSerializable(ctx, m.GetServiceNumber())
		if popErr := writeBuffer.PopContext("serviceNumber"); popErr != nil {
			return errors.Wrap(popErr, "Error popping for serviceNumber")
		}
		if _serviceNumberErr != nil {
			return errors.Wrap(_serviceNumberErr, "Error serializing 'serviceNumber' field")
		}

		// Optional Field (errorParameters) (Can be skipped, if the value is null)
		var errorParameters BACnetConstructedData = nil
		if m.GetErrorParameters() != nil {
			if pushErr := writeBuffer.PushContext("errorParameters"); pushErr != nil {
				return errors.Wrap(pushErr, "Error pushing for errorParameters")
			}
			errorParameters = m.GetErrorParameters()
			_errorParametersErr := writeBuffer.WriteSerializable(ctx, errorParameters)
			if popErr := writeBuffer.PopContext("errorParameters"); popErr != nil {
				return errors.Wrap(popErr, "Error popping for errorParameters")
			}
			if _errorParametersErr != nil {
				return errors.Wrap(_errorParametersErr, "Error serializing 'errorParameters' field")
			}
		}

		if popErr := writeBuffer.PopContext("ConfirmedPrivateTransferError"); popErr != nil {
			return errors.Wrap(popErr, "Error popping for ConfirmedPrivateTransferError")
		}
		return nil
	}
	return m.SerializeParent(ctx, writeBuffer, m, ser)
}

func (m *_ConfirmedPrivateTransferError) isConfirmedPrivateTransferError() bool {
	return true
}

func (m *_ConfirmedPrivateTransferError) String() string {
	if m == nil {
		return "<nil>"
	}
	writeBuffer := utils.NewWriteBufferBoxBasedWithOptions(true, true)
	if err := writeBuffer.WriteSerializable(context.Background(), m); err != nil {
		return err.Error()
	}
	return writeBuffer.GetBox().String()
}

branch_name: refs/heads/develop


text:
package gotek

import (
	"io/ioutil"
	"encoding/json"
	"net/url"
	"net/http"
	"net/http/cookiejar"
)

type Client struct {
	Login		string
	Password	string
}

var (
	client *http.Client
)

func init() {
	cookiejar, _ := cookiejar.New(nil)
	client = &http.Client{ Jar: cookiejar }
}

func (c *Client) SignIn() (*Board, error) {
	var dashboard Board

	response, err := client.PostForm(DASHBOARD_ENDPOINT,
		url.Values{
			"login": { c.Login },
			"password": { c.Password },
		})
	if err != nil {
		return nil, err
	} else {
		defer response.Body.Close()

		contents, err := ioutil.ReadAll(response.Body)
		if err != nil {
			return nil, err
		}

		err = json.Unmarshal(contents[31:], &dashboard)
		if err != nil {
			return nil, err
		}
	}
	return &dashboard, nil
}

repository: LilliJane/gotek

repo_name: LilliJane/gotek


text:
@inproceedings{stanczak2022neurons,
title={{Same Neurons, Different Languages: Probing Morphosyntax in Multilingual Pre-trained Models}},
author={Stańczak, Karolina and Ponti, Edoardo and Hennigen, Lucas Torroba and Cotterell, Ryan and Augenstein, Isabelle},
booktitle = {Proceedings of NAACL-HLT},
publisher = {Association for Computational Linguistics},
year = 2022
}

repository: copenlu/academic-kickstart

repo_name: copenlu/academic-kickstart


text:
package runner_test

import (
	"context"
	"testing"
	"time"

	"github.com/google/go-cmp/cmp"

	"github.com/nornir-automation/gornir/pkg/gornir"
	"github.com/nornir-automation/gornir/pkg/plugins/runner"
)

// TestParallel is going to check that the func runs on all hosts
// and that it takes less than X time to complete. The test func
// basically will sleep for N ms and given we are using goroutines
// the completion should only be slightly above it even though
// we are sleeping once per device
func TestParallel(t *testing.T) {
	testCases := []struct {
		name          string
		expected      map[string]bool
		sleepDuration time.Duration
	}{
		{
			name:          "simple test",
			expected:      map[string]bool{"dev1": true, "dev2": true, "dev3": true, "dev4": true},
			sleepDuration: 200 * time.Millisecond,
		},
	}

	testHosts := map[string]*gornir.Host{
		"dev1": {Hostname: "dev1"},
		"dev2": {Hostname: "dev2"},
		"dev3": {Hostname: "dev3"},
		"dev4": {Hostname: "dev4"},
	}

	for _, tc := range testCases {
		tc := tc
		results := make(chan *gornir.JobResult, len(testHosts))
		t.Run(tc.name, func(t *testing.T) {
			rnr := runner.Parallel()
			startTime := time.Now()
			if err := rnr.Run(
				context.Background(),
				NewNullLogger(),
				make(gornir.Processors, 0),
				&testTaskSleep{sleepDuration: tc.sleepDuration},
				testHosts,
				results,
			); err != nil {
				t.Fatal(err)
			}
			if err := rnr.Wait(); err != nil {
				t.Fatal(err)
			}
			close(results)

			// let's process the results and turn it into a map so we can
			// compare with our expected value
			got := make(map[string]bool)
			for res := range results {
				got[res.Host().Hostname] = res.Data().(testTaskSleepResults).success
			}
			if !cmp.Equal(got, tc.expected) {
				t.Error(cmp.Diff(got, tc.expected))
			}
			// now we check test took what we expected
			if time.Since(startTime) > (tc.sleepDuration + time.Millisecond*100) {
				t.Errorf("test took to long, parallelization might not be working: %v\n", time.Since(startTime).Seconds())
			}
		})
	}
}

repository: nornir-automation/gornir

repo_name: nornir-automation/gornir


text:
package raftnase

import (
	"fmt"
	"time"

	"git.tu-berlin.de/mcc-fred/fred/pkg/fred"
	"github.com/go-errors/errors"
	"github.com/rs/zerolog/log"
	"go.etcd.io/etcd/clientv3"
	"go.etcd.io/etcd/pkg/transport"
)

const (
	fmtKgNodeString             = "kg|%s|node|%s"
	fmtKgStatusString           = "kg|%s|status"
	fmtKgMutableString          = "kg|%s|mutable"
	fmtKgExpiryString           = "kg|%s|expiry|node|%s"
	fmtNodeAdressString         = "node|%s|address"
	fmtNodeExternalAdressString = "node|%s|extaddress"
	fmtUserPermissionString     = "user|%s|kg|%s|method|%s"
	fmtFailedNodeKgString       = "failnode|%s|kg|%s|%s" // Node, Keygroup, ID
	fmtFailedNodePrefix         = "failnode|%s|"
	nodePrefixString            = "node|"
	sep                         = "|"
	timeout                     = 5 * time.Second
)

// NameService is the interface to the etcd server that serves as NaSe
// It is used by the replservice to sync updates to keygroups with other nodes and thereby makes sure that ReplicationStorage always has up to date information
type NameService struct {
	cli    *clientv3.Client
	NodeID string
}

// NewNameService creates a new NameService
func NewNameService(nodeID string, endpoints []string, certfFile string, keyFile string, caFile string) (*NameService, error) {
	tlsInfo := transport.TLSInfo{
		CertFile:      certfFile,
		KeyFile:       keyFile,
		TrustedCAFile: caFile,
	}

	tlsConfig, err := tlsInfo.ClientConfig()

	if err != nil {
		return nil, errors.Errorf("Error configuring certificates for the etcd client: %v", err)
	}

	cli, err := clientv3.New(clientv3.Config{
		Endpoints:   endpoints,
		DialTimeout: timeout,
		TLS:         tlsConfig,
	})

	if err != nil {
		// Deadline Exceeded
		return nil, errors.Errorf("Error starting the etcd client: %v", err)
	}

	return &NameService{
		cli: cli, NodeID: nodeID,
	}, nil
}

// RegisterSelf stores information about this node
func (n *NameService) RegisterSelf(host string, externalHost string) error {

}

// GetNodeID returns the ID of this node.
func (n *NameService) GetNodeID() fred.NodeID {

}

branch_name: refs/heads/main


text:
cmake_minimum_required(VERSION 3.0)

project(posprintf ASM)

add_library(posprintf STATIC posprintf.S)
target_include_directories(posprintf SYSTEM PUBLIC "/include")

set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -marm -x assembler-with-cpp")

license: Zlib

repository: Daxidz/gba-toolchain

repo_name: Daxidz/gba-toolchain


text:
SUMMARY = "Illustration of Pixie's Foreign Function Interface"
HOMEPAGE = "https://github.com/linneman/libffitest"
LICENSE = "GPLv2"

LIC_FILES_CHKSUM = "file://COPYING;md5=23c2a5e0106b99d75238986559bb5fc6"
SRCREV = "af524381d817bab5e4cc412c1a6c27be67556771"
SRC_URI = "git://github.com/linneman/libffitest.git"
S = "${WORKDIR}/git"

# do not include the package boost here to avoid that the complete boost-dev
# package is integrated!

RDEPENDS_${PN} = "packagegroup-core-buildessential boost-ffi-headers"

inherit autotools pkgconfig

PACKAGE_SNAP_LIB_SYMLINKS = "0"
INHIBIT_PACKAGE_STRIP = "1"
INSANE_SKIP_${PN} += "dev-deps"

do_install_append() {
  mkdir -p ${D}/opt/examples
  cp -r ${S}/example_pixie/example.pxi ${D}/opt/examples/ffi_example.pxi

  mkdir -p ${D}/usr/local/include
  ln -s /usr/include/ffitest ${D}/usr/local/include/ffitest
}

FILES_${PN} += "/opt/examples/*"
FILES_${PN} += "/usr/local/include/ffitest"

repository: linneman/meta-pixie

repo_name: linneman/meta-pixie