text:
SUMMARY = "Connman config to static IPv4 address setup wired interface"
DESCRIPTION = "ConnMan configuration to set up to Wired network interface"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

FILES_${PN} = "${localstatedir}/*"

#                IP Address     / subnet mask
# CONNMAN_IPv4 = xxx.xxx.xxx.xxx/xxx.xxx.xxx.xxx

IPv4CFGF = "${D}${localstatedir}/lib/connman/wired.config"

do_install() {
    if [ -n "${CONNMAN_IPv4}" ] ; then
	install -d ${D}${localstatedir}/lib/connman

	echo "[global]" > ${IPv4CFGF}
	echo "Name = Wired" >> ${IPv4CFGF}
	echo "Description = Wired network configuration" >> ${IPv4CFGF}
	echo "" >> ${IPv4CFGF}
	echo "[service_ether]" >> ${IPv4CFGF}
	echo "Type = ethernet" >> ${IPv4CFGF}
	echo "IPv4 = ${CONNMAN_IPv4}" >> ${IPv4CFGF}

	if [ -n "${CONNMAN_IPv4_NS}" ] ; then
	    echo "Nameservers = ${CONNMAN_IPv4_NS}" \
		 >> ${D}${localstatedir}/lib/connman/wired.config
	fi
    else
	install -d ${D}${localstatedir}/lib/connman
	touch ${D}${localstatedir}/dummy
    fi
}

repository: mickey-happygolucky/meta-mpd-server

repo_name: mickey-happygolucky/meta-mpd-server


text:
// @flow
import { getCurrentSelectionsReducerDesc } from 'capture-core/reducers/descriptions/currentSelections.reducerDescriptionGetter';

export const currentSelectionsReducerDesc = getCurrentSelectionsReducerDesc({});

license_type: permissive

branch_name: refs/heads/master

gha_language: JavaScript

extension: js


text:
SUMMARY= "A collection of programs that provide support \
for TPM based attestation using the TPM quote mechanism. \
"
DESCRIPTION = "\
The TPM Quote Tools is a collection of programs that provide support \
for TPM based attestation using the TPM quote mechanism.  The manual \
page for tpm_quote_tools provides a usage overview. \
\
TPM Quote Tools has been tested with TrouSerS on Linux and NTRU on \
Windows XP.  It was ported to Windows using MinGW and MSYS. \
"
SECTION = "security/tpm"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://COPYING;md5=8ec30b01163d242ecf07d9cd84e3611f"

DEPENDS = "libtspi tpm-tools"

PV = "1.0.4+git${SRCPV}"

SRC_URI = "\
    git://git.code.sf.net/p/tpmquotetools/tpm-quote-tools;branch=master \
"
SRCREV = "d70da818778f641c05de8eb205fb72782e5555db"

S = "${WORKDIR}/git"

inherit autotools

license: MIT

gha_license_id: MIT

gha_language: BitBake

extension: bb


text:
COMPATIBLE_MACHINE = "nslu2"

IMAGE_BASENAME = "unslung"
IMAGE_NAME = "${IMAGE_BASENAME}-${MACHINE}-${DISTRO_VERSION}"

IMAGE_LINGUAS = ""
USE_DEVFS = "1"

DEPENDS  = "virtual/kernel \
	${UNSLUNG_EXTRA_DEPENDS}"

IMAGE_INSTALL = "kernel update-modules unslung-rootfs \
	libc6-unslung slingbox ipkg libipkg libgcc \
	kernel-module-netconsole \
	${UNSLUNG_EXTRA_INSTALL}"

IMAGE_PREPROCESS_COMMAND += "unslung_clean_image; "

inherit image

