text:
package odb

import (
	"bytes"
	"io"
	"io/ioutil"
)

// ObjectDatabase enables the reading and writing of objects against a storage
// backend.
type ObjectDatabase struct {
	// s is the storage backend which opens/creates/reads/writes.
	s storer
}

// FromFilesystem constructs an *ObjectDatabase instance that is backed by a
// directory on the filesystem. Specifically, this should point to:
//
//  /absolute/repo/path/.git/objects
func FromFilesystem(root string) (*ObjectDatabase, error) {
	return &ObjectDatabase{s: newFileStorer(root)}, nil
}

// Blob returns a *Blob as identified by the SHA given, or an error if one was
// encountered.
func (o *ObjectDatabase) Blob(sha []byte) (*Blob, error) {
	var b Blob

	if err := o.decode(sha, &b); err != nil {
		return nil, err
	}
	return &b, nil
}

// Tree returns a *Tree as identified by the SHA given, or an error if one was
// encountered.
func (o *ObjectDatabase) Tree(sha []byte) (*Tree, error) {
	var t Tree
	if err := o.decode(sha, &t); err != nil {
		return nil, err
	}
	return &t, nil
}

// Commit returns a *Commit as identified by the SHA given, or an error if one
// was encountered.
func (o *ObjectDatabase) Commit(sha []byte) (*Commit, error) {
	var c Commit

	if err := o.decode(sha, &c); err != nil {
		return nil, err
	}
	return &c, nil
}

// WriteBlob stores a *Blob on disk and returns the SHA it is uniquely
// identified by, or an error if one was encountered.
func (o *ObjectDatabase) WriteBlob(b *Blob) ([]byte, error) {
	buf, err := ioutil.TempFile("", "")
	if err != nil {
		return nil, err
	}
	defer buf.Close()

	sha, _, err := o.encodeBuffer(b, buf)
	if err != nil {
		return nil, err
	}
	return sha, nil
}

// WriteTree stores a *Tree on disk and returns the SHA it is uniquely
// identified by, or an error if one was encountered.
func (o *ObjectDatabase) WriteTree(t *Tree) ([]byte, error) {
	sha, _, err := o.encode(t)
	if err != nil {
		return nil, err
	}
	return sha, nil
}

// WriteCommit stores a *Commit on disk and returns the SHA it is uniquely
// identified by, or an error if one was encountered.
func (o *ObjectDatabase) WriteCommit(c *Commit) ([]byte, error) {
	sha, _, err := o.encode(c)
	if err != nil {
		return nil, err
	}
	return sha, nil
}

// encode encodes and saves an object to the storage backend and uses an
// in-memory buffer to calculate the object's encoded body.
func (d *ObjectDatabase) encode(object Object) (sha []byte, n int64, err error) {
	return d.encodeBuffer(object, bytes.NewBuffer(nil))
}

// encodeBuffer encodes and saves an object to the storage backend by using the
// given buffer to calculate and store the object's encoded body.
func (d *ObjectDatabase) encodeBuffer(object Object, buf io.ReadWriter) (sha []byte, n int64, err error) {
	cn, err := object.Encode(buf)
	if err != nil {
		return nil, 0, err
	}

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

	to := NewObjectWriter(tmp)
	if _, err = to.WriteHeader(object.Type(), int64(cn)); err != nil {
		return nil, 0, err
	}

	if seek, ok := buf.(io.Seeker); ok {
		if _, err = seek.Seek(0, io.SeekStart); err != nil {
			return nil, 0, err
		}
	}

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

	if err = to.Close(); err != nil {
		return nil, 0, err
	}

	if _, err := tmp.Seek(0, io.SeekStart); err != nil {
		return nil, 0, err
	}
	return d.save(to.Sha(), tmp)
}

// save writes the given buffer to the location given by the storer "o.s" as
// identified by the sha []byte.
func (o *ObjectDatabase) save(sha []byte, buf io.Reader) ([]byte, int64, error) {
	n, err := o.s.Store(sha, buf)

	return sha, n, err
}

// decode decodes an object given by the sha "sha []byte" into the given object
// "into", or returns an error if one was encountered.
func (o *ObjectDatabase) decode(sha []byte, into Object) error {
	f, err := o.s.Open(sha)
	if err != nil {
		return err
	}

	r, err := NewObjectReadCloser(f)
	if err != nil {
		return err
	}

	typ, size, err := r.Header()
	if err != nil {
		return err
	} else if typ != into.Type() {
		return &UnexpectedObjectType{Got: typ, Wanted: into.Type()}
	}

	if _, err = into.Decode(r, size); err != nil {
		return err
	}

	if err = r.Close(); err != nil {
		return err
	}
	return nil
}

repository: hydyne/git-lfs

repo_name: hydyne/git-lfs


text:
package model

type Options struct {
	FallBackUser string `hcl:"fallback_user"`
	Meta         Meta   `hcl:"meta"`
}

type Meta struct {
	User           string `hcl:"user"`
	Groups         string `hcl:"groups"`
	HostVarsPrefix string `hcl:"hostvars_prefix"`
	Env            string `hcl:"environment"`
}

repository: xlucas/ansible-openstack-inventory

license_type: permissive

repo_name: xlucas/ansible-openstack-inventory

branch_name: refs/heads/master

extension: go


text:
@article{clowers2008dual,
 author = {Clowers, Brian H and Dodds, Eric D and Seipert, Richard R and Lebrilla, Carlito B},
 doi = {10.1016/j.ab.2008.06.041},
 journal = {Analytical biochemistry},
 number = {2},
 pages = {205--213},
 publisher = {Elsevier},
 title = {Dual polarity accurate mass calibration for electrospray ionization and matrix-assisted laser desorption/ionization mass spectrometry using maltooligosaccharides},
 volume = {381},
 year = {2008}
}

license: MIT

repository: bhclowers/academic-clowers

repo_name: bhclowers/academic-clowers

extension: bib


text:
SUMMARY = "Chassis Power Control"
HOMEPAGE = "https://github.com/openbmc/phosphor-power-control"
PR = "r1"
PV = "1.0+git${SRCPV}"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=86d3f3a95c324c9479bd8986968f4327"

inherit autotools pkgconfig

DEPENDS += "autoconf-archive-native"
DEPENDS += "phosphor-logging"
DEPENDS += "nlohmann-json"
DEPENDS += "gpioplus"

S = "${WORKDIR}/git"

SRC_URI = "git://github.com/openbmc/phosphor-power-control"
SRCREV = "ca9aa00180423b548369a7485bbca641581cc1ab"

repository: Intel-BMC/openbmc

repo_name: Intel-BMC/openbmc

gha_license_id: NOASSERTION

gha_language: Python

extension: bb


text:
#----------------------------------------------------------------
# Generated CMake target import file for configuration "Release".
#----------------------------------------------------------------

# Commands may need to know the format version.
set(CMAKE_IMPORT_FILE_VERSION 1)

# Import target "ik" for configuration "Release"
set_property(TARGET ik APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(ik PROPERTIES
  IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/ik.lib"
  )

list(APPEND _IMPORT_CHECK_TARGETS ik )
list(APPEND _IMPORT_CHECK_FILES_FOR_ik "${_IMPORT_PREFIX}/lib/ik.lib" )

# Commands beyond this point should not need to know the version.
set(CMAKE_IMPORT_FILE_VERSION)

repository: chic-yukim/CRAvatar

repo_name: chic-yukim/CRAvatar

extension: cmake


text:
@article{thorwirth_descendant_2020,
 abstract = {The carbon chain ions HC 3 O + and HC 3 S + – longer variants of the famous ‘X-ogen’ line carrier HCO + – have been observed for the first time using two cryogenic 22-pole ion trap apparatus (FELion, Coltrap) and two different light sources: the Free Electron Laser for Infrared eXperiments (FELIX), which was operated between 460 and 2500 cm − 1 , and an optical parametric oscillator operating near 3200 cm − 1 ; signals from both experiments were detected by infrared predissociation action spectroscopy. The majority of vibrational fundamentals were observed for both ions and their wavenumbers compare very favourably with results from high-level anharmonic force field calculations performed here at the coupled-cluster singles and doubles level augmented by a perturbative treatment of triple excitations, CCSD(T). As the action scheme employed here probes the Ne-tagged weakly bound variants, Ne–HC 3 O + and Ne–HC 3 S + , corresponding calculations of these systems were also performed. Differences in the structures and molecular force fields between the bare ions and their Ne-tagged complexes are found to be very small.},
 author = {Thorwirth, Sven and Harding, Michael E. and Asvany, Oskar and Brünken, Sandra and Jusko, Pavol and Lee, Kin Long Kelvin and Salomon, Thomas and McCarthy, Michael C. and Schlemmer, Stephan},
 doi = {10.1080/00268976.2020.1776409},
 file = {Snapshot:/home/kelvin/Dropbox (MIT)/Papers/Zotero/storage/FNAACPXQ/00268976.2020.html:text/html},
 issn = {0026-8976},
 journal = {Molecular Physics},
 keywords = {action spectroscopy, Ion traps, vibrational spectroscopy},
 month = {June},
 note = {ZSCC: NoCitationData[s0]
Publisher: Taylor & Francis
_eprint: https://doi.org/10.1080/00268976.2020.1776409},
 number = {0},
 pages = {e1776409},
 shorttitle = {Descendant of the X-ogen carrier and a ‘mass of 69’},
 title = {Descendant of the X-ogen carrier and a ‘mass of 69’: infrared action spectroscopic detection of HC3O+ and HC3S+},
 url = {https://doi.org/10.1080/00268976.2020.1776409},
 urldate = {2020-06-12},
 volume = {0},
 year = {2020}
}

repository: MartinDrumel/personal-website

repo_name: MartinDrumel/personal-website


text:
DESCRIPTION = "A C++ Wrapper for the directfb framebuffer library."
HOMEPAGE = "http://directfb.org"
SECTION = "libs"
MAINTAINER = "Michael 'Mickey' Lauer <mickey@Vanille.de>"
DEPENDS = "directfb"
LICENSE = "LGPL"

SRC_URI = "http://www.directfb.org/downloads/Extras/++DFB-${PV}.tar.gz"
S = "${WORKDIR}/++DFB-${PV}"

inherit autotools pkgconfig

do_stage() {
	autotools_stage_all
}

do_install() {
        oe_runmake 'DESTDIR=${D}' install
}

repository: BackupTheBerlios/openslug-svn

repo_name: BackupTheBerlios/openslug-svn


text:
/*
Copyright 2018 The Knative Authors

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

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

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

package testing

import (
	sourcesv1alpha1 "github.com/n3wscott/sources/pkg/apis/sources/v1alpha1"
	fakesourcesclientset "github.com/n3wscott/sources/pkg/client/clientset/versioned/fake"
	sourceslisters "github.com/n3wscott/sources/pkg/client/listers/sources/v1alpha1"
	appsv1 "k8s.io/api/apps/v1"
	corev1 "k8s.io/api/core/v1"
	rbacv1 "k8s.io/api/rbac/v1"
	apiextensionsv1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
	fakeapiextensionsclientset "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/fake"
	apiextensionsv1beta1listers "k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1"
	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	fakekubeclientset "k8s.io/client-go/kubernetes/fake"
	appsv1listers "k8s.io/client-go/listers/apps/v1"
	corev1listers "k8s.io/client-go/listers/core/v1"
	rbacv1listers "k8s.io/client-go/listers/rbac/v1"
	"k8s.io/client-go/tools/cache"
	fakeeventingclientset "knative.dev/eventing/pkg/client/clientset/versioned/fake"
	fakesharedclientset "knative.dev/pkg/client/clientset/versioned/fake"
	"knative.dev/pkg/reconciler/testing"
	fakeservingclientset "knative.dev/serving/pkg/client/clientset/versioned/fake"
)

var subscriberAddToScheme = func(scheme *runtime.Scheme) error {
	scheme.AddKnownTypeWithName(schema.GroupVersionKind{Group: "testing.eventing.knative.dev", Version: "v1alpha1", Kind: "Subscriber"}, &unstructured.Unstructured{})
	return nil
}

var sinkAddToScheme = func(scheme *runtime.Scheme) error {
	scheme.AddKnownTypeWithName(schema.GroupVersionKind{Group: "testing.eventing.knative.dev", Version: "v1alpha1", Kind: "Sink"}, &unstructured.Unstructured{})
	return nil
}

var clientSetSchemes = []func(*runtime.Scheme) error{
	fakekubeclientset.AddToScheme,
	fakesharedclientset.AddToScheme,
	fakeeventingclientset.AddToScheme,
	fakeservingclientset.AddToScheme,
	fakesourcesclientset.AddToScheme,
	fakeapiextensionsclientset.AddToScheme,
	subscriberAddToScheme,
	sinkAddToScheme,
}

type Listers struct {
	sorter testing.ObjectSorter
}

func NewScheme() *runtime.Scheme {
	scheme := runtime.NewScheme()

	for _, addTo := range clientSetSchemes {
		addTo(scheme)
	}
	return scheme
}

func NewListers(objs []runtime.Object) Listers {
	scheme := runtime.NewScheme()

	for _, addTo := range clientSetSchemes {
		addTo(scheme)
	}

	ls := Listers{
		sorter: testing.NewObjectSorter(scheme),
	}

	ls.sorter.AddObjects(objs...)

	return ls
}

func (l *Listers) indexerFor(obj runtime.Object) cache.Indexer {
	return l.sorter.IndexerForObjectType(obj)
}

// TODO(spencer-p) Some of these probably need to be changed or are unnecessary

func (l *Listers) GetKubeObjects() []runtime.Object {
	return l.sorter.ObjectsForSchemeFunc(fakekubeclientset.AddToScheme)
}

func (l *Listers) GetEventingObjects() []runtime.Object {
	return l.sorter.ObjectsForSchemeFunc(fakeeventingclientset.AddToScheme)
}

func (l *Listers) GetServingObjects() []runtime.Object {
	return l.sorter.ObjectsForSchemeFunc(fakeservingclientset.AddToScheme)
}

func (l *Listers) GetSinkObjects() []runtime.Object {
	return l.sorter.ObjectsForSchemeFunc(sinkAddToScheme)
}

func (l *Listers) GetAllObjects() []runtime.Object {
	return l.GetObjectsFrom(
		l.GetEventingObjects,
		l.GetServingObjects,
		l.GetSinkObjects,
		l.GetKubeObjects,
	)
}

func (l *Listers) GetObjectsFrom(getters ...func() []runtime.Object) []runtime.Object {
	var all []runtime.Object
	for _, get := range getters {
		all = append(all, get()...)
	}
	return all
}

func (l *Listers) GetSourcesObjects() []runtime.Object {
	return l.sorter.ObjectsForSchemeFunc(fakesourcesclientset.AddToScheme)
}

func (l *Listers) GetSharedObjects() []runtime.Object {
	return l.sorter.ObjectsForSchemeFunc(fakesharedclientset.AddToScheme)
}

func (l *Listers) GetJobSourceLister() sourceslisters.JobSourceLister {
	return sourceslisters.NewJobSourceLister(l.indexerFor(&sourcesv1alpha1.JobSource{}))
}

func (l *Listers) GetCronJobSourceLister() sourceslisters.CronJobSourceLister {
	return sourceslisters.NewCronJobSourceLister(l.indexerFor(&sourcesv1alpha1.CronJobSource{}))
}

func (l *Listers) GetServiceSourceLister() sourceslisters.ServiceSourceLister {
	return sourceslisters.NewServiceSourceLister(l.indexerFor(&sourcesv1alpha1.ServiceSource{}))
}

func (l *Listers) GetDeploymentLister() appsv1listers.DeploymentLister {
	return appsv1listers.NewDeploymentLister(l.indexerFor(&appsv1.Deployment{}))
}

func (l *Listers) GetK8sServiceLister() corev1listers.ServiceLister {
	return corev1listers.NewServiceLister(l.indexerFor(&corev1.Service{}))
}

func (l *Listers) GetNamespaceLister() corev1listers.NamespaceLister {
	return corev1listers.NewNamespaceLister(l.indexerFor(&corev1.Namespace{}))
}

func (l *Listers) GetServiceAccountLister() corev1listers.ServiceAccountLister {
	return corev1listers.NewServiceAccountLister(l.indexerFor(&corev1.ServiceAccount{}))
}

func (l *Listers) GetServiceLister() corev1listers.ServiceLister {
	return corev1listers.NewServiceLister(l.indexerFor(&corev1.Service{}))
}

func (l *Listers) GetRoleBindingLister() rbacv1listers.RoleBindingLister {
	return rbacv1listers.NewRoleBindingLister(l.indexerFor(&rbacv1.RoleBinding{}))
}

func (l *Listers) GetEndpointsLister() corev1listers.EndpointsLister {
	return corev1listers.NewEndpointsLister(l.indexerFor(&corev1.Endpoints{}))
}

func (l *Listers) GetConfigMapLister() corev1listers.ConfigMapLister {
	return corev1listers.NewConfigMapLister(l.indexerFor(&corev1.ConfigMap{}))
}

func (l *Listers) GetCustomResourceDefinitionLister() apiextensionsv1beta1listers.CustomResourceDefinitionLister {
	return apiextensionsv1beta1listers.NewCustomResourceDefinitionLister(l.indexerFor(&apiextensionsv1beta1.CustomResourceDefinition{}))
}

repository: spencer-p/sources

repo_name: spencer-p/sources


text:
DESCRIPTION = "StreamRipper lets you record streaming mp3 to your hard drive."
SECTION = "console/multimedia"
LICENSE = "GPL"

SRC_URI = "${SOURCEFORGE_MIRROR}/streamripper/streamripper-${PV}.tar.gz"

inherit autotools

SRC_URI[md5sum] = "57cd09098917bda29f841d366649681c"
SRC_URI[sha256sum] = "1747aee9fa4cc09b49e0fb14baace3293f8f870c0de27fd3550cde21d99e9cd7"

repository: libo/openembedded

repo_name: libo/openembedded

branch_name: HEAD


text:
require firmware.inc
require firmiszip.inc
# require firmware-cip.inc

ARM_INSTRUCTION_SET = "arm"

PR = "r0"

DL_URI = "http://downloadcenter.samsung.com/content/FM/200911/20091119185403937/${MACHINE}[__________PX__].exe"

# S = "${WORKDIR}
P_OFFSET = "3969566"
P_LINE = ";/mtd_rwarea/rcSGO     &"
require firmware-package.bbclass

repository: metalsky/SamyGO

repo_name: metalsky/SamyGO


text:
SUMMARY = "A tool for generating C bindings to Rust code."
HOMEPAGE = "https://github.com/eqrion/cbindgen"
LICENSE = "MPL-2.0"

SRC_URI += "crate://crates.io/cbindgen/${PV}"
S = "${WORKDIR}/cbindgen-${PV}"

SRC_URI += " \
    crate://crates.io/atty/0.2.14 \
    crate://crates.io/autocfg/1.1.0 \
    crate://crates.io/bitflags/1.3.2 \
    crate://crates.io/cfg-if/1.0.0 \
    crate://crates.io/clap/3.2.25 \
    crate://crates.io/clap_lex/0.2.4 \
    crate://crates.io/fastrand/1.9.0 \
    crate://crates.io/hashbrown/0.12.3 \
    crate://crates.io/heck/0.4.1 \
    crate://crates.io/hermit-abi/0.1.19 \
    crate://crates.io/indexmap/1.9.3 \
    crate://crates.io/instant/0.1.12 \
    crate://crates.io/itoa/1.0.6 \
    crate://crates.io/lazy_static/1.4.0 \
    crate://crates.io/libc/0.2.144 \
    crate://crates.io/lock_api/0.4.9 \
    crate://crates.io/log/0.4.17 \
    crate://crates.io/os_str_bytes/6.5.0 \
    crate://crates.io/parking_lot/0.11.2 \
    crate://crates.io/parking_lot_core/0.8.6 \
    crate://crates.io/proc-macro2/1.0.58 \
    crate://crates.io/quote/1.0.27 \
    crate://crates.io/redox_syscall/0.2.16 \
    crate://crates.io/remove_dir_all/0.5.3 \
    crate://crates.io/ryu/1.0.13 \
    crate://crates.io/scopeguard/1.1.0 \
    crate://crates.io/serde/1.0.163 \
    crate://crates.io/serde_derive/1.0.163 \
    crate://crates.io/serde_json/1.0.96 \
    crate://crates.io/serial_test/0.5.1 \
    crate://crates.io/serial_test_derive/0.5.1 \
    crate://crates.io/smallvec/1.10.0 \
    crate://crates.io/strsim/0.10.0 \
    crate://crates.io/syn/1.0.109 \
    crate://crates.io/syn/2.0.16 \
    crate://crates.io/tempfile/3.3.0 \
    crate://crates.io/termcolor/1.2.0 \
    crate://crates.io/textwrap/0.16.0 \
    crate://crates.io/toml/0.5.11 \
    crate://crates.io/unicode-ident/1.0.8 \
    crate://crates.io/winapi-i686-pc-windows-gnu/0.4.0 \
    crate://crates.io/winapi-util/0.1.5 \
    crate://crates.io/winapi-x86_64-pc-windows-gnu/0.4.0 \
    crate://crates.io/winapi/0.3.9 \
"

LIC_FILES_CHKSUM = " \
    file://LICENSE;md5=9741c346eef56131163e13b9db1241b3 \
"

inherit cargo
BBCLASSEXTEND = "native"

repository: meta-rust/meta-rust

repo_name: meta-rust/meta-rust

gha_license_id: MIT

gha_language: NASL


text:
package handlers

import (
	"fmt"
	"net/http"

	"github.com/takama/k8sapp/pkg/config"
	"github.com/takama/k8sapp/pkg/logger"
	"github.com/takama/k8sapp/pkg/router"
	"github.com/takama/k8sapp/pkg/version"
)

// Handler defines common part for all handlers
type Handler struct {
	logger logger.Logger
	config *config.Config
}

// New returns new instance of the Handler
func New(logger logger.Logger, config *config.Config) *Handler {
	return &Handler{
		logger: logger,
		config: config,
	}
}

// Base handler implements middleware logic
func (h *Handler) Base(handle func(router.Control)) func(router.Control) {
	return func(c router.Control) {

		// TODO: Add custom logic here

		handle(c)
	}
}

// Root handler shows version
func (h *Handler) Root(c router.Control) {
	c.Code(http.StatusOK)
	c.Write(fmt.Sprintf("%s v%s", config.SERVICENAME, version.RELEASE))
}


text:
@InProceedings{guerif08a,
  title = {Unsupervised Variable Selection: when random rankings sound as irrelevancy},
  author = {Sébastien Guérif},
  pages = {163--177},
  abstract = {Whereas the variable selection has been extensively studied in the context of  supervised learning, the unsupervised variable selection has attracted attention  of researchers more recently as the available amount of unlabeled data has exploded.  Many unsupervised variable ranking criteria were proposed and their relevance is usually  demonstrated using either external cluster validity indexes or the accuracy of a classifier  which are both supervised criteria. Actually, the major issue of the variable subset selection  according to a ranking measure has been adressed only by few authors in the unsupervised  learning context. In this paper, we propose to combine multiple ranking to go ahead toward  a stable consensus variable subset in a totally unsupervised fashion.},
  pdf = {http://jmlr.org/proceedings/papers/v4/guerif08a/guerif08a.pdf},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX


text:
HOMEPAGE = "http://fuse.sf.net"
DESCRIPTION = "With FUSE it is possible to implement a fully functional filesystem in a userspace program"
MAINTAINER = "Koen Kooi <koen@linuxtogo.org>"

LICENSE = "GPL"

DEPENDS = "fakeroot-native"
RRECOMMEND = "fuse"

SRC_URI="${SOURCEFORGE_MIRROR}/fuse/fuse-${PV}.tar.gz"
S = "${WORKDIR}/fuse-${PV}"

inherit autotools pkgconfig module
EXTRA_OECONF = "  --with-kernel=${STAGING_KERNEL_DIR}"

do_configure() {
cd ${S} ; oe_runconf
}

do_compile(){
LDFLAGS=""
cd ${S}/kernel
oe_runmake
}

fakeroot do_install() {
LDFLAGS=""
cd ${S}/kernel
oe_runmake install DESTDIR=${D}
}

FILES_${PN} = "/dev /lib/modules"


text:
%% This BibTeX bibliography file was created using BibDesk.
%% http://bibdesk.sourceforge.net/

%% Created for 胡天晓 at 2017-06-28 22:33:25 +0800

%% Saved with string encoding Unicode (UTF-8)

@book{ml,
	Author = {Christopher M. Bishop},
	Date-Added = {2017-06-28 14:31:10 +0000},
	Date-Modified = {2017-06-28 14:33:24 +0000},
	Publisher = {Springer},
	Title = {Pattern Recognition and Machine Learning},
	Year = {2007}}

@book{ai,
	Author = {Stuart Russell and Peter Norvig},
	Date-Modified = {2017-06-28 14:31:07 +0000},
	Publisher = {Prentice Hall},
	Title = {Artificial Intelligence: A Modern Approach},
	Year = {2009}}

repository: TianxiaoHu/GomokuAgent

repo_name: TianxiaoHu/GomokuAgent


text:
# this image relies on
#  poky/meta
#  poky/meta-yocto
#  poky/meta-yocto-bsp
#  poky/meta-oe/meta-oe
#  poky/meta-securepoint

# Base this image on core-image-minimal
#include recipes-core/images/core-image-minimal.bb

inherit extrausers
EXTRA_USERS_PARAMS = "\
 usermod -P insecure root; \
"

IMAGE_FEATURES += "ssh-server-dropbear"

IMAGE_INSTALL_append = "\
    runit \
    nginx \
    bind bind-utils-rdnc bind-utils-host \
    net-snmp-server-snmpd \
    openvpn \
    strongswan \
    radvd \
    squid \
    sendmail \
    openldap \
    openldap-slapd \
    dovecot \
    dovecot-pigeonhole \
    lua5.1 \
    lualdap \
    coreutils \
    util-linux-fsck \
    e2fsprogs-mke2fs syslinux-mbr syslinux-extlinux \
    collectd \
    collectd-plugin-unixsock collectd-plugin-cpu collectd-plugin-syslog \
    collectd-plugin-interface collectd-plugin-memory collectd-plugin-rrdtool \
    collectd-plugin-entropy \
    strace \
    tcpdump \
    lsof \
    nut \
    smartmontools \
    hddtemp \
    util-linux-getopt \
    kernel-module-tun \
    krb5-workstation \
    pam-krb5 \
    mskutil \
    cifs-utils kernel-module-cifs \
    "
IMAGE_FSTYPES = "ext3 vmdk"
inherit core-image

repository: Securepoint/yocto-meta-securepoint

repo_name: Securepoint/yocto-meta-securepoint


text:
SUMMARY = "Jinja2 is a modern and designer friendly templating language for Python, modelled after Django’s templates."
SECTION = "devel/python"

HOMEPAGE = "http://jinja.pocoo.org/docs/"

LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://LICENSE;md5=20c831f91dd3bd486020f672ba2be386"

SRC_URI = "git://github.com/mitsuhiko/jinja2.git;protocol=https"
SRCREV = "966e1a409f02de57b75a0463fc953d54dad2a205"

# SRCREV = tag
PV = "2.8"

S = "${WORKDIR}/git"

inherit setuptools

export BUILD_SYS
export HOST_SYS
export STAGING_INCDIR
export STAGING_LIBDIR

RDEPENDS_${PN} += "${PYTHON_PN}-io ${PYTHON_PN}-pickle ${PYTHON_PN}-crypt \
    ${PYTHON_PN}-math ${PYTHON_PN}-netclient ${PYTHON_PN}-re ${PYTHON_PN}-textutils \
    ${PYTHON_PN}-lang ${PYTHON_PN}-pprint ${PYTHON_PN}-shell ${PYTHON_PN}-markupsafe \
    ${PYTHON_PN}-json ${PYTHON_PN}-threading ${PYTHON_PN}-numbers"
RCONFLICTS_${PN} += "python-jinja2"
RPROVIDES_${PN} += "python-jinja2"

CLEANBROKEN = "1"
BBCLASSEXTEND = "native"

repository: koenkooi/meta-maker

repo_name: koenkooi/meta-maker

gha_language: BitBake


text:
DESCRIPTION = "Collection of DPF-based plugins."
SRC_URI = "git://github.com/DISTRHO/DPF-Plugins;protocol=https \
	file://0001-build-remove-strip-flags-and-gen-rule.patch"
SRCREV = "6454c590a2b5402195e655b1386358210e067dfd"
LICENSE = "ISC"

LIC_FILES_CHKSUM = "file://LICENSE;md5=ec024abddfab2ee463c8c1ad98883d12"

S = "${WORKDIR}/git/"

DEPENDS = " lv2 mod-lv2-data "

FILES_${PN} = " ${libdir}/lv2/ "

EXTRA_OEMAKE = " DESTDIR=${D} PREFIX=${prefix}/ "

do_install() {
	oe_runmake install

	rm -Rf ${D}${libdir}/dssi ${D}${libdir}/vst ${D}${libdir}/ladspa
}


text:
@inproceedings{zangerle:2021,
 author = {Eva Zangerle and Maximilian Mayerl and Martin Potthast and Benno Stein},
 booktitle = {CLEF 2021 Labs and Workshops, Notebook Papers},
 editor = {Guglielmo Faggioli and Nicola Ferro and Alexis Joly and Maria Maistro and Florina Piroi},
 pages = {1760--1771},
 publisher = {CEUR-WS.org},
 title = {Overview of the Style Change Detection Task at PAN 2021},
 url = {http://ceur-ws.org/Vol-2936/},
 year = {2021}
}

branch_name: refs/heads/main


text:
@techreport{puschmann:microkernel:2009,
    author = {Andre Puschmann},
    title = {Vergleich von monolithischen- und mikrokernbasierten Betriebssystemarchitekturen und deren Robustheits- und Echtzeiteigenschaften für den Einsatz in industrietauglichen Anwendungen},
    institution = {TU Ilmenau},
    year = {2009}
}

repository: andrepuschmann/academic-kickstart

repo_name: andrepuschmann/academic-kickstart


text:
@inproceedings{debruhl2014power,
 author = {DeBruhl, Bruce and Kroer, Christian and Datta, Anupam and Sandholm, Tuomas and Tague, Patrick},
 booktitle = {WiSec},
 title = {Power napping with loud neighbors: optimal energy-constrained jamming and anti-jamming},
 url = {http://www.columbia.edu/~ck2945/papers/power_napping-WiSec14.pdf},
 year = {2014}
}

repository: ChrKroer/academic-kickstart

repo_name: ChrKroer/academic-kickstart


text:
SUMMARY = "Phosphor OpenBMC Kudo System Power Control Service"
DESCRIPTION = "Phosphor OpenBMC Kudo System Power Control Daemon"

PR = "r1"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/Apache-2.0;md5=89aea4e17d99a7cacdbeed46a0096b10"

inherit systemd
inherit obmc-phosphor-systemd

DEPENDS += "systemd"
RDEPENDS:${PN} += "libsystemd"
RDEPENDS:${PN} += "bash"

SRC_URI = " \
    file://init_once.sh \
    file://host-powerctrl.service \
    "

SYSTEMD_PACKAGES = "${PN}"
SYSTEMD_SERVICE:${PN} = " \
    host-powerctrl.service \
    "

do_install () {
    install -d ${D}${libexecdir}/${PN}
    install -m 0755 ${WORKDIR}/init_once.sh ${D}${libexecdir}/${PN}/init_once.sh
    install -d ${D}${systemd_unitdir}/system/
    install -m 0644 ${WORKDIR}/host-powerctrl.service ${D}${systemd_unitdir}/system
}

repository: openbmc/openbmc

repo_name: openbmc/openbmc


text:
@inproceedings{Dubey2008,
 abstract = {Large scientific computing clusters require a distributed dependability subsystem that can provide fault isolation and recovery and is capable of learning and predicting failures, to improve the reliability of scientific workflows. In this paper, we outline the key ideas in the design of a Scientific Computing Autonomic Reliability Framework (SCARF) for large computing clusters used in the Lattice Quantum Chromo Dynamics project at Fermi Lab.},
 author = {Abhishek Dubey and Sandeep Neema and Jim Kowalkowski and Amitoj Singh},
 bibsource = {dblp computer science bibliography, https://dblp.org},
 biburl = {https://dblp.org/rec/bib/conf/eScience/DubeyNKS08},
 booktitle = {Fourth International Conference on e-Science, e-Science 2008, 7-12 December 2008, Indianapolis, IN, USA},
 category = {poster},
 doi = {10.1109/eScience.2008.113},
 file = {:Dubey2008-Scientific_Computing_Autonomic_Reliability_Framework.pdf:PDF},
 keywords = {},
 oldkeywords = {reliability},
 pages = {352--353},
 project = {cps-middleware,cps-reliability},
 timestamp = {Wed, 16 Oct 2019 14:14:49 +0200},
 title = {Scientific Computing Autonomic Reliability Framework},
 url = {https://doi.org/10.1109/eScience.2008.113},
 year = {2008}
}


text:
@InProceedings{zhou11a,
  title = {Dependent Hierarchical Beta Process for Image Interpolation and Denoising},
  author = {Mingyuan Zhou and Hongxia Yang and Guillermo Sapiro and David Dunson and Lawrence Carin},
  pages = {883--891},
  abstract = {A dependent hierarchical beta process (dHBP) is developed as a prior for data that may be represented in terms of a sparse set of latent features, with covariate-dependent feature usage. The dHBP is applicable to general covariates and data models, imposing that signals with similar covariates are likely to be manifested in terms of similar features. Coupling the dHBP with the Bernoulli process, and upon marginalizing out the dHBP, the model may be interpreted as a covariate-dependent hierarchical Indian buffet process. As applications, we consider interpolation and denoising of an image, with covariates defined by the location of image patches within an image. Two types of noise models are considered: (i) typical white Gaussian noise; and (ii) spiky noise of arbitrary amplitude, distributed uniformly at random. In these examples, the features correspond to the atoms of a dictionary, learned based upon the data under test (without a priori training data). State-of-the-art performance is demonstrated, with efficient inference using hybrid Gibbs, Metropolis-Hastings and slice sampling.

[pdf]},
  pdf = {http://jmlr.org/proceedings/papers/v15/zhou11a/zhou11a.pdf},
}


text:
@inproceedings{yadollahi2020exploring,
 author = {Yadollahi, Elmira and Couto, Marta and Johal, Wafa and Dillenbourg, Pierre and Paiva, Ana},
 booktitle = {International Conference on Artificial Intelligence in Education},
 organization = {Springer, Cham},
 pages = {346--351},
 title = {Exploring the Role of Perspective Taking in Educational Child-Robot Interaction},
 year = {2020}
}

repository: estella-a/research-group-website-src

repo_name: estella-a/research-group-website-src


text:
package todo

import (
	"io/ioutil"
	"os"
	"regexp"
	"strings"

	"github.com/gonuts/commander"
)

func todoDelete(tasksFile string) *commander.Command {
	delete := func(cmd *commander.Command, args []string) error {
		file, err := ioutil.ReadFile(tasksFile)
		if err != nil {
			panic(err)
		}

		lines := strings.Split(string(file), "\n")

		for i, line := range lines {
			if strings.Contains(line, "ID\": "+"\""+os.Args[2]) {
				for k := -1; k <= 4; k++ {
					lines[i+k] = ""
				}
			}
		}

		output, _ := removeEmptyLines(strings.Join(lines, "\n"))

		errorWriting := ioutil.WriteFile(tasksFile, []byte(output), 0644)
		if errorWriting != nil {
			panic(errorWriting)
		}

		return nil
	}

	return &commander.Command{
		Run:       delete,
		UsageLine: "delete Task",
		Short:     "Delete a task",
		Long: `
Delete a task.

ex:
  $ ./go-todo delete "MyTask"
`,
	}
}

func removeEmptyLines(lines string) (string, error) {
	regex, err := regexp.Compile("\n\n")
	if err != nil {
		panic(err)
	}
	lines = regex.ReplaceAllString(lines, "\n")

	return lines, err
}


text:
---
---

@string{aps = {American Physical Society,}}

@article{onose2018ipsj,
  title={A Garment-type Pressure Sensor for Pressure-Ulcer Care Use: To Measure Pressures on Human Skin},
  author={Ryosuke Onose, Yu Enokibori, Kenji Mase},
  journal={Journal of Information Processing},
  volume={59},
  number={10},
  pages={1827-1836},
  year={2018},
  publisher={Journal of Information Processing},
  html={http://id.nii.ac.jp/1001/00191497/},
  abstract={Preventing pressure ulcer is one of important issues in nursing cure. Our project has tried to estimate and reduce the risk of pressure ulcer using a sheet-type pressure sensor. However, we found that body-pressure dispersion cushions that were inserted between bed and patient interfere with accurate sensing through preliminary experiments in an elderly care facility. To solve this issue, we are implementing a garment-type pressure sensor that measures directly the pressures that are applied onto the human skin. We compared the detection performance of pressure value put on body surface by evaluating accuracies of posture classification using bed-sheet and garment-type pressure sensors with 20 users. The garment-type sensor could succeeded to classify more accurately than the ones of the bed-sheet-type sensor in the classification task of postures using both of sensors. We confirmed that the garment-type pressure sensor has higher detectionability than the bed-sheet-type sensor when dispersion cushions are inserted. }
}

@article{onose2018ubicomp_poster,
  title={Textile Sensor based Visualization to Enhance Skills to Understand Body Pressure Distribution for Pressure Ulcer Prevention},
  author={Ryosuke Onose, Yu Enokibori, Yuko Harasawa, Kenji Mase},
  journal={The 2018 ACM International Joint Conference on Pervasive and Ubiquitous Computing (UbiComp 2018) Poster},
  year={2018},
  doi={10.1145/3267305.3267644},
  html={https://dl.acm.org/citation.cfm?id=3267644},
  abstract={This study proposes a system to visualize the body-pressures applied to body parts in a bed, with textile pressure sensors to support caregivers to learn posture change skill for pressure ulcer prevention. As the result of an evaluation with 21 nursing students, the comparison group using our system for learning showed better scores than ones of the control group with skill to understand the body-pressure distribution of sub-body parts: head (6/6, 100%) and right leg (3/6, 50%).}
}

@article{onose2018ubicomp_dc,
  title={User-Friendly Design of Caregiving Support System},
  author={Ryosuke Onose},
  journal={The 2018 ACM International Joint Conference on Pervasive and Ubiquitous Computing (UbiComp 2018) Doctoral Colloquium},
  year={2018},
  doi={10.1145/3267305.3267318},
  html={https://dl.acm.org/citation.cfm?id=3267318},
}

@article{onose2018mobicase,
  title={A Comparison Result between Garment-type and Bed-sheet-type Pressure Sensor for Pressure Ulcer Prevention},
  author={Ryosuke Onose, Yu Enokibori, Kenji Mase},
  journal={The 9th EAI International Conference on Mobile Computing, Applications and Services (MobiCASE 2018) Poster},
  year={2018},
  doi={10.1007/978-3-319-90740-6_16},
  html={https://doi.org/10.1007/978-3-319-90740-6_16},
  abstract={Preventing pressure ulcer is one of important aims in nursing. Our project has tried to estimate and reduce the risk of pressure ulcer using the sheet-type pressure sensor. However, we found a problem that body-pressure dispersion cushions interfere with accurate sensing when the previous experiment in nursing institute. A garment-type pressure sensor proposed in this paper successfully detected body-pressure changes regardless cushion replacement as the sensor could classify more accurate score in the classification task of postures using both of sensors.}
}

@article{onose2017ubicomp,
  title={Garment vs. Bed-Sheet Sensors: To Deal with Pressure Dispersion Cushion Use in Pressure Ulcer Prevention},
  author={Ryosuke Onose, Yu Enokibori, Kenji Mase},
  journal={The 2018 ACM International Joint Conference on Pervasive and Ubiquitous Computing (UbiComp 2017) Poster},
  year={2017},
  doi={10.1145/3123024.3123143},
  html={https://doi.org/10.1145/3123024.3123143},
  abstract={Our project is estimating and reducing the risk of pressure ulcers using bed-sheet-type textile pressure sensors. However, body-pressure dispersion cushions interfere with accurate sensing and cause such problems as indistinct body-pressure changes, blurred body shape, and unmeasurable body-pressure changes. To solve these issues, we implement a garment-type pressure sensor that measures the pressures that are directly added to the human skin. Our sensor successfully detected the body-pressure changes that are overlooked by bed-sheet-type sensors, avoided body-pressure shape vagueness, and measured the pressure increase depending on the body part lift-up by cushion use through an experiment with 20 subjects.}
}

@article{PhysRev.47.777,
  title={Can Quantum-Mechanical Description of Physical Reality Be Considered Complete?},
  author={Einstein, A. and Podolsky, B. and Rosen, N.},
  abstract={In a complete theory there is an element corresponding to each element of reality. A sufficient condition for the reality of a physical quantity is the possibility of predicting it with certainty, without disturbing the system. In quantum mechanics in the case of two physical quantities described by non-commuting operators, the knowledge of one precludes the knowledge of the other. Then either (1) the description of reality given by the wave function in quantum mechanics is not complete or (2) these two quantities cannot have simultaneous reality. Consideration of the problem of making predictions concerning a system on the basis of measurements made on another system that had previously interacted with it leads to the result that if (1) is false then (2) is also false. One is thus led to conclude that the description of reality as given by a wave function is not complete.},
  journal={Phys. Rev.,},
  volume={47},
  issue={10},
  pages={777--780},
  numpages={0},
  year={1935},
  month={May},
  publisher=aps,
  doi={10.1103/PhysRev.47.777},
  url={http://link.aps.org/doi/10.1103/PhysRev.47.777},
  html={https://journals.aps.org/pr/abstract/10.1103/PhysRev.47.777},
  pdf={example_pdf.pdf}
}

@article{einstein1905molekularkinetischen,
  title={{\"U}ber die von der molekularkinetischen Theorie der W{\"a}rme geforderte Bewegung von in ruhenden Fl{\"u}ssigkeiten suspendierten Teilchen},
  author={Einstein, A.},
  journal={Annalen der physik,},
  volume={322},
  number={8},
  pages={549--560},
  year={1905},
  publisher={Wiley Online Library}
}

@article{einstein1905movement,
  title={Un the movement of small particles suspended in statiunary liquids required by the molecular-kinetic theory 0f heat},
  author={Einstein, A.},
  journal={Ann. Phys.,},
  volume={17},
  pages={549--560},
  year={1905}
}

@article{einstein1905electrodynamics,
  title={On the electrodynamics of moving bodies},
  author={Einstein, A.},
  year={1905}
}


text:
require fftw.inc

EXTRA_OECONF = "--disable-fortran --enable-single --enable-shared \
    --enable-threads \
    ${@base_contains('TUNE_FEATURES', 'neon', '--enable-neon', '', d)} \
"

SRC_URI[md5sum] = "0a05ca9c7b3bfddc8278e7c40791a1c2"
SRC_URI[sha256sum] = "85cdfc0a0ba10d8fa4f0f8e733aac1a5936c859832a9e3d5c0731fb5c54a97f3"

repository: ExorEmbedded/exor-workspace

repo_name: ExorEmbedded/exor-workspace


text:
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: comet_server.proto

package comet_server

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	math "math"
)

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

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

type Request struct {
	I                    string   `protobuf:"bytes,1,opt,name=I,proto3" json:"I,omitempty"`
	ID                   string   `protobuf:"bytes,2,opt,name=ID,proto3" json:"ID,omitempty"`
	Service              string   `protobuf:"bytes,3,opt,name=Service,proto3" json:"Service,omitempty"`
	Path                 string   `protobuf:"bytes,4,opt,name=Path,proto3" json:"Path,omitempty"`
	Version              uint32   `protobuf:"varint,5,opt,name=Version,proto3" json:"Version,omitempty"`
	ST                   int64    `protobuf:"varint,6,opt,name=ST,proto3" json:"ST,omitempty"`
	Data                 []byte   `protobuf:"bytes,7,opt,name=Data,proto3" json:"Data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Request) Reset()         { *m = Request{} }
func (m *Request) String() string { return proto.CompactTextString(m) }
func (*Request) ProtoMessage()    {}
func (*Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_b912673fd82858c8, []int{0}
}

func (m *Request) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Request.Unmarshal(m, b)
}
func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Request.Marshal(b, m, deterministic)
}
func (m *Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Request.Merge(m, src)
}
func (m *Request) XXX_Size() int {
	return xxx_messageInfo_Request.Size(m)
}
func (m *Request) XXX_DiscardUnknown() {
	xxx_messageInfo_Request.DiscardUnknown(m)
}

var xxx_messageInfo_Request proto.InternalMessageInfo

func (m *Request) GetI() string {
	if m != nil {
		return m.I
	}
	return ""
}

func (m *Request) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *Request) GetService() string {
	if m != nil {
		return m.Service
	}
	return ""
}

func (m *Request) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *Request) GetVersion() uint32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *Request) GetST() int64 {
	if m != nil {
		return m.ST
	}
	return 0
}

func (m *Request) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type RequestAck struct {
	I                    string   `protobuf:"bytes,1,opt,name=I,proto3" json:"I,omitempty"`
	ID                   string   `protobuf:"bytes,2,opt,name=ID,proto3" json:"ID,omitempty"`
	ST                   int64    `protobuf:"varint,3,opt,name=ST,proto3" json:"ST,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RequestAck) Reset()         { *m = RequestAck{} }
func (m *RequestAck) String() string { return proto.CompactTextString(m) }
func (*RequestAck) ProtoMessage()    {}
func (*RequestAck) Descriptor() ([]byte, []int) {
	return fileDescriptor_b912673fd82858c8, []int{1}
}

func (m *RequestAck) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RequestAck.Unmarshal(m, b)
}
func (m *RequestAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RequestAck.Marshal(b, m, deterministic)
}
func (m *RequestAck) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestAck.Merge(m, src)
}
func (m *RequestAck) XXX_Size() int {
	return xxx_messageInfo_RequestAck.Size(m)
}
func (m *RequestAck) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestAck.DiscardUnknown(m)
}

var xxx_messageInfo_RequestAck proto.InternalMessageInfo

func (m *RequestAck) GetI() string {
	if m != nil {
		return m.I
	}
	return ""
}

func (m *RequestAck) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *RequestAck) GetST() int64 {
	if m != nil {
		return m.ST
	}
	return 0
}

type Response struct {
	I                    string   `protobuf:"bytes,1,opt,name=I,proto3" json:"I,omitempty"`
	ID                   string   `protobuf:"bytes,2,opt,name=ID,proto3" json:"ID,omitempty"`
	Service              string   `protobuf:"bytes,3,opt,name=Service,proto3" json:"Service,omitempty"`
	Path                 string   `protobuf:"bytes,4,opt,name=Path,proto3" json:"Path,omitempty"`
	Version              uint32   `protobuf:"varint,5,opt,name=Version,proto3" json:"Version,omitempty"`
	ST                   int64    `protobuf:"varint,6,opt,name=ST,proto3" json:"ST,omitempty"`
	Code                 int64    `protobuf:"varint,7,opt,name=Code,proto3" json:"Code,omitempty"`
	Message              string   `protobuf:"bytes,8,opt,name=Message,proto3" json:"Message,omitempty"`
	Data                 []byte   `protobuf:"bytes,9,opt,name=Data,proto3" json:"Data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Response) Reset()         { *m = Response{} }
func (m *Response) String() string { return proto.CompactTextString(m) }
func (*Response) ProtoMessage()    {}
func (*Response) Descriptor() ([]byte, []int) {
	return fileDescriptor_b912673fd82858c8, []int{2}
}

func (m *Response) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Response.Unmarshal(m, b)
}
func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Response.Marshal(b, m, deterministic)
}
func (m *Response) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Response.Merge(m, src)
}
func (m *Response) XXX_Size() int {
	return xxx_messageInfo_Response.Size(m)
}
func (m *Response) XXX_DiscardUnknown() {
	xxx_messageInfo_Response.DiscardUnknown(m)
}

var xxx_messageInfo_Response proto.InternalMessageInfo

func (m *Response) GetI() string {
	if m != nil {
		return m.I
	}
	return ""
}

func (m *Response) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *Response) GetService() string {
	if m != nil {
		return m.Service
	}
	return ""
}

func (m *Response) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *Response) GetVersion() uint32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *Response) GetST() int64 {
	if m != nil {
		return m.ST
	}
	return 0
}

func (m *Response) GetCode() int64 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *Response) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *Response) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type ResponseAck struct {
	I                    string   `protobuf:"bytes,1,opt,name=I,proto3" json:"I,omitempty"`
	ID                   string   `protobuf:"bytes,2,opt,name=ID,proto3" json:"ID,omitempty"`
	ST                   int64    `protobuf:"varint,3,opt,name=ST,proto3" json:"ST,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ResponseAck) Reset()         { *m = ResponseAck{} }
func (m *ResponseAck) String() string { return proto.CompactTextString(m) }
func (*ResponseAck) ProtoMessage()    {}
func (*ResponseAck) Descriptor() ([]byte, []int) {
	return fileDescriptor_b912673fd82858c8, []int{3}
}

func (m *ResponseAck) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ResponseAck.Unmarshal(m, b)
}
func (m *ResponseAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ResponseAck.Marshal(b, m, deterministic)
}
func (m *ResponseAck) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResponseAck.Merge(m, src)
}
func (m *ResponseAck) XXX_Size() int {
	return xxx_messageInfo_ResponseAck.Size(m)
}
func (m *ResponseAck) XXX_DiscardUnknown() {
	xxx_messageInfo_ResponseAck.DiscardUnknown(m)
}

var xxx_messageInfo_ResponseAck proto.InternalMessageInfo

func (m *ResponseAck) GetI() string {
	if m != nil {
		return m.I
	}
	return ""
}

func (m *ResponseAck) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *ResponseAck) GetST() int64 {
	if m != nil {
		return m.ST
	}
	return 0
}

func init() {
	proto.RegisterType((*Request)(nil), "comet_server.Request")
	proto.RegisterType((*RequestAck)(nil), "comet_server.RequestAck")
	proto.RegisterType((*Response)(nil), "comet_server.Response")
	proto.RegisterType((*ResponseAck)(nil), "comet_server.ResponseAck")
}

func init() { proto.RegisterFile("comet_server.proto", fileDescriptor_b912673fd82858c8) }

var fileDescriptor_b912673fd82858c8 = []byte{
	// 308 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x93, 0xc1, 0x4e, 0xbb, 0x40,
	0x10, 0xc6, 0xb3, 0xd0, 0x7f, 0x29, 0x53, 0xfe, 0x1e, 0x36, 0xd1, 0x6c, 0x3c, 0x11, 0x4e, 0x9c,
	0x7a, 0xa8, 0xb7, 0xd6, 0x8b, 0x29, 0x17, 0x0e, 0x26, 0x66, 0x69, 0xbc, 0x1a, 0x84, 0xb1, 0x25,
	0xa6, 0x2c, 0xee, 0x42, 0x5f, 0xc4, 0xe7, 0xf1, 0xe2, 0x93, 0x19, 0xa6, 0x60, 0xd0, 0x8b, 0xc1,
	0x8b, 0xb7, 0xf9, 0xbe, 0xf0, 0x1b, 0x66, 0xbe, 0xdd, 0x05, 0x9e, 0xa9, 0x03, 0xd6, 0x0f, 0x06,
	0xf5, 0x11, 0xf5, 0xa2, 0xd2, 0xaa, 0x56, 0xdc, 0x1b, 0x7a, 0xc1, 0x2b, 0x03, 0x47, 0xe2, 0x4b,
	0x83, 0xa6, 0xe6, 0x1e, 0xb0, 0x58, 0x30, 0x9f, 0x85, 0xae, 0x64, 0x31, 0x3f, 0x03, 0x2b, 0x8e,
	0x84, 0x45, 0xd2, 0x8a, 0x23, 0x2e, 0xc0, 0x49, 0x50, 0x1f, 0x8b, 0x0c, 0x85, 0x4d, 0x66, 0x2f,
	0x39, 0x87, 0xc9, 0x5d, 0x5a, 0xef, 0xc5, 0x84, 0x6c, 0xaa, 0xdb, 0xaf, 0xef, 0x51, 0x9b, 0x42,
	0x95, 0xe2, 0x9f, 0xcf, 0xc2, 0xff, 0xb2, 0x97, 0x6d, 0xdf, 0x64, 0x2b, 0xa6, 0x3e, 0x0b, 0x6d,
	0x69, 0x25, 0xdb, 0x96, 0x8e, 0xd2, 0x3a, 0x15, 0x8e, 0xcf, 0x42, 0x4f, 0x52, 0x1d, 0xac, 0x00,
	0xba, 0xa1, 0x6e, 0xb2, 0xe7, 0x1f, 0xe6, 0x3a, 0xf5, 0xb3, 0xfb, 0x7e, 0xc1, 0x3b, 0x83, 0x99,
	0x44, 0x53, 0xa9, 0xd2, 0xe0, 0xdf, 0xad, 0xb4, 0x51, 0x39, 0xd2, 0x4a, 0xb6, 0xa4, 0xba, 0xa5,
	0x6f, 0xd1, 0x98, 0x74, 0x87, 0x62, 0x76, 0xfa, 0x57, 0x27, 0x3f, 0x03, 0x70, 0x07, 0x01, 0xac,
	0x61, 0xde, 0xef, 0x30, 0x3a, 0x81, 0xe5, 0x9b, 0x05, 0xde, 0x66, 0x70, 0xc8, 0x7c, 0x05, 0xae,
	0xc1, 0x32, 0x5f, 0x36, 0x06, 0x35, 0x3f, 0x5f, 0x7c, 0xb9, 0x14, 0x5d, 0xce, 0x97, 0x17, 0xdf,
	0xed, 0x2e, 0xc1, 0x6b, 0x98, 0x13, 0xfb, 0xa4, 0x0b, 0x2c, 0xf3, 0xb1, 0xf4, 0x1a, 0x80, 0xe8,
	0x9d, 0x56, 0x4d, 0x35, 0x16, 0xee, 0xc7, 0xd6, 0x4a, 0x1d, 0x7e, 0xcb, 0x56, 0x8d, 0xd9, 0x8f,
	0x64, 0x1f, 0xa7, 0xf4, 0x50, 0xae, 0x3e, 0x02, 0x00, 0x00, 0xff, 0xff, 0xca, 0x69, 0x18, 0x4d,
	0x3e, 0x03, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// CometServerClient is the client API for CometServer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CometServerClient interface {
	Send2User(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
	Send2Friend(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
	Send2Group(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
	Send2Room(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
	Send2Push(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
}

type cometServerClient struct {
	cc *grpc.ClientConn
}

func NewCometServerClient(cc *grpc.ClientConn) CometServerClient {
	return &cometServerClient{cc}
}

func (c *cometServerClient) Send2User(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/comet_server.Comet_server/send2user", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cometServerClient) Send2Friend(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/comet_server.Comet_server/send2friend", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cometServerClient) Send2Group(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/comet_server.Comet_server/send2group", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cometServerClient) Send2Room(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/comet_server.Comet_server/send2room", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cometServerClient) Send2Push(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/comet_server.Comet_server/send2push", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CometServerServer is the server API for CometServer service.
type CometServerServer interface {
	Send2User(context.Context, *Request) (*Response, error)
	Send2Friend(context.Context, *Request) (*Response, error)
	Send2Group(context.Context, *Request) (*Response, error)
	Send2Room(context.Context, *Request) (*Response, error)
	Send2Push(context.Context, *Request) (*Response, error)
}

func RegisterCometServerServer(s *grpc.Server, srv CometServerServer) {
	s.RegisterService(&_CometServer_serviceDesc, srv)
}

func _CometServer_Send2User_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CometServerServer).Send2User(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/comet_server.Comet_server/Send2User",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CometServerServer).Send2User(ctx, req.(*Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _CometServer_Send2Friend_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CometServerServer).Send2Friend(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/comet_server.Comet_server/Send2Friend",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CometServerServer).Send2Friend(ctx, req.(*Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _CometServer_Send2Group_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CometServerServer).Send2Group(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/comet_server.Comet_server/Send2Group",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CometServerServer).Send2Group(ctx, req.(*Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _CometServer_Send2Room_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CometServerServer).Send2Room(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/comet_server.Comet_server/Send2Room",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CometServerServer).Send2Room(ctx, req.(*Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _CometServer_Send2Push_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CometServerServer).Send2Push(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/comet_server.Comet_server/Send2Push",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CometServerServer).Send2Push(ctx, req.(*Request))
	}
	return interceptor(ctx, in, info, handler)
}

var _CometServer_serviceDesc = grpc.ServiceDesc{
	ServiceName: "comet_server.Comet_server",
	HandlerType: (*CometServerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "send2user",
			Handler:    _CometServer_Send2User_Handler,
		},
		{
			MethodName: "send2friend",
			Handler:    _CometServer_Send2Friend_Handler,
		},
		{
			MethodName: "send2group",
			Handler:    _CometServer_Send2Group_Handler,
		},
		{
			MethodName: "send2room",
			Handler:    _CometServer_Send2Room_Handler,
		},
		{
			MethodName: "send2push",
			Handler:    _CometServer_Send2Push_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "comet_server.proto",
}


text:
package cmd

import (
	"fmt"
	"github.com/spf13/cobra"
	"github.com/wuyq101/livermore/workflow"
)

var FetchAll bool

func init() {
	RootCmd.AddCommand(fetchCmd)
	fetchCmd.Flags().BoolVarP(&FetchAll, "all", "a", false, "Fetch all stock info current in database.")
}

var fetchCmd = &cobra.Command{
	Use:   "fetch",
	Short: "Fetch stock data by code",
	Long: `Fetch stock data by code
          stock code: sh600036, sz000166
	`,
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Start to fetch stock data ...")
		w := workflow.Instance()
		if FetchAll {
			w.FetchAllStockInfo()
			return
		}
		fmt.Printf("args %q \n", args)
		if args == nil || len(args) <= 0 {
			fmt.Println("please input stock code, like sh600036 sz000166")
			return
		}
		w.FetchStockInfo(args)
	},
}


text:
require busybox.inc
PR = "r18"

SRC_URI = "\
  http://www.busybox.net/downloads/busybox-${PV}.tar.gz \
  file://busybox-1.13.2-awk.patch;patch=1 \
  file://busybox-1.13.2-depmod.patch;patch=1 \
  file://busybox-1.13.2-init.patch;patch=1 \
  file://busybox-1.13.2-killall.patch;patch=1 \
  file://busybox-1.13.2-mdev.patch;patch=1 \
  file://busybox-1.13.2-modprobe.patch;patch=1 \
  file://busybox-1.13.2-printf.patch;patch=1 \
  file://busybox-1.13.2-syslogd.patch;patch=1 \
  file://busybox-1.13.2-tar.patch;patch=1 \
  file://busybox-1.13.2-top24.patch;patch=1 \
  file://busybox-1.13.2-unzip.patch;patch=1 \
  file://busybox-1.13.2-wget.patch;patch=1 \
  \
  file://udhcpscript.patch;patch=1 \
  file://udhcpc-fix-nfsroot.patch;patch=1 \
  file://B921600.patch;patch=1 \
  file://get_header_tar.patch;patch=1 \
  file://busybox-appletlib-dependency.patch;patch=1 \
  file://find-touchscreen.sh \
  file://busybox-cron \
  file://busybox-httpd \
  file://busybox-udhcpd \
  file://default.script \
  file://hwclock.sh \
  file://mount.busybox \
  file://mountall \
  file://syslog \
  file://syslog.conf \
  file://umount.busybox \
  file://defconfig \
  file://mdev \
  file://mdev.conf \
"

EXTRA_OEMAKE += "V=1 ARCH=${TARGET_ARCH} CROSS_COMPILE=${TARGET_PREFIX}"

do_configure () {
	install -m 0644 ${WORKDIR}/defconfig ${S}/.config
	if [ "${TARGET_ARCH}" = "avr32" ] ; then
		sed -i s:CONFIG_FEATURE_OSF_LABEL=y:CONFIG_FEATURE_OSF_LABEL=n: ${S}/.config
	fi
	cml1_do_configure
}

do_install_append() {
    install -m 0644 ${WORKDIR}/mdev.conf ${D}${sysconfdir}/
    install -d ${D}${sysconfdir}/init.d/
    install -d ${D}${sysconfdir}/mdev
    install -m 0755 ${WORKDIR}/find-touchscreen.sh ${D}${sysconfdir}/mdev/
    install -m 0755 ${WORKDIR}/mdev ${D}${sysconfdir}/init.d/
}


text:
@PACKAGE_INIT@

get_filename_component(doxygen_cmake_dir ${CMAKE_CURRENT_LIST_FILE} PATH)
set_and_check(DOXYGEN_CMAKE_MODULE_DIR "${doxygen_cmake_dir}")
list(APPEND DOXYGEN_CMAKE_MODULE_PATH "${DOXYGEN_CMAKE_MODULE_DIR}")
list(APPEND CMAKE_MODULE_PATH "${DOXYGEN_CMAKE_MODULE_PATH}")

include(${DOXYGEN_CMAKE_MODULE_DIR}/FindDoxygenCMake.cmake)

repository: igor-chalenko/DoxygenCMake

repo_name: igor-chalenko/DoxygenCMake

extension: in


text:
require ../../include/gles-control.inc

DESCRIPTION = "SGX/RGX user module"
LICENSE = "CLOSED"

PN = "gles-user-module"
PR = "r0"

COMPATIBLE_MACHINE = "(r8a7742|r8a7743|r8a7745|r8a77470)"
PACKAGE_ARCH = "${MACHINE_ARCH}"
DEPENDS += " kernel-module-gles "
RDEPENDS_${PN} += "kernel-module-dc-linuxfb kernel-module-pvrsrvkm bash libegl libegl-dev \
    ${@bb.utils.contains("DISTRO_FEATURES", "wayland", " libdrm wayland-kms libgbm", "", d)} \
"

INSANE_SKIP_${PN} += "dev-deps file-rdeps"

S_r8a7742 = "${WORKDIR}/rogue"
GLES_r8a7742 = "rgx"

S_r8a7743 = "${WORKDIR}/eurasia"
GLES_r8a7743 = "sgx"
S_r8a7745 = "${WORKDIR}/eurasia"
GLES_r8a7745 = "sgx"
S_r8a77470 = "${WORKDIR}/eurasia"
GLES_r8a77470 = "sgx"

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

OPENGLES3 ?= "0"

SRC_URI_r8a7743 = "file://r8a7743_linux_sgx_binaries_gles2.tar.bz2"
SRC_URI_append_r8a7743 = " ${@bb.utils.contains("DISTRO_FEATURES", "wayland", " \
    file://EGL_headers_for_wayland.patch \
    ", "", d)}"

SRC_URI_r8a7745 = "file://r8a7745_linux_sgx_binaries_gles2.tar.bz2"
SRC_URI_append_r8a7745 = " ${@bb.utils.contains("DISTRO_FEATURES", "wayland", " \
    file://EGL_headers_for_wayland.patch \
    ", "", d)}"

SRC_URI_r8a7742 = '${@base_conditional( "OPENGLES3", "1", \
    "file://r8a7742_linux_rgx_binaries_gles3.tar.bz2", \
    "file://r8a7742_linux_rgx_binaries_gles2.tar.bz2", d )}'
SRC_URI_append_r8a7742 = " ${@bb.utils.contains("DISTRO_FEATURES", "wayland", " \
    file://EGL_headers_for_wayland.patch \
    ", "", d)}"

SRC_URI_r8a77470 = "file://r8a77470_linux_sgx_binaries_gles2.tar.bz2"
SRC_URI_append_r8a77470 = " ${@bb.utils.contains("DISTRO_FEATURES", "wayland", " \
    file://EGL_headers_for_wayland.patch \
    ", "", d)}"

#do_populate_lic[noexec] = "1"
do_compile[noexec] = "1"

do_install() {
    # Copy binary into sysroot
    cp -r ${S}/etc ${D}
    cp -r ${S}/usr ${D}

    if [ "${USE_WAYLAND}" = "1" ]; then
        # Rename libEGL.so
        mv ${D}/usr/lib/libEGL.so ${D}/usr/lib/libEGL-pvr.so

        # Set the "WindowSystem" parameter for wayland
        if [ "${GLES}" = "rgx" ]; then
            sed -i -e "s/WindowSystem=libpvrNULL_WSEGL.so/WindowSystem=libpvrWAYLAND_WSEGL.so/g" \
            ${D}/${sysconfdir}/powervr.ini
        elif [ "${GLES}" = "sgx" ]; then
            sed -i -e "s/WindowSystem=libpvrPVR2D_FLIPWSEGL.so/WindowSystem=libpvrPVR2D_WAYLANDWSEGL.so/g" \
            ${D}/${sysconfdir}/powervr.ini
        fi
    fi
}

PACKAGES = "\
    ${PN} \
    ${PN}-dev \
"

FILES_${PN} = " \
    ${sysconfdir}/* \
    ${libdir}/* \
    /usr/local/bin/* \
"

FILES_${PN}-dev = " \
    ${includedir}/* \
"

inherit update-rc.d

PROVIDES = "virtual/libgles2"
PROVIDES_append = "${@bb.utils.contains("DISTRO_FEATURES", "wayland", "", " virtual/egl", d)}"
RPROVIDES_${PN} += "${GLES}-user-module libgles2-mesa libgles2-mesa-dev libgles2 libgles2-dev"
INSANE_SKIP_${PN} += "ldflags already-stripped"
INSANE_SKIP_${PN}-dev += "ldflags"

INHIBIT_SYSROOT_STRIP = "1"
INHIBIT_PACKAGE_DEBUG_SPLIT = "1"

INITSCRIPT_NAME = "rc.pvr"
INITSCRIPT_PARAMS = "start 7 5 2 . stop 62 0 1 6 ."


text:
require tegra-binaries-${PV}.inc
require tegra-shared-binaries.inc

DESCRIPTION = "nvpmodel tool and configuration files"

COMPATIBLE_MACHINE = "(tegra)"

do_configure() {
    tar -C ${B} -x -f ${S}/nv_tegra/nv_tools.tbz2
}

do_compile[noexec] = "1"

do_install() {
    install -d ${D}${sbindir}
    install -d ${D}${sysconfdir}/nvpmodel
    install -m 0755 ${B}/usr/sbin/nvpmodel ${D}${sbindir}/
    install -m 0644 ${B}/etc/nvpmodel/${NVPMODEL}.conf ${D}${sysconfdir}/nvpmodel.conf
}

FILES_${PN} = "${sbindir}/nvpmodel ${sysconfdir}"
INSANE_SKIP_${PN} = "ldflags"

PACKAGE_ARCH = "${MACHINE_ARCH}"

repository: b-man/meta-tegra

repo_name: b-man/meta-tegra


text:
# CMake generated Testfile for
# Source directory: /Volumes/Macintosh HD/Volumes/Macintosh HD/Volumes/Macintosh HD/Volumes/Macintosh HD/Developer/VTK/Graphics
# Build directory: /Volumes/Macintosh HD/Volumes/Macintosh HD/Volumes/Macintosh HD/Volumes/Macintosh HD/Volumes/Macintosh HD/Developer/VTK/VTK-Build/Graphics
#
# This file includes the relevent testing commands required for
# testing this directory and lists subdirectories to be tested as well.

repository: mandalin/DissertationCODE

repo_name: mandalin/DissertationCODE


text:
#
# Copyright 2018 Armin Kuster <akuster808@gmail.com
#

DESCRIPTION = "Scripts to copy boot and rootFS to an Emmc device"
SECTION = "bootloaders"
LICENSE = "GPL-2.0-only"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"

S = "${WORKDIR}"

do_patch[noexec] = "1"
do_compile[noexec] = "1"

SRC_URI = "file://emmc.tmp"
EMMC_DEVICE = "/dev/mmcblk0boot0"
EMMC_ROOTFS = "/dev/mmcblk0"
EMMC_MNT = "/mnt"
FSTYPE = "ext4"

CLEANBROKEN = "1"

do_configure () {
    cat ${B}/emmc.tmp > ${B}/emmc.sh
    echo "dd if=/emmc/bl1.bin.hardkernel of=${EMMC_DEVICE} conv=notrunc bs=512 seek=0" >> ${B}/emmc.sh
    echo "dd if=/emmc/bl2.bin.hardkernel of=${EMMC_DEVICE} conv=notrunc bs=512 seek=30" >> ${B}/emmc.sh
    echo "dd if=/emmc/u-boot-dtb.bin of=${EMMC_DEVICE} conv=notrunc bs=512 seek=62" >> ${B}/emmc.sh
    echo "dd if=/emmc/tzsw.bin.hardkernel of=${EMMC_DEVICE} conv=notrunc bs=512 seek=2110" >> ${B}/emmc.sh
    echo "sync" >> ${B}/emmc.sh

    echo "parted -s ${EMMC_ROOTFS} mklabel msdos" >> ${B}/emmc.sh
    echo "parted -s ${EMMC_ROOTFS} unit s mkpart primary fat32 8192 50789 " >> ${B}/emmc.sh
    echo "parted -s ${EMMC_ROOTFS} set 1 boot on" >> ${B}/emmc.sh
    echo "parted -s ${EMMC_ROOTFS} unit s mkpart primary ${FSTYPE} 57344 100%" >> ${B}/emmc.sh
    echo "parted ${EMMC_ROOTFS} print " >> ${B}/emmc.sh
    echo "sleep 3" >> ${B}/emmc.sh
    echo "umount  ${EMMC_MNT}" >> ${B}/emmc.sh
    echo "mkfs.${FSTYPE} -F ${EMMC_ROOTFS}p2" >> ${B}/emmc.sh
    echo "mkfs.msdos ${EMMC_ROOTFS}p1" >> ${B}/emmc.sh
    echo "mount -t ${FSTYPE}  ${EMMC_ROOTFS}p2 ${EMMC_MNT}" >> ${B}/emmc.sh
    echo "rsync -avP --exclude='/dev' --exclude='/proc' --exclude='/sys' --exclude='/emmc' --exclude='/mnt' --exclude='/run' / ${EMMC_MNT}" >> ${B}/emmc.sh
    echo "sleep 1" >> ${B}/emmc.sh
    echo "umount  ${EMMC_MNT}" >> ${B}/emmc.sh
    echo "sleep 2" >> ${B}/emmc.sh
    echo "mount ${EMMC_ROOTFS}p1 ${EMMC_MNT}" >> ${B}/emmc.sh
    echo "cp boot.scr ${EMMC_MNT}" >> ${B}/emmc.sh
    echo "umount  ${EMMC_MNT}" >> ${B}/emmc.sh
    echo "fi"  >> ${B}/emmc.sh

}

do_install () {
    install -d ${D}/emmc
    install ${B}/emmc.sh ${D}/emmc
}

FILES:${PN} = "/emmc"

RDEPENDS:${PN} = "coreutils rsync e2fsprogs parted dosfstools"

PACKAGE_ARCH = "${MACHINE_ARCH}"

COMPATIBLE_MACHINE  = "(odroid-xu3|odroid-xu4|odroid-xu3-lite|odroid-hc1)"

repository: YoeDistro/meta-odroid

repo_name: YoeDistro/meta-odroid


text:
DESCRIPTION = "LV2 Toolkit v2."
LICENSE = "GPLv3"
LIC_FILES_CHKSUM = "file://COPYING;md5=905c38b5340fed9d382aab1d5221bb66"

SRC_URI = "git://github.com/lvtk/lvtk.git"
SRCREV = "c3d76e818072713da7049c53a484d4286ba6cfe2"

S = "${WORKDIR}/git/"

DEPENDS = " gtkmm lv2 "

EXTRA_OECONF = " --bundle=lvtk-2.lv2 "

inherit waf pkgconfig

do_install_prepend() {
    cp -R ../build/ ${S}/
}

do_install_append() {
   rm -R ${D}${libdir}/lv2/
}


text:
require ${PN}.inc

SRC_URI = "https://github.com/c-util/c-dvar/archive/v${PV}.tar.gz"
SRC_URI[md5sum] = "dd001aef84e74cf56f003167421fc159"
SRC_URI[sha256sum] = "6c549d96ea4d13f45712b4f0cfeff6ee17f2add064b24c352081f5bafbc6b053"


text:
DESCRIPTION = "Task to install graphics binaries on sdk target"
LICENSE = "MIT"
PR = "r8"

inherit packagegroup

GRAPHICS_RDEPENDS = "\
    libgbm-dev \
    ti-sgx-ddk-um-dev \
    "

GRAPHICS_RDEPENDS_append_omap-a15 = "\
    ti-gc320-libs-dev \
"

RDEPENDS_${PN} = "\
    ${GRAPHICS_RDEPENDS} \
"


text:
/*
Copyright 2021.

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

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

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

package controllers

import (
	"context"
	"errors"
	"fmt"
	"time"

	"github.com/go-logr/logr"
	"github.com/google/uuid"
	ctlerrors "go.lunarway.com/postgresql-controller/pkg/errors"
	apierrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"
	ctrl "sigs.k8s.io/controller-runtime"
	"sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/log"
	"sigs.k8s.io/controller-runtime/pkg/reconcile"

	postgresqlv1alpha1 "go.lunarway.com/postgresql-controller/api/v1alpha1"
	"go.lunarway.com/postgresql-controller/pkg/kube"
	"go.lunarway.com/postgresql-controller/pkg/postgres"
)

// PostgreSQLDatabaseReconciler reconciles a PostgreSQLDatabase object
type PostgreSQLDatabaseReconciler struct {
	client.Client
	Log logr.Logger

	// contains a map of credentials for hosts
	HostCredentials map[string]postgres.Credentials
}

//+kubebuilder:rbac:groups=postgresql.lunar.tech,resources=postgresqldatabases,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=postgresql.lunar.tech,resources=postgresqldatabases/status,verbs=get;update;patch
//+kubebuilder:rbac:groups="",resources=secrets;configmaps,verbs=get;list

func (r *PostgreSQLDatabaseReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	reqLogger := log.FromContext(ctx)

	requestID, err := uuid.NewRandom()
	if err != nil {
		reqLogger.Error(err, "Failed to pick a request ID. Continuing without")
	}
	reqLogger = reqLogger.WithValues("requestId", requestID.String())
	status, err := r.reconcile(ctx, reqLogger, req)
	status.Persist(ctx, err, r.Log)

	return requeueStrategy(reqLogger, err)
}

// SetupWithManager sets up the controller with the Manager.
func (r *PostgreSQLDatabaseReconciler) SetupWithManager(mgr ctrl.Manager) error {
	return ctrl.NewControllerManagedBy(mgr).
		For(&postgresqlv1alpha1.PostgreSQLDatabase{}).
		Complete(r)
}

func (r *PostgreSQLDatabaseReconciler) reconcile(ctx context.Context, reqLogger logr.Logger, request reconcile.Request) (status, error) {
	reqLogger.Info("Reconciling PostgreSQLDatabase")
	// Fetch the PostgreSQLDatabase instance
	database := &postgresqlv1alpha1.PostgreSQLDatabase{}
	err := r.Client.Get(ctx, request.NamespacedName, database)
	if err != nil {
		if apierrors.IsNotFound(err) {
			// Request object not found, could have been deleted after reconcile request.
			// Owned objects are automatically garbage collected. For additional cleanup logic use finalizers.
			// Return and don't requeue
			return status{}, nil
		}
		// Error reading the object - requeue the request.
		return status{}, err
	}
	reqLogger = reqLogger.WithValues(
		"database", database.Spec.Name,
		"isShared", database.Spec.IsShared,
	)
	reqLogger.Info("Updating PostgreSQLDatabase resource")

	status := status{
		log:      reqLogger,
		client:   r.Client,
		now:      metav1.Now,
		database: database,
	}
	host, adminCredentials, err := r.adminCredentials(ctx, reqLogger, &adminCredentialsParams{
		namespace:       request.NamespacedName.Namespace,
		host:            database.Spec.Host,
		hostCredentials: database.Spec.HostCredentials,
	})
	if err != nil {
		return status, fmt.Errorf("determining host credentials: %w", err)
	}
	status.host = host
	reqLogger = reqLogger.WithValues("host", host)
	user, err := kube.ResourceValue(r.Client, database.Spec.User, request.Namespace)
	if err != nil {
		if !ctlerrors.IsInvalid(err) {
			return status, fmt.Errorf("resolve user reference: %w", err)
		}
		// backwards compatibility to support resources without a User
		reqLogger.Info("User name fallback to database name")
		user = database.Spec.Name
	}
	status.user = user
	reqLogger = reqLogger.WithValues("user", user)
	password, err := kube.ResourceValue(r.Client, database.Spec.Password, request.Namespace)
	if err != nil {
		return status, fmt.Errorf("resolve password reference: %w", err)
	}
	isShared := database.Spec.IsShared

	reqLogger.Info("Resolved all referenced values for PostgreSQLDatabase resource")

	// Ensure the database is in sync with the object
	err = r.EnsurePostgreSQLDatabase(
		ctx,
		reqLogger,
		&EnsureParams{
			Host:  host,
			Admin: *adminCredentials,
			Target: postgres.Credentials{
				Name:     database.Spec.Name,
				User:     user,
				Password: password,
				Shared:   isShared,
			},
		},
	)
	if err != nil {
		return status, fmt.Errorf("ensure database: %w", err)
	}
	return status, nil
}

type status struct {
	log    logr.Logger
	client client.Client
	now    func() metav1.Time

	database *postgresqlv1alpha1.PostgreSQLDatabase
	host     string
	user     string
}

// Persist writes the status to a PostgreSQLDatabase instance and persists it on
// client. Any errors are logged.
func (s *status) Persist(ctx context.Context, err error, log logr.Logger) {
	ok := s.update(err)
	if !ok {
		return
	}
	err = s.client.Status().Update(ctx, s.database)
	if err != nil {
		log.Error(err, "failed to set status of database", "status", s)
	}
}

// update updates database reference based on its values and returns whether any
// changes were written.
func (s *status) update(err error) bool {
	if s.database == nil {
		return false
	}

	var errorMessage string
	var phase postgresqlv1alpha1.PostgreSQLDatabasePhase
	switch {
	case err == nil:
		phase = postgresqlv1alpha1.PostgreSQLDatabasePhaseRunning
	case err != nil:
		errorMessage = err.Error()
		if ctlerrors.IsInvalid(err) {
			phase = postgresqlv1alpha1.PostgreSQLDatabasePhaseInvalid
		} else {
			phase = postgresqlv1alpha1.PostgreSQLDatabasePhaseFailed
		}
	}
	phaseEqual := s.database.Status.Phase == phase
	errorEqual := s.database.Status.Error == errorMessage
	hostEqual := s.database.Status.Host == s.host
	if phaseEqual && errorEqual && hostEqual {
		return false
	}
	s.database.Status.PhaseUpdated = s.now()
	s.database.Status.Phase = phase
	s.database.Status.Host = s.host
	s.database.Status.User = s.user
	s.database.Status.Error = errorMessage
	return true
}

// requeueStrategy returns the right strategy for handling any errors from the
// reconciliation loop.
func requeueStrategy(log logr.Logger, err error) (ctrl.Result, error) {
	if err == nil {
		return ctrl.Result{}, nil
	}

	// if resource is invalid there is nothing we can do about it and we rely on
	// the client to update the resource before we touch it again
	if ctlerrors.IsInvalid(err) {
		log.Info("Dropping resources from queue as it is invalid", "error", err)
		return reconcile.Result{}, nil
	}

	// if it is a temporary error, eg. secret not found, we try again shortly as
	// the secret might have appeared
	if ctlerrors.IsTemporary(err) {
		log.Info("Failed to reconcile PostgreSQLDatabase object, attempting again shortly", "error", err)
		return ctrl.Result{
			RequeueAfter: 10 * time.Second,
		}, nil
	}

	// if it is an unknown error we try again later as it might be an unidentified
	// temporary issue, eg. no access to Kubernetes API.
	log.Info("Failed to reconcile PostgreSQLDatabase object due unknown error", "error", err)
	return ctrl.Result{
		RequeueAfter: 10 * time.Second,
	}, nil
}

// EnsureParams contains the required parameters for
// `PostgreSQLDatabaseReconciler.EnsurePostgreSQLDatabase()`.
type EnsureParams struct {
	// Host is the host name for the database instance.
	Host string

	// Admin holds the administrator credentials for the database instance.
	Admin postgres.Credentials

	// Target contains the credentials for the Postgres database that we intend
	// to create.
	Target postgres.Credentials
}

func (r *PostgreSQLDatabaseReconciler) EnsurePostgreSQLDatabase(ctx context.Context, log logr.Logger, params *EnsureParams) error {
	connectionString := postgres.ConnectionString{
		Host:     params.Host,
		Database: "postgres", // default database
		User:     params.Admin.Name,
		Password: params.Admin.Password,
		Params:   params.Admin.Params,
	}
	db, err := postgres.Connect(log, connectionString)
	if err != nil {
		return fmt.Errorf("connect to host %s: %w", connectionString, err)
	}
	defer func() {
		err := db.Close()
		if err != nil {
			log.Error(err, "failed to close database connection", "host", params.Host, "database", "postgres", "user", params.Admin.Name)
		}
	}()
	err = postgres.Database(log, db, params.Host, params.Target)
	if err != nil {
		return fmt.Errorf("create database %s on host %s: %w", params.Target.Name, connectionString, err)
	}
	return nil
}

type adminCredentialsParams struct {
	// namespace is the namespace containing the target PostgreSQLDatabase
	// resource.
	namespace string

	// host is the host name of the host. If it is provided, its value must be
	// a key in the `PostgreSQLDatabaseReconciler`'s `HostCredentials` map
	// field. It must not be provided if `HostCredentials` is provided.
	host postgresqlv1alpha1.ResourceVar

	// hostCredentials is the name of the `PostgreSQLHostCredentials` resource
	// in the same namespace. It must not be provided if `Host` is provided.
	hostCredentials string
}

// adminCredentials returns the correct `postgres.Credentials` based on the
// values of `params.Host` and `params.HostCredentials` fields of `params`.
// Exactly one of these fields must be set, and if `Host` is set, then this
// method will return the adminCredentials from `r.HostCredentials` map,
// otherwise it will search the Kubernetes namespace for a
// `PostgreSQLHostCredentials` with the name specified in
// `params.HostCredentials`.
func (r *PostgreSQLDatabaseReconciler) adminCredentials(ctx context.Context, reqLogger logr.Logger, params *adminCredentialsParams) (string, *postgres.Credentials, error) {
	host, err := kube.ResourceValue(r.Client, params.host, params.namespace)
	if err != nil {
		// if the `host` value is missing, we want to keep going because it
		// should mean that the `hostCredentials` is provided.
		if !errors.Is(err, kube.ErrNoValue) {
			return "", nil, fmt.Errorf("resolve host reference: %w", err)
		}
	}

	// If the `HostCredentials` field is populated and the `Host` field is
	// empty, then return credentials stored in the corresponding
	// `PostgreSQLHostCredentials` resource.
	if host == "" && params.hostCredentials != "" {
		reqLogger.Info(fmt.Sprintf("Using remote host credential from PostgreSQLHostCredentials resource %s/%s", params.namespace, params.hostCredentials))
		host, credentials, err := r.remoteCredentials(ctx, params.namespace, params.hostCredentials)
		if err != nil {
			return "", nil, fmt.Errorf("get remote credentials %s/%s: %w", params.namespace, params.hostCredentials, err)
		}
		return host, credentials, nil
	}

	// If the `Host` field is populated but no the `HostCredentials` field,
	// then return the credentials from the `r.HostCredentials` map.
	if params.hostCredentials == "" && host != "" {
		reqLogger.Info("Using local host credential from controller arguments")
		cs, ok := r.HostCredentials[host]
		if !ok {
			return "", nil, ctlerrors.NewInvalid(fmt.Errorf("unknown credentials for host"))
		}
		return host, &cs, nil
	}

	// If we got here, neither or both of the fields are populated. Return an
	// error.
	return "", nil, ctlerrors.NewInvalid(fmt.Errorf("must specify exactly one of `host` and `hostCredentials`"))
}

// remoteCredentials resolves the credentials from a `PostgreSQLHostCredentials`
// resource.
func (r *PostgreSQLDatabaseReconciler) remoteCredentials(ctx context.Context, namespace, name string) (string, *postgres.Credentials, error) {
	// Fetch the `PostgreSQLHostCredentials` from the API.
	var hostCreds postgresqlv1alpha1.PostgreSQLHostCredentials
	err := r.Client.Get(
		ctx,
		types.NamespacedName{
			Namespace: namespace,
			Name:      name,
		},
		&hostCreds,
	)
	if err != nil {
		return "", nil, fmt.Errorf("get PostgreSQLHostCredentials resource: %w", err)
	}

	// Resolve the `user` field.
	user, err := kube.ResourceValue(r.Client, hostCreds.Spec.User, hostCreds.Namespace)
	if err != nil {
		return "", nil, fmt.Errorf("resolve user resource var: %w", err)
	}

	// Resolve the `password` field.
	password, err := kube.ResourceValue(r.Client, hostCreds.Spec.Password, hostCreds.Namespace)
	if err != nil {
		return "", nil, fmt.Errorf("resolve password resource var: %w", err)
	}

	// Resolve the `host` field.
	host, err := kube.ResourceValue(r.Client, hostCreds.Spec.Host, hostCreds.Namespace)
	if err != nil {
		return "", nil, fmt.Errorf("resolve host resource var: %w", err)
	}

	// Return the resulting host and credentials
	return host, &postgres.Credentials{
		Name:     user,
		User:     user,
		Password: password,
		Params:   hostCreds.Spec.Params,
	}, nil
}

repository: lunarway/postgresql-controller

repo_name: lunarway/postgresql-controller

gha_language: Go


text:
SUMMARY = "Tool used to launch programs quickly by typing their names "
LICENSE = "LGPL-2.1-only"
LIC_FILES_CHKSUM = "file://LICENSE;md5=435ed639f84d4585d93824e7da3d85da"

inherit lxqt qt5-translation pkgconfig features_check

REQUIRED_DISTRO_FEATURES = "x11"

DEPENDS += "qtscript libqtxdg lxqt-globalkeys menu-cache muparser"

SRCREV = "026092e281f32c3575ad897791e75c07192f5639"
PV = "1.2.0"