text:
numpages = {4},
keywords = {pervasive health, physical activity, play pattern, gamification, augmented reality game, motivation},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3026333,
author = {Uosaki, Noriko and Yonekawa, Takahiro and Yin, Chengjiu},
title = {Supporting Out-of-Class Interaction among Learners with InCircle},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3026333},
doi = {10.1145/3022198.3026333},
abstract = {This paper describes the development and evaluation of a chat system called InCircle. It is widely recognized in Japan that in-class learning time is far from sufficient in higher education, and it is highly necessary to promote out-of-class learning. In recent years, with the spreads of educational application of SNS (social network services), student-centred collaborative learning environment has been drawing attention. InCircle was introduced in a language and culture class at university in Japan in order to boost up out-of-class interaction among students and to enhance learning opportunities out-of-class. The result of the pilot evaluation showed that the number of the students' posting dramatically increased, while its out-of-class use was not active as expected.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {331–334},
numpages = {4},
keywords = {collaborative learning, international exchange subject, InCircle, out-of-class learning, international students},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3026327,
author = {Wahl, Andreas M. and Endler, Gregor and Schwab, Peter K. and Herbst, Sebastian and Lenz, Richard},
title = {We Can Query More than We Can Tell: Facilitating Collaboration Through Query-Driven Knowledge-Sharing},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3026327},
doi = {10.1145/3022198.3026327},
abstract = {We introduce Query-driven Knowledge-Sharing Systems (QKSS), which extend data management systems with knowledge-sharing capabilities to facilitate collaboration among different teams of data scientists. Relevant tacit knowledge about data sources is extracted from SQL query logs and externalized to support data source discovery and data integration. By studying this collaborative knowledge, data scientists are enabled to formulate effective analytical queries over unfamiliar data sources.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {335–338},
numpages = {4},
keywords = {data integration, data source discovery, collaborative data science, knowledge sharing},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3026341,
author = {Wozniak, Pawe\l{} W. and Lischke, Lars and Mayer, Sven and Preikschat, Andreas and Schweizer, Markus and Vu, Ba and von Molo, Carlo and Henze, Niels},
title = {Understanding Work in Public Transport Management Control Rooms},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3026341},
doi = {10.1145/3022198.3026341},
abstract = {Urban transport systems are increasingly important for modern cities as they provide sustainable transport and a positive social environment. The systems that allow controlling transport infrastructures integrate many legacy systems and require increasing resources for maintenance. Authorities managing public transport facilities not only need to dynamically adapt to the daily fluctuations in city life, but they also strive to be in constant dialogue with the citizens. In this poster paper, we present our preliminary insights from a study where we looked closely at the operations centre of a light rail and bus operator in a major German city. Through contextual inquiry, we chart emerging issues and design challenges. We showcase how urban facility managers negotiate legacy systems and cooperate with each other to keep transport systems functioning.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {339–342},
numpages = {4},
keywords = {work environment, public transport, Control room},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3026339,
author = {Ye, Teng and Reinecke, Katharina and Robert, Lionel P.},
title = {Personalized Feedback Versus Money: The Effect on Reliability of Subjective Data in Online Experimental Platforms},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3026339},
doi = {10.1145/3022198.3026339},
abstract = {We compared the data reliability on a subjective task from two platforms: Amazon's Mechanical Turk (MTurk) and LabintheWild. MTurk incentivizes participants with financial compensation while LabintheWild provides participants with personalized feedback. LabintheWild was found to produce higher data reliability than MTurk. Our findings suggested that online experiment platforms providing feedback in exchange for study participation could produce more reliable data in subjective preference tasks than those offering financial compensation.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {343–346},
numpages = {4},
keywords = {motivation, compensation, mechanical turk, data quality, online experimentation, crowdsourcing, incentives},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3026355,
author = {Zaga, Cristina and Moreno, Alejandro and Evers, Vanessa},
title = {<i>Gotta Hatch 'em All!</i>: Robot-Supported Cooperation in Interactive Playgrounds},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3026355},
doi = {10.1145/3022198.3026355},
abstract = {In this paper, we present ongoing research combining two technologies to support children's cooperative interaction: interactive playgrounds and robots. We propose that interactive playgrounds are vehicles for playful cooperation when robots are integrated into the system as cooperative co-players. We developed the Hatch 'em all game, wherein children are encouraged to hatch eggs cooperatively with a robot, and tested the effect of the robot's cooperative behavior on the children. We found that when the robot played cooperatively, children cooperated and helped the robot more than when the robot played selfishly. Our findings suggest that the social affordances of the playground, together with the social interactions between the children and the robot, enabled instances of team cooperation and prosocial behavior. Our work contributes to the CSCW community by opening a novel avenue for supporting children's cooperation, which could serve as a future testbed to investigate the role of robots in cooperative interaction},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {347–350},
numpages = {4},
keywords = {cooperative game, interactive playground, child-robot interaction, cscw},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022653,
author = {MacFadden, Michael S. and Ng, Agustina and Ignat, Claudia-Lavinia and Gu, Ning and Sun, Chengzheng},
title = {The Fifteenth International Workshop on Collaborative Editing Systems},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022653},
doi = {10.1145/3022198.3022653},
abstract = {Not long ago, real time collaborative editing (CE) systems were seen as a novelty to the average user, and a niche area of computer science research. Today, nothing could be further from the truth. Users are increasingly more connected and are creating more and more content online, on mobile devices, and in cloud based applications. Users are increasingly expecting collaborative editing functionalities in all of their applications.The focus of this year's workshop is: 1) to explore recent advances in the technologies that enable collaborative editing systems, 2) to evaluate the adoption of these technologies by commercial industry and the open source communities, and 3) to foster an exchange of ideas between CE researchers and end-user CE systems builders. The goal is to increase the adoption of recent technological advancements in CE research by practitioners and to have practitioners identify real-world challenges for future research.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {351–354},
numpages = {4},
keywords = {collaborative editing systems, groupware},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022656,
author = {McInnis, Brian and Centivany, Alissa and Kim, Juho and Poblet, Marta and Levy, Karen and Leshed, Gilly},
title = {Crowdsourcing Law and Policy: A Design-Thinking Approach to Crowd-Civic Systems},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022656},
doi = {10.1145/3022198.3022656},
abstract = {Crowdsourcing technologies, strategies and methods offer new opportunities for bridging existing gaps among law, policymaking, and the lived experience of citizens. In recent years, a number of initiatives across the world have applied crowdsourcing to contexts including constitutional reform, drafting federal bills, and generating local policies. However, crowd-civic systems also come with challenges and risks such as socio-technical barriers, marginalization of specific groups, silencing of interests, etc. Using a design-thinking approach, this workshop will address both opportunities and challenges of crowd-civic systems to develop best practices for increasing public engagement with law and policy. The workshop organizers will suggest an initial framework explicitly intended to be criticized by participants and reconfigured through a series of iterative cooperative small-group activities focusing on ``diagnosing'' the failures of past crowd-civic system efforts and the successes of online action around social issues. While the ultimate objective of the workshop is to develop a best practices guide, we see iterations on the guide as a mechanism for fostering community and collaboration among policymakers, technologists, and researchers around crowd-civic systems for law and policy.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {355–361},
numpages = {7},
keywords = {best practices, crowdsourcing, law and policy, online action, civic engagement},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022658,
author = {Filippova, Anna and Chapman, Brad and Geiger, R. Stuart and Herbsleb, James D. and Kalyanasundaram, Arun and Trainer, Erik and Moser, Aurelia and Stoltzfus, Arlin},
title = {Hacking and Making at Time-Bounded Events: Current Trends and Next Steps in Research and Event Design},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022658},
doi = {10.1145/3022198.3022658},
abstract = {Time-bounded collaborative events in which teams work together under intense time pressure are becoming increasingly popular. While hackathons, that is, competitive overnight coding events, are one of the more prevalent examples of this phenomenon, there are many more distinct event design variations for different audiences and with divergent aims, such as sprints, codefests, hack-days, edit-a-thons and so on. Taken together, these events offer new opportunities and challenges for cooperative work by affording explicit, predictable, time-bounded spaces for interdependent work and access to new audiences of collaborators. This one-day workshop brings together researchers interested in the phenomenon, experienced event organizers, and participants interested in running their own events to consolidate research to-date, share practical experiences, and understand what benefits different event variations may offer, how they may be applied in other contexts, and how insights from studying these events may contribute to CSCW knowledge.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {363–370},
numpages = {8},
keywords = {collaborative learning, innovation, sprints, codefests, edit-a-thons, open-source software, radical collocation, time-bounded collaborative events, scientific software, hackathons},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022654,
author = {Wagenknecht, Susann and Erickson, Ingrid and \O{}sterlund, Carsten and Mazmanian, Melissa and Bj\o{}rn, Pernille},
title = {Theory Transfers? Social Theory & CSCW Research},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022654},
doi = {10.1145/3022198.3022654},
abstract = {Finding time to present and discuss theories at CSCW events has proven a perpetual challenge. This workshop takes up this cause by facilitating an open-ended discussion about how diverse strands of social theory not only align with but support innovative CSCW research. The workshop will focus on three guiding questions: How, when, and to what end can social theory benefit CSCW research? What recent developments in social theory could be especially impactful for CSCW research today? What can CSCW research contribute to social theory? With an aim to building a new community of practice, the workshop will provide an open forum for scholars and practitioners to probing the merits and limitations of social theory for CSCW research. We welcome participants with diverse theoretical interests, ranging from organizational theory to intersectionality, social materiality to pragmatism, practice theory, and beyond.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {371–376},
numpages = {6},
keywords = {social theory, cscw research},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022660,
author = {Wisniewski, Pamela and Vitak, Jessica and Page, Xinru and Knijnenburg, Bart and Wang, Yang and Fiesler, Casey},
title = {In Whose Best Interest? Exploring the Real, Potential, and Imagined Ethical Concerns in Privacy-Focused Agenda},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022660},
doi = {10.1145/3022198.3022660},
abstract = {Through a series of ACM SIGCHI workshops, we have built a research community of individuals dedicated to networked privacy--from identifying the key challenges to designing privacy solutions and setting a privacy-focused agenda for the future. In this workshop, we take an intentional pause to unpack the potential ethical questions and concerns this agenda might raise. Rather than strictly focusing on privacy as a state that is always desired--where more privacy is viewed unequivocally as "better"--we consider situations where privacy may not be optimal for researchers, end users, or society. We discuss the current research landscape, including the recent updates to the ACM's Code of Ethics, and how researchers and designers can make more informed decisions regarding ethics, privacy, and other competing values in privacy-related research and designs. Our workshop includes group discussions, breakout activities, and a panel of experts with diverse insights discussing topics related to privacy and ethics.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {377–382},
numpages = {6},
keywords = {privacy, security, research design, usability, ethics, information disclosure},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022662,
author = {Gu, Ning and Ding, Xianghua (Sharon) and Lu, Tun and Ackerman, Mark S.},
title = {CSCW in China and Beyond},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022662},
doi = {10.1145/3022198.3022662},
abstract = {Recent years, we've observed a fast expansion of CSCW researchers in China. We want to hold a workshop so as to improve the communication and collaboration between CSCW researchers from China and the ACM CSCW community.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {383–386},
numpages = {4},
keywords = {ccf technical committee on collaborative computing (tccc), acm cscw community, cscw, computer-supported cooperative work, chinese conference on computer-supported cooperative work (ccscw)},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022665,
author = {Fox, Sarah and Menking, Amanda and Steinhardt, Stephanie and Hoffmann, Anna Lauren and Bardzell, Shaowen},
title = {Imagining Intersectional Futures: Feminist Approaches in CSCW},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022665},
doi = {10.1145/3022198.3022665},
abstract = {The aim of this one-day workshop is to explore theoretical and methodological approaches that help us consider issues of gender, sexual orientation, and power in the design of socio-technical systems. This program builds on two previous workshops on the topic of feminism and CSCW. With this instantiation, we are motivated by an explicit commitment to intersectionality--a recognition that the effects of various oppressions cannot be understood independently. Considerable time will be devoted to discussing work in post-colonial feminism, queer theory, Women of Color feminism, and feminist critical disability studies. Through generative conversation with participants, feedback on works-in-progress, and the initiation of outlets for new feminist CSCW work, we aim to 1) build on existing research and practice and 2) identify concerns and approaches for both designing and assessing research oriented toward intersectional and feminist futures in the context of CSCW and social computing.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {387–393},
numpages = {7},
keywords = {intersectionality, feminism, collaboration, design},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022652,
author = {Law, Edith and Williams, Alex C. and Wiggins, Andrea and Brier, Jonathan and Preece, Jenny and Shirk, Jennifer and Newman, Greg},
title = {The Science of Citizen Science: Theories, Methodologies and Platforms},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022652},
doi = {10.1145/3022198.3022652},
abstract = {Citizen science is a form of collaboration that engages non-professionals as contributors to scientific research, typically through the processes of gathering, transforming or analyzing data. To date, research has documented examples of hugely successful citizen science projects, such as Zooniverse and eBird, but citizen science also includes hundreds of smaller citizen science and functionally similar digital humanities projects, operating from small-scale web platforms and in-person collaborative teams. Yet, it is unclear what the "science" of citizen science entails: What are the core research questions and methodologies for answering them? What theories and concepts have been associated with citizen science research to date? What are the technology needs for supporting successful research collaboration among diverse stakeholders and across distinctive types of citizen science projects? In this workshop, our goal is to (i) bring together researchers studying citizen science to form a coherent map summarizing the theories, methodologies and platforms that currently defines citizen science research, with a special focus on CHI and CSCW relevant topics (ii) brainstorm a list of fundamental open questions and ways to tackle them, and (iii) form a multidisciplinary community to build synergies for further collaboration.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {395–400},
numpages = {6},
keywords = {theory, citizen science, platform, methodology},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022659,
author = {Jung, Malte F. and \v{S}abanovi\'{c}, Selma and Eyssel, Friederike and Fraune, Marlena},
title = {Robots in Groups and Teams},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022659},
doi = {10.1145/3022198.3022659},
abstract = {Over the last decade, the idea that robots could become an integral part of groups and teams has developed from a promising vision into a reality. Robots are increasingly designed to interact with groups and teams of people, yet most human-robot interaction research still focuses on a single humans interacting with a single robot. The goal for the workshop is therefore to advance research in computer supported cooperative work (CSCW) and human robot interaction (HRI) by raising awareness for the social and technical challenges that surround the placement of robots within work-groups and teams. The workshop will be organized around three central questions: (1) How do robots shape the dynamics of groups and teams in existing settings? (2) How does a robot's behavior shape how humans interact with each other in dyads and in larger groups and teams? (3) How can robots improve the performance of work groups and teams by acting on social processes? These core issues will be covered across a set of presentations that initiate in- depth discussions around each question to improve the quality of and support the growth of research in the CSCW community that focuses on the intersection of robots, groups, and teams.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {401–407},
numpages = {7},
keywords = {group performance, artificial agents, robots, group dynamics, groups and teams, artificial intelligence},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022664,
author = {Dillahunt, Tawanna R. and Erete, Sheena and Galusca, Roxana and Israni, Aarti and Nacu, Denise and Sengers, Phoebe},
title = {Reflections on Design Methods for Underserved Communities},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022664},
doi = {10.1145/3022198.3022664},
abstract = {The goal of this workshop is to facilitate a discussion around the ways in which research and design methods can be better tailored to support and engage underserved communities. We aim to create a publicly accessible repository of tools to support research and design efforts with underserved communities and to facilitate critical conversations about appropriate methods and solutions in this space. At the workshop, participants will collaborate with one another to explore their own as well as past, present, and future research and design initiatives with underserved communities; discuss challenges and lessons learned from using methods to facilitate technological development and creation among such populations; and brainstorm methods and solutions to address these challenges. Discussion and ideas generated from this workshop will be archived online and made available to the larger research community.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {409–413},
numpages = {5},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022655,
author = {Korn, Matthias and Schorch, Mar\'{e}n and Pipek, Volkmar and Bietz, Matthew and \O{}sterlund, Carsten and Procter, Rob and Ribes, David and Williams, Robin},
title = {E-Infrastructures for Research Collaboration: The Case of the Social Sciences and Humanities},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022655},
doi = {10.1145/3022198.3022655},
abstract = {Collaborative research practices are a highly interesting domain for CSCW. So far, CSCW has mainly focused on computation- and/or data-intensive research endeavors. Here, resources are typically pooled via common e-infrastructures for data access and processing, a set-up requiring additional layers of coordination. Such a focus largely foregrounds the sciences and other fields that rely on highly structured (or structure-able) data and the routinized processes of analysis. In contrast, in this one-day workshop we discuss the conditions and challenges characteristic of research collaboration in the qualitative social sciences and humanities (SSH). In particular, we examine the sociotechnical infrastructures that enable and support research practices that--in comparison with the collaborative paradigm of the natural sciences--tend to be less structured, compartmentalized, and routinized, but more fluid, flexible, and open-ended. The workshop seeks to collect empirical insights and design experiences, preparing the grounds for a comprehensive understanding of the role of e-infrastructures for collaborative research practices in SSH.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {415–420},
numpages = {6},
keywords = {qualitative research, humanities, cyberinfrastructure, infrastructuring, social sciences, e-research, e-infrastructure},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022661,
author = {Goggins, Sean and Germonprez, Matt and Million, A.J. and Halfaker, Aaron and Hemphill, Libby},
title = {Advancing the OCDX: Building Social Computing Infrastructure},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022661},
doi = {10.1145/3022198.3022661},
abstract = {We propose a workshop that builds on prior CSCW workshops focused on building a shared technical, social, and methodological infrastructure for more transparently sharing: a) data connected to social computing papers, b) methods and software built to analyze that data, and c) a common set of ethical practices built to address issues emerging in social computing research.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {421–424},
numpages = {4},
keywords = {data factories, research methods, CSCW tools, open collaboration, metadata},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022663,
author = {Gilbert, Eric and Lampe, Cliff and Leavitt, Alex and Lo, Katherine and Yarosh, Lana},
title = {Conceptualizing, Creating, & Controlling Constructive and Controversial Comments: A CSCW Research-Athon},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022663},
doi = {10.1145/3022198.3022663},
abstract = {Many social media platforms provide features for commenting, which often provide affordances for people to give feedback to others. Around the theme of advancing research about online comments, this workshop aims to bring together a diverse range of researchers for cross-discipline community building and especially dedicated time for productive, early mixed-methods research. The workshop is structured around a research "hackathon," where participants actively work on producing initial stages of research, theory, and design related to a central dataset (in the case of this workshop, public comments from a historical reddit.com corpus). Participants will form collaborative teams to tackle questions of interest that move forward current thinking around online comment behaviors, participants, quality, and design. The one-day workshop is led by 5 researchers, and it will accommodate up to 32 participants.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {425–430},
numpages = {6},
keywords = {hackathon, quality, feedback, social media, commenters, design, moderation, reddit, comments},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

@inproceedings{10.1145/3022198.3022666,
author = {Porcheron, Martin and Fischer, Joel E. and McGregor, Moira and Brown, Barry and Luger, Ewa and Candello, Heloisa and O'Hara, Kenton},
title = {Talking with Conversational Agents in Collaborative Action},
year = {2017},
isbn = {9781450346887},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3022198.3022666},
doi = {10.1145/3022198.3022666},
abstract = {This one-day workshop intends to bring together both academics and industry practitioners to explore collaborative challenges in speech interaction. Recent improvements in speech recognition and computing power has led to conversational interfaces being introduced to many of the devices we use every day, such as smartphones, watches, and even televisions. These interfaces allow us to get things done, often by just speaking commands, relying on a reasonably well understood single-user model. While research on speech recognition is well established, the social implications of these interfaces remain underexplored, such as how we socialise, work, and play around such technologies, and how these might be better designed to support collaborative collocated talk-in-action. Moreover, the advent of new products such as the Amazon Echo and Google Home, which are positioned as supporting multi-user interaction in collocated environments such as the home, makes exploring the social and collaborative challenges around these products, a timely topic. In the workshop, we will review current practices and reflect upon prior work on studying talk-in-action and collocated interaction. We wish to begin a dialogue that takes on the renewed interest in research on spoken interaction with devices, grounded in the existing practices of the CSCW community.},
booktitle = {Companion of the 2017 ACM Conference on Computer Supported Cooperative Work and Social Computing},
pages = {431–436},
numpages = {6},
keywords = {multi-party conversation, conversational agents, collocated interaction, intelligent personal assistants, CSCW},
location = {Portland, Oregon, USA},
series = {CSCW '17 Companion}
}

license_type: permissive

branch_name: refs/heads/main

extension: bib


text:
#
# Base recipe: meta-debian/recipes-debian/xorg-lib/libxext_1.3.2.bb
# Base bracnh: daisy
#

SUMMARY = "XExt: X Extension library"

DESCRIPTION = "libXext provides an X Window System client interface to \
several extensions to the X protocol.  The supported protocol extensions \
are DOUBLE-BUFFER, DPMS, Extended-Visual-Information, LBX, MIT_SHM, \
MIT_SUNDRY-NONSTANDARD, Multi-Buffering, SECURITY, SHAPE, SYNC, TOG-CUP, \
XC-APPGROUP, XC-MISC, XTEST.  libXext also provides a small set of \
utility functions to aid authors of client APIs for X protocol \
extensions."

require xorg-lib-common.inc

PR = "${INC_PR}.0"

LICENSE = "MIT-style"
LIC_FILES_CHKSUM = "file://COPYING;md5=879ce266785414bd1cbc3bc2f4d9d7c8"

DEPENDS += "xproto virtual/libx11 xextproto libxau libxdmcp"
PROVIDES = "xext"

BBCLASSEXTEND = "native nativesdk"

# There is no debian patch
DEBIAN_PATCH_TYPE = "nopatch"

# Correct the package name follow Debian
DEBIANNAME_${PN}-dbg = "${PN}6-dbg"

license: MIT

repository: nghiaht-tsdv/meta-debian

repo_name: nghiaht-tsdv/meta-debian

branch_name: refs/heads/jethro

gha_language: BitBake

extension: bb


text:
// Copyright 2020 Google LLC
//
// 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 ramcli

import (
	"fmt"
	"log"
	"os"

	"github.com/BrunoReboul/ram/services/publish2fs"
	"github.com/BrunoReboul/ram/utilities/ffo"
	"github.com/BrunoReboul/ram/utilities/solution"
)

// configurePublish2fsInstances
func (deployment *Deployment) configurePublish2fsInstances() (err error) {
	serviceName := "publish2fs"
	log.Printf("configure %s instances", serviceName)
	var publish2fsInstanceDeployment publish2fs.InstanceDeployment
	publish2fsInstance := publish2fsInstanceDeployment.Settings.Instance
	serviceFolderPath := fmt.Sprintf("%s/%s/%s", deployment.Core.RepositoryPath, solution.MicroserviceParentFolderName, serviceName)
	if _, err := os.Stat(serviceFolderPath); os.IsNotExist(err) {
		os.Mkdir(serviceFolderPath, 0755)
	}
	instancesFolderPath := fmt.Sprintf("%s/%s", serviceFolderPath, solution.InstancesFolderName)
	if _, err := os.Stat(instancesFolderPath); os.IsNotExist(err) {
		os.Mkdir(instancesFolderPath, 0755)
	}

	publish2fsInstance.GCF.TriggerTopic = "cai-rces-cloudresourcemanager-Organization"
	instanceFolderPath := makeInstanceFolderPath(instancesFolderPath, fmt.Sprintf("%s_cloudresourcemanager_Organization",
		serviceName))
	if _, err := os.Stat(instanceFolderPath); os.IsNotExist(err) {
		os.Mkdir(instanceFolderPath, 0755)
	}
	if err = ffo.MarshalYAMLWrite(fmt.Sprintf("%s/%s", instanceFolderPath, solution.InstanceSettingsFileName), publish2fsInstance); err != nil {
		return err
	}
	log.Printf("done %s", instanceFolderPath)

	publish2fsInstance.GCF.TriggerTopic = "cai-rces-cloudresourcemanager-Folder"
	instanceFolderPath = makeInstanceFolderPath(instancesFolderPath, fmt.Sprintf("%s_cloudresourcemanager_Folder",
		serviceName))
	if _, err := os.Stat(instanceFolderPath); os.IsNotExist(err) {
		os.Mkdir(instanceFolderPath, 0755)
	}
	if err = ffo.MarshalYAMLWrite(fmt.Sprintf("%s/%s", instanceFolderPath, solution.InstanceSettingsFileName), publish2fsInstance); err != nil {
		return err
	}
	log.Printf("done %s", instanceFolderPath)

	publish2fsInstance.GCF.TriggerTopic = "cai-rces-cloudresourcemanager-Project"
	instanceFolderPath = makeInstanceFolderPath(instancesFolderPath, fmt.Sprintf("%s_cloudresourcemanager_Project",
		serviceName))
	if _, err := os.Stat(instanceFolderPath); os.IsNotExist(err) {
		os.Mkdir(instanceFolderPath, 0755)
	}
	if err = ffo.MarshalYAMLWrite(fmt.Sprintf("%s/%s", instanceFolderPath, solution.InstanceSettingsFileName), publish2fsInstance); err != nil {
		return err
	}
	log.Printf("done %s", instanceFolderPath)

	publish2fsInstance.GCF.TriggerTopic = "gci-groupMembers"
	instanceFolderPath = makeInstanceFolderPath(instancesFolderPath, fmt.Sprintf("%s_gci_groupMembers",
		serviceName))
	if _, err := os.Stat(instanceFolderPath); os.IsNotExist(err) {
		os.Mkdir(instanceFolderPath, 0755)
	}
	if err = ffo.MarshalYAMLWrite(fmt.Sprintf("%s/%s", instanceFolderPath, solution.InstanceSettingsFileName), publish2fsInstance); err != nil {
		return err
	}
	log.Printf("done %s", instanceFolderPath)

	for directoryCustomerID := range deployment.Core.SolutionSettings.Monitoring.DirectoryCustomerIDs {
		publish2fsInstance.GCF.TriggerTopic = fmt.Sprintf("gci-groups-%s", directoryCustomerID)
		instanceFolderPath = makeInstanceFolderPath(instancesFolderPath, fmt.Sprintf("%s_gci_groups_%s",
			serviceName,
			directoryCustomerID))
		if _, err := os.Stat(instanceFolderPath); os.IsNotExist(err) {
			os.Mkdir(instanceFolderPath, 0755)
		}
		if err = ffo.MarshalYAMLWrite(fmt.Sprintf("%s/%s", instanceFolderPath, solution.InstanceSettingsFileName), publish2fsInstance); err != nil {
			return err
		}
		log.Printf("done %s", instanceFolderPath)
	}
	return nil
}

repository: BrunoReboul/ram

repo_name: BrunoReboul/ram

branch_name: refs/heads/dev

gha_language: Go

extension: go


text:
if(NOT TARGET capnproto)

  # Restore origin compile flags
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS_ORIGIN}")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_ORIGIN}")

  # Set options
  SET(BUILD_TESTING OFF CACHE BOOL "Build unit tests and enable CTest 'check' target." FORCE)

  # Module subdirectory
  add_subdirectory("capnproto")

  # Cygwin workaround: https://github.com/capnproto/capnproto/pull/696
  set_target_properties(kj PROPERTIES INTERFACE_COMPILE_FEATURES "")

  # Module folder
  set_target_properties(capnp PROPERTIES FOLDER modules/capnproto)
  set_target_properties(capnp-json PROPERTIES FOLDER modules/capnproto)
  set_target_properties(capnp-rpc PROPERTIES FOLDER modules/capnproto)
  set_target_properties(capnp_tool PROPERTIES FOLDER modules/capnproto)
  set_target_properties(capnpc PROPERTIES FOLDER modules/capnproto)
  set_target_properties(capnpc_capnp PROPERTIES FOLDER modules/capnproto)
  set_target_properties(capnpc_cpp PROPERTIES FOLDER modules/capnproto)
  set_target_properties(kj PROPERTIES FOLDER modules/capnproto)
  set_target_properties(kj-async PROPERTIES FOLDER modules/capnproto)
  set_target_properties(kj-http PROPERTIES FOLDER modules/capnproto)
  set_target_properties(kj-test PROPERTIES FOLDER modules/capnproto)

  # Module definition
  set(capnproto "${CMAKE_CURRENT_SOURCE_DIR}/capnproto/c++/src" PARENT_SCOPE)

  # Restore custom compile flags
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS_CUSTOM}")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_CUSTOM}")