# Note that anything in this function must be repeatable without having to rebuild the rootfs
unslung_clean_image () {

	# Remove the patches
	rm -rf ${IMAGE_ROOTFS}/patches

	# Remove the kernel image
	rm -rf ${IMAGE_ROOTFS}/boot
	rm -f ${IMAGE_ROOTFS}${libdir}/ipkg/alternatives/zImage
	# And remove the post and pre scripts for the kernel; saves flash space
	rm -f ${IMAGE_ROOTFS}${libdir}/ipkg/info/kernel.postinst
	rm -f ${IMAGE_ROOTFS}${libdir}/ipkg/info/kernel.postrm

	# Remove all the postinst scripts; don't need them.  But keep the
	# postrm scripts just in case we need to remove something.
	rm -f ${IMAGE_ROOTFS}${libdir}/ipkg/info/*.postinst

	# Remove info from the local feed used to build the image
	rm -f ${IMAGE_ROOTFS}${libdir}/ipkg/lists/*
	rm -f ${IMAGE_ROOTFS}/${sysconfdir}/version

	# Tidy up some thing which are in the wrong place
	mv ${IMAGE_ROOTFS}${libdir}/libipkg* ${IMAGE_ROOTFS}/lib/

	# Remove the ipkg symlink - unsling puts it back in
	rm -f ${IMAGE_ROOTFS}${bindir}/ipkg
	# and make the ipkg symlink point to the ipkg-fl utility instead.
	ln -s ipkg-fl ${IMAGE_ROOTFS}${bindir}/ipkg

	# Hack out the modutils stuff - it's too hard to make it work
	rm -f ${IMAGE_ROOTFS}${libdir}/ipkg/info/update-modules.postinst
	rm -rf ${IMAGE_ROOTFS}/etc/rcS.d
	echo "#!/bin/sh" > ${IMAGE_ROOTFS}/usr/sbin/update-modules
	echo "exit 0" >> ${IMAGE_ROOTFS}/usr/sbin/update-modules
	chmod ugo+x ${IMAGE_ROOTFS}/usr/sbin/update-modules
	echo "#!/bin/sh" > ${IMAGE_ROOTFS}/sbin/depmod
	echo "exit 0" >> ${IMAGE_ROOTFS}/sbin/depmod
	chmod ugo+x ${IMAGE_ROOTFS}/sbin/depmod

	# Don't need this empty directory hanging around
	rm -rf ${IMAGE_ROOTFS}/lib/modules/2.4.22-xfs/pcmcia

	# Strip symbols and fix permissions on the libgcc_s.so.1 library
	${STRIP} ${IMAGE_ROOTFS}/lib/libgcc_s.so.1
	chmod ugo+x ${IMAGE_ROOTFS}/lib/libgcc_s.so.1

	# FIXME: change made 24 Jul 2006 by the OE folks changes the "strip"
	# behavior to create an extra file named .debug/<filename> containing
	# the stripped symbols.  These files are supposed to be packaged
	# separately by the standard bb routines, but for some reason this
	# does not alway occur.  This extremely ugly step is to remove the
	# debug cruft from the rootfs if any are left in the obvious locations.
	# Once someone figures out why and what the right way is to fix this,
	# this code should be removed.

	rm -rf ${IMAGE_ROOTFS}/bin/.debug
	rm -rf ${IMAGE_ROOTFS}/sbin/.debug
	rm -rf ${IMAGE_ROOTFS}/lib/.debug
	rm -rf ${IMAGE_ROOTFS}/usr/bin/.debug
	rm -rf ${IMAGE_ROOTFS}/usr/sbin/.debug
	rm -rf ${IMAGE_ROOTFS}/usr/lib/.debug

# MJW - Experimental - just to make space; remove before releasing!
#	#### Hack to make space for testing!  REMOVE THIS!
#	rm -rf ${IMAGE_ROOTFS}/etc/samba/codepages/unicode_map.850
#	rm -rf ${IMAGE_ROOTFS}/bin/ftp
#	#### End of Hack!

}

# Override this function for unslung, since we don't need Apex.

nslu2_pack_image () {
	slugimage -p \
		-b ${STAGING_LIBDIR}/nslu2-binaries/RedBoot \
		-s ${STAGING_LIBDIR}/nslu2-binaries/SysConf \
		-k ${DEPLOY_DIR_IMAGE}/zImage-${MACHINE}.bin \
		-r Ramdisk:1,Flashdisk:${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.rootfs.jffs2 \
		-m ${STAGING_FIRMWARE_DIR}/NPE-B \
		-t ${STAGING_LIBDIR}/nslu2-binaries/Trailer \
		-o ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}-nslu2.bin
	slugimage -F -p \
		-b ${STAGING_LIBDIR}/nslu2-binaries/RedBoot \
		-s ${STAGING_LIBDIR}/nslu2-binaries/SysConf \
		-k ${DEPLOY_DIR_IMAGE}/zImage-${MACHINE}.bin \
		-r Ramdisk:1,Flashdisk:${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.rootfs.jffs2 \
		-m ${STAGING_FIRMWARE_DIR}/NPE-B \
		-t ${STAGING_LIBDIR}/nslu2-binaries/Trailer \
		-o ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}-nslu2-16mb.bin
}


text:
@article{Johnson2020,
 abstract = {Auxotrophy, or an organism's requirement for an exogenous source of an organic molecule, is widespread throughout species and ecosystems. Auxotrophy can result in obligate interactions between organisms, influencing ecosystem structure and community composition. We explore how auxotrophy-induced interactions between aquatic microorganisms affect microbial community structure and stability. While some studies have documented auxotrophy in aquatic microorganisms, these studies are not widespread, and we therefore do not know the full extent of auxotrophic interactions in aquatic environments. Current theoretical and experimental work suggests that auxotrophy links microbial community members through a complex web of metabolic dependencies. We discuss the proposed ways in which auxotrophy may enhance or undermine the stability of aquatic microbial communities, highlighting areas where our limited understanding of these interactions prevents us from being able to predict the ecological implications of auxotrophy. Finally, we examine an example of auxotrophy in harmful algal blooms to place this often theoretical discussion in a field context where auxotrophy may have implications for the development and robustness of algal bloom communities. We seek to draw attention to the relationship between auxotrophy and community stability in an effort to encourage further field and theoretical work that explores the underlying principles of microbial interactions.},
 author = {Johnson, Winifred M and Alexander, Harriet and Bier, Raven L and Miller, Dan R and Muscarella, Mario E and Pitz, Kathleen J and Smith, Heidi},
 doi = {10.1093/femsec/fiaa115},
 file = {:Users/halexand/Library/Application Support/Mendeley Desktop/Downloaded/Johnson et al. - 2020 - Auxotrophic interactions A stabilizing attribute of aquatic microbial communities.pdf:pdf},
 issn = {0168-6496},
 journal = {FEMS Microbiology Ecology},
 keywords = {community},
 month = {jun},
 publisher = {Oxford University Press (OUP)},
 title = {Auxotrophic interactions: A stabilizing attribute of aquatic microbial communities?},
 year = {2020}
}

repository: AlexanderLabWHOI/academic-kickstart

repo_name: AlexanderLabWHOI/academic-kickstart

gha_language: TeX

extension: bib


text:
@article{example,
  title = {The prognostic value of KRAS mutation subtypes and PD-L1 expression in patients with lung adenocarcinoma},
  author={Luwei Tao, Ruoyu Miao, Tarek Mekhail, Jingxin Sun, Lingbin Meng, Cheng Fang, Jian Guan, Akriti Jain, Yuan Du, Amanda Allen, Brenda L Rzeszutko, Mark A Socinski, Chung-Che Chang},
  journal = {Clinical Lung Cancer},
  year    = 2020

}

repository: YuanEldaif/YuanDu-Netlify

repo_name: YuanEldaif/YuanDu-Netlify


text:
package paddlectl

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"os"
	"path"
	"strings"

	"k8s.io/client-go/pkg/api/v1"

	paddlejob "github.com/PaddlePaddle/cloud/go/api"
	"github.com/PaddlePaddle/cloud/go/utils/config"
	kubeutil "github.com/PaddlePaddle/cloud/go/utils/kubeutil"
	"github.com/golang/glog"
	"github.com/google/subcommands"
	apiresource "k8s.io/apimachinery/pkg/api/resource"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

const (
	invalidJobName = "jobname can not contain '.' or '_'"
)

// Config is global config object for paddlectl commandline
var Config = config.ParseDefaultConfig()

// SubmitCmd define the subcommand of submitting paddle training jobs.
type SubmitCmd struct {
	Jobname    string `json:"name"`
	Jobpackage string `json:"jobPackage"`
	CPU        int    `json:"cpu"`
	GPU        int    `json:"gpu"`
	Memory     string `json:"memory"`
	Pservers   int    `json:"pservers"`
	PSCPU      int    `json:"pscpu"`
	PSMemory   string `json:"psmemory"`
	Entry      string `json:"entry"`
	Topology   string `json:"topology"`
	Datacenter string `json:"datacenter"`
	Passes     int    `json:"passes"`

	// docker image to run jobs
	Image    string `json:"image"`
	Registry string `json:"registry"`

	// Alpha features:
	// TODO: separate API versions
	FaultTolerant bool `json:"faulttolerant"`
	MaxInstance   int  `json:"maxInstance"`
	MinInstance   int  `json:"minInstance"`

	// TODO(gongwb): init config in memory.
	KubeConfig string `json:"kubeconfig"`

	// TODO(gongwb): create from yaml.
}

// Name is subcommands name.
func (*SubmitCmd) Name() string { return "submit" }

// Synopsis is subcommands synopsis.
func (*SubmitCmd) Synopsis() string { return "Submit job to PaddlePaddle Cloud." }

// Usage is subcommands Usage.
func (*SubmitCmd) Usage() string {
	return `submit [options] <package path>:
	Submit job to PaddlePaddle Cloud.
	Options:
`
}

func (p *SubmitCmd) getTrainer() *paddlejob.TrainerSpec {
	return &paddlejob.TrainerSpec{
		Entrypoint:  p.Entry,
		Workspace:   getJobPfsPath(p.Jobpackage, p.Jobname),
		MinInstance: p.MinInstance,
		MaxInstance: p.MaxInstance,
		Resources: v1.ResourceRequirements{
			Limits: v1.ResourceList{
				"cpu":    *apiresource.NewQuantity(int64(p.CPU), apiresource.DecimalSI),
				"memory": apiresource.MustParse(p.Memory),
			},
			Requests: v1.ResourceList{
				"cpu":    *apiresource.NewQuantity(int64(p.CPU), apiresource.DecimalSI),
				"memory": apiresource.MustParse(p.Memory),
			},
		},
	}
}

func (p *SubmitCmd) getPserver() *paddlejob.PserverSpec {
	return &paddlejob.PserverSpec{
		// TODO(gongwb):Pserver can be auto-scaled?
		MinInstance: p.Pservers,
		MaxInstance: p.Pservers,
		Resources: v1.ResourceRequirements{
			Limits: v1.ResourceList{
				"cpu":    *apiresource.NewQuantity(int64(p.PSCPU), apiresource.DecimalSI),
				"memory": apiresource.MustParse(p.PSMemory),
			},
			Requests: v1.ResourceList{
				"cpu":    *apiresource.NewQuantity(int64(p.PSCPU), apiresource.DecimalSI),
				"memory": apiresource.MustParse(p.PSMemory),
			},
		},
	}
}

func (p *SubmitCmd) getMaster() *paddlejob.MasterSpec {
	return &paddlejob.MasterSpec{}
}

// GetTrainingJob get's paddlejob.TrainingJob struct filed by Submitcmd paramters.
func (p *SubmitCmd) GetTrainingJob() *paddlejob.TrainingJob {
	t := paddlejob.TrainingJob{
		metav1.TypeMeta{
			Kind:       "TrainingJob",
			APIVersion: "paddlepaddle.org/v1",
		},
		metav1.ObjectMeta{
			Name:      p.Jobname,
			Namespace: kubeutil.NameEscape(Config.ActiveConfig.Username),
		},

		// General job attributes.
		paddlejob.TrainingJobSpec{
			Image: p.Image,

			// TODO(gongwb): init them?

			FaultTolerant: p.FaultTolerant,
			Passes:        p.Passes,

			Trainer: *p.getTrainer(),
			Pserver: *p.getPserver(),
			Master:  *p.getMaster(),
		},
		paddlejob.TrainingJobStatus{},
	}

	if glog.V(3) {
		glog.Infof("GetTrainingJob: %s\n", t)
	}
	return &t
}

// SetFlags registers subcommands flags.
func (p *SubmitCmd) SetFlags(f *flag.FlagSet) {
	f.StringVar(&p.KubeConfig, "kubeconfig", "", "Kubernetes config.")
	f.StringVar(&p.Jobname, "jobname", "paddle-cluster-job", "Cluster job name.")
	f.IntVar(&p.CPU, "cpu", 1, "CPU resource each trainer will use. Defaults to 1.")
	f.IntVar(&p.GPU, "gpu", 0, "GPU resource each trainer will use. Defaults to 0.")
	f.StringVar(&p.Memory, "memory", "1Gi", " Memory resource each trainer will use. Defaults to 1Gi.")
	f.IntVar(&p.Pservers, "pservers", 1, "Number of parameter servers. Defaults equal to -p")
	f.IntVar(&p.PSCPU, "pscpu", 1, "Parameter server CPU resource. Defaults to 1.")
	f.StringVar(&p.PSMemory, "psmemory", "1Gi", "Parameter server momory resource. Defaults to 1Gi.")
	f.StringVar(&p.Entry, "entry", "", "Command of starting trainer process. Defaults to paddle train")
	f.StringVar(&p.Topology, "topology", "", "Will Be Deprecated .py file contains paddle v1 job configs")
	f.IntVar(&p.Passes, "passes", 1, "Pass count for training job")
	f.StringVar(&p.Image, "image", "paddlepaddle/paddlecloud-job", "Runtime Docker image for the job")
	f.StringVar(&p.Registry, "registry", "", "Registry secret name for the runtime Docker image")
	f.IntVar(&p.MinInstance, "min_instance", 1, "The minimum number of trainers"+
		"only used fo faulttolerant. Default to 1.")
	f.IntVar(&p.MaxInstance, "max_instance", 1, "The minimum number of trainers,"+
		"only used for faulttolerant, Default to 1.")
	f.BoolVar(&p.FaultTolerant, "faulttolerant", false, "if true, use new fault-tolerant pservers")
}

// Execute submit command.
func (p *SubmitCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
	if f.NArg() != 1 {
		f.Usage()
		return subcommands.ExitFailure
	}

	p.Jobpackage = f.Arg(0)
	p.Datacenter = Config.ActiveConfig.Name

	s := NewSubmitter(p)
	if err := s.Submit(f.Arg(0), p.Jobname); err != nil {
		fmt.Fprintf(os.Stderr, "error submiting job: %v\n", err)
		return subcommands.ExitFailure
	}

	fmt.Printf("%s submited.\n", p.Jobname)
	return subcommands.ExitSuccess
}

// Submitter submit job to cloud.
type Submitter struct {
	args *SubmitCmd
}

// NewSubmitter returns a submitter object.
func NewSubmitter(cmd *SubmitCmd) *Submitter {
	s := Submitter{cmd}
	return &s
}

func getJobPfsPath(jobPackage, jobName string) string {
	_, err := os.Stat(jobPackage)
	if os.IsNotExist(err) {
		return jobPackage
	}

	return path.Join("/pfs", Config.ActiveConfig.Name, "home", Config.ActiveConfig.Username, "jobs", jobName)
}

// putFiles puts files to pfs and
// if jobPackage is not a local dir, skip uploading package.
func putFilesToPfs(jobPackage, jobName string) error {
	_, pkgerr := os.Stat(jobPackage)
	if pkgerr == nil {
		dest := getJobPfsPath(jobPackage, jobName)
		if !strings.HasSuffix(jobPackage, "/") {
			jobPackage = jobPackage + "/"
		}
		err := putFiles(jobPackage, dest)
		if err != nil {
			return err
		}
	} else if os.IsNotExist(pkgerr) {
		glog.Warning("jobpackage not a local dir, skip upload.")
	}

	return nil
}

func (s *Submitter) getKubeConfig() (string, error) {
	kubeconfig := s.args.KubeConfig
	if _, err := os.Stat(kubeconfig); err != nil {
		return "", fmt.Errorf("can't access kubeconfig '%s' error: %v", kubeconfig, err)
	}

	return kubeconfig, nil
}

// Submit current job.
func (s *Submitter) Submit(jobPackage string, jobName string) error {
	if err := checkJobName(jobName); err != nil {
		return err
	}

	if err := putFilesToPfs(jobPackage, jobName); err != nil {
		return err
	}

	kubeconfig, err := s.getKubeConfig()
	if err != nil {
		return err
	}

	client, clientset, err := kubeutil.CreateClient(kubeconfig)
	if err != nil {
		return err
	}

	namespace := kubeutil.NameEscape(Config.ActiveConfig.Username)
	if err := kubeutil.FindNamespace(clientset, namespace); err != nil {
		return err
	}

	return kubeutil.CreateTrainingJob(client, namespace, s.args.GetTrainingJob())
}

func checkJobName(jobName string) error {
	if strings.Contains(jobName, "_") || strings.Contains(jobName, ".") {
		return errors.New(invalidJobName)
	}

	return nil
}

repository: adrianvrabie/cloud

repo_name: adrianvrabie/cloud

branch_name: refs/heads/develop

extension: go


text:
package migrataur

import (
	"strings"
	"testing"
)

// assertInstance is a utility class used for testing only. Just drop this file somewhere
// and enjoy.
type assertInstance struct {
	t *testing.T
}

func assert(t *testing.T) *assertInstance {
	return &assertInstance{t: t}
}

func (a *assertInstance) contains(pattern, actual string) *assertInstance {
	if !strings.Contains(actual, pattern) {
		a.t.Errorf("Expected %s to contains %s", actual, pattern)
	}

	return a
}

func (a *assertInstance) true(actual bool) *assertInstance {
	if actual == false {
		a.t.Errorf("Expected to be true! Got: %t", actual)
	}

	return a
}

func (a *assertInstance) false(actual bool) *assertInstance {
	if actual == true {
		a.t.Errorf("Expected to be false! Got: %t", actual)
	}

	return a
}

func (a *assertInstance) equals(expected, actual interface{}) *assertInstance {
	if actual != expected {
		a.t.Errorf("Expected: %s, Got: %s", expected, actual)
	}

	return a
}

func (a *assertInstance) notEquals(expected, actual interface{}) *assertInstance {
	if actual == expected {
		a.t.Errorf("Should be not equals: %s, And: %s", expected, actual)
	}

	return a
}

func (a *assertInstance) notNil(actual interface{}) *assertInstance {
	if actual == nil {
		a.t.Error("Should not be nil!")
	}

	return a
}

func (a *assertInstance) nil(actual interface{}) *assertInstance {
	if actual != nil {
		a.t.Error(actual)
	}

	return a
}

func (a *assertInstance) applied(migrations []*Migration, names ...string) *assertInstance {
	lenActual, lenExpected := len(migrations), len(names)

	a.equals(lenExpected, lenActual)

	for i := 0; i < len(migrations); i++ {
		a.contains(names[i], migrations[i].Name)
	}

	return a
}

func (a *assertInstance) exists(path string) *assertInstance {
	if !mockFSAdapter.exists(path) {
		a.t.Errorf("File %s does not exists", path)
	}

	return a
}

func (a *assertInstance) notExists(path string) *assertInstance {
	if mockFSAdapter.exists(path) {
		a.t.Errorf("File %s should not exists", path)
	}

	return a
}

repository: YuukanOO/migrataur

repo_name: YuukanOO/migrataur


text:
import { mixins } from 'vue-class-component';
import { validationMixin } from 'vuelidate';

const fillPollTypeMixinConfig = {
  props: {
    poll: {
      required: true,
      type: Object
    },
    isLogged: {
      required: true,
      type: Boolean
    },
    user: {
      required: true,
      type: String
    },
    loading: {
      type: Boolean,
      default: false
    },
    config: Object
  },
  computed: {
    isAuthor() {
      return this.user === this.poll.user;
    },
    hasVoted() {
      return this.poll.answers.some(ans => ans.user === this.user);
    }
  },
  methods: {
    vote(payload) {
      this.$emit('vote', payload);
    },
    removeVote(user = this.user) {
      this.$emit('remove-vote', user);
    }
  }
};

export default mixins(validationMixin, fillPollTypeMixinConfig);

repository: Poll-me/poll-me-vue

repo_name: Poll-me/poll-me-vue


text:
# - Utility function for Find modules considering multiple possible versions
#
# Requires these CMake modules:
#  no additional modules required
#
# Original Author:
# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
# http://academic.cleardefinition.com
# Iowa State University HCI Graduate Program/VRAC
#
# Copyright 2009-2010, Iowa State University
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0

if(__check_version)
	return()
endif()
set(__check_version YES)

function(check_version var packagename version)
	# By default, we say that the version is good enough
	set(_result TRUE)

	# Was a version requested?  If so, what is our test condition?
	if(${packagename}_FIND_VERSION)
		if(${packagename}_FIND_VERSION_EXACT)
			# Yes, an exact == version was requested - check it.

			if(NOT "${version}" VERSION_EQUAL "${${packagename}_FIND_VERSION}")
				# version is not an exact match
				set(_result FALSE)
			endif()
		else()
			# Yes, a minimum >= version was requested - check it.

			if("${version}" VERSION_LESS "${${packagename}_FIND_VERSION}")
				# version is lower than requested
				set(_result FALSE)
			endif()

		endif()
	endif()

	# Return _result
	set(${var} ${_result} PARENT_SCOPE)
endfunction()

repository: rpavlik/cmake-modules

repo_name: rpavlik/cmake-modules

branch_name: refs/heads/main

gha_language: CMake

extension: cmake


text:
LICENSE = "LGPL"
DEPENDS = "glib-2.0 gnutls check"
DESCRIPTION = "Loudmouth is a lightweight and easy-to-use C library for programming with the Jabber protocol."

SRC_URI = "http://ftp.imendio.com/pub/imendio/${PN}/src/${PN}-${PV}.tar.gz"

inherit autotools pkgconfig

SRC_URI[md5sum] = "7abcba853b45a8595333da9aa807623c"
SRC_URI[sha256sum] = "f7614a14e2ae31b2ba22e419f78ba0d21afbb98fdeb24ae117327c3c8af05f1d"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD