text:
@article{DBLP:journals/eaai/CasadeiVAPD21,
  author    = {Roberto Casadei and
               Mirko Viroli and
               Giorgio Audrito and
               Danilo Pianini and
               Ferruccio Damiani},
  title     = {Engineering collective intelligence at the edge with aggregate processes},
  journal   = {Eng. Appl. Artif. Intell.},
  volume    = {97},
  pages     = {104081},
  year      = {2021},
  url       = {https://doi.org/10.1016/j.engappai.2020.104081},
  doi       = {10.1016/j.engappai.2020.104081},
  timestamp = {Mon, 21 Dec 2020 09:15:18 +0100},
  biburl    = {https://dblp.org/rec/journals/eaai/CasadeiVAPD21.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{DBLP:journals/scp/AlrahmanNL20,
  author    = {Yehia Abd Alrahman and
               Rocco De Nicola and
               Michele Loreti},
  title     = {Programming interactions in collective adaptive systems by relying
               on attribute-based communication},
  journal   = {Sci. Comput. Program.},
  volume    = {192},
  pages     = {102428},
  year      = {2020},
  url       = {https://doi.org/10.1016/j.scico.2020.102428},
  doi       = {10.1016/j.scico.2020.102428},
  timestamp = {Sat, 30 May 2020 19:47:39 +0200},
  biburl    = {https://dblp.org/rec/journals/scp/AlrahmanNL20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/soca/ScekicMSDHCTRCD15,
  author    = {Ognjen Scekic and
               Daniele Miorandi and
               Tommaso Schiavinotto and
               Dimitrios I. Diochnos and
               Alethia Hume and
               Ronald Chenu{-}Abente and
               Hong Linh Truong and
               Michael Rovatsos and
               Iacopo Carreras and
               Schahram Dustdar and
               Fausto Giunchiglia},
  title     = {SmartSociety - {A} Platform for Collaborative People-Machine Computation},
  _booktitle = {8th {IEEE} International Conference on Service-Oriented Computing
               and Applications, {SOCA} 2015, Rome, Italy, October 19-21, 2015},
  booktitle = {{SOCA} 2015},
  pages     = {147--154},
  publisher = {{IEEE} Computer Society},
  year      = {2015},
  url       = {https://doi.org/10.1109/SOCA.2015.10},
  doi       = {10.1109/SOCA.2015.10},
  timestamp = {Sat, 05 Sep 2020 18:06:33 +0200},
  biburl    = {https://dblp.org/rec/conf/soca/ScekicMSDHCTRCD15.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/mobiquitous/KoutsoubeliasL16,
  author    = {Manos Koutsoubelias and
               Spyros Lalis},
  editor    = {Takahiro Hara and
               Hiroshi Shigeno},
  title     = {TeCoLa: {A} Programming Framework for Dynamic and Heterogeneous Robotic
               Teams},
  booktitle = {Proceedings of the 13th International Conference on Mobile and Ubiquitous
               Systems: Computing, Networking and Services, MobiQuitous 2016, Hiroshima,
               Japan, November 28 - December 1, 2016},
  pages     = {115--124},
  publisher = {{ACM}},
  year      = {2016},
  url       = {https://doi.org/10.1145/2994374.2994397},
  doi       = {10.1145/2994374.2994397},
  timestamp = {Tue, 06 Nov 2018 11:07:32 +0100},
  biburl    = {https://dblp.org/rec/conf/mobiquitous/KoutsoubeliasL16.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/cbse/BuresGHKKP13,
  author    = {Tom{\'{a}}s Bures and
               Ilias Gerostathopoulos and
               Petr Hnetynka and
               Jaroslav Keznikl and
               Michal Kit and
               Frantisek Plasil},
  editor    = {Philippe Kruchten and
               Dimitra Giannakopoulou and
               Massimo Tivoli},
  title     = {{DEECO:} an ensemble-based component system},
  _booktitle = {CBSE'13, Proceedings of the 16th {ACM} {SIGSOFT} Symposium on Component
               Based Software Engineering, part of Comparch '13, Vancouver, BC, Canada,
               June 17-21, 2013},
  booktitle = {CBSE'13},
  pages     = {81--90},
  publisher = {{ACM}},
  year      = {2013},
  url       = {https://doi.org/10.1145/2465449.2465462},
  doi       = {10.1145/2465449.2465462},
  timestamp = {Thu, 11 Mar 2021 17:04:51 +0100},
  biburl    = {https://dblp.org/rec/conf/cbse/BuresGHKKP13.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{DBLP:journals/taas/NicolaLPT14,
  author    = {Rocco De Nicola and
               Michele Loreti and
               Rosario Pugliese and
               Francesco Tiezzi},
  title     = {A Formal Approach to Autonomic Systems Programming: The {SCEL} Language},
  journal   = {{ACM} Trans. Auton. Adapt. Syst.},
  volume    = {9},
  number    = {2},
  pages     = {7:1--7:29},
  year      = {2014},
  url       = {https://doi.org/10.1145/2619998},
  doi       = {10.1145/2619998},
  timestamp = {Thu, 20 May 2021 14:31:19 +0200},
  biburl    = {https://dblp.org/rec/journals/taas/NicolaLPT14.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{DBLP:journals/jlap/ViroliBDACP19,
  author    = {Mirko Viroli and
               Jacob Beal and
               Ferruccio Damiani and
               Giorgio Audrito and
               Roberto Casadei and
               Danilo Pianini},
  title     = {From distributed coordination to field calculus and aggregate computing},
  journal   = {J. Log. Algebraic Methods Program.},
  volume    = {109},
  year      = {2019},
  url       = {https://doi.org/10.1016/j.jlamp.2019.100486},
  doi       = {10.1016/j.jlamp.2019.100486},
  timestamp = {Sat, 22 Feb 2020 19:18:14 +0100},
  biburl    = {https://dblp.org/rec/journals/jlap/ViroliBDACP19.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{DBLP:journals/computer/BealPV15,
  author    = {Jacob Beal and
               Danilo Pianini and
               Mirko Viroli},
  title     = {Aggregate Programming for the Internet of Things},
  journal   = {Computer},
  volume    = {48},
  number    = {9},
  pages     = {22--30},
  year      = {2015},
  url       = {https://doi.org/10.1109/MC.2015.261},
  doi       = {10.1109/MC.2015.261},
  timestamp = {Wed, 12 Aug 2020 10:31:37 +0200},
  biburl    = {https://dblp.org/rec/journals/computer/BealPV15.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{DBLP:journals/fi/CasadeiPPVW20,
  author    = {Roberto Casadei and
               Danilo Pianini and
               Andrea Placuzzi and
               Mirko Viroli and
               Danny Weyns},
  title     = {Pulverization in Cyber-Physical Systems: Engineering the Self-Organizing
               Logic Separated from Deployment},
  journal   = {Future Internet},
  volume    = {12},
  number    = {11},
  pages     = {203},
  year      = {2020},
  url       = {https://doi.org/10.3390/fi12110203},
  doi       = {10.3390/fi12110203},
  timestamp = {Thu, 21 Jan 2021 17:35:11 +0100},
  biburl    = {https://dblp.org/rec/journals/fi/CasadeiPPVW20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{DBLP:journals/csur/WeisenburgerWS20,
  author    = {Pascal Weisenburger and
               Johannes Wirth and
               Guido Salvaneschi},
  title     = {A Survey of Multitier Programming},
  journal   = {{ACM} Comput. Surv.},
  volume    = {53},
  number    = {4},
  pages     = {81:1--81:35},
  year      = {2020},
  url       = {https://doi.org/10.1145/3397495},
  doi       = {10.1145/3397495},
  timestamp = {Sat, 17 Oct 2020 14:17:19 +0200},
  biburl    = {https://dblp.org/rec/journals/csur/WeisenburgerWS20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{DBLP:journals/jfp/Brady13,
  author    = {Edwin C. Brady},
  title     = {Idris, a general-purpose dependently typed programming language: Design
               and implementation},
  journal   = {J. Funct. Program.},
  volume    = {23},
  number    = {5},
  pages     = {552--593},
  year      = {2013},
  url       = {https://doi.org/10.1017/S095679681300018X},
  doi       = {10.1017/S095679681300018X},
  timestamp = {Sun, 21 Jun 2020 17:42:23 +0200},
  biburl    = {https://dblp.org/rec/journals/jfp/Brady13.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}
@inproceedings{DBLP:conf/ecoop/WeisenburgerS19,
  author    = {Pascal Weisenburger and
               Guido Salvaneschi},
  editor    = {Alastair F. Donaldson},
  title     = {Multitier Modules},
  booktitle = {33rd European Conference on Object-Oriented Programming, {ECOOP} 2019,
               July 15-19, 2019, London, United Kingdom},
  series    = {LIPIcs},
  volume    = {134},
  pages     = {3:1--3:29},
  publisher = {Schloss Dagstuhl - Leibniz-Zentrum f{\"{u}}r Informatik},
  year      = {2019},
  url       = {https://doi.org/10.4230/LIPIcs.ECOOP.2019.3},
  doi       = {10.4230/LIPIcs.ECOOP.2019.3},
  timestamp = {Sun, 25 Oct 2020 22:50:36 +0100},
  biburl    = {https://dblp.org/rec/conf/ecoop/WeisenburgerS19.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{DBLP:journals/programming/WeisenburgerS20,
  author    = {Pascal Weisenburger and
               Guido Salvaneschi},
  title     = {Implementing a Language for Distributed Systems: Choices and Experiences
               with Type Level and Macro Programming in Scala},
  journal   = {Art Sci. Eng. Program.},
  volume    = {4},
  number    = {3},
  pages     = {17},
  year      = {2020},
  url       = {https://doi.org/10.22152/programming-journal.org/2020/4/17},
  doi       = {10.22152/programming-journal.org/2020/4/17},
  timestamp = {Wed, 17 Feb 2021 08:59:22 +0100},
  biburl    = {https://dblp.org/rec/journals/programming/WeisenburgerS20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/ecoop/CasadeiV16,
  author    = {Roberto Casadei and
               Mirko Viroli},
  title     = {Towards Aggregate Programming in Scala},
  booktitle = {First Workshop on Programming Models and Languages for Distributed
               Computing, PMLDC@ECOOP 2016, Rome, Italy, July 17, 2016},
  pages     = {5},
  publisher = {{ACM}},
  year      = {2016},
  url       = {https://doi.org/10.1145/2957319.2957372},
  doi       = {10.1145/2957319.2957372},
  timestamp = {Tue, 06 Nov 2018 16:59:31 +0100},
  biburl    = {https://dblp.org/rec/conf/ecoop/CasadeiV16.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/issta/WeisenburgerRS18,
  author    = {Pascal Weisenburger and
               Tobias Reinhard and
               Guido Salvaneschi},
  editor    = {Julian Dolby and
               William G. J. Halfond and
               Ashish Mishra},
  title     = {Static latency tracking with placement types},
  booktitle = {Companion Proceedings for the {ISSTA/ECOOP} 2018 Workshops, {ISSTA}
               2018, Amsterdam, Netherlands, July 16-21, 2018},
  pages     = {34--36},
  publisher = {{ACM}},
  year      = {2018},
  url       = {https://doi.org/10.1145/3236454.3236486},
  doi       = {10.1145/3236454.3236486},
  timestamp = {Sun, 25 Oct 2020 22:46:49 +0100},
  biburl    = {https://dblp.org/rec/conf/issta/WeisenburgerRS18.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/isola/CasadeiVAD20,
  author    = {Roberto Casadei and
               Mirko Viroli and
               Giorgio Audrito and
               Ferruccio Damiani},
  title     = {FScaFi : {A} Core Calculus for Collective Adaptive Systems Programming},
  booktitle = {ISoLA {(2)}},
  series    = {LNCS},
  volume    = {12477},
  pages     = {344--360},
  publisher = {Springer},
  year      = {2020}
}

@incollection{cv2017actorcas,
	booktitle = {Programming with Actors: State-of-the-Art and Research Perspectives},
	year = 2018,
	status = {Published},
	venue_list = {--},
	_editor = {Ricci, Alessandro and Haller, Philipp},
	series = {LNCS},
	publisher = {Springer International Publishing},
	author = {Casadei, Roberto and Viroli, Mirko},
	title = {Programming Actor-Based Collective Adaptive Systems},
	abstract = {In recent years, we are witnessing a growing interest in large-scale situated systems, such as those falling under the umbrella of pervasive computing, Cyber-Physical Systems, and the Internet of Things. The actor model is a natural choice for designing and implementing such systems, thanks to the ability of actors to address distribution, autonomy of control, and asynchronous communication: namely, it is convenient to view the pervasive cyberspace as an environment densely inhabited by mobile situated actors. But how can an actor-centric development approach be fruitfully used to engineer a complex coordination strategy, where a myriad of devices/actors performs adaptive distributed sensing/processing/acting?
Aggregate computing has been proposed as an emerging paradigm that faces this general problem by adopting a global, system-level stance, allowing to specify and functionally compose collective behaviours by operating on diffused data structures, known as “computational fields”. In this paper, we develop on the idea of integrating the actor model and aggregate computing, presenting a software framework where declarative global-level system specifications are automatically turned into an underlying system of Scala/Akka actors carrying complex coordination tasks involving large sets of devices spread over the pervasive computing system.},
	pages = {94--122},
	volume = 10789,
	doi = {10.1007/978-3-030-00302-9\_4}
}

@inproceedings{DBLP:conf/ecoop/Burmako13,
  author    = {Eugene Burmako},
  title     = {Scala macros: let our powers combine!: on how rich syntax and static
               types work with metaprogramming},
  booktitle = {Proceedings of the 4th Workshop on Scala, SCALA@ECOOP 2013, Montpellier,
               France, July 2, 2013},
  pages     = {3:1--3:10},
  publisher = {{ACM}},
  year      = {2013},
  url       = {https://doi.org/10.1145/2489837.2489840},
  doi       = {10.1145/2489837.2489840},
  timestamp = {Tue, 06 Nov 2018 16:59:31 +0100},
  biburl    = {https://dblp.org/rec/conf/ecoop/Burmako13.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{Weisenburger.2018,
  author    = {Pascal Weisenburger and
               Mirko K{\"{o}}hler and
               Guido Salvaneschi},
  title     = {Distributed system development with ScalaLoci},
  journal   = {Proc. {ACM} Program. Lang.},
  volume    = {2},
  number    = {{OOPSLA}},
  pages     = {129:1--129:30},
  year      = {2018},
  url       = {https://doi.org/10.1145/3276499},
  doi       = {10.1145/3276499},
  timestamp = {Wed, 17 Feb 2021 08:54:10 +0100},
  biburl    = {https://dblp.org/rec/journals/pacmpl/WeisenburgerKS18.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/fmco/CooperLWY06,
  author    = {Ezra Cooper and
               Sam Lindley and
               Philip Wadler and
               Jeremy Yallop},
  editor    = {Frank S. de Boer and
               Marcello M. Bonsangue and
               Susanne Graf and
               Willem P. de Roever},
  title     = {Links: Web Programming Without Tiers},
  booktitle = {Formal Methods for Components and Objects, 5th International Symposium,
               {FMCO} 2006, Amsterdam, The Netherlands, November 7-10, 2006, Revised
               Lectures},
  series    = {Lecture Notes in Computer Science},
  volume    = {4709},
  pages     = {266--296},
  publisher = {Springer},
  year      = {2006},
  url       = {https://doi.org/10.1007/978-3-540-74792-5\_12},
  doi       = {10.1007/978-3-540-74792-5\_12},
  timestamp = {Tue, 14 May 2019 10:00:53 +0200},
  biburl    = {https://dblp.org/rec/conf/fmco/CooperLWY06.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{MekkiBCM18,
    author    = {Kais Mekki and
               Eddy Bajic and
               Fr{\'{e}}d{\'{e}}ric Chaxel and
               Fernand Meyer},
    title     = {Overview of Cellular {LPWAN} Technologies for IoT Deployment: Sigfox,
               LoRaWAN, and NB-IoT},
    booktitle = {2018 {IEEE} International Conference on Pervasive Computing and Communications
               Workshops, PerCom Workshops 2018, Athens, Greece, March 19-23, 2018},
    pages     = {197--202},
    publisher = {{IEEE} Computer Society},
    year      = {2018},
    url       = {https://doi.org/10.1109/PERCOMW.2018.8480255},
    doi       = {10.1109/PERCOMW.2018.8480255},
    timestamp = {Wed, 16 Oct 2019 14:14:54 +0200},
    biburl    = {https://dblp.org/rec/conf/percom/MekkiBCM18.bib},
    bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{TOCL2019,
  doi = {10.1145/3285956},
  url = {https://doi.org/10.1145/3285956},
  year  = {2019},
  month = {jan},
  publisher = {Association for Computing Machinery ({ACM})},
  volume = {20},
  number = {1},
  pages = {1--55},
  author = {Giorgio Audrito and Mirko Viroli and Ferruccio Damiani and Danilo Pianini and Jacob Beal},
  title = {A Higher-Order Calculus of Computational Fields},
  journal = {ACM Trans. Comput. Logic}
}

@inproceedings{PianiniSAC2015,
  author    = {Danilo Pianini and
               Mirko Viroli and
               Jacob Beal},
  title     = {Protelis: practical aggregate programming},
  booktitle = {{ACM} SAC},
  pages     = {1846--1853},
  year      = {2015},
  url       = {http://doi.acm.org/10.1145/2695664.2695913},
  doi       = {10.1145/2695664.2695913},
  timestamp = {Tue, 21 Jul 2015 21:17:02 +0200},
  biburl    = {http://dblp.uni-trier.de/rec/bib/conf/sac/PianiniVB15},
  bibsource = {dblp computer science bibliography, http://dblp.org}
}

@inproceedings{DBLP:conf/acsos/Audrito20,
  author    = {Giorgio Audrito},
  title     = {{FCPP:} an efficient and extensible Field Calculus framework},
  booktitle = {{IEEE} International Conference on Autonomic Computing and Self-Organizing
               Systems, {ACSOS} 2020, Washington, DC, USA, August 17-21, 2020},
  pages     = {153--159},
  publisher = {{IEEE}},
  year      = {2020},
  url       = {https://doi.org/10.1109/ACSOS49614.2020.00037},
  doi       = {10.1109/ACSOS49614.2020.00037},
  timestamp = {Fri, 23 Oct 2020 15:37:58 +0200},
  biburl    = {https://dblp.org/rec/conf/acsos/Audrito20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/coordination/AguzziCMPV21,
  author    = {Gianluca Aguzzi and
               Roberto Casadei and
               Niccol{\`{o}} Maltoni and
               Danilo Pianini and
               Mirko Viroli},
  editor    = {Ferruccio Damiani and
               Ornela Dardha},
  title     = {ScaFi-Web: {A} Web-Based Application for Field-Based Coordination
               Programming},
  booktitle = {Coordination Models and Languages - 23rd {IFIP} {WG} 6.1 International
               Conference, {COORDINATION} 2021, Held as Part of the 16th International
               Federated Conference on Distributed Computing Techniques, DisCoTec
               2021, Valletta, Malta, June 14-18, 2021, Proceedings},
  series    = {Lecture Notes in Computer Science},
  volume    = {12717},
  pages     = {285--299},
  publisher = {Springer},
  year      = {2021},
  url       = {https://doi.org/10.1007/978-3-030-78142-2\_18},
  doi       = {10.1007/978-3-030-78142-2\_18},
  timestamp = {Tue, 15 Jun 2021 17:23:40 +0200},
  biburl    = {https://dblp.org/rec/conf/coordination/AguzziCMPV21.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}


text:
@INPROCEEDINGS{Limberger2017,
  author = {Daniel Limberger and Willy Scheibel and Matthias Trapp and J\"urgen D\"ollner},
  title = {Mixed-Projection Treemaps: A novel approach mixing {2D} and {2.5D} Treemaps},
  pages = {164--169},
  abstract = {This paper presents a novel technique for combining 2D and 2.5D treemaps using multi-perspective views to leverage the advantages of both treemap types. It enables a new form of overview+detail visualization for tree-structured data and contributes new concepts for real-time rendering of and interaction with treemaps. The technique operates by tilting the graphical elements representing inner nodes using affine transformations and animated state transitions. We explain how to mix orthogonal and perspective projections within a single treemap. Finally, we show application examples that benefit from the reduced interaction overhead.},
  doi = {10.1109/iV.2017.67},
  year = {2017},
  booktitle = {IV'17: Proceedings of the International Conference on Information Visualisation},
  editor = {Ebad Banissi and Mark W. McK. Bannatyne and Fatma Bouali and Nuno Miguel Soares Datia and Georges Grinstein and Dennis Groth and Weidong Huang and Malinka Ivanova and Sarah Kenderdine and Minoru Nakayama and Joao Moura Pires and Muhammad Sarfraz and Marco Temperini and Anna Ursyn and Gilles Venturini and Theodor G. Wyeld and Jian J. Zhang},
  publisher = {IEEE Computer Society},
  isbn = {9781538608326}
}

license: MIT

repository: vis-au/treevisnet

license_type: permissive

repo_name: vis-au/treevisnet

branch_name: refs/heads/master

gha_language: TeX

extension: bib


text:
package main

import (
	_ "go-echo-swagger-sports-api/controllers"
	_ "go-echo-swagger-sports-api/db"

	"github.com/labstack/echo/middleware"
	"github.com/labstack/echo/v4"
)

func main() {
	e := echo.New()

	// Middleware
	e.Use(middleware.Logger())
	e.Use(middleware.Recover())

	e.Logger.Fatal(e.Start(":3000"))
}

repository: CodexTapes/go-echo-swagger-sports-api

repo_name: CodexTapes/go-echo-swagger-sports-api

extension: go


text:
@article{Kimura2020,
 abstract = {© Copyright © 2020 Kimura, Takemura, Nakashima, Kobori, Nagahara, Numao and Shinohara. Climate change is one of the most important issues for humanity. To defuse this problem, it is considered necessary to improve energy efficiency, make energy sources cleaner, and reduce energy consumption in urban areas. The Japanese government has recommended an air conditioner setting of 28°C in summer and 20°C in winter since 2005. The aim of this setting is to save energy by keeping room temperatures constant. However, it is unclear whether this is an appropriate temperature for workers and students. This study examined whether thermal environments influence task performance over time. To examine whether the relationship between task performance and thermal environments influences the psychological states of participants, we recorded their subjective rating of mental workload along with their working memory score, electroencephalogram (EEG), heart rate variability, skin conductance level (SCL), and tympanum temperature during the task and compared the results among different conditions. In this experiment, participants were asked to read some texts and answer questions related to those texts. Room temperature (18, 22, 25, or 29°C) and humidity (50%) were manipulated during the task and participants performed the task at these temperatures. The results of this study showed that the temporal cost of task and theta power of EEG, which is an index for concentration, decreased over time. However, subjective mental workload increased with time. Moreover, the low frequency to high frequency ratio and SCL increased with time and heat (25 and 29°C). These results suggest that mental workload, especially implicit mental workload, increases in warmer environments, even if learning efficiency is facilitated. This study indicates integrated evidence for relationships among task performance, psychological state, and thermal environment by analyzing behavioral, subjective, and physiological indexes multidirectionally.},
 author = {Kimura, T. and Takemura, N. and Nakashima, Y. and Kobori, H. and Nagahara, H. and Numao, M. and Shinohara, K.},
 doi = {10.3389/fpsyg.2020.00568},
 issn = {16641078},
 journal = {Frontiers in Psychology},
 keywords = {EEG,autonomic nervous system,learning efficiency,mental workload,thermal environment},
 title = {Warmer Environments Increase Implicit Mental Workload Even If Learning Efficiency Is Enhanced},
 volume = {11},
 year = {2020}
}

repository: conscienceli/islab-website

repo_name: conscienceli/islab-website

gha_license_id: MIT


text:
package bitarray

import (
	"fmt"
	"math"
	"strconv"
)

var blockLen int = 64
var msb uint64 = 0x8000000000000000

//Bitarray array struct
type Bitarray struct {
	storage []uint64
}

func (b *Bitarray) getStrgIdxInnerIdx(i uint64) (strgIdx uint64, innerIdx uint64, err error) {

	if uint64(len(b.storage)*64) <= i {
		return 0, 0, fmt.Errorf("b.storage have not enough length")
	}
	strgIdx = uint64(len(b.storage)) - i/64 - 1
	innerIdx = 1 << (i % 64)

	return strgIdx, innerIdx, err
}

//InitializeBySize init bitarray by given size
func (b *Bitarray) InitializeBySize(size uint64) error {
	storageSize := uint64(math.Ceil(float64(size) / 64))
	b.storage = make([]uint64, storageSize)
	return nil
}

//InitializeByStrValue take a value like "0110111001"
func (b *Bitarray) InitializeByStrValue(val string) error {

	val = removeLeftZeros(val)

	size := uint64(len(val))
	err := b.InitializeBySize(size)
	var tmp uint64

	if err == nil {
		i := len(b.storage) - 1
		for len(val) >= blockLen && i >= 0 {
			tmp, err = strconv.ParseUint(val[len(val)-blockLen:], 2, 64)
			b.storage[i] = tmp
			val = val[:len(val)-blockLen]
			i--
		}
		if len(val) > 0 && i == 0 {
			tmp, err = strconv.ParseUint(val, 2, 64)
			b.storage[i] = tmp
		} else {
			err = fmt.Errorf("len(val)=%d, i=%d", len(val), i)
		}
	}

	return err
}

//InitializeByValue take a uint like 0b111010
func (b *Bitarray) InitializeByValue(val uint64) error {

	err := b.InitializeBySize(64)
	b.storage[0] = val
	return err
}

//InitializeByBitarray: clone given bitarray
func (b *Bitarray) InitializeByBitarray(bSrc *Bitarray) error {
	b.storage = make([]uint64, len(bSrc.storage))
	copy(b.storage, bSrc.storage)
	return nil
}

//Get i-th index of bitarray
func (b *Bitarray) Get(i uint64) (uint8, error) {
	strgIdx, innerIdx, err := b.getStrgIdxInnerIdx(i)
	if err != nil {
		return 0, err
	}
	val := b.storage[strgIdx] & innerIdx
	if val == 0 {
		return 0, nil
	}
	return 1, nil
}

func (b *Bitarray) resize(i uint64) error {
	appendSize := uint64(math.Ceil(float64(i-uint64(len(b.storage)*64-1)) / 64))
	b.storage = append(make([]uint64, appendSize), b.storage...)
	return nil
}

//Set: set given index to 0 or 1
func (b *Bitarray) Set(i uint64, v uint8) error {
	strgIdx, innerIdx, err := b.getStrgIdxInnerIdx(i)
	if err != nil {
		err = b.resize(i)
		if err == nil {
			return b.Set(i, v)
		}
		return err
	}

	if v == 0 {
		b.storage[strgIdx] &= ^(innerIdx)
	} else if v == 1 {
		b.storage[strgIdx] |= innerIdx
	} else {
		return fmt.Errorf("v must be 0 or 1, but you pass[%d]", v)
	}
	return nil
}

//Compare: compare given bitarray with caller bitarray and return true or false
//'0001101' is equal to '01101' is equal to '1101'
func (b *Bitarray) Compare(ba *Bitarray) bool {
	if len(b.storage) != len(ba.storage) {
		if *b.ToString() == *ba.ToString() {
			return true
		}
		return false
	}

	for i, v := range b.storage {
		if v != ba.storage[i] {
			return false
		}
	}
	return true
}

//And: Bitwise And given bitarray with caller bitarray and return bitarray result
func (b *Bitarray) And(ba *Bitarray) (res *Bitarray) {
	tmp := &Bitarray{
		storage: []uint64{},
	}
	if len(b.storage) <= len(ba.storage) {
		res = b
		tmp = ba
	} else {
		res = ba
		tmp = b
	}
	for i := len(res.storage) - 1; i >= 0; i-- {
		res.storage[i] &= tmp.storage[i]
	}
	return res
}

//Or: Bitwise Or given bitarray with caller bitarray and return bitarray result
func (b *Bitarray) Or(ba *Bitarray) (res *Bitarray) {
	tmp := &Bitarray{
		storage: []uint64{},
	}
	if len(b.storage) <= len(ba.storage) {
		res = ba
		tmp = b
	} else {
		res = b
		tmp = ba
	}

	for i := len(tmp.storage) - 1; i >= 0; i-- {
		res.storage[i] |= tmp.storage[i]
	}
	return res
}

//Xor: Bitwise Xor given bitarray with caller bitarray and return bitarray result
func (b *Bitarray) Xor(ba *Bitarray) (res *Bitarray) {
	tmp := &Bitarray{
		storage: []uint64{},
	}
	if len(b.storage) <= len(ba.storage) {
		res = ba
		tmp = b
	} else {
		res = b
		tmp = ba
	}
	for i := len(tmp.storage) - 1; i >= 0; i-- {
		res.storage[i] ^= tmp.storage[i]
	}
	return res
}

//Not: Bitwise Not caller bitarray and return bitarray result
func (b *Bitarray) Not() (res *Bitarray) {
	res = &Bitarray{
		storage: make([]uint64, len(b.storage)),
	}
	for i := 0; i < len(b.storage); i++ {
		res.storage[i] = ^b.storage[i]
	}
	return res
}

//ToString: return string representation of bitarray
func (b *Bitarray) ToString() *string {
	res := ""
	for _, v := range b.storage {
		tmp := fmt.Sprintf("%064b", v)
		_ = tmp
		res += fmt.Sprintf("%064b", v)
	}
	res = removeLeftZeros(res)
	return &res
}

func (b *Bitarray) ShiftLeft(n int) (res *Bitarray) {
	if n == 0 {
		res = &Bitarray{}
		res.InitializeByBitarray(b)
		return res
	}

	size := len(b.storage)
	sr := 64 - (n % 64)
	sl := n % 64
	if b.storage[0]>>(sr) != 0 {
		size++
	}
	res = &Bitarray{
		storage: make([]uint64, size),
	}
	for i, v := range b.storage {
		res.storage[i+1] = v << sl
		res.storage[i] += v >> sr
	}
	for i := 0; i < n/64; i++ {
		res.storage = append(res.storage, 0)
	}
	return res
}

func (b *Bitarray) ShiftRight(n int) (res *Bitarray) {
	res = &Bitarray{}
	if n == 0 {
		res.InitializeByBitarray(b)
		return res
	}

	size := len(b.storage)
	dr := n / 64

	if dr >= size {
		res.InitializeBySize(1)
		return res
	}

	sr := n % 64
	r := uint64(math.Pow(2, float64(sr))) - 1
	res.storage = make([]uint64, len(b.storage)-dr)
	copy(res.storage, b.storage[:len(b.storage)-dr])

	var shiftCarry uint64 = 0
	for i, v := range res.storage {
		res.storage[i] = res.storage[i] >> sr
		res.storage[i] += shiftCarry
		shiftCarry = (v & r)
		shiftCarry = shiftCarry << (64 - sr)
	}
	for res.storage[0] == 0 {
		res.storage = res.storage[1:]
	}
	return res
}

func (b *Bitarray) Flip(i uint64) error {
	v, err := b.Get(i)
	if err != nil {
		return err
	}
	b.Set(i, 1-v)
	return nil
}


text:
@INPROCEEDINGS{Mondal2011,
  author = {Debajyoti Mondal and Muhammad Jawaherul Alam and Md. Saidur Rahman},
  title = {Minimum-Layer Drawings of Trees},
  pages = {221--232},
  abstract = {A layered drawing of a tree T is a planar straight-line drawing of T, where the vertices of T are placed on some horizontal lines called layers. A minimum-layer drawing of T is a layered drawing of T on k layers, where k is the minimum number of layers required for any layered drawing of T. In this paper we give a linear-time algorithm for obtaining minimum-layer drawings of trees.},
  doi = {10.1007/978-3-642-19094-0_23},
  year = {2011},
  booktitle = {WALCOM'11: Proceedings of the International Workshop on Algorithms and Computation},
  editor = {Naoki Katoh and Amit Kumar},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  isbn = {9783642190933},
}


text:
package handlers

import (
	"encoding/json"
	"log"
	"net/http"
)

func GetInstanceImages(rw http.ResponseWriter, req *http.Request) {
	playground := core.PlaygroundFindByDomain(req.Host)
	if playground == nil {
		log.Printf("Playground for domain %s was not found!", req.Host)
		rw.WriteHeader(http.StatusBadRequest)
		return
	}
	json.NewEncoder(rw).Encode(playground.AvailableDinDInstanceImages)
}

repository: freeCompilerCamp/play-with-compiler

repo_name: freeCompilerCamp/play-with-compiler

gha_language: JavaScript


text:
@article{pmid28135244,
 author = {Warren, H. R.  and Evangelou, E. and ... and Niiranen, T. J. and ... and Caulfield, M. J.  and Elliott, P.},
 journal = {Nat. Genet.},
 keywords = {intarticle},
 month = {Mar},
 number = {3},
 pages = {403--415},
 title = {Genome-wide association analysis identifies novel blood pressure loci and offers biological insights into cardiovascular risk},
 volume = {49},
 year = {2017}
}

repository: hypertensioncenter/academic-kickstart

repo_name: hypertensioncenter/academic-kickstart


text:
@article{mandal2015ancom,
  title={Analysis of composition of microbiomes: a novel method for studying microbial composition},
  url={https://pubmed.ncbi.nlm.nih.gov/26028277/},
  author={Mandal, Siddhartha and Van Treuren, Will and White, Richard A and Eggesb{\o}, Merete and Knight, Rob and Peddada, Shyamal D},
  journal={Microbial ecology in health and disease},
  volume={26},
  number={1},
  pages={27663},
  year={2015},
  doi={10.3402/mehd.v26.27663},
  publisher={Taylor \& Francis}
}

@article{lin2020ancombc,
  title={Analysis of compositions of microbiomes with bias correction},
  url={https://www.nature.com/articles/s41467-020-17041-7},
  author={Lin, Huang and Peddada, Shyamal Das},
  journal={Nature communications},
  volume={11},
  number={1},
  pages={3514},
  year={2020},
  doi={10.1038/s41467-020-17041-7},
  publisher={Nature Publishing Group UK London}
}


text:
package database

import (
	"crypto/cipher"
	"encoding/binary"
	"fmt"
)

type EncryptedFile struct {
	block cipher.Block
	impl  File
}

func WrapInCTR(block cipher.Block, impl File) *EncryptedFile {
	return &EncryptedFile{block, impl}
}

func applyCTR(block cipher.Block, p []byte, off int64) {
	tailLen := off % int64(block.BlockSize())
	off -= tailLen
	off /= int64(block.BlockSize())
	iv := make([]byte, block.BlockSize())
	binary.BigEndian.PutUint64(iv[len(iv)-8:], uint64(off))
	stream := cipher.NewCTR(block, iv)
	tail := make([]byte, tailLen)
	stream.XORKeyStream(tail, tail)
	stream.XORKeyStream(p, p)
}

func allZeros(p []byte) bool {
	for _, c := range p {
		if c != 0 {
			return false
		}
	}
	return true
}

func (f *EncryptedFile) ReadAt(p []byte, off int64) (n int, err error) {
	n, err = f.impl.ReadAt(p, off)
	if err != nil {
		return n, err
	}
	if allZeros(p) {
		return n, fmt.Errorf("data was wiped")
	}
	applyCTR(f.block, p, off)
	return n, nil
}

func (f *EncryptedFile) WriteAt(p []byte, off int64) (n int, err error) {
	applyCTR(f.block, p, off)
	return f.impl.WriteAt(p, off)
}

repository: starius/pasta

repo_name: starius/pasta


text:
package main

import (
	"fmt"
	"github.com/chechiachang/etherscan"
)

const RATSCAM_CONTRACT = "0x8a883a20940870Dc055F2070ac8eC847ed2d9918"

func main() {
	fmt.Println("ratscam...")
	contract := etherscan.GetContract(RATSCAM_CONTRACT)
	for _, r := range contract.Results {
		fmt.Println(r.Name)
		fmt.Println(r)
	}
}

repository: chechiachang/etherscan

repo_name: chechiachang/etherscan


text:
@article{Glass-2021-Identifying,
    title = "Identifying groundwater discharge zones in the Central Mackenzie Valley using remotely sensed optical and thermal imagery",
    author = "Glass, Brittney K.  and
      Rudolph, David L.  and
      Duguay, Claude  and
      Wicke, Andrew",
    journal = "Canadian Journal of Earth Sciences, Volume 58, Issue 2",
    volume = "58",
    number = "2",
    year = "2021",
    publisher = "Canadian Science Publishing",
    url = "https://aclanthology.org/G21-185001",
    doi = "10.1139/cjes-2019-0169",
    pages = "105--121",
    abstract = "Landsat 4{--}5 Thematic Mapper, Landsat 8 Operational Land Imager, and RapidEye-3 data sets were used to identify potential groundwater discharge zones, via icings, in the Central Mackenzie Valley (CMV) of the Northwest Territories. Given that this area is undergoing active shale oil exploration and climatic changes, identification of groundwater discharge zones is of great importance both for pinpointing potential contaminant transport pathways and for characterizing the hydrologic system. Following the work of Morse and Wolfe (2015), a series of image algorithms were applied to imagery for the entire CMV and for the Bogg Creek watershed (a sub watershed of the CMV) for selected years between 2004 and 2017. Icings were statistically examined for all of the selected years to determine whether a significant difference in their spatial occurrence existed. It was concluded that there was a significant difference in the spatial distribution of icings from year to year (α = 0.05), but that there were several places where icings were recurring. During the summer of 2018, these recurrent icings, which are expected to be spring sourced, were verified using a thermal camera aboard a helicopter, as well as in situ measurements of hydraulic gradient, groundwater geochemistry, and electroconductivity. Strong agreement was found between the mapped icings and summer field data, making them ideal field monitoring locations. Furthermore, identifying these discharge points remotely is expected to have drastically reduced the field efforts that would have been required to find them in situ. This work demonstrates the value of remote sensing methods for hydrogeological applications, particularly in remote northern locations.",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications

branch_name: refs/heads/main

gha_language: Python


text:
require x11-xserver-utils.inc

DESCRIPTION = "a command-line interface to the RandR extension"

LIC_FILES_CHKSUM = "file://COPYING;md5=fe1608bdb33cf8c62a4438f7d34679b3"

S = "${DEBIAN_UNPACK_DIR}/xrandr"

repository: manut/meta-combo

repo_name: manut/meta-combo

branch_name: refs/heads/morty

gha_language: BitBake

extension: bb


text:
@article {Hoppeeaaw7238,
	author = {Hoppe, Travis A. and Litovitz, Aviva and Willis, Kristine A. and Meseroll, Rebecca A. and Perkins, Matthew J. and Hutchins, B. Ian and Davis, Alison F. and Lauer, Michael S. and Valantine, Hannah A. and Anderson, James M. and Santangelo, George M.},
	title = {Topic choice contributes to the lower rate of NIH awards to African-American/black scientists},
	volume = {5},
	number = {10},
	elocation-id = {eaaw7238},
	year = {2019},
	doi = {10.1126/sciadv.aaw7238},
	publisher = {American Association for the Advancement of Science},
	abstract = {Despite efforts to promote diversity in the biomedical workforce, there remains a lower rate of funding of National Institutes of Health R01 applications submitted by African-American/black (AA/B) scientists relative to white scientists. To identify underlying causes of this funding gap, we analyzed six stages of the application process from 2011 to 2015 and found that disparate outcomes arise at three of the six: decision to discuss, impact score assignment, and a previously unstudied stage, topic choice. Notably, AA/B applicants tend to propose research on topics with lower award rates. These topics include research at the community and population level, as opposed to more fundamental and mechanistic investigations; the latter tend to have higher award rates. Topic choice alone accounts for over 20\% of the funding gap after controlling for multiple variables, including the applicant{\textquoteright}s prior achievements. Our findings can be used to inform interventions designed to close the funding gap.},
	URL = {https://advances.sciencemag.org/content/5/10/eaaw7238},
	eprint = {https://advances.sciencemag.org/content/5/10/eaaw7238.full.pdf},
	journal = {Science Advances}
}

repository: pmean/build-website

repo_name: pmean/build-website


text:
// Copyright 2019 Tskken. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.

package quadgo

import "fmt"

// Point is the basic 2D coordinate structure for QuadGo
type Point struct {
	X, Y float64
}

// NewPoint creates a new point for the given x and y positions.
func NewPoint(x, y float64) Point {
	return Point{
		X: x,
		Y: y,
	}
}

// IsEqual checks if the given point is equal to this point.
func (p Point) IsEqual(point Point) bool {
	return p.X == point.X && p.Y == point.Y
}

func (p Point) String() string {
	return fmt.Sprintf("X: %v, Y: %v", p.X, p.Y)
}

repository: Tskken/quadgo

repo_name: Tskken/quadgo

gha_language: Go


text:
package plan

import (
	"github.com/hdpe.me/esup/schema"
	"github.com/hdpe.me/esup/testutil"
	"io/ioutil"
	"os"
)

var indexSetTestCases = []PlanTestCase{
	&indexSetTestCase{
		desc:    "create fresh index set",
		envName: "env",
		version: "20010203040506",
		indexSet: IndexSetSpec{
			Name:    "x",
			Content: "{}",
			Meta:    schema.IndexSetMeta{},
		},
		expected: []testutil.Matcher{
			newCreateIndexMatcher().
				withName("env-x_20010203040506").
				withDefinition("{}"),
			newCreateAliasMatcher().
				withName("env-x").
				withIndex("env-x_20010203040506"),
			newWriteChangelogEntryMatcher().
				withResourceType("index_set").
				withResourceIdentifier("x").
				withFinalName("env-x_20010203040506").
				withEnvName("env").
				withDefinition("{}").
				withMeta("{\"Index\":\"\",\"Prototype\":{\"Disabled\":false,\"MaxDocs\":0},\"Reindex\":{\"Pipeline\":\"\"}}"),
		},
	},
	&indexSetTestCase{
		desc:    "update existing index set",
		envName: "env",
		version: "20010203040506",
		setup: func(setup Setup) {
			setup.Apply(
				&createIndex{
					name:       "old",
					definition: "{}",
				},
				&createAlias{
					name:  "env-x",
					index: "old",
				},
				&writeChangelogEntry{
					resourceType:       "index_set",
					resourceIdentifier: "x",
					definition:         "{}",
					meta:               "{}",
					envName:            "env",
				},
			)
		},
		indexSet: IndexSetSpec{
			Name:    "x",
			Content: "{}",
			Meta:    schema.IndexSetMeta{},
		},
		expected: []testutil.Matcher{
			newCreateIndexMatcher().
				withName("env-x_20010203040506").
				withDefinition("{}"),
			newReindexMatcher().
				withFrom("env-x").
				withTo("env-x_20010203040506").
				withMaxDocs(-1),
			newUpdateAliasMatcher().
				withName("env-x").
				withIndexToAdd("env-x_20010203040506").
				withIndicesToRemove([]string{"old"}),
			newWriteChangelogEntryMatcher(),
		},
	},
	&indexSetTestCase{
		desc:    "create static index set",
		envName: "env",
		setup: func(setup Setup) {
			setup.Apply(
				&createIndex{
					name:       "common-idx",
					definition: "{}",
				},
				&createAlias{
					name:  "other-idx",
					index: "common-idx",
				},
			)
		},
		indexSet: IndexSetSpec{
			Name:    "x",
			Content: "",
			Meta: schema.IndexSetMeta{
				Index: "common-idx",
			},
		},
		expected: []testutil.Matcher{
			newCreateAliasMatcher().
				withName("env-x").
				withIndex("common-idx"),
			newWriteChangelogEntryMatcher().
				withResourceType("index_set").
				withResourceIdentifier("x").
				withFinalName("common-idx").
				withEnvName("env").
				withDefinition("").
				withMeta("{\"Index\":\"common-idx\",\"Prototype\":{\"Disabled\":false,\"MaxDocs\":0},\"Reindex\":{\"Pipeline\":\"\"}}"),
		},
	},
	&indexSetTestCase{
		desc:    "update static index set",
		envName: "env",
		setup: func(setup Setup) {
			setup.Apply(
				&createIndex{
					name:       "common-idx",
					definition: "{}",
				},
				&createIndex{
					name:       "common2-idx",
					definition: "{}",
				},
				&createAlias{
					name:  "other-idx",
					index: "common-idx",
				},
				&createAlias{
					name:  "env-idx",
					index: "common-idx",
				},
			)
		},
		indexSet: IndexSetSpec{
			Name:    "idx",
			Content: "",
			Meta: schema.IndexSetMeta{
				Index: "common2-idx",
			},
		},
		expected: []testutil.Matcher{
			newUpdateAliasMatcher().
				withName("env-idx").
				withIndexToAdd("common2-idx").
				withIndicesToRemove([]string{"common-idx"}),
			newWriteChangelogEntryMatcher(),
		},
	},
}

type indexSetTestCase struct {
	desc     string
	envName  string
	version  string
	setup    func(Setup)
	indexSet IndexSetSpec
	expected []testutil.Matcher

	// temp file containing index set resource definition
	filePath string
}

func (r *indexSetTestCase) Desc() string {
	return r.desc
}

func (r *indexSetTestCase) EnvName() string {
	return r.envName
}

func (r *indexSetTestCase) Version() string {
	return r.version
}

func (r *indexSetTestCase) Schema() (schema.Schema, error) {
	file, err := ioutil.TempFile("", "*")

	if err != nil {
		return schema.Schema{}, err
	}

	r.filePath = file.Name()
	err = ioutil.WriteFile(r.filePath, []byte(r.indexSet.Content), 0600)

	return schema.Schema{
		EnvName: r.envName,
		IndexSets: []schema.IndexSet{
			{
				IndexSet: r.indexSet.Name,
				FilePath: r.filePath,
				Meta:     r.indexSet.Meta,
			},
		},
	}, err
}

func (r *indexSetTestCase) Setup() func(setup Setup) {
	return r.setup
}

func (r *indexSetTestCase) Expected() []testutil.Matcher {
	return r.expected
}

func (r *indexSetTestCase) Clean() error {
	return os.Remove(r.filePath)
}

type IndexSetSpec struct {
	Name    string
	Content string
	Meta    schema.IndexSetMeta
}

repository: hdpe/esup

repo_name: hdpe/esup


text:
SUMMARY = "OpenLDAP Directory Service"
DESCRIPTION = "OpenLDAP Software is an open source implementation of the Lightweight Directory Access Protocol."
HOMEPAGE = "http://www.OpenLDAP.org/license.html"
# The OpenLDAP Public License - see the HOMEPAGE - defines
# the license.  www.openldap.org claims this is Open Source
# (see http://www.openldap.org), the license appears to be
# basically BSD.  opensource.org does not record this license
# at present (so it is apparently not OSI certified).
LICENSE = "OpenLDAP"
LIC_FILES_CHKSUM = "file://COPYRIGHT;md5=beceb5ac7100b6430640c61655b25c1f \
                    file://LICENSE;md5=153d07ef052c4a37a8fac23bc6031972 \
                    "
SECTION = "libs"

LDAP_VER = "${@'.'.join(d.getVar('PV').split('.')[0:2])}"

SRC_URI = "http://www.openldap.org/software/download/OpenLDAP/openldap-release/${BP}.tgz \
    file://initscript \
    file://slapd.service \
    file://remove-user-host-pwd-from-version.patch \
    file://0001-build-top.mk-unset-STRIP_OPTS.patch \
    file://0001-configure-Pass-pthread_t-to-pthread_detach.patch \
"

SRC_URI[sha256sum] = "ee3c430c4ef7b87c57b622108c7339376d6c27fbbf2767770be3de1df63d008c"

DEPENDS = "util-linux groff-native"

inherit autotools-brokensep update-rc.d systemd pkgconfig

# CV SETTINGS
# Required to work round AC_FUNC_MEMCMP which gets the wrong answer
# when cross compiling (should be in site?)
EXTRA_OECONF += "ac_cv_func_memcmp_working=yes"

# CONFIG DEFINITIONS
# The following is necessary because it cannot be determined for a
# cross compile automagically.  Select should yield fine on all OE
# systems...
EXTRA_OECONF += "--with-yielding-select=yes"
# Shared libraries are nice...
EXTRA_OECONF += "--enable-dynamic"

PACKAGECONFIG ??= "asyncmeta gnutls modules \
                   mdb ldap meta null passwd proxycache dnssrv \
                   ${@bb.utils.filter('DISTRO_FEATURES', 'ipv6', d)} \
"
#--with-tls              with TLS/SSL support auto|openssl|gnutls [auto]
PACKAGECONFIG[gnutls] = "--with-tls=gnutls,,gnutls"
PACKAGECONFIG[openssl] = "--with-tls=openssl,,openssl"

PACKAGECONFIG[sasl] = "--with-cyrus-sasl,--without-cyrus-sasl,cyrus-sasl"
PACKAGECONFIG[modules] = "lt_cv_dlopen_self=yes --enable-modules,--disable-modules,libtool"
PACKAGECONFIG[ipv6] = "--enable-ipv6,--disable-ipv6"

# SLAPD options
#
# UNIX crypt(3) passwd support:
EXTRA_OECONF += "--enable-crypt"

# SLAPD BACKEND
#
# The backend must be set by the configuration.  This controls the
# required database.
#
# Backends="asyncmeta dnssrv ldap mdb meta ndb null passwd perl relay sock sql wt"
#
# Note that multiple backends can be built.  The ldbm backend requires a
# build-time choice of database API. To use the gdbm (or other) API the
# Berkely database module must be removed from the build.
md = "${libexecdir}/openldap"
#

#--enable-asyncmeta    enable asyncmeta backend no|yes|mod no
PACKAGECONFIG[asyncmeta] = "--enable-asyncmeta=mod,--enable-asyncmeta=no"

#--enable-dnssrv       enable dnssrv backend no|yes|mod no
PACKAGECONFIG[dnssrv] = "--enable-dnssrv=mod,--enable-dnssrv=no"

#--enable-ldap         enable ldap backend no|yes|mod no
PACKAGECONFIG[ldap] = "--enable-ldap=mod,--enable-ldap=no,"

#--enable-mdb          enable mdb database backend no|yes|mod [yes]
PACKAGECONFIG[mdb] = "--enable-mdb=yes,--enable-mdb=no,"

#--enable-meta         enable metadirectory backend no|yes|mod no
PACKAGECONFIG[meta] = "--enable-meta=mod,--enable-meta=no,"

#--enable-ndb          enable MySQL NDB Cluster backend no|yes|mod [no]
PACKAGECONFIG[ndb] = "--enable-ndb=mod,--enable-ndb=no,"

#--enable-null         enable null backend no|yes|mod no
PACKAGECONFIG[null] = "--enable-null=mod,--enable-null=no,"

#--enable-passwd       enable passwd backend no|yes|mod no
PACKAGECONFIG[passwd] = "--enable-passwd=mod,--enable-passwd=no,"

#--enable-perl         enable perl backend no|yes|mod no
#  This requires a loadable perl dynamic library, if enabled without
#  doing something appropriate (building perl?) the build will pick
#  up the build machine perl - not good (inherit perlnative?)
PACKAGECONFIG[perl] = "--enable-perl=mod,--enable-perl=no,perl"

#--enable-relay        enable relay backend no|yes|mod [yes]
PACKAGECONFIG[relay] = "--enable-relay=mod,--enable-relay=no,"

#--enable-sock         enable sock backend no|yes|mod [no]
PACKAGECONFIG[sock] = "--enable-sock=mod,--enable-sock=no,"

#--enable-sql          enable sql backend no|yes|mod no
# sql requires some sql backend which provides sql.h, sqlite* provides
# sqlite.h (which may be compatible but hasn't been tried.)
PACKAGECONFIG[sql] = "--enable-sql=mod,--enable-sql=no,sqlite3"

#--enable-wt           enable wt backend no|yes|mod no
# back-wt is marked currently as experimental
PACKAGECONFIG[wt] = "--enable-wt=mod,--enable-wt=no"

#--enable-dyngroup     Dynamic Group overlay no|yes|mod no
#  This is a demo, Proxy Cache defines init_module which conflicts with the
#  same symbol in dyngroup
PACKAGECONFIG[dyngroup] = "--enable-dyngroup=mod,--enable-dyngroup=no,"

#--enable-proxycache   Proxy Cache overlay no|yes|mod no
PACKAGECONFIG[proxycache] = "--enable-proxycache=mod,--enable-proxycache=no,"
FILES:${PN}-overlay-proxycache = "${md}/pcache-*.so.*"
PACKAGES += "${PN}-overlay-proxycache"

# Append URANDOM_DEVICE='/dev/urandom' to CPPFLAGS:
# This allows tls to obtain random bits from /dev/urandom, by default
# it was disabled for cross-compiling.
CPPFLAGS:append = " -D_GNU_SOURCE -DURANDOM_DEVICE=\\"/dev/urandom\\" -fPIC"

LDFLAGS:append = " -pthread"

do_configure() {
    rm -f ${S}/libtool
    aclocal
    libtoolize --force --copy
    gnu-configize
    cp ${STAGING_DATADIR_NATIVE}/libtool/build-aux/ltmain.sh ${S}/build
    cp ${STAGING_DATADIR_NATIVE}/libtool/build-aux/missing ${S}/build
    cp ${STAGING_DATADIR_NATIVE}/libtool/build-aux/compile ${S}/build
    autoconf
    oe_runconf
}

LEAD_SONAME = "libldap-${LDAP_VER}.so.*"

# The executables go in a separate package.  This allows the
# installation of the libraries with no daemon support.
# Each module also has its own package - see above.
PACKAGES += "${PN}-slapd ${PN}-slurpd ${PN}-bin"

# Package contents - shift most standard contents to -bin
FILES:${PN} = "${libdir}/lib*.so.* ${sysconfdir}/openldap/ldap.* ${localstatedir}/${BPN}/data"
FILES:${PN}-slapd = "${sysconfdir}/init.d ${libexecdir}/slapd ${sbindir} ${localstatedir}/run ${localstatedir}/volatile/run \
    ${sysconfdir}/openldap/slapd.* ${sysconfdir}/openldap/schema \
    ${sysconfdir}/openldap/DB_CONFIG.example ${systemd_unitdir}/system/*"
FILES:${PN}-slurpd = "${libexecdir}/slurpd ${localstatedir}/openldap-slurp"
FILES:${PN}-bin = "${bindir}"
FILES:${PN}-dev = "${includedir} ${libdir}/lib*.so ${libdir}/*.la ${libexecdir}/openldap/*.a ${libexecdir}/openldap/*.la ${libexecdir}/openldap/*.so ${libdir}/pkgconfig/*.pc"
FILES:${PN}-dbg += "${libexecdir}/openldap/.debug"

do_install:append() {
    install -d ${D}${sysconfdir}/init.d
    cat ${WORKDIR}/initscript > ${D}${sysconfdir}/init.d/openldap
    chmod 755 ${D}${sysconfdir}/init.d/openldap
    # This is duplicated in /etc/openldap and is for slapd
    rm -f ${D}${localstatedir}/openldap-data/DB_CONFIG.example

    # Installing slapd under ${sbin} is more FHS and LSB compliance
    mv ${D}${libexecdir}/slapd ${D}/${sbindir}/slapd
    rmdir --ignore-fail-on-non-empty ${D}${libexecdir}
    SLAPTOOLS="slapadd slapcat slapdn slapindex slappasswd slaptest slapauth slapacl slapschema slapmodify"
    cd ${D}/${sbindir}/
    rm -f ${SLAPTOOLS}
    for i in ${SLAPTOOLS}; do ln -sf slapd $i; done

    rmdir "${D}${localstatedir}/run"
    rmdir --ignore-fail-on-non-empty "${D}${localstatedir}"

    install -d ${D}${systemd_unitdir}/system/
    install -m 0644 ${WORKDIR}/slapd.service ${D}${systemd_unitdir}/system/
    sed -i -e 's,@SBINDIR@,${sbindir},g' ${D}${systemd_unitdir}/system/*.service

    # Uses mdm as the database
    #  and localstatedir as data directory ...
    sed -e 's/# modulepath/modulepath/' \
        -e 's/# moduleload\s*back_bdb.*/moduleload    back_mdb/' \
        -e 's/database\s*bdb/database        mdb/' \
        -e 's%^directory\s*.*%directory   ${localstatedir}/${BPN}/data/%' \
        -i ${D}${sysconfdir}/openldap/slapd.conf

    mkdir -p ${D}${localstatedir}/${BPN}/data
}

INITSCRIPT_PACKAGES = "${PN}-slapd"
INITSCRIPT_NAME:${PN}-slapd = "openldap"
INITSCRIPT_PARAMS:${PN}-slapd = "defaults"
SYSTEMD_PACKAGES = "${PN}-slapd"
SYSTEMD_SERVICE:${PN}-slapd = "slapd.service"
SYSTEMD_AUTO_ENABLE:${PN}-slapd ?= "disable"

PACKAGES_DYNAMIC += "^${PN}-backends.* ^${PN}-backend-.*"

# The modules require their .so to be dynamicaly loaded
INSANE_SKIP:${PN}-backend-asyncmeta  += "dev-so"
INSANE_SKIP:${PN}-backend-dnssrv     += "dev-so"
INSANE_SKIP:${PN}-backend-ldap       += "dev-so"
INSANE_SKIP:${PN}-backend-meta       += "dev-so"
INSANE_SKIP:${PN}-backend-mdb        += "dev-so"
INSANE_SKIP:${PN}-backend-null       += "dev-so"
INSANE_SKIP:${PN}-backend-passwd     += "dev-so"

python populate_packages:prepend () {
    backend_dir    = d.expand('${libexecdir}/openldap')
    do_split_packages(d, backend_dir, r'back_([a-z]*)\.so$', 'openldap-backend-%s', 'OpenLDAP %s backend', prepend=True, extra_depends='', allow_links=True)
    do_split_packages(d, backend_dir, r'back_([a-z]*)\-.*\.so\..*$', 'openldap-backend-%s', 'OpenLDAP %s backend', extra_depends='', allow_links=True)

    metapkg = "${PN}-backends"
    d.setVar('ALLOW_EMPTY:' + metapkg, "1")
    d.setVar('FILES:' + metapkg, "")
    metapkg_rdepends = []
    packages = d.getVar('PACKAGES').split()
    for pkg in packages[1:]:
        if pkg.count("openldap-backend-") and not pkg in metapkg_rdepends and not pkg.count("-dev") and not pkg.count("-dbg") and not pkg.count("static") and not pkg.count("locale"):
            metapkg_rdepends.append(pkg)
    d.setVar('RDEPENDS:' + metapkg, ' '.join(metapkg_rdepends))
    d.setVar('DESCRIPTION:' + metapkg, 'OpenLDAP backends meta package')
    packages.append(metapkg)
    d.setVar('PACKAGES', ' '.join(packages))
}

BBCLASSEXTEND = "native"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded


text:
package tags

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"regexp"
	"strings"
	"testing"

	yaml "gopkg.in/yaml.v2"

	"github.com/osteele/liquid/parser"
	"github.com/osteele/liquid/render"
	"github.com/stretchr/testify/require"
)

var iterationTests = []struct{ in, expected string }{
	{`{% for a in array %}{{ a }} {% endfor %}`, "first second third "},
	{`{% for a in nil %}{{ a }}.{% endfor %}`, ""},
	{`{% for a in false %}{{ a }}.{% endfor %}`, ""},
	{`{% for a in 2 %}{{ a }}.{% endfor %}`, ""},
	{`{% for a in "str" %}{{ a }}.{% endfor %}`, ""},
	{`{% for a in map %}{{ a[0] }}={{ a[1] }}.{% endfor %}`, "a=1."},
	{`{% for a in map_slice %}{{ a[0] }}={{ a[1] }}.{% endfor %}`, "a=1.b=2."},
	{`{% for k in keyed_map %}{{ k }}={{ keyed_map[k] }}.{% endfor %}`, "a=1.b=2."},

	// loop modifiers
	{`{% for a in array reversed %}{{ a }}.{% endfor %}`, "third.second.first."},
	{`{% for a in array limit: 2 %}{{ a }}.{% endfor %}`, "first.second."},
	{`{% for a in array limit: limit %}{{ a }}.{% endfor %}`, "first.second."},
	{`{% for a in array limit: loopmods.limit %}{{ a }}.{% endfor %}`, "first.second."},
	{`{% for a in array limit: loopmods["limit"] %}{{ a }}.{% endfor %}`, "first.second."},
	{`{% for a in array offset: 1 %}{{ a }}.{% endfor %}`, "second.third."},
	{`{% for a in array offset: offset %}{{ a }}.{% endfor %}`, "second.third."},
	{`{% for a in array offset: loopmods.offset %}{{ a }}.{% endfor %}`, "second.third."},
	{`{% for a in array offset: loopmods["offset"] %}{{ a }}.{% endfor %}`, "second.third."},
	{`{% for a in array reversed limit: 1 %}{{ a }}.{% endfor %}`, "third."},
	{`{% for a in array limit: 0 %}{{ a }}.{% endfor %}`, ""},
	{`{% for a in array offset: 3 %}{{ a }}.{% endfor %}`, ""},
	{`{% for a in array offset: 10 %}{{ a }}.{% endfor %}`, ""},
	// TODO investigate how these combine; does it depend on the order?
	// {`{% for a in array reversed offset:1 %}{{ a }}.{% endfor %}`, "second.first."},
	// {`{% for a in array limit:1 offset:1 %}{{ a }}.{% endfor %}`, "second."},
	// {`{% for a in array reversed limit:1 offset:1 %}{{ a }}.{% endfor %}`, "second."},

	// loop variables
	{`{% for a in array %}{{ forloop.first }}.{% endfor %}`, "true.false.false."},
	{`{% for a in array %}{{ forloop.last }}.{% endfor %}`, "false.false.true."},
	{`{% for a in array %}{{ forloop.index }}.{% endfor %}`, "1.2.3."},
	{`{% for a in array %}{{ forloop.index0 }}.{% endfor %}`, "0.1.2."},
	{`{% for a in array %}{{ forloop.rindex }}.{% endfor %}`, "3.2.1."},
	{`{% for a in array %}{{ forloop.rindex0 }}.{% endfor %}`, "2.1.0."},
	{`{% for a in array %}{{ forloop.length }}.{% endfor %}`, "3.3.3."},

	{`{% for i in array %}{{ forloop.index }}[{% for j in array %}{{ forloop.index }}{% endfor %}]{{ forloop.index }}{% endfor %}`,
		"1[123]12[123]23[123]3"},

	{`{% for a in array reversed %}{{ forloop.first }}.{% endfor %}`, "true.false.false."},
	{`{% for a in array reversed %}{{ forloop.last }}.{% endfor %}`, "false.false.true."},
	{`{% for a in array reversed %}{{ forloop.index }}.{% endfor %}`, "1.2.3."},
	{`{% for a in array reversed %}{{ forloop.rindex }}.{% endfor %}`, "3.2.1."},
	{`{% for a in array reversed %}{{ forloop.length }}.{% endfor %}`, "3.3.3."},

	{`{% for a in array limit:2 %}{{ forloop.index }}.{% endfor %}`, "1.2."},
	{`{% for a in array limit:2 %}{{ forloop.rindex }}.{% endfor %}`, "2.1."},
	{`{% for a in array limit:2 %}{{ forloop.first }}.{% endfor %}`, "true.false."},
	{`{% for a in array limit:2 %}{{ forloop.last }}.{% endfor %}`, "false.true."},
	{`{% for a in array limit:2 %}{{ forloop.length }}.{% endfor %}`, "2.2."},

	{`{% for a in array offset:1 %}{{ forloop.index }}.{% endfor %}`, "1.2."},
	{`{% for a in array offset:1 %}{{ forloop.rindex }}.{% endfor %}`, "2.1."},
	{`{% for a in array offset:1 %}{{ forloop.first }}.{% endfor %}`, "true.false."},
	{`{% for a in array offset:1 %}{{ forloop.last }}.{% endfor %}`, "false.true."},
	{`{% for a in array offset:1 %}{{ forloop.length }}.{% endfor %}`, "2.2."},

	{`{% for a in array %}{% if a == 'second' %}{% break %}{% endif %}{{ a }}{% endfor %}`, "first"},
	{`{% for a in array %}{% if a == 'second' %}{% continue %}{% endif %}{{ a }}.{% endfor %}`, "first.third."},

	// cycle
	{`{% for a in array %}{% cycle 'even', 'odd' %}.{% endfor %}`, "even.odd.even."},
	{`{% for a in array %}{% cycle '0', '1' %},{% cycle '0', '1' %}.{% endfor %}`, "0,1.0,1.0,1."},
	// {`{% for a in array %}{% cycle group: 'a', '0', '1' %},{% cycle '0', '1' %}.{% endfor %}`, "0,1.0,1.0,1."},

	// range
	{`{% for i in (3 .. 5) %}{{i}}.{% endfor %}`, "3.4.5."},
	{`{% for i in (3..5) %}{{i}}.{% endfor %}`, "3.4.5."},

	// tablerow
	{`{% tablerow product in products %}{{ product }}{% endtablerow %}`,
		`
Cool Shirt
	Alien Poster
	Batman Poster
	Bullseye Shirt
	Another Classic Vinyl
	Awesome Jeans
`},

	{`{% tablerow product in products cols:2 %}{{ product }}{% endtablerow %}`,
		`
Cool Shirt	Alien Poster

Batman Poster	Bullseye Shirt

Another Classic Vinyl	Awesome Jeans
`},
	{`{% tablerow product in products cols: cols %}{{ product }}{% endtablerow %}`,
		`
Cool Shirt	Alien Poster

Batman Poster	Bullseye Shirt

Another Classic Vinyl	Awesome Jeans
`},
	{`{% tablerow product in products cols: loopmods.cols %}{{ product }}{% endtablerow %}`,
		`
Cool Shirt	Alien Poster

Batman Poster	Bullseye Shirt

Another Classic Vinyl	Awesome Jeans
`},
	{`{% tablerow product in products cols: loopmods.cols %}{{ product }}{% endtablerow %}`,
		`
Cool Shirt	Alien Poster

Batman Poster	Bullseye Shirt

Another Classic Vinyl	Awesome Jeans
`},
}

var iterationSyntaxErrorTests = []struct{ in, expected string }{
	{`{% for a b c %}{% endfor %}`, "syntax error"},
	{`{% for a in array offset %}{% endfor %}`, "undefined loop modifier"},
	{`{% cycle %}`, "syntax error"},
}

var iterationErrorTests = []struct{ in, expected string }{
	{`{% break %}`, "break outside a loop"},
	{`{% continue %}`, "continue outside a loop"},
	{`{% cycle 'a', 'b' %}`, "cycle must be within a forloop"},
	{`{% for a in array | undefined_filter %}{% endfor %}`, "undefined filter"},
	{`{% for a in array %}{{ a | undefined_filter }}{% endfor %}`, "undefined filter"},
}

var iterationTestBindings = map[string]interface{}{
	"array": []string{"first", "second", "third"},
	// hash has only one element, since iteration order is non-deterministic
	"map":       map[string]interface{}{"a": 1},
	"keyed_map": IterationKeyedMap(map[string]interface{}{"a": 1, "b": 2}),
	"map_slice": yaml.MapSlice{{Key: "a", Value: 1}, {Key: "b", Value: 2}},
	"products": []string{
		"Cool Shirt", "Alien Poster", "Batman Poster", "Bullseye Shirt", "Another Classic Vinyl", "Awesome Jeans",
	},
	"offset":   1,
	"limit":    2,
	"cols":     2,
	"loopmods": map[string]interface{}{"limit": 2, "offset": 1, "cols": 2},
}

func TestIterationTags(t *testing.T) {
	config := render.NewConfig()
	AddStandardTags(config)
	for i, test := range iterationTests {
		t.Run(fmt.Sprintf("%02d", i+1), func(t *testing.T) {
			root, err := config.Compile(test.in, parser.SourceLoc{})
			require.NoErrorf(t, err, test.in)
			buf := new(bytes.Buffer)
			err = render.Render(root, buf, iterationTestBindings, config)
			require.NoErrorf(t, err, test.in)
			actual := buf.String()
			if strings.Contains(test.in, "{% tablerow") {
				replaceWS := regexp.MustCompile(`\n\s*`).ReplaceAllString
				actual = replaceWS(actual, "")
				test.expected = replaceWS(test.expected, "")
			}
			require.Equalf(t, test.expected, actual, test.in)
		})
	}
}

func TestIterationTags_errors(t *testing.T) {
	cfg := render.NewConfig()
	AddStandardTags(cfg)

	for i, test := range iterationSyntaxErrorTests {
		t.Run(fmt.Sprintf("%02d", i+1), func(t *testing.T) {
			_, err := cfg.Compile(test.in, parser.SourceLoc{})
			require.Errorf(t, err, test.in)
			require.Containsf(t, err.Error(), test.expected, test.in)
		})
	}

	for i, test := range iterationErrorTests {
		t.Run(fmt.Sprintf("%02d", i+1+len(iterationSyntaxErrorTests)), func(t *testing.T) {
			root, err := cfg.Compile(test.in, parser.SourceLoc{})
			require.NoErrorf(t, err, test.in)
			err = render.Render(root, ioutil.Discard, iterationTestBindings, cfg)
			require.Errorf(t, err, test.in)
			require.Containsf(t, err.Error(), test.expected, test.in)
		})
	}
}

repository: osteele/liquid

repo_name: osteele/liquid


text:
@InProceedings{wang13a,
  pdf = {http://jmlr.org/proceedings/papers/v28/wang13a.pdf},
  number = {2},
  section = {cycle-2},
  title = {Fast dropout training},
  author = {Wang, Sida and Manning, Christopher},
  pages = {118-126},
  abstract = {Preventing feature co-adaptation by encouraging independent contributions from different features often improves classification and regression performance.  Dropout training (Hinton et al., 2012) does this by randomly dropping out (zeroing) hidden units and input features during training of neural networks. However, repeatedly sampling a random subset of input features makes training much slower. Based on an examination of the implied objective function of dropout training, we show how to do fast dropout training by sampling from or integrating a Gaussian approximation, instead of doing Monte Carlo optimization of this objective.  This approximation, justified by the central limit theorem and empirical evidence, gives an order of magnitude speedup and more stability.  We show how to do fast dropout training for classification, regression, and multilayer neural networks. Beyond dropout, our technique is extended to integrate out other types of noise and small image transformations. },
}

repository: mreid/papersite

repo_name: mreid/papersite


text:
# Copyright (c) 2013, Ruslan Baratov
# All rights reserved.

include(CMakeParseArguments) # cmake_parse_arguments

include(hunter_internal_error)
include(hunter_error_page)

function(hunter_fatal_error)
  cmake_parse_arguments(x "" "ERROR_PAGE" "" "${ARGV}")
  if(NOT x_ERROR_PAGE)
    hunter_internal_error("Expected argument ERROR_PAGE")
  endif()
  message("")
  foreach(x ${x_UNPARSED_ARGUMENTS})
    message("[hunter ** FATAL ERROR **] ${x}")
  endforeach()
  message("[hunter ** FATAL ERROR **] [Directory:${CMAKE_CURRENT_LIST_DIR}]")
  message("")
  hunter_error_page("${x_ERROR_PAGE}")
endfunction()

repository: cpp-pm/hunter

repo_name: cpp-pm/hunter

gha_language: CMake

extension: cmake


text:
package entity_operations

import (
	"GIG/app/repositories"
	"github.com/lsflk/gig-sdk/models"
	"log"
)

func HandleEntityTermination(entity models.Entity) {
	if entity.GetTitle() != "" {
		existingEntity, err := repositories.EntityRepository{}.GetEntityBy("title", entity.GetTitle())
		if err != nil {
			log.Println(err)
		}
		err = repositories.EntityRepository{}.TerminateEntity(existingEntity, entity.GetSource(), entity.GetSourceDate())
		if err != nil {
			log.Println(err)
		}
	}

	entities, err := repositories.EntityRepository{}.GetEntities(entity.GetTitle(), entity.GetCategories(), 0, 0)
	if err != nil {
		log.Println(err)
	}

	for _, result := range entities {
		err = repositories.EntityRepository{}.TerminateEntity(result, entity.GetSource(), entity.GetSourceDate())
		if err != nil {
			log.Println(err)
		}
	}
}

repository: LSFLK/GIG

repo_name: LSFLK/GIG