endif()

repository: ottoGithub/CppSerialization

repo_name: ottoGithub/CppSerialization

branch_name: refs/heads/master

gha_license_id: MIT

extension: cmake


text:
// SPDX-FileCopyrightText: 2020-present Open Networking Foundation <info@opennetworking.org>
//
// SPDX-License-Identifier: Apache-2.0

package asn1

import (
	"github.com/onosproject/onos-lib-go/pkg/errors"
	"math"
)

// UpdateValue - replace the bytes value with values from a new []byte
// the size stays the same
func (m *BitString) UpdateValue(newBytes []byte) ([]byte, error) {
	if m == nil {
		return m.Value, errors.NewInvalid("null")
	}
	expectedLen := int(math.Ceil(float64(m.Len) / 8.0))
	if len(newBytes) != expectedLen {
		return m.Value, errors.NewInvalid("too many bytes %d. Expecting %d", len(newBytes), expectedLen)
	}
	m.Value = newBytes
	return m.Value, nil
}

// TruncateValue - truncates value of trailing bits in the BitString the size stays the same
// Assuming that BitString has a non-empty length
func (m *BitString) TruncateValue() ([]byte, error) {
	if m == nil {
		return m.Value, errors.NewInvalid("null")
	}
	if m.Len == 0 {
		return nil, errors.NewInvalid("Length should not be 0")
	}
	// Computing the number of bytes
	expectedBytesLen := int(math.Ceil(float64(m.Len) / 8.0))
	if len(m.Value) != expectedBytesLen {
		return m.Value, errors.NewInvalid("too many bytes %d. Expecting %d", len(m.Value), expectedBytesLen)
	}
	// Creating set of truncated bytes, with trailing zeroes
	// Since we've got there, value in expectedLen is correct
	truncBytes := make([]byte, expectedBytesLen)
	for i := 0; i < expectedBytesLen; i++ {
		truncBytes[i] = m.Value[i]
	}

	bitsFull := expectedBytesLen * 8
	trailingBits := uint32(bitsFull) - m.Len

	mask := ^((1 << trailingBits) - 1)
	truncBytes[len(truncBytes)-1] = truncBytes[len(truncBytes)-1] & byte(mask)
	//fmt.Printf("Last byte after truncation is %x\n", truncBytes[len(truncBytes)-1])
	m.Value = truncBytes
	return m.Value, nil
}

