text:
package log

import (
	"context"
	"errors"
	"fmt"
	"io"
	"os"

	"gitoa.ru/go-4devs/log/entry"
	"gitoa.ru/go-4devs/log/field"
	"gitoa.ru/go-4devs/log/level"
)

var _ io.Writer = (Logger)(nil)

var (
	ErrIgnoredKey    = errors.New("ignored key without a value")
	ErrNonStringKeys = errors.New("ignored key-value pairs with non-string keys")
)

func writeOutput(_ int, err error) {
	if err != nil {
		fmt.Fprint(os.Stderr, err)
	}
}

// Logger logged message.
type Logger func(ctx context.Context, entry *entry.Entry) (int, error)

func (l Logger) Write(in []byte) (int, error) {
	return l.write(context.Background(), level.Info, string(in))
}

func (l Logger) write(ctx context.Context, level level.Level, msg string, fields ...field.Field) (int, error) {
	data := entry.Get()

	defer func() {
		entry.Put(data)
	}()

	return l(ctx, data.SetLevel(level).SetMessage(msg).Add(fields...))
}

func (l Logger) writef(ctx context.Context, level level.Level, format string, args ...interface{}) (int, error) {
	data := entry.Get()

	defer func() {
		entry.Put(data)
	}()

	return l(ctx, data.SetLevel(level).SetMessagef(format, args...))
}

func (l Logger) kv(ctx context.Context, args ...interface{}) field.Fields {
	kvEntry := entry.Get()

	defer func() {
		entry.Put(kvEntry)
	}()

	for i := 0; i < len(args); i++ {
		if f, ok := args[i].(field.Field); ok {
			kvEntry = kvEntry.Add(f)

			continue
		}

		if i == len(args)-1 {
			writeOutput(l.write(ctx, level.Critical, fmt.Sprint("Ignored key without a value.", args[i]), kvEntry.Fields()...))

			break
		}

		i++

		key, val := args[i-1], args[i]
		if keyStr, ok := key.(string); ok {
			kvEntry = kvEntry.AddAny(keyStr, val)

			continue
		}

		writeOutput(l.write(ctx, level.Critical, fmt.Sprint("Ignored key-value pairs with non-string keys.", key, val), kvEntry.Fields()...))
	}

	return kvEntry.Fields()
}

// With adds middlewares to logger.
func (l Logger) With(mw ...Middleware) Logger {
	return With(l, mw...)
}

// Emerg log by emergency level.
func (l Logger) Emerg(ctx context.Context, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Emergency, "", args...))
}

// Alert log by alert level.
func (l Logger) Alert(ctx context.Context, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Alert, "", args...))
}

// Crit log by critical level.
func (l Logger) Crit(ctx context.Context, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Critical, "", args...))
}

// Err log by error level.
func (l Logger) Err(ctx context.Context, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Error, "", args...))
}

// Warn log by warning level.
func (l Logger) Warn(ctx context.Context, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Warning, "", args...))
}

// Notice log by notice level.
func (l Logger) Notice(ctx context.Context, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Notice, "", args...))
}

// Info log by info level.
func (l Logger) Info(ctx context.Context, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Info, "", args...))
}

// Debug log by debug level.
func (l Logger) Debug(ctx context.Context, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Debug, "", args...))
}

// Print log by info level and arguments.
func (l Logger) Print(args ...interface{}) {
	writeOutput(l.writef(context.Background(), level.Info, "", args...))
}

// Fatal log by alert level and arguments.
func (l Logger) Fatal(args ...interface{}) {
	writeOutput(l.writef(context.Background(), level.Alert, "", args...))
}

// Panic log by emergency level and arguments.
func (l Logger) Panic(args ...interface{}) {
	writeOutput(l.writef(context.Background(), level.Emergency, "", args...))
}

// Println log by info level and arguments.
func (l Logger) Println(args ...interface{}) {
	writeOutput(l.write(context.Background(), level.Info, fmt.Sprintln(args...)))
}

// Fatalln log by alert level and arguments.
func (l Logger) Fatalln(args ...interface{}) {
	writeOutput(l.write(context.Background(), level.Alert, fmt.Sprintln(args...)))
}

// Panicln log by emergency level and arguments.
func (l Logger) Panicln(args ...interface{}) {
	writeOutput(l.write(context.Background(), level.Emergency, fmt.Sprintln(args...)))
}

// EmergKVs sugared log by emergency level and key-values.
func (l Logger) EmergKVs(ctx context.Context, msg string, args ...interface{}) {
	writeOutput(l.write(ctx, level.Emergency, msg, l.kv(ctx, args...)...))
}

// AlertKVs sugared log by alert level and key-values.
func (l Logger) AlertKVs(ctx context.Context, msg string, args ...interface{}) {
	writeOutput(l.write(ctx, level.Alert, msg, l.kv(ctx, args...)...))
}

// CritKVs sugared log by critcal level and key-values.
func (l Logger) CritKVs(ctx context.Context, msg string, args ...interface{}) {
	writeOutput(l.write(ctx, level.Critical, msg, l.kv(ctx, args...)...))
}

// ErrKVs sugared log by error level and key-values.
func (l Logger) ErrKVs(ctx context.Context, msg string, args ...interface{}) {
	writeOutput(l.write(ctx, level.Error, msg, l.kv(ctx, args...)...))
}

// WarnKVs sugared log by warning level and key-values.
func (l Logger) WarnKVs(ctx context.Context, msg string, args ...interface{}) {
	writeOutput(l.write(ctx, level.Warning, msg, l.kv(ctx, args...)...))
}

// NoticeKVs sugared log by notice level and key-values.
func (l Logger) NoticeKVs(ctx context.Context, msg string, args ...interface{}) {
	writeOutput(l.write(ctx, level.Notice, msg, l.kv(ctx, args...)...))
}

// InfoKVs sugared log by info level and key-values.
func (l Logger) InfoKVs(ctx context.Context, msg string, args ...interface{}) {
	writeOutput(l.write(ctx, level.Info, msg, l.kv(ctx, args...)...))
}

// DebugKVs sugared log by debug level and key-values.
func (l Logger) DebugKVs(ctx context.Context, msg string, args ...interface{}) {
	writeOutput(l.write(ctx, level.Debug, msg, l.kv(ctx, args...)...))
}

// EmergKV log by emergency level and key-values.
func (l Logger) EmergKV(ctx context.Context, msg string, args ...field.Field) {
	writeOutput(l.write(ctx, level.Emergency, msg, args...))
}

// AlertKV log by alert level and key-values.
func (l Logger) AlertKV(ctx context.Context, msg string, args ...field.Field) {
	writeOutput(l.write(ctx, level.Alert, msg, args...))
}

// CritKV log by critcal level and key-values.
func (l Logger) CritKV(ctx context.Context, msg string, args ...field.Field) {
	writeOutput(l.write(ctx, level.Critical, msg, args...))
}

// ErrKV log by error level and key-values.
func (l Logger) ErrKV(ctx context.Context, msg string, args ...field.Field) {
	writeOutput(l.write(ctx, level.Error, msg, args...))
}

// WarnKV log by warning level and key-values.
func (l Logger) WarnKV(ctx context.Context, msg string, args ...field.Field) {
	writeOutput(l.write(ctx, level.Warning, msg, args...))
}

// NoticeKV log by notice level and key-values.
func (l Logger) NoticeKV(ctx context.Context, msg string, args ...field.Field) {
	writeOutput(l.write(ctx, level.Notice, msg, args...))
}

// InfoKV log by info level and key-values.
func (l Logger) InfoKV(ctx context.Context, msg string, args ...field.Field) {
	writeOutput(l.write(ctx, level.Info, msg, args...))
}

// DebugKV log by debug level and key-values.
func (l Logger) DebugKV(ctx context.Context, msg string, args ...field.Field) {
	writeOutput(l.write(ctx, level.Debug, msg, args...))
}

// Emergf log by emergency level by format and arguments.
func (l Logger) Emergf(ctx context.Context, format string, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Emergency, format, args...))
}

// Alertf log by alert level by format and arguments.
func (l Logger) Alertf(ctx context.Context, format string, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Alert, format, args...))
}

// Critf log by critical level by format and arguments.
func (l Logger) Critf(ctx context.Context, format string, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Critical, format, args...))
}

// Errf log by error level by format and arguments.
func (l Logger) Errf(ctx context.Context, format string, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Error, format, args...))
}

// Warnf log by warning level by format and arguments.
func (l Logger) Warnf(ctx context.Context, format string, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Warning, format, args...))
}

// Noticef log by notice level by format and arguments.
func (l Logger) Noticef(ctx context.Context, format string, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Notice, format, args...))
}

// Infof log by info level by format and arguments.
func (l Logger) Infof(ctx context.Context, format string, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Info, format, args...))
}

// Debugf log by debug level by format and arguments.
func (l Logger) Debugf(ctx context.Context, format string, args ...interface{}) {
	writeOutput(l.writef(ctx, level.Debug, format, args...))
}

// Printf log by info level by format and arguments without context.
func (l Logger) Printf(format string, args ...interface{}) {
	writeOutput(l.writef(context.Background(), level.Info, format, args...))
}

// Fatalf log by alert level by format and arguments without context.
func (l Logger) Fatalf(format string, args ...interface{}) {
	writeOutput(l.writef(context.Background(), level.Alert, format, args...))
}

// Panicf log by emergency level and arguments without context.
func (l Logger) Panicf(format string, args ...interface{}) {
	writeOutput(l.writef(context.Background(), level.Emergency, format, args...))
}

func (l Logger) Writer(ctx context.Context, level level.Level, fields ...field.Field) io.Writer {
	return writer{
		ctx:    ctx,
		level:  level,
		Logger: l,
		fields: fields,
	}
}

//nolint:containedctx
type writer struct {
	ctx    context.Context
	level  level.Level
	fields []field.Field
	Logger
}

func (w writer) WithLevel(level level.Level) writer {
	return writer{
		level:  level,
		Logger: w.Logger,
		ctx:    w.ctx,
		fields: w.fields,
	}
}

func (w writer) WithContext(ctx context.Context) writer {
	return writer{
		level:  w.level,
		Logger: w.Logger,
		ctx:    ctx,
		fields: w.fields,
	}
}

func (w writer) WithFields(fields ...field.Field) writer {
	return writer{
		level:  w.level,
		Logger: w.Logger,
		ctx:    w.ctx,
		fields: fields,
	}
}

func (w writer) Write(in []byte) (int, error) {
	return w.write(w.ctx, w.level, string(in), w.fields...)
}

license: MIT

gha_license_id: MIT


text:
SUMMARY = "Bare-metal build of a subset of LLVM 3.6 with support for TI C66x"
HOMEPAGE = "http://git.ti.com/opencl/llvm"
DESCRIPTION = "A subset of LLVM 3.6 libraries built using gcc-arm-baremetal-native. Used in the OpenCL running over a TI-RTOS based host."

# 3-clause BSD-like
# University of Illinois/NCSA Open Source License
LICENSE = "NCSA"

require llvm-rtos.inc
require recipes-ti/includes/arago-paths.inc

PR = "${INC_PR}.0"

DEPENDS = "gcc-arm-baremetal-native cmake-native"

COMPATIBLE_MACHINE = "omap-a15"
PACKAGE_ARCH = "${MACHINE_ARCH}"

S = "${WORKDIR}/git"
RELEASE_TARGET = ""
RELEASE_TARGET_omap-a15 = "am57xx"

CLEANBROKEN = "1"

export LLVM_SRC_DIR="${S}"
export LLVM_INSTALL_DIR="${D}${LLVM_RTOS_INSTALL_DIR_RECIPE}"

do_compile() {
    unset LDFLAGS
    unset TARGET_LDFLAGS

    # Clean the build directory
    rm -rf build.sysbios

    mkdir -p build.sysbios/build.native
    cd build.sysbios/build.native; CC="${BUILD_CC}" CXX="${BUILD_CXX}" cmake "${S}"; cd ../..
    make -C build.sysbios/build.native llvm-tblgen llvm-config ${PARALLEL_MAKE}

    cd build.sysbios; cmake -DCMAKE_TOOLCHAIN_FILE="${S}/ToolChain_ARMSysBios.cmake" -Wno-dev "${S}"; cd ..

    make -C build.sysbios LLVMSupport LLVMCore LLVMBitReader ${PARALLEL_MAKE}

}

