text:
image are difficult to interpret. Using optical remote sensing provides important physical parameters of the plantation using multispectral data acquisition. Both types of data are complementary and need to be exploited simultaneously to obtain a holistic view on the plantation. Using interferometric SAR a topographical surface and height profiles of oil palm plantations can be derived. The information is crucial in the effort of mapping the oil palms age profile in the country. With this monitored, a replanting program could be effectively installed to maximize national production. VIR remote sensing delivers information on the plants' health and stress along with other biophysical parameters. Therefore the study aims to discover a set of parameters for oil palm plantation monitoring, which are retrievable from multisensor remote sensing data. The parameters are validated through the collection of ground. It is anticipated to derive all relevant information for the oil palm industry to implement a sustainable plantation management. The workflow on the parameter extraction and information derivation is designed and optimized.},
author_keywords={Image fusion;  Palm oil;  Radar;  Remote sensing},
document_type={Conference Paper},
source={Scopus},
}

@CONFERENCE{Maltese2015,
author={Maltese, D. and Reichert, O.},
title={Maritime piracy: Design of an infrared multiple cameras system for short-range detection and targeting},
journal={Proceedings of SPIE - The International Society for Optical Engineering},
year={2015},
volume={9451},
number={January},
doi={10.1117/12.2177104},
art_number={94510A},
note={cited By 0},
url={https://www.scopus.com/inward/record.uri?eid=2-s2.0-84937239233&doi=10.1117%2f12.2177104&partnerID=40&md5=5dd9a4f891d7b629ebde11d36ff9db9e},
affiliation={Sagem Defense and Security, 100 avenue de Paris, Massy cedex, France},
abstract={Nowadays, maritime piracy turns out to be a severe threat for commercial ships, as illustrated by recent events that occurred in Gulfs of Aden and Guinea. Consequently, the design of a fully integrated shipborne self-protection system to counter this treat becomes a requirement. Today's technology allows to equip commercial ships that are sailing in high-risk areas with early detection, dissuasion and protection capabilities to face coordinated attacks from pirates in various scenarios. In this paper, a practical example of a module composed of multiple distributed COTS Infra-Red passive sensors is discussed. It is focused on a 360° close day/night surveillance system around the ship to detect and track these specific threats. The observation module presented hereafter takes advantage of Sagem experience in naval applications and infrared-based surveillance systems. The paper puts forward the detection process (image processing and 3D tracking). The module is planned to be combined with other ones (radar, AIS (Automatic Identification Systems) and electro-optics sensors suites) through a data fusion process in order to provide the ship with a continuous maritime awareness situation from long to very short ranges. The multisensor suite is part of BlueDome, a comprehensive and non-lethal anti-piracy solution developed by the Sagem-led Autoprotection consortium and recently unveiled at the Euromaritime trade show. To conclude, results of detection scenarios are provided. Data have been registered during sea trials dedicated to very short range threats. Results highlight how the module detects and tracks the threats to be targeted. They also demonstrate how module performances are improved by implementing two specific processes: track fusion and features association in tracking process (heuristics assessment). © 2015 SPIE.},
author_keywords={3D tracking;  BlueDome;  COTS passive sensors;  detection;  Maritime piracy;  track fusion},
document_type={Conference Paper},
source={Scopus},
}

@ARTICLE{Elkotb2015800,
author={Elkotb, A.S. and Huang, S.-J. and Lin, C.-C. and Doong, D.-J.},
title={Evaluating the efficiency of multisensor satellite data fusion based on the accuracy level of land cover/use classification},
journal={Journal of Marine Science and Technology (Taiwan)},
year={2015},
volume={23},
number={5},
pages={800-806},
doi={10.6119/JMST-014-1202-1},
note={cited By 0},
url={https://www.scopus.com/inward/record.uri?eid=2-s2.0-84946849255&doi=10.6119%2fJMST-014-1202-1&partnerID=40&md5=3269c8f051b0e0b8fb0ba74e440bb17d},
affiliation={Department of Marine Environmental Informatics, National Taiwan Ocean University, Keelung, Taiwan},
abstract={The term imagery fusion has been used to describe a variety of combining operations performed to increase the ground resolution of multispectral data. The objective of this study was to characterize and evaluate the impact of different pixellevel fusion methods on the accuracy level of land cover/use classification. Panchromatic FORMOSAT-2 data and multispectral SPOT-6 data were considered, and Brovey, Ehlers, and principal component analysis (PCA) algorithms were used as pixel-level fusion algorithms. The improvement in the accuracy of the fused images relative to the original images was determined. The land cover/use categories were classified into five groups by using a maximum likelihood algorithm. To verify and assess the accuracy of classification, training sites were selected for all land cover/use themes. The classification accuracy was calculated for all images by using error matrices. The greatest improvement in land cover/use classification was obtained by using the Brovey algorithm; the overall accuracy was 93.68% and the kappa coefficient was 0.9115. The next greatest improvement was obtained using the Ehlers algorithm, and the overall accuracy and kappa coefficient were 89.54% and 0.8620, respectively. Finally, the least accurate classification was obtained by using the PCA algorithm; the overall accuracy was 88.36% and the kappa coefficient was 0.8247. Comparing the fused images with the original images, the overall accuracy of 86.36% and kappa coefficient value of 0.8036, which were obtained for the original images, were used as benchmarks.},
author_keywords={Accuracy;  FORMOSAT-2;  Fusion techniques;  Land cover/use;  SPOT-6},
document_type={Article},
source={Scopus},
}

@ARTICLE{Duda2015307,
author={Duda, Z.},
title={Fusion Kalman filtration with k-step delay sharing pattern},
journal={Archives of Control Sciences},
year={2015},
volume={25},
number={3},
pages={307-318},
doi={10.1515/acsc-2015-0020},
note={cited By 3},
url={https://www.scopus.com/inward/record.uri?eid=2-s2.0-84943779494&doi=10.1515%2facsc-2015-0020&partnerID=40&md5=12655edf2d0f4999a6bb0e2a84c2286f},
affiliation={Institute of Automatic Control, Silesian Technical University, ul. Akademicka 16, Gliwice, Poland},
abstract={A fusion hierarchical state filtration with k-step delay sharing pattern for a multisensor system is considered. A global state estimate depends on local state estimates determined by local nodes using local information. Local available information consists of local measurements and k-step delay global information - global estimate sent from a central node. Local estimates are transmitted to the central node to be fused. The synthesis of local and global filters is presented. It is shown that a fusion filtration with k-step delay sharing pattern is equivalent to the optimal centralized classical Kalman filtration when local measurements are transmitted to the center node and used to determine a global state estimate. It is proved that the k-step delay sharing pattern can reduce covariances of local state errors. © Archives of Control Sciences 2015.},
author_keywords={fusion Kalman filtration;  k- step delay sharing pattern;  multisensor system},
document_type={Article},
source={Scopus},
}

@CONFERENCE{Lai2015149,
author={Lai, T. and Wang, G. and Zhu, W. and Gao, F. and Qiao, Z.},
title={An online error correction method based on odometer and MIMU},
journal={Structural Health Monitoring and Integrity Management - Proceeding of the 2nd International Conference of Structural Health Monitoring and Integrity Management, ICSHMIM 2014},
year={2015},
pages={149-152},
note={cited By 0},
url={https://www.scopus.com/inward/record.uri?eid=2-s2.0-84949740853&partnerID=40&md5=7002cc399ce1b96ce7f07494b948675b},
affiliation={Nanotechnology and Microsystems Laboratory, College of Mechanical Engineering, Shi Jiazhuang, China},
abstract={Micro Inertial Measurement Unit (MIMU) integration storage test system is a typical multisensor information fusion system consisting of microsensors, gyroscope, and integrated circuit. Its main error source is accelerometer. An online method was proposed for correcting the major state parameters combining odometer and MIMU to achieve completely independent and rapid attitude determination. The error mathematical model has been derived, and the simulation results show that the odometer’s accuracy met the requirements of solver speed to correct the MIMU major state parameters. The feasibility of this method is verified by experiments, and it can effectively correct MIMU inertia error. © 2015 Taylor & Francis Group, London.},
document_type={Conference Paper},
source={Scopus},
}

@CONFERENCE{Tao20154877,
author={Tao, G.a  and Liu, W.a  and Zhang, J.a  and Qi, W.b  and Xu, H.b },
title={Optimal and self-tuning information fusion Kalman filter with complex colored noise},
journal={Chinese Control Conference, CCC},
year={2015},
volume={2015-September},
pages={4877-4881},
doi={10.1109/ChiCC.2015.7260396},
art_number={7260396},
note={cited By 0},
url={https://www.scopus.com/inward/record.uri?eid=2-s2.0-84946593737&doi=10.1109%2fChiCC.2015.7260396&partnerID=40&md5=2bb83252ff4d0fbb4667f34ba98e6418},
affiliation={Computer and Information Engineering College, Heilongjiang University of Science and Technology, Harbin, China; Heilongjiang University, Harbin, China},
abstract={For the multisensor systems with complex colored noise, using the modern time series analysis, a steady-state optimal and self-tuning Kalman filter weighted by scalars is presented. State augmentation and measurement transformation methods are applied to transform the colored process noise and colored observation noises into white noises. So these problems are transformed to Kalman prediction problems of normal systems with correlated white noises. A steady-state Kalman predictor with complex colored noises is derived on the basis of linear minimum mean square error estimation and fusion criterion weighted by scalars. Then, the filter for original system with colored noises is derived. The precision of the weighted fusion filter is higher than that of the local Kalman filter for every sensor. When the white noise variances are unknown, a self-tuning information fusion Kalman filter weighted by scalars is obtained. A simulation example proves the effectiveness and feasibility of the filtering fusion algorithm. © 2015 Technical Committee on Control Theory, Chinese Association of Automation.},
author_keywords={colored noises;  Multisensor information fusion;  Noise variance estimation;  Self-tuning fusion Kalman filter},
document_type={Conference Paper},
source={Scopus},
}

@CONFERENCE{Detchev201580,
author={Detchev, I.a  and Habib, A.b  and Mazaheri, M.a  and Melia, A.c },
title={Long term stability analysis for a multi-camera photogrammetric system},
journal={Imaging and Geospatial Technology Forum, IGTF 2015 - ASPRS Annual Conference and co-located JACIE Workshop},
year={2015},
pages={80-85},
note={cited By 0},
url={https://www.scopus.com/inward/record.uri?eid=2-s2.0-84943526983&partnerID=40&md5=f61d0adff710c1cda17f23da18ce28d2},
affiliation={Department of Geomatics Engineering, University of Calgary, 2500 University Drive NW, Calgary, AB, Canada; Lyles School of Civil Engineering, Purdue University, 550 Stadium Mall Drive, West Lafayette, IN, United States; Department of Mechanical and Manufacturing Engineering, University of Calgary, 2500 University Drive NW, Calgary, AB, Canada},
abstract={Multi-camera photogrammetric systems used in applications such as mobile mapping, vision-aided navigation, biomedical sciences and infrastructure health monitoring have become widespread with the falling cost of solid state sensors and the off-the-shelf availability of digital cameras. These photogrammetric systems require a system calibration, i.e., calibration for both the interior orientation parameters of each camera, and the mounting parameters of each camera with respect to a body frame or a reference camera. The frequency of the system calibration depends on the build quality and on any external factors such as the working environment and the handling of the system components. Since these systems include consumer grade components, which are not necessarily built for engineering applications, the frequency of calibration must be investigated as to avoid extra labour, but at the same time preserve the desired level of precision. This investigation can be achieved through a system stability analysis, where the effects of any changes in the interior or mounting parameters are quantified and compared to a threshold. This paper describes a multi-camera photogrammetric system built for a biomedical application and used in a hospital setting. The system description includes the plausible factors that might cause system instability from one calibration session to another. The system was calibrated (bi-)weekly for the duration of six months. This long term stability analysis data will be analysed in order to decide if the calibration frequency was adequate and also to consult on improving the stability of future system prototypes.},
author_keywords={Digital close range photogrammetry;  Geometric system calibration;  Multisensor systems;  System stability analysis},
document_type={Conference Paper},
source={Scopus},
}

@CONFERENCE{Huan2015476,
author={Huan, W. and Jinping, S.},
title={Sparse representation based distributed multisensor track fusion},
journal={Proceedings - 2015 2nd International Conference on Information Science and Control Engineering, ICISCE 2015},
year={2015},
pages={476-479},
doi={10.1109/ICISCE.2015.110},
art_number={7120650},
note={cited By 0},
url={https://www.scopus.com/inward/record.uri?eid=2-s2.0-84938801726&doi=10.1109%2fICISCE.2015.110&partnerID=40&md5=1cf90b967ac599f4a208903c2ed31f28},
affiliation={School of Electronic and Information Engineering, Beihang University, Beijing, China},
abstract={In the distributed multisensory information fusion system, each local sensor independently forms local tracks, and multisensory track fusion refers to fusing multiple local tracks that represent the same target into one global track. By studying the theory of multisensory track fusion and signal sparse representation, a sparse representation based multisensory track fusion algorithm is proposed. This new algorithm first obtains a noisy dictionary and a noise-free dictionary by sample tracks. At each scan, the state vectors of local tracks from the same target are rewritten as a vector, and then the sparse representation coefficients of the vector in noisy dictionary are computed. At last, the global state vector at this scan is obtained by the sparse representation coefficients and noise-free dictionary. Simulation results illustrate that the fusion results of the new algorithm are better than that of Linear Minimum Mean-Square Error (LMMSE). © 2015 IEEE.},
author_keywords={Distributed;  Multisensor;  Sparse representation;  Track fusion},
document_type={Conference Paper},
source={Scopus},
}

@ARTICLE{Wang20151900,
author={Wang, X.-M.a  b  and Liu, W.-Q.a  and Deng, Z.-L.a },
title={Robust Covariance Intersection fusion steady-state Kalman filter for uncertain systems},
journal={Dianzi Yu Xinxi Xuebao/Journal of Electronics and Information Technology},
year={2015},
volume={37},
number={8},
pages={1900-1905},
doi={10.11999/JEIT141515},
note={cited By 3},
url={https://www.scopus.com/inward/record.uri?eid=2-s2.0-84939505644&doi=10.11999%2fJEIT141515&partnerID=40&md5=31c39fbf3d8b730ce04aa1f1259ca2ec},
affiliation={Electronic Engineering College, Heilongjiang University, Harbin, China; Department of Computer Science and Technology, Heilongjiang Technology and Business College, Harbin, China},
abstract={For the linear discrete time multisensor system with uncertain model parameters and noise variances, a Covariance Intersection (CI) fusion robust steady-state Kalman filter based on the minimax robust estimation principle is presented. Firstly, introducing the fictitious noise, the model parameter uncertainty can be compensated, so the multisensory system with both the model parameter and noise variance uncertainties is converted into that with only uncertain noise variances. Secondly, using the Lyapunov equation, the robustness of the local robust Kalman filter is proved, so the robustness of the CI fused Kalman filter is guaranteed and it is proved that the robust accuracy of the CI fuser is higher than that of each local filter. Finally, a simulation example shows that how to search the robust region of uncertain parameters and shows the good performance of the proposed robust Kalman filter. ©, 2015, Science Press. All right reserved.},
author_keywords={Covariance Intersection (CI) fusion;  Fictitious noise;  Multisensor information fusion;  Robust Kalman filter;  Uuncertain system},
document_type={Article},
source={Scopus},
}

@CONFERENCE{Chen201573,
author={Chen, Q.P. and Lin, C.C. and Lin, H. and Guo, M. and Zhang, X.L. and Zhu, S.S.},
title={Fuzzy association algorithm and computer simulation of target’s information from radar and AIS},
journal={Multimedia, Communication and Computing Application - Proceedings of the International Conference on Multimedia, Communication and Computing Application, MCCA 2014},
year={2015},
pages={73-76},
note={cited By 0},
url={https://www.scopus.com/inward/record.uri?eid=2-s2.0-84949816946&partnerID=40&md5=eae0bc3a5f0a035c10f2d819565cdf48},
affiliation={Navigation Technology Institute of Jimei University, Xiamen, China},
abstract={Marine radar and AIS (Automatic Identification System) all can acquire the target’s information at sea, including the ship’s position, course, speed, and so on. However, they have some different characteristics. Therefore, it is very important to fuse the target’s information to get the predominance. Based on the theory of multisensor information fusion, it studies on the association algorithm of the target’s information from the two sensors by using multifactor fuzzy integration decision making. The mathematical models are established, including the fuzzy factor sets, membership degree, and judgment rules, and conducted the computer simulation. The results show that the algorithm can greatly improve the accuracy and reliability of the target information. It researches and discusses the relation between the association probability and the threshold. © 2015 Taylor & Francis Group, London.},
document_type={Conference Paper},
source={Scopus},
}

@CONFERENCE{Qiu20153682,
author={Qiu, G. and Bao, J.},
title={Deflection coefficient maximization based cooperative multi-sensor feature extraction for fault diagnosis},
journal={Proceedings of the 2015 27th Chinese Control and Decision Conference, CCDC 2015},
year={2015},
pages={3682-3686},
doi={10.1109/CCDC.2015.7162565},
art_number={7162565},
note={cited By 0},
url={https://www.scopus.com/inward/record.uri?eid=2-s2.0-84945542182&doi=10.1109%2fCCDC.2015.7162565&partnerID=40&md5=12f62a1f066f1b351caa71bfb8bc353d},
affiliation={Laboratory of Intelligent Instrument, Industrial Automation and Testing Technology, CQUPT, Chongqing, China},
abstract={In this paper we address two feature extraction approaches schemes, namely the maximum eigen-vector based algorithm (Max-EV) and the multiple eigen-vector (Mul-EV) based algorithm. They serve to detect the state characteristic parameters over rotating machinery using multi-sensor. A fusion centre (FC) is operating to collect the raw observations data from the multisensor in the network and make the final decisions over the information fusion. The optimal weights of the proposed multi-sensor feature information sensing methods are the multiple eigenvectors of the signal sample autocorrelation matrix or the maximum eigenvector. The proposed algorithms demand no a prior knowledge of the noise power and the mechanical signal. Theoretical analysis and simulation results show the proposed methods are robust against the noise power uncertainty and require less sensing data to yield the same performance, compared with the conventional feature extraction methods. © 2015 IEEE.},
author_keywords={Feature Extraction;  Maximum eigenvector;  Multi-sensor;  Multiple eigenvector},
document_type={Conference Paper},
source={Scopus},
}

license_type: permissive

extension: bib


text:
SUMMARY = "Tool Command Language ToolKit Extension"
HOMEPAGE = "http://tcl.sourceforge.net"
SECTION = "devel/tcltk"

# http://www.tcl.tk/software/tcltk/license.html
LICENSE = "TCL"
LIC_FILES_CHKSUM = "file://${S}/../license.terms;md5=c88f99decec11afa967ad33d314f87fe \
    file://${S}/../compat/license.terms;md5=c88f99decec11afa967ad33d314f87fe \
    file://${S}/../doc/license.terms;md5=c88f99decec11afa967ad33d314f87fe \
    file://${S}/../library/license.terms;md5=c88f99decec11afa967ad33d314f87fe \
    file://${S}/../macosx/license.terms;md5=c88f99decec11afa967ad33d314f87fe \
    file://${S}/../tests/license.terms;md5=c88f99decec11afa967ad33d314f87fe \
    file://${S}/../unix/license.terms;md5=c88f99decec11afa967ad33d314f87fe \
    file://${S}/../win/license.terms;md5=c88f99decec11afa967ad33d314f87fe \
    file://${S}/../xlib/license.terms;md5=c88f99decec11afa967ad33d314f87fe \
"

DEPENDS = "tcl virtual/libx11 libxt"

SRC_URI = "\
    ${SOURCEFORGE_MIRROR}/tcl/${BPN}${PV}-src.tar.gz \
    file://confsearch.diff;striplevel=2 \
    file://tkprivate.diff;striplevel=2 \
    file://fix-xft.diff \
"
SRC_URI[md5sum] = "602a47ad9ecac7bf655ada729d140a94"
SRC_URI[sha256sum] = "63df418a859d0a463347f95ded5cd88a3dd3aaa1ceecaeee362194bc30f3e386"

S = "${WORKDIR}/${BPN}${PV}/unix"

PSEUDO_IGNORE_PATHS .= ",${WORKDIR}/${BPN}${PV}"

# Short version format: "8.6"
VER = "${@os.path.splitext(d.getVar('PV'))[0]}"

LDFLAGS += "-Wl,-rpath,${libdir}/tcltk/${PV}/lib"
inherit autotools features_check pkgconfig
# depends on virtual/libx11
REQUIRED_DISTRO_FEATURES = "x11"

EXTRA_OECONF = "\
    --enable-threads \
    --with-x \
    --with-tcl=${STAGING_BINDIR}/crossscripts \
    --libdir=${libdir} \
"
export TK_LIBRARY='${libdir}/tk${VER}'
do_install:append() {
    ln -sf libtk${VER}.so ${D}${libdir}/libtk${VER}.so.0
    oe_libinstall -so libtk${VER} ${D}${libdir}
    ln -sf wish${VER} ${D}${bindir}/wish

    sed -i "s;-L${B};-L${STAGING_LIBDIR};g" tkConfig.sh
    sed -i "s;'${WORKDIR};'${STAGING_INCDIR};g" tkConfig.sh
    install -d ${D}${bindir_crossscripts}
    install -m 0755 tkConfig.sh ${D}${bindir_crossscripts}
}

PACKAGECONFIG ??= "xft"
PACKAGECONFIG[xft] = "--enable-xft,--disable-xft,xft"
PACKAGECONFIG[xss] = "--enable-xss,--disable-xss,libxscrnsaver libxext"

PACKAGES =+ "${PN}-lib"

FILES:${PN}-lib = "${libdir}/libtk${VER}.so*"
FILES:${PN} += "${libdir}/tk*"

# isn't getting picked up by shlibs code
RDEPENDS:${PN} += "tk-lib"
RDEPENDS:${PN}:class-native = ""

BBCLASSEXTEND = "native nativesdk"

# Fix the path in sstate
SSTATE_SCAN_FILES += "*Config.sh"

inherit binconfig

SYSROOT_DIRS += "${bindir_crossscripts}"

# Fix some paths that might be used by Tcl extensions
BINCONFIG_GLOB = "*Config.sh"

# Cleanup host path from ${libdir}/tclConfig.sh and remove the
# ${bindir_crossscripts}/tclConfig.sh from target
PACKAGE_PREPROCESS_FUNCS += "tcl_package_preprocess"
tcl_package_preprocess() {
        sed -i -e "s;${DEBUG_PREFIX_MAP};;g" \
               -e "s;-L${STAGING_LIBDIR};-L${libdir};g" \
               -e "s;${STAGING_INCDIR};${includedir};g" \
               -e "s;--sysroot=${RECIPE_SYSROOT};;g" \
               ${PKGD}${libdir}/tkConfig.sh

        rm -f ${PKGD}${bindir_crossscripts}/tkConfig.sh
}

license: MIT

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded

branch_name: refs/heads/master

gha_license_id: MIT

gha_language: BitBake

extension: bb


text:
SUMMARY = "Chassis Power Control service for Intel based platforms"
DESCRIPTION = "Chassis Power Control service for Intel based platforms"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=86d3f3a95c324c9479bd8986968f4327"
SRCREV = "2ae5308d69f1bac6b82f6918780fefb0f869aad5"
PV = "1.0+git${SRCPV}"

SRC_URI = "git://github.com/openbmc/x86-power-control.git;protocol=https;branch=master"

S = "${WORKDIR}/git"

inherit meson systemd pkgconfig
inherit obmc-phosphor-dbus-service

SYSTEMD_SERVICE:${PN} += "chassis-system-reset.service \
                         chassis-system-reset.target"
DEPENDS += " \
    boost \
    i2c-tools \
    libgpiod \
    nlohmann-json \
    sdbusplus \
    phosphor-logging \
  "
FILES:${PN}  += "${systemd_system_unitdir}/xyz.openbmc_project.Chassis.Control.Power@.service"

pkg_postinst:${PN}:append() {
    mkdir -p $D$systemd_system_unitdir/sysinit.target.wants
    for i in ${OBMC_HOST_INSTANCES};
    do
        LINK="$D$systemd_system_unitdir/sysinit.target.wants/xyz.openbmc_project.Chassis.Control.Power@${i}.service"
        TARGET="../xyz.openbmc_project.Chassis.Control.Power@.service"
        ln -s $TARGET $LINK
    done
}

pkg_prerm:${PN}:append() {
    for i in ${OBMC_HOST_INSTANCES};
    do
        LINK="$D$systemd_system_unitdir/sysinit.target.requires/xyz.openbmc_project.Chassis.Control.Power@${i}.service"
        rm $LINK
    done
}

repository: openbmc/openbmc

repo_name: openbmc/openbmc

gha_license_id: NOASSERTION

gha_language: Python


text:
@InProceedings{2022_jds_batardiere,
  author = 	 {Batardière, B. and Chiquet, J. and Kwon, J. and Sansonnet, L.},
  title = 	 {Multivariate Poisson Lognormal model: optimisation, inference
and application to high dimensional data},
  booktitle = {actes des 51$\ieme$ journées françaises de statistique, Saclay},
  year = 	 {2022},
}

@InProceedings{2019_jds_tabouy,
  author = 	 {Tabouy, T. and Barbillon, P. and Chiquet, J.},
  title = 	 {Inférence Variationnelle du Modèle à Blocs
                  Stochastiques (SBM) avec covariables en présence de
                  données manquantes},
  booktitle = {actes des 51$\ieme$ journées françaises de statistique, Saclay},
  year = 	 {2019},
}

@InProceedings{conf_jds_18a,
  author = 	 {Tabouy, T. and Barbillon, P. and Chiquet, J.},
  title = 	 {Identifiabilité du modèle à Blocs Stochastiques en
                  présence de données manquantes},
  booktitle = {actes des 50$\ieme$ journées françaises de statistique, Saclay},
  year = 	 {2018},
}

@InProceedings{conf_jds_18b,
  author = 	 {Perrot, M. and Lévy-Leduc, C. and Chiquet, J. and Sansonnet, L.},
  title = 	 {Sélection de variables dans le modèle linéaire
                  multivarié en grande dimension avec prise en compte
                  de la dépendance},
  booktitle = {actes des 50$\ieme$ journées françaises de statistique, Saclay},
  year = 	 {2018},
}

@InProceedings{conf_jds_18c,
  author = 	 {Sundqvist, M. and Chiquet, J. and de Koning, L. and
                  Dubois, T. and Rigaill, G.},
  title = 	 {Cluster stability for more robust classification in
                  Triple-Negative Breast Cancer},
  booktitle = {actes des 50$\ieme$ journées françaises de statistique, Saclay},
  year = 	 {2018},
}

@InProceedings{conf_jds_18d,
  author = 	 {Hulot, A. and Chiquet, J. and Jaffrezic, F. and Rigaill, G.},
  title = 	 {Fused-ANOVA: une méthode de clustering en grande dimension},
  booktitle = {actes des 50$\ieme$ journées françaises de statistique, Saclay},
  year = 	 {2018},
}

@InProceedings{conf_jds_18e,
  author = 	 {Guinot, F. and Szafranzki, M. and Chiquet, J. and Ambroise, C.},
  title = 	 {Une approche hiérarchique de la recherche
                  d'interactions entre données omiques},
  booktitle = {actes des 50$\ieme$ journées françaises de statistique, Saclay},
  year = 	 {2018},
}

@InProceedings{conf_jds_17a,
  author = 	 {Tabouy, T. and Barbillon, P. and Chiquet, J.},
  title = 	 {Inférence du Modèle à Blocs Stochastiques en présence de données manquantes},
  booktitle = {actes des 49$\ieme$ journées françaises de statistique, Avignon},
  year = 	 {2017},
}

@InProceedings{conf_jds_17b,
  author = 	 {Perrot-Dockes, M. and Lévy-Leduc, C. and Chiquet, J. and Sansonnet, L.},
  title = 	 {Modèle linéaire multivarié parcimonieux avec estimation de covariance : une application à des données de métabolomique},
  booktitle = {actes des 49$\ieme$ journées françaises de statistique, Avignon},
  year = 	 {2017},
}

@InProceedings{conf_jds_17c,
  author = 	 {Étienne, M.-P. and Chiquet, J. and Donnet, S. and Samson, A.},
  title = 	 {Méthode conjointe de segmentation-classification pour des modèles d'écologie du déplacement},
  booktitle = {actes des 49$\ieme$ journées françaises de statistique, Avignon},
  year = 	 {2016},
}

@InProceedings{conf_jds_16,
  author = 	 {Brault, V. and Chiquet, J. and Lévy-Leduc, C.},
  title = 	 {Détection rapide des frontières des blocs d'une matrice constante par blocs bruitée},
  booktitle = {actes des 48$\ieme$ journées françaises de statistique, Montpellier},
  year = 	 {2016},
}

@InProceedings{conf_jds_15a,
  author = 	 {Mary-Huard, T. and Chiquet, J. and Célisse, A. and
                  Fuchs, M.},
  title = 	 {Formule   exacte  pour   la  validation
    croisée dans le cadre de la régression ``pool-sample''},
  booktitle = {actes des 47$\ieme$ journées françaises de statistique, Lille},
  year = 	 {2015},
}

@InProceedings{conf_jds_15b,
  author = 	 {Mattei, Pierre-Alexandre and Latouche, Pierre and
                  Bouveyron, Charles and Chiquet, Julien},
  title = 	 {Une relaxation continue du rasoir d'{Occam} pour la
                  régression en grande dimension},
  booktitle = {actes des 47$\ieme$ journées françaises de statistique, Lille},
  year = 	 {2015},
}

@InProceedings{conf_jds_14,
  author = 	 {Chiquet, J. and Mary-Huard, T. and Robin, S.},
  title = 	 {Inférence jointe de la structure de modèles
                  graphiques gaussiens},
  booktitle = {actes des 46$\ieme$ journées françaises de statistique, Rennes},
  year = 	 {2014},
}

@InProceedings{conf_jobim_12,
  author = 	 {Plassais, J. and Chiquet, J. and Cervino, A. and Ambroise, C.},
  title = 	 {A comparison of two statistical methods combining
                  high-throughput data to predict the level of disease
                  activity in patients with Rheumatoid Arthritis},
  booktitle = {JOBIM'12, Rennes},
  year = 	 {2012},
}

@InProceedings{conf_cap_10,
  author = 	 {Grandvalet, Y. and Chiquet, J. and Ambroise, C.},
  title = 	 {Inférence jointe de la structure de modèles
                  graphiques gaussiens},
  booktitle = {actes de CAp'10, Clermont-Ferrand},
  year = 	 {2010},
}

@InProceedings{conf_modgraph_10,
  author = 	 {Charbonnier, C. and Chiquet, J. and Ambroise, C.},
  title = 	 {Weighted-Lasso for Structured Network Inference for
                  Time-Course data},
  booktitle = {JOBIM'10, Montpellier},
  year = 	 {2010},
}

@InProceedings{conf_jobim_10,
  author = 	 {Chiquet, J. and Grandvalet, Y. and Ambroise, C.},
  title = 	 {Inferring Multiple Graphical Structures},
  booktitle = {Workshop MODGRAPHII, JOBIM'10, Montpellier},
  year = 	 {2010},
}

@InProceedings{conf_modgraph_09,
  author = 	 {Chiquet, J. and Charbonnier, C. and Ambroise, C.},
  title = 	 {{SIMoNe : Statistical Inference for Modular Networks}},
  booktitle = {Workshop MODGRAPH, JOBIM'09, Nantes},
  year = 	 {2009},
}

@InProceedings{conf_cfm_05a,
  author = 	 {Chiquet, J. and Limnios, N. and Eid, M.},
  title = 	 {Processus markoviens de saut dans les équations
                  différentielles stochastiques appliquées à la
                  modélisation de la fatigue des matériaux},
  booktitle = {Congrès Français de Mécanique'05, Troyes},
  year = 	 {2005},
}

@InProceedings{conf_cfm_05b,
  author = 	 {Chiquet, J. and Limnios, N. and Yurizin, T. and Eid, M.},
  title = 	 {Modèle stochastique de taille critique de fissure
                  dans les structures soumises au vieillissement par
                  irradiation},
  booktitle = {Congrès Français de Mécanique'05, Troyes},
  year = 	 {2005},
}


text:
package utils

import (
	"errors"
	"math/rand"
	"strconv"
	"strings"
	"time"
)

var MinMaxError = errors.New("Min cannot be greater than max.")
var Char_Buff = [26]string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
	"t", "u", "v", "w", "x", "y", "z"}

func RandChoice(choices []interface{}) (interface{}, error) {
	var winner interface{}
	length := len(choices)
	i, err := IntRange(0, length)
	if err != nil {
		return nil, err
	}
	winner = choices[i]
	return winner, nil
}

func IntRange(min, max int) (int, error) {
	var result int
	switch {
	case min > max:
		return result, MinMaxError
	case min == max:
		result = max
	case min < max:
		rand.Seed(time.Now().UnixNano())
		result = min + rand.Intn(max-min)
	}
	return result, nil
}

func RandCode(codelen int) string {
	if codelen == 0 {
		return ""
	}
	numLen := rand.Intn(codelen)
	charLen := codelen - numLen
	var buff string
	for i := 0; i < numLen; i++ {
		buff = buff + strconv.Itoa(rand.Intn(10))
	}
	for i := 0; i < charLen; i++ {
		buff = buff + Char_Buff[rand.Intn(26)]
	}
	var code string
	arr := rand.Perm(codelen)
	for i := 0; i < 6; i++ {
		code = code + string(buff[arr[i]])
	}
	return strings.ToUpper(code)
}
func RandNumCode(codelen int) string {
	if codelen == 0 {
		return ""
	}
	var buff string
	for i := 0; i < codelen; i++ {
		buff = buff + strconv.Itoa(rand.Intn(10))
	}
	return strings.ToUpper(buff)
}

repository: konser/go-pack

repo_name: konser/go-pack

extension: go


text:
SUMMARY = "Linux-based partitioning hypervisor"
DESCRIPTION = "Jailhouse is a partitioning Hypervisor based on Linux. It is able to run bare-metal applications or (adapted) \
operating systems besides Linux. For this purpose, it configures CPU and device virtualization features of the hardware \
platform in a way that none of these domains, called 'cells' here, can interfere with each other in an unacceptable way."
HOMEPAGE = "https://github.com/siemens/jailhouse"
SECTION = "jailhouse"
LICENSE = "GPL-2.0 & BSD-2-Clause"

LIC_FILES_CHKSUM = " \
    file://COPYING;md5=9fa7f895f96bde2d47fd5b7d95b6ba4d \
"

SRCREV = "4ce7658dddfd5a1682a379d5ac46657e93fe1ff0"
PV = "0.12+git${SRCPV}"

FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"

SRC_URI = "git://github.com/siemens/jailhouse \
           file://0001-configs-arm64-Add-support-for-RPi4-with-more-than-1G.patch \
           "

DEPENDS = "virtual/kernel dtc-native python3-mako-native make-native"

require jailhouse-arch.inc
inherit module python3native bash-completion setuptools3

S = "${WORKDIR}/git"
B = "${S}"

JH_DATADIR ?= "${datadir}/jailhouse"
JH_EXEC_DIR ?= "${libexecdir}/jailhouse"
CELL_DIR ?= "${JH_DATADIR}/cells"
INMATES_DIR ?= "${JH_DATADIR}/inmates"
DTS_DIR ?= "${JH_DATADIR}/cells/dts"

JH_CELL_FILES ?= "*.cell"

EXTRA_OEMAKE = "ARCH=${JH_ARCH} CROSS_COMPILE=${TARGET_PREFIX} CC="${CC}" KDIR=${STAGING_KERNEL_BUILDDIR}"

do_configure() {
	sed -i '1s|^#!/usr/bin/env python$|#!/usr/bin/env python3|' ${B}/tools/${BPN}-*
}

do_compile() {
	oe_runmake
}

do_install() {
	# Install pyjailhouse python modules needed by the tools
	distutils3_do_install

	# We want to install the python tools, but we do not want to use pip...
	# At least with v0.10, we can work around this with
	# 'PIP=":" PYTHON_PIP_USEABLE=yes'
	oe_runmake PIP=: PYTHON=python3 PYTHON_PIP_USEABLE=yes DESTDIR=${D} install

	install -d ${D}${CELL_DIR}
	install -m 0644 ${B}/configs/${JH_ARCH}/${JH_CELL_FILES} ${D}${CELL_DIR}/

	install -d ${D}${INMATES_DIR}
	install -m 0644 ${B}/inmates/demos/${JH_ARCH}/*.bin ${D}${INMATES_DIR}

	if [ ${JH_ARCH}  != "x86" ]; then
		install -d ${D}${DTS_DIR}
		install -m 0644 ${B}/configs/${JH_ARCH}/dts/*.dtb ${D}${DTS_DIR}
	fi
}

PACKAGE_BEFORE_PN = "kernel-module-jailhouse pyjailhouse ${PN}-tools ${PN}-demos"
FILES_${PN} = "${base_libdir}/firmware ${libexecdir} ${sbindir} ${JH_DATADIR}"
FILES_pyjailhouse = "${PYTHON_SITEPACKAGES_DIR}"
FILES_${PN}-tools = "${libexecdir}/${BPN}/${BPN}-* ${JH_DATADIR}/*.tmpl"
FILES_${PN}-demos = "${JH_DATADIR}/ ${sbindir}/ivshmem-demo"

RDEPENDS_${PN}-tools = "pyjailhouse python3-mmap python3-math python3-datetime python3-curses python3-compression python3-mako"
RDEPENDS_pyjailhouse = "python3-core python3-ctypes python3-fcntl"
RDEPENDS_${PN}-demos = "jailhouse"

RRECOMMENDS_${PN} = "${PN}-tools"

KERNEL_MODULE_AUTOLOAD += "jailhouse"

repository: Limoto/meta-jailhouse

repo_name: Limoto/meta-jailhouse


text:
@article{ye2021urban,
 abstract = {Recognizing urban functions is crucial for understanding urban spatial structures and urban planning. Previous work has investigated urban functions based on human activities that were derived from mobile phone positioning data, check-in data, taxi data, etc. However, urban functions can only be comprehensively sensed from both human activities and the physical environment together. To do so, a deep learning method was proposed to predict urban functions by integrating social media data and street-level imagery. The verbs extracted from social media posts were taken as the proxy for human activities, and we identified urban physical environmental information from street-level imagery. Then urban functions were uncovered from both the verbs in terms of human activities and street-level imagery from the perspective of the physical environment. Twelve types of urban function were recognized by verbs in social media posts, which were then improved by integrating street-level imagery within the 5th Ring Road of Beijing, China. The experiment demonstrated that verbs as direct proxies for human activities can avoid noise, and the multi-source data integration eliminated biases caused by a single data source. This work provides a comprehensive understanding of urban structure and dynamics for urban management and planning.},
 annotation = {00012},
 author = {Ye, Chao and Zhang, Fan and Mu, Lan and Gao, Yong and Liu, Yu},
 doi = {10.1177/2399808320935467},
 issn = {2399-8083},
 journal = {Environment and Planning B: Urban Analytics and City Science},
 keywords = {deep neural network,social media,street-level imagery,Urban function},
 language = {en},
 month = {July},
 number = {6},
 pages = {1430--1444},
 publisher = {SAGE Publications Ltd STM},
 title = {Urban Function Recognition by Integrating Social Media and Street-Level Imagery},
 volume = {48},
 year = {2021}
}

branch_name: refs/heads/main


text:
SUMMARY = "GNSSTk C++ Library"
DESCRIPTION = "The goal of the gnsstk project is to provide an open source library to the satellite navigation community--to free researchers to focus on research, not lower level coding."
AUTHOR = "ARL:UT"
HOMEPAGE = "https://github.com/SGL-UT/gnsstk"
PR = "r0"

LICENSE = "LGPL-3.0-only"
LIC_FILES_CHKSUM = "file://COPYING.md;md5=d32239bcb673463ab874e80d47fae504"

GIT_BRANCH = "stable"
SRC_URI = "git://github.com/SGL-UT/gnsstk.git;branch=${GIT_BRANCH};protocol=https"
SRCREV = "90eb02cd63c342e01c375dfc0fca8cecdf91162e"
S = "${WORKDIR}/git"
RDEPENDS:${PN} = "bash"
inherit cmake

EXTRA_OECMAKE += " -DCMAKE_SKIP_INSTALL_RPATH=ON -DCMAKE_SKIP_RPATH=ON -DUSE_RPATH=OFF -DBUILD_EXT=ON -DBUILD_PYTHON=OFF"

PACKAGES = "gnsstk gnsstk-dev gnsstk-dbg"

FILES:${PN} += " ${bindir}/* "
FILES:${PN}-dev += " ${includedir}/* ${libdir}/* /usr/share/cmake/*"
FILES:${PN}-dbg += " \
     ${prefix}/src/debug/gnsstk/* \
     ${bindir}/.debug/* \
"

repository: carlesfernandez/meta-gnss-sdr

repo_name: carlesfernandez/meta-gnss-sdr

gha_language: C


text:
package funcs

import (
	"encoding/base64"
	"fmt"
	"os"
	"time"

	"github.com/sacloud/usacloud/command"
	"github.com/sacloud/usacloud/command/internal"
	"github.com/sacloud/usacloud/command/params"
)

func ServerVncSnapshot(ctx command.Context, params *params.VncSnapshotServerParam) error {

	client := ctx.GetAPIClient()
	api := client.GetServerAPI()
	p, e := api.Read(params.Id)
	if e != nil {
		return fmt.Errorf("ServerVncSnapshot is failed: %s", e)
	}
	if !p.IsUp() {
		return fmt.Errorf("ServerVncSnapshot is failed: %s", "server is not running")
	}

	if !p.IsUp() && params.WaitForBoot {

		err := internal.ExecWithProgress(
			fmt.Sprintf("Still booting[ID:%d]...", params.Id),
			fmt.Sprintf("Connect to server[ID:%d]", params.Id),
			command.GlobalOption.Progress,
			func(compChan chan bool, errChan chan error) {
				// call manipurate functions
				err := api.SleepUntilUp(params.Id, client.DefaultTimeoutDuration)
				if err != nil {
					errChan <- err
					return
				}
				compChan <- true
			},
		)
		if err != nil {
			return fmt.Errorf("ServerVncSnapshot is failed: %s", e)
		}
	}

	snapshotReq := api.NewVNCSnapshotRequest()
	vncSnapshotResponse, err := api.GetVNCSnapshot(params.Id, snapshotReq)
	if err != nil {
		return fmt.Errorf("ServerVncSnapshot is failed: %s", err)
	}
	vncImage, err := base64.StdEncoding.DecodeString(vncSnapshotResponse.Image)
	if err != nil {
		return fmt.Errorf("ServerVncSnapshot is failed: %s", err)
	}

	var filename string
	if len(params.OutputPath) > 0 {
		filename = params.OutputPath
	} else {
		filename = fmt.Sprintf("%d_%s.gif", params.Id, time.Now().Format("20060102-150405"))
	}
	file, err := os.Create(filename)
	if err != nil {
		return fmt.Errorf("ServerVncSnapshot is failed: %s", err)
	}
	defer file.Close()

	_, err = file.Write(vncImage)
	if err != nil {
		return fmt.Errorf("ServerVncSnapshot is failed: %s", err)
	}

	out := command.GlobalOption.Err
	fmt.Fprintln(out, "Snapshot created:", filename)

	return nil
}


text:
require sofia-sip.inc

PR = "r2"

SRC_URI[archive.md5sum] = "09d027ee9817cc1a1b8c0e96271bade4"
SRC_URI[archive.sha256sum] = "328531d0f522a207a9721223c92b823643af5c82e5958fc5e9c945ea36ddafd6"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
class IndecisiveApp extends React.Component {

    constructor(props) {
        super(props);
        this.handleRemoveOptions = this.handleRemoveOptions.bind(this);
        this.handleRemoveOption = this.handleRemoveOption.bind(this);
        this.handlePickOption = this.handlePickOption.bind(this);
        this.handleAddOption = this.handleAddOption.bind(this);

        this.state = {
            options: props.options
        }
    }

    componentDidMount() {
        try {
            const json = localStorage.getItem('options');
            const options = JSON.parse(json);

            if(options) this.setState(() => ({options}));
        } catch (e) {

        }
    }

    componentDidUpdate(prevProps, prevState) {
        if(prevState.options.length !== this.state.options.length) {
            const json = JSON.stringify(this.state.options);
            localStorage.setItem('options', json);
        }
    }

    handleRemoveOptions() {
        this.setState(() => ({ options: [] }));
    }

    handleRemoveOption(optionToRemove) {
        this.setState((prevState) => ({
            options: prevState.options.filter((option) => optionToRemove !== option )
        }));
    }

    handlePickOption() {
        const randomNumber = Math.floor( Math.random() * this.state.options.length );
        const option = this.state.options[randomNumber];

        alert(option);
    }

    handleAddOption(option) {
        if(!option) {
            return 'Enter some valid value to add option.'
        } else if(this.state.options.indexOf(option) > -1) {
            return 'Option already exist'
        }

        this.setState((prevState) => ({ options: prevState.options.concat(option) }));
    }

    render() {
        const title = "Indecisive App";
        const subtitle = "Put your choices in the hands of a computer.";

        return (

                <Action
                    hasOptions={this.state.options.length > 0}
                    handlePickOption={this.handlePickOption}
                />
                <Options
                    options={this.state.options}
                    handleRemoveOptions={this.handleRemoveOptions}
                    handleRemoveOption={this.handleRemoveOption}
                />
                <AddOption
                    handleAddOption={this.handleAddOption}
                />

        );
    }
}

IndecisiveApp.defaultProps = {
  options: []
};

const Header = (props) => {
    return (

{props.title}

{props.subtitle}

    );
};

const Action = (props) => {
    return (

            <button
                onClick={props.handlePickOption}
                disabled={!props.hasOptions}
            >
                What should I do?
            </button>

    );
};

const Options = (props) => {
    return (

            <button onClick={props.handleRemoveOptions}>Remove All</button>
            {
                props.options.map((option, index) =>
                    <Option
                        key={index}
                        option={option}
                        handleRemoveOption={props.handleRemoveOption}
                    />
                )
            }

    );
};

const Option = (props) => {
    return (

            {props.option}
            <button onClick={(e) => {
                props.handleRemoveOption(props.option)
            }}>
                Remove Option
            </button>

    );
};

class AddOption extends React.Component {
    constructor(props) {
        super(props);

        this.formSubmit = this.formSubmit.bind(this);

        this.state = {
            error: undefined
        }
    }

    formSubmit(e) {
        e.preventDefault();
        const option = e.target.elements.option.value.trim();

        const error = this.props.handleAddOption(option);

        this.setState(() => ({ error }));

        if(!error) e.target.elements.option.value = "";
    }

    render() {
        return (

                {(this.state.error &&
{this.state.error}
)}
                <form onSubmit={this.formSubmit}>
                    <input type="text" name="option" autoFocus={1}/>
                    <button type="submit">Add Options</button>
                </form>

        );
    }
}

ReactDOM.render(<IndecisiveApp />, document.getElementById('app'));

repository: vaibhav-sidapara/indecisive-app

repo_name: vaibhav-sidapara/indecisive-app

extension: js


text:
require u-boot.inc

FILESEXTRAPATHS_prepend := "${THISDIR}/u-boot-2017.05:"

PV = "2017.05"
PR = "r1"

COMPATIBLE_MACHINE = "beaglebone"

UBOOT_LOCALVERSION = "-jumpnow"

# v2017.05
SRCREV = "64c4ffa9fa223f7ae8640f9c8f3044bfa0e3bfda"
SRC_URI = " \
    git://git.denx.de/u-boot.git;branch=master;protocol=git \
    file://0001-Remove-unused-boot-options.patch \
    file://0002-Set-custom-bootcommand-always-envboot-first.patch \
    file://0003-Skip-check-for-boot-scr.patch \
"

SPL_BINARY = "MLO"

branch_name: refs/heads/pyro

gha_language: Shell


text:
require u-boot-ti.inc

PR = "r7"

SPL_BINARY = "MLO"

# No patches for other machines yet
COMPATIBLE_MACHINE = "(beagleboard)"

SRC_URI = "git://git.denx.de/u-boot.git;protocol=git \
           file://2011.09/0001-omap3-mem-Comment-enable_gpmc_cs_config-more.patch \
           file://2011.09/0002-OMAP3-Update-SDRC-dram_init-to-always-call-make_cs1_.patch \
           file://2011.09/0003-OMAP3-Add-a-helper-function-to-set-timings-in-SDRC.patch \
           file://2011.09/0004-OMAP3-Change-mem_ok-to-clear-again-after-reading-bac.patch \
           file://2011.09/0005-OMAP3-Remove-get_mem_type-prototype.patch \
           file://2011.09/0006-omap3-mem-Add-MCFG-helper-macro.patch \
           file://2011.09/0007-OMAP3-Add-optimal-SDRC-autorefresh-control-values.patch \
           file://2011.09/0008-OMAP3-Suffix-all-Micron-memory-timing-parts-with-the.patch \
           file://2011.09/0009-OMAP3-SPL-Rework-memory-initalization-and-devkit8000.patch \
           file://2011.09/0010-OMAP3-SPL-Add-identify_nand_chip-function.patch \
           file://2011.09/0011-OMAP3-Add-SPL-support-to-Beagleboard.patch \
           file://2011.09/0012-OMAP3-Add-SPL-support-to-omap3_evm.patch \
           file://2011.09/0013-AM3517-Add-SPL-support.patch \
           file://2011.09/0014-AM3517-CraneBoard-Add-SPL-support.patch \
           file://2011.09/0015-HACK-beagleboard-config-disable-cache-for-USB.patch \
           file://2011.09/0016-beagleboard-config-enable-gpio-command.patch \
           file://2011.09/0017-Increased-some-timeout-durations-for-MMC-and-EHCI.patch \
           file://2011.09/0018-beagleboard-mount-rootfs-RO-instead-of-RW-at-boot.patch \
           file://2011.09/0019-BeagleBoard-config-Really-switch-to-ttyO2.patch \
           file://2011.09/0020-beagleboard-add-support-for-TCT-Beacon-board.patch \
           file://2011.09/0021-beagleboard-add-support-for-scanning-loop-through-ex.patch \
           file://0001-config-Always-use-GNU-ld.patch \
           file://fw_env.config \
          "

SRCREV = "fdbe8b9a2d1858ba35dd6214315563ad44d4a0e3"

repository: Angstrom-distribution/meta-ti

repo_name: Angstrom-distribution/meta-ti

gha_language: BlitzBasic


text:
PR = "${INC_PR}.0"

require ipsec-tools.inc

SRC_URI[ipsec-tools-0.7.2.md5sum] = "72861f005746ee27984b2ee715ecc629"
SRC_URI[ipsec-tools-0.7.2.sha256sum] = "08722ff6c62de3e042fef337454f03622a79053108d6dcc686c9c854f9f9e031"

EXTRA_OECONF += " --disable-security-context"


text:
@article{cunningham-2010,
  author = {Darryl Cunningham},
  title = {The Facts In The Case Of Dr. Andrew Wakefield},
  annote = {A graphic novel depiction of the controversial career of Andrew Wakefield.}
  URL = {http://darryl-cunningham.blogspot.com/2010/05/facts-in-case-of-dr-andrew-wakefield.html},
  source = {20/wakefield-case.bib},
  urldate = {2020-03-01},
  date = {2010-05-18},
  mendeley-tags = {Ethics in research}
}

repository: pmean/build-website

repo_name: pmean/build-website


text:
DESCRIPTION = "dpath"
HOMEPAGE = "http://pypi.python.org/pypi/dpath"
SECTION = "devel/python"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE.txt;md5=1e6b859ac818b783f4314be23277a1ce"
PR = "r3"

SRCNAME = "dpath"
SRC_URI = "http://pypi.python.org/packages/source/d/${SRCNAME}/${SRCNAME}-${PV}.tar.gz"

SRC_URI[md5sum] = "075ffe1ef5ef1b6ee70b6f64b0504af1"
SRC_URI[sha256sum] = "fe5f554a414ddc714d9b5b306a908033673f4fb5fbb5f197e0d03f0ae321dcad"

S = "${WORKDIR}/${SRCNAME}-${PV}"

inherit distutils

RDEPENDS_${PN} = "python-core python-shell python-re python-lang python-io python-math python-threading python-logging python-argparse python-json"


text:
// Copyright © 2017 The virtual-kubelet 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.
//
// Edited by the systemk authors in 2021.

package cmd

import (
	"flag"
	"net"
	"os"

	"github.com/miekg/systemk/internal/provider"
	"github.com/spf13/pflag"
	vklogv2 "github.com/virtual-kubelet/virtual-kubelet/log/klogv2"
	"k8s.io/klog/v2"
)

// A global logger for this package is declared here since this is the place
// where we tie systemk logging to klogv2 (see the imports).
var log = vklogv2.New(nil)

func installFlags(flags *pflag.FlagSet, c *provider.Opts) {
	hostname, _ := os.Hostname()
	if hostname == "" {
		hostname = "systemk"
	}

	flags.StringVar(&c.KubeConfigPath, "kubeconfig", "", "cluster client configuration")
	flags.StringVar(&c.KubeClusterDomain, "cluster-domain", provider.DefaultKubeClusterDomain, "cluster domain")
	flags.StringVar(&c.NodeName, "nodename", hostname, "value to be set as the Node name and label node.k8s.io/hostname")
	flags.StringVar(&c.ListenAddress, "addr", provider.DefaultListenAddr, "address to bind for serving requests from the Kubernetes API server")
	flags.StringVar(&c.MetricsAddr, "metrics-addr", provider.DefaultMetricsAddr, "address to listen for metrics/stats requests")
	flags.IntVar(&c.PodSyncWorkers, "pod-sync-workers", provider.DefaultPodSyncWorkers, `number of pod synchronization workers`)
	flags.DurationVar(&c.InformerResyncPeriod, "full-resync-period", provider.DefaultInformerResyncPeriod, "interval period for recurring listing of all Pods assigned to this Node")
	flags.DurationVar(&c.StreamIdleTimeout, "stream-idle-timeout", provider.DefaultStreamIdleTimeout, "maximum time a streaming connection can be idle before the connection is automatically closed")
	flags.DurationVar(&c.StreamCreationTimeout, "stream-creation-timeout", provider.DefaultStreamCreationTimeout, "stream-creation-timeout is the maximum time for streaming connection")
	flags.StringVar(&c.ServerCertPath, "tls-cert", "", "path to the certificate to secure the kubelet API")
	flags.StringVar(&c.ServerKeyPath, "tls-key", "", "path to the private key to sign the kubelet API")
	flags.IPVar(&c.NodeInternalIP, "internal-ip", net.IPv4zero, "IP address to advertise as Node InternalIP, 0.0.0.0 means auto-detect")
	flags.IPVar(&c.NodeExternalIP, "external-ip", net.IPv4zero, "IP address to advertise as Node ExternalIP, 0.0.0.0 means auto-detect")
	flags.StringSliceVarP(&c.AllowedHostPaths, "dir", "d", provider.DefaultAllowedPaths, "only allow mounts below these directories")
	flags.BoolVarP(&c.UserMode, "user", "u", false, "rely on the user's systemd")
	flags.BoolVarP(&c.DisableTaint, "disable-taint", "", false, "disable the node taint")

	// Since klog is the logger implementation, install its flags.
	// But prepend "klog." to the flag name for clear separation.
	flagset := flag.NewFlagSet("klog", flag.PanicOnError)
	klog.InitFlags(flagset)
	flagset.VisitAll(func(f *flag.Flag) {
		// klog flags are the majority of the flags, and they shouldn't exist in the first place
		// only allow a minimal set.
		if f.Name == "v" {
			f.Name = "klog." + f.Name
			flags.AddGoFlag(f)
		}
	})
}

repository: miekg/systemk

repo_name: miekg/systemk


text:
package main

import (
	"bytes"
	"flag"
	"fmt"
	"image"
	"image/color"
	"image/draw"
	"image/png"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"

	"github.com/alecthomas/chroma"
	"github.com/alecthomas/chroma/formatters"
	"github.com/alecthomas/chroma/lexers"
	"github.com/alecthomas/chroma/styles"
	"github.com/golang/freetype/truetype"
	"github.com/skanehira/clipboard-image"
	"golang.org/x/image/font"
	"golang.org/x/image/math/fixed"
	"golang.org/x/term"
)

var version = "1.1.0"

func exitErr(err error) {
	fmt.Fprintln(os.Stderr, err)
	os.Exit(1)
}

func main() {
	name := "code2img"
	fs := flag.NewFlagSet(name, flag.ContinueOnError)
	fs.SetOutput(os.Stderr)
	fs.Usage = func() {
		fs.SetOutput(os.Stdout)
		fmt.Printf(`%[1]s - generate image of source code

Version: %s

Usage:
  $ %[1]s -t monokai main.go main.png
  $ echo 'fmt.Println("Hello World")' | %[1]s -ext go -t native -o sample.png
  $ %[1]s -c main.go

  -t	color theme(default: solarized-dark)
  -o	output file name(default: out.png)
  -c	copy to clipboard
  -ext	file extension
`, name, version)
	}

	theme := fs.String("t", "solarized-dark", "")
	ext := fs.String("ext", "", "")
	output := fs.String("o", "out.png", "")
	useClipboard := fs.Bool("c", false, "")

	if err := fs.Parse(os.Args[1:]); err != nil {
		if err == flag.ErrHelp {
			return
		}
		os.Exit(1)
	}

	var src io.Reader

	// if use stdin, then require those argments
	if !term.IsTerminal(int(os.Stdin.Fd())) {
		if *ext == "" {
			fs.Usage()
			os.Exit(1)
		}
		src = os.Stdin
	} else {
		args := fs.Args()
		if len(args) < 1 {
			fs.Usage()
			os.Exit(1)
		}

		in := args[0]
		*ext = filepath.Ext(in)[1:]

		var err error
		src, err = os.Open(in)
		if err != nil {
			exitErr(err)
		}
		*ext = filepath.Ext(args[0])[1:]

		if !*useClipboard && len(args) > 1 {
			*output = args[1]
		}
	}

	buf := &bytes.Buffer{}
	if _, err := io.Copy(buf, src); err != nil {
		exitErr(err)
	}
	source := buf.String()

	w, h := getSize(source)
	formatters.Register("png", &pngFormat{
		width:  w,
		height: h,
	})

	if err := toImg(*useClipboard, source, *output, *ext, *theme); err != nil {
		exitErr(err)
	}
}

func getSize(s string) (int, int) {
	w, h := 0, 0
	for _, s := range strings.Split(s, "\n") {
		ww := len(s) * 12
		if ww > w {
			w = ww
		}
		h++
	}
	h = h + 2
	return w, h * 20
}

type pngFormat struct {
	width, height int
}

func (p *pngFormat) Format(w io.Writer, style *chroma.Style, iterator chroma.Iterator) error {
	f, err := Assets.Open("/font/Cica-Regular.ttf")
	defer f.Close()

	b := &bytes.Buffer{}
	if _, err := io.Copy(b, f); err != nil {
		return err
	}

	ft, err := truetype.Parse(b.Bytes())
	if err != nil {
		return err
	}

	opt := truetype.Options{
		Size: 20,
	}
	face := truetype.NewFace(ft, &opt)

	bg := style.Get(chroma.Background).Background
	bgColor := color.RGBA{R: bg.Red(), G: bg.Green(), B: bg.Blue(), A: 255}

	img := image.NewRGBA(image.Rect(0, 0, p.width, p.height))
	draw.Draw(img, img.Bounds(), &image.Uniform{C: bgColor}, image.ZP, draw.Src)

	dr := &font.Drawer{
		Dst:  img,
		Src:  image.White,
		Face: face,
	}

	padding := 2
	x := fixed.Int26_6(padding)
	y := fixed.Int26_6(2)

	for _, t := range iterator.Tokens() {
		s := style.Get(t.Type)
		if s.Colour.IsSet() {
			c := s.Colour
			dr.Src = image.NewUniform(color.RGBA{R: c.Red(), G: c.Green(), B: c.Blue(), A: 255})
		} else {
			c := s.Colour
			if c.Brightness() < 0.5 {
				dr.Src = image.NewUniform(color.White)
			} else {
				dr.Src = image.NewUniform(color.Black)
			}
		}

		for _, c := range t.String() {
			if c == '\n' {
				x = fixed.Int26_6(padding)
				y++
				continue
			} else if c == '\t' {
				x += fixed.Int26_6(padding)
				continue
			}
			dr.Dot.X = fixed.I(10) * x
			dr.Dot.Y = fixed.I(20) * y
			s := fmt.Sprintf("%c", c)
			dr.DrawString(s)

			// if mutibyte
			if len(s) > 2 {
				x = x + 2
			} else {
				x++
			}
		}
	}

	return png.Encode(w, img)
}

func toImg(useClipboard bool, source, outFile string, lexer, style string) error {
	l := lexers.Get(lexer)
	if l == nil {
		l = lexers.Analyse(source)
	}
	if l == nil {
		l = lexers.Fallback
	}
	l = chroma.Coalesce(l)

	f := formatters.Get("png")
	if f == nil {
		f = formatters.Fallback
	}

	s := styles.Get(style)
	if s == nil {
		s = styles.Fallback
	}

	it, err := l.Tokenise(nil, source)
	if err != nil {
		return err
	}

	buf := new(bytes.Buffer)

	if err := f.Format(buf, s, it); err != nil {
		return err
	}

	if useClipboard {
		return clipboard.CopyToClipboard(buf)
	}

	tmp, err := ioutil.TempFile("", "")
	if err != nil {
		return err
	}

	if _, err := io.Copy(tmp, buf); err != nil {
		return err
	}

	tmp.Close()
	return os.Rename(tmp.Name(), outFile)
}


text:
package client

import (
	"github.com/BSNDA/PCNGateway-Go-SDK/pkg/common/errors"
	"github.com/BSNDA/PCNGateway-Go-SDK/pkg/core/config"
	"github.com/BSNDA/PCNGateway-Go-SDK/pkg/core/entity/base"
	"github.com/BSNDA/PCNGateway-Go-SDK/pkg/core/entity/enum"
	"github.com/BSNDA/PCNGateway-Go-SDK/pkg/core/sign"
	"github.com/BSNDA/bsn-sdk-crypto/crypto/secp256k1"
	"github.com/BSNDA/bsn-sdk-crypto/crypto/secp256r1"
	"github.com/BSNDA/bsn-sdk-crypto/crypto/sm"
	"github.com/wonderivan/logger"
)

type Client struct {
	Config *config.Config
	sign   sign.Crypto
}

func (c *Client) SetAlgorithm(algorithmType enum.App_AlgorithmType, puk, pri string) error {

	var sh sign.SignHandle
	var err error

	switch algorithmType {
	case enum.AppAlgorithmType_SM2:
		sh, err = sm.NewSM2Handle(puk, pri)
	case enum.AppAlgorithmType_R1:
		sh, err = secp256r1.NewEcdsaR1Handle(puk, pri)
	case enum.AppAlgorithmType_K1:
		sh, err = secp256k1.NewEcdsaK1Handle(puk, pri)
	default:
		return errors.New("Invalid certificate type")
	}

	if err != nil {
		return err
	} else {
		c.sign = sign.NewCrypto(sh)
		return nil
	}

}

func (c *Client) GetHeader() base.ReqHeader {
	return c.Config.GetReqHeader()
}

func (c *Client) GetURL(url string) string {
	return c.Config.GetNodeApi() + url
}

func (c *Client) Sign(data string) string {

	mac, err := c.sign.Sign(data)

	if err != nil {
		logger.Error("Exception in signature")
	}

	return mac
}

func (c *Client) Verify(mac, data string) bool {
	if mac == "" {
		return true
	}
	return c.sign.Verify(mac, data)

}

repository: togiter/PCNGateway-Go-SDK

repo_name: togiter/PCNGateway-Go-SDK


text:
include neutrino-lua-plugins-target-pattern.inc

SUMMARY = "Content for ${SRC_NAME}, required by Neutrino bouquets. Contributed by tuxbox, ni."
MAINTAINER = "community"
SECTION = "optional"

DEPENDS = "plutotv-update"

PR = "r2"
PV = "0.${SRCPV}"

SRCREV_prov0 = "${AUTOREV}"
SRCREV_prov1 = "${AUTOREV}"
# SRCREV_FORMAT = "${MAINTAINER}_prov0_prov1"
SRCREV_FORMAT = "${MAINTAINER}"

S = "${WORKDIR}/src"
SRC_RAW= "src-raw"

## We store temporarily the origin git contents into a separate "${WORKDIR}/${SRC_RAW}" directory.
SRC_URI = " \
	git://github.com/tuxbox-neutrino/plugin-scripts-lua.git;name=prov0;protocol=https;subpath=plugins/${SRC_NAME};destsuffix=${SRC_RAW}/${SRC_NAME}-prov0 \
	git://github.com/neutrino-images/ni-neutrino-plugins.git;name=prov1;protocol=https;subpath=scripts-lua/plugins/${SRC_NAME};destsuffix=${SRC_RAW}/${SRC_NAME}-prov1 \
	file://0001-yt_live.xml-update-live-channels.patch \
"

## Before install, we misuse the do_patch routine to prepare content.
## Because we need files from several sources, these have been already fetched into the ${SRC_RAW} directory.
## We only select the required data from ${SRC_RAW} directory, and we move it into the required source code directory ${S}.
## Finally we will patch some adjustments.
do_patch () {
	WEBTVPROVLIST="prov0 prov1"

	for p in $WEBTVPROVLIST; do
		cp  ${SRC_RAW}/${SRC_NAME}-$p/*.lua ${S}
		cp  ${SRC_RAW}/${SRC_NAME}-$p/*.xml ${S}
	done

	git -C ${S} apply ${WORKDIR}/0001-yt_live.xml-update-live-channels.patch
}

do_install () {
	# Clean up.
	rm -rf ${D}${N_PLUGIN_DIR}

	# Install content from source directory into target.
	install -d ${D}${N_WEBTV_DIR}
	install -m 644 ${S}/* ${D}${N_WEBTV_DIR}
}

repository: neutrino-hd/meta-neutrino

repo_name: neutrino-hd/meta-neutrino


text:
@article{Ubeda2011,
    author = {{\'{U}}beda, F and Wilkins, J F},
    doi = {10.1111/j.1420-9101.2010.02187.x},
    file = {:home/diego/.local/share/data/Mendeley Ltd./Mendeley Desktop/Downloaded/Ubeda, Wilkins - 2011 - The Red Queen theory of recombination hotspots.pdf:pdf},
    issn = {1420-9101},
    journal = {Journal of evolutionary biology},
    keywords = {Alleles,Animals,Biological Evolution,Chromosomes,Chromosomes: genetics,Computer Simulation,Crossing Over, Genetic,DNA Repair,Female,Male,Meiosis,Meiosis: genetics,Models, Genetic,Mutation,Recombination, Genetic,Recombination, Genetic: genetics},
    number = {3},
    pages = {541--553},
    pmid = {21159001},
    title = {{The Red Queen theory of recombination hotspots.}},
    url = {http://www.ncbi.nlm.nih.gov/pubmed/21159001},
    volume = {24},
    year = {2011}
}
@article{Ubeda2019,
    author = {{\'{U}}beda, Francisco and Russell, Timothy W. and Jansen, Vincent A.A.},
    doi = {10.1016/j.tpb.2018.12.005},
    file = {:home/diego/Dropbox/Articles/Articulos/Ubeda{\_}2019{\_}Prdm9AndTheEvolutionOfRecombinationHotspots{\_}TheorPopBiol.pdf:pdf},
    issn = {10960325},
    journal = {Theoretical Population Biology},
    keywords = {Gene conversion,Heteroclinic cycles,PRDM9,Population genetics,Recombination hotspot paradox,Viability selection},
    pages = {19--32},
    publisher = {Elsevier Inc.},
    title = {{PRDM9 and the evolution of recombination hotspots}},
    url = {https://doi.org/10.1016/j.tpb.2018.12.005},
    volume = {126},
    year = {2019}
}
@article{Hartasanchez2014,
    author = {Hartas{\'{a}}nchez, Diego A and Vall{\`{e}}s-Codina, Oriol and Bras{\'{o}}-Vives, Marina and Navarro, Arcadi},
    doi = {10.1534/g3.114.012435},
    file = {:home/diego/Dropbox/Articles/Articulos/Hartasanchez{\_}2014{\_}InterplayOfInterlocusGeneConversionAndCrossoverInSegmentalDuplicationsUnderANeutralScenario{\_}G3.pdf:pdf},
    issn = {2160-1836},
    journal = {G3 (Bethesda)},
    pages = {1479--1489},
    pmid = {24906640},
    title = {{Interplay of Interlocus Gene Conversion and Crossover in Segmental Duplications Under a Neutral Scenario.}},
    url = {http://www.ncbi.nlm.nih.gov/pubmed/24906640},
    volume = {4},
    year = {2014}
}
@article{Baker2017,
    author = {Baker, Zachary and Schumer, Molly and Haba, Yuki and Bashkirova, Lisa and Holland, Chris and Rosenthal, Gil G. and Przeworski, Molly},
    doi = {10.7554/eLife.24133},
    file = {:home/diego/Dropbox/Articles/Articulos/Baker{\_}Przeworski{\_}2017{\_}RepeatedLossesOfPRDM9DirectedRecombinationDespiteTheConservationOfPRDM9AcrossVertebrates{\_}eLife.pdf:pdf},
    issn = {2050084X},
    journal = {eLife},
    pages = {e24133},
    title = {{Repeated losses of PRDM9-directed recombination despite the conservation of PRDM9 across vertebrates}},
    volume = {6},
    year = {2017}
}
@article{Oliver2009,
    author = {Oliver, Peter L. and Goodstadt, Leo and Bayes, Joshua J. and Birtle, Zo{\"{e}} and Roach, Kevin C. and Phadnis, Nitin and Beatson, Scott A. and Lunter, Gerton and Malik, Harmit S. and Ponting, Chris P.},
    doi = {10.1371/journal.pgen.1000753},
    file = {:home/diego/Dropbox/Articles/Articulos/Oliver{\_}Ponting{\_}2009{\_}AcceleratiedEvolutionOfThePrdm9SpeciationGeneAcrossDiverseMetazoanTaxa{\_}PlosGenetics.pdf:pdf},
    isbn = {1553-7404 (Electronic)$\backslash$r1553-7390 (Linking)},
    issn = {15537390},
    journal = {PLoS Genetics},
    number = {12},
    pages = {e1000753},
    title = {{Accelerated evolution of the Prdm9 speciation gene across diverse metazoan taxa}},
    volume = {5},
    year = {2009}
}
@article{Thomas2009,
    author = {Thomas, James H. and Emerson, Ryan O. and Shendure, Jay},
    doi = {10.1371/journal.pone.0008505},
    file = {:home/diego/Dropbox/Articles/Articulos/Thomas{\_}Shendure{\_}2009{\_}ExtraordinaryMolecularEvolutionInThePrdm9FertilityGene{\_}PlosOne.pdf:pdf},
    issn = {19326203},
    journal = {PLoS ONE},
    number = {12},
    title = {{Extraordinary molecular evolution in the PRDM9 fertility gene}},
    volume = {4},
    pages = {e8505},
    year = {2009}
}
@article{Grey2018,
    author = {Grey, Corinne AND Baudat, Frédéric AND de Massy, Bernard},
    journal = {PLOS Genetics},
    publisher = {Public Library of Science},
    title = {PRDM9, a driver of the genetic map},
    year = {2018},
    volume = {14},
    url = {https://doi.org/10.1371/journal.pgen.1007479},
    pages = {e1007479},
    number = {8},
    doi = {10.1371/journal.pgen.1007479}
}
@article{Groeneveld2012,
    author = {Groeneveld, Linn Fenna AND Atencia, Rebeca AND Garriga, Rosa M. AND Vigilant, Linda},
    journal = {PLOS ONE},
    publisher = {Public Library of Science},
    title = {High Diversity at {PRDM9} in Chimpanzees and Bonobos},
    year = {2012},
    volume = {7},
    url = {https://doi.org/10.1371/journal.pone.0039064},
    pages = {e39064},
    number = {7},
    doi = {10.1371/journal.pone.0039064}
}
@article{Yang2006,
    author = {Yang, Derek and Goldsmith, Edie B. and Lin, Yunfu and Waldman, Barbara Criscuolo and Kaza, Vimala and Waldman, Alan S.},
    doi = {10.1534/genetics.106.060590},
    issn = {00166731},
    journal = {Genetics},
    number = {1},
    pages = {135--144},
    pmid = {16816418},
    title = {{Genetic exchange between homeologous sequences in mammalian chromosomes is averted by local homology requirements for initiation and resolution of recombination}},
    volume = {174},
    year = {2006}
}
@article{Persikov2008,
    author = {Persikov, Anton V. and Singh, Mona and Osada, Robert},
    title = "{Predicting DNA recognition by {C}ys2{H}is2 zinc finger proteins}",
    journal = {Bioinformatics},
    volume = {25},
    number = {1},
    pages = {22--29},
    year = {2008},
    month = {11},
    issn = {1367-4803},
    doi = {10.1093/bioinformatics/btn580},
    url = {https://doi.org/10.1093/bioinformatics/btn580},
    eprint = {http://oup.prod.sis.lan/bioinformatics/article-pdf/25/1/22/16886957/btn580.pdf},
}
@article{Wolfe2000b,
    author = {Wolfe, Scot A. and Nekludova, Lena and Pabo, Carl O.},
    title = {DNA Recognition by {C}ys2{H}is2 Zinc Finger Proteins},
    journal = {Annual Review of Biophysics and Biomolecular Structure},
    volume = {29},
    number = {1},
    pages = {183-212},
    year = {2000},
    doi = {10.1146/annurev.biophys.29.1.183},
    URL = {https://doi.org/10.1146/annurev.biophys.29.1.183},
}
@article{Schwartz2014,
    author = {Schwartz, Jerrod J. and Roach, David J. and Thomas, James H. and Shendure, Jay},
    doi = {10.1038/ncomms5370},
    file = {:home/diego/Dropbox/Articles/Articulos/Schwartz{\_}Shendure{\_}2014{\_}PrimateEvolutionOfTheRecombinationRegulatorPrdm9{\_}NatComm.pdf:pdf},
    isbn = {2041-1723 (Electronic)$\backslash$r2041-1723 (Linking)},
    issn = {20411723},
    journal = {Nature Communications},
    pages = {4370},
    pmid = {25001002},
    publisher = {Nature Publishing Group},
    title = {{Primate evolution of the recombination regulator PRDM9}},
    url = {http://dx.doi.org/10.1038/ncomms5370},
    volume = {5},
    year = {2014}
}
@article{Latrille2017,
    author = {Latrille, Thibault and Duret, Laurent and Lartillot, Nicolas},
    doi = {10.1098/rstb.2016.0463},
    file = {:home/diego/Dropbox/Articles/Articulos/Latrille{\_}Lartillot{\_}2017{\_}TheRedQueenModelOfRecombinationHotSpotEvolutionATheoreticalInvestigation{\_}PhilTransB.pdf:pdf},
    isbn = {0000000299},
    issn = {14712970},
    journal = {Philosophical Transactions of the Royal Society B: Biological Sciences},
    keywords = {Biased gene conversion,PRDM9,Recombination,Red queen},
    number = {1736},
    title = {{The red queen model of recombination hot-spot evolution: A theoretical investigation}},
    volume = {372},
    year = {2017}
}
@article{Jeffreys2013,
    author = {Jeffreys, A. J. and Cotton, V. E. and Neumann, R. and Lam, K.-W. G.},
    doi = {10.1073/pnas.1220813110},
    file = {:home/diego/Dropbox/Articles/Articulos/Jeffreys{\_}2013{\_}RecombinationRegulatorPRDM9InfluencesTheInstabilityOfItsOwnCodingSequenceInHumans{\_}PNAS.pdf:pdf},
    isbn = {1091-6490 (Electronic)$\backslash$r0027-8424 (Linking)},
    issn = {0027-8424},
    journal = {Proceedings of the National Academy of Sciences of the United States of America},
    number = {2},
    pages = {600--605},
    pmid = {23267059},
    title = {{Recombination regulator PRDM9 influences the instability of its own coding sequence in humans}},
    volume = {110},
    year = {2013}
}
@article{Innan2003,
    author = {Innan, Hideki},
    doi = {10.1073/pnas.1031592100},
    file = {:home/diego/.local/share/data/Mendeley Ltd./Mendeley Desktop/Downloaded/Innan - 2003 - A two-locus gene conversion model with selection and its application to the human RHCE and RHD genes.pdf:pdf},
    issn = {0027-8424},
    journal = {Proceedings of the National Academy of Sciences of the United States of America},
    number = {15},
    pages = {8793--8798},
    pmid = {12857961},
    title = {{A two-locus gene conversion model with selection and its application to the human RHCE and RHD genes$\backslash$n10.1073/pnas.1031592100}},
    url = {http://www.pnas.org/cgi/content/abstract/100/15/8793 http://www.pubmedcentral.nih.gov/articlerender.fcgi?artid=166392{\&}tool=pmcentrez{\&}rendertype=abstract},
    volume = {100},
    year = {2003}
}
@article{Ohta1982,
    author = {Ohta, T},
    file = {:home/diego/.local/share/data/Mendeley Ltd./Mendeley Desktop/Downloaded/Ohta - 1982 - Allelic and nonallelic homology of a supergene family.pdf:pdf},
    issn = {0027-8424},
    journal = {Proceedings of the National Academy of Sciences of the United States of America},
    keywords = {Alleles,Gene Conversion,Genes,Genetic,Major Histocompatibility Complex,Polymorphism},
    month = {may},
    number = {10},
    pages = {3251--3254},
    pmid = {6954477},
    title = {{Allelic and nonallelic homology of a supergene family.}},
    url = {http://www.pubmedcentral.nih.gov/articlerender.fcgi?artid=346393{\&}tool=pmcentrez{\&}rendertype=abstract},
    volume = {79},
    year = {1982}
}


text:
# Copyright (C) 2015 Aananth Chellapa Natarajan <c.n.aananth@gmail.com>
# Released under the MIT license (see COPYING.MIT for the terms)

DESCRIPTION = "Driver for Belkin USB wireless dongle. Model - F9L1001v1"
HOMEPAGE = "https://github.com/dz0ny/rt8192cu"
LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://README.md;md5=606384b5e54e39d1c22df89e5de1b1e3"

SRC_URI = "git://github.com/dz0ny/rt8192cu.git \
           file://modules-build-compilation-error.patch \
"

SRC_URI[md5sum] = "5d5e8fbad6e3c72fc8bdb41d9333d94f"
SRC_URI[sha256sum] = "5a34b37fae763d4f04768b868e34f859f138cf8f2473ade31b8791c703176b79"

SRCREV_default_pn-rtl81xx="${AUTOREV}"

S = "${WORKDIR}/git"

inherit module

repository: aananthcn/meta-aananth

repo_name: aananthcn/meta-aananth


text:
package http

import (
	"testing"

	"net/http"

	"github.com/songrgg/backeye/pkg/response"
	"github.com/stretchr/testify/assert"
)

func TestUnavailable(t *testing.T) {
	a, err := NewAssertion("xxx", "", "", "", "")
	assert.NotNil(t, err)
	assert.Nil(t, a)
}

func TestCheckHeader(t *testing.T) {
	a, err := NewAssertion("equal", "header", "X-Upstream-Status", "200", "")
	assert.Nil(t, err)

	res := response.Response{}

	result, err := a.Check(res)
	assert.NotNil(t, err)
	assert.False(t, result)

	SetHeaders(res, http.Header{
		"X-Upstream-Status": []string{"200"},
	})
	result, err = a.Check(res)
	assert.Nil(t, err)
	assert.True(t, result)
}

func TestCheckStatus(t *testing.T) {
	a, err := NewAssertion("equal", "status", "", 200, "")
	assert.Nil(t, err)

	res := response.Response{}

	result, err := a.Check(res)
	assert.NotNil(t, err)
	assert.False(t, result)

	SetStatus(res, 500)
	result, err = a.Check(res)
	assert.NotNil(t, err)
	assert.False(t, result)

	SetStatus(res, 200)
	result, err = a.Check(res)
	assert.Nil(t, err)
	assert.True(t, result)
}

func TestCheckBody(t *testing.T) {
	a, err := NewAssertion("equal", "body", "code", float64(20000), "json")
	assert.Nil(t, err)

	res := response.Response{}

	result, err := a.Check(res)
	assert.NotNil(t, err)
	assert.False(t, result)

	SetBody(res, []byte("{\"code\": 50000}"))
	result, err = a.Check(res)
	assert.NotNil(t, err)
	assert.False(t, result)

	SetBody(res, []byte("{\"code\": 20000}"))
	result, err = a.Check(res)
	assert.Nil(t, err)
	assert.True(t, result)
}

repository: songrgg/backeye

repo_name: songrgg/backeye

gha_language: JavaScript


text:
file(REMOVE_RECURSE
  "CMakeFiles/tiles.dir/src/tiles.cpp.o"
  "CMakeFiles/tiles.dir/src/tilesInt.C.o"
  "tiles.pdb"
  "tiles.so"
)

# Per-language clean rules from dependency scanning.
foreach(lang CXX)
  include(CMakeFiles/tiles.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

repository: AmiiThinks/RobotLearning

repo_name: AmiiThinks/RobotLearning

extension: cmake


text:
@article{carlson2001discourse,
  title={Discourse tagging reference manual},
  author={Carlson, Lynn and Marcu, Daniel},
  journal={ISI Technical Report ISI-TR-545},
  volume={54},
  pages={56},
  year={2001}
}

@inproceedings{soricut2003sentence,
  title={Sentence level discourse parsing using syntactic and lexical information},
  author={Soricut, Radu and Marcu, Daniel},
  booktitle={Proceedings of the 2003 Conference of the North American Chapter of the Association for Computational Linguistics on Human Language Technology-Volume 1},
  pages={149--156},
  year={2003},
  organization={Association for Computational Linguistics}
}

@inproceedings{subba2007automatic,
  title={Automatic discourse segmentation using neural networks},
  author={Subba, Rajen and Di Eugenio, Barbara},
  booktitle={Proc. of the 11th Workshop on the Semantics and Pragmatics of Dialogue},
  pages={189--190},
  year={2007}
}

@inproceedings{inproceedings,
  author = {Hernault, Hugo and Bollegala, Danushka and Ishizuka, Mitsuru},
  year = {2010},
  month = {03},
  pages = {315-326},
  title = {A Sequential Model for Discourse Segmentation},
  doi = {10.1007/978-3-642-12116-6_26}
}

@inproceedings{bach2012reranking,
  title={A reranking model for discourse segmentation using subtree features},
  author={Bach, Ngo Xuan and Minh, Nguyen Le and Shimazu, Akira},
  booktitle={Proceedings of the 13th Annual Meeting of the Special Interest Group on Discourse and Dialogue},
  pages={160--168},
  year={2012},
  organization={Association for Computational Linguistics}
}

@article{heilman2015fast,
  title={Fast rhetorical structure theory discourse parsing},
  author={Heilman, Michael and Sagae, Kenji},
  journal={arXiv preprint arXiv:1505.02425},
  year={2015}
}


text:
package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	//syncTest()
	chanTest()
}

//Go 语言提供了 sync 和 channel 两种方式支持协程(goroutine)的并发。

var wg sync.WaitGroup

func download(url string) {
	fmt.Println("start download url is", url)
	time.Sleep(time.Second)
	wg.Done() //为wg减去一个计数
}

func syncTest() {
	for i := 0; i < 3; i++ {
		wg.Add(1)                            //为wg添加一个计数
		go download("a.com" + string(i+'0')) //启动新的协成 并发执行download
	}
	wg.Wait() //等待所有的协成执行完毕
	fmt.Println("Done")
}

var ch = make(chan string, 10) // 创建大小为 10 的缓冲信道

func chanDownload(url string) {
	fmt.Println("start download url is", url)
	time.Sleep(time.Second)
	ch <- url //将URL信息发送给 chan
}

//使用 channel 信道，可以在协程之间传递消息。阻塞等待并发协程返回消息。
func chanTest() {
	for i := 0; i < 3; i++ {
		go chanDownload("a.com" + string(i+'0')) //启动新的协成 并发执行download
	}
	for i := 0; i < 3; i++ {
		msg := <-ch
		fmt.Println("finish :", msg)
	}
	fmt.Println("Done")
}

repository: aystzh/go-hello

repo_name: aystzh/go-hello


text:
package auth

import (
	"github.com/gorilla/mux"
	"github.com/kidstuff/WebUtil/response"
	"net/http"
	"strings"
)

func OAuthHandleWrapper(handler http.HandlerFunc, groups []string, pri []string) http.HandlerFunc {
	return func(rw http.ResponseWriter, req *http.Request) {
		userMngr, err := Provider().OpenUserMngr(req)
		if err != nil {
			response.InternalErrorResponse(rw, &response.JSONErr{Message: err.Error()})
		}
		defer userMngr.Close()

		token := strings.TrimPrefix(req.Header.Get("Authorization"), "Bearer ")
		user, err := userMngr.GetUser(token)
		if err != nil {
			if err == ErrNotLogged {
				response.ForbiddenResponse(rw, &response.JSONErr{
					Code:        response.ErrCodeNotLogged,
					Message:     err.Error(),
					Description: "User need to be logged in to perform this action.",
				})
				return
			}
			response.InternalErrorResponse(rw, &response.JSONErr{Message: err.Error()})
			return
		}

		if len(groups) > 0 {
			for _, bg := range user.BriefGroups {
				for _, g2 := range groups {
					if bg.Name == g2 {
						handler(rw, req)
						return
					}
				}
			}
		}

		var (
			cannot   bool
			cannotDo string
		)
		for _, do := range pri {
			if !userMngr.Can(user, do) {
				cannotDo += do + ","
			}
		}

		if cannot {
			response.ForbiddenResponse(rw, &response.JSONErr{
				Code:        response.ErrNoPermission,
				Message:     "User doesn't have valid permission.",
				Description: "User doesn't have " + cannotDo + " permission.",
			})
			return
		}

		// run user defined handler
		handler(rw, req)
	}
}

func OAuthOwnerPrivilegeWrapper(handler http.HandlerFunc, userIdField string) http.HandlerFunc {
	return func(rw http.ResponseWriter, req *http.Request) {
		userMngr, err := Provider().OpenUserMngr(req)
		if err != nil {
			response.InternalErrorResponse(rw, &response.JSONErr{Message: err.Error()})
		}
		defer userMngr.Close()

		token := strings.TrimPrefix(req.Header.Get("Authorization"), "Bearer ")
		user, err := userMngr.GetUser(token)
		if err != nil {
			if err == ErrNotLogged {
				response.ForbiddenResponse(rw, &response.JSONErr{
					Code:        response.ErrCodeNotLogged,
					Message:     err.Error(),
					Description: "User need to be logged in to perform this action.",
				})
				return
			}
			response.InternalErrorResponse(rw, &response.JSONErr{Message: err.Error()})
			return
		}

		vars := mux.Vars(req)
		idStr := vars[userIdField]
		if len(idStr) == 0 {
			response.BadRequestResponse(rw, &response.JSONErr{
				Message:     "Missing " + userIdField + " from request URL",
				Description: "OAuthOwnerPrivilegeWrapper require " + userIdField + " defiend by 'userIdField' to be exist in handle pattern.",
			})
			return
		}

		u, err := userMngr.FindUser(idStr)
		if err != nil {
			response.InternalErrorResponse(rw, &response.JSONErr{Message: err.Error()})
			return
		}

		if u.Id != user.Id {
			response.ForbiddenResponse(rw, &response.JSONErr{
				Code:        response.ErrNoPermission,
				Message:     "Current user must be the owner of profile.",
				Description: "Current user must be the owner of the profile defined by " + userIdField + " field.",
			})
			return
		}

		handler(rw, req)
	}
}

repository: kidstuff/WebAuth

repo_name: kidstuff/WebAuth


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

package summarize

import (
	"fmt"

	"go.fuchsia.dev/fuchsia/tools/fidl/lib/fidlgen"
)

/*
Implementations of properties shared between multple Element types.  If an
Element type needs a property, a property type is embedded into its type.  For
an example, see below how isMember embeds named.
*/

// named is something that has a name.
type named struct {
	symbolTable *symbolTable
	// name is a fully qualified name. It is generic, as sometimes it is a
	// compound identifier and sometimes "just" an identifier.
	name Name
	// parent is nonempty for members.
	parent fidlgen.EncodedCompoundIdentifier
}

func newNamed(s *symbolTable,
	name fidlgen.EncodedCompoundIdentifier) named {
	return named{symbolTable: s, name: Name(name)}
}

func (l *named) Serialize() ElementStr {
	var e ElementStr
	e.Name = l.Name()
	return e
}

func (l *named) Name() Name {
	if l.parent != "" {
		return Name(fmt.Sprintf("%v.%v", l.parent, l.name))
	}
	return l.name
}

// isMember is something that is a member.
type isMember struct {
	named
	parentType fidlgen.DeclType
	maybeValue *fidlgen.Constant
}

// newIsMember creates a new element that represents a member.
func newIsMember(
	st *symbolTable,
	parentName fidlgen.EncodedCompoundIdentifier,
	name fidlgen.Identifier,
	parentType fidlgen.DeclType,
	maybeDefaultValue *fidlgen.Constant) *isMember {
	return &isMember{
		named: named{
			symbolTable: st,
			parent:      parentName,
			name:        Name(name),
		},
		parentType: parentType,
		maybeValue: maybeDefaultValue,
	}
}

func (i *isMember) Serialize() ElementStr {
	e := i.named.Serialize()
	e.Kind = Kind(fmt.Sprintf("%v/member", i.parentType))
	e.Value = fidlConstToValue(i.maybeValue)
	return e
}

func (*isMember) Member() bool {
	return true
}

// notMember is something that is not a member.
type notMember struct{}

func (m *notMember) Member() bool {
	return false
}

// aggregate is the base Element for anything that looks like a struct, API-wise.
type aggregate struct {
	named
	notMember
	// Not all aggregates have strictness.  Union has it, but tables and
	// structs don't, for example.  So we allow Strictness to be a
	// tri-state.
	Strictness
	resourceness fidlgen.Resourceness
	typeName     fidlgen.DeclType
}

func newAggregateWithStrictness(
	name fidlgen.EncodedCompoundIdentifier,
	resourceness fidlgen.Resourceness,
	typeName fidlgen.DeclType,
	s fidlgen.Strictness) *aggregate {
	a := newAggregate(name, resourceness, typeName)
	a.Strictness = strictness(s)
	return a
}

func newAggregate(
	name fidlgen.EncodedCompoundIdentifier,
	resourceness fidlgen.Resourceness,
	typeName fidlgen.DeclType) *aggregate {
	return &aggregate{
		named:        named{name: Name(name)},
		resourceness: resourceness,
		typeName:     typeName,
	}
}

func resourceness(resourceness fidlgen.Resourceness) Resourceness {
	if resourceness.IsResourceType() {
		return isResource
	}
	return isValue
}

func (s *aggregate) Serialize() ElementStr {
	e := s.named.Serialize()
	e.Resourceness = resourceness(s.resourceness)
	e.Strictness = s.Strictness
	e.Kind = Kind(s.typeName)
	return e
}

// member is an element of an aggregate (e.g. field of a struct).
type member struct {
	m          isMember
	memberType fidlgen.Type
	// This is the explicit ordinal (table/union members) or the 1-based index
	// of the member (struct members).
	ordinal int
}

// newMember creates a new aggregate member element.
func newMember(
	st *symbolTable,
	parentName fidlgen.EncodedCompoundIdentifier,
	name fidlgen.Identifier,
	memberType fidlgen.Type,
	declType fidlgen.DeclType,
	ordinal int,
	maybeDefaultValue *fidlgen.Constant) *member {
	return &member{
		m:          *newIsMember(st, parentName, name, declType, maybeDefaultValue),
		memberType: memberType,
		ordinal:    ordinal,
	}
}

// Member implements Element.
func (s *member) Member() bool {
	return s.m.Member()
}

// Name implements Element.
func (s *member) Name() Name {
	return s.m.Name()
}

func (s *member) Serialize() ElementStr {
	e := s.m.Serialize()
	e.Type = s.m.symbolTable.fidlTypeString(s.memberType)
	e.Ordinal = Ordinal(fmt.Sprint(s.ordinal))
	return e
}

repository: gnoliyil/fuchsia

repo_name: gnoliyil/fuchsia


text:
@conference{Litj12c,
 abstract = {Purpose: The recent PI-RADS standard considers T2-weighted (T2W) MR the best imaging modality to characterize central gland (CG) lesions. In this study we assessed whether computer-aided diagnosis using T2 texture and relaxation features can separate benign and malignant CG lesions. Materials and Methods: MR scans of 101 patients were included in this study. The reference standard was MR-guided MR biopsy. Of these patients 36 had benign disease (e.g. benign prostatic hyperplasia) and 65 had prostate cancer. Lesions were annotated on the T2W sequence using a contouring tool. A quantitative T2 relaxation map was computed using an estimator that combines the T2W and proton density images with a turbo-spin-echo signal model and a gain factor. The latter was estimated using an automatically selected muscle reference region. Several texture voxel features were computed on the resulting T2-map: co-occurrenc matrix based homogeneity, neighboring gray-level dependence matrix based texture strength, and multi-scale Gaussian derivative features. For the latter 5 scales between 2 and 12 mm and derivatives up to the second order were calculated. For the matrix based features we calculated several histogram bin sizes (8, 16 and 32) and kernel sizes (4, 8 and 12 mm). The total number of texture features was 42. A linear discriminant classifier with feature selection was trained to compute the cancer likelihood for each voxel in the lesion. A feature selection was performed in a nested cross-validation loop using 10 folds. Cross-validation was performed in a leave-one-patient-out manner. For each annotated region a summary lesion likelihood was computed using the 75th percentile of the voxel likelihoods. The diagnostic accuracy of the lesion cancer likelihood was evaluated using receiver-operating characteristic (ROC) analysis and bootstrapping. Results: An area under the ROC curve of 0.76 (95% bootstrap confidence interval 0.64 Ã¯Â¿Â½ 0.87) was obtained for determining cancer likelihood using texture features, which is similar to radiologist performance reported in the literature when they only have T2W images available, like in this study. Conclusion: A novel method for characterizing lesions in T2-weighted MRI using texture descriptors was developed. The performance is in the range of values reported in the literature for radiologists. Clinical relevance: A CAD system for classification of CG lesions could improve the characterization of these lesions, which might result in better treatment planning.},
 author = {G. Litjens and J. O. Barentsz and N. Karssemeijer and H.J. Huisman},
 booktitle = {RSNA},
 optgroups = {Prostate},
 optnote = {DIAG, RADIOLOGY, ProstateCancer},
 owner = {Geert},
 timestamp = {2012.08.27},
 title = {Computerized characterization of central gland lesions using texture and relaxation features from T2-weighted prostate MRI},
 year = {2012}
}


text:
package comparator

import (
	"encoding/json"
	"fmt"

	"github.com/sysdiglabs/kube-psp-advisor/generator"

	"github.com/sysdiglabs/kube-psp-advisor/advisor/types"
)

const (
	Source = "Source"
	Target = "Target"
)

type Comparator struct {
	escalationReport *types.LintReport
	gen              *generator.Generator
	srcCssList       []types.ContainerSecuritySpec
	srcPssList       []types.PodSecuritySpec
	targetCssList    []types.ContainerSecuritySpec
	targetPssList    []types.PodSecuritySpec
}

// NewComparator returns a new comparator object
func NewComparator() (*Comparator, error) {
	gen, err := generator.NewGenerator()

	if err != nil {
		return nil, err
	}

	return &Comparator{
		gen:              gen,
		escalationReport: types.NewEscalationReport(),
		srcCssList:       []types.ContainerSecuritySpec{},
		srcPssList:       []types.PodSecuritySpec{},
		targetCssList:    []types.ContainerSecuritySpec{},
		targetPssList:    []types.PodSecuritySpec{},
	}, nil
}

// LoadYamls loads yamls from files
func (c *Comparator) LoadYamls(yamls []string, dirType string) error {
	if dirType != Source && dirType != Target {
		return fmt.Errorf("invalid directory type: %s (expected 'Source' or 'Target')", dirType)
	}
	cssList := []types.ContainerSecuritySpec{}
	pssList := []types.PodSecuritySpec{}
	for _, yamlFile := range yamls {
		csl, psl, err := c.gen.LoadYaml(yamlFile)
		if err != nil {
			return err
		}

		if len(csl) > 0 {
			cssList = append(cssList, csl...)
			pssList = append(pssList, psl...)
		}
	}

	if dirType == Source {
		c.srcCssList = cssList
		c.srcPssList = pssList
	} else {
		c.targetCssList = cssList
		c.targetPssList = pssList
	}

	return nil
}

// Compare compares security contexts between the source YAMLs and target YAMLs
func (c *Comparator) Compare() {
	c.escalationReport.GenerateEscalationReportFromSecurityContext(c.srcCssList, c.targetCssList, c.srcPssList, c.targetPssList)
}

// Clear clears everything in the comparator
func (c *Comparator) Clear() {
	c.srcCssList = []types.ContainerSecuritySpec{}
	c.targetCssList = []types.ContainerSecuritySpec{}
	c.srcPssList = []types.PodSecuritySpec{}
	c.targetPssList = []types.PodSecuritySpec{}

	c.escalationReport = types.NewEscalationReport()
}

// PrintEscalationReport prints escalation report to STDOUT
func (c *Comparator) PrintEscalationReport() {
	data, _ := json.Marshal(c.escalationReport)

	fmt.Println(string(data))

}

repository: pbalogh-sa/kube-psp-advisor

repo_name: pbalogh-sa/kube-psp-advisor


text:
DESCRIPTION = "Prebuilt Keystone2 initramfs with SerDes, QMSS and NETCP PA firmware"

LICENSE = "TI-TFL"
LIC_FILES_CHKSUM = "file://LICENSE;md5=c5e02be633f1499c109d1652514d85ec"

CLEANBROKEN = "1"

COMPATIBLE_MACHINE = "keystone"

PACKAGE_ARCH = "${MACHINE_ARCH}"

SRC_URI = "http://arago-project.org/files/releases/k2-fw/k2-initramfs-${PV}.tar.gz"

SRC_URI[md5sum] = "27fb248cbfe08ed8344bdc4451067c8f"
SRC_URI[sha256sum] = "beb19d685ee0d20281266726e4c2ba4b245af9450c1bd5155ff06d8c1656dd26"

S = "${WORKDIR}"
TARGET = "k2-fw-initrd.cpio.gz"
TARGETM = "k2-fw-initrd-${MACHINE}.cpio.gz"

do_install() {
	install -d ${D}/boot
	install -m 0644 ${S}/${TARGET} ${D}/boot/${TARGETM}
	ln -s ${TARGETM} ${D}/boot/${TARGET}
}

FILES_${PN} = "/boot"

inherit deploy

do_deploy() {
	install -d ${DEPLOYDIR}
	install -m 0644 ${S}/${TARGET} ${DEPLOYDIR}/${TARGETM}
	ln -s ${TARGETM} ${DEPLOYDIR}/${TARGET}
}

addtask deploy before do_build after do_compile

do_image_complete() {
	:
}

addtask image_complete after do_deploy before do_build


text:
@ARTICLE{Moret2010,
  author = {Philippe Moret and Walter Binder and Alex Villaz\'on and Danilo Ansaloni and Abbas Heydarnoori},
  title = {Visualizing and exploring profiles with calling context ring charts},
  journal = {Software -- Practice and Experience},
  year = {2010},
  volume = {40},
  pages = {825--847},
  number = {9},
  abstract = {Calling context profiling is an important technique for analyzing the performance of object-oriented software with complex inter-procedural control flow. The Calling Context Tree (CCT) is a common data structure that stores dynamic metrics, such as CPU time, separately for each calling context. As CCTs may comprise millions of nodes, there is a need for a condensed visualization that eases the localization of performance bottlenecks. In this article, we discuss Calling Context Ring Charts (CCRCs), a compact visualization for CCTs, where callee methods are represented in ring segments surrounding the caller's ring segment. In order to reveal hot methods, their callers, and callees, the ring segments can be sized according to a chosen dynamic metric. We describe two case studies where CCRCs help us to detect and fix performance problems in applications. A performance evaluation also confirms that our implementation can efficiently handle large CCTs.},
  doi = {10.1002/spe.985}
}

repository: vis-au/treevisnet

repo_name: vis-au/treevisnet

gha_language: TeX


text:
package params

import (
	"github.com/cosmos/cosmos-sdk/client"
	"github.com/cosmos/cosmos-sdk/codec"
	"github.com/cosmos/cosmos-sdk/codec/types"
)

type EncodingConfig struct {
	InterfaceRegistry types.InterfaceRegistry
	Marshaler         codec.Marshaler
	TxConfig          client.TxConfig
	Amino             *codec.LegacyAmino
}

branch_name: refs/heads/development

gha_language: Go


text:
require ${PN}.inc

PR = "r1"

SRC_URI = "http://sources.openembedded.org/opie-1.2.4-split_core_apps_qss.tar.bz2;name=split_core_apps_qss"
SRC_URI[split_core_apps_qss.md5sum] = "eae54a6c89a108edfd06e3095a88f2a3"
SRC_URI[split_core_apps_qss.sha256sum] = "3122d14a2f95908abcc6580c95be00252b4e2dd1ce42bafcd4b120ef0d6a4e74"


text:
package config

import (
	"encoding/json"
	"fmt"
)

type StorageDriver string

const (
	LocalStorageDriver StorageDriver = "local"
	S3StorageDriver    StorageDriver = "s3"
)

type StorageOptions interface {
	Driver() StorageDriver
}

type LocalStorageOptions struct {
	FilesDir string `json:"files_dir"`
}

func (o LocalStorageOptions) Driver() StorageDriver {
	return LocalStorageDriver
}

type S3StorageOptions struct {
	Region          string `json:"region"`
	AccessKeyID     string `json:"access_key_id"`
	SecretAccessKey string `json:"secret_access_key"`
	Endpoint        string `json:"endpoint"`
	Bucket          string `json:"bucket"`
	PathPrefix      string `json:"path_prefix,omitempty"`
	UsePathStyle    bool   `json:"use_path_style,omitempty"`
}

func (o S3StorageOptions) Driver() StorageDriver {
	return S3StorageDriver
}

// Storage contains storage config.
type Storage struct {
	Options StorageOptions `json:"options"`
}

func (c Storage) MarshalJSON() ([]byte, error) {
	cfg := struct {
		Driver  StorageDriver  `json:"driver"`
		Options StorageOptions `json:"options"`
	}{
		Driver:  c.Options.Driver(),
		Options: c.Options,
	}
	return json.Marshal(cfg)
}

func (c *Storage) UnmarshalJSON(bytes []byte) error {
	var cfg struct {
		Driver  StorageDriver   `json:"driver"`
		Options json.RawMessage `json:"options"`
	}
	if err := json.Unmarshal(bytes, &cfg); err != nil {
		return err
	}
	switch cfg.Driver {
	case LocalStorageDriver:
		var options LocalStorageOptions
		if err := json.Unmarshal(cfg.Options, &options); err != nil {
			return err
		}
		c.Options = options
	case S3StorageDriver:
		var options S3StorageOptions
		if err := json.Unmarshal(cfg.Options, &options); err != nil {
			return err
		}
		c.Options = options
	default:
		return fmt.Errorf("driver %q is not supported", cfg.Driver)
	}
	return nil
}

repository: udovin/solve

repo_name: udovin/solve


text:
// Code generated by go generate; DO NOT EDIT.
package containers

import (
	"net/url"

	"github.com/containers/podman/v4/pkg/bindings/internal/util"
)

// Changed returns true if named field has been set
func (o *ListOptions) Changed(fieldName string) bool {
	return util.Changed(o, fieldName)
}

// ToParams formats struct fields to be passed to API service
func (o *ListOptions) ToParams() (url.Values, error) {
	return util.ToParams(o)
}

// WithAll set field All to given value
func (o *ListOptions) WithAll(value bool) *ListOptions {
	o.All = &value
	return o
}

// GetAll returns value of field All
func (o *ListOptions) GetAll() bool {
	if o.All == nil {
		var z bool
		return z
	}
	return *o.All
}

// WithExternal set field External to given value
func (o *ListOptions) WithExternal(value bool) *ListOptions {
	o.External = &value
	return o
}

// GetExternal returns value of field External
func (o *ListOptions) GetExternal() bool {
	if o.External == nil {
		var z bool
		return z
	}
	return *o.External
}

// WithFilters set field Filters to given value
func (o *ListOptions) WithFilters(value map[string][]string) *ListOptions {
	o.Filters = value
	return o
}

// GetFilters returns value of field Filters
func (o *ListOptions) GetFilters() map[string][]string {
	if o.Filters == nil {
		var z map[string][]string
		return z
	}
	return o.Filters
}

// WithLast set field Last to given value
func (o *ListOptions) WithLast(value int) *ListOptions {
	o.Last = &value
	return o
}

// GetLast returns value of field Last
func (o *ListOptions) GetLast() int {
	if o.Last == nil {
		var z int
		return z
	}
	return *o.Last
}

// WithNamespace set field Namespace to given value
func (o *ListOptions) WithNamespace(value bool) *ListOptions {
	o.Namespace = &value
	return o
}

// GetNamespace returns value of field Namespace
func (o *ListOptions) GetNamespace() bool {
	if o.Namespace == nil {
		var z bool
		return z
	}
	return *o.Namespace
}

// WithSize set field Size to given value
func (o *ListOptions) WithSize(value bool) *ListOptions {
	o.Size = &value
	return o
}

// GetSize returns value of field Size
func (o *ListOptions) GetSize() bool {
	if o.Size == nil {
		var z bool
		return z
	}
	return *o.Size
}

// WithSync set field Sync to given value
func (o *ListOptions) WithSync(value bool) *ListOptions {
	o.Sync = &value
	return o
}

// GetSync returns value of field Sync
func (o *ListOptions) GetSync() bool {
	if o.Sync == nil {
		var z bool
		return z
	}
	return *o.Sync
}

repository: containers/podman

repo_name: containers/podman