repository: tomikazi/onos-lib-go

repo_name: tomikazi/onos-lib-go


text:
package liveshare

import (
	"context"
	"fmt"
	"io"
	"sync"
	"time"

	"github.com/opentracing/opentracing-go"
	"github.com/sourcegraph/jsonrpc2"
)

type rpcClient struct {
	*jsonrpc2.Conn
	conn       io.ReadWriteCloser
	handlersMu sync.Mutex
	handlers   map[string][]*handlerWrapper
}

func newRPCClient(conn io.ReadWriteCloser) *rpcClient {
	return &rpcClient{conn: conn, handlers: make(map[string][]*handlerWrapper)}
}

func (r *rpcClient) connect(ctx context.Context) {
	stream := jsonrpc2.NewBufferedStream(r.conn, jsonrpc2.VSCodeObjectCodec{})
	r.Conn = jsonrpc2.NewConn(ctx, stream, r)
}

func (r *rpcClient) do(ctx context.Context, method string, args, result interface{}) error {
	span, ctx := opentracing.StartSpanFromContext(ctx, method)
	defer span.Finish()

	waiter, err := r.Conn.DispatchCall(ctx, method, args)
	if err != nil {
		return fmt.Errorf("error dispatching %q call: %w", method, err)
	}

	// timeout for waiter in case a connection cannot be made
	waitCtx, cancel := context.WithTimeout(ctx, 2*time.Minute)
	defer cancel()

	return waiter.Wait(waitCtx, result)
}