do_install() {
    cd build.sysbios; make -f include/llvm/Makefile install/local; cd ..

    install -d ${D}${LLVM_RTOS_INSTALL_DIR_RECIPE}/bin
    install -m 755 ${S}/build.sysbios/build.native/bin/llvm-config ${D}${LLVM_RTOS_INSTALL_DIR_RECIPE}/bin/llvm-config-host

    install -d ${D}${LLVM_RTOS_INSTALL_DIR_RECIPE}/lib
    for libfile in ${S}/build.sysbios/lib/*.a; do
        install -m 644 ${libfile} ${D}${LLVM_RTOS_INSTALL_DIR_RECIPE}/lib
    done
}

FILES_${PN} += "${LLVM_RTOS_INSTALL_DIR_RECIPE}"

# This package contains one x86-64 executable and a few static libraries
INSANE_SKIP_${PN} = "arch file-rdeps staticdev"

INHIBIT_PACKAGE_STRIP = "1"
INHIBIT_SYSROOT_STRIP = "1"
INHIBIT_PACKAGE_DEBUG_SPLIT = "1"

license_type: permissive

branch_name: refs/heads/master

extension: bb


text:
import React from 'react'
import { DropdownHeroStyled } from './styled'
import cx from "classnames";
import Select from "react-select";
import { selectOptions } from "variables/Variables.jsx";
import {
    FormGroup,
    Col
} from 'react-bootstrap'

export class DropdownHero extends React.Component {
    render() {
        const {
            theme_standard,
            label,
            width_label,
            width_select,
            max_width
        } = this.props
        const customClass = cx({
            "theme_standard": theme_standard
        })
        return (
            <DropdownHeroStyled
                width_label={width_label}
                width_select={width_select}
                max_width={max_width}
            >

                    <FormGroup>

{label}

                            <Select
                                placeholder="Single Select"
                                name="singleSelect"
                                options={selectOptions}
                                onChange={value =>
                                    this.setState({ singleSelect: value })
                                }
                            />

                    </FormGroup>

            </DropdownHeroStyled >
        )
    }
}

extension: js


text:
SUMMARY = "distributed pub/sub"
DESCRIPTION = "distributed pub/sub examples and lib."

LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE.md;md5=048191255019d4e1ee70aef53dbbec10"

S = "${WORKDIR}/git"
SRCREV_dps = "59a3c33d64f2b3fc16cc5c52b5f4a7bec47640a7"
SRCREV_safestring = "db404a9bba3a58d06adfdab4021e7b91265ac0f0"
PV = "0.1+git${SRCPV}"
PR = "r0"

SRCREV_FORMAT = "dps"
SRC_URI = "git://github.com/01org/dps-for-iot.git;name=dps \
           git://github.com/01org/safestringlib.git;protocol=https;name=safestring;destsuffix=git/ext/safestring \
           "
inherit scons

DEPENDS = "libuv nodejs python-scons-native python"

INSANE_SKIP_${PN} += " ldflags"
INSANE_SKIP_${PN}-dev += "ldflags"
INSANE_SKIP_${PN}-dbg += "ldflags"

ERROR_QA_remove = "ldflags"
WARN_QA_append = " ldflags"

EXTRA_OESCONS = " \
    sysroot=${STAGING_DIR_TARGET} \
"

do_compile_prepend() {
    export PKG_CONFIG_PATH="${PKG_CONFIG_PATH}"
    export PKG_CONFIG="PKG_CONFIG_SYSROOT_DIR=\"${PKG_CONFIG_SYSROOT_DIR}\" pkg-config"
    export STAGING_PREFIX="${STAGING_DIR_HOST}/${prefix}"
    export LINKFLAGS="${LDFLAGS}"
    export SYSROOT="${STAGING_DIR_TARGET}"
}
scons_do_compile() {
    ${STAGING_BINDIR_NATIVE}/scons target=yocto ${PARALLEL_MAKE} ${EXTRA_OESCONS} || \
    die "scons build execution failed."
}

do_install() {
    install -d ${D}${libdir}/dps
    install -m 0755 ${WORKDIR}/git/build/dist/lib/libdps_shared.so ${D}${libdir}/dps/libdps_shared.so
    install -m 0755 ${WORKDIR}/git/build/dist/lib/libdps.a ${D}${libdir}/dps/libdps.a

    install -d ${D}/${libdir}/dps/bin
    install -c -m 0755 ${WORKDIR}/git/build/dist/bin/publisher ${D}/${libdir}/dps/bin/publisher
    install -c -m 0755 ${WORKDIR}/git/build/dist/bin/pub_many ${D}/${libdir}/dps/bin/pub_many
    install -c -m 0755 ${WORKDIR}/git/build/dist/bin/registry ${D}/${libdir}/dps/bin/registry
    install -c -m 0755 ${WORKDIR}/git/build/dist/bin/reg_pubs ${D}/${libdir}/dps/bin/reg_pubs
    install -c -m 0755 ${WORKDIR}/git/build/dist/bin/reg_subs ${D}/${libdir}/dps/bin/reg_subs
    install -c -m 0755 ${WORKDIR}/git/build/dist/bin/subscriber ${D}/${libdir}/dps/bin/subscriber
}

PACKAGES =+ "${PN}-tests"

RDEPENDS_${PN} += "libuv"
ALLOW_EMPTY_${PN}-staticdev = "1"

FILES_${PN} += "${libdir}/dps/libdps_shared.so"

FILES_${PN}-staticdev += "${libdir}/dps/libdps.a"

FILES_${PN}-tests += "${libdir}/dps/bin/publisher \
                    ${libdir}/dps/bin/pub_many \
                    ${libdir}/dps/bin/registry \
                    ${libdir}/dps/bin/reg_pubs \
                    ${libdir}/dps/bin/reg_subs \
                    ${libdir}/dps/bin/subscriber"

repository: intel/dps-for-iot

repo_name: intel/dps-for-iot

gha_license_id: NOASSERTION

gha_language: C


text:
package model

import (
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/utils"

	"strings"
)

// RestoreNewInstanceRequestBody 实例信息。
type RestoreNewInstanceRequestBody struct {

	// 实例名称。用于表示实例的名称，用于表示实例的名称，允许和已有名称重复。 取值范围：长度为4~64位，必须以字母开头（A~Z或a~z），区分大小写，可以包含字母、数字（0~9）、中划线（-）或者下划线（_），不能包含其他特殊字符。
	Name string `json:"name"`

	// 可用区ID，请参见[地区和终端节点](https://developer.huaweicloud.com/endpoint)。
	AvailabilityZone string `json:"availability_zone"`

	// 虚拟私有云ID。获取方法请参见《虚拟私有云API参考》中“VPC”的内容。 取值：非空，字符长度校验，严格UUID正则校验。
	VpcId string `json:"vpc_id"`

	// 子网ID。获取方法请参见《虚拟私有云API参考》中“子网”的内容。
	SubnetId string `json:"subnet_id"`

	// 指定实例所属的安全组ID。 获取方法请参见《虚拟私有云API参考》中“安全组”的内容。
	SecurityGroupId string `json:"security_group_id"`

	// 数据库密码。 取值范围：长度为8~32位，必须是大写字母（A~Z）、小写字母（a~z）、数字（0~9）、特殊字符~!@#%^*-_=+?的组合。 建议您输入高强度密码，以提高安全性，防止出现密码被暴力破解等安全风险。
	Password *string `json:"password,omitempty"`

	// 磁盘加密时的密钥ID，严格UUID正则校验。 不传该参数时，表示不进行磁盘加密。
	DiskEncryptionId *string `json:"disk_encryption_id,omitempty"`

	// 参数组配置信息。
	Configurations *[]RestoreNewInstanceConfigurationsOption `json:"configurations,omitempty"`

	// 实例规格详情。
	Flavor []RestoreNewInstanceFlavorOption `json:"flavor"`

	BackupStrategy *BackupStrategy `json:"backup_strategy,omitempty"`

	// 企业项目ID。
	EnterpriseProjectId *string `json:"enterprise_project_id,omitempty"`

	// SSL开关选项。 取值： - 取“0”，表示DDS实例默认不启用SSL连接。 - 取“1”，表示DDS实例默认启用SSL连接。 - 不传该参数时，默认启用SSL连接。
	SslOption *string `json:"ssl_option,omitempty"`

	// 创建新实例所在专属存储池ID，仅专属云创建实例时有效。
	DssPoolId *string `json:"dss_pool_id,omitempty"`

	// 创建新实例设置云服务器组关联的策略名称列表，仅专属云创建实例时有效。 取值    - 取“anti-affinity”，表示DDS实例开启反亲和部署，反亲和部署是出于高可用性考虑，将您的Primary、Secondary和Hidden节点分别创建在不同的物理机上。当前仅支持该值，不传该值默认不开启反亲和部署。
	ServerGroupPolicies *[]string `json:"server_group_policies,omitempty"`

	RestorePoint *RestorePoint `json:"restore_point"`

	ChargeInfo *ChargeInfoOption `json:"charge_info,omitempty"`
}

func (o RestoreNewInstanceRequestBody) String() string {
	data, err := utils.Marshal(o)
	if err != nil {
		return "RestoreNewInstanceRequestBody struct{}"
	}

	return strings.Join([]string{"RestoreNewInstanceRequestBody", string(data)}, " ")
}

gha_language: Go

extension: go


text:
@article{ SaezGallego2016-reserve,
title={Determining reserve requirements in DK1 area of Nord Pool using a probabilistic approach},
  author={Saez-Gallego, Javier and Morales, Juan M and Madsen, Henrik and J{\'o}nsson, Tryggvi},
  journal={Energy},
  volume={74},
  pages={682--693},
  year={2014},
  publisher={Elsevier}
}

gha_language: CSS

extension: bib


text:
/*
Copyright 2019 Cisco Systems

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.
*/

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

package cisco_ios_xr_bundlemgr_oper_bundle_information_events_mbr_events_mbr_bundles_events_mbr_bundle_events_mbr_bundle_descendant

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	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 BmdEventBagMultiple_KEYS struct {
	BundleInterface      string   `protobuf:"bytes,1,opt,name=bundle_interface,json=bundleInterface,proto3" json:"bundle_interface,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_BmdEventBagMultiple_KEYS proto.InternalMessageInfo

func (m *BmdEventBagMultiple_KEYS) GetBundleInterface() string {
	if m != nil {
		return m.BundleInterface
	}
	return ""
}

type BmdBagEventData struct {
	DataType             string   `protobuf:"bytes,1,opt,name=data_type,json=dataType,proto3" json:"data_type,omitempty"`
	NoData               uint32   `protobuf:"varint,2,opt,name=no_data,json=noData,proto3" json:"no_data,omitempty"`
	Error                uint32   `protobuf:"varint,3,opt,name=error,proto3" json:"error,omitempty"`
	StringData           string   `protobuf:"bytes,4,opt,name=string_data,json=stringData,proto3" json:"string_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_BmdBagEventData proto.InternalMessageInfo

func (m *BmdBagEventData) GetDataType() string {
	if m != nil {
		return m.DataType
	}
	return ""
}

func (m *BmdBagEventData) GetNoData() uint32 {
	if m != nil {
		return m.NoData
	}
	return 0
}

func (m *BmdBagEventData) GetError() uint32 {
	if m != nil {
		return m.Error
	}
	return 0
}

func (m *BmdBagEventData) GetStringData() string {
	if m != nil {
		return m.StringData
	}
	return ""
}

type BmdBagEventItemMbr struct {
	MemberEventType      string           `protobuf:"bytes,1,opt,name=member_event_type,json=memberEventType,proto3" json:"member_event_type,omitempty"`
	TimeStamp            uint64           `protobuf:"varint,2,opt,name=time_stamp,json=timeStamp,proto3" json:"time_stamp,omitempty"`
	Data                 *BmdBagEventData `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_BmdBagEventItemMbr proto.InternalMessageInfo

func (m *BmdBagEventItemMbr) GetMemberEventType() string {
	if m != nil {
		return m.MemberEventType
	}
	return ""
}

func (m *BmdBagEventItemMbr) GetTimeStamp() uint64 {
	if m != nil {
		return m.TimeStamp
	}
	return 0
}

func (m *BmdBagEventItemMbr) GetData() *BmdBagEventData {
	if m != nil {
		return m.Data
	}
	return nil
}

type BmdBagEventItemBdl struct {
	BundleEventType      string           `protobuf:"bytes,1,opt,name=bundle_event_type,json=bundleEventType,proto3" json:"bundle_event_type,omitempty"`
	TimeStamp            uint64           `protobuf:"varint,2,opt,name=time_stamp,json=timeStamp,proto3" json:"time_stamp,omitempty"`
	Data                 *BmdBagEventData `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_BmdBagEventItemBdl proto.InternalMessageInfo

func (m *BmdBagEventItemBdl) GetBundleEventType() string {
	if m != nil {
		return m.BundleEventType
	}
	return ""
}

func (m *BmdBagEventItemBdl) GetTimeStamp() uint64 {
	if m != nil {
		return m.TimeStamp
	}
	return 0
}

func (m *BmdBagEventItemBdl) GetData() *BmdBagEventData {
	if m != nil {
		return m.Data
	}
	return nil
}

type BmdBagEventItemRg struct {
	RgEventType          string           `protobuf:"bytes,1,opt,name=rg_event_type,json=rgEventType,proto3" json:"rg_event_type,omitempty"`
	TimeStamp            uint64           `protobuf:"varint,2,opt,name=time_stamp,json=timeStamp,proto3" json:"time_stamp,omitempty"`
	Data                 *BmdBagEventData `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *BmdBagEventItemRg) Reset()         { *m = BmdBagEventItemRg{} }
func (m *BmdBagEventItemRg) String() string { return proto.CompactTextString(m) }
func (*BmdBagEventItemRg) ProtoMessage()    {}
func (*BmdBagEventItemRg) Descriptor() ([]byte, []int) {
	return fileDescriptor_2eb75e524eb4a446, []int{4}
}

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

var xxx_messageInfo_BmdBagEventItemRg proto.InternalMessageInfo

func (m *BmdBagEventItemRg) GetRgEventType() string {
	if m != nil {
		return m.RgEventType
	}
	return ""
}

func (m *BmdBagEventItemRg) GetTimeStamp() uint64 {
	if m != nil {
		return m.TimeStamp
	}
	return 0
}

func (m *BmdBagEventItemRg) GetData() *BmdBagEventData {
	if m != nil {
		return m.Data
	}
	return nil
}

type BmdBagEventItem struct {
	EventType            string              `protobuf:"bytes,1,opt,name=event_type,json=eventType,proto3" json:"event_type,omitempty"`
	MemberEvtInfo        *BmdBagEventItemMbr `protobuf:"bytes,2,opt,name=member_evt_info,json=memberEvtInfo,proto3" json:"member_evt_info,omitempty"`
	BundleEvtInfo        *BmdBagEventItemBdl `protobuf:"bytes,3,opt,name=bundle_evt_info,json=bundleEvtInfo,proto3" json:"bundle_evt_info,omitempty"`
	RgEvtInfo            *BmdBagEventItemRg  `protobuf:"bytes,4,opt,name=rg_evt_info,json=rgEvtInfo,proto3" json:"rg_evt_info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *BmdBagEventItem) Reset()         { *m = BmdBagEventItem{} }
func (m *BmdBagEventItem) String() string { return proto.CompactTextString(m) }
func (*BmdBagEventItem) ProtoMessage()    {}
func (*BmdBagEventItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_2eb75e524eb4a446, []int{5}
}

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

var xxx_messageInfo_BmdBagEventItem proto.InternalMessageInfo

func (m *BmdBagEventItem) GetEventType() string {
	if m != nil {
		return m.EventType
	}
	return ""
}

func (m *BmdBagEventItem) GetMemberEvtInfo() *BmdBagEventItemMbr {
	if m != nil {
		return m.MemberEvtInfo
	}
	return nil
}

func (m *BmdBagEventItem) GetBundleEvtInfo() *BmdBagEventItemBdl {
	if m != nil {
		return m.BundleEvtInfo
	}
	return nil
}

func (m *BmdBagEventItem) GetRgEvtInfo() *BmdBagEventItemRg {
	if m != nil {
		return m.RgEvtInfo
	}
	return nil
}

type BmdEventBag struct {
	ItemName             string             `protobuf:"bytes,1,opt,name=item_name,json=itemName,proto3" json:"item_name,omitempty"`
	Items                []*BmdBagEventItem `protobuf:"bytes,2,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *BmdEventBag) Reset()         { *m = BmdEventBag{} }
func (m *BmdEventBag) String() string { return proto.CompactTextString(m) }
func (*BmdEventBag) ProtoMessage()    {}
func (*BmdEventBag) Descriptor() ([]byte, []int) {
	return fileDescriptor_2eb75e524eb4a446, []int{6}
}

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

var xxx_messageInfo_BmdEventBag proto.InternalMessageInfo

func (m *BmdEventBag) GetItemName() string {
	if m != nil {
		return m.ItemName
	}
	return ""
}

func (m *BmdEventBag) GetItems() []*BmdBagEventItem {
	if m != nil {
		return m.Items
	}
	return nil
}

type BmdEventBagMultiple struct {
	EventsItem           []*BmdEventBag `protobuf:"bytes,50,rep,name=events_item,json=eventsItem,proto3" json:"events_item,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *BmdEventBagMultiple) Reset()         { *m = BmdEventBagMultiple{} }
func (m *BmdEventBagMultiple) String() string { return proto.CompactTextString(m) }
func (*BmdEventBagMultiple) ProtoMessage()    {}
func (*BmdEventBagMultiple) Descriptor() ([]byte, []int) {
	return fileDescriptor_2eb75e524eb4a446, []int{7}
}

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

var xxx_messageInfo_BmdEventBagMultiple proto.InternalMessageInfo

func (m *BmdEventBagMultiple) GetEventsItem() []*BmdEventBag {
	if m != nil {
		return m.EventsItem
	}
	return nil
}

func init() {
	proto.RegisterType((*BmdEventBagMultiple_KEYS)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.events_mbr.events_mbr_bundles.events_mbr_bundle.events_mbr_bundle_descendant.bmd_event_bag_multiple_KEYS")
	proto.RegisterType((*BmdBagEventData)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.events_mbr.events_mbr_bundles.events_mbr_bundle.events_mbr_bundle_descendant.bmd_bag_event_data")
	proto.RegisterType((*BmdBagEventItemMbr)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.events_mbr.events_mbr_bundles.events_mbr_bundle.events_mbr_bundle_descendant.bmd_bag_event_item_mbr")
	proto.RegisterType((*BmdBagEventItemBdl)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.events_mbr.events_mbr_bundles.events_mbr_bundle.events_mbr_bundle_descendant.bmd_bag_event_item_bdl")
	proto.RegisterType((*BmdBagEventItemRg)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.events_mbr.events_mbr_bundles.events_mbr_bundle.events_mbr_bundle_descendant.bmd_bag_event_item_rg")
	proto.RegisterType((*BmdBagEventItem)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.events_mbr.events_mbr_bundles.events_mbr_bundle.events_mbr_bundle_descendant.bmd_bag_event_item")
	proto.RegisterType((*BmdEventBag)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.events_mbr.events_mbr_bundles.events_mbr_bundle.events_mbr_bundle_descendant.bmd_event_bag")
	proto.RegisterType((*BmdEventBagMultiple)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.events_mbr.events_mbr_bundles.events_mbr_bundle.events_mbr_bundle_descendant.bmd_event_bag_multiple")
}

func init() { proto.RegisterFile("bmd_event_bag_multiple.proto", fileDescriptor_2eb75e524eb4a446) }

var fileDescriptor_2eb75e524eb4a446 = []byte{
	// 519 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x96, 0x3f, 0x6f, 0xd4, 0x30,
	0x18, 0xc6, 0xe5, 0xbb, 0xb4, 0x90, 0x37, 0x8a, 0x0e, 0x2c, 0xfe, 0x44, 0x2a, 0x88, 0x53, 0xa6,
	0xc2, 0x90, 0xe1, 0xf8, 0x0a, 0x54, 0xe2, 0x84, 0xc4, 0x90, 0xb2, 0x30, 0x59, 0xc9, 0xc5, 0x17,
	0x45, 0x8a, 0xed, 0xc8, 0x76, 0x11, 0x15, 0x53, 0xd7, 0x2e, 0x48, 0xf0, 0x15, 0x10, 0x13, 0x1b,
	0x2b, 0x3b, 0x9f, 0x80, 0xcf, 0xc0, 0xd7, 0x40, 0xaf, 0x9d, 0x44, 0x2d, 0x69, 0xe7, 0x9e, 0x3a,
	0xdd, 0xf9, 0xb1, 0xdf, 0x57, 0xbf, 0xf7, 0xb9, 0x3c, 0xe7, 0xc0, 0x93, 0x52, 0x54, 0x8c, 0x7f,
	0xe0, 0xd2, 0xb2, 0xb2, 0xa8, 0x99, 0x38, 0x69, 0x6d, 0xd3, 0xb5, 0x3c, 0xeb, 0xb4, 0xb2, 0x8a,
	0x7e, 0xda, 0x34, 0x66, 0xa3, 0x58, 0xa3, 0x0c, 0xfb, 0xa8, 0x59, 0x79, 0x22, 0xab, 0x96, 0x8b,
	0x5a, 0x33, 0xd5, 0x71, 0x9d, 0xf9, 0x25, 0x6b, 0xe4, 0x56, 0x69, 0x51, 0xd8, 0x46, 0xc9, 0xcc,
	0x35, 0x32, 0x4c, 0x94, 0xfa, 0xc2, 0xd7, 0xbe, 0xce, 0x4c, 0xa5, 0xa9, 0xc2, 0x2a, 0x6e, 0x36,
	0x5c, 0x56, 0x85, 0xb4, 0xe9, 0x6b, 0x38, 0xb8, 0x1a, 0x8e, 0xbd, 0x39, 0x7a, 0x7f, 0x4c, 0x9f,
	0xc3, 0xbd, 0x91, 0xc0, 0x72, 0xbd, 0x2d, 0x36, 0x3c, 0x21, 0x4b, 0x72, 0x18, 0xe6, 0x0b, 0xaf,
	0xaf, 0x07, 0x39, 0x3d, 0x23, 0x40, 0xb1, 0x15, 0x36, 0xf1, 0xed, 0xaa, 0xc2, 0x16, 0xf4, 0x00,
	0x42, 0xfc, 0x64, 0xf6, 0xb4, 0x1b, 0x4a, 0xef, 0xa2, 0xf0, 0xee, 0xb4, 0xe3, 0xf4, 0x31, 0xdc,
	0x91, 0xca, 0x9d, 0x4b, 0x66, 0x4b, 0x72, 0x18, 0xe7, 0xfb, 0x52, 0xbd, 0xc2, 0xaa, 0x07, 0xb0,
	0xc7, 0xb5, 0x56, 0x3a, 0x99, 0x3b, 0xd9, 0x2f, 0xe8, 0x33, 0x88, 0x8c, 0xd5, 0x8d, 0xac, 0x7d,
	0x49, 0xe0, 0xba, 0x81, 0x97, 0xb0, 0x2c, 0x3d, 0x9f, 0xc1, 0xa3, 0xcb, 0x0c, 0x8d, 0xe5, 0x02,
	0x47, 0xa7, 0x2f, 0xe0, 0xbe, 0xe0, 0xa2, 0xe4, 0xba, 0xdf, 0xb8, 0xc0, 0xb3, 0xf0, 0x1b, 0x47,
	0xa8, 0x3b, 0xac, 0xa7, 0x00, 0xb6, 0x11, 0x9c, 0x19, 0x5b, 0x88, 0xce, 0x91, 0x05, 0x79, 0x88,
	0xca, 0x31, 0x0a, 0xf4, 0x1b, 0x81, 0xc0, 0x01, 0x20, 0x5c, 0xb4, 0xfa, 0x4c, 0xb2, 0x1b, 0xfc,
	0x05, 0xb3, 0xa9, 0xe7, 0xb9, 0xa3, 0xbb, 0xce, 0x8c, 0xb2, 0x6a, 0xd1, 0x8c, 0xbe, 0xd1, 0xd4,
	0x0c, 0xbf, 0x71, 0xdb, 0xcc, 0x38, 0x9b, 0xc1, 0xc3, 0x2b, 0xcc, 0xd0, 0x35, 0x4d, 0x21, 0xd6,
	0xf5, 0xd4, 0x87, 0x48, 0xd7, 0xb7, 0xcd, 0x83, 0xbf, 0xc1, 0xff, 0x09, 0x45, 0x0f, 0x70, 0xb8,
	0xc9, 0xf4, 0x21, 0x1f, 0x67, 0xff, 0x45, 0x60, 0x31, 0x26, 0xc7, 0x3a, 0x6c, 0xe7, 0x40, 0xb4,
	0xfa, 0xba, 0x4b, 0x73, 0x0e, 0x41, 0xcf, 0xe3, 0x21, 0xcd, 0x76, 0x2d, 0xb7, 0xca, 0xe1, 0x8f,
	0xcf, 0x7a, 0x8f, 0x3f, 0xdf, 0x51, 0xfc, 0xb2, 0x6a, 0xf3, 0x78, 0xc8, 0x9f, 0xc7, 0xff, 0x49,
	0x20, 0x72, 0x8f, 0x67, 0x8f, 0x1e, 0x38, 0xf4, 0x2f, 0x3b, 0x87, 0xae, 0xeb, 0x3c, 0xc4, 0xc4,
	0x38, 0xea, 0xf4, 0x0f, 0x81, 0xf8, 0xd2, 0xb5, 0x82, 0xd7, 0x80, 0x3b, 0x27, 0x0b, 0x31, 0x5e,
	0x03, 0x28, 0xbc, 0x2d, 0x04, 0xa7, 0xdf, 0x09, 0xec, 0xe1, 0xc2, 0x24, 0xb3, 0xe5, 0x7c, 0xd7,
	0x02, 0x84, 0x60, 0xb9, 0xc7, 0x4b, 0x7f, 0x13, 0xff, 0x97, 0x3a, 0xbd, 0x2e, 0xe9, 0x0f, 0x02,
	0x51, 0xdf, 0x15, 0xcf, 0x26, 0x2b, 0x37, 0xc9, 0xf9, 0xcd, 0x4f, 0x32, 0xb2, 0xe6, 0x3e, 0xe6,
	0x66, 0x6d, 0xb9, 0x28, 0xf7, 0xdd, 0xbb, 0xc7, 0xcb, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe4,
	0x63, 0xf1, 0x57, 0x9b, 0x08, 0x00, 0x00,
}

repository: cisco-ie/cisco-proto

repo_name: cisco-ie/cisco-proto


text:
LICENSE = "BSD"
DESCRIPTION = "fget is a commandline tool for mirroring \
remote files via FTP. It was designed as an analog to the \
GNU wget utility. The fget package includes an FTP client \
library, so that others can make use of FTP from within \
their own C programs."
SECTION = "libs"
PRIORITY = "optional"

SRC_URI = "ftp://ftp.feep.net/pub/software/fget/fget-${PV}.tar.gz"

inherit autotools

do_configure() {
	oe_runconf
}

do_stage() {
	oe_libinstall -a -C lib libfget ${STAGING_LIBDIR}
	install -m 0755 lib/libfget.h ${STAGING_INCDIR}/
}

SRC_URI[md5sum] = "a556eef04aeb574ac8ab0dd8c868fcab"
SRC_URI[sha256sum] = "ceaa67f19a1c5462f5e739fcd3b53dd42b0173d9deee579c55e5088801559e43"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
include(GenerateExportHeader)

function (libazul_generate_export_header component_name)
    generate_export_header(azul_${component_name} EXPORT_FILE_NAME "${CMAKE_BINARY_DIR}/exports/include/azul/${component_name}/export.hpp")
    target_include_directories(azul_${component_name} PUBLIC ${CMAKE_BINARY_DIR}/exports/include)
    install(FILES ${CMAKE_BINARY_DIR}/exports/include/azul/${component_name}/export.hpp DESTINATION include/azul/${component_name}/)
endfunction()

repository: MichaEiler/libazul

repo_name: MichaEiler/libazul

extension: cmake


text:
package daos

import (
	"errors"
	"time"

	"github.com/gofreta/gofreta-api/app"
	"github.com/gofreta/gofreta-api/models"

	"github.com/globalsign/mgo"
	"github.com/globalsign/mgo/bson"
)

// UserDAO gets and persists user data in database.
type UserDAO struct {
	Session    *mgo.Session
	Collection string
}

// ensureIndexes makes sure that the required db indexes and constraints are set.
func (dao *UserDAO) ensureIndexes() {
	session := dao.Session.Copy()
	defer session.Close()

	c := session.DB("").C(dao.Collection)

	emailIndex := mgo.Index{
		Key:        []string{"email"},
		Unique:     true,
		DropDups:   true,
		Background: true,
		Sparse:     true,
	}

	if err := c.EnsureIndex(emailIndex); err != nil {
		panic(err)
	}

	usernameIndex := mgo.Index{
		Key:        []string{"username"},
		Unique:     true,
		DropDups:   true,
		Background: true,
		Sparse:     true,
	}

	if err := c.EnsureIndex(usernameIndex); err != nil {
		panic(err)
	}
}

// NewUserDAO creates a new UserDAO.
func NewUserDAO(session *mgo.Session) *UserDAO {
	dao := &UserDAO{
		Session:    session,
		Collection: "user",
	}

	dao.ensureIndexes()

	return dao
}

// -------------------------------------------------------------------
// • Query methods
// -------------------------------------------------------------------

// Count returns the total number of user models based on the provided conditions.
func (dao *UserDAO) Count(conditions bson.M) (int, error) {
	session := dao.Session.Copy()
	defer session.Close()

	result, err := session.DB("").C(dao.Collection).
		Find(conditions).
		Count()

	return result, err
}

// GetList returns list with user models.
func (dao *UserDAO) GetList(limit int, offset int, conditions bson.M, sortData []string) ([]models.User, error) {
	session := dao.Session.Copy()
	defer session.Close()

	users := []models.User{}

	// for case insensitive sort
	collation := &mgo.Collation{
		Locale:   "en",
		Strength: 2,
	}

	err := session.DB("").C(dao.Collection).
		Find(conditions).
		Collation(collation).
		Sort(sortData...).
		Skip(offset).
		Limit(limit).
		All(&users)

	return users, err
}

// GetOne returns single user model based on the provided conditions.
func (dao *UserDAO) GetOne(conditions bson.M) (*models.User, error) {
	session := dao.Session.Copy()
	defer session.Close()

	user := &models.User{}

	err := session.DB("").C(dao.Collection).
		Find(conditions).
		One(user)

	return user, err
}

// GetByEmail returns single active user model by its email.
func (dao *UserDAO) GetByEmail(email string, additionalConditions ...bson.M) (*models.User, error) {
	conditions := bson.M{}
	if len(additionalConditions) > 0 && additionalConditions[0] != nil {
		conditions = additionalConditions[0]
	}
	conditions["email"] = email

	return dao.GetOne(conditions)
}

// GetByUsername returns single active user model by its username.
func (dao *UserDAO) GetByUsername(username string, additionalConditions ...bson.M) (*models.User, error) {
	conditions := bson.M{}
	if len(additionalConditions) > 0 && additionalConditions[0] != nil {
		conditions = additionalConditions[0]
	}
	conditions["username"] = username

	return dao.GetOne(conditions)
}

// GetByID returns single user model by its id.
func (dao *UserDAO) GetByID(id string, additionalConditions ...bson.M) (*models.User, error) {
	if !bson.IsObjectIdHex(id) {
		err := errors.New("Invalid object id format")

		return &models.User{}, err
	}

	conditions := bson.M{}
	if len(additionalConditions) > 0 && additionalConditions[0] != nil {
		conditions = additionalConditions[0]
	}
	conditions["_id"] = bson.ObjectIdHex(id)

	return dao.GetOne(conditions)
}

// Authenticate validates and returns active user model.
func (dao *UserDAO) Authenticate(username, password string) (*models.User, error) {
	user, err := dao.GetByUsername(username, bson.M{"status": models.UserStatusActive})
	if err != nil {
		return nil, err
	}

	if user.ValidatePassword(password) {
		return user, nil
	}

	return nil, errors.New("Invalid username or password.")
}

// -------------------------------------------------------------------
// • DB persists methods
// -------------------------------------------------------------------

// Create inserts and returns a new user model.
func (dao *UserDAO) Create(form *models.UserCreateForm) (*models.User, error) {
	session := dao.Session.Copy()
	defer session.Close()

	// validate
	validateErr := form.Validate()
	if validateErr != nil {
		return &models.User{}, validateErr
	}

	user := form.ResolveModel()

	// db write
	dbErr := session.DB("").C(dao.Collection).Insert(user)

	return user, dbErr
}

// Update updates and returns existing user model.
func (dao *UserDAO) Update(form *models.UserUpdateForm) (*models.User, error) {
	session := dao.Session.Copy()
	defer session.Close()

	// validate
	validateErr := form.Validate()
	if validateErr != nil {
		return &models.User{}, validateErr
	}

	model := form.ResolveModel()

	// db write
	dbErr := session.DB("").C(dao.Collection).UpdateId(model.ID, model)

	return model, dbErr
}

// ResetPassword resets and changes user's password.
func (dao *UserDAO) ResetPassword(form *models.UserResetPasswordForm) (*models.User, error) {
	session := dao.Session.Copy()
	defer session.Close()

	// validate
	validateErr := form.Validate()
	if validateErr != nil {
		return &models.User{}, validateErr
	}

	model := form.ResolveModel()

	// db write
	dbErr := session.DB("").C(dao.Collection).UpdateId(model.ID, model)

	return model, dbErr
}

// RenewResetPasswordHash renews user reset password hash string.
func (dao *UserDAO) RenewResetPasswordHash(model *models.User) (*models.User, error) {
	session := dao.Session.Copy()
	defer session.Close()

	exp := time.Now().Add(time.Hour * time.Duration(app.Config.GetInt64("resetPassword.expire"))).Unix()

	model.SetResetPasswordHash(exp)

	model.Modified = time.Now().Unix()

	// db write
	dbErr := session.DB("").C(dao.Collection).UpdateId(model.ID, model)

	return model, dbErr
}

// Delete deletes the provided user model.
func (dao *UserDAO) Delete(model *models.User) error {
	session := dao.Session.Copy()
	defer session.Close()

	count, _ := dao.Count(nil)
	if count < 2 {
		return errors.New("You can't delete the only existing user.")
	}

	// db write
	err := session.DB("").C(dao.Collection).RemoveId(model.ID)

	return err
}

// SetAccessGroup sets new access group to all available users.
func (dao *UserDAO) SetAccessGroup(group string, actions ...string) error {
	session := dao.Session.Copy()
	defer session.Close()

	_, err := session.DB("").C(dao.Collection).
		UpdateAll(bson.M{}, bson.M{"$set": bson.M{"access." + group: actions}})

	return err
}

// UnsetAccessGroup unsets/removes access group from all available users.
func (dao *UserDAO) UnsetAccessGroup(group string) error {
	session := dao.Session.Copy()
	defer session.Close()

	_, err := session.DB("").C(dao.Collection).
		UpdateAll(bson.M{}, bson.M{"$unset": bson.M{"access." + group: 1}})

	return err
}

repository: gofreta/gofreta-api

repo_name: gofreta/gofreta-api


text:
@InProceedings{dasarathy16,
  supplementary = {Supplementary:dasarathy16-supp.pdf},
  title = {Active Learning Algorithms for Graphical Model Selection},
  author = {Dasarathy, Gautamd and Singh, Aarti and Balcan, Maria-Florina and Park, Jong H.},
  pages = {1356-1364},
  abstract = {The problem of learning the structure of a high dimensional graphical model from data has received considerable attention in recent years. In many applications such as sensor networks and proteomics  it is often expensive to obtain samples from all the variables involved simultaneously. For instance, this might involve the synchronization of a large number of sensors or the tagging of a large number of proteins.  To address this important issue, we initiate the study of a novel graphical model selection problem, where the goal is to optimize the total number of scalar samples obtained by allowing the collection of samples from only subsets of the variables. We propose a general paradigm for graphical model selection where feedback is used to guide the sampling to high degree vertices, while obtaining only few samples from the ones with the low degrees. We instantiate this framework with two specific active learning algorithms, one of which makes mild assumptions but is computationally expensive, while the other is computationally more efficient but requires stronger (nevertheless standard) assumptions. Whereas the sample complexity of passive algorithms is typically a function of the maximum degree of the graph, we show that the sample complexity of our algorithms is provably smaller and that it depends on a novel local complexity measure that is akin to the average degree of the graph. We finally demonstrate the efficacy of our framework via simulations.},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX


text:
# Find and sets up RobWorkSim.
#
#
#
#
#  ROBWORKSIM_INCLUDE_DIR - Where to find robwork include sub-directory.
#  ROBWORKSIM_LIBRARIES   - List of libraries when using RobWork (includes all libraries that RobWork depends on).
#  ROBWORKSIM_LIBRARY_DIRS - List of directories where libraries of RobWork are located.
#  ROBWORKSIM_FOUND       - True if RobWork was found. (not impl yet)
#
#  RWSIM_ROOT             - If set this defines the root of ROBWORKSIM if not set then it
#                              if possible be autodetected.
#
#
#

# Allow the syntax else (), endif (), etc.
SET(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS 1)

# Check if RWstudio_ROOT path are setup correctly
FIND_FILE(ROBWORKSIM_FOUND RobWorkSimSetup.cmake ${RWSIM_ROOT}/cmake NO_DEFAULT_PATH)
IF(NOT ROBWORKSIM_FOUND)
 MESSAGE(SEND_ERROR "RobWorkSim: Path to RobWorkSim root (RWSIM_ROOT) is incorrectly setup! \nRWSIM_ROOT == ${RWSIM_ROOT}")
ENDIF()
MESSAGE(STATUS "RobWorkSim: ROOT dir: ${RWSIM_ROOT}")

#
# Setup the default include and library dirs for RobWorkSim
#
#INCLUDE("${RWSIM_ROOT}/build/RobWorkSimBuildConfig${CMAKE_BUILD_TYPE}.cmake")

 ####################################################################
# DEPENDENCIES - REQUIRED
# Check for all dependencies, this adds LIBRARY_DIRS and include dirs that
# the configuration depends on
#

#Include default settings for constructing a robwork dependent project
#SET(ROBWORK_ROOT ${RW_ROOT})
#SET(CMAKE_MODULE_PATH ${RW_ROOT}/build ${CMAKE_MODULE_PATH})
#SET(RobWork_DIR ${RW_ROOT}/cmake)
#FIND_PACKAGE(RobWork REQUIRED)

#STRING(COMPARE EQUAL "${ROBWORKSIM_VERSION}" "${ROBWORK_VERSION}" COMPATIBLE_VERSION)
#IF( NOT COMPATIBLE_VERSION )
#    MESSAGE(SEND_ERROR "RobWorkSim: Version of RobWork ${ROBWORK_VERSION} is incompatible with version of RobWorkSim ${ROBWORKSIM_VERSION}")
#ENDIF()

#And for the qtgui stuff
#SET(ROBWORKSTUDIO_ROOT ${RWS_ROOT})
#SET(RWSTUDIO_ROOT ${RWS_ROOT})

#SET(CMAKE_MODULE_PATH ${RWS_ROOT}/cmake ${CMAKE_MODULE_PATH})
#FIND_PACKAGE(RobWorkStudio REQUIRED)

#STRING(COMPARE EQUAL "${ROBWORKSTUDIO_VERSION}" "${ROBWORKSIM_VERSION}" COMPATIBLE_VERSION)
#IF( NOT COMPATIBLE_VERSION )
#    MESSAGE(SEND_ERROR "RobWorkSim: Version of RobWorkStudio ${ROBWORKSTUDIO_VERSION} is incompatible with version of RobWorkSim ${ROBWORKSIM_VERSION}")
#ENDIF()

 ####################################################################
# DEPENDENCIES - OPTIONAL
# these dependencies are optional, which is the user can switch off
# modules

# optional compilation of sandbox
IF (RWSIM_BUILD_SANDBOX)
    MESSAGE(STATUS "RobWorkSim: Sandbox ENABLED!")
    SET(SANDBOX_LIB "rwsim_sandbox")
    SET(RWSIM_HAVE_SANDBOX true)
ELSE ()
    MESSAGE(STATUS "RobWorkSim: Sandbox DISABLED!")
    SET(RWSIM_HAVE_SANDBOX false)
ENDIF ()

# Check if SWIG is available
IF(RW_BUILD_WITH_SWIG AND NOT DEFINED SWIG_EXECUTABLE)
    SET(SWIG_EXECUTABLE ${RW_BUILD_WITH_SWIG_CMD})
ENDIF()
FIND_PACKAGE(SWIG 1.3 QUIET)
IF(SWIG_FOUND)
    MESSAGE(STATUS "RobWorkSim: SWIG ${SWIG_VERSION} found!")
ELSE()
    MESSAGE(STATUS "RobWorkSim: SWIG not found!")
ENDIF()

INCLUDE(CMakeDependentOption)
# optional compilation of sandbox
SET(RWSIM_HAVE_LUA False)
CMAKE_DEPENDENT_OPTION(RWSIM_DISABLE_LUA "Set when you want to disable lua!" OFF "RW_BUILD_WITH_LUA" ON)
IF( NOT RWSIM_DISABLE_LUA )
    IF(NOT SWIG_FOUND)
        MESSAGE(STATUS "RobWorkSim: Lua DISABLED! - SWIG was not found!")
        SET(RWSIM_HAVE_LUA False)
    ELSEIF (RW_BUILD_WITH_LUA)
        MESSAGE(STATUS "RobWorkSim: Lua ENABLED!")
        SET(RWSIM_LUA "rwsim_lua")
        SET(RWSIM_HAVE_LUA True)
    ELSE ()
        MESSAGE(STATUS "RobWorkSim: Lua DISABLED! - RobWork is NOT compiled with Lua support! Set RWSIM_DISABLE_LUA=ON")
        SET(RWSIM_HAVE_LUA False)
    ENDIF ()
ELSE ()
    MESSAGE(STATUS "RobWorkSim: Lua DISABLED!")
ENDIF()
#MESSAGE(" ${RWSIM_DISABLE_LUA} and ${RW_BUILD_WITH_LUA} ")

# test if Bullet exists
SET(RWSIM_HAVE_BULLET False)
#OPTION(RWSIM_USE_BULLET "Set to ON if Bullet should be use. you may need to set BULLET_ROOT")
FIND_PACKAGE(Bullet QUIET)
IF(NOT DEFINED RWSIM_DISABLE_BULLET)
    SET(RWSIM_DISABLE_BULLET OFF)
ENDIF()
CMAKE_DEPENDENT_OPTION(RWSIM_DISABLE_BULLET "Set when you want to disable Bullet!" ${RWSIM_DISABLE_BULLET} "BULLET_FOUND" ON)
IF(NOT RWSIM_DISABLE_BULLET)
    FIND_PACKAGE(Bullet)
    IF(BULLET_FOUND)
    	SET(RWSIM_HAVE_BULLET TRUE)
    	#INCLUDE_DIRECTORIES( ${BULLET_INCLUDE_DIR} ${BULLET_ROOT}/Demos/)
    	SET(RWSIM_BULLET_LIBRARY rwsim_bullet ${BULLET_LIBRARIES})

        # BULLET_LIBRARIES
        MESSAGE(STATUS "RobWorkSim: Bullet enabled and found.")
        SET(RW_BULLET_INCLUDE_DIR ${BULLET_INCLUDE_DIR})
    ELSE()
        SET(RWSIM_HAVE_BULLET FALSE)
        MESSAGE(SEND_ERROR "RobWorkSim: Bullet enabled but not found. Please setup BULLET_ROOT." ${RWSIM_USE_BULLET})
    ENDIF()
ELSE()
    MESSAGE(STATUS "RobWorkSim: Bullet disabled.")
ENDIF()

# test if ODE exists
SET(RWSIM_HAVE_ODE False)
FIND_PACKAGE(ODE QUIET)
#MESSAGE("ODE_FOUND: ${ODE_FOUND} ")
CMAKE_DEPENDENT_OPTION(RWSIM_DISABLE_ODE "Set when you want to disable ODE!" OFF "${ODE_FOUND};${RW_BUILD_WITH_PQP}" ON)
#OPTION(RWSIM_USE_ODE "Set to ON if ODE should be use. you may need to set ODE_ROOT" ${RWSIM_USE_ODE})
IF(NOT RWSIM_DISABLE_ODE)
    FIND_PACKAGE(ODE)
    IF(ODE_FOUND)
    	IF (RW_BUILD_WITH_PQP)
    		SET(RWSIM_HAVE_ODE TRUE)
    		#INCLUDE_DIRECTORIES( ${ODE_INCLUDE_DIR} )
    		SET(RWSIM_ODE_LIBRARY rwsim_ode ${ODE_LIBRARIES})
    		# ODE_LIBRARIES
        	MESSAGE(STATUS "RobWorkSim: ODE enabled and found. Using ${ODE_BUILD_WITH}")
        	SET(RW_ODE_INCLUDE_DIR ${ODE_INCLUDE_DIR} )
    	ELSE()
        	SET(RWSIM_HAVE_ODE FALSE)
        	MESSAGE(SEND_ERROR "RobWorkSim: ODE enabled but RobWork was not build with PQP. Please compile RobWork with PQP support.")
    	ENDIF()
    ELSE()
        SET(RWSIM_HAVE_ODE FALSE)
        MESSAGE(SEND_ERROR "RobWorkSim: ODE enabled but not found. Please setup ODE_ROOT.")
    ENDIF()
ELSE()
    MESSAGE(STATUS "RobWorkSim: ODE disabled.")
ENDIF()

SET(RWSIM_HAVE_RWPE False)
OPTION(RWSIM_DISABLE_RWPE "Set when you want to disable RobWorkPhysicsEngine!" OFF)
IF(NOT RWSIM_DISABLE_RWPE)
	SET(RWSIM_HAVE_RWPE TRUE)
	SET(RWSIM_RWPE_LIBRARY rwsim_rwpe)
    MESSAGE(STATUS "RobWorkSim: RobWorkPhysicsEngine enabled.")
ENDIF()

SET(RWSIM_HAVE_RWPHYS False)
OPTION(RWSIM_DISABLE_RWPHYS "Set when you want to disable RWPhysics engine!" OFF)
IF(NOT RWSIM_DISABLE_RWPHYS)
	SET(RWSIM_HAVE_RWPHYS TRUE)
    MESSAGE(STATUS "RobWorkSim: RWPhysics enabled.")
ENDIF()

# Add additional packages that are required by your project here
IF( USE_OPENCV AND DEFINED OpenCV_ROOT_DIR)
    SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ROOT}/cmake/Modules)

    SET(OpenCV_FIND_REQUIRED_COMPONENTS CV CXCORE HIGHGUI)
    FIND_PACKAGE( OpenCV REQUIRED "CV CXCORE HIGHGUI")
    INCLUDE_DIRECTORIES( ${OPENCV_INCLUDE_DIR} )
    MESSAGE(STATUS "RobWorkSim: USING OPENCV")
ENDIF()

#######################################################################
# COMPILER FLAGS AND MACRO SETUP
#

#
# Set extra compiler flags. The user should be able to change this.
# The compiler flags from RobWork are automatically set
#
IF(NOT DEFINED RWSIM_CXX_FLAGS)
	SET(RWSIM_CXX_FLAGS "${RW_BUILD_WITH_CXX_FLAGS} ${RWSIM_CXX_FLAGS_TMP}"
		CACHE STRING "Change this to force using your own flags and not those of RobWorkSim"
	)
ENDIF()
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${RWSIM_CXX_FLAGS}")
MESSAGE(STATUS "RobWorkSim: Adding RWSIM CXX flags: ${RWSIM_CXX_FLAGS}")

#
# Set extra linker flags. The user should be able to change this.
# The linker flags from RobWork are automatically set.
#
IF(DEFINED RWSIM_LINKER_FLAGS)
	SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${RWSIM_LINKER_FLAGS}" CACHE STRING "" FORCE)
	IF(WIN32)
		SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${RWSIM_LINKER_FLAGS}" CACHE STRING "" FORCE)
	ENDIF()

	MESSAGE(STATUS "RobWorkSim: Adding RWSIM linker flags: ${RWSIM_LINKER_FLAGS}")
ENDIF()

###########################################################################
# SETTING UP VARS
# here we setup the output variables
#

# Setup RobWorkSim include and link directories
#
# The include dirs
#
SET(ROBWORKSIM_INCLUDE_DIRS
    ${RWSIM_ROOT}/src
    ${ROBWORK_INCLUDE_DIRS}
    ${RW_ODE_INCLUDE_DIR}
    ${RW_BULLET_INCLUDE_DIR}
)
SET(ROBWORKSIM_INCLUDE_DIR "${ROBWORKSIM_INCLUDE_DIRS}")
#
# The library dirs
#
SET(ROBWORKSIM_LIBRARY_DIRS
    ${Boost_LIBRARY_DIRS}
    ${RWSIM_CMAKE_LIBRARY_OUTPUT_DIRECTORY}
    ${RWSIM_LIBRARY_OUT_DIR}
    ${RWSIM_ARCHIVE_OUT_DIR}
    ${ROBWORK_LIBRARY_DIRS}
)

#
# Setup the Library List here. We need to make sure the correct order is maintained
# which is crucial for some compilers.
#
SET(ROBWORKSIM_LIBRARIES
  ${RWS_SANDBOX}
  ${RWSIM_BULLET_LIBRARY}
  rwsim
  ${RWSIM_ODE_LIBRARY}
  rwsim
  ${ROBWORK_LIBRARIES}
)

repository: skyellen/robwork-mirror

repo_name: skyellen/robwork-mirror


text:
UBOOT_VERSION = "v2017.01"
XILINX_RELEASE_VERSION = "v2017.3"
SRCREV ?= "da811c4511ef9caeb95f9a22fe49d38bd8e56ded"

include u-boot-xlnx.inc
include u-boot-spl-zynq-init.inc

SRC_URI_append = " \
		file://arm64-zynqmp-Setup-partid-for-QEMU-to-match-silicon.patch \
		"

LICENSE = "GPLv2+"
LIC_FILES_CHKSUM = "file://README;beginline=1;endline=6;md5=157ab8408beab40cd8ce1dc69f702a6c"

# u-boot-xlnx has support for these
HAS_PLATFORM_INIT ?= " \
		zynq_microzed_config \
		zynq_zed_config \
		zynq_zc702_config \
		zynq_zc706_config \
		zynq_zybo_config \
		xilinx_zynqmp_zcu102_rev1_0_config \
		"

repository: sandeshghimire/xilinx-yocto

repo_name: sandeshghimire/xilinx-yocto

gha_language: Python


text:
package web

import (
	"fmt"
	"github.com/gorilla/websocket"
	"net/http"
	"testing"
)

func TestWeb_ListenAndAccept(t *testing.T) {
	http.HandleFunc("/", Hello)
	http.HandleFunc("/hel", Hello)
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		fmt.Println(err)
	}
}

func Hello(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("abc"))
}

func TestStr2Bit(t *testing.T) {
	str := "abc"
	fmt.Printf("%b\n", []byte(str))
	str = "1011100111011100011111111011110"
	fmt.Println(len(str))
}

func TestHttpFileServer(t *testing.T) {
	err := http.ListenAndServe(":8080", http.FileServer(http.Dir("static")))
	if err != nil {
		fmt.Println(err)
	}
}

func TestWebSocket(t *testing.T) {
	http.HandleFunc("/ws", handWS)
	http.ListenAndServe(":8080", nil)
}

func handWS(w http.ResponseWriter, r *http.Request) {
	upgrader := &websocket.Upgrader{
		CheckOrigin: func(r *http.Request) bool {
			return true
		},
	}
	wsConn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer wsConn.Close()

	for {
		mt, p, err := wsConn.ReadMessage()
		if err != nil {
			fmt.Println(err)
			return
		}
		fmt.Println("message type: ", mt)
		fmt.Println("data: ", p)
	}
}

func TestSlice(t *testing.T) {
	s1 := make([]int, 2)
	s1[0] = 11
	s1[1] = 22

	s2 := s1[:0]
	fmt.Println(s2)
	fmt.Println(s2 == nil)
	fmt.Println(len(s2))
	fmt.Println("--------------")

	var s3 []int
	fmt.Println(s3 == nil)
}

repository: jdxj/smtp

repo_name: jdxj/smtp


text:
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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 main

import (
	"fmt"
	"log"
	"os"
	"time"

	"github.com/golang/protobuf/proto"
	"github.com/ouqiang/canal-go/client"
	protocol "github.com/ouqiang/canal-go/protocol"
)

func main() {

	// 192.168.199.17 替换成你的canal server的地址
	// example 替换成-e canal.destinations=example 你自己定义的名字
	connector := client.NewSimpleCanalConnector("192.168.199.17", 11111, "", "", "example", 60000, 60*60*1000)
	err := connector.Connect()
	if err != nil {
		log.Println(err)
		os.Exit(1)
	}

	// https://github.com/alibaba/canal/wiki/AdminGuide
	//mysql 数据解析关注的表，Perl正则表达式.
	//
	//多个正则之间以逗号(,)分隔，转义符需要双斜杠(\\)
	//
	//常见例子：
	//
	//  1.  所有表：.*   or  .*\\..*
	//	2.  canal schema下所有表： canal\\..*
	//	3.  canal下的以canal打头的表：canal\\.canal.*
	//	4.  canal schema下的一张表：canal\\.test1
	//  5.  多个规则组合使用：canal\\..*,mysql.test1,mysql.test2 (逗号分隔)

	err = connector.Subscribe(".*\\..*")
	if err != nil {
		log.Println(err)
		os.Exit(1)
	}

	for {

		message, err := connector.Get(100, nil, nil)
		if err != nil {
			log.Println(err)
			os.Exit(1)
		}
		batchId := message.Id
		if batchId == -1 || len(message.Entries) <= 0 {
			time.Sleep(300 * time.Millisecond)
			fmt.Println("===没有数据了===")
			continue
		}

		printEntry(message.Entries)

	}
}

func printEntry(entrys []protocol.Entry) {

	for _, entry := range entrys {
		if entry.GetEntryType() == protocol.EntryType_TRANSACTIONBEGIN || entry.GetEntryType() == protocol.EntryType_TRANSACTIONEND {
			continue
		}
		rowChange := new(protocol.RowChange)

		err := proto.Unmarshal(entry.GetStoreValue(), rowChange)
		checkError(err)
		if rowChange != nil {
			eventType := rowChange.GetEventType()
			header := entry.GetHeader()
			fmt.Println(fmt.Sprintf("================> binlog[%s : %d],name[%s,%s], eventType: %s", header.GetLogfileName(), header.GetLogfileOffset(), header.GetSchemaName(), header.GetTableName(), header.GetEventType()))

			for _, rowData := range rowChange.GetRowDatas() {
				if eventType == protocol.EventType_DELETE {
					printColumn(rowData.GetBeforeColumns())
				} else if eventType == protocol.EventType_INSERT {
					printColumn(rowData.GetAfterColumns())
				} else {
					fmt.Println("-------> before")
					printColumn(rowData.GetBeforeColumns())
					fmt.Println("-------> after")
					printColumn(rowData.GetAfterColumns())
				}
			}
		}
	}
}

func printColumn(columns []*protocol.Column) {
	for _, col := range columns {
		fmt.Println(fmt.Sprintf("%s : %s  update= %t", col.GetName(), col.GetValue(), col.GetUpdated()))
	}
}

func checkError(err error) {
	if err != nil {
		fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
		os.Exit(1)
	}
}

repository: ouqiang/canal-go

repo_name: ouqiang/canal-go


text:
SUMMARY = "cve-check-tool"
DESCRIPTION = "cve-check-tool is a tool for checking known (public) CVEs.\
The tool will identify potentially vunlnerable software packages within Linux distributions through version matching."
HOMEPAGE = "https://github.com/ikeydoherty/cve-check-tool"
SECTION = "Development/Tools"
LICENSE = "GPL-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=e8c1458438ead3c34974bc0be3a03ed6"

SRC_URI = "https://github.com/ikeydoherty/${BPN}/releases/download/v${PV}/${BP}.tar.xz \
    file://curl-allow-overriding-default-CA-certificate-file.patch \
    file://0001-Check-for-malloc_trim-before-using-it.patch \
"

SRC_URI[md5sum] = "c5f4247140fc9be3bf41491d31a34155"
SRC_URI[sha256sum] = "b8f283be718af8d31232ac1bfc10a0378fb958aaaa49af39168f8acf501e6a5b"

DEPENDS = "libcheck glib-2.0 json-glib curl libxml2 sqlite3 openssl ca-certificates"

inherit pkgconfig autotools

EXTRA_OECONF = "--disable-static --enable-relative-plugins"
CFLAGS += "-Wno-error=pedantic"

BBCLASSEXTEND = "native nativesdk"


text:
package config

import (
	"io"
	"io/ioutil"

	"github.com/ghodss/yaml"
	"github.com/pkg/errors"
)

// RunConfig ...
type RunConfig struct {
	StageConfigFile io.ReadCloser
	StageConfig     StageConfig
	RunSteps        map[string]map[string]bool
	OpenFile        func(s string, t map[string]string) (io.ReadCloser, error)
}

type StageConfig struct {
	Stages map[string]StepConditions `json:"stages,omitempty"`
}

type StepConditions struct {
	Conditions map[string]map[string]interface{} `json:"stepConditions,omitempty"`
}

// InitRunConfig ...
func (r *RunConfig) InitRunConfig(config *Config, filters map[string]StepFilters, parameters map[string][]StepParameters,
	secrets map[string][]StepSecrets, stepAliases map[string][]Alias, glob func(pattern string) (matches []string, err error),
	openFile func(s string, t map[string]string) (io.ReadCloser, error)) error {
	r.OpenFile = openFile
	r.RunSteps = map[string]map[string]bool{}

	if len(r.StageConfig.Stages) == 0 {
		if err := r.loadConditions(); err != nil {
			return errors.Wrap(err, "failed to load pipeline run conditions")
		}
	}

	err := r.evaluateConditions(config, filters, parameters, secrets, stepAliases, glob)
	if err != nil {
		return errors.Wrap(err, "failed to evaluate step conditions: %v")
	}

	return nil
}

// ToDo: optimize parameter handling
func (r *RunConfig) getStepConfig(config *Config, stageName, stepName string, filters map[string]StepFilters,
	parameters map[string][]StepParameters, secrets map[string][]StepSecrets, stepAliases map[string][]Alias) (StepConfig, error) {
	// no support for flag values and envParameters
	// so far not considered necessary

	flagValues := map[string]interface{}{} // args of step from pipeline_generated.yml

	envParameters := map[string]interface{}{}

	// parameters via paramJSON not supported
	// not considered releavant for pipeline yaml syntax resolution
	paramJSON := ""

	return config.GetStepConfig(flagValues, paramJSON, nil, nil, false, filters[stepName], parameters[stepName], secrets[stepName],
		envParameters, stageName, stepName, stepAliases[stepName])
}

func (r *RunConfig) loadConditions() error {
	defer r.StageConfigFile.Close()
	content, err := ioutil.ReadAll(r.StageConfigFile)
	if err != nil {
		return errors.Wrapf(err, "error: failed to read the stageConfig file")
	}

	err = yaml.Unmarshal(content, &r.StageConfig)
	if err != nil {
		return errors.Errorf("format of configuration is invalid %q: %v", content, err)
	}
	return nil
}

func stepConfigLookup(m map[string]interface{}, stepName, key string) interface{} {
	// flat map: key is on top level
	if m[key] != nil {
		return m[key]
	}
	// lookup for step config with following format
	// general:
	//   <key>: <value>
	// stages:
	//   <stepName>:
	//     <key>: <value>
	// steps:
	//   <stepName>:
	//     <key>: <value>
	if m["general"] != nil {
		general := m["general"].(map[string]interface{})
		if general[key] != nil {
			return general[key]
		}
	}
	if m["stages"] != nil {
		stages := m["stages"].(map[string]interface{})
		if stages[stepName] != nil {
			stageStepConfig := stages[stepName].(map[string]interface{})
			if stageStepConfig[key] != nil {
				return stageStepConfig[key]
			}
		}
	}
	if m["steps"] != nil {
		steps := m["steps"].(map[string]interface{})
		if steps[stepName] != nil {
			stepConfig := steps[stepName].(map[string]interface{})
			if stepConfig[key] != nil {
				return stepConfig[key]
			}
		}
	}
	return nil
}

repository: artembannikov/jenkins-library

repo_name: artembannikov/jenkins-library


text:
// Copyright 2021 Google LLC. All Rights Reserved.
//
// 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 core

import (
	"encoding/json"
	"io/ioutil"
	"os/exec"
	"path/filepath"

	"github.com/apigee/registry/rpc"
)

type SpectralLintResult struct {
	Code     string            `json:"code"`
	Path     []string          `json:"path"`
	Message  string            `json:"message"`
	Severity int32             `json:"severity"`
	Range    SpectralLintRange `json:"range"`
	Source   string            `json:"source"`
}

type SpectralLintRange struct {
	Start SpectralLintLocation `json:"start"`
	End   SpectralLintLocation `json:"end"`
}

type SpectralLintLocation struct {
	Line      int32 `json:"line"`
	Character int32 `json:"character"`
}

func lintFileForOpenAPIWithSpectral(path string, root string) (*rpc.LintFile, error) {
	cmd := exec.Command("spectral", "lint", path, "--f", "json", "--output", "spectral-lint.json")
	cmd.Dir = root
	// ignore errors from Spectral because Spectral returns an error result when APIs have errors.
	cmd.Run()
	b, err := ioutil.ReadFile(filepath.Join(root, "/spectral-lint.json"))
	if err != nil {
		return nil, err
	}
	var lintResults []*SpectralLintResult
	err = json.Unmarshal(b, &lintResults)
	if err != nil {
		return nil, err
	}
	problems := make([]*rpc.LintProblem, 0)
	for _, result := range lintResults {
		problem := &rpc.LintProblem{
			Message:    result.Message,
			RuleId:     result.Code,
			RuleDocUri: "https://meta.stoplight.io/docs/spectral/docs/reference/openapi-rules.md#" + result.Code,
			Location: &rpc.LintLocation{
				StartPosition: &rpc.LintPosition{
					LineNumber:   result.Range.Start.Line + 1,
					ColumnNumber: result.Range.Start.Character + 1,
				},
				EndPosition: &rpc.LintPosition{
					LineNumber:   result.Range.End.Line + 1,
					ColumnNumber: result.Range.End.Character,
				},
			},
		}
		problems = append(problems, problem)
	}
	result := &rpc.LintFile{Problems: problems}
	return result, nil
}

repository: Jamaalbwells/registry

repo_name: Jamaalbwells/registry

branch_name: refs/heads/main

gha_language: JavaScript


text:
@inproceedings{doan2018online,
 author = {Doan, Thang and Monteiro, Joao and Albuquerque, Isabela and Mazoure, Bogdan and Durand, Audrey and Pineau, Joelle and Hjelm, R Devon},
 booktitle = {Association for the Advancement of Artificial Intelligence (to appear)},
 title = {Online Adaptative Curriculum Learning for GANs},
 url = {https://arxiv.org/abs/1808.00020},
 year = {2019}
}


text:
@article{DBLP:journals/corr/abs-1802-08091,
  author    = {Miao Wang and
               Guo{-}Ye Yang and
               Jin{-}Kun Lin and
               Ariel Shamir and
               Song{-}Hai Zhang and
               Shao{-}Ping Lu and
               Shi{-}Min Hu},
  title     = {Deep Online Video Stabilization},
  journal   = {CoRR},
  volume    = {abs/1802.08091},
  year      = {2018},
  url       = {http://arxiv.org/abs/1802.08091},
  archivePrefix = {arXiv},
  eprint    = {1802.08091},
  timestamp = {Wed, 28 Mar 2018 12:42:11 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/abs-1802-08091},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@ARTICLE {alanc.brooks2003,
    author = "Alan  C.  Brooks",
    title  = "Real-T ime Digital Image Stabilization",
    year   = "2003",
    note   = "EE 420 Image Processing Computer Project Final Paper"
}

@misc{BibEntry2018Aug,
	title = {{Fused Video Stabilization on the Pixel 2 and Pixel 2 XL}},
	journal = {Google AI Blog},
	year = {2018},
	month = {Aug},
	note = {[Online; accessed 11. Aug. 2018]},
	url = {https://ai.googleblog.com/2017/11/fused-video-stabilization-on-pixel-2.html}
}

@INPROCEEDINGS{797671,
author={A. Censi and A. Fusiello and V. Roberto},
booktitle={Proceedings 10th International Conference on Image Analysis and Processing},
title={Image stabilization by features tracking},
year={1999},
volume={},
number={},
pages={665-667},
keywords={motion compensation;image sequences;video signal processing;tracking;stability;feature extraction;feature tracking;image stabilization;video sequences;warping;camera motion;robust technique;homographies;motion compensation;mosaic images;RMS error;computational cost;frame rate;real-time implementation;Cameras;Layout;Motion compensation;Machine vision;Laboratories;Mathematics;Informatics;Video sequences;Read only memory;Computational efficiency},
doi={10.1109/ICIAP.1999.797671},
ISSN={},
month={Sept},}

@unknown{blockTang,
author = {Tang, Chongwu and Yang, Xiaokang and Chen, Li and Zhai, Guangtao},
year = {2011},
month = {10},
pages = {1-5},
title = {A fast video stabilization algorithm based on block matching and edge completion},
booktitle = {MMSP 2011 - IEEE International Workshop on Multimedia Signal Processing}
}
@INPROCEEDINGS{7115639,
author={M. Garrigues and A. Manzanera},
booktitle={Proceedings of the 2014 Conference on Design and Architectures for Signal and Image Processing},
title={Video++, a modern image and video processing C++ framework},
year={2014},
volume={},
number={},
pages={1-6},
keywords={C++ language;program compilers;software libraries;video signal processing;Video++ framework;image processing;video processing;C++ framework;image applications;video applications;multicore processors;code generation;C++11 features;code optimization;C++14 features;Libraries;Image processing;Kernel;Containers;Streaming media;Standards;Benchmark testing},
doi={10.1109/DASIP.2014.7115639},
ISSN={},
month={Oct},}

@misc{OpenCVMe72:online,
author = {OpenCV},
title = {Meanshift and Camshift},
howpublished = {\url{https://docs.opencv.org/3.4/db/df8/tutorial_py_meanshift.html}},
month = {},
year = {},
note = {(Accessed on 10/12/2018)}
}

@misc{OpenCVcv11:online,
author = {OpenCV},
title = {cv::Mat Class Reference},
howpublished = {\url{https://docs.opencv.org/3.1.0/d3/d63/classcv_1_1Mat.html}},
month = {},
year = {},
note = {(Accessed on 10/12/2018)}
}
@misc{OpenCVcv94:online,
author = {OpenCV},
title = {cv::RotatedRect Class Reference},
howpublished = {\url{https://docs.opencv.org/3.4/db/dd6/classcv_1_1RotatedRect.html}},
month = {},
year = {},
note = {(Accessed on 10/12/2018)}
}

@MISC{Bradski98computervision,
    author = {Gary R. Bradski},
    title = {Computer Vision Face Tracking For Use in a Perceptual User Interface},
    year = {1998}
}

@misc{OpenCVme45:online,
author = {Eric Yuan},
title = {OpenCV, meanShift, camShift},
howpublished = {\url{http://eric-yuan.me/continuously-adaptive-shift/}},
month = {September},
year = {2013},
note = {(Accessed on 10/12/2018)}
}

@misc{matt42vp0:online,
author = {Matthieu Garrigues},
title = {matt-42/vpp: Video++, a C++14 high performance video and image processing library.},
howpublished = {\url{https://github.com/matt-42/vpp}},
month = {},
year = {},
note = {(Accessed on 10/12/2018)}
}

repository: MariusHerget/cimarron

repo_name: MariusHerget/cimarron


text:
package qtypes

import (
	"testing"
	"github.com/stretchr/testify/assert"
	"github.com/zpatrick/go-config"
)

func TestPlugin_CfgString(t *testing.T) {
	cfgMap := map[string]string{
		"testTyp.testName.database": "qframe",
	}
	cfg := config.NewConfig(
		[]config.Provider{
			config.NewStatic(cfgMap),
		},
	)
	p := NewNamedPlugin(NewQChan(), cfg, "testTyp", "testPkg", "testName", "0.0.0")
	got, err := p.CfgString("database")
	assert.NoError(t, err)
	assert.Equal(t, "qframe", got)
	got = p.CfgStringOr("database", "alt")
	assert.Equal(t, "qframe", got)
	got = p.CfgStringOr("nil", "alt")
	assert.Equal(t, "alt", got)
}

func TestPlugin_CfgBool(t *testing.T) {
	cfgMap := map[string]string{
		"testTyp.testName.key": "true",
		"testTyp.testName.key2": "nil",
	}
	cfg := config.NewConfig(
		[]config.Provider{
			config.NewStatic(cfgMap),
		},
	)
	p := NewNamedPlugin(NewQChan(), cfg, "testTyp", "testPkg", "testName", "0.0.0")
	got, err := p.CfgBool("key")
	assert.NoError(t, err)
	assert.True(t, got)
	got = p.CfgBoolOr("key", false)
	assert.True(t, got)
	got = p.CfgBoolOr("nil", false)
	assert.False(t, got)
	_, err = p.CfgBool("key2")
	assert.Error(t, err, "Should read 'nil'")

}

func TestPlugin_CfgInt(t *testing.T) {
	cfgMap := map[string]string{
		"testTyp.testName.key": "1",
	}
	cfg := config.NewConfig(
		[]config.Provider{
			config.NewStatic(cfgMap),
		},
	)
	p := NewNamedPlugin(NewQChan(), cfg, "testTyp", "testPkg", "testName", "0.0.0")
	got, err := p.CfgInt("key")
	assert.NoError(t, err)
	assert.Equal(t, 1, got)
	got = p.CfgIntOr("key", 2)
	assert.Equal(t, 1, got)
	got = p.CfgIntOr("nil", 2)
	assert.Equal(t, 2, got)
}

func TestPlugin_GetInputs(t *testing.T) {
	cfg := config.NewConfig([]config.Provider{})
	p := NewNamedPlugin(NewQChan(), cfg, "testTyp", "testPkg", "testName", "0.0.0")
	assert.Equal(t, 0, len(p.GetInputs()))
	cfg = config.NewConfig([]config.Provider{config.NewStatic(map[string]string{
		"testTyp.testName.inputs": "test",
	})})
	p = NewNamedPlugin(NewQChan(), cfg, "testTyp", "testPkg", "testName", "0.0.0")
	assert.Equal(t, 1, len(p.GetInputs()))
}

repository: qnib/qframe-types

repo_name: qnib/qframe-types


text:
#
# mkfontscale_debian.bb
#
require xorg-app-common.inc

SUMMARY = "A program to create an index of scalable font files for X"

DESCRIPTION = "For each directory argument, mkfontscale reads all of the \
scalable font files in the directory. For every font file found, an X11 \
font name (XLFD) is generated, and is written together with the file \
name to a file fonts.scale in the directory.  The resulting fonts.scale \
is used by the mkfontdir program."

DEPENDS = "util-macros-native zlib libfontenc freetype xproto"

BBCLASSEXTEND = "native"

LIC_FILES_CHKSUM = "file://COPYING;md5=2e0d129d05305176d1a790e0ac1acb7f"

SRC_URI[md5sum] = "03de3f15db678e277f5ef9c013aca1ad"
SRC_URI[sha256sum] = "244017992477ced2397a44fd0ddcfb0f1d9899128613f5c4db81471163b0b731"

#
# debian
#
inherit debian-package
DEBIAN_SECTION = "x11"
DPR = "0"
DPN = "xfonts-utils"

# There is no debian patch
DEBIAN_PATCH_TYPE = "nopatch"

S = "${DEBIAN_UNPACK_DIR}/mkfontscale"

repository: takuya-t/meta-debian

repo_name: takuya-t/meta-debian

branch_name: refs/heads/daisy


text:
@article{Wang_2019_dec,
 author = {Xiangfeng Wang and Tonglin Mao},
 doi = {10.1016/j.pbi.2019.08.002},
 journal = {Current Opinion in Plant Biology},
 month = {dec},
 pages = {86--96},
 publisher = {Elsevier BV},
 title = {Understanding the functions and mechanisms of plant cytoskeleton in response to environmental signals},
 url = {https://doi.org/10.1016%2Fj.pbi.2019.08.002},
 volume = {52},
 year = {2019}
}

repository: wanglab-cau/CrazyHsu

repo_name: wanglab-cau/CrazyHsu


text:
package action

import (
	"context"
	"fmt"
	"os"
	"path"
	"path/filepath"
	"regexp"
	"strconv"
	"sync"
	"time"

	"github.com/rockbears/log"
	"github.com/spf13/afero"

	"github.com/ovh/cds/engine/worker/internal/plugin"
	"github.com/ovh/cds/engine/worker/pkg/workerruntime"
	"github.com/ovh/cds/sdk"
)

func RunArtifactDownload(ctx context.Context, wk workerruntime.Runtime, a sdk.Action, _ []sdk.Variable) (sdk.Result, error) {
	res := sdk.Result{Status: sdk.StatusSuccess}

	project := sdk.ParameterValue(wk.Parameters(), "cds.project")
	workflow := sdk.ParameterValue(wk.Parameters(), "cds.workflow")
	number := sdk.ParameterValue(wk.Parameters(), "cds.run.number")
	pattern := sdk.ParameterValue(a.Parameters, "pattern")

	destPath := sdk.ParameterValue(a.Parameters, "path")

	actionWorkflow := sdk.ParameterValue(a.Parameters, "workflow")
	actionRunNumber := sdk.ParameterValue(a.Parameters, "number")

	destinationWorkflow := workflow
	if actionWorkflow != "" {
		destinationWorkflow = actionWorkflow
	}
	destinationWorkflowNum := number
	if actionRunNumber != "0" && actionRunNumber != "" {
		destinationWorkflowNum = actionRunNumber
	}

	if destPath == "" {
		destPath = "."
	}
	workdir, err := workerruntime.WorkingDirectory(ctx)
	if err != nil {
		res.Status = sdk.StatusFail
		return res, err
	}

	var abs string
	if x, ok := wk.BaseDir().(*afero.BasePathFs); ok {
		abs, _ = x.RealPath(workdir.Name())
	} else {
		abs = workdir.Name()
	}

	if !sdk.PathIsAbs(destPath) {
		destPath = filepath.Join(abs, destPath)
	}

	wkDirFS := afero.NewOsFs()
	if err := wkDirFS.MkdirAll(destPath, os.FileMode(0744)); err != nil {
		res.Status = sdk.StatusFail
		return res, fmt.Errorf("unable to create %s: %v", destPath, err)
	}

	wk.SendLog(ctx, workerruntime.LevelInfo, fmt.Sprintf("Downloading artifacts from workflow into '%s'...", destPath))

	n, err := strconv.ParseInt(destinationWorkflowNum, 10, 64)
	if err != nil {
		res.Status = sdk.StatusFail
		return res, fmt.Errorf("cds.run.number variable is not valid. aborting")
	}

	reg, err := regexp.Compile(pattern)
	if err != nil {
		res.Status = sdk.StatusFail
		res.Reason = fmt.Sprintf("Invalid pattern %s, must be a regex : %v", pattern, err)
		wk.SendLog(ctx, workerruntime.LevelInfo, res.Reason)
		return res, err
	}

	// Priority:
	// 1. Integration artifact manager on workflow
	// 2. CDN
	if wk.GetIntegrationPlugin(sdk.GRPCPluginDownloadArtifact) != nil {
		return GetArtifactFromIntegrationPlugin(ctx, wk, res, pattern, reg, destPath, sdk.GRPCPluginDownloadArtifact, project, destinationWorkflow, n)
	}
	wk.SendLog(ctx, workerruntime.LevelInfo, fmt.Sprintf("CDN '%s'...", destPath))

	// GET Artifact from CDS CDN
	cdnItems, err := wk.Client().WorkflowRunArtifactsLinks(project, destinationWorkflow, n)
	if err != nil {
		res.Status = sdk.StatusFail
		return res, err
	}

	wg := new(sync.WaitGroup)
	wg.Add(len(cdnItems.Items))
	for i := range cdnItems.Items {
		item := cdnItems.Items[i]
		apiRef, is := item.GetCDNRunResultApiRef()
		if !is {
			res.Status = sdk.StatusFail
			res.Reason = fmt.Sprintf("item %s is not an artifact", item.ID)
			return res, sdk.WrapError(sdk.ErrInvalidData, "item %s is not an artifact", item.ID)
		}
		if pattern != "" && !reg.MatchString(apiRef.ToFilename()) {
			wk.SendLog(ctx, workerruntime.LevelInfo, fmt.Sprintf("%s does not match pattern %s - skipped", a.Name, pattern))
			wg.Done()
			continue
		}

		go func(a sdk.CDNItem) {
			defer wg.Done()
			destFile := path.Join(destPath, a.APIRef.ToFilename())
			wk.SendLog(ctx, workerruntime.LevelInfo, fmt.Sprintf("Downloading artifact %s from workflow %s/%s on run %d...", destFile, project, destinationWorkflow, n))

			f, err := os.OpenFile(destFile, os.O_RDWR|os.O_CREATE|os.O_TRUNC, os.FileMode(apiRef.Perm))
			if err != nil {
				res.Status = sdk.StatusFail
				res.Reason = sdk.NewError(sdk.ErrUnknownError, fmt.Errorf("cannot create file (OpenFile) %s: %s", destFile, err)).Error()
				log.Warn(ctx, "%s", res.Reason)
				wk.SendLog(ctx, workerruntime.LevelError, res.Reason)
				return
			}
			if err := wk.Client().CDNItemDownload(ctx, wk.CDNHttpURL(), item.APIRefHash, sdk.CDNTypeItemRunResult, a.MD5, f); err != nil {
				_ = f.Close()
				res.Status = sdk.StatusFail
				res.Reason = err.Error()
				log.Warn(ctx, "Cannot download artifact %s: %s", destFile, err)
				wk.SendLog(ctx, workerruntime.LevelError, res.Reason)
				return
			}
			if err := f.Close(); err != nil {
				res.Status = sdk.StatusFail
				res.Reason = sdk.NewErrorFrom(sdk.ErrUnknownError, "unable to close file %s: %v", destFile, err).Error()
				log.Warn(ctx, "%s", res.Reason)
				wk.SendLog(ctx, workerruntime.LevelError, res.Reason)
				return
			}
		}(item)
	}
	wg.Wait()
	return res, nil
}

func GetArtifactFromIntegrationPlugin(ctx context.Context, wk workerruntime.Runtime, res sdk.Result, pattern string, regexp *regexp.Regexp, destPath string, pluginName string, key, wkfName string, number int64) (sdk.Result, error) {
	pfName := sdk.ParameterFind(wk.Parameters(), "cds.integration.artifact_manager")
	if pfName == nil {
		return res, sdk.NewErrorFrom(sdk.ErrNotFound, "unable to retrieve artifact manager integration... Aborting")
	}

	wg := new(sync.WaitGroup)
	runResults, err := wk.Client().WorkflowRunResultsList(ctx, key, wkfName, number)
	if err != nil {
		return res, err
	}

	wg.Add(len(runResults))
	for _, runResult := range runResults {
		if runResult.Type != sdk.WorkflowRunResultTypeArtifactManager {
			wg.Done()
			continue
		}

		artData, err := runResult.GetArtifactManager()
		if err != nil {
			wk.SendLog(ctx, workerruntime.LevelInfo, "Can read run result data: "+err.Error())
			wg.Done()
			continue
		}
		opts := sdk.ParametersToMap(wk.Parameters())
		repoName := opts[fmt.Sprintf("cds.integration.artifact_manager.%s", sdk.ArtifactoryConfigCdsRepository)]
		if repoName != artData.RepoName {
			wk.SendLog(ctx, workerruntime.LevelDebug, fmt.Sprintf("%s does not match configured repo name %s - skipped", repoName, artData.RepoName))
			wg.Done()
			continue
		}

		if pattern != "" && !regexp.MatchString(artData.Name) {
			wk.SendLog(ctx, workerruntime.LevelDebug, fmt.Sprintf("%s does not match pattern %s - skipped", artData.Name, pattern))
			wg.Done()
			continue
		}
		destFile := path.Join(destPath, artData.Name)
		opts[sdk.ArtifactDownloadPluginInputDestinationPath] = destFile
		opts[sdk.ArtifactDownloadPluginInputFilePath] = artData.Path
		opts[sdk.ArtifactDownloadPluginInputMd5] = artData.MD5
		opts[sdk.ArtifactDownloadPluginInputPerm] = strconv.FormatUint(uint64(artData.Perm), 10)

		go func(opts map[string]string) {
			defer wg.Done()
			wk.SendLog(ctx, workerruntime.LevelInfo, fmt.Sprintf("Downloading artifact %s from %s...", artData.Name, repoName))
			resultPart := runGRPCIntegrationPlugin(ctx, wk, pluginName, opts)
			if resultPart.Status == sdk.StatusFail {
				res.Status = resultPart.Status
				res.Reason = resultPart.Reason
			}
		}(opts)
		// Be kind with the artifact manager
		if len(runResults) > 1 {
			time.Sleep(250 * time.Millisecond)
		}
	}
	wg.Wait()
	return res, nil
}

func runGRPCIntegrationPlugin(ctx context.Context, wk workerruntime.Runtime, pluginName string, opts map[string]string) sdk.Result {
	pluginClient, err := plugin.NewClient(ctx, wk, plugin.TypeIntegration, pluginName)
	if err != nil {
		return sdk.Result{
			Status: sdk.StatusFail,
			Reason: fmt.Sprintf("unable to start GRPCPlugin: %v", err),
		}
	}
	defer pluginClient.Close(ctx)
	pluginResult := pluginClient.Run(ctx, opts)
	return sdk.Result{Status: pluginResult.Status, Reason: pluginResult.Details}
}

repository: ovh/cds

repo_name: ovh/cds


text:
@book{authorname2011,
  author = "Author, First",
  year = 2011,
  title = "Book Title",
  address = "Every Town, CA",
  publisher = "Generic University Press",
}

repository: admb-project/admb

repo_name: admb-project/admb