text:
@article{liu_2012,
title = {Bis-{SNP}: combined {DNA} methylation and {SNP} calling for Bisulfite-seq data.},
author = {Liu, Yaping and Siegmund, Kimberly D and Laird, Peter W and Berman, Benjamin P},
pages = {R61},
url = {http://dx.doi.org/10.1186/gb-2012-13-7-r61},
year = {2012},
month = {jul},
day = {11},
urldate = {2017-06-12},
journal = {Genome Biol},
volume = {13},
number = {7},
doi = {10.1186/gb-2012-13-7-r61},
pmid = {22784381},
pmcid = {PMC3491382},
keywords = {mytoppapers},
f1000-projects = {{ERC}-{CoG} and {GDC} and {ISF}-personal-2018 and my-top-papers and U24},
abstract = {Bisulfite treatment of {DNA} followed by high-throughput sequencing (Bisulfite-seq) is an important method for studying {DNA} methylation and epigenetic gene regulation, yet current software tools do not adequately address single nucleotide polymorphisms ({SNPs}). Identifying {SNPs} is important for accurate quantification of methylation levels and for identification of allele-specific epigenetic events such as imprinting. We have developed a model-based bisulfite {SNP} caller, Bis-{SNP}, that results in substantially better {SNP} calls than existing methods, thereby improving methylation estimates. At an average 30× genomic coverage, Bis-{SNP} correctly identified 96\% of {SNPs} using the default high-stringency settings. The open-source package is available at http://epigenome.usc.edu/publicationdata/bissnp2011.}
}
@article{kelly_2012,
title = {Genome-wide mapping of nucleosome positioning and {DNA} methylation within individual {DNA} molecules.},
author = {Kelly, Theresa K and Liu, Yaping and Lay, Fides D and Liang, Gangning and Berman, Benjamin P and Jones, Peter A},
pages = {2497-2506},
url = {http://dx.doi.org/10.1101/gr.143008.112},
year = {2012},
month = {dec},
day = {1},
urldate = {2017-06-12},
journal = {Genome Res},
volume = {22},
number = {12},
doi = {10.1101/gr.143008.112},
pmid = {22960375},
pmcid = {PMC3514679},
keywords = {mytoppapers},
f1000-projects = {{ERC}-{CoG} and {ISF}-personal-2018 and my-top-papers and U24},
abstract = {{DNA} methylation and nucleosome positioning work together to generate chromatin structures that regulate gene expression. Nucleosomes are typically mapped using nuclease digestion requiring significant amounts of material and varying enzyme concentrations. We have developed a method ({NOMe}-seq) that uses a {GpC} methyltransferase (M.{CviPI}) and next generation sequencing to generate a high resolution footprint of nucleosome positioning genome-wide using less than 1 million cells while retaining endogenous {DNA} methylation information from the same {DNA} strand. Using a novel bioinformatics pipeline, we show a striking anti-correlation between nucleosome occupancy and {DNA} methylation at {CTCF} regions that is not present at promoters. We further show that the extent of nucleosome depletion at promoters is directly correlated to expression level and can accommodate multiple nucleosomes and provide genome-wide evidence that expressed non-{CpG} island promoters are nucleosome-depleted. Importantly, {NOMe}-seq obtains {DNA} methylation and nucleosome positioning information from the same {DNA} molecule, giving the first genome-wide {DNA} methylation and nucleosome positioning correlation at the single molecule, and thus, single cell level, that can be used to monitor disease progression and response to therapy.}
}
@article{yao_2015,
title = {Inferring regulatory element landscapes and transcription factor networks from cancer methylomes.},
author = {Yao, Lijing and Shen, Hui and Laird, Peter W and Farnham, Peggy J and Berman, Benjamin P},
pages = {105},
url = {http://dx.doi.org/10.1186/s13059-015-0668-3},
year = {2015},
month = {may},
day = {21},
urldate = {2017-04-19},
journal = {Genome Biol},
volume = {16},
doi = {10.1186/s13059-015-0668-3},
pmid = {25994056},
pmcid = {PMC4460959},
keywords = {mytoppapers},
f1000-projects = {{ERC}-{CoG} and {ISF}-personal-2018 and my-top-papers and test and U24},
abstract = {Recent studies indicate that {DNA} methylation can be used to identify transcriptional enhancers, but no systematic approach has been developed for genome-wide identification and analysis of enhancers based on {DNA} methylation. We describe {ELMER} (Enhancer Linking by Methylation/Expression Relationships), an R-based tool that uses {DNA} methylation to identify enhancers and correlates enhancer state with expression of nearby genes to identify transcriptional targets. Transcription factor motif analysis of enhancers is coupled with expression analysis of transcription factors to infer upstream regulators. Using {ELMER}, we investigated more than 2,000 tumor samples from The Cancer Genome Atlas. We identified networks regulated by known cancer drivers such as {GATA3} and {FOXA1} (breast cancer), {SOX17} and {FOXA2} (endometrial cancer), and {NFE2L2}, {SOX2}, and {TP63} (squamous cell lung cancer). We also identified novel networks with prognostic associations, including {RUNX1} in kidney cancer. We propose {ELMER} as a powerful new paradigm for understanding the cis-regulatory interface between cancer-associated transcription factors and their functional target genes.}
}
@article{berman_2012,
title = {Regions of focal {DNA} hypermethylation and long-range hypomethylation in colorectal cancer coincide with nuclear lamina-associated domains.},
author = {Berman, Benjamin P and Weisenberger, Daniel J and Aman, Joseph F and Hinoue, Toshinori and Ramjan, Zachary and Liu, Yaping and Noushmehr, Houtan and Lange, Christopher P E and van Dijk, Cornelis M and Tollenaar, Rob A E M and Van Den Berg, David and Laird, Peter W},
pages = {40-46},
url = {http://dx.doi.org/10.1038/ng.969},
year = {2012},
month = {jan},
urldate = {2017-02-20},
journal = {Nat Genet},
volume = {44},
number = {1},
doi = {10.1038/ng.969},
pmid = {22120008},
pmcid = {PMC4309644},
keywords = {mytoppapers},
f1000-projects = {{ERC}-{CoG} and {ISF}-personal-2018 and my-top-papers and U24},
abstract = {Extensive changes in {DNA} methylation are common in cancer and may contribute to oncogenesis through transcriptional silencing of tumor-suppressor genes. Genome-scale studies have yielded important insights into these changes but have focused on {CpG} islands or gene promoters. We used whole-genome bisulfite sequencing (bisulfite-seq) to comprehensively profile a primary human colorectal tumor and adjacent normal colon tissue at single-basepair resolution. Regions of focal hypermethylation in the tumor were located primarily at {CpG} islands and were concentrated within regions of long-range (\textgreater100 kb) hypomethylation. These hypomethylated domains covered nearly half of the genome and coincided with late replication and attachment to the nuclear lamina in human cell lines. We confirmed the confluence of hypermethylation and hypomethylation within these domains in 25 diverse colorectal tumors and matched adjacent tissue. We propose that widespread {DNA} methylation changes in cancer are linked to silencing programs orchestrated by the three-dimensional organization of chromatin within the nucleus.}
}
@article{lay_2015,
title = {The role of {DNA} methylation in directing the functional organization of the cancer epigenome.},
author = {Lay, Fides D and Liu, Yaping and Kelly, Theresa K and Witt, Heather and Farnham, Peggy J and Jones, Peter A and Berman, Benjamin P},
pages = {467-477},
url = {http://dx.doi.org/10.1101/gr.183368.114},
year = {2015},
month = {apr},
urldate = {2018-10-31},
journal = {Genome Res},
volume = {25},
number = {4},
doi = {10.1101/gr.183368.114},
pmid = {25747664},
pmcid = {PMC4381519},
keywords = {mytoppapers},
f1000-projects = {{ERC}-{CoG} and {ISF}-personal-2018 and my-top-papers},
abstract = {The holistic role of {DNA} methylation in the organization of the cancer epigenome is not well understood. Here we perform a comprehensive, high-resolution analysis of chromatin structure to compare the landscapes of {HCT116} colon cancer cells and a {DNA} methylation-deficient derivative. The {NOMe}-seq accessibility assay unexpectedly revealed symmetrical and transcription-independent nucleosomal phasing across active, poised, and inactive genomic elements. {DNA} methylation abolished this phasing primarily at enhancers and {CpG} island ({CGI}) promoters, with little effect on insulators and non-{CGI} promoters. Abolishment of {DNA} methylation led to the context-specific reestablishment of the poised and active states of normal colon cells, which were marked in methylation-deficient cells by distinct {H3K27} modifications and the presence of either well-phased nucleosomes or nucleosome-depleted regions, respectively. At higher-order genomic scales, we found that long, {H3K9me3}-marked domains had lower accessibility, consistent with a more compact chromatin structure. Taken together, our results demonstrate the nuanced and context-dependent role of {DNA} methylation in the functional, multiscale organization of cancer epigenomes. \copyright 2015 Lay et al.; Published by Cold Spring Harbor Laboratory Press.}
}
@article{hao_2016,
title = {Spatial intratumoral heterogeneity and temporal clonal evolution in esophageal squamous cell carcinoma.},
author = {Hao, Jia-Jie and Lin, De-Chen and Dinh, Huy Q and Mayakonda, Anand and Jiang, Yan-Yi and Chang, Chen and Jiang, Ye and Lu, Chen-Chen and Shi, Zhi-Zhou and Xu, Xin and Zhang, Yu and Cai, Yan and Wang, Jin-Wu and Zhan, Qi-Min and Wei, Wen-Qiang and Berman, Benjamin P and Wang, Ming-Rong and Koeffler, H Phillip},
pages = {1500-1507},
url = {http://dx.doi.org/10.1038/ng.3683},
year = {2016},
month = {oct},
day = {17},
urldate = {2018-10-31},
journal = {Nat Genet},
volume = {48},
number = {12},
doi = {10.1038/ng.3683},
pmid = {27749841},
pmcid = {PMC5127772},
keywords = {mytoppapers},
f1000-projects = {{ERC}-{CoG} and {ISF}-personal-2018 and my-top-papers},
abstract = {Esophageal squamous cell carcinoma ({ESCC}) is among the most common malignancies, but little is known about its spatial intratumoral heterogeneity ({ITH}) and temporal clonal evolutionary processes. To address this, we performed multiregion whole-exome sequencing on 51 tumor regions from 13 {ESCC} cases and multiregion global methylation profiling for 3 of these 13 cases. We found an average of 35.8\% heterogeneous somatic mutations with strong evidence of {ITH}. Half of the driver mutations located on the branches of tumor phylogenetic trees targeted oncogenes, including {PIK3CA}, {NFE2L2} and {MTOR}, among others. By contrast, the majority of truncal and clonal driver mutations occurred in tumor-suppressor genes, including {TP53}, {KMT2D} and {ZNF750}, among others. Interestingly, phyloepigenetic trees robustly recapitulated the topological structures of the phylogenetic trees, indicating a possible relationship between genetic and epigenetic alterations. Our integrated investigations of spatial {ITH} and clonal evolution provide an important molecular foundation for enhanced understanding of tumorigenesis and progression in {ESCC}.}
}
@article{zhou_2018,
title = {{DNA} methylation loss in late-replicating domains is linked to mitotic cell division.},
author = {Zhou, Wanding and Dinh, Huy Q and Ramjan, Zachary and Weisenberger, Daniel J and Nicolet, Charles M and Shen, Hui and Laird, Peter W and Berman, Benjamin P},
pages = {591-602},
url = {http://www.nature.com/articles/s41588-018-0073-4},
year = {2018},
month = {apr},
day = {2},
urldate = {2018-04-10},
journal = {Nat Genet},
volume = {50},
number = {4},
issn = {1061-4036},
doi = {10.1038/s41588-018-0073-4},
pmid = {29610480},
pmcid = {PMC5893360},
keywords = {mytoppapers},
f1000-projects = {{ERC}-{CoG} and {GDC} and {ISF}-personal-2018 and my-top-papers},
abstract = {{DNA} methylation loss occurs frequently in cancer genomes, primarily within lamina-associated, late-replicating regions termed partially methylated domains ({PMDs}). We profiled 39 diverse primary tumors and 8 matched adjacent tissues using whole-genome bisulfite sequencing ({WGBS}) and analyzed them alongside 343 additional human and 206 mouse {WGBS} datasets. We identified a local {CpG} sequence context associated with preferential hypomethylation in {PMDs}. Analysis of {CpGs} in this context ('solo-{WCGWs}') identified previously undetected {PMD} hypomethylation in almost all healthy tissue types. {PMD} hypomethylation increased with age, beginning during fetal development, and appeared to track the accumulation of cell divisions. In cancer, {PMD} hypomethylation depth correlated with somatic mutation density and cell cycle gene expression, consistent with its reflection of mitotic history and suggesting its application as a mitotic clock. We propose that late replication leads to lifelong progressive methylation loss, which acts as a biomarker for cellular aging and which may contribute to oncogenesis.}
}
@article{silva_2018,
title = {{ELMER} v.2: An R/Bioconductor package to reconstruct gene regulatory networks from {DNA} methylation and transcriptome profiles.},
author = {Silva, Tiago C and Coetzee, Simon G and Gull, Nicole and Yao, Lijing and Hazelett, Dennis J and Noushmehr, Houtan and Lin, De-Chen and Berman, Benjamin P},
url = {https://academic.oup.com/bioinformatics/advance-article/doi/10.1093/bioinformatics/bty902/5145133},
year = {2019},
month = {jun},
day = {1},
urldate = {2019-06-01},
journal = {Bioinformatics},
issn = {1367-4803},
doi = {10.1093/bioinformatics/bty902},
pmid = {30364927},
keywords = {mytoppapers},
f1000-projects = {{ERC}-{CoG} and {ISF}-personal-2018 and my-top-papers},
abstract = {Motivation: {DNA} methylation has been used to identify functional changes at transcriptional enhancers and other cisregulatory modules ({CRMs}) in tumors and other disease tissues. Our R/Bioconductor package {ELMER} (Enhancer Linking by Methylation/Expression Relationships) provides a systematic approach that reconstructs altered gene regulatory networks ({GRNs}) by combining enhancer methylation and gene expression data derived from the same sample set. Results: We present a completely revised version 2 of {ELMER} that provides numerous new features including an optional web-based interface and a new Supervised Analysis mode to use pre-defined sample groupings. We show that Supervised mode significantly increases statistical power and identifies additional {GRNs} and associated Master Regulators, such as {SOX11} and {KLF5} in Basal-like breast cancer. Availability: {ELMER} v.2 is available as an R/Bioconductor package at http://bioconductor.org/packages/{ELMER}/.}
}
@article{lin_2017,
title = {Genomic and epigenomic heterogeneity of hepatocellular carcinoma.},
author = {Lin, De-Chen and Mayakonda, Anand and Dinh, Huy Q and Huang, Pinbo and Lin, Lehang and Liu, Xiaoping and Ding, Ling-Wen and Wang, Jie and Berman, Benjamin P and Song, Er-Wei and Yin, Dong and Koeffler, H Phillip},
pages = {2255-2265},
url = {http://dx.doi.org/10.1158/0008-5472.{CAN}-16-2822},
year = {2017},
month = {may},
day = {1},
urldate = {2018-10-31},
journal = {Cancer Res},
volume = {77},
number = {9},
doi = {10.1158/0008-5472.{CAN}-16-2822},
pmid = {28302680},
pmcid = {PMC5413372},
keywords = {mytoppapers},
f1000-projects = {{ERC}-{CoG} and {ISF}-personal-2018 and my-top-papers},
abstract = {Understanding the intratumoral heterogeneity of hepatocellular carcinoma is instructive for developing personalized therapy and identifying molecular biomarkers. Here we applied whole-exome sequencing to 69 samples from 11 patients to resolve the genetic architecture of subclonal diversification. Spatial genomic diversity was found in all 11 hepatocellular carcinoma cases, with 29\% of driver mutations being heterogeneous, including {TERT}, {ARID1A}, {NOTCH2}, and {STAG2}. Similar with other cancer types, {TP53} mutations were always shared between all tumor regions, that is, located on the "trunk" of the evolutionary tree. In addition, we found that variants within several drug targets such as {KIT}, {SYK}, and {PIK3CA} were mutated in a fully clonal manner, indicating their therapeutic potentials for hepatocellular carcinoma. Temporal dissection of mutational signatures suggested that mutagenic processes associated with exposure to aristolochic acid and aflatoxin might play a more important role in early, as opposed to late, stages of hepatocellular carcinoma development. Moreover, we observed extensive intratumoral epigenetic heterogeneity in hepatocellular carcinoma based on multiple independent analytical methods and showed that intratumoral methylation heterogeneity might play important roles in the biology of hepatocellular carcinoma cells. Our results also demonstrated prominent heterogeneity of intratumoral methylation even in a stable hepatocellular carcinoma genome. Together, these findings highlight widespread intratumoral heterogeneity at both the genomic and epigenomic levels in hepatocellular carcinoma and provide an important molecular foundation for better understanding the pathogenesis of this malignancy. Cancer Res; 77(9); 2255-65. \copyright2017 {AACR}. \copyright2017 American Association for Cancer Research.}
}
@article{lin_2018,
title = {Identification of distinct mutational patterns and new driver genes in oesophageal squamous cell carcinomas and adenocarcinomas.},
author = {Lin, De-Chen and Dinh, Huy Q and Xie, Jian-Jun and Mayakonda, Anand and Silva, Tiago Chedraoui and Jiang, Yan-Yi and Ding, Ling-Wen and He, Jian-Zhong and Xu, Xiu-E and Hao, Jia-Jie and Wang, Ming-Rong and Li, Chunquan and Xu, Li-Yan and Li, En-Min and Berman, Benjamin P and Phillip Koeffler, H},
pages = {1769-1779},
url = {http://dx.doi.org/10.1136/gutjnl-2017-314607},
year = {2018},
urldate = {2018-10-31},
journal = {Gut},
volume = {67},
number = {10},
doi = {10.1136/gutjnl-2017-314607},
pmid = {28860350},
pmcid = {PMC5980794},
keywords = {mytoppapers},
f1000-projects = {{ERC}-{CoG} and {ISF}-personal-2018 and my-top-papers},
abstract = {{OBJECTIVES}: Oesophageal squamous cell carcinoma ({OSCC}) and adenocarcinoma ({OAC}) are distinct cancers in terms of a number of clinical and epidemiological characteristics, complicating the design of clinical trials and biomarker developments. We analysed 1048 oesophageal tumour-germline pairs from both subtypes, to characterise their genomic features, and biological and clinical significance. {DESIGN}: Previously exome-sequenced samples were re-analysed to identify significantly mutated genes ({SMGs}) and mutational signatures. The biological functions of novel {SMGs} were investigated using cell line and xenograft models. We further performed whole-genome bisulfite sequencing and chromatin immunoprecipitation ({ChIP})-seq to characterise epigenetic alterations. {RESULTS}: {OSCC} and {OAC} displayed nearly mutually exclusive sets of driver genes, indicating that they follow independent developmental paths. The combined sample size allowed the statistical identification of a number of novel subtype-specific {SMGs}, mutational signatures and prognostic biomarkers. Particularly, we identified a novel mutational signature similar to Catalogue Of Somatic Mutations In Cancer ({COSMIC})signature 16, which has prognostic value in {OSCC}. Two newly discovered {SMGs}, {CUL3} and {ZFP36L2}, were validated as important tumour-suppressors specific to the {OSCC} subtype. We further identified their additional loss-of-function mechanisms. {CUL3} was homozygously deleted specifically in {OSCC} and other squamous cell cancers ({SCCs}). Notably, {ZFP36L2} is associated with super-enhancer in healthy oesophageal mucosa; {DNA} hypermethylation in its super-enhancer reduced active histone markers in squamous cancer cells, suggesting an epigenetic inactivation of a super-enhancer-associated {SCC} suppressor. {CONCLUSIONS}: These data comprehensively contrast differences between {OSCC} and {OAC} at both genomic and epigenomic levels, and reveal novel molecular features for further delineating the pathophysiological mechanisms and treatment strategies for these cancers. \copyright Article author(s) (or their employer(s) unless otherwise stated in the text of the article) 2018. All rights reserved. No commercial use is permitted unless otherwise expressly granted.}
}
@article{juve_2012,
title = {An evaluation of the cost and performance of scientific workflows on amazon {EC2}},
author = {Juve, Gideon and Deelman, Ewa and Berriman, G. Bruce and Berman, Benjamin P. and Maechling, Philip},
pages = {5-21},
url = {http://link.springer.com/10.1007/s10723-012-9207-6},
year = {2012},
month = {mar},
urldate = {2018-11-01},
journal = {J Grid Computing},
volume = {10},
number = {1},
issn = {1570-7873},
doi = {10.1007/s10723-012-9207-6},
f1000-projects = {{ERC}-{CoG} and {ISF}-personal-2018 and my-top-papers}
}


text:
@misc{cdc,
  author = "cdc.gov",
  year = "2020",
  title = "Older Adults",
  url = "https://www.cdc.gov/coronavirus/2019-ncov/need-extra-precautions/older-adults.html",
  institution = "CDC"
}

@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 = {2019},
    url = {https://www.R-project.org/},
}

@book{Python,
  author = {Van Rossum, Guido and Drake, Fred L.},
  title = {Python 3 Reference Manual},
  year = {2009},
  isbn = {1441412697},
  publisher = {CreateSpace},
  address = {Scotts Valley, CA}
}

@InProceedings{ mckinney-proc-scipy-2010,
  author    = { Wes McKinney },
  title     = { Data Structures for Statistical Computing in Python },
  booktitle = { Proceedings of the 9th Python in Science Conference },
  pages     = { 51 - 56 },
  year      = { 2010 },
  editor    = { St\'efan van der Walt and Jarrod Millman }
}

@book{oliphant2006guide,
  title={A guide to NumPy},
  author={Oliphant, Travis E},
  volume={1},
  year={2006},
  publisher={Trelgol Publishing USA}
}

@article{walt2011numpy,
  title={The NumPy array: a structure for efficient numerical computation},
  author={Walt, St{\'e}fan van der and Colbert, S Chris and Varoquaux, Gael},
  journal={Computing in Science \& Engineering},
  volume={13},
  number={2},
  pages={22--30},
  year={2011},
  publisher={IEEE Computer Society}
}

@article{pedregosa2011scikit,
  title={Scikit-learn: Machine learning in Python},
  author={Pedregosa, Fabian and Varoquaux, Ga{\"e}l and Gramfort, Alexandre and Michel, Vincent and Thirion, Bertrand and Grisel, Olivier and Blondel, Mathieu and Prettenhofer, Peter and Weiss, Ron and Dubourg, Vincent and others},
  journal={Journal of machine learning research},
  volume={12},
  number={Oct},
  pages={2825--2830},
  year={2011}
}

@article{Altair2018,
  doi = {10.21105/joss.01057},
  url = {https://doi.org/10.21105/joss.01057},
  year  = {2018},
  month = {dec},
  publisher = {The Open Journal},
  author = {Jacob VanderPlas and Brian Granger and Jeffrey Heer and Dominik Moritz and Kanit Wongsuphasawat and Arvind Satyanarayan and Eitan Lees and Ilia Timofeev and Ben Welsh and Scott Sievert},
  title = {Altair: Interactive Statistical Visualizations for Python},
  journal = {Journal of Open Source Software}
}

@Manual{tidyverse,
    title = {tidyverse: Easily Install and Load the 'Tidyverse'},
    author = {Hadley Wickham},
    year = {2017},
    note = {R package version 1.2.1},
    url = {https://CRAN.R-project.org/package=tidyverse},
}

@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{cowplot,
  title = {cowplot: Streamlined Plot Theme and Plot Annotations for 'ggplot2'},
  author = {Claus O. Wilke},
  year = {2019},
  note = {R package version 1.0.0},
  url = {https://CRAN.R-project.org/package=cowplot},
}

@Manual{ggridges,
  title = {ggridges: Ridgeline Plots in 'ggplot2'},
  author = {Claus O. Wilke},
  year = {2018},
  note = {R package version 0.5.1},
  url = {https://CRAN.R-project.org/package=ggridges},
}

@Manual{docopt,
    title = {docopt: Command-Line Interface Specification Language},
    author = {Edwin {de Jonge}},
    year = {2018},
    note = {R package version 0.6.1},
    url = {https://CRAN.R-project.org/package=docopt},
}

@Article{Hunter,
  Author    = {Hunter, J. D.},
  Title     = {Matplotlib: A 2D graphics environment},
  Journal   = {Computing in Science \& Engineering},
  Volume    = {9},
  Number    = {3},
  Pages     = {90--95},
  abstract  = {Matplotlib is a 2D graphics package used for Python for
  application development, interactive scripting, and publication-quality
  image generation across user interfaces and operating systems.},
  publisher = {IEEE COMPUTER SOC},
  doi       = {10.1109/MCSE.2007.55},
  year      = 2007
}

@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},
}

@Article{mice,
    title = {{mice}: Multivariate Imputation by Chained Equations in R},
    author = {Stef {van Buuren} and Karin Groothuis-Oudshoorn},
    journal = {Journal of Statistical Software},
    year = {2011},
    volume = {45},
    number = {3},
    pages = {1-67},
    url = {https://www.jstatsoft.org/v45/i03/},
}

@Manual{resample,
    title = {resample: Resampling Functions},
    author = {Tim Hesterberg},
    year = {2015},
    note = {R package version 0.4},
    url = {https://CRAN.R-project.org/package=resample},
}

@Article{testthat,
    author = {Hadley Wickham},
    title = {testthat: Get Started with Testing},
    journal = {The R Journal},
    year = {2011},
    volume = {3},
    pages = {5--10},
    url = {https://journal.r-project.org/archive/2011-1/RJournal_2011-1_Wickham.pdf},
}

@Manual{rjson,
  title = {rjson: JSON for R},
  author = {Alex Couture-Beil},
  year = {2018},
  note = {R package version 0.2.20},
  url = {https://CRAN.R-project.org/package=rjson},
}

@Manual{repr,
  title = {repr: Serializable Representations},
  author = {Philipp Angerer and Thomas Kluyver and Jan Schulz},
  year = {2019},
  note = {R package version 1.0.1},
  url = {https://CRAN.R-project.org/package=repr},
}

@book{chandra2015python,
  title={Python requests essentials},
  author={Chandra, Rakesh Vidya and Varanasi, Bala Subrahmanyam},
  year={2015},
  publisher={Packt Publishing Ltd}
}

@article{pedregosa2011scikit,
  title={Scikit-learn: Machine learning in Python},
  author={Pedregosa, Fabian and Varoquaux, Ga{\"e}l and Gramfort, Alexandre and Michel, Vincent and Thirion, Bertrand and Grisel, Olivier and Blondel, Mathieu and Prettenhofer, Peter and Weiss, Ron and Dubourg, Vincent and others},
  journal={Journal of machine learning research},
  volume={12},
  number={Oct},
  pages={2825--2830},
  year={2011}
}

@inproceedings{seabold2010statsmodels,
  title={statsmodels: Econometric and statistical modeling with python},
  author={Seabold, Skipper and Perktold, Josef},
  booktitle={9th Python in Science Conference},
  year={2010},
}

@online{chollet2015keras,
  title={Keras},
  author={Chollet, Francois and others},
  year={2015},
  publisher={GitHub},
  url={https://github.com/fchollet/keras},
}

@inproceedings{abadi2016tensorflow,
  title={Tensorflow: A system for large-scale machine learning},
  author={Abadi, Mart{\'\i}n and Barham, Paul and Chen, Jianmin and Chen, Zhifeng and Davis, Andy and Dean, Jeffrey and Devin, Matthieu and Ghemawat, Sanjay and Irving, Geoffrey and Isard, Michael and others},
  booktitle={12th $\{$USENIX$\}$ Symposium on Operating Systems Design and Implementation ($\{$OSDI$\}$ 16)},
  pages={265--283},
  year={2016}
}

@MISC {pmdarima,
  author = {Taylor G. Smith and others},
  title  = {{pmdarima}: ARIMA estimators for {Python}},
  year   = {2017--},
  url    = "http://www.alkaline-ml.com/pmdarima",
  note   = {[Online; accessed <today>]}
}

@article{da-Costa-Luis2019,
  doi = {10.21105/joss.01277},
  url = {https://doi.org/10.21105/joss.01277},
  year = {2019},
  publisher = {The Open Journal},
  volume = {4},
  number = {37},
  pages = {1277},
  author = {Casper O. da Costa-Luis},
  title = {`tqdm`: A Fast, Extensible Progress Meter for Python and CLI},
  journal = {Journal of Open Source Software}
}

@inproceedings{Ke2017LightGBMAH,
  title={LightGBM: A Highly Efficient Gradient Boosting Decision Tree},
  author={Guolin Ke and Qi Meng and Thomas Finley and Taifeng Wang and Wei Chen and Weidong Ma and Qiwei Ye and Tie-Yan Liu},
  booktitle={NIPS},
  year={2017}
}

license: MIT

license_type: permissive

branch_name: refs/heads/master

extension: bib


text:
DESCRIPTION = "NVIDIA compositor GStreamer plugin"
SECTION = "multimedia"
LICENSE = "BSD-3-Clause & Proprietary"
LIC_FILES_CHKSUM = "file://nvbuf_utils.h;endline=9;md5=e496d7a11e95b70c8d6bc8365b28f8cb \
                    file://README.txt;endline=26;md5=d4da79f8cebc6b73ce481b090afa99ae \
"

TEGRA_SRC_SUBARCHIVE = "Linux_for_Tegra/source/public/gst-nvcompositor_src.tbz2"
require recipes-bsp/tegra-sources/tegra-sources-35.1.0.inc

DEPENDS = "gstreamer1.0 gstreamer1.0-plugins-base virtual/egl tegra-mmapi tegra-libraries-multimedia-utils"

SRC_URI += " file://0001-Update-makefile-for-OE-builds.patch"

S = "${WORKDIR}/gst-nvcompositor"

inherit pkgconfig features_check

REQUIRED_DISTRO_FEATURES = "opengl"

do_install() {
	oe_runmake install DESTDIR="${D}"
}
FILES:${PN} = "${libdir}/gstreamer-1.0"

repository: SOL-Space-Operating-Linux/meta-tegra

repo_name: SOL-Space-Operating-Linux/meta-tegra

gha_license_id: MIT

gha_language: BitBake

extension: bb


text:
@inproceedings{Kazi:2016:SSD:2897839.2927410,
 acmid = {2927410},
 address = {New York, NY, USA},
 articleno = {84},
 author = {Kazi, Rubaiat Habib and Grossman, Tovi and Umetani, Nobuyuki and Fitzmaurice, George},
 booktitle = {ACM SIGGRAPH 2016 Talks},
 doi = {10.1145/2897839.2927410},
 isbn = {978-1-4503-4282-7},
 keywords = {motion amplifiers, principles of animation, sketching},
 location = {Anaheim, California},
 numpages = {1},
 pages = {84:1--84:1},
 publisher = {ACM},
 series = {SIGGRAPH '16},
 title = {SKUID: Sketching Dynamic Drawings Using the Principles of 2D Animation},
 url = {http://doi.acm.org/10.1145/2897839.2927410},
 year = {2016}
}

repository: jmatejka/group-website

repo_name: jmatejka/group-website


text:
@BOOK{Burke2010,
	AUTHOR = {Burke, Bill},
	YEAR = {2010},
	TITLE = {RESTful Java with JAX-RS},
	EDITION = {},
	ISBN = {978-1-449-38305-3},
	PUBLISHER = {O'Reilly Media, Inc.},
	ADDRESS = {Sebastopol, CA},
}
@BOOK{Tilkov2011,
	AUTHOR = {Tilkov, Stefan},
	YEAR = {2011},
	TITLE = {REST und HTTP - Einsatz der Architektur des Web für Integrationsszenarien},
	ISBN = {978-3-898-64732-8},
	PUBLISHER = {Dpunkt Verlag GmbH},
	ADDRESS = {Heidelberg},
}
@BOOK{Ament2013,
	AUTHOR = {Ament, John D.},
	YEAR = {2013},
	TITLE = {Arquillian Testing Guide - },
	EDITION = {},
	ISBN = {978-1-782-16070-0},
	PUBLISHER = {Packt Publishing, Limited},
	ADDRESS = {Birmingham},
}
@BOOK{Gupta2012,
	AUTHOR = {Gupta, Arun},
	YEAR = {2012},
	TITLE = {Java EE 6 Pocket Guide - },
	EDITION = {1. Aufl.},
	ISBN = {978-1-449-33668-4},
	PUBLISHER = {O'Reilly Media, Inc.},
	ADDRESS = {Sebastopol, CA},
}
@techreport{group2009jsr299,
  author = {{JSR-299 Expert Group}},
  institution = {Oracle Corporation},
  interhash = {6a67efc85aaae8c950eb810357a07051},
  intrahash = {9ee7fc28a71e6496a17d96255efe5c64},
  keywords = {CDI javaee},
  timestamp = {2012-12-07T10:32:19.000+0100},
  TITLE = {JSR-299: Contexts and Dependency Injection for the Java EE platform},
  url = {http://download.oracle.com/otndocs/jcp/web_beans-1.0-fr-eval-oth-JSpec/},
  year = {2009},
}
@misc{resteasy,
  author = {{jboss.org Community Documentation}},
  institution = {Red Hat},
  TITLE = {RESTEasy JAX-RS 2.3.6.Final: RESTFul Web Services for Java},
  howpublished = "\url{http://docs.jboss.org/resteasy/docs/2.3.6.Final/userguide/html_single/index.html}",
  year = {2010},
}
@misc{weld,
  author = {{seamframework.org Community Documentation}},
  institution = {Red Hat},
  TITLE = {Weld - CDI Reference Implementation},
  howpublished = "\url{https://docs.jboss.org/weld/reference/2.1.0.Final/en-US/html_single}",
  year = {2010},
}
@misc{cxf,
  author = {{Apache CXF}},
  institution = {Apache Foundation},
  TITLE = {JAX-RS : Client API},
  howpublished = "\url{http://cxf.apache.org/docs/jax-rs-client-api.html}",
  year = {2013},
}

repository: Robotregent/CDR

repo_name: Robotregent/CDR


text:
// Copyright (c) 2018 SAP SE or an SAP affiliate company. All rights reserved. This file is licensed under the Apache Software License, v. 2 except as noted otherwise in the LICENSE file
//
// 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 client

import (
	"context"
)

const (
	// AWS-SDK is missing these constant. So, added here till the time it comes from
	// upstream AWS-SDK-GO

	// errCodeBucketNotEmpty for service response error code
	// "BucketNotEmpty".
	//
	// The specified bucket us exist.
	errCodeBucketNotEmpty = "BucketNotEmpty"
)

// Interface is an interface which must be implemented by AWS clients.
type Interface interface {
	GetAccountID(ctx context.Context) (string, error)
	GetInternetGateway(ctx context.Context, vpcID string) (string, error)
	VerifyVPCAttributes(ctx context.Context, vpcID string) error

	// S3 wrappers
	DeleteObjectsWithPrefix(ctx context.Context, bucket, prefix string) error
	CreateBucketIfNotExists(ctx context.Context, bucket, region string) error
	DeleteBucketIfExists(ctx context.Context, bucket string) error

	// The following functions are only temporary needed due to https://github.com/gardener/gardener/issues/129.
	ListKubernetesELBs(ctx context.Context, vpcID, clusterName string) ([]string, error)
	ListKubernetesELBsV2(ctx context.Context, vpcID, clusterName string) ([]string, error)
	ListKubernetesSecurityGroups(ctx context.Context, vpcID, clusterName string) ([]string, error)
	DeleteELB(ctx context.Context, name string) error
	DeleteELBV2(ctx context.Context, arn string) error
	DeleteSecurityGroup(ctx context.Context, id string) error
}

extension: go


text:
@article{davies2014variable,
 abstract = {Questions: Termite mounds of the genus Macrotermes are prominent features in African savannas, forming nutrient hotspots that support greater plant diversity, which is of higher nutritional value than the surrounding savanna matrix. However, little is known about grass communities on and around mounds or how the functional importance of mounds varies across sites. As mean annual rainfall increases, savannas in southern Africa become increasingly dystrophic through increased denitrification (including pyrodenitrification) and the leaching of soil nutrients. The functional importance of mounds is concomitantly expected to increase as the difference in foliar nutrient levels between mounds and the savanna matrix increases. We tested this prediction on grass communities across a rainfall gradient to: (i) determine the degree to which grass assemblages differ between termite mounds and the savanna matrix; (ii) determine the spatial extent to which mounds influence grass communities; and (iii) investigate whether these patterns differ across savanna types. Location: Kruger National Park, South Africa. Methods: Grass communities were surveyed at three savanna sites differing in mean annual rainfall (550-750mm center dot yr(-1)). Grass diversity and tissue nitrogen concentrations were measured on and off termite mounds and along transects away from mounds in order to calculate the spatial influence of termite mounds on savanna grass communities. Using termite mound densities estimated from airborne LiDAR, we up-scaled field-based results to determine the percentage of the landscape influenced by Macrotermes termite activity. Results: Although species richness of grasses was lower on mounds than in the savanna matrix, the assemblage composition varied significantly, with higher nutrient concentrations in grasses located on mounds. This pattern became more distinct with increasing rainfall. The spatial extent of these nutrient-rich grasses also differed across the rainfall gradient, with a larger sphere of influence around mounds in wetter areas. Mounds distinctly altered grass communities over ca. 2% of the entire landscape. Conclusions: Our results show that Macrotermes mounds are important components of savanna heterogeneity, and reveal that the functional importance of mounds increases with increasing rainfall.},
 author = {Davies, Andrew B. and Robertson, Mark P. and Levick, Shaun R. and Asner, Gregory P. and van Rensburg, Berndt J. and Parr, Catherine L.},
 doi = {10.1111/jvs.12200},
 issn = {16541103},
 journal = {Journal of Vegetation Science},
 keywords = {LiDAR,Macrotermes,Nutrients,Spatial heterogeneity,Species richness},
 number = {6},
 pages = {1405--1416},
 title = {Variable effects of termite mounds on African savanna grass communities across a rainfall gradient},
 volume = {25},
 year = {2014}
}

repository: geospatialeco/SpatialDataScience

repo_name: geospatialeco/SpatialDataScience


text:
require qemu-devicetrees.inc

XILINX_RELEASE_VERSION = "v2018.3"

BRANCH ?= "master"
SRCREV ?= "e3e40b8829894a479c7d7380fc8137886645dda8"

repository: Ircona/openbmc

repo_name: Ircona/openbmc

gha_license_id: NOASSERTION

gha_language: Python


text:
SUMMARY = "JupyterLab is the next-generation web-based user interface for Project Jupyter"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=8bcc6c9ef50f2097920808c2bc5bffd2"

SRC_URI[sha256sum] = "472f6b7996c75f6991592483c26d9fe205a59a71ccbce15842400155dc64f59b"

inherit pypi setuptools3

PYPI_PACKAGE = "jupyterlab"

RDEPENDS:${PN} += " \
    ${PYTHON_PN}-notebook \
    ${PYTHON_PN}-babel \
    ${PYTHON_PN}-jupyterlab-server \
    ${PYTHON_PN}-anyio \
    ${PYTHON_PN}-sniffio \
    ${PYTHON_PN}-nbclassic \
    "

do_install:append(){
	install -d ${D}/usr/share/jupyter/lab
	cp -r ${S}/jupyterlab/schemas ${D}/usr/share/jupyter/lab/
	cp -r ${S}/jupyterlab/themes ${D}/usr/share/jupyter/lab/
	cp -r ${B}/jupyterlab/static ${D}/usr/share/jupyter/lab/
}

FILES:${PN} += " \
    ${datadir}/etc/jupyter/jupyter_notebook_config.d/jupyterlab.json \
    ${datadir}/jupyter/lab \
    ${prefix}/etc/jupyter/jupyter_notebook_config.d \
    ${prefix}/etc/jupyter/jupyter_server_config.d \
    ${prefix}/etc/jupyter/jupyter_notebook_config.d/jupyterlab.json \
    ${prefix}/etc/jupyter/jupyter_server_config.d/jupyterlab.json \
    "

BBCLASSEXTEND = "native"

repository: Xilinx/meta-jupyter

repo_name: Xilinx/meta-jupyter


text:
package feeds

import (
	"fmt"
	"testing"
	"time"

	"github.com/xeipuuv/gojsonschema"
)

const schemaPath = "../../package.schema.json"

type extendPackage struct {
	Package
	NonConformingField string `json:"non_conforming_field"`
}

var (
	schemaLoader = gojsonschema.NewReferenceLoader("file://" + schemaPath)
	dummyPackage = Package{
		Name:        "foobarpackage",
		Version:     "1.0.0",
		CreatedDate: time.Now().UTC(),
		Type:        "npm",
		SchemaVer:   schemaVer,
	}
)

func TestValidSchema(t *testing.T) {
	t.Parallel()

	validPackage := gojsonschema.NewGoLoader(dummyPackage)
	result, err := gojsonschema.Validate(schemaLoader, validPackage)
	if err != nil {
		t.Fatal(err)
	}

	if result.Valid() != true {
		out := "The Package json is not valid against the current schema. see errors :\n"
		for _, desc := range result.Errors() {
			out += fmt.Sprintf("- %s\n", desc)
		}
		t.Fatal(out)
	}
}

func TestInvalidSchema(t *testing.T) {
	t.Parallel()

	// The Schema defines that additional properties are not valid, ensure enforcement
	// against an extra struct field. If an extra field is added, the SchemVer minor should
	// be incremented to advertise an additive change.
	invalidPackageField := extendPackage{dummyPackage, "extrafield"}
	invalidField := gojsonschema.NewGoLoader(invalidPackageField)
	result, err := gojsonschema.Validate(schemaLoader, invalidField)
	if err != nil {
		t.Fatal(err)
	}

	if result.Valid() {
		t.Fatalf("Non-conformant extra field incorrectly validated")
	}

	// The Schema defines a required pattern for the schema_ver, ensure enforcement against
	// empty string.
	invalidPackageFormat := dummyPackage
	invalidPackageFormat.SchemaVer = ""
	invalidFormat := gojsonschema.NewGoLoader(invalidPackageFormat)
	result, err = gojsonschema.Validate(schemaLoader, invalidFormat)
	if err != nil {
		t.Fatal(err)
	}

	if result.Valid() {
		t.Fatalf("Non-conformant field format incorrectly validated")
	}
}

repository: calebbrown/package-feeds

repo_name: calebbrown/package-feeds

branch_name: refs/heads/main


text:
include(vcpkg_common_functions)

vcpkg_download_distfile(ARCHIVE
    URLS "https://kent.dl.sourceforge.net/project/soxr/soxr-0.1.3-Source.tar.xz"
    FILENAME "soxr-0.1.3-Source.tar.xz"
    SHA512 f4883ed298d5650399283238aac3dbe78d605b988246bea51fa343d4a8ce5ce97c6e143f6c3f50a3ff81795d9c19e7a07217c586d4020f6ced102aceac46aaa8
)

vcpkg_extract_source_archive_ex(
    OUT_SOURCE_PATH SOURCE_PATH
    ARCHIVE ${ARCHIVE}
)

vcpkg_configure_cmake(
    SOURCE_PATH ${SOURCE_PATH}
    PREFER_NINJA # Disable this option if project cannot be built with Ninja
)

vcpkg_install_cmake()

# Handle copyright
file(INSTALL ${SOURCE_PATH}/COPYING.LGPL DESTINATION ${CURRENT_PACKAGES_DIR}/share/soxr RENAME copyright)

# Post-build test for cmake libraries
# vcpkg_test_cmake(PACKAGE_NAME soxr)

repository: MVoz/vcpkg-old

repo_name: MVoz/vcpkg-old

extension: cmake


text:
package iterator

import "fmt"

type Item struct {
	ID   int
	Name string
}

type Items []Item

func (a Items) Iterator() Iterator {
	return NewCloseableIterator(next(a), func() error {
		return nil
	})
}

func next(items []Item) ComputeNext {
	index := 0

	return func() (interface{}, bool, error) {
		if index >= len(items) {
			return nil, true, nil
		}

		n := &items[index]
		index++
		return n, false, nil
	}
}

func nextAndIndex(items []Item) (ComputeNext, *int) {
	index := 0

	return func() (interface{}, bool, error) {
		if index >= len(items) {
			return nil, true, nil
		}

		n := &items[index]
		index++
		return n, false, nil
	}, &index
}

func generateItems(from int, to int) []Item {
	var items []Item
	for from < to {
		items = append(items, Item{
			ID:   from,
			Name: fmt.Sprintf("item_%04d", from),
		})
		from++
	}
	return items
}

func itemsFromIds(ids ...int) []Item {
	var items []Item
	for _, id := range ids {
		items = append(items, Item{
			ID:   id,
			Name: fmt.Sprintf("item_%04d", id),
		})
	}
	return items
}

repository: calvernaz/go-iterators

repo_name: calvernaz/go-iterators


text:
package utils

import (
	"encoding/csv"
	"fmt"
	"github.com/packagewjx/workload-classifier/pkg/core"
	"github.com/pkg/errors"
	"io"
	"strings"
)

func WriteContainerWorkloadHeader(out io.Writer) error {
	header := make([]string, 1, 1+core.NumSections+core.NumSectionFields)
	header[0] = "container_id"
	for i := 0; i < core.NumSections; i++ {
		header = append(header,
			fmt.Sprintf("cpu_avg_%d", i),
			fmt.Sprintf("cpu_max_%d", i),
			fmt.Sprintf("cpu_min_%d", i),
			fmt.Sprintf("cpu_p50_%d", i),
			fmt.Sprintf("cpu_p90_%d", i),
			fmt.Sprintf("cpu_p99_%d", i),
			fmt.Sprintf("mem_avg_%d", i),
			fmt.Sprintf("mem_max_%d", i),
			fmt.Sprintf("mem_min_%d", i),
			fmt.Sprintf("mem_p50_%d", i),
			fmt.Sprintf("mem_p90_%d", i),
			fmt.Sprintf("mem_p99_%d", i))
	}
	_, err := out.Write([]byte(strings.Join(header, core.Splitter)))
	return err
}

func WriteContainerWorkloadData(out io.Writer, data []*core.ContainerWorkloadData) error {
	writer := csv.NewWriter(out)
	defer writer.Flush()

	for i, cData := range data {
		record := WorkloadDataToStringRecord(cData)
		err := writer.Write(record)
		if err != nil {
			return errors.Wrap(err, fmt.Sprintf("写入第%d条数据出错", i))
		}
	}

	return nil
}

repository: packagewjx/workload-classifier

repo_name: packagewjx/workload-classifier


text:
package goutil

import (
	"crypto/md5"
	"crypto/sha1"
	"fmt"
	"math/rand"
	"time"
	"unsafe"
)

//EncodeMD5 EncodeMD5
func EncodeMD5(value string) string {
	m := md5.New()
	m.Write([]byte(value))
	return fmt.Sprintf("%x", m.Sum(nil))
}

//EncodeSha1 EncodeSha1
func EncodeSha1(value string) string {
	m := sha1.New()
	m.Write([]byte(value))
	return fmt.Sprintf("%x", m.Sum(nil))
}

const (
	letterBytes   = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	letterIdxMask = 1<<6 - 1 // All 1-bits, as many as 6
)

var src = rand.NewSource(time.Now().UnixNano())

//RandStringBytesMaskImprSrc 返回指定长度的随机字符串
//出处 https://colobu.com/2018/09/02/generate-random-string-in-Go/
//评论区 作者 heyuanchao
//实测该页面最快
func RandStringBytesMaskImprSrc(n int) string {
	b := make([]byte, n)
	// A src.Int63() generates 63 random bits, enough for 10 characters!
	for i, cache, remain := n-1, src.Int63(), 10; i >= 0; {
		if remain == 0 {
			cache, remain = src.Int63(), 10
		}
		b[i] = letterBytes[int(cache&letterIdxMask)%len(letterBytes)]
		i--
		cache >>= 6
		remain--
	}
	return *(*string)(unsafe.Pointer(&b))
}

repository: orchie/goutil

repo_name: orchie/goutil


text:
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: envoy/type/matcher/value.proto

package envoy_type_matcher

import (
	fmt "fmt"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// Specifies the way to match a ProtobufWkt::Value. Primitive values and ListValue are supported.
// StructValue is not supported and is always not matched.
// [#next-free-field: 7]
type ValueMatcher struct {
	// Specifies how to match a value.
	//
	// Types that are valid to be assigned to MatchPattern:
	//	*ValueMatcher_NullMatch_
	//	*ValueMatcher_DoubleMatch
	//	*ValueMatcher_StringMatch
	//	*ValueMatcher_BoolMatch
	//	*ValueMatcher_PresentMatch
	//	*ValueMatcher_ListMatch
	MatchPattern         isValueMatcher_MatchPattern `protobuf_oneof:"match_pattern"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (m *ValueMatcher) Reset()         { *m = ValueMatcher{} }
func (m *ValueMatcher) String() string { return proto.CompactTextString(m) }
func (*ValueMatcher) ProtoMessage()    {}
func (*ValueMatcher) Descriptor() ([]byte, []int) {
	return fileDescriptor_145b36501d266253, []int{0}
}
func (m *ValueMatcher) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValueMatcher) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValueMatcher.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValueMatcher) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValueMatcher.Merge(m, src)
}
func (m *ValueMatcher) XXX_Size() int {
	return m.Size()
}
func (m *ValueMatcher) XXX_DiscardUnknown() {
	xxx_messageInfo_ValueMatcher.DiscardUnknown(m)
}

var xxx_messageInfo_ValueMatcher proto.InternalMessageInfo

type isValueMatcher_MatchPattern interface {
	isValueMatcher_MatchPattern()
	MarshalTo([]byte) (int, error)
	Size() int
}

type ValueMatcher_NullMatch_ struct {
	NullMatch *ValueMatcher_NullMatch `protobuf:"bytes,1,opt,name=null_match,json=nullMatch,proto3,oneof" json:"null_match,omitempty"`
}
type ValueMatcher_DoubleMatch struct {
	DoubleMatch *DoubleMatcher `protobuf:"bytes,2,opt,name=double_match,json=doubleMatch,proto3,oneof" json:"double_match,omitempty"`
}
type ValueMatcher_StringMatch struct {
	StringMatch *StringMatcher `protobuf:"bytes,3,opt,name=string_match,json=stringMatch,proto3,oneof" json:"string_match,omitempty"`
}
type ValueMatcher_BoolMatch struct {
	BoolMatch bool `protobuf:"varint,4,opt,name=bool_match,json=boolMatch,proto3,oneof" json:"bool_match,omitempty"`
}
type ValueMatcher_PresentMatch struct {
	PresentMatch bool `protobuf:"varint,5,opt,name=present_match,json=presentMatch,proto3,oneof" json:"present_match,omitempty"`
}
type ValueMatcher_ListMatch struct {
	ListMatch *ListMatcher `protobuf:"bytes,6,opt,name=list_match,json=listMatch,proto3,oneof" json:"list_match,omitempty"`
}

func (*ValueMatcher_NullMatch_) isValueMatcher_MatchPattern()   {}
func (*ValueMatcher_DoubleMatch) isValueMatcher_MatchPattern()  {}
func (*ValueMatcher_StringMatch) isValueMatcher_MatchPattern()  {}
func (*ValueMatcher_BoolMatch) isValueMatcher_MatchPattern()    {}
func (*ValueMatcher_PresentMatch) isValueMatcher_MatchPattern() {}
func (*ValueMatcher_ListMatch) isValueMatcher_MatchPattern()    {}

func (m *ValueMatcher) GetMatchPattern() isValueMatcher_MatchPattern {
	if m != nil {
		return m.MatchPattern
	}
	return nil
}

func (m *ValueMatcher) GetNullMatch() *ValueMatcher_NullMatch {
	if x, ok := m.GetMatchPattern().(*ValueMatcher_NullMatch_); ok {
		return x.NullMatch
	}
	return nil
}

func (m *ValueMatcher) GetDoubleMatch() *DoubleMatcher {
	if x, ok := m.GetMatchPattern().(*ValueMatcher_DoubleMatch); ok {
		return x.DoubleMatch
	}
	return nil
}

func (m *ValueMatcher) GetStringMatch() *StringMatcher {
	if x, ok := m.GetMatchPattern().(*ValueMatcher_StringMatch); ok {
		return x.StringMatch
	}
	return nil
}

func (m *ValueMatcher) GetBoolMatch() bool {
	if x, ok := m.GetMatchPattern().(*ValueMatcher_BoolMatch); ok {
		return x.BoolMatch
	}
	return false
}

func (m *ValueMatcher) GetPresentMatch() bool {
	if x, ok := m.GetMatchPattern().(*ValueMatcher_PresentMatch); ok {
		return x.PresentMatch
	}
	return false
}

func (m *ValueMatcher) GetListMatch() *ListMatcher {
	if x, ok := m.GetMatchPattern().(*ValueMatcher_ListMatch); ok {
		return x.ListMatch
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ValueMatcher) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ValueMatcher_NullMatch_)(nil),
		(*ValueMatcher_DoubleMatch)(nil),
		(*ValueMatcher_StringMatch)(nil),
		(*ValueMatcher_BoolMatch)(nil),
		(*ValueMatcher_PresentMatch)(nil),
		(*ValueMatcher_ListMatch)(nil),
	}
}

// NullMatch is an empty message to specify a null value.
type ValueMatcher_NullMatch struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ValueMatcher_NullMatch) Reset()         { *m = ValueMatcher_NullMatch{} }
func (m *ValueMatcher_NullMatch) String() string { return proto.CompactTextString(m) }
func (*ValueMatcher_NullMatch) ProtoMessage()    {}
func (*ValueMatcher_NullMatch) Descriptor() ([]byte, []int) {
	return fileDescriptor_145b36501d266253, []int{0, 0}
}
func (m *ValueMatcher_NullMatch) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValueMatcher_NullMatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValueMatcher_NullMatch.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValueMatcher_NullMatch) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValueMatcher_NullMatch.Merge(m, src)
}
func (m *ValueMatcher_NullMatch) XXX_Size() int {
	return m.Size()
}
func (m *ValueMatcher_NullMatch) XXX_DiscardUnknown() {
	xxx_messageInfo_ValueMatcher_NullMatch.DiscardUnknown(m)
}

var xxx_messageInfo_ValueMatcher_NullMatch proto.InternalMessageInfo

// Specifies the way to match a list value.
type ListMatcher struct {
	// Types that are valid to be assigned to MatchPattern:
	//	*ListMatcher_OneOf
	MatchPattern         isListMatcher_MatchPattern `protobuf_oneof:"match_pattern"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *ListMatcher) Reset()         { *m = ListMatcher{} }
func (m *ListMatcher) String() string { return proto.CompactTextString(m) }
func (*ListMatcher) ProtoMessage()    {}
func (*ListMatcher) Descriptor() ([]byte, []int) {
	return fileDescriptor_145b36501d266253, []int{1}
}
func (m *ListMatcher) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ListMatcher) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListMatcher.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ListMatcher) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListMatcher.Merge(m, src)
}
func (m *ListMatcher) XXX_Size() int {
	return m.Size()
}
func (m *ListMatcher) XXX_DiscardUnknown() {
	xxx_messageInfo_ListMatcher.DiscardUnknown(m)
}

var xxx_messageInfo_ListMatcher proto.InternalMessageInfo

type isListMatcher_MatchPattern interface {
	isListMatcher_MatchPattern()
	MarshalTo([]byte) (int, error)
	Size() int
}

type ListMatcher_OneOf struct {
	OneOf *ValueMatcher `protobuf:"bytes,1,opt,name=one_of,json=oneOf,proto3,oneof" json:"one_of,omitempty"`
}

func (*ListMatcher_OneOf) isListMatcher_MatchPattern() {}

func (m *ListMatcher) GetMatchPattern() isListMatcher_MatchPattern {
	if m != nil {
		return m.MatchPattern
	}
	return nil
}

func (m *ListMatcher) GetOneOf() *ValueMatcher {
	if x, ok := m.GetMatchPattern().(*ListMatcher_OneOf); ok {
		return x.OneOf
	}
	return nil
}

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

func init() {
	proto.RegisterType((*ValueMatcher)(nil), "envoy.type.matcher.ValueMatcher")
	proto.RegisterType((*ValueMatcher_NullMatch)(nil), "envoy.type.matcher.ValueMatcher.NullMatch")
	proto.RegisterType((*ListMatcher)(nil), "envoy.type.matcher.ListMatcher")
}

func init() { proto.RegisterFile("envoy/type/matcher/value.proto", fileDescriptor_145b36501d266253) }

var fileDescriptor_145b36501d266253 = []byte{
	// 358 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0x4f, 0x4b, 0xc3, 0x30,
	0x18, 0x87, 0x17, 0xe7, 0x86, 0x7b, 0xbb, 0x5d, 0x82, 0xa0, 0xec, 0xd0, 0xd5, 0x81, 0x30, 0x3c,
	0xb4, 0xa0, 0x27, 0xc1, 0x83, 0x14, 0x91, 0x81, 0xff, 0xc6, 0x04, 0x8f, 0x8e, 0xd6, 0xbd, 0xd3,
	0x42, 0x96, 0x94, 0x34, 0x1d, 0xee, 0x9b, 0xf8, 0x91, 0x3c, 0xfa, 0x11, 0x64, 0x9f, 0xc2, 0xa3,
	0x34, 0x49, 0xdd, 0xc0, 0x8a, 0xb7, 0xe4, 0x7d, 0x9f, 0xdf, 0xd3, 0x37, 0x4d, 0xc0, 0x45, 0xbe,
	0x10, 0xcb, 0x40, 0x2d, 0x53, 0x0c, 0xe6, 0x91, 0x7a, 0x7a, 0x41, 0x19, 0x2c, 0x22, 0x96, 0xa3,
	0x9f, 0x4a, 0xa1, 0x04, 0xa5, 0xba, 0xef, 0x17, 0x7d, 0xdf, 0xf6, 0xbb, 0xbd, 0x8a, 0x0c, 0xcf,
	0xe7, 0x31, 0x4a, 0x13, 0xaa, 0x04, 0x32, 0x25, 0x13, 0xfe, 0x6c, 0x81, 0xbd, 0x45, 0xc4, 0x92,
	0x69, 0xa4, 0x30, 0x28, 0x17, 0xa6, 0xd1, 0x7f, 0xab, 0x43, 0xfb, 0xa1, 0xf8, 0xfc, 0x8d, 0x89,
	0xd1, 0x2b, 0x00, 0x9e, 0x33, 0x36, 0xd1, 0x9a, 0x7d, 0xe2, 0x91, 0x81, 0x73, 0x7c, 0xe4, 0xff,
	0x1e, 0xca, 0xdf, 0x4c, 0xf9, 0xb7, 0x39, 0x63, 0x7a, 0x3d, 0xac, 0x8d, 0x5b, 0xbc, 0xdc, 0xd0,
	0x4b, 0x68, 0x4f, 0x45, 0x1e, 0x33, 0xb4, 0xba, 0x2d, 0xad, 0x3b, 0xa8, 0xd2, 0x5d, 0x68, 0xce,
	0xfa, 0x86, 0xb5, 0xb1, 0x33, 0x5d, 0x17, 0x0a, 0x8f, 0x39, 0x8e, 0xf5, 0xd4, 0xff, 0xf6, 0xdc,
	0x6b, 0x6e, 0xc3, 0x93, 0xad, 0x0b, 0xb4, 0x07, 0x10, 0x0b, 0x51, 0x1e, 0x6e, 0xdb, 0x23, 0x83,
	0x9d, 0x62, 0xe0, 0xa2, 0x66, 0x80, 0x43, 0xe8, 0xa4, 0x12, 0x33, 0xe4, 0xca, 0x32, 0x0d, 0xcb,
	0xb4, 0x6d, 0xd9, 0x60, 0xe7, 0x00, 0x2c, 0xc9, 0x4a, 0xa6, 0xa9, 0xa7, 0xe9, 0x55, 0x4d, 0x73,
	0x9d, 0x64, 0x6a, 0x3d, 0x4b, 0x8b, 0x95, 0xdb, 0xae, 0x03, 0xad, 0x9f, 0x7f, 0x16, 0xee, 0x42,
	0x47, 0x07, 0x26, 0x69, 0xa4, 0x14, 0x4a, 0x4e, 0xeb, 0x5f, 0x21, 0xe9, 0x3f, 0x82, 0xb3, 0x11,
	0xa7, 0xa7, 0xd0, 0x14, 0x1c, 0x27, 0x62, 0x66, 0x2f, 0xc5, 0xfb, 0xef, 0x52, 0x86, 0xb5, 0x71,
	0x43, 0x70, 0xbc, 0x9b, 0x55, 0xfb, 0xc3, 0xb3, 0xf7, 0x95, 0x4b, 0x3e, 0x56, 0x2e, 0xf9, 0x5c,
	0xb9, 0x04, 0xbc, 0x44, 0x18, 0x61, 0x2a, 0xc5, 0xeb, 0xb2, 0xc2, 0x1d, 0x82, 0x96, 0x8f, 0x8a,
	0x67, 0x33, 0x22, 0x71, 0x53, 0xbf, 0x9f, 0x93, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x52, 0xfa,
	0x91, 0x67, 0xd0, 0x02, 0x00, 0x00,
}

func (m *ValueMatcher) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValueMatcher) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValueMatcher) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.MatchPattern != nil {
		{
			size := m.MatchPattern.Size()
			i -= size
			if _, err := m.MatchPattern.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *ValueMatcher_NullMatch_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValueMatcher_NullMatch_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NullMatch != nil {
		{
			size, err := m.NullMatch.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintValue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *ValueMatcher_DoubleMatch) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValueMatcher_DoubleMatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DoubleMatch != nil {
		{
			size, err := m.DoubleMatch.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintValue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *ValueMatcher_StringMatch) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValueMatcher_StringMatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.StringMatch != nil {
		{
			size, err := m.StringMatch.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintValue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *ValueMatcher_BoolMatch) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValueMatcher_BoolMatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i--
	if m.BoolMatch {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x20
	return len(dAtA) - i, nil
}
func (m *ValueMatcher_PresentMatch) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValueMatcher_PresentMatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i--
	if m.PresentMatch {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x28
	return len(dAtA) - i, nil
}
func (m *ValueMatcher_ListMatch) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValueMatcher_ListMatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ListMatch != nil {
		{
			size, err := m.ListMatch.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintValue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *ValueMatcher_NullMatch) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValueMatcher_NullMatch) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValueMatcher_NullMatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *ListMatcher) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ListMatcher) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ListMatcher) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.MatchPattern != nil {
		{
			size := m.MatchPattern.Size()
			i -= size
			if _, err := m.MatchPattern.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *ListMatcher_OneOf) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ListMatcher_OneOf) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.OneOf != nil {
		{
			size, err := m.OneOf.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintValue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func encodeVarintValue(dAtA []byte, offset int, v uint64) int {
	offset -= sovValue(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ValueMatcher) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MatchPattern != nil {
		n += m.MatchPattern.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValueMatcher_NullMatch_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NullMatch != nil {
		l = m.NullMatch.Size()
		n += 1 + l + sovValue(uint64(l))
	}
	return n
}
func (m *ValueMatcher_DoubleMatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DoubleMatch != nil {
		l = m.DoubleMatch.Size()
		n += 1 + l + sovValue(uint64(l))
	}
	return n
}
func (m *ValueMatcher_StringMatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StringMatch != nil {
		l = m.StringMatch.Size()
		n += 1 + l + sovValue(uint64(l))
	}
	return n
}
func (m *ValueMatcher_BoolMatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}
func (m *ValueMatcher_PresentMatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}
func (m *ValueMatcher_ListMatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ListMatch != nil {
		l = m.ListMatch.Size()
		n += 1 + l + sovValue(uint64(l))
	}
	return n
}
func (m *ValueMatcher_NullMatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ListMatcher) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MatchPattern != nil {
		n += m.MatchPattern.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ListMatcher_OneOf) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OneOf != nil {
		l = m.OneOf.Size()
		n += 1 + l + sovValue(uint64(l))
	}
	return n
}

func sovValue(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozValue(x uint64) (n int) {
	return sovValue(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ValueMatcher) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowValue
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValueMatcher: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValueMatcher: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullMatch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthValue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthValue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ValueMatcher_NullMatch{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.MatchPattern = &ValueMatcher_NullMatch_{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DoubleMatch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthValue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthValue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DoubleMatcher{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.MatchPattern = &ValueMatcher_DoubleMatch{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringMatch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthValue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthValue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &StringMatcher{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.MatchPattern = &ValueMatcher_StringMatch{v}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BoolMatch", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.MatchPattern = &ValueMatcher_BoolMatch{b}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PresentMatch", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.MatchPattern = &ValueMatcher_PresentMatch{b}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMatch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthValue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthValue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ListMatcher{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.MatchPattern = &ValueMatcher_ListMatch{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipValue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValue
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValueMatcher_NullMatch) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowValue
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NullMatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NullMatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipValue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValue
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ListMatcher) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowValue
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListMatcher: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListMatcher: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OneOf", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthValue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthValue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ValueMatcher{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.MatchPattern = &ListMatcher_OneOf{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipValue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValue
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipValue(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowValue
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowValue
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowValue
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthValue
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupValue
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthValue
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthValue        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowValue          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupValue = fmt.Errorf("proto: unexpected end of group")
)

repository: aallbrig/ambassador

repo_name: aallbrig/ambassador


text:
@article{johnston_evidence-based_2009,
	title = {Evidence-based effect size estimation: An illustration using the case of acupuncture for cancer-related fatigue},
	volume = {9},
	issn = {1472-6882},
	url = {http://www.biomedcentral.com/1472-6882/9/1},
	doi = {10.1186/1472-6882-9-1},
	shorttitle = {Evidence-based effect size estimation},
	abstract = {{BACKGROUND}:Estimating a realistic effect size is an important issue in the planning of clinical studies of complementary and alternative medicine therapies. When a minimally important difference is not available, researchers may estimate effect size using the published literature. This evidence-based effect size estimation may be used to produce a range of empirically-informed effect size and consequent sample size estimates. We provide an illustration of deriving plausible effect size ranges for a study of acupuncture in the relief of post-chemotherapy fatigue in breast cancer patients.{METHODS}:A {PubMed} search identified three uncontrolled studies reporting the effect of acupuncture in relieving fatigue. A separate search identified five randomized controlled trials ({RCTs}) with a wait-list control of breast cancer patients receiving standard care that reported data on fatigue. We use these published data to produce best, average, and worst-case effect size estimates and related sample size estimates for a trial of acupuncture in the relief of cancer-related fatigue relative to a wait-list control receiving standard care.{RESULTS}:Use of evidence-based effect size estimation to calculate sample size requirements for a study of acupuncture in relieving fatigue in breast cancer survivors relative to a wait-list control receiving standard care suggests that an adequately-powered phase {III} randomized controlled trial comprised of two arms would require at least 101 subjects (52 per arm) if a strong effect is assumed for acupuncture and 235 (118 per arm) if a moderate effect is assumed.{CONCLUSION}:Evidence-based effect size estimation helps justify assumptions in light of empirical evidence and can lead to more realistic sample size calculations, an outcome that would be of great benefit for the field of complementary and alternative medicine.},
	pages = {1},
	number = {1},
	journaltitle = {{BMC} Complementary and Alternative Medicine},
	author = {Johnston, Michael and Hays, Ron and Hui, Ka-Kit},
	urldate = {2009-02-24},
	date = {2009},
	tags = {Sample size justification}
}

repository: pmean/build-website

repo_name: pmean/build-website


text:
package etc

const (
	SqliteDatabaseName = "demo"

	MysqlUser     = "root"
	MysqlPassword = "root"
	MysqlHost     = "localhost"
	MysqlPort     = 3306
	MysqlDatabase = "sjyx"
	MysqlLogMode  = true
)


text:
//【golang select机制】
//检查每个case语句
//如果有任意一个chan是send or receive ready，那么就执行该block
//如果多个case是ready的，那么随机找1个并执行该block
//如果都没有ready，那么就block and wait
//如果有default block，而且其他的case都没有ready，就执行该default block
package main

import (
	"fmt"
)

func main() {
	c := make(chan int)
	go func() {
		//sub routine不停的从channel中读
		for value := range c {
			fmt.Println(value)
		}
	}()

	for {
		//main routine不停的向channel中写
		select {
		case c <- 0:
		case c <- 1:
		case c <- 2:
		}
	}
}

repository: JoshuaAndrew/learning

repo_name: JoshuaAndrew/learning


text:
@Proceedings{GordonAISTATS2011,
  booktitle = {Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics},
  conference_number = 14,
  editor = {Geoffrey Gordon and David Dunson and Miroslav Dud\'{i}k},
  publisher = {JMLR Workshop and Conference Proceedings},
  logo = {SAIS_logo.jpg},
  volume = {15},
  year = {2011},
  shortname = {AISTATS},
  OPTsections = {preface=Preface|default=Accepted Papers},
  start = {2011-04-11},
  end = {2011-04-13},
  published = {2011-06-14},
  month = {11-13 April},
  address = {Fort Lauderdale, FL, USA},
  sections = {preface=Preface|notable=Part I: Notable Papers|default=Part II: Regular Papers}

}

repository: mlresearch/papersite

repo_name: mlresearch/papersite

gha_language: TeX


text:
# CMake generated Testfile for
# Source directory: /home/lirh/pointcloud/GAN/PointGAN/PU-GAN/evaluation_code
# Build directory: /home/lirh/pointcloud/GAN/PointGAN/PU-GAN/evaluation_code
#
# This file includes the relevant testing commands required for
# testing this directory and lists subdirectories to be tested as well.
add_test(compilation_of__evaluation "/usr/local/bin/cmake" "--build" "/home/lirh/pointcloud/GAN/PointGAN/PU-GAN/evaluation_code" "--target" "evaluation")
set_tests_properties(compilation_of__evaluation PROPERTIES  FIXTURES_SETUP "evaluation" LABELS "Distance_2_Tests")
add_test(execution___of__evaluation "/home/lirh/pointcloud/GAN/PointGAN/PU-GAN/evaluation_code/evaluation")
set_tests_properties(execution___of__evaluation PROPERTIES  DEPENDS "compilation_of__evaluation" FIXTURES_REQUIRED "Distance_2_Tests;evaluation" LABELS "Distance_2_Tests" WORKING_DIRECTORY "/home/lirh/pointcloud/GAN/PointGAN/PU-GAN/evaluation_code/__exec_test_dir")
add_test(Distance_2_Tests_SetupFixture "/usr/local/bin/cmake" "-E" "copy_directory" "/home/lirh/pointcloud/GAN/PointGAN/PU-GAN/evaluation_code" "/home/lirh/pointcloud/GAN/PointGAN/PU-GAN/evaluation_code/__exec_test_dir")
set_tests_properties(Distance_2_Tests_SetupFixture PROPERTIES  FIXTURES_SETUP "Distance_2_Tests" LABELS "Distance_2_Tests")
add_test(Distance_2_Tests_CleanupFixture "/usr/local/bin/cmake" "-E" "remove_directory" "/home/lirh/pointcloud/GAN/PointGAN/PU-GAN/evaluation_code/__exec_test_dir")
set_tests_properties(Distance_2_Tests_CleanupFixture PROPERTIES  FIXTURES_CLEANUP "Distance_2_Tests" LABELS "Distance_2_Tests")

repository: liruihui/Dis-PU

repo_name: liruihui/Dis-PU


text:
require acpid.inc

SRC_URI_append = " file://event.c.diff \
                   file://fixfd.diff \
                   file://netlink.diff"
PR = "${INC_PR}.0"
SRC_URI[md5sum] = "1d9c52fe2c0b51f8463f357c2a3d3ddb"
SRC_URI[sha256sum] = "d57ae5302c38c37d060a097fa51600fe06fbfffd575641d638407944f126b7b1"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
@ARTICLE{Birgand2016-to,
  title   = "First report of a novel multiplexer pumping system coupled to a
             water quality probe to collect high temporal frequency in situ
             water chemistry measurements at multiple sites",
  author  = "Birgand, Fran{\c c}ois and Aveni-Deforge, Kyle and Smith, Brad and
             Maxwell, Bryan and Horstman, Marc and Gerling, Alexandra B and
             Carey, Cayelan C",
  journal = "Limnol. Oceanogr. Methods",
  volume  =  14,
  number  =  12,
  pages   = "767--783",
  month   =  dec,
  year    =  2016,
  url     = "http://dx.doi.org/10.1002/lom3.10122",
  file    = "All Papers/B/Birgand et al. 2016 - Birgand_et_al_2016_LOMeView.pdf;All Papers/B/Birgand et al. 2016 - First report of a novel multiplexer pumping system ... oral frequency in situ water chemistry measurements at multiple sites.pdf",
  issn    = "1541-5856",
  doi     = "10.1002/lom3.10122"
}

repository: francoisbirgand/Multiplexo

repo_name: francoisbirgand/Multiplexo


text:
@InProceedings{der07a,
  title = {Large-Margin Classification in Banach Spaces},
  author = {Ricky Der and Daniel Lee},
  pages = {91--98},
  abstract = {We propose a framework for dealing with binary hard-margin classification in Banach spaces, centering on the use of a supporting semi-inner-product (s.i.p.) taking the place of an inner-product in Hilbert spaces. The theory of semi-inner-product spaces allows for a geometric, Hilbert-like formulation of the problems, and we show that a surprising number of results from the Euclidean case can be appropriately generalised. These include the Representer theorem, convexity of the associated optimization programs, and even, for a particular class of Banach spaces, a ``kernel trick'' for non-linear classification.},
  pdf = {http://jmlr.org/proceedings/papers/v2/der07a/der07a.pdf},
}

repository: mreid/papersite

repo_name: mreid/papersite


text:
package calibnet

import (
	"fmt"

	rice "github.com/GeertJohan/go.rice"
)

var genesisBytes []byte

func init() {
	box, err := rice.FindBox("genesis")
	if err != nil {
		panic(fmt.Sprintf("failed to find mainnet genesis data directory: %v", err))
	}
	genesisBytes, err = box.Bytes("calibnet.car")
	if err != nil {
		panic(fmt.Sprintf("failed to read mainnet genesis data: %v", err))
	}
}

repository: iand/filecoin-kernel

repo_name: iand/filecoin-kernel


text:
require bison.inc

PR = "${INC_PR}.0"

# >> bison-2.3-r0: /usr/lib/liby.a
# That one is a special case: it wants to stay in the main bison package,
# since bison itself is a development tool.  I'm not sure why it is a
# static-only library; that might be an error.

FILES_${PN} += "${libdir}/liby.a"

SRC_URI[md5sum] = "22327efdd5080e2b1acb6e560a04b43a"
SRC_URI[sha256sum] = "52f78aa4761a74ceb7fdf770f3554dd84308c3b93c4255e3a5c17558ecda293e"


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

package match

import (
	"bytes"
	"io"
	"net/http"

	"github.com/erda-project/erda/pkg/encoding/jsonparse"
)

func init() {
	registry("request_body", requestBody{})
}

type requestBody struct {
}

func (f requestBody) get(expr string, r *http.Request) interface{} {
	body, err := io.ReadAll(r.Body)
	if err != nil {
		return nil
	}
	r.Body = io.NopCloser(bytes.NewBuffer(body))
	return jsonparse.FilterJson(body, expr, "jsonpath")
}

repository: erda-project/erda

repo_name: erda-project/erda

gha_language: Go


text:
package certificate

import (
	"crypto/rand"
	"crypto/x509"
	"fmt"

	"github.com/pkg/errors"
	"github.com/smallstep/cli/flags"
	"github.com/smallstep/cli/utils"
	"github.com/urfave/cli"
	"go.step.sm/cli-utils/command"
	"go.step.sm/cli-utils/errs"
	"go.step.sm/cli-utils/ui"
	"go.step.sm/crypto/pemutil"
	"go.step.sm/crypto/x509util"
	"software.sslmate.com/src/go-pkcs12"
)

func p12Command() cli.Command {
	return cli.Command{
		Name:   "p12",
		Action: command.ActionFunc(p12Action),
		Usage:  `package a certificate and keys into a .p12 file`,
		UsageText: `step certificate p12 <p12-path> [<crt-path>] [<key-path>]
[**--ca**=<file>] [**--password-file**=<file>]`,
		Description: `**step certificate p12** creates a .p12 (PFX / PKCS12)
file containing certificates and keys. This can then be used to import
into Windows / Firefox / Java applications.

## EXIT CODES

This command returns 0 on success and \>0 if any error occurs.

## EXAMPLES

Package a certificate and private key together:

'''
$ step certificate p12 foo.p12 foo.crt foo.key
'''

Package a certificate and private key together, and include an intermediate certificate:

'''
$ step certificate p12 foo.p12 foo.crt foo.key --ca intermediate.crt
'''

Package a CA certificate into a "trust store" for Java applications:

'''
$ step certificate p12 trust.p12 --ca ca.crt
'''

Package a certificate and private key with an empty password:

'''
$ step certificate p12 --no-password --insecure foo.p12 foo.crt foo.key
'''`,
		Flags: []cli.Flag{
			cli.StringSliceFlag{
				Name: "ca",
				Usage: `The path to the <file> containing a CA or intermediate certificate to
add to the .p12 file. Use the '--ca' flag multiple times to add
multiple CAs or intermediates.`,
			},
			cli.StringFlag{
				Name:  "password-file",
				Usage: `The path to the <file> containing the password to encrypt the .p12 file.`,
			},
			flags.NoPassword,
			flags.Force,
			flags.Insecure,
		},
	}
}

func p12Action(ctx *cli.Context) error {
	if err := errs.MinMaxNumberOfArguments(ctx, 1, 3); err != nil {
		return err
	}

	p12File := ctx.Args().Get(0)
	crtFile := ctx.Args().Get(1)
	keyFile := ctx.Args().Get(2)
	caFiles := ctx.StringSlice("ca")
	hasKeyAndCert := crtFile != "" && keyFile != ""

	// If either key or cert are provided, both must be provided
	if !hasKeyAndCert && (crtFile != "" || keyFile != "") {
		return errs.MissingArguments(ctx, "key_file")
	}

	// If no key and cert are provided, ca files must be provided
	if !hasKeyAndCert && len(caFiles) == 0 {
		return errors.Errorf("flag '--%s' must be provided when no <crt_path> and <key_path> are present", "ca")
	}

	// Validate flags
	switch {
	case ctx.String("password-file") != "" && ctx.Bool("no-password"):
		return errs.IncompatibleFlagWithFlag(ctx, "no-password", "password-file")
	case ctx.Bool("no-password") && !ctx.Bool("insecure"):
		return errs.RequiredInsecureFlag(ctx, "no-password")
	}

	x509CAs := []*x509.Certificate{}
	for _, caFile := range caFiles {
		x509Bundle, err := pemutil.ReadCertificateBundle(caFile)
		if err != nil {
			return errors.Wrap(err, "error reading CA certificate")
		}
		x509CAs = append(x509CAs, x509Bundle...)
	}

	var err error
	var password string
	if !ctx.Bool("no-password") {
		if passwordFile := ctx.String("password-file"); passwordFile != "" {
			password, err = utils.ReadStringPasswordFromFile(passwordFile)
			if err != nil {
				return err
			}
		}

		if password == "" {
			pass, err := ui.PromptPassword("Please enter a password to encrypt the .p12 file")
			if err != nil {
				return errors.Wrap(err, "error reading password")
			}
			password = string(pass)
		}
	}

	var pkcs12Data []byte
	if hasKeyAndCert {
		// If we have a key and certificate, we're making an identity store
		x509CertBundle, err := pemutil.ReadCertificateBundle(crtFile)
		if err != nil {
			return errors.Wrap(err, "error reading certificate")
		}

		key, err := pemutil.Read(keyFile)
		if err != nil {
			return errors.Wrap(err, "error reading key")
		}

		// The first certificate in the bundle will be our server cert
		x509Cert := x509CertBundle[0]
		// Any remaining certs will be intermediates for the server
		x509CAs = append(x509CAs, x509CertBundle[1:]...)

		pkcs12Data, err = pkcs12.Encode(rand.Reader, key, x509Cert, x509CAs, password)
		if err != nil {
			return errs.Wrap(err, "failed to encode PKCS12 data")
		}
	} else {
		// If we have only --ca flags, we're making a trust store
		var certsWithFriendlyNames []pkcs12.TrustStoreEntry
		for _, cert := range x509CAs {
			certsWithFriendlyNames = append(certsWithFriendlyNames, pkcs12.TrustStoreEntry{
				Cert:         cert,
				FriendlyName: fmt.Sprintf("%s - %s", cert.Subject.String(), x509util.Fingerprint(cert)),
			})
		}
		pkcs12Data, err = pkcs12.EncodeTrustStoreEntries(rand.Reader, certsWithFriendlyNames, password)
		if err != nil {
			return errs.Wrap(err, "failed to encode PKCS12 data")
		}
	}

	if err := utils.WriteFile(p12File, pkcs12Data, 0600); err != nil {
		return err
	}

	ui.Printf("Your .p12 bundle has been saved as %s.\n", p12File)
	return nil
}

repository: smallstep/cli

repo_name: smallstep/cli


text:
@ARTICLE{drostejiao2020,
       author = {{Droste}, Richard and {Jiao}, Jianbo and {Noble}, J. Alison},
        title = "{Unified Image and Video Saliency Modeling}",
      journal = {arXiv e-prints},
     keywords = {Computer Science - Computer Vision and Pattern Recognition, Computer Science - Machine Learning},
         year = 2020,
        month = mar,
          eid = {arXiv:2003.05477},
        pages = {arXiv:2003.05477},
archivePrefix = {arXiv},
       eprint = {2003.05477},
 primaryClass = {cs.CV}
}


text:
SUMMARY = "Hello world from OTC IoT QA"
DESCRIPTION = "test application"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"
SRC_URI = "file://hello.c \
"
S = "${WORKDIR}"
do_compile() {
    ${CC} hello.c -o hello
}
inherit native

repository: intel/intel-iot-refkit

repo_name: intel/intel-iot-refkit


text:
require linux-omap3.inc

KVER = "2.6.37"
PSPREL = "04.02.00.07"

DEFAULT_PREFERENCE_dm37x-evm = "-1"

# Use literal tags in SRCREV, when available, instead of commit IDs
SRCREV = "v2.6.37_OMAPPSP_04.02.00.07"