type handler func(conn *jsonrpc2.Conn, req *jsonrpc2.Request)

type handlerWrapper struct {
	fn handler
}

func (r *rpcClient) register(requestType string, fn handler) func() {
	r.handlersMu.Lock()
	defer r.handlersMu.Unlock()

	h := &handlerWrapper{fn: fn}
	r.handlers[requestType] = append(r.handlers[requestType], h)

	return func() {
		r.deregister(requestType, h)
	}
}

func (r *rpcClient) deregister(requestType string, handler *handlerWrapper) {
	r.handlersMu.Lock()
	defer r.handlersMu.Unlock()

	handlers := r.handlers[requestType]
	for i, h := range handlers {
		if h == handler {
			// Swap h with last element and pop.
			last := len(handlers) - 1
			handlers[i], handlers[last] = handlers[last], nil
			r.handlers[requestType] = handlers[:last]
			break
		}
	}
}

func (r *rpcClient) Handle(ctx context.Context, conn *jsonrpc2.Conn, req *jsonrpc2.Request) {
	r.handlersMu.Lock()
	defer r.handlersMu.Unlock()

	for _, handler := range r.handlers[req.Method] {
		go handler.fn(conn, req)
	}
}

repository: cli/cli

repo_name: cli/cli

branch_name: refs/heads/trunk


text:
package main

import (
	"context"

	"github.com/arschles/receipt-classifier/file"
	"github.com/arschles/receipt-classifier/matchers"
)

func walkDir(ctx context.Context, dir string) ([]decoded, error) {
	// diskFS, err := fs.NewFS(dir)
	// if err != nil {
	// 	return nil, err
	// }

	return nil, nil

}

type decoded struct {
	Regions []region `json:"regions"`
}

func (d decoded) allWords() file.Words {
	ret := []file.Word{}
	for _, region := range d.Regions {
		for _, line := range region.Lines {
			for _, word := range line.Words {
				ret = append(ret, file.Word(word.Text))
			}
		}
	}
	return ret
}

type region struct {
	Lines []line `json:"lines"`
}

type line struct {
	Words []word `json:"words"`
}

type word struct {
	Text string `json:"text"`
}

// TODO: read this from a file
func companies() file.Words {
	return []file.Word{
		"marriott",
		"microsoft",
		"github",
		"privacy.com",
		"netlify",
		"statuscode",
		"papercall",
		"gophercon",
		"netflix",
		"software engineering daily",
	}
}

func runMatches(d decoded) (*file.Matches, error) {
	words := d.allWords()
	return &file.Matches{
		Companies: matchers.Companies(words, companies()),
	}, nil
}

repository: arschles/packrat

repo_name: arschles/packrat


text:
PV = "1.0"

LICENSE = "GPLv2+"
LIC_FILES_CHKSUM = "file://COPYING;md5=751419260aa954499f7abaabaa882bbe"
DESCRIPTION = "Support B08 800x480 Display"

SRC_URI = "file://COPYING \
           file://30-b08display.conf "

S = "${WORKDIR}"

do_install () {
    install -d ${D}/usr/share/X11/xorg.conf.d/
    install -m 644 ${FILE_DIRNAME}/${PN}-${PV}/30-b08display.conf ${D}/usr/share/X11/xorg.conf.d/
}

FILES_${PN} = "/usr/share/X11/xorg.conf.d/"


text:
package protobuf

import (
	"errors"
	"io"
	"sync"
)

const maxInt = uint64(^uint(0) >> 1)

// readLength reads an varint encoded integer from an io.ByteWriter. Max
// defines the maximum message size that can be read, if max is 0, the
// maximum message size is not checked.
func readLength(r io.ByteReader, max int) (int, error) {
	size, _, err := readUvarint(r)
	if err != nil {
		return 0, err
	}
	if size > maxInt {
		return 0, errors.New("integer overflow")
	}

	msize := int(size)
	if max > 0 && msize > max {
		return 0, errors.New("message too large")
	}
	return msize, nil
}

// writeLength encodes size and writes it to an io.ByteWriter. Max defines
// the maximum message size that can be read, if max is 0, the maximum
// message size is not checked.
func writeLength(w io.ByteWriter, size, max int) error {
	if max > 0 && size > max {
		return errors.New("message too large")
	}
	return writeUvarint(w, uint64(size))
}

func readUvarint(r io.ByteReader) (uint64, int, error) {
	var v uint64
	for shift, n := uint(0), 0; ; shift += 7 {
		b, err := r.ReadByte()
		if err != nil {
			return v, n, err
		}
		n++

		if b < 0x80 {
			if n > 10 || n == 10 && b > 1 {
				return v, n, errors.New("64-bit integer overflow")
			}
			return v | uint64(b)<<shift, n, nil
		}
		v |= uint64(b&0x7f) << shift
	}
}

func writeUvarint(w io.ByteWriter, v uint64) (err error) {
	for v >= 0x80 {
		if err = w.WriteByte(byte(v) | 0x80); err != nil {
			return err
		}
		v >>= 7
	}
	return w.WriteByte(byte(v))
}

var (
	pool64 = sync.Pool{New: func() interface{} { return [8]byte{} }}
	pool32 = sync.Pool{New: func() interface{} { return [4]byte{} }}
)

func readFixed32(r io.Reader) (uint32, error) {
	b := pool32.Get().([4]byte)
	defer pool32.Put(b)

	if _, err := io.ReadFull(r, b[:]); err != nil {
		return 0, err
	}

	return uint32(b[0]) |
		uint32(b[1])<<8 |
		uint32(b[2])<<16 |
		uint32(b[3])<<24, nil
}

func writeFixed32(w io.Writer, v uint32) error {
	b := pool32.Get().([4]byte)
	defer pool32.Put(b)

	b[0] = byte(v)
	b[1] = byte(v >> 8)
	b[2] = byte(v >> 16)
	b[3] = byte(v >> 24)

	_, err := w.Write(b[:])
	return err
}

func readFixed64(r io.Reader) (uint64, error) {
	b := pool64.Get().([8]byte)
	defer pool64.Put(b)

	if _, err := io.ReadFull(r, b[:]); err != nil {
		return 0, err
	}

	return uint64(b[0]) |
		uint64(b[1])<<8 |
		uint64(b[2])<<16 |
		uint64(b[3])<<24 |
		uint64(b[4])<<32 |
		uint64(b[5])<<40 |
		uint64(b[6])<<48 |
		uint64(b[7])<<56, nil
}

func writeFixed64(w io.Writer, v uint64) error {
	b := pool64.Get().([8]byte)
	defer pool64.Put(b)

	b[0] = byte(v)
	b[1] = byte(v >> 8)
	b[2] = byte(v >> 16)
	b[3] = byte(v >> 24)
	b[4] = byte(v >> 32)
	b[5] = byte(v >> 40)
	b[6] = byte(v >> 48)
	b[7] = byte(v >> 56)

	_, err := w.Write(b[:])
	return err
}

license: ISC


text:
/*
Copyright 2020 The KubeSphere Authors.

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

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

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

package helmrepoindex

import (
	"bytes"
	"context"
	"fmt"
	"net/url"
	"strings"
	"time"

	"helm.sh/helm/v3/pkg/getter"

	"kubesphere.io/api/application/v1alpha1"

	"kubesphere.io/kubesphere/pkg/simple/client/s3"
)

func parseS3Url(parse *url.URL) (region, endpoint, bucket, path string) {
	if strings.HasPrefix(parse.Host, "s3.") {
		region = strings.Split(parse.Host, ".")[1]
		endpoint = fmt.Sprintf("https://%s", parse.Host)
	} else {
		region = "us-east-1"
		endpoint = fmt.Sprintf("http://%s", parse.Host)
	}
	parts := strings.Split(strings.TrimPrefix(parse.Path, "/"), "/")
	if len(parts) > 0 {
		bucket = parts[0]
		path = strings.Join(parts[1:], "/")
	} else {
		bucket = parse.Path
	}

	return region, endpoint, bucket, path
}

func loadData(ctx context.Context, u string, cred *v1alpha1.HelmRepoCredential) (*bytes.Buffer, error) {
	parsedURL, err := url.Parse(u)
	if err != nil {
		return nil, err
	}
	var resp *bytes.Buffer
	if strings.HasPrefix(u, "s3://") {
		region, endpoint, bucket, p := parseS3Url(parsedURL)
		client, err := s3.NewS3Client(&s3.Options{
			Endpoint:        endpoint,
			Bucket:          bucket,
			Region:          region,
			AccessKeyID:     cred.AccessKeyID,
			SecretAccessKey: cred.SecretAccessKey,
			DisableSSL:      !strings.HasPrefix(region, "https://"),
			ForcePathStyle:  true,
		})

		if err != nil {
			return nil, err
		}

		data, err := client.Read(p)
		if err != nil {
			return nil, err
		}

		resp = bytes.NewBuffer(data)
	} else {
		skipTLS := true
		if cred.InsecureSkipTLSVerify != nil && !*cred.InsecureSkipTLSVerify {
			skipTLS = false
		}

		indexURL := parsedURL.String()
		// TODO add user-agent
		g, _ := getter.NewHTTPGetter()
		resp, err = g.Get(indexURL,
			getter.WithTimeout(5*time.Minute),
			getter.WithURL(u),
			getter.WithInsecureSkipVerifyTLS(skipTLS),
			getter.WithTLSClientConfig(cred.CertFile, cred.KeyFile, cred.CAFile),
			getter.WithBasicAuth(cred.Username, cred.Password),
		)
		if err != nil {
			return nil, err
		}
	}

	return resp, nil
}

func LoadChart(ctx context.Context, u string, cred *v1alpha1.HelmRepoCredential) (*bytes.Buffer, error) {
	return loadData(ctx, u, cred)
}

repository: kubesphere/kubesphere

repo_name: kubesphere/kubesphere


text:
package ratelimit

import (
	"context"
	"errors"
	"math/rand"
	"sync/atomic"
	"time"

	"golang.org/x/sync/semaphore"
)

func init() {
	// Ensuring rand is random based on our start time
	rand.Seed(time.Now().UnixNano())
}

// Throttler allows for up to fix number of actions to happen within a
// fixed interval with accounting for jitters
type Throttler struct {
	limit             int64
	consumed, waiting int64
	interval, jitter  time.Duration

	bucket  *semaphore.Weighted
	running bool
}

// NewThrottler will configure a new rater limiting bucket with max of limit / (interval + [0,jitter)) ==> rate
// Once the limit has been breached, it will pause computation for that thread until the interval + jitter amount
// has been reached
func NewThrottler(limit int64, interval, jitter time.Duration) *Throttler {
	if limit < 0 {
		limit = 1
	}
	if interval < 0 {
		interval = 100 * time.Millisecond
	}
	if jitter < 0 {
		jitter = 0
	}
	return &Throttler{
		limit:    limit,
		interval: interval,
		jitter:   jitter,
		bucket:   semaphore.NewWeighted(limit),
	}
}

func withJitter(ticker *time.Timer, jiter time.Duration) <-chan time.Time {
	if jiter < 0 {
		return ticker.C
	}
	delay := rand.Int63n(int64(jiter))
	time.Sleep(time.Duration(delay))
	return ticker.C
}

// Start runs a background go routine that was reset the sync limit
// based on the interval and jitter time
func (lb *Throttler) Start() {
	if lb.running {
		return
	}
	lb.running = true
	lb.reset()
	go func() {
		timer := time.NewTimer(lb.interval)
		defer timer.Stop()
		for {
			if !lb.running {
				return
			}
			select {
			case <-withJitter(timer, lb.jitter):
				lb.reset()
			}
		}
	}()
}

// Stop will stop the background task to reset the bucket from running
// and will release anyone waiting for the
func (lb *Throttler) Stop() {
	if !lb.running {
		return
	}
	lb.running = false
	// Ensure all waiting proccesses are being let through
	for lb.waiting > 0 {
		lb.bucket.Release(lb.consumed)
	}
}

// Consume will take one place in the internal semiphore and will
// block once we have reached out limit and delay the processing of blocked
// this does mean that blocked will be delayed instead of dropped.
func (lb *Throttler) Consume(ctx context.Context) error {
	if !lb.running {
		return errors.New("not started")
	}
	atomic.AddInt64(&lb.waiting, 1)
	if err := lb.bucket.Acquire(ctx, 1); err != nil {
		return err
	}
	atomic.AddInt64(&lb.waiting, -1)
	atomic.AddInt64(&lb.consumed, 1)
	return nil
}

func (lb *Throttler) reset() {
	lb.bucket.Release(lb.consumed)
	atomic.StoreInt64(&lb.consumed, 0)
}

repository: MovieStoreGuy/detector-doctor

repo_name: MovieStoreGuy/detector-doctor


text:
@article {
	Teh1989,
	author		= {C. H. Teh and R. T. Chin},
	journal		= {IEEE Transactions on Pattern Analysis and Machine Intelligence},
    title		= {On the detection of dominant points on digital curves},
	year		= {1989},
	volume		= {11},
	number		= {8},
	pages		= {859-872},
	doi			= {10.1109/34.31447},
	ISSN		= {0162-8828},
	month		= {Aug},
}

@article {
	Yilmaz2004,
	author		= {A. Yilmaz and Xin Li and M. Shah},
	journal		= {IEEE Transactions on Pattern Analysis and Machine Intelligence},
	title		= {Contour-based object tracking with occlusion handling in video acquired using mobile cameras},
	year		= {2004},
	volume		= {26},
	number		= {11},
	pages		= {1531-1536},
	doi			= {10.1109/TPAMI.2004.96},
	ISSN		= {0162-8828},
	month		= {Nov},
}

@incollection {
	Liu2006,
	title 		= {Analysis of Contour Motions},
	author 		= {Liu, Ce and William T. Freeman and Edward H. Adelson},
	booktitle	= {Advances in Neural Information Processing Systems 19},
	editor 		= {P. B. Sch\"{o}lkopf and J. C. Platt and T. Hoffman},
	pages 		= {913--920},
	year 		= {2007},
	publisher 	= {MIT Press},
	url 		= {http://papers.nips.cc/paper/3040-analysis-of-contour-motions.pdf},
}

@inbook {
	Saha2017,
	author		= "Sourav Saha and Saptarshi Roy and Prasenjit Dey and Soumya Pal and Tamal Chakraborty and Mahapatra, Priya Ranjan Sinha",
	editor		= "Mandal, Jyotsna Kumar and Satapathy, Suresh Chandra and Sanyal, Manas Kumar and Bhateja, Vikrant",
	title		= "A Computer Vision Framework for Detecting Dominant Points on Contour of Image-Object Through Thick-Edge Polygonal Approximation",
	bookTitle	= "Proceedings of the First International Conference on Intelligent Computing and 	Communication",
	year		= "2017",
	publisher	= "Springer Singapore",
	address		= "Singapore",
	pages		= "527--535",
	isbn		= "978-981-10-2035-3",
	doi			= "10.1007/978-981-10-2035-3_54",
	url			= "http://dx.doi.org/10.1007/978-981-10-2035-3_54"
}

@inproceedings {
	bgslibrary,
	author    	= {Sobral, Andrews},
	title     	= {{BGSLibrary}: An OpenCV C++ Background Subtraction Library},
	booktitle 	= {IX Workshop de Visão Computacional (WVC'2013)},
	address   	= {Rio de Janeiro, Brazil},
	year      	= {2013},
	month     	= {Jun},
	url       	=	{https://github.com/andrewssobral/bgslibrary},
}

@article {
	Ramer1972,
	title 		= "An iterative procedure for the polygonal approximation of plane curves",
	journal 	= "Computer Graphics and Image Processing",
	volume 		= "1",
	number 		= "3",
	pages 		= "244 - 256",
	year 		= "1972",
	note 		= "",
	issn 		= "0146-664X",
	doi 		= "http://dx.doi.org/10.1016/S0146-664X(72)80017-0",
	url 		= "http://www.sciencedirect.com/science/article/pii/S0146664X72800170",
	author 		= "Urs Ramer",
}

@article {
	Wall1984,
	title 		= "A fast sequential method for polygonal approximation of digitized curves",
	journal 	= "Computer Vision, Graphics, and Image Processing",
	volume 		= "28",
	number 		= "2",
	pages 		= "220 - 227",
	year 		= "1984",
	note 		= "",
	issn 		= "0734-189X",
	doi 		= "http://dx.doi.org/10.1016/S0734-189X(84)80023-7",
	url 		= "http://www.sciencedirect.com/science/article/pii/S0734189X84800237",
	author 		= "Karin Wall and Per-Erik Danielsson",
}

@Inbook {
	Noh2013,
	author		= "Noh, SeungJong and Jeon, Moongu",
	editor		= "Lee, Kyoung Mu and Matsushita, Yasuyuki and Rehg, James M. and Hu, Zhanyi",
	title		= "A New Framework for Background Subtraction Using Multiple Cues",
	bookTitle	= "Computer Vision -- ACCV 2012: 11th Asian Conference on Computer Vision, Daejeon, Korea, November 5-9, 2012, Revised Selected Papers, Part III",
	year		= "2013",
	publisher	= "Springer Berlin Heidelberg",
	address		= "Berlin, Heidelberg",
	pages		= "493--506",
	isbn		= "978-3-642-37431-9",
	doi			= "10.1007/978-3-642-37431-9_38",
	url			= "http://dx.doi.org/10.1007/978-3-642-37431-9_38"
}

@misc {
	train_data,
    title 		= {I-Lids Dataset for AVSS 2007},
    url			= {http://www.eecs.qmul.ac.uk/~andrea/avss2007_d.html},
}

@misc {
	MPEG-7,
    title 		= {MPEG-7 Shape Matching},
    url			= {http://www.dabi.temple.edu/~shape/MPEG7/dataset.html},
}


text:
@misc{1,
	title={Mobile Ad-Hoc Networks:Routing},
    url={http://www.ece.rochester.edu/courses/ECE586/lectures/MANETS_Routing.pdf},
    publisher={University of Rochester},
    author={Heinzelman, W},
    year={2017}
    }

    @misc{2,
	title={What is a wireless LAN?},
    url={https://kb.iu.edu/d/aick},
    publisher={Kb.iu.edu.}
    }

     @misc{3,
	title={What is Apache?},
    url={http://www.wpbeginner.com/glossary/apache/},
    publisher={Wpbeginner.com},
    year={2017}
    }

     @misc{4,
	title={Apache vs Nginx: Practical Considerations},
    url={https://www.digitalocean.com/community/tutorials/apache-vs-nginx-practical-considerations},
    publisher={Digital Ocean},
    author={Ellingwood, J},
    year={2017}
    }

    @book{5,
    author    = {James F. Kurose, Keith W. Ross},
    title     = {Computer networking : a top-down approach},
    year      = {2013},
    publisher = {Pearson Education, Inc.},
    address   = {Boston}
    }

    @misc{6,
	title={Raspberry Pi Model 3B},
    url={https://www.pishop.us/product/raspberry-pi/pi-boards/raspberry-pi-3-model-b-armv8-with-1g-ram/?src=raspberrypi},
    publisher={PiShop},
    year={2017}
    }

    @misc{7,
	title={Beagle Boards},
    url={https://beagleboard.org/},
    author={Jason Kridner},
    year={2017}
    }

    @misc{8,
	title={How To Deploy a Node.js and MongoDB Application with Rancher on Ubuntu 16.04},
    url={https://www.digitalocean.com/community/tutorials/how-to-deploy-a-node-js-and-mongodb-application-with-rancher-on-ubuntu-16-04},
    publisher={Digital Ocean},
    author={James Kolce},
    year={2017}
    }


text:
SUMMARY = "Tools for ethernet bridging"
HOMEPAGE = "http://www.linuxfoundation.org/collaborate/workgroups/networking/bridge"
SECTION = "net"
LICENSE = "GPL-2.0-only"

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

SRCREV = "75d949b9fae9718201422f0bd3d1103e67dd597c"

SRC_URI = "\
    git://git.kernel.org/pub/scm/network/bridge/bridge-utils.git;branch=main \
    file://0001-include-missing-kernel-header.patch \
    file://0002-build-don-t-ignore-CFLAGS-from-environment.patch \
    file://0003-libbridge-Modifying-the-AR-to-cross-toolchain.patch \
    file://0004-cleanup-includes.patch \
"

S = "${WORKDIR}/git"

DEPENDS = "sysfsutils"

inherit autotools-brokensep update-alternatives

ALTERNATIVE:${PN} = "brctl"
ALTERNATIVE_PRIORITY[brctl] = "100"
ALTERNATIVE_LINK_NAME[brctl] = "${sbindir}/brctl"

EXTRA_OECONF = "--with-linux-headers=${STAGING_INCDIR}"

do_install:append () {
    install -d ${D}/${datadir}/bridge-utils
    install -d ${D}/${sysconfdir}/network/if-pre-up.d
    install -d ${D}/${sysconfdir}/network/if-post-down.d
}

RRECOMMENDS:${PN} = "kernel-module-bridge"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded


text:
#
# Sets Forge installation paths.
#

# NOTE: These paths are all relative to the project installation prefix.

# Executables
if(NOT DEFINED FG_INSTALL_BIN_DIR)
    set(FG_INSTALL_BIN_DIR "bin" CACHE PATH "Installation path for executables")
endif()

# Libraries
if(NOT DEFINED FG_INSTALL_LIB_DIR)
    set(FG_INSTALL_LIB_DIR "lib" CACHE PATH "Installation path for libraries")
endif()

# Header files
if(NOT DEFINED FG_INSTALL_INC_DIR)
    set(FG_INSTALL_INC_DIR "include" CACHE PATH "Installation path for headers")
endif()

set(DATA_DIR "share/Forge")

# Documentation
if(NOT DEFINED FG_INSTALL_DOC_DIR)
    if (WIN32)
        set(docs_dir "doc")
    else ()
        set(docs_dir "${DATA_DIR}/doc")
    endif ()
    set(FG_INSTALL_DOC_DIR "${docs_dir}" CACHE PATH "Installation path for documentation")
endif()

if(NOT DEFINED FG_INSTALL_EXAMPLE_DIR)
    if (WIN32)
        set(examples_dir "examples")
    else ()
        set(examples_dir "${DATA_DIR}/examples")
    endif ()
    set(FG_INSTALL_EXAMPLE_DIR "${examples_dir}" CACHE PATH "Installation path for examples")
endif()

# Man pages
if(NOT DEFINED FG_INSTALL_MAN_DIR)
    set(FG_INSTALL_MAN_DIR "${DATA_DIR}/man" CACHE PATH "Installation path for man pages")
endif()

# CMake files
if(NOT DEFINED FG_INSTALL_CMAKE_DIR)
    if(WIN32)
        set(cmake_dir "cmake")
    else()
        set(cmake_dir "${DATA_DIR}/cmake")
    endif()
    set(FG_INSTALL_CMAKE_DIR "${cmake_dir}" CACHE PATH "Installation path for CMake files")
endif()

# Use absolute paths (these changes are internal and will not show up in cache)
# The cache will continue to show relative/absolute paths as used without modifications
# This is required for configure_package_config_file in CMakeLists.txt

# CMAKE_INSTALL_PREFIX
# If this is relative, it is relative to PROJECT_BINARY_DIR
if(NOT IS_ABSOLUTE ${CMAKE_INSTALL_PREFIX})
    get_filename_component(CMAKE_INSTALL_PREFIX
                          "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_PREFIX}"
                           ABSOLUTE)
endif()

mark_as_advanced(
    FG_INSTALL_CMAKE_DIR
    FG_INSTALL_MAN_DIR
    FG_INSTALL_EXAMPLE_DIR
    FG_INSTALL_DOC_DIR
    FG_INSTALL_INC_DIR
    FG_INSTALL_LIB_DIR
    FG_INSTALL_BIN_DIR)

repository: pyzh/forge

repo_name: pyzh/forge


text:
/*
 *  VS_Socket.h
 *  VectorStorm
 *
 *  Created by Trevor Powell on 18/04/08.
 *  Copyright 2009 Trevor Powell. All rights reserved.
 *
 */

#ifndef VS_SOCKET_H
#define VS_SOCKET_H

class vsStore;
class vsNetClient;

class vsSocketListener
{
public:

	vsSocketListener() {}
	virtual ~vsSocketListener() {}

	virtual bool	HandlePacket( vsNetClient *from, vsStore *packet ) { UNUSED(from); UNUSED(packet); return false; }
};

class vsSocket
{
	uint32_t	m_privateIP;
	int			m_privatePort;
	//uint32_t	m_publicIP;	// for use someday if I ever do a serious network game
	//int		m_publicPort;

	int			m_socket;

	vsSocketListener *		m_listener;

public:

				vsSocket(int port = 0);		// a port of 0 means that we don't care what port we're using.  This is the preferred usage, as it will allow multiple instances to run on one computer!
	virtual		~vsSocket();

	void		SetListener( vsSocketListener *listener );

	void		SendTo( vsNetClient *to, vsStore *packet );

	void		Poll();		// call once per frame to check for any activity on the socket.
};

#endif // VS_SOCKET_H

license: Zlib

repository: vectorstorm/vectorstorm

repo_name: vectorstorm/vectorstorm

gha_license_id: NOASSERTION

extension: h


text:
#include "snake.hpp"

#include <cstddef>
#include <vector>// std::vector<bool>

struct block;
struct snake_internal;

struct block
{
    size_t x;
    size_t y;
};

// (226 * 56) * 12 / 2 / 1024
// round buffer
struct snake_internal
{
    //std::vector<line> lines;
};

namespace snake {
class snake
{
    position curr_pos;

public:
    snake(position init_pos) noexcept:
	curr_pos{init_pos}
    {}

};

snake* make_snake(position init_pos) noexcept
{
    return new snake{init_pos};
}
}

repository: NobodyXu/snippet

repo_name: NobodyXu/snippet

extension: cc


text:
require xorg-doc-common.inc
PE = "1"

DEPENDS += "util-macros"

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

SRC_URI[sha256sum] = "65a9fdddedc17bd5e9c0b00d904960f03f047c3a62de5458989d493c29fec806"

FILES:${PN} += " /usr/share/sgml/X11"


text:
@Manual{R,
  title = {{R}: A Language and Environment for Statistical Computing},
  author = {{R Core Team}},
  organization = {R Foundation for Statistical Computing},
  address = {Vienna, Austria},
  year = {2016},
  url = {https://www.R-project.org/},
  note = {version 3.3.2},
}

@Manual{BH,
  title = {{BH}: Boost C++ Header Files},
  author = {Dirk Eddelbuettel and John W. Emerson and Michael J. Kane},
  year = {2016},
  note = {R package version 1.62.0-1},
  url = {https://CRAN.R-project.org/package=BH},
}

@Manual{DBI,
  title = {{DBI}: {R} Database Interface},
  author = {{R Special Interest Group on Databases (R-SIG-DB)} and Hadley Wickham and Kirill Müller},
  year = {2016},
  note = {R package version 0.5-1},
  url = {https://CRAN.R-project.org/package=DBI},
}

@Manual{DT,
  title = {{DT}: A Wrapper of the JavaScript Library 'DataTables'},
  author = {Yihui Xie},
  year = {2016},
  note = {R package version 0.2},
  url = {https://CRAN.R-project.org/package=DT},
}

@Book{MASS,
  title = {Modern Applied Statistics with S},
  author = {W. N. Venables and B. D. Ripley},
  publisher = {Springer},
  edition = {Fourth},
  address = {New York},
  year = {2002},
  note = {ISBN 0-387-95457-0},
  url = {http://www.stats.ox.ac.uk/pub/MASS4},
}

@Manual{PKI,
  title = {{PKI}: Public Key Infrastucture for {R} Based on the X.509 Standard},
  author = {Simon Urbanek},
  year = {2015},
  note = {R package version 0.1-3},
  url = {https://CRAN.R-project.org/package=PKI},
}

@Manual{R6,
  title = {{R6}: Classes with Reference Semantics},
  author = {Winston Chang},
  year = {2016},
  note = {R package version 2.2.0},
  url = {https://CRAN.R-project.org/package=R6},
}

@Manual{RColorBrewer,
  title = {{RColorBrewer}: ColorBrewer Palettes},
  author = {Erich Neuwirth},
  year = {2014},
  note = {R package version 1.1-2},
  url = {https://CRAN.R-project.org/package=RColorBrewer},
}

@Manual{RCurl,
  title = {{RCurl}: General Network (HTTP/FTP/...) Client Interface for {R}},
  author = {Duncan Temple Lang and the CRAN team},
  year = {2016},
  note = {R package version 1.95-4.8},
  url = {https://CRAN.R-project.org/package=RCurl},
}

@Manual{RJSONIO,
  title = {{RJSONIO}: Serialize {R} objects to JSON, JavaScript Object Notation},
  author = {Duncan Temple Lang},
  year = {2014},
  note = {R package version 1.3-0},
  url = {https://CRAN.R-project.org/package=RJSONIO},
}

@Article{Rcpp,
  title = {{Rcpp}: Seamless {{R}} and {C++} Integration},
  author = {Dirk Eddelbuettel and Romain Fran\c{c}ois},
  journal = {Journal of Statistical Software},
  year = {2011},
  volume = {40},
  number = {8},
  pages = {1--18},
  url = {http://www.jstatsoft.org/v40/i08/},
}

@Book{Rcpp,
  title = {Seamless {R} and {C++} Integration with {Rcpp}},
  author = {Dirk Eddelbuettel},
  publisher = {Springer},
  address = {New York},
  year = {2013},
  note = {ISBN 978-1-4614-6867-7},
}

@Manual{assertthat,
  title = {{assertthat}: Easy pre and post assertions.},
  author = {'Hadley Wickham'},
  year = {2013},
  note = {R package version 0.1},
  url = {https://CRAN.R-project.org/package=assertthat},
}

@Manual{backports,
  title = {{backports}: Reimplementations of Functions Introduced Since {R}-3.0.0},
  author = {Michel Lang},
  year = {2017},
  note = {R package version 1.0.5},
  url = {https://CRAN.R-project.org/package=backports},
}

@Manual{base64enc,
  title = {{base64enc}: Tools for base64 encoding},
  author = {Simon Urbanek},
  year = {2015},
  note = {R package version 0.1-3},
  url = {https://CRAN.R-project.org/package=base64enc},
}

@Manual{bitops,
  title = {{bitops}: Bitwise Operations},
  author = {S original by Steve Dutky initial R port and extensions by Martin Maechler; revised and modified by Steve Dutky},
  year = {2013},
  note = {R package version 1.0-6},
  url = {https://CRAN.R-project.org/package=bitops},
}

@Manual{caTools,
  title = {{caTools}: Tools: moving window statistics, GIF, Base64, ROC AUC, etc.},
  author = {Jarek Tuszynski},
  year = {2014},
  note = {R package version 1.17.1},
  url = {https://CRAN.R-project.org/package=caTools},
}

@Manual{cellranger,
  title = {{cellranger}: Translate Spreadsheet Cell Ranges to Rows and Columns},
  author = {Jennifer Bryan},
  year = {2016},
  note = {R package version 1.1.0},
  url = {https://CRAN.R-project.org/package=cellranger},
}

@Manual{codetools,
  title = {{codetools}: Code Analysis Tools for {R}},
  author = {Luke Tierney},
  year = {2016},
  note = {R package version 0.2-15},
  url = {https://CRAN.R-project.org/package=codetools},
}

@Manual{colorspace,
  title = {{colorspace}: Color Space Manipulation},
  author = {Ross Ihaka and Paul Murrell and Kurt Hornik and Jason C. Fisher and Achim Zeileis},
  year = {2016},
  note = {R package version 1.3-1},
  url = {https://CRAN.R-project.org/package=colorspace},
}

@Article{colorspace,
  title = {Escaping {RGB}land: Selecting Colors for Statistical Graphics},
  author = {Achim Zeileis and Kurt Hornik and Paul Murrell},
  journal = {Computational Statistics \& Data Analysis},
  year = {2009},
  volume = {53},
  number = {9},
  pages = {3259--3270},
  doi = {10.1016/j.csda.2008.11.033},
}

@Article{colorspace,
  title = {Somewhere over the Rainbow: How to Make Effective Use of Colors in Meteorological Visualizations},
  author = {Reto Stauffer and Georg J. Mayr and Markus Dabernig and Achim Zeileis},
  journal = {Bulletin of the American Meteorological Society},
  year = {2009},
  volume = {96},
  number = {2},
  pages = {203--216},
  doi = {10.1175/BAMS-D-13-00155.1},
}

@Manual{commonmark,
  title = {{commonmark}: High Performance CommonMark and Github Markdown Rendering in {R}},
  author = {Jeroen Ooms},
  year = {2017},
  note = {R package version 1.2},
  url = {https://CRAN.R-project.org/package=commonmark},
}

@Manual{curl,
  title = {{curl}: A Modern and Flexible Web Client for {R}},
  author = {Jeroen Ooms},
  year = {2017},
  note = {R package version 2.6},
  url = {https://CRAN.R-project.org/package=curl},
}

@Manual{devtools,
  title = {{devtools}: Tools to Make Developing {R} Packages Easier},
  author = {Hadley Wickham and Winston Chang},
  year = {2017},
  note = {R package version 1.13.0},
  url = {https://CRAN.R-project.org/package=devtools},
}

@Manual{dichromat,
  title = {{dichromat}: Color Schemes for Dichromats},
  author = {Thomas Lumley},
  year = {2013},
  note = {R package version 2.0-0},
  url = {https://CRAN.R-project.org/package=dichromat},
}

@Manual{digest,
  title = {{digest}: Create Compact Hash Digests of {R} Objects},
  author = {Dirk Eddelbuettel with contributions by Antoine Lucas and Jarek Tuszynski and Henrik Bengtsson and Simon Urbanek and Mario Frasca and Bryan Lewis and Murray Stokely and Hannes Muehleisen and Duncan Murdoch and Jim Hester and Wush Wu and Qiang Kou and Thierry Onkelinx and Michel Lang and Viliam Simko.},
  year = {2017},
  note = {R package version 0.6.12},
  url = {https://CRAN.R-project.org/package=digest},
}

@Manual{dplyr,
  title = {{dplyr}: A Grammar of Data Manipulation},
  author = {Hadley Wickham and Romain Francois},
  year = {2016},
  note = {R package version 0.5.0},
  url = {https://CRAN.R-project.org/package=dplyr},
}

@Manual{evaluate,
  title = {{evaluate}: Parsing and Evaluation Tools that Provide More Details than the
Default},
  author = {Hadley Wickham},
  year = {2016},
  note = {R package version 0.10},
  url = {https://CRAN.R-project.org/package=evaluate},
}

@Manual{expm,
  title = {{expm}: Matrix Exponential, Log, 'etc'},
  author = {Vincent Goulet and Christophe Dutang and Martin Maechler and David Firth and Marina Shapira and Michael Stadelmann},
  year = {2017},
  note = {R package version 0.999-2},
  url = {https://CRAN.R-project.org/package=expm},
}

@Manual{foreign,
  title = {{foreign}: Read Data Stored by Minitab, S, SAS, SPSS, Stata, Systat, Weka,
dBase, ...},
  author = {{R Core Team}},
  year = {2016},
  note = {R package version 0.8-67},
  url = {https://CRAN.R-project.org/package=foreign},
}

@Manual{formatR,
  title = {{formatR}: Format {R} Code Automatically},
  author = {Yihui Xie},
  year = {2016},
  note = {R package version 1.4},
  url = {https://CRAN.R-project.org/package=formatR},
}

@Manual{formr,
  title = {{formr}: formr survey framework},
  author = {Ruben Arslan},
  year = {2014},
  note = {R package version 0.6.11},
}

@Book{ggplot2,
  author = {Hadley Wickham},
  title = {{ggplot2}: Elegant Graphics for Data Analysis},
  publisher = {Springer-Verlag New York},
  year = {2009},
  isbn = {978-0-387-98140-6},
  url = {http://ggplot2.org},
  note = {version 2.2.0},
}

@Manual{git2r,
  author = {Stefan Widgren and {others}},
  title = {{git2r}: Provides Access to Git Repositories},
  year = {2016},
  note = {R package version 0.14.0},
  url = {https://CRAN.R-project.org/package=git2r},
}

@Manual{gridExtra,
  title = {{gridExtra}: Miscellaneous Functions for "Grid" Graphics},
  author = {Baptiste Auguie},
  year = {2016},
  note = {R package version 2.2.1},
  url = {https://CRAN.R-project.org/package=gridExtra},
}

@Manual{gtable,
  title = {{gtable}: Arrange 'Grobs' in Tables},
  author = {Hadley Wickham},
  year = {2016},
  note = {R package version 0.2.0},
  url = {https://CRAN.R-project.org/package=gtable},
}

@Manual{haven,
  title = {{haven}: Import and Export 'SPSS', 'Stata' and 'SAS' Files},
  author = {Hadley Wickham and Evan Miller},
  year = {2016},
  note = {R package version 1.0.0},
  url = {https://CRAN.R-project.org/package=haven},
}

@Manual{highr,
  title = {{highr}: Syntax Highlighting for {R} Source Code},
  author = {Yixuan Qiu and Yihui Xie},
  year = {2016},
  note = {R package version 0.6},
  url = {https://CRAN.R-project.org/package=highr},
}

@Manual{hms,
  title = {{hms}: Pretty Time of Day},
  author = {Kirill Müller},
  year = {2016},
  note = {R package version 0.3},
  url = {https://CRAN.R-project.org/package=hms},
}

@Manual{htmltools,
  title = {{htmltools}: Tools for HTML},
  author = {{RStudio} and {Inc.}},
  year = {2017},
  note = {R package version 0.3.6},
  url = {https://CRAN.R-project.org/package=htmltools},
}

@Manual{htmlwidgets,
  title = {{htmlwidgets}: HTML Widgets for {R}},
  author = {Ramnath Vaidyanathan and Yihui Xie and JJ Allaire and Joe Cheng and Kenton Russell},
  year = {2016},
  note = {R package version 0.8},
  url = {https://CRAN.R-project.org/package=htmlwidgets},
}

@Manual{httr,
  title = {{httr}: Tools for Working with URLs and HTTP},
  author = {Hadley Wickham},
  year = {2016},
  note = {R package version 1.2.1},
  url = {https://CRAN.R-project.org/package=httr},
}

@Article{jsonlite,
  title = {The jsonlite Package: A Practical and Consistent Mapping Between JSON Data and {R} Objects},
  author = {Jeroen Ooms},
  journal = {arXiv:1403.2805 [stat.CO]},
  year = {2014},
  url = {https://arxiv.org/abs/1403.2805},
  note = {version 1.1},
}

@Manual{knitr,
  title = {{knitr}: A General-Purpose Package for Dynamic Report Generation in {R}},
  author = {Yihui Xie},
  year = {2016},
  note = {R package version 1.15.1},
  url = {http://yihui.name/knitr/},
}

@Book{knitr,
  title = {Dynamic Documents with {R} and knitr},
  author = {Yihui Xie},
  publisher = {Chapman and Hall/CRC},
  address = {Boca Raton, Florida},
  year = {2015},
  edition = {2nd},
  note = {ISBN 978-1498716963},
  url = {http://yihui.name/knitr/},
}

@InCollection{knitr,
  booktitle = {Implementing Reproducible Computational Research},
  editor = {Victoria Stodden and Friedrich Leisch and Roger D. Peng},
  title = {knitr: A Comprehensive Tool for Reproducible Research in {R}},
  author = {Yihui Xie},
  publisher = {Chapman and Hall/CRC},
  year = {2014},
  note = {ISBN 978-1466561595},
  url = {http://www.crcpress.com/product/isbn/9781466561595},
}

@Manual{labeling,
  title = {{labeling}: Axis Labeling},
  author = {Justin Talbot},
  year = {2014},
  note = {R package version 0.3},
  url = {https://CRAN.R-project.org/package=labeling},
}

@Manual{lazyeval,
  title = {{lazyeval}: Lazy (Non-Standard) Evaluation},
  author = {Hadley Wickham},
  year = {2016},
  note = {R package version 0.2.0},
  url = {https://CRAN.R-project.org/package=lazyeval},
}

@Manual{likert,
  title = {{likert}: Analysis and Visualization Likert Items},
  author = {Jason Bryer and Kimberly Speerschneider},
  year = {2016},
  note = {R package version 1.3.5},
  url = {https://CRAN.R-project.org/package=likert},
}

@Article{lubridate,
  title = {Dates and Times Made Easy with {lubridate}},
  author = {Garrett Grolemund and Hadley Wickham},
  journal = {Journal of Statistical Software},
  year = {2011},
  volume = {40},
  number = {3},
  pages = {1--25},
  url = {http://www.jstatsoft.org/v40/i03/},
  note = {version 1.6.0},
}

@Manual{magrittr,
  title = {{magrittr}: A Forward-Pipe Operator for {R}},
  author = {Stefan Milton Bache and Hadley Wickham},
  year = {2014},
  note = {R package version 1.5},
  url = {https://CRAN.R-project.org/package=magrittr},
}

@Manual{markdown,
  title = {{markdown}: 'Markdown' Rendering for {R}},
  author = {JJ Allaire and Jeffrey Horner and Vicent Marti and Natacha Porte},
  year = {2015},
  note = {R package version 0.7.7},
  url = {https://CRAN.R-project.org/package=markdown},
}

@Manual{memoise,
  title = {{memoise}: Memoisation of Functions},
  author = {Hadley Wickham and Jim Hester and Kirill Müller and Daniel Cook},
  year = {2017},
  note = {R package version 1.1.0},
  url = {https://CRAN.R-project.org/package=memoise},
}

@Manual{mime,
  title = {{mime}: Map Filenames to MIME Types},
  author = {Yihui Xie},
  year = {2016},
  note = {R package version 0.5},
  url = {https://CRAN.R-project.org/package=mime},
}

@Manual{mnormt,
  title = {The {{R}} package \texttt{mnormt}: The multivariate normal and $t$ distributions (version 1.5-5)},
  author = {Adelchi Azzalini and Alan Genz},
  year = {2016},
  url = {http://azzalini.stat.unipd.it/SW/Pkg-mnormt},
  note = {version 1.5-5},
}

@Article{msm,
  title = {Multi-State Models for Panel Data: The {msm} Package for {{R}}},
  author = {Christopher H. Jackson},
  journal = {Journal of Statistical Software},
  year = {2011},
  volume = {38},
  number = {8},
  pages = {1--29},
  url = {http://www.jstatsoft.org/v38/i08/},
  note = {version 1.6.4},
}

@Manual{munsell,
  title = {{munsell}: Utilities for Using Munsell Colours},
  author = {Charlotte Wickham},
  year = {2016},
  note = {R package version 0.4.3},
  url = {https://CRAN.R-project.org/package=munsell},
}

@Manual{mvtnorm,
  title = {{mvtnorm}: Multivariate Normal and t Distributions},
  author = {Alan Genz and Frank Bretz and Tetsuhisa Miwa and Xuefei Mi and Friedrich Leisch and Fabian Scheipl and Torsten Hothorn},
  year = {2017},
  note = {R package version 1.0-6},
  url = {https://CRAN.R-project.org/package=mvtnorm},
}

@Book{mvtnorm,
  title = {Computation of Multivariate Normal and t Probabilities},
  author = {Alan Genz and Frank Bretz},
  series = {Lecture Notes in Statistics},
  year = {2009},
  publisher = {Springer-Verlag},
  address = {Heidelberg},
  isbn = {978-3-642-01688-2},
}

@Manual{openssl,
  title = {{openssl}: Toolkit for Encryption, Signatures and Certificates Based on
OpenSSL},
  author = {Jeroen Ooms},
  year = {2016},
  note = {R package version 0.9.5},
  url = {https://CRAN.R-project.org/package=openssl},
}

@Manual{openxlsx,
  title = {{openxlsx}: Read, Write and Edit XLSX Files},
  author = {Alexander Walker},
  year = {2015},
  note = {R package version 3.0.0},
  url = {https://CRAN.R-project.org/package=openxlsx},
}

@Manual{packrat,
  title = {{packrat}: A Dependency Management System for Projects and their {R} Package
Dependencies},
  author = {Kevin Ushey and Jonathan McPherson and Joe Cheng and Aron Atkins and JJ Allaire},
  year = {2016},
  note = {R package version 0.4.8-1},
  url = {https://CRAN.R-project.org/package=packrat},
}

@Manual{pander,
  title = {{pander}: An {R} Pandoc Writer},
  author = {Gergely Daróczi and Roman Tsegelskyi},
  year = {2015},
  note = {R package version 0.6.0},
  url = {https://CRAN.R-project.org/package=pander},
}

@Article{plyr,
  title = {The Split-Apply-Combine Strategy for Data Analysis},
  author = {Hadley Wickham},
  journal = {Journal of Statistical Software},
  year = {2011},
  volume = {40},
  number = {1},
  pages = {1--29},
  url = {http://www.jstatsoft.org/v40/i01/},
  note = {version 1.8.4},
}

@Manual{pryr,
  title = {{pryr}: Tools for Computing on the Language},
  author = {Hadley Wickham},
  year = {2015},
  note = {R package version 0.1.2},
  url = {https://CRAN.R-project.org/package=pryr},
}

@Manual{psych,
  title = {{psych}: Procedures for Psychological, Psychometric, and Personality Research},
  author = {William Revelle},
  organization = { Northwestern University},
  address = { Evanston, Illinois},
  year = {2017},
  note = {R package version 1.7.3},
  url = {https://CRAN.R-project.org/package=psych},
}

@Manual{readr,
  title = {{readr}: Read Tabular Data},
  author = {Hadley Wickham and Jim Hester and Romain Francois},
  year = {2016},
  note = {R package version 1.0.0},
  url = {https://CRAN.R-project.org/package=readr},
}

@Manual{readxl,
  title = {{readxl}: Read Excel Files},
  author = {Hadley Wickham and Jennifer Bryan},
  year = {2017},
  note = {R package version 1.0.0},
  url = {https://CRAN.R-project.org/package=readxl},
}

@Manual{rematch,
  title = {{rematch}: Match Regular Expressions with a Nicer 'API'},
  author = {Gabor Csardi},
  year = {2016},
  note = {R package version 1.0.1},
  url = {https://CRAN.R-project.org/package=rematch},
}

@Article{reshape2,
  title = {Reshaping Data with the {reshape} Package},
  author = {Hadley Wickham},
  journal = {Journal of Statistical Software},
  year = {2007},
  volume = {21},
  number = {12},
  pages = {1--20},
  url = {http://www.jstatsoft.org/v21/i12/},
  note = {version 1.4.2},
}

@Manual{rmarkdown,
  title = {{rmarkdown}: Dynamic Documents for {R}},
  author = {JJ Allaire and Joe Cheng and Yihui Xie and Jonathan McPherson and Winston Chang and Jeff Allen and Hadley Wickham and Aron Atkins and Rob Hyndman and Ruben Arslan},
  year = {2017},
  note = {R package version 1.5},
  url = {https://CRAN.R-project.org/package=rmarkdown},
}

@Manual{rprojroot,
  title = {{rprojroot}: Finding Files in Project Subdirectories},
  author = {Kirill Müller},
  year = {2017},
  note = {R package version 1.2},
  url = {https://CRAN.R-project.org/package=rprojroot},
}

@Manual{rsconnect,
  title = {{rsconnect}: Deployment Interface for {R} Markdown Documents and Shiny Applications},
  author = {JJ Allaire},
  year = {2016},
  note = {R package version 0.5.0-2},
}

@Manual{rstudioapi,
  title = {{rstudioapi}: Safely Access the RStudio API},
  author = {Hadley Wickham and JJ Allaire},
  year = {2016},
  note = {R package version 0.6},
  url = {https://CRAN.R-project.org/package=rstudioapi},
}

@Manual{scales,
  title = {{scales}: Scale Functions for Visualization},
  author = {Hadley Wickham},
  year = {2016},
  note = {R package version 0.4.1},
  url = {https://CRAN.R-project.org/package=scales},
}

@Manual{stringi,
  title = {{R} package stringi: Character string processing facilities},
  author = {Marek Gagolewski},
  year = {2017},
  url = {http://www.gagolewski.com/software/stringi/},
  note = {version 1.1.2},
}

@Manual{stringr,
  title = {{stringr}: Simple, Consistent Wrappers for Common String Operations},
  author = {Hadley Wickham},
  year = {2017},
  note = {R package version 1.2.0},
  url = {https://CRAN.R-project.org/package=stringr},
}

@Manual{tibble,
  title = {{tibble}: Simple Data Frames},
  author = {Hadley Wickham and Romain Francois and Kirill Müller},
  year = {2017},
  note = {R package version 1.3.0},
  url = {https://CRAN.R-project.org/package=tibble},
}

@Manual{tidyr,
  title = {{tidyr}: Easily Tidy Data with 'spread()' and 'gather()' Functions},
  author = {Hadley Wickham},
  year = {2017},
  note = {R package version 0.6.2},
  url = {https://CRAN.R-project.org/package=tidyr},
}

@Manual{whisker,
  title = {{whisker}: {{mustache}} for {R}, logicless templating},
  author = {Edwin {de Jonge}},
  year = {2013},
  note = {R package version 0.3-2},
  url = {https://CRAN.R-project.org/package=whisker},
}

@Manual{withr,
  title = {{withr}: Run Code 'With' Temporarily Modified Global State},
  author = {Jim Hester and Kirill Müller and Hadley Wickham and Winston Chang},
  year = {2016},
  note = {R package version 1.0.2},
  url = {https://CRAN.R-project.org/package=withr},
}

@Manual{xtable,
  title = {{xtable}: Export Tables to LaTeX or HTML},
  author = {David B. Dahl},
  year = {2016},
  note = {R package version 1.8-2},
  url = {https://CRAN.R-project.org/package=xtable},
}

@Manual{yaml,
  title = {{yaml}: Methods to Convert {R} Data to YAML and Back},
  author = {Jeremy Stephens},
  year = {2016},
  note = {R package version 2.1.14},
  url = {https://CRAN.R-project.org/package=yaml},
}

extension: bibtex


text:
DESCRIPTION = "TI SRIO peripheral low level driver"

DEPENDS="common-csl-ip rm-lld cppi-lld"

include srio-lld.inc

PR = "${INC_PR}.0"

do_compile () {
#   Now build the lld
	oe_runmake clean
	for device in ${DEVICELIST}
	do
		oe_runmake lib DEVICE="${device}"
	done
}

do_install () {
	oe_runmake install INSTALL_INC_BASE_DIR=${D}${includedir} INSTALL_LIB_BASE_DIR=${D}${libdir}
}

repository: joelagnel/meta-ti

repo_name: joelagnel/meta-ti