text:
@article{BeliakovJames2011:citationjournalranks,
   author = {Beliakov, Gleb and James, Simon},
   journal = {Fuzzy Sets and Systems},
   pages = {101--119},
   title = {Citation-based journal ranks: {T}he use of fuzzy measures},
   volume = {167},
   year = {2011}
}

@article{Choquet1954:theorycapa,
   author = {Choquet, Gustave},
   journal = {Annales de l'institut {F}ourier},
   pages = {131--295},
   title = {Theory of capacities},
   volume = {5},
   year = {1954}
}

@book{DuboisPrade1980:fss,
   title = {Fuzzy sets and systems. {T}heory and applications},
   author = {Didier Dubois and Henri Prade},
   year = {1980},
   publisher = {Academic Press},
   address = {New York}
}

@article{EvenLehrer2014:decompositionintegral,
   journal = {Economic Theory},
   year = {2014},
   volume = {56},
   number = {1},
   pages = {33--58},
   title = {Decomposition-integral: {U}nifying {C}hoquet and the concave integrals},
   author = {Yaarit Even and Ehud Lehrer}
}

@article{Grabisch1997:kadditive,
   author = {Grabisch, Michel},
   journal = {Fuzzy Sets and Systems},
   number = {167--189},
   title = {{\textit{k}-order} additive discrete fuzzy measures and their representation},
   volume = {92},
   year = {1997}
}

@article{Grabisch2000:graphicalchoquet,
   author = {Grabisch, Michel},
   journal = {IEEE Transactions on Fuzzy Systems},
   number = {5},
   pages = {627--631},
   title = {A graphical interpretation of the {C}hoquet integral},
   volume = {8},
   year = {2000}
}

@article{GrecoMesiarRindone2014:twocharactunivine,
   title = {Two new characterizations of universal integrals on the scale $[0,1]$},
   author = {Salvatore Greco and Radko Mesiar and Fabio Rindone},
   journal = {Information Sciences},
   year = {2014},
   pages = {217--224},
   volume = {267}
}

@article{GroesETAL1998:axiomchoquet,
   author = {Groes, Ebbe and Jacobsen, Hans J{\o}rgen and Sloth, Birgitte and Tran{\ae}s, Torben},
   journal = {Economic Theory},
   pages = {441--448},
   title = {Axiomatic characterizations of the {C}hoquet integral},
   volume = {12},
   year = {1998}
}

@article{KlementMesiarPap2010:universalintegral,
   author = {E.P. Klement and Radko Mesiar and Endre Pap},
   title = {A universal integral as common frame for {C}hoquet and {S}ugeno integral},
   journal = {{IEEE} Transactions on Fuzzy Systems},
   volume = {18},
   year = {2010},
   pages = {178--187}
}

@article{Lehrer2009:concaveintegral,
   author = {Ehud Lehrer},
   title = {A new integral for capacities},
   journal = {Economic Theory},
   volume = {39},
   number = {1},
   year = {2009},
   pages = {157--176}
}

@article{MesiarStupnanova2013:decompositionintegrals,
   title = {Decomposition integrals},
   author = {Radko Mesiar and Andrea Stup\v{n}anov\'{a}},
   journal = {International Journal of Approximate Reasoning},
   year = {2013},
   volume = {54},
   number = {8},
   pages = {1252--1259}
}

@inproceedings{SanchezTrillas2012:fuzziness,
   author = {Daniel Sanchez and Enric Trillas},
   booktitle = {Proc.~IPMU 2012 (CCIS 298)},
   editor = {Salvatore Greco and others},
   publisher = {Springer-Verlag},
   year = {2012},
   pages = {25--43},
   title = {Measures of fuzziness under different uses of fuzzy sets}
}

@article{Shilkret1971:maxitivemeasure,
   author = {N. Shilkret},
   title = {Maxitive measure and integration},
   journal = {Indagationes Mathematic\ae},
   volume = {33},
   year = {1971},
   pages = {109--116}
}

@phdthesis{Sugeno1974:PhD,
   author = {Michio Sugeno},
   institution = {Meguro-ku},
   location = {Tokyo},
   school = {Tokyo Institute of Technology},
   title = {Theory of fuzzy integrals and its applications},
   year = {1974}
}

@article{TorraNarukawa2006:interpretationfuzzyint,
   author = {Torra, Vicen\c{c} and Narukawa, Yasuo},
   title = {The interpretation of fuzzy integrals and their application to fuzzy systems},
   journal = {International Journal of Approximate Reasoning},
   volume = {41},
   year = {2006},
   pages = {43--58}
}

@article{TorraNarukawa2008:h2fuzzyintegrals,
   author = {Torra, Vicen\c{c} and Narukawa, Yasuo},
   journal = {IEEE Transactions on Fuzzy Systems},
   number = {3},
   pages = {795--797},
   title = {The $h$-index and the number of citations: {T}wo fuzzy integrals},
   volume = {16},
   year = {2008}
}

@article{Weber1984:fuzziness,
   author = {Siegfried Weber},
   journal = {Fuzzy Sets and Systems},
   volume = {13},
   year = {1984},
   pages = {247--271},
   title = {Measures of fuzzy sets and measures of fuzziness}
}

@article{Yang1985:PanIntegral,
   author = {Qingji Yang},
   title = {The {PAN}-integral on the Fuzzy Measure Space},
   journal = {Fuzzy Mathematics},
   volume = {3},
   year = {1985},
   pages = {107--114}
}

@article{ZengLi2006:inclusionsimilarityfuzziness,
   title = {Inclusion Measures, Similarity Measures, and the Fuzziness of Fuzzy Sets and Their Relations},
   author = {Wanyi Zeng and Hongxing Li},
   journal = {International Journal of Intelligent Systems},
   volume = {21},
   year = {2006},
   pages = {639--653}
}

license: Unlicense

repository: GodotMisogi/bibliography

repo_name: GodotMisogi/bibliography

gha_license_id: Unlicense


text:
//
// Created by timovdk on 5/15/20.
//

#include "stp/plays/contested/GetBallRisky.h"
#include "stp/roles/active/BallGetter.h"
#include "stp/roles/passive/Defender.h"
#include "stp/roles/Keeper.h"
#include "stp/roles/active/PassReceiver.h"

namespace rtt::ai::stp::play {

    GetBallRisky::GetBallRisky() : Play() {
        startPlayEvaluation.clear();
        startPlayEvaluation.emplace_back(eval::NormalPlayGameState);
        startPlayEvaluation.emplace_back(eval::BallIsFree);
        startPlayEvaluation.emplace_back(eval::WeHaveMajority);
        startPlayEvaluation.emplace_back(eval::BallClosestToUs);

        keepPlayEvaluation.clear();
        keepPlayEvaluation.emplace_back(eval::NormalPlayGameState);
        keepPlayEvaluation.emplace_back(eval::BallIsFree);
        keepPlayEvaluation.emplace_back(eval::WeHaveMajority);
        keepPlayEvaluation.emplace_back(eval::BallClosestToUs);

        roles = std::array<std::unique_ptr<Role>, rtt::ai::Constants::ROBOT_COUNT()>{
                std::make_unique<role::Keeper>(role::Keeper("keeper")),
                std::make_unique<role::BallGetter>(role::BallGetter("ball_getter")),
                std::make_unique<role::PassReceiver>(role::PassReceiver("receiver_0")),
                std::make_unique<role::PassReceiver>(role::PassReceiver("receiver_1")),
                std::make_unique<role::PassReceiver>(role::PassReceiver("receiver_2")),
                std::make_unique<role::Defender>(role::Defender("defender_0")),
                std::make_unique<role::Defender>(role::Defender("defender_1")),
                std::make_unique<role::Defender>(role::Defender("defender_2")),
                std::make_unique<role::Defender>(role::Defender("midfielder_0")),
                std::make_unique<role::Defender>(role::Defender("midfielder_1")),
                std::make_unique<role::Defender>(role::Defender("midfielder_2"))};
    }

    uint8_t GetBallRisky::score(PlayEvaluator &playEvaluator) noexcept { return 120; }

    void GetBallRisky::calculateInfoForScoredRoles(world::World *world) noexcept {
        stpInfos["ball_getter"].setPositionToShootAt(world->getField().value().getTheirGoalCenter());
    }

    void GetBallRisky::calculateInfoForRoles() noexcept {
        calculateInfoForScoredRoles(world);

        auto enemyRobots = world->getWorld()->getThem();
        auto enemyAttacker = world->getWorld()->getRobotClosestToBall(world::them);

        if (enemyRobots.empty()) {
            RTT_ERROR("There are no enemy robots, which are necessary for this play!")
            return;
        }

        enemyRobots.erase(std::remove_if(enemyRobots.begin(), enemyRobots.end(),
                                         [&](const auto enemyRobot) -> bool {
                                             return enemyAttacker &&
                                                    enemyRobot->getId() ==
                                                    enemyAttacker.value()->getId();
                                         }));

        auto enemyClosestToGoal = world->getWorld()->getRobotClosestToPoint(field.getOurGoalCenter(), enemyRobots);

        stpInfos["keeper"].setEnemyRobot(world->getWorld()->getRobotClosestToBall(world::them));

        stpInfos["receiver_0"].setPositionToMoveTo(PositionComputations::getPosition(stpInfos["receiver_2"].getPositionToMoveTo(),gen::gridRightTop, gen::OffensivePosition, field, world));
        stpInfos["receiver_1"].setPositionToMoveTo(PositionComputations::getPosition(stpInfos["receiver_1"].getPositionToMoveTo(),gen::gridRightBot, gen::OffensivePosition, field, world));
        stpInfos["receiver_2"].setPositionToMoveTo(PositionComputations::getPosition(stpInfos["receiver_2"].getPositionToMoveTo(),gen::gridRightMid, gen::OffensivePosition, field, world));

        stpInfos["defender_0"].setPositionToDefend(field.getOurGoalCenter());
        stpInfos["defender_0"].setEnemyRobot(enemyAttacker);
        stpInfos["defender_0"].setBlockDistance(BlockDistance::CLOSE);

        stpInfos["defender_1"].setPositionToDefend(field.getOurGoalCenter());
        stpInfos["defender_1"].setEnemyRobot(enemyClosestToGoal);
        stpInfos["defender_1"].setBlockDistance(BlockDistance::CLOSE);

        if (enemyClosestToGoal) {
            stpInfos["defender_2"].setPositionToDefend(enemyClosestToGoal.value()->getPos());
        } else {
            stpInfos["defender_2"].setPositionToDefend(field.getOurGoalCenter() + Vector2{1, 1});
        }

        stpInfos["defender_2"].setEnemyRobot(enemyAttacker);
        stpInfos["defender_2"].setBlockDistance(BlockDistance::CLOSE);

        stpInfos["midfielder_0"].setPositionToDefend(field.getOurGoalCenter());
        stpInfos["midfielder_0"].setEnemyRobot(enemyAttacker);
        stpInfos["midfielder_0"].setBlockDistance(BlockDistance::CLOSE);

        stpInfos["midfielder_1"].setPositionToDefend(field.getOurGoalCenter());
        stpInfos["midfielder_1"].setEnemyRobot(enemyClosestToGoal);
        stpInfos["midfielder_1"].setBlockDistance(BlockDistance::CLOSE);

        if (enemyClosestToGoal)
            stpInfos["midfielder_2"].setPositionToDefend(enemyClosestToGoal.value()->getPos());
        else
            stpInfos["midfielder_2"].setPositionToDefend(field.getTheirGoalCenter() + Vector2{1, 1});
        stpInfos["midfielder_2"].setEnemyRobot(enemyAttacker);
        stpInfos["midfielder_2"].setBlockDistance(BlockDistance::CLOSE);
    }

    Dealer::FlagMap GetBallRisky::decideRoleFlags() const noexcept {
        Dealer::FlagMap flagMap;
        Dealer::DealerFlag ballGetter(DealerFlagTitle::CLOSE_TO_BALL, DealerFlagPriority::REQUIRED);

        flagMap.insert({"keeper", {DealerFlagPriority::KEEPER, {}}});
        flagMap.insert({"ball_getter", {DealerFlagPriority::REQUIRED, {ballGetter}}});
        flagMap.insert({"receiver_0", {DealerFlagPriority::LOW_PRIORITY, {}}});
        flagMap.insert({"receiver_1", {DealerFlagPriority::LOW_PRIORITY, {}}});
        flagMap.insert({"receiver_2", {DealerFlagPriority::LOW_PRIORITY, {}}});
        flagMap.insert({"defender_0", {DealerFlagPriority::LOW_PRIORITY, {}}});
        flagMap.insert({"defender_1", {DealerFlagPriority::LOW_PRIORITY, {}}});
        flagMap.insert({"defender_2", {DealerFlagPriority::LOW_PRIORITY, {}}});
        flagMap.insert({"midfielder_0", {DealerFlagPriority::LOW_PRIORITY, {}}});
        flagMap.insert({"midfielder_1", {DealerFlagPriority::LOW_PRIORITY, {}}});
        flagMap.insert({"midfielder_2", {DealerFlagPriority::LOW_PRIORITY, {}}});
        return flagMap;
    }

    const char *GetBallRisky::getName() { return "Get Ball Risky"; }

}  // namespace rtt::ai::stp::play

license: MIT

repository: maxthielen/yml

license_type: permissive

repo_name: maxthielen/yml

branch_name: refs/heads/development

gha_license_id: MIT

extension: cpp


text:
LICENSE = "GPL"

PR = "r1"

DEPENDS = "glib-2.0 zlib"

SRC_URI = "http://repository.maemo.org/pool/maemo4.0/free/source/libo/${PN}_${PV}-1.tar.gz"

inherit autotools pkgconfig

do_configure() {
	gnu-configize
	libtoolize --force
	oe_runconf
}

SRC_URI[md5sum] = "4c5b31154943108ba0fecf00c8af9f3c"
SRC_URI[sha256sum] = "687f46d5d5eb5ced18534f3cfcfdd82db6b25679437602f1519cae48d019b55d"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD

extension: bb


text:
package handler

import (
	"encoding/json"
	"log"
	"net/http"
)

//HandlerRoute - This interface provides the object with the responsibility to handle requests.
type HandlerRoute interface {
	Props() (path string, method string)
	Handler(w http.ResponseWriter, r *http.Request)
}

// ResponseError - This method provides to return errors in JSON format.
func ResponseError(w http.ResponseWriter, httpStatus int, message string) {

	data := map[string]string{}
	data["error"] = message

	ResponseJSON(w, httpStatus, data)
}

// ResponseJSON - This method provides to return the results in JSON format.
func ResponseJSON(w http.ResponseWriter, httpStatus int, payload interface{}) {

	data, err := json.Marshal(payload)
	if err != nil {
		log.Fatal(err.Error())
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(httpStatus)
	w.Write(data)
}

repository: hugoamac/mux-rest-api

repo_name: hugoamac/mux-rest-api

branch_name: refs/heads/master

extension: go


text:
PV = "0.0+cvs${SRCDATE}"
LICENSE = "BSD-X"
SECTION = "libs"
PRIORITY = "optional"
DEPENDS = "libxfont xtrans"

SRC_URI = "${FREEDESKTOP_CVS}/xlibs;module=FS"
S = "${WORKDIR}/FS"

inherit autotools pkgconfig

do_stage() {
	autotools_stage_all
}


text:
/*############################################################################
  # Copyright (C) 2020 Intel Corporation
  #
  # SPDX-License-Identifier: MIT
  ############################################################################*/

#include "src/cpu_workstream.h"
#include "src/cpu_common.h"

CpuWorkstream::CpuWorkstream() : m_allocator({}) {
    av_log_set_level(AV_LOG_QUIET);
}

CpuWorkstream::~CpuWorkstream() {}

mfxStatus CpuWorkstream::Sync(mfxSyncPoint &syncp, mfxU32 wait) {
    return MFX_ERR_NONE;
}

repository: ajunlonglive/oneVPL-cpu

repo_name: ajunlonglive/oneVPL-cpu


text:
# Copyright (C) 2014 Urs Fässler <urs.fassler@bytesatwork.ch>
# Released under the MIT license (see COPYING.MIT for the terms)

##################################################
# ATTENTION:                                     #
# This image is for development purpose only.    #
# Please do not use in a production environment. #
##################################################

DESCRIPTION = "bytes at work AG root file system for development"

LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

IMAGE_INSTALL += "\
	packagegroup-core-boot \
	\
	binutils \
	binutils-symlinks \
	bzip2 \
	can-utils \
	coreutils \
	dosfstools \
	e2fsprogs \
	e2fsprogs-mke2fs \
	evtest \
	file \
	gdb \
	gdbserver \
	htop \
	i2c-tools \
	iproute2 \
	libsocketcan \
	man \
	man-pages \
	mtd-utils \
	mtd-utils-jffs2 \
	mtd-utils-misc \
	mtd-utils-ubifs \
	nano \
	openssh-scp \
	openssh-sshd \
	perf \
	procps \
	screen \
	startcan \
	strace \
	tar \
	tcpdump \
	time \
	tslib \
	tslib-calibrate \
	tslib-conf \
	tslib-tests \
	usbutils \
	util-linux-sfdisk \
	valgrind \
	vim \
	wget \
"

IMAGE_LINGUAS = " "

IMAGE_FEATURES += "package-management"

inherit core-image

require development-motd.inc
require password.inc

repository: gicho/meta-bytesatwork

repo_name: gicho/meta-bytesatwork


text:
DESCRIPTION = "XML::RegExp - Regular expressions for XML tokens"
SECTION = "libs"
LICENSE = "unknown"
PR = "r2"

SRC_URI = "http://search.cpan.org/CPAN/authors/id/T/TJ/TJMATHER/XML-RegExp-${PV}.tar.gz"

S = "${WORKDIR}/XML-RegExp-${PV}"

inherit cpan

BBCLASSEXTEND="native"

SRC_URI[md5sum] = "5826b24e0d05714e25c2bb04e1f1c09b"
SRC_URI[sha256sum] = "4608bd4aed51d6f31a1a77796bc42f7ddf9700fe9b33c86a6b75ccb6a9cf6abe"


text:
LICENSE = "LGPL"
PR = "r0"
DESCRIPTION = "libgpewidget contains a collection of widgets and other common code shared by many GPE applications."
SECTION = "gpe/libs"
PRIORITY = "optional"
MAINTAINER = "Philip Blundell <pb@handhelds.org>"
DEPENDS = "gtk+ cairo libxrender gtk-doc intltool-native"

SRC_URI = "${GPE_MIRROR}/${PN}-${PV}.tar.bz2 \
	file://doc.patch;patch=1"

inherit pkgconfig autotools

EXTRA_OECONF = "--enable-cairo"

do_stage () {
	oe_libinstall -C .libs -so libgpewidget ${STAGING_LIBDIR}
	autotools_stage_includes
}

repository: Terentyev/familiar-linux

repo_name: Terentyev/familiar-linux


text:
package templates

import (
	"github.com/prometheus/prometheus/pkg/rulefmt"
)

// Pipeline can build a RuleGroup that powers the generation of SLO time series. The
// RuleGroup generated by the Pipeline will include rules installed by templates and the
// global alerting windows, with each SLOs registered on a Pipeline instance via the
// MustRegister() method.
type Pipeline struct {
	// Name defines the RuleGroup name in Prometheus
	Name string

	// SLORules is where each SLO should place the appropriate rules that power the
	// post-processing and alert trailers.
	SLORules []rulefmt.Rule
}

func NewPipeline(name string) *Pipeline {
	return &Pipeline{name, []rulefmt.Rule{}}
}

func (p *Pipeline) MustRegister(slos ...SLO) {
	for _, slo := range slos {
		p.SLORules = append(p.SLORules, slo.Rules()...)
	}
}

func (p *Pipeline) Build() rulefmt.RuleGroups {
	return rulefmt.RuleGroups{
		Groups: []rulefmt.RuleGroup{
			rulefmt.RuleGroup{
				Name: p.Name,
				Rules: flattenRules(
					p.SLORules,
					TemplateRules,
					AlertRules,
				),
			},
		},
	}
}

repository: gocardless/slo-builder

repo_name: gocardless/slo-builder

gha_language: Go


text:
package encrypt

import (
	"bytes"
	"crypto/aes"
	"crypto/cipher"
	"encoding/base64"
	"errors"
)

//高级加密标准（Adevanced Encryption Standard ,AES）

//16,24,32位字符串的话，分别对应AES-128，AES-192，AES-256 加密方法
//key不能泄露
var PwdKey = []byte("DIS**#KKKDJJSKDI")

//PKCS7 填充模式
func PKCS7Padding(ciphertext []byte, blockSize int) []byte {
	padding := blockSize - len(ciphertext)%blockSize
	//Repeat()函数的功能是把切片[]byte{byte(padding)}复制padding个，然后合并成新的字节切片返回
	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
	return append(ciphertext, padtext...)
}

//填充的反向操作，删除填充字符串
func PKCS7UnPadding(origData []byte) ([]byte, error) {
	//获取数据长度
	length := len(origData)
	if length == 0 {
		return nil, errors.New("加密字符串错误！")
	} else {
		//获取填充字符串长度
		unpadding := int(origData[length-1])
		//截取切片，删除填充字节，并且返回明文
		return origData[:(length - unpadding)], nil
	}
}

//实现加密
func AesEcrypt(origData []byte, key []byte) ([]byte, error) {
	//创建加密算法实例
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	//获取块的大小
	blockSize := block.BlockSize()
	//对数据进行填充，让数据长度满足需求
	origData = PKCS7Padding(origData, blockSize)
	//采用AES加密方法中CBC加密模式
	blocMode := cipher.NewCBCEncrypter(block, key[:blockSize])
	crypted := make([]byte, len(origData))
	//执行加密
	blocMode.CryptBlocks(crypted, origData)
	return crypted, nil
}

//实现解密
func AesDeCrypt(cypted []byte, key []byte) ([]byte, error) {
	//创建加密算法实例
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	//获取块大小
	blockSize := block.BlockSize()
	//创建加密客户端实例
	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
	origData := make([]byte, len(cypted))
	//这个函数也可以用来解密
	blockMode.CryptBlocks(origData, cypted)
	//去除填充字符串
	origData, err = PKCS7UnPadding(origData)
	if err != nil {
		return nil, err
	}
	return origData, err
}

//加密base64
func EnPwdCode(pwd []byte) (string, error) {
	result, err := AesEcrypt(pwd, PwdKey)
	if err != nil {
		return "", err
	}
	return base64.StdEncoding.EncodeToString(result), err
}

//解密
func DePwdCode(pwd string) ([]byte, error) {
	//解密base64字符串
	pwdByte, err := base64.StdEncoding.DecodeString(pwd)
	if err != nil {
		return nil, err
	}
	//执行AES解密
	return AesDeCrypt(pwdByte, PwdKey)

}

branch_name: refs/heads/main


text:
@book{boyd,
 author = {Boyd, Stephen and Vandenberghe, Lieven},
 title = {Convex Optimization},
 year = {2004},
 isbn = {0521833787},
 publisher = {Cambridge University Press},
 address = {New York, NY, USA}
 }

@book{nielsen,
	title      = {Neural Networks and Deep Learning},
	author     = {Nielsen, Michael A.},
	year       = {2015},
	publisher  = {Determination Press}
}

@book{Goodfellow-et-al-2016,
    title={Deep Learning},
    author={Ian Goodfellow and Yoshua Bengio and Aaron Courville},
    publisher={MIT Press},
    note={\url{http://www.deeplearningbook.org}},
    year={2016}
}

@ARTICLE{Jain-Kar,
   author = {{Jain}, P. and {Kar}, P.},
    title = "{Non-convex Optimization for Machine Learning}",
  journal = {ArXiv e-prints},
archivePrefix = "arXiv",
   eprint = {1712.07897},
 primaryClass = "stat.ML",
 keywords = {Statistics - Machine Learning, Computer Science - Learning, Mathematics - Optimization and Control},
     year = 2017,
    month = dec,
   adsurl = {http://adsabs.harvard.edu/abs/2017arXiv171207897J},
  adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}

@ARTICLE{vidal-et-al,
   author = {{Vidal}, R. and {Bruna}, J. and {Giryes}, R. and {Soatto}, S.
	},
    title = "{Mathematics of Deep Learning}",
  journal = {ArXiv e-prints},
archivePrefix = "arXiv",
   eprint = {1712.04741},
 primaryClass = "cs.LG",
 keywords = {Computer Science - Learning, Computer Science - Computer Vision and Pattern Recognition},
     year = 2017,
    month = dec,
   adsurl = {http://adsabs.harvard.edu/abs/2017arXiv171204741V},
  adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}

@book{bertsekas,
  title={Nonlinear programming},
  author={Bertsekas, D.P.},
  isbn={9781886529007},
  lccn={95081359},
  series={Athena Scientific optimization and computation series},
  year={1999},
  publisher={Athena Scientific}
}

@misck{levine,
	author = 	{LeVine, Steve},
	title = 	{Artificial Intelligence Pioneer Says We Need to Start Over.},
	editor = 	{Axios},
	month = 	{January},
	year = 		{2018},
	url = 		{http://bit.ly/2E25FSd},
	note =      {[Online; posted 15-September-2017]},
}

@article{duran,
	title={gerdm/convex\_nonconvex: .tex and code for the essay ``Convex v.s. Non-Convex Problems''},
	DOI={10.5281/zenodo.1164246},
	publisher={Zenodo},
	author={Gerardo Durán Martín},
	year={2018},
	month={Feb},
	url = {https://zenodo.org/record/1164246#.WnNWiGaZPRY}
}

extension: bib


text:
// Onut
#include <onut/Random.h>

// STL
#include <stdlib.h>
#include <time.h>

namespace onut
{
    void setSeed(unsigned int seed)
    {
        srand(seed);
    }

    unsigned int randomizeSeed()
    {
        auto seed = static_cast<unsigned int>(time(nullptr));
        setSeed(seed);
        return seed;
    }

    int randi()
    {
        return rand();
    }

    int randi(int max)
    {
        return rand() % (max + 1);
    }

    int randi(int min, int max)
    {
        auto range = max - min + 1;
        return rand() % range + min;
    }

    bool randb()
    {
        return randi(0, 1) ? true : false;
    }

    bool randb(float chances)
    {
        return (randf(0.f, 1.f) <= chances);
    }

    float randf(float max)
    {
        auto rnd = rand();
        auto rndf = static_cast<double>(rnd) / static_cast<double>(RAND_MAX - 1);
        rndf *= static_cast<double>(max);
        return static_cast<float>(rndf);
    }

    float randf(float min, float max)
    {
        auto rnd = rand();
        auto rndf = static_cast<double>(rnd) / static_cast<double>(RAND_MAX - 1);
        rndf *= static_cast<double>(max - min);
        return static_cast<float>(rndf)+min;
    }

    Vector2 rand2f(const Vector2& max)
    {
        return{randf(max.x), randf(max.y)};
    }

    Vector2 rand2f(const Vector2& min, const Vector2& max)
    {
        return{randf(min.x, max.x), randf(min.y, max.y)};
    }

    Vector2 randCircle(const Vector2& center, float radius)
    {
        float dist = ORandFloat(0.0f, 1.0f);
        dist *= dist;
        dist = 1 - dist;
        dist *= radius;
        float angle = ORandFloat(0.0f, O2PI);
        return{center.x + cosf(angle) * dist, center.y + sinf(angle) * dist};
    }

    Vector2 randCircleEdge(const Vector2& center, float radius)
    {
        float angle = ORandFloat(0.0f, O2PI);
        return{center.x + cosf(angle) * radius, center.y + sinf(angle) * radius};
    }

    Vector3 randDirection()
    {
        auto theta = onut::randf(O2PI);
        auto phi = acosf(onut::randf(-1.f, 1.f));

        auto cos_theta = cosf(theta);
        auto sin_theta = sinf(theta);
        auto cos_phi = cosf(phi);
        auto sin_phi = sinf(phi);

        return Vector3(
            cos_theta * sin_phi,
            sin_theta * sin_phi,
            cos_phi
        );
    }

    Vector3 rand3f(const Vector3& max)
    {
        return{randf(max.x), randf(max.y), randf(max.z)};
    }

    Vector3 rand3f(const Vector3& min, const Vector3& max)
    {
        return{randf(min.x, max.x), randf(min.y, max.y), randf(min.z, max.z)};
    }

    Vector4 rand4f(const Vector4& max)
    {
        return{randf(max.x), randf(max.y), randf(max.z), randf(max.w)};
    }

    Vector4 rand4f(const Vector4& min, const Vector4& max)
    {
        return{randf(min.x, max.x), randf(min.y, max.y), randf(min.z, max.z), randf(min.w, max.w)};
    }

    Color randc(float alpha)
    {
        return{randf(1.f) * alpha, randf(1.f) * alpha, randf(1.f) * alpha, alpha};
    }

    Color randc(const Color& max)
    {
        return{randf(max.r), randf(max.g), randf(max.b), randf(max.a)};
    }

    Color randc(const Color& min, const Color& max)
    {
        return{randf(min.r, max.r), randf(min.g, max.g), randf(min.b, max.b), randf(min.a, max.a)};
    }

    static float saturate(float a)
    {
        return std::min(1.0f, std::max(a, 0.0f));
    }

    Color randc(const Color& color, float variation)
    {
        // TODO: Use HSB instead
        return Color(
            saturate(randf(color.r - variation, color.r + variation)),
            saturate(randf(color.g - variation, color.g + variation)),
            saturate(randf(color.b - variation, color.b + variation)),
            color.a
        );
    }

    Color randc(const std::vector<Color>& palette, float variation)
    {
        return randc(randv(palette), variation);
    }

    template<> int randt<int>(const int& min, const int& max)
    {
        return randi(min, max);
    }

    template<> int randt<int>(const int& max)
    {
        return randi(max);
    }

    template<> unsigned int randt<unsigned int>(const unsigned int& min, const unsigned int& max)
    {
        auto range = max - min + 1;
        return rand() % range + min;
    }

    template<> unsigned int randt<unsigned int>(const unsigned int& max)
    {
        return rand() % (max + 1);
    }

    template<> float randt<float>(const float& min, const float& max)
    {
        return randf(min, max);
    }

    template<> float randt<float>(const float& max)
    {
        return randf(max);
    }

    template<> double randt<double>(const double& min, const double& max)
    {
        auto rnd = rand();
        auto rndf = static_cast<double>(rnd) / static_cast<double>(RAND_MAX - 1);
        rndf *= max - min;
        return rndf + min;
    }

    template<> double randt<double>(const double& max)
    {
        auto rnd = rand();
        auto rndf = static_cast<double>(rnd) / static_cast<double>(RAND_MAX - 1);
        rndf *= max;
        return rndf;
    }

    template<> Vector2 randt<Vector2>(const Vector2& min, const Vector2& max)
    {
        return rand2f(min, max);
    }

    template<> Vector2 randt<Vector2>(const Vector2& max)
    {
        return rand2f(max);
    }

    template<> Vector3 randt<Vector3>(const Vector3& min, const Vector3& max)
    {
        return rand3f(min, max);
    }

    template<> Vector3 randt<Vector3>(const Vector3& max)
    {
        return rand3f(max);
    }

    template<> Vector4 randt<Vector4>(const Vector4& min, const Vector4& max)
    {
        return rand4f(min, max);
    }

    template<> Vector4 randt<Vector4>(const Vector4& max)
    {
        return rand4f(max);
    }

    template<> Color randt<Color>(const Color& min, const Color& max)
    {
        return randc(min, max);
    }

    template<> Color randt<Color>(const Color& max)
    {
        return randc(max);
    }
}

repository: Daivuk/onut

repo_name: Daivuk/onut

gha_language: C


text:
package awslambda

import (
	"testing"

	"github.com/caddyserver/caddy"
	"github.com/caddyserver/caddy/caddyhttp/httpserver"
)

func TestSetup(t *testing.T) {
	input := "awslambda /foo"
	c := caddy.NewTestController("http", input)
	err := setup(c)
	if err != nil {
		t.Errorf("setup() returned err: %v", err)
	}

	mids := httpserver.GetConfig(c).Middleware()
	mid := mids[len(mids)-1]
	handler := mid(nil).(Handler)

	expected := []*Config{
		&Config{
			Path:    "/foo",
			Include: []string{},
			Exclude: []string{},
		},
	}
	handler.Configs[0].invoker = nil
	eqOrErr(expected, handler.Configs, 0, t)
}

repository: coopernurse/caddy-awslambda

repo_name: coopernurse/caddy-awslambda


text:
@article{cai2016GeometricInference,
	Author = {Cai, T. Tony and Liang, Tengyuan and Rakhlin, Alexander},
	Journal = {The Annals of Statistics},
	Month = aug,
	Number = {4},
	Pages = {1536--1563},
	Title = {Geometric Inference for General High-Dimensional Linear Inverse Problems},
	Volume = {44},
	Year = {2016},
	Doi = {10.1214/15-AOS1426}}


text:
include recipes-core/images/core-image-base.bb

IMAGE_FEATURES += "debug-tweaks"

# SOC_EXTRA_IMAGE_FEATURES ?= "tools-testapps"
SOC_EXTRA_IMAGE_FEATURES=""

# Add extra image features
EXTRA_IMAGE_FEATURES += " \
    ${SOC_EXTRA_IMAGE_FEATURES} \
    nfs-server \
    tools-debug \
    tools-profile \
"

IMAGE_INSTALL += " \
    dropbear \
    xbmc \
    xbmc-nm-addon \
    networkmanager \
    procps \
    util-linux-mount \
    libntfs-3g \
    ntfsprogs \
    ntfs-3g \
    ntp \
    ntp-utils \
    tvheadend \
    util-linux \
    firmware-imx-vpu-imx6d \
    fsl-rc-local \
    xbmc-image-custom-rfs \
    packagegroup-core-sdk \
    joe \
"

export IMAGE_BASENAME = "xbmc-image"

repository: wolfgar/meta-stef

repo_name: wolfgar/meta-stef

gha_language: BlitzBasic


text:
package https

// 维护session共享区
func (p *p1) AddHeader(key, value string) *p1 {
	p.comm.header.Add(key, value)
	return p
}
func (p *p1) AddHeaders(entries map[string]string) *p1 {
	p.comm.header.Adds(entries)
	return p
}
func (p *p1) RemoveHeader(key string) *p1 {
	p.comm.header.Remove(key)
	return p
}
func (p *p1) ClearHeader() *p1 {
	p.comm.header.Clear()
	return p
}
func (p *p1) AddCookie(key, value string) *p1 {
	p.comm.cookie.Add(key, value)
	return p
}
func (p *p1) AddCookies(entries map[string]string) *p1 {
	p.comm.cookie.Adds(entries)
	return p
}
func (p *p1) RemoveCookie(key string) *p1 {
	p.comm.cookie.Remove(key)
	return p
}
func (p *p1) ClearCookie() *p1 {
	p.comm.cookie.Clear()
	return p
}
func (p *p1) SetTimeOut(time int) *p1 {
	p.SetRespTimeOut(time)
	p.SetConnTimeOut(time)
	return p
}
func (p *p1) SetConnTimeOut(time int) *p1 {
	p.comm.connTimeout = time
	return p
}
func (p *p1) SetRespTimeOut(time int) *p1 {
	p.comm.respTimeout = time
	return p
}
func (p *p1) Proxy(proxy string) *p1 {
	p.comm.proxy = proxy
	return p
}
func (p *p1) BasicAuth(user, password string) *p1 {
	p.comm.auth = encodeBasicAuth(user, password)
	return p
}
func (p *p1) Retry(count uint) *p1 {
	p.comm.retry = count
	return p
}

func (p *p1) SkipSSLVerify(verify bool) *p1{
	p.comm.skipSSLVerify = verify
	return p
}

// 维护 request 私有区
func (p *p2) AddHeader(key, value string) *p2 {
	p.req.header.Add(key, value)
	return p
}
func (p *p2) AddHeaders(entries map[string]string) *p2 {
	p.req.header.Adds(entries)
	return p
}
func (p *p2) RemoveHeader(key string) *p2 {
	p.req.header.Remove(key)
	return p
}
func (p *p2) ClearHeader() *p2 {
	p.req.header.Clear()
	return p
}
func (p *p2) AddCookie(key, value string) *p2 {
	p.req.cookie.Add(key, value)
	return p
}
func (p *p2) AddCookies(entries map[string]string) *p2 {
	p.req.cookie.Adds(entries)
	return p
}
func (p *p2) RemoveCookie(key string) *p2 {
	p.req.cookie.Remove(key)
	return p
}
func (p *p2) ClearCookie() *p2 {
	p.req.cookie.Clear()
	return p
}
func (p *p2) SetTimeOut(time int) *p2 {
	p.SetRespTimeOut(time)
	p.SetConnTimeOut(time)
	return p
}
func (p *p2) SetConnTimeOut(time int) *p2 {
	p.req.connTimeout = time
	return p
}
func (p *p2) SetRespTimeOut(time int) *p2 {
	p.req.respTimeout = time
	return p
}
func (p *p2) Proxy(proxy string) *p2 {
	p.req.proxy = proxy
	return p
}
func (p *p2) BasicAuth(user, password string) *p2 {
	p.req.auth = encodeBasicAuth(user, password)
	return p
}
func (p *p2) Retry(count uint) *p2 {
	p.req.retry = count
	return p
}
func (p *p2) SkipSSLVerify(verify bool) *p2{
	p.req.skipSSLVerify = verify
	return p
}

repository: szllzs/go-tools

repo_name: szllzs/go-tools


text:
package test

import (
	"context"
	"log"
	"testing"

	"github.com/components/student"
)

func TestStudentDB(t *testing.T) {

	//	Get conection with database
	//	Use config mongo function
	db, err := GetMongoDB("localhost", "27017")

	// Close conection in the end
	defer db.Disconnect(context.TODO())

	// Checks if creating conection with mongo db
	// doesn't return any errors
	if err != nil {
		log.Fatal(err)
	}

	// Get test collection of student
	collection := db.Database("apc_database_test").Collection("student_test")

	// Drop all content to start testing
	collection.Drop(context.TODO())

	// Instantiate grades for test
	grades := student.StudentGrades{
		Exams:    []float64{1.4, 2.3, 2.4},
		Projects: []float64{1.6, 3.1, 2.4},
		Lists:    []float64{1.2, 1.2, 1.2},
	}

	// Instantiate some students objects
	student1 := student.StudentCreate{
		FirstName: "Thiago",
		LastName:  "Veras Machado",
		Matricula: "160156666",
		Handles:   []string{"Veras", "113065"},
		Password:  "HQFnf-1234",
		PhotoURL:  "https://userpic.codeforces.com/546204/title/d2ac05baf39339f.jpg",
		Email:     "teste@gmail.com",
		Grades:    grades,
	}

	student2 := student.StudentCreate{
		FirstName: "Vitor",
		LastName:  "Fernandes Dullens",
		Matricula: "160571946",
		Handles:   []string{"vitordullens", "2353251"},
		Password:  "Hgqwge1234",
		PhotoURL:  "https://userpic.codeforces.com/551311/title/95d04d8b95b95302.jpg",
		Email:     "teste@gmail.com",
		Grades:    grades,
	}

	student3 := student.StudentCreate{
		FirstName: "Giovanni",
		LastName:  "Guidini",
		Matricula: "136246666",
		Handles:   []string{"Gguidini", "11165"},
		Password:  "12rw-1234",
		PhotoURL:  "https://userpic.codeforces.com/765049/title/2075d6432eadaae9.jpg",
		Email:     "teste@gmail.com",
		Grades:    grades,
	}
	///////////////////////////////////////////////////////////////////////////////////////////
	// 								 INSERT STUDENTS DB TEST 								 //
	///////////////////////////////////////////////////////////////////////////////////////////
	// Test if student class array can be inserted in test database
	// Checks if err variable is not null

	if err := student.CreateStudents(db, []student.StudentCreate{student1, student2, student3}, "apc_database_test", "student_test"); err != nil {
		t.Errorf("Failed to insert students in Database : %s", err)
	}

	///////////////////////////////////////////////////////////////////////////////////////////
	// 							   GET ALL STUDENTS FROM DB TEST 				      		 //
	///////////////////////////////////////////////////////////////////////////////////////////
	//
	// Test if can get all students from database
	// Checks if err variable is not null
	//

	var students []student.Student

	if students, err = student.GetStudents(db, "apc_database_test", "student_test"); err != nil {
		t.Errorf("Failed to get students from Database : %s", err)
	}

	///////////////////////////////////////////////////////////////////////////////////////////
	// 							UPDATE LIST OF STUDENTS FROM DB TEST   		         		 //
	///////////////////////////////////////////////////////////////////////////////////////////
	//
	// Test if student class array can be updated in test database
	// Change some students name, then update that class on DB
	// Checks if err variable is not null

	students[0].FirstName = "Guilherme"
	students[0].LastName = "Carvalho"

	students[2].FirstName = "Henrique"
	students[2].LastName = "Machado"

	if err := student.UpdateStudents(db, []student.Student{students[0], students[2]}, "apc_database_test", "student_test"); err != nil {
		t.Errorf("Failed to update students in Database : %s", err)
	}

	students = nil

	if students, err = student.GetStudents(db, "apc_database_test", "student_test"); err != nil {
		t.Errorf("Failed to get students from Database : %s", err)
	}

	if students[0].FirstName != "Guilherme" {
		t.Errorf("Invalid students[0] first name, got: %s, want: %s.", students[0].FirstName, "Thiago")
	}

	if students[2].LastName != "Machado" {
		t.Errorf("Invalid students[2] last name, got: %s, want: %s.", students[2].LastName, "Machado")
	}

	///////////////////////////////////////////////////////////////////////////////////////////
	// 							DELETE LIST OF STUDENTS FROM DB TEST   		         		 //
	///////////////////////////////////////////////////////////////////////////////////////////
	//
	// Test if student class array can be deleted in test database
	// Checks if err variable is not null

	if err := student.DeleteStudents(db, []student.Student{students[0]}, "apc_database_test", "student_test"); err != nil {
		t.Errorf("Failed to delete students in Database : %s", err)
	}

	students = nil

	if students, err = student.GetStudents(db, "apc_database_test", "student_test"); err != nil {
		t.Errorf("Failed to get students from Database : %s", err)
	}

	if len(students) != 2 {
		t.Errorf("Invalid students size, got: %d, want: %d.", len(students), 2)
	}

}

repository: apc-unb/apc-api

repo_name: apc-unb/apc-api


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: bm_member_data.proto

package cisco_ios_xr_bundlemgr_oper_bundle_information_bundle_bundle_members_bundle_member_bundle_member_item

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 BmMemberData_KEYS struct {
	MemberInterface      string   `protobuf:"bytes,1,opt,name=member_interface,json=memberInterface,proto3" json:"member_interface,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_BmMemberData_KEYS proto.InternalMessageInfo

func (m *BmMemberData_KEYS) GetMemberInterface() string {
	if m != nil {
		return m.MemberInterface
	}
	return ""
}

type BmLacpCounters struct {
	LacpdUsReceived             uint32   `protobuf:"varint,1,opt,name=lacpd_us_received,json=lacpdUsReceived,proto3" json:"lacpd_us_received,omitempty"`
	LacpdUsTransmitted          uint32   `protobuf:"varint,2,opt,name=lacpd_us_transmitted,json=lacpdUsTransmitted,proto3" json:"lacpd_us_transmitted,omitempty"`
	MarkerPacketsReceived       uint32   `protobuf:"varint,3,opt,name=marker_packets_received,json=markerPacketsReceived,proto3" json:"marker_packets_received,omitempty"`
	MarkerResponsesTransmitted  uint32   `protobuf:"varint,4,opt,name=marker_responses_transmitted,json=markerResponsesTransmitted,proto3" json:"marker_responses_transmitted,omitempty"`
	IllegalPacketsReceived      uint32   `protobuf:"varint,5,opt,name=illegal_packets_received,json=illegalPacketsReceived,proto3" json:"illegal_packets_received,omitempty"`
	ExcessLacpdUsReceived       uint32   `protobuf:"varint,6,opt,name=excess_lacpd_us_received,json=excessLacpdUsReceived,proto3" json:"excess_lacpd_us_received,omitempty"`
	ExcessMarkerPacketsReceived uint32   `protobuf:"varint,7,opt,name=excess_marker_packets_received,json=excessMarkerPacketsReceived,proto3" json:"excess_marker_packets_received,omitempty"`
	Defaulted                   uint32   `protobuf:"varint,8,opt,name=defaulted,proto3" json:"defaulted,omitempty"`
	Expired                     uint32   `protobuf:"varint,9,opt,name=expired,proto3" json:"expired,omitempty"`
	LastClearedSec              uint32   `protobuf:"varint,10,opt,name=last_cleared_sec,json=lastClearedSec,proto3" json:"last_cleared_sec,omitempty"`
	LastClearedNsec             uint32   `protobuf:"varint,11,opt,name=last_cleared_nsec,json=lastClearedNsec,proto3" json:"last_cleared_nsec,omitempty"`
	XXX_NoUnkeyedLiteral        struct{} `json:"-"`
	XXX_unrecognized            []byte   `json:"-"`
	XXX_sizecache               int32    `json:"-"`
}

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

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

var xxx_messageInfo_BmLacpCounters proto.InternalMessageInfo

func (m *BmLacpCounters) GetLacpdUsReceived() uint32 {
	if m != nil {
		return m.LacpdUsReceived
	}
	return 0
}

func (m *BmLacpCounters) GetLacpdUsTransmitted() uint32 {
	if m != nil {
		return m.LacpdUsTransmitted
	}
	return 0
}

func (m *BmLacpCounters) GetMarkerPacketsReceived() uint32 {
	if m != nil {
		return m.MarkerPacketsReceived
	}
	return 0
}

func (m *BmLacpCounters) GetMarkerResponsesTransmitted() uint32 {
	if m != nil {
		return m.MarkerResponsesTransmitted
	}
	return 0
}

func (m *BmLacpCounters) GetIllegalPacketsReceived() uint32 {
	if m != nil {
		return m.IllegalPacketsReceived
	}
	return 0
}

func (m *BmLacpCounters) GetExcessLacpdUsReceived() uint32 {
	if m != nil {
		return m.ExcessLacpdUsReceived
	}
	return 0
}

func (m *BmLacpCounters) GetExcessMarkerPacketsReceived() uint32 {
	if m != nil {
		return m.ExcessMarkerPacketsReceived
	}
	return 0
}

func (m *BmLacpCounters) GetDefaulted() uint32 {
	if m != nil {
		return m.Defaulted
	}
	return 0
}

func (m *BmLacpCounters) GetExpired() uint32 {
	if m != nil {
		return m.Expired
	}
	return 0
}

func (m *BmLacpCounters) GetLastClearedSec() uint32 {
	if m != nil {
		return m.LastClearedSec
	}
	return 0
}

func (m *BmLacpCounters) GetLastClearedNsec() uint32 {
	if m != nil {
		return m.LastClearedNsec
	}
	return 0
}

type BmLacpLinkData struct {
	InterfaceHandle         string   `protobuf:"bytes,1,opt,name=interface_handle,json=interfaceHandle,proto3" json:"interface_handle,omitempty"`
	ActorSystemPriority     uint32   `protobuf:"varint,2,opt,name=actor_system_priority,json=actorSystemPriority,proto3" json:"actor_system_priority,omitempty"`
	ActorSystemMacAddress   string   `protobuf:"bytes,3,opt,name=actor_system_mac_address,json=actorSystemMacAddress,proto3" json:"actor_system_mac_address,omitempty"`
	ActorOperationalKey     uint32   `protobuf:"varint,4,opt,name=actor_operational_key,json=actorOperationalKey,proto3" json:"actor_operational_key,omitempty"`
	PartnerSystemPriority   uint32   `protobuf:"varint,5,opt,name=partner_system_priority,json=partnerSystemPriority,proto3" json:"partner_system_priority,omitempty"`
	PartnerSystemMacAddress string   `protobuf:"bytes,6,opt,name=partner_system_mac_address,json=partnerSystemMacAddress,proto3" json:"partner_system_mac_address,omitempty"`
	PartnerOperationalKey   uint32   `protobuf:"varint,7,opt,name=partner_operational_key,json=partnerOperationalKey,proto3" json:"partner_operational_key,omitempty"`
	SelectedAggregatorId    uint32   `protobuf:"varint,8,opt,name=selected_aggregator_id,json=selectedAggregatorId,proto3" json:"selected_aggregator_id,omitempty"`
	AttachedAggregatorId    uint32   `protobuf:"varint,9,opt,name=attached_aggregator_id,json=attachedAggregatorId,proto3" json:"attached_aggregator_id,omitempty"`
	ActorPortId             uint32   `protobuf:"varint,10,opt,name=actor_port_id,json=actorPortId,proto3" json:"actor_port_id,omitempty"`
	ActorPortPriority       uint32   `protobuf:"varint,11,opt,name=actor_port_priority,json=actorPortPriority,proto3" json:"actor_port_priority,omitempty"`
	PartnerPortId           uint32   `protobuf:"varint,12,opt,name=partner_port_id,json=partnerPortId,proto3" json:"partner_port_id,omitempty"`
	PartnerPortPriority     uint32   `protobuf:"varint,13,opt,name=partner_port_priority,json=partnerPortPriority,proto3" json:"partner_port_priority,omitempty"`
	ActorPortState          uint32   `protobuf:"varint,14,opt,name=actor_port_state,json=actorPortState,proto3" json:"actor_port_state,omitempty"`
	PartnerPortState        uint32   `protobuf:"varint,15,opt,name=partner_port_state,json=partnerPortState,proto3" json:"partner_port_state,omitempty"`
	XXX_NoUnkeyedLiteral    struct{} `json:"-"`
	XXX_unrecognized        []byte   `json:"-"`
	XXX_sizecache           int32    `json:"-"`
}

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

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

var xxx_messageInfo_BmLacpLinkData proto.InternalMessageInfo

func (m *BmLacpLinkData) GetInterfaceHandle() string {
	if m != nil {
		return m.InterfaceHandle
	}
	return ""
}

func (m *BmLacpLinkData) GetActorSystemPriority() uint32 {
	if m != nil {
		return m.ActorSystemPriority
	}
	return 0
}

func (m *BmLacpLinkData) GetActorSystemMacAddress() string {
	if m != nil {
		return m.ActorSystemMacAddress
	}
	return ""
}

func (m *BmLacpLinkData) GetActorOperationalKey() uint32 {
	if m != nil {
		return m.ActorOperationalKey
	}
	return 0
}

func (m *BmLacpLinkData) GetPartnerSystemPriority() uint32 {
	if m != nil {
		return m.PartnerSystemPriority
	}
	return 0
}

func (m *BmLacpLinkData) GetPartnerSystemMacAddress() string {
	if m != nil {
		return m.PartnerSystemMacAddress
	}
	return ""
}

func (m *BmLacpLinkData) GetPartnerOperationalKey() uint32 {
	if m != nil {
		return m.PartnerOperationalKey
	}
	return 0
}

func (m *BmLacpLinkData) GetSelectedAggregatorId() uint32 {
	if m != nil {
		return m.SelectedAggregatorId
	}
	return 0
}

func (m *BmLacpLinkData) GetAttachedAggregatorId() uint32 {
	if m != nil {
		return m.AttachedAggregatorId
	}
	return 0
}

func (m *BmLacpLinkData) GetActorPortId() uint32 {
	if m != nil {
		return m.ActorPortId
	}
	return 0
}

func (m *BmLacpLinkData) GetActorPortPriority() uint32 {
	if m != nil {
		return m.ActorPortPriority
	}
	return 0
}

func (m *BmLacpLinkData) GetPartnerPortId() uint32 {
	if m != nil {
		return m.PartnerPortId
	}
	return 0
}

func (m *BmLacpLinkData) GetPartnerPortPriority() uint32 {
	if m != nil {
		return m.PartnerPortPriority
	}
	return 0
}

func (m *BmLacpLinkData) GetActorPortState() uint32 {
	if m != nil {
		return m.ActorPortState
	}
	return 0
}

func (m *BmLacpLinkData) GetPartnerPortState() uint32 {
	if m != nil {
		return m.PartnerPortState
	}
	return 0
}

type BmMbrStateReasonDataType struct {
	ReasonType           string   `protobuf:"bytes,1,opt,name=reason_type,json=reasonType,proto3" json:"reason_type,omitempty"`
	Severity             string   `protobuf:"bytes,2,opt,name=severity,proto3" json:"severity,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_BmMbrStateReasonDataType proto.InternalMessageInfo

func (m *BmMbrStateReasonDataType) GetReasonType() string {
	if m != nil {
		return m.ReasonType
	}
	return ""
}

func (m *BmMbrStateReasonDataType) GetSeverity() string {
	if m != nil {
		return m.Severity
	}
	return ""
}

type BmMuxData struct {
	MuxState                 string                    `protobuf:"bytes,1,opt,name=mux_state,json=muxState,proto3" json:"mux_state,omitempty"`
	Error                    uint32                    `protobuf:"varint,2,opt,name=error,proto3" json:"error,omitempty"`
	MemberMuxStateReason     string                    `protobuf:"bytes,3,opt,name=member_mux_state_reason,json=memberMuxStateReason,proto3" json:"member_mux_state_reason,omitempty"`
	MemberMuxStateReasonData *BmMbrStateReasonDataType `protobuf:"bytes,4,opt,name=member_mux_state_reason_data,json=memberMuxStateReasonData,proto3" json:"member_mux_state_reason_data,omitempty"`
	MemberState              string                    `protobuf:"bytes,5,opt,name=member_state,json=memberState,proto3" json:"member_state,omitempty"`
	MuxStateReason           string                    `protobuf:"bytes,6,opt,name=mux_state_reason,json=muxStateReason,proto3" json:"mux_state_reason,omitempty"`
	XXX_NoUnkeyedLiteral     struct{}                  `json:"-"`
	XXX_unrecognized         []byte                    `json:"-"`
	XXX_sizecache            int32                     `json:"-"`
}

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

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

var xxx_messageInfo_BmMuxData proto.InternalMessageInfo

func (m *BmMuxData) GetMuxState() string {
	if m != nil {
		return m.MuxState
	}
	return ""
}

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

func (m *BmMuxData) GetMemberMuxStateReason() string {
	if m != nil {
		return m.MemberMuxStateReason
	}
	return ""
}

func (m *BmMuxData) GetMemberMuxStateReasonData() *BmMbrStateReasonDataType {
	if m != nil {
		return m.MemberMuxStateReasonData
	}
	return nil
}

func (m *BmMuxData) GetMemberState() string {
	if m != nil {
		return m.MemberState
	}
	return ""
}

func (m *BmMuxData) GetMuxStateReason() string {
	if m != nil {
		return m.MuxStateReason
	}
	return ""
}

type BmMacAddrSt struct {
	Address              string   `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_BmMacAddrSt proto.InternalMessageInfo

func (m *BmMacAddrSt) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type BmMemberData struct {
	Bandwidth            uint32          `protobuf:"varint,50,opt,name=bandwidth,proto3" json:"bandwidth,omitempty"`
	Counters             *BmLacpCounters `protobuf:"bytes,51,opt,name=counters,proto3" json:"counters,omitempty"`
	LinkData             *BmLacpLinkData `protobuf:"bytes,52,opt,name=link_data,json=linkData,proto3" json:"link_data,omitempty"`
	MemberMuxData        *BmMuxData      `protobuf:"bytes,53,opt,name=member_mux_data,json=memberMuxData,proto3" json:"member_mux_data,omitempty"`
	PortPriority         uint32          `protobuf:"varint,54,opt,name=port_priority,json=portPriority,proto3" json:"port_priority,omitempty"`
	PortNumber           uint32          `protobuf:"varint,55,opt,name=port_number,json=portNumber,proto3" json:"port_number,omitempty"`
	UnderlyingLinkId     uint32          `protobuf:"varint,56,opt,name=underlying_link_id,json=underlyingLinkId,proto3" json:"underlying_link_id,omitempty"`
	LinkOrderNumber      uint32          `protobuf:"varint,57,opt,name=link_order_number,json=linkOrderNumber,proto3" json:"link_order_number,omitempty"`
	InterfaceName        string          `protobuf:"bytes,58,opt,name=interface_name,json=interfaceName,proto3" json:"interface_name,omitempty"`
	IccpNode             uint32          `protobuf:"varint,59,opt,name=iccp_node,json=iccpNode,proto3" json:"iccp_node,omitempty"`
	MemberType           string          `protobuf:"bytes,60,opt,name=member_type,json=memberType,proto3" json:"member_type,omitempty"`
	MemberName           string          `protobuf:"bytes,61,opt,name=member_name,json=memberName,proto3" json:"member_name,omitempty"`
	MacAddress           *BmMacAddrSt    `protobuf:"bytes,62,opt,name=mac_address,json=macAddress,proto3" json:"mac_address,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_BmMemberData proto.InternalMessageInfo

func (m *BmMemberData) GetBandwidth() uint32 {
	if m != nil {
		return m.Bandwidth
	}
	return 0
}

func (m *BmMemberData) GetCounters() *BmLacpCounters {
	if m != nil {
		return m.Counters
	}
	return nil
}

func (m *BmMemberData) GetLinkData() *BmLacpLinkData {
	if m != nil {
		return m.LinkData
	}
	return nil
}

func (m *BmMemberData) GetMemberMuxData() *BmMuxData {
	if m != nil {
		return m.MemberMuxData
	}
	return nil
}

func (m *BmMemberData) GetPortPriority() uint32 {
	if m != nil {
		return m.PortPriority
	}
	return 0
}

func (m *BmMemberData) GetPortNumber() uint32 {
	if m != nil {
		return m.PortNumber
	}
	return 0
}

func (m *BmMemberData) GetUnderlyingLinkId() uint32 {
	if m != nil {
		return m.UnderlyingLinkId
	}
	return 0
}

func (m *BmMemberData) GetLinkOrderNumber() uint32 {
	if m != nil {
		return m.LinkOrderNumber
	}
	return 0
}

func (m *BmMemberData) GetInterfaceName() string {
	if m != nil {
		return m.InterfaceName
	}
	return ""
}

func (m *BmMemberData) GetIccpNode() uint32 {
	if m != nil {
		return m.IccpNode
	}
	return 0
}

func (m *BmMemberData) GetMemberType() string {
	if m != nil {
		return m.MemberType
	}
	return ""
}

func (m *BmMemberData) GetMemberName() string {
	if m != nil {
		return m.MemberName
	}
	return ""
}

func (m *BmMemberData) GetMacAddress() *BmMacAddrSt {
	if m != nil {
		return m.MacAddress
	}
	return nil
}

func init() {
	proto.RegisterType((*BmMemberData_KEYS)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.bundle.bundle_members.bundle_member.bundle_member_item.bm_member_data_KEYS")
	proto.RegisterType((*BmLacpCounters)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.bundle.bundle_members.bundle_member.bundle_member_item.bm_lacp_counters")
	proto.RegisterType((*BmLacpLinkData)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.bundle.bundle_members.bundle_member.bundle_member_item.bm_lacp_link_data")
	proto.RegisterType((*BmMbrStateReasonDataType)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.bundle.bundle_members.bundle_member.bundle_member_item.bm_mbr_state_reason_data_type")
	proto.RegisterType((*BmMuxData)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.bundle.bundle_members.bundle_member.bundle_member_item.bm_mux_data")
	proto.RegisterType((*BmMacAddrSt)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.bundle.bundle_members.bundle_member.bundle_member_item.bm_mac_addr_st")
	proto.RegisterType((*BmMemberData)(nil), "cisco_ios_xr_bundlemgr_oper.bundle_information.bundle.bundle_members.bundle_member.bundle_member_item.bm_member_data")
}

func init() { proto.RegisterFile("bm_member_data.proto", fileDescriptor_af03d980950c6672) }

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

repository: cisco-ie/cisco-proto

repo_name: cisco-ie/cisco-proto


text:
/*
Copyright 2023 The Kubernetes 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 (
	gotest "testing"

	"k8s.io/component-base/featuregate"
)

func TestSpecialGates(t *gotest.T) {
	gate := featuregate.NewFeatureGate()
	gate.Add(map[featuregate.Feature]featuregate.FeatureSpec{
		"alpha_default_on":         {PreRelease: featuregate.Alpha, Default: true},
		"alpha_default_on_set_off": {PreRelease: featuregate.Alpha, Default: true},
		"alpha_default_off":        {PreRelease: featuregate.Alpha, Default: false},
		"alpha_default_off_set_on": {PreRelease: featuregate.Alpha, Default: false},

		"beta_default_on":         {PreRelease: featuregate.Beta, Default: true},
		"beta_default_on_set_off": {PreRelease: featuregate.Beta, Default: true},
		"beta_default_off":        {PreRelease: featuregate.Beta, Default: false},
		"beta_default_off_set_on": {PreRelease: featuregate.Beta, Default: false},

		"stable_default_on":         {PreRelease: featuregate.GA, Default: true},
		"stable_default_on_set_off": {PreRelease: featuregate.GA, Default: true},
		"stable_default_off":        {PreRelease: featuregate.GA, Default: false},
		"stable_default_off_set_on": {PreRelease: featuregate.GA, Default: false},
	})
	gate.Set("alpha_default_on_set_off=false")
	gate.Set("beta_default_on_set_off=false")
	gate.Set("stable_default_on_set_off=false")
	gate.Set("alpha_default_off_set_on=true")
	gate.Set("beta_default_off_set_on=true")
	gate.Set("stable_default_off_set_on=true")

	before := map[featuregate.Feature]bool{
		"AllAlpha": false,
		"AllBeta":  false,

		"alpha_default_on":         true,
		"alpha_default_on_set_off": false,
		"alpha_default_off":        false,
		"alpha_default_off_set_on": true,

		"beta_default_on":         true,
		"beta_default_on_set_off": false,
		"beta_default_off":        false,
		"beta_default_off_set_on": true,

		"stable_default_on":         true,
		"stable_default_on_set_off": false,
		"stable_default_off":        false,
		"stable_default_off_set_on": true,
	}
	expect(t, gate, before)

	cleanupAlpha := SetFeatureGateDuringTest(t, gate, "AllAlpha", true)
	expect(t, gate, map[featuregate.Feature]bool{
		"AllAlpha": true,
		"AllBeta":  false,

		"alpha_default_on":         true,
		"alpha_default_on_set_off": true,
		"alpha_default_off":        true,
		"alpha_default_off_set_on": true,

		"beta_default_on":         true,
		"beta_default_on_set_off": false,
		"beta_default_off":        false,
		"beta_default_off_set_on": true,

		"stable_default_on":         true,
		"stable_default_on_set_off": false,
		"stable_default_off":        false,
		"stable_default_off_set_on": true,
	})

	cleanupBeta := SetFeatureGateDuringTest(t, gate, "AllBeta", true)
	expect(t, gate, map[featuregate.Feature]bool{
		"AllAlpha": true,
		"AllBeta":  true,

		"alpha_default_on":         true,
		"alpha_default_on_set_off": true,
		"alpha_default_off":        true,
		"alpha_default_off_set_on": true,

		"beta_default_on":         true,
		"beta_default_on_set_off": true,
		"beta_default_off":        true,
		"beta_default_off_set_on": true,

		"stable_default_on":         true,
		"stable_default_on_set_off": false,
		"stable_default_off":        false,
		"stable_default_off_set_on": true,
	})

	// run cleanups in reverse order like defer would
	cleanupBeta()
	cleanupAlpha()
	expect(t, gate, before)
}

func expect(t *gotest.T, gate featuregate.FeatureGate, expect map[featuregate.Feature]bool) {
	t.Helper()
	for k, v := range expect {
		if gate.Enabled(k) != v {
			t.Errorf("Expected %v=%v, got %v", k, v, gate.Enabled(k))
		}
	}
}

repository: kubernetes/kubernetes

repo_name: kubernetes/kubernetes


text:
@article{conway2020communication,
 author = {Bevil Conway and Sivalogeswaran Ratnasingam and Julian Jara-Ettinger and Richard Futrell and Edward Gibson},
 journal = {Cognition},
 pages = {104086},
 title = {Communication efficiency of color naming across languages provides a new framework for the evolution of color terms},
 url = {http://socsci.uci.edu/~rfutrell/papers/conway2020communication.pdf},
 volume = {195},
 year = {2020}
}

repository: langprocgroup/academic-kickstart

repo_name: langprocgroup/academic-kickstart


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

// package context defines different context types that hold information
// about the place at which an event occurs or where content should be
// stored in and retrieved from.

package context

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 Context struct {
	// Types that are valid to be assigned to Ctx:
	//	*Context_SectionCtx
	//	*Context_ThreadCtx
	//	*Context_CommentCtx
	//	*Context_SubcommentCtx
	Ctx                  isContext_Ctx `protobuf_oneof:"ctx"`
	SectionId            string        `protobuf:"bytes,5,opt,name=section_id,json=sectionId,proto3" json:"section_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_Context proto.InternalMessageInfo

type isContext_Ctx interface {
	isContext_Ctx()
}

type Context_SectionCtx struct {
	SectionCtx *Section `protobuf:"bytes,1,opt,name=section_ctx,json=sectionCtx,proto3,oneof"`
}

type Context_ThreadCtx struct {
	ThreadCtx *Thread `protobuf:"bytes,2,opt,name=thread_ctx,json=threadCtx,proto3,oneof"`
}

type Context_CommentCtx struct {
	CommentCtx *Comment `protobuf:"bytes,3,opt,name=comment_ctx,json=commentCtx,proto3,oneof"`
}

type Context_SubcommentCtx struct {
	SubcommentCtx *Subcomment `protobuf:"bytes,4,opt,name=subcomment_ctx,json=subcommentCtx,proto3,oneof"`
}

func (*Context_SectionCtx) isContext_Ctx() {}

func (*Context_ThreadCtx) isContext_Ctx() {}

func (*Context_CommentCtx) isContext_Ctx() {}

func (*Context_SubcommentCtx) isContext_Ctx() {}

func (m *Context) GetCtx() isContext_Ctx {
	if m != nil {
		return m.Ctx
	}
	return nil
}

func (m *Context) GetSectionCtx() *Section {
	if x, ok := m.GetCtx().(*Context_SectionCtx); ok {
		return x.SectionCtx
	}
	return nil
}

func (m *Context) GetThreadCtx() *Thread {
	if x, ok := m.GetCtx().(*Context_ThreadCtx); ok {
		return x.ThreadCtx
	}
	return nil
}

func (m *Context) GetCommentCtx() *Comment {
	if x, ok := m.GetCtx().(*Context_CommentCtx); ok {
		return x.CommentCtx
	}
	return nil
}

func (m *Context) GetSubcommentCtx() *Subcomment {
	if x, ok := m.GetCtx().(*Context_SubcommentCtx); ok {
		return x.SubcommentCtx
	}
	return nil
}

func (m *Context) GetSectionId() string {
	if m != nil {
		return m.SectionId
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Context) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Context_SectionCtx)(nil),
		(*Context_ThreadCtx)(nil),
		(*Context_CommentCtx)(nil),
		(*Context_SubcommentCtx)(nil),
	}
}

// A Section is the highest level and just has the name of the section.
type Section struct {
	Id                   string   `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Section proto.InternalMessageInfo

func (m *Section) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

// A Thread is inside of a section and has a thread identifier unique to
// that section.
type Thread struct {
	SectionCtx           *Section `protobuf:"bytes,1,opt,name=section_ctx,json=sectionCtx,proto3" json:"section_ctx,omitempty"`
	Id                   string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Thread proto.InternalMessageInfo

func (m *Thread) GetSectionCtx() *Section {
	if m != nil {
		return m.SectionCtx
	}
	return nil
}

func (m *Thread) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

// A Comment is inside of a thread and has a comment identifier unique to
// that thread.
type Comment struct {
	ThreadCtx            *Thread  `protobuf:"bytes,1,opt,name=thread_ctx,json=threadCtx,proto3" json:"thread_ctx,omitempty"`
	Id                   string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Comment proto.InternalMessageInfo

func (m *Comment) GetThreadCtx() *Thread {
	if m != nil {
		return m.ThreadCtx
	}
	return nil
}

func (m *Comment) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

// A Subcomment is inside of a comment and has a subcomment identifier
// unique to that comment.
type Subcomment struct {
	CommentCtx           *Comment `protobuf:"bytes,1,opt,name=comment_ctx,json=commentCtx,proto3" json:"comment_ctx,omitempty"`
	Id                   string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Subcomment proto.InternalMessageInfo

func (m *Subcomment) GetCommentCtx() *Comment {
	if m != nil {
		return m.CommentCtx
	}
	return nil
}

func (m *Subcomment) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func init() {
	proto.RegisterType((*Context)(nil), "context.Context")
	proto.RegisterType((*Section)(nil), "context.Section")
	proto.RegisterType((*Thread)(nil), "context.Thread")
	proto.RegisterType((*Comment)(nil), "context.Comment")
	proto.RegisterType((*Subcomment)(nil), "context.Subcomment")
}

func init() {
	proto.RegisterFile("context.proto", fileDescriptor_b64063be2fc89884)
}

var fileDescriptor_b64063be2fc89884 = []byte{
	// 310 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x3f, 0x4f, 0xf3, 0x30,
	0x10, 0x87, 0x1b, 0xf7, 0x6d, 0xab, 0x5c, 0xd5, 0xbe, 0xc8, 0x2c, 0x65, 0x40, 0xaa, 0x32, 0x15,
	0x21, 0x52, 0xa0, 0x2b, 0x53, 0xb3, 0x24, 0x62, 0x40, 0x32, 0x4c, 0x2c, 0x15, 0xb1, 0xad, 0xc4,
	0x12, 0x89, 0x51, 0xe2, 0xa0, 0x7c, 0x05, 0xbe, 0x35, 0xb2, 0xe3, 0x36, 0x7f, 0xd4, 0x81, 0x2d,
	0xf1, 0xdd, 0x73, 0xfe, 0xdd, 0x23, 0xc3, 0x82, 0xca, 0x5c, 0xf1, 0x5a, 0xf9, 0x5f, 0x85, 0x54,
	0x12, 0xcf, 0xec, 0xaf, 0xf7, 0x83, 0x60, 0x16, 0x34, 0xdf, 0x78, 0x07, 0xf3, 0x92, 0x53, 0x25,
	0x64, 0x7e, 0xa0, 0xaa, 0x5e, 0x39, 0x6b, 0x67, 0x33, 0x7f, 0xbc, 0xf0, 0x8f, 0xe4, 0x6b, 0x53,
	0x0b, 0x47, 0x04, 0x6c, 0x5b, 0xa0, 0x6a, 0x7c, 0x0f, 0xa0, 0xd2, 0x82, 0x7f, 0x30, 0xc3, 0x20,
	0xc3, 0xfc, 0x3f, 0x31, 0x6f, 0xa6, 0x14, 0x8e, 0x88, 0xdb, 0x34, 0x69, 0x62, 0x07, 0x73, 0x2a,
	0xb3, 0x8c, 0xe7, 0xca, 0x20, 0xe3, 0xc1, 0x35, 0x41, 0x53, 0xd3, 0xd7, 0xd8, 0x36, 0x0d, 0x3d,
	0xc1, 0xb2, 0xac, 0xe2, 0x2e, 0xf7, 0xcf, 0x70, 0x97, 0x6d, 0xbc, 0x53, 0x39, 0x1c, 0x91, 0x45,
	0xdb, 0xac, 0xe9, 0x6b, 0x38, 0x46, 0x3e, 0x08, 0xb6, 0x9a, 0xac, 0x9d, 0x8d, 0x4b, 0x5c, 0x7b,
	0x12, 0xb1, 0xfd, 0x04, 0xc6, 0x54, 0xd5, 0xde, 0x15, 0xcc, 0xec, 0x8e, 0x78, 0x09, 0x28, 0x62,
	0xc6, 0x80, 0x4b, 0x50, 0xc4, 0xbc, 0x67, 0x98, 0x36, 0xab, 0xe0, 0x87, 0x3f, 0x49, 0xea, 0x29,
	0x5a, 0x02, 0x12, 0xcc, 0xa8, 0x71, 0x09, 0x12, 0xcc, 0x8b, 0xb4, 0x72, 0x93, 0x0d, 0xfb, 0x3d,
	0x7b, 0xce, 0x59, 0x7b, 0x5d, 0x77, 0xc3, 0x51, 0x2f, 0x00, 0xed, 0xde, 0x3a, 0x5b, 0xd7, 0x90,
	0x73, 0xde, 0x6c, 0xcf, 0xeb, 0x60, 0xe0, 0xfe, 0xf6, 0xfd, 0x26, 0x11, 0x2a, 0xad, 0x62, 0x9f,
	0xca, 0x6c, 0xfb, 0x59, 0x89, 0x32, 0xa9, 0xbe, 0xf9, 0x96, 0xa6, 0xbc, 0x90, 0xe6, 0xe9, 0xdc,
	0x25, 0x72, 0x6b, 0x07, 0xc6, 0x53, 0x73, 0xb2, 0xfb, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x60, 0x60,
	0x9a, 0x84, 0x5d, 0x02, 0x00, 0x00,
}

repository: luisguve/cheroproto-go

repo_name: luisguve/cheroproto-go


text:
package freki

import (
	"bytes"
	"log"
	"testing"

	. "github.com/smartystreets/goconvey/convey"
)

func TestLogger(t *testing.T) {
	Convey("The wrapped logger should", t, func() {
		buff := new(bytes.Buffer)
		testLogger := NewStandardLogger(log.New(buff, "", log.LstdFlags))

		testLogger.Debug("hello")
		So(buff.String(), ShouldEndWith, "DEBUG hello\n")
		buff.Reset()

		testLogger.Debug("hello", "world")
		So(buff.String(), ShouldEndWith, "DEBUG helloworld\n")
		buff.Reset()

		testLogger.Debugf("hello %s", "world")
		So(buff.String(), ShouldEndWith, "DEBUG hello world\n")
		buff.Reset()

		testLogger.Error("hello")
		So(buff.String(), ShouldEndWith, "ERROR hello\n")
		buff.Reset()

		testLogger.Error("hello", "world")
		So(buff.String(), ShouldEndWith, "ERROR helloworld\n")
		buff.Reset()

		testLogger.Errorf("hello %s", "world")
		So(buff.String(), ShouldEndWith, "ERROR hello world\n")
		buff.Reset()

		testLogger.Info("hello")
		So(buff.String(), ShouldEndWith, "INFO hello\n")
		buff.Reset()

		testLogger.Info("hello", "world")
		So(buff.String(), ShouldEndWith, "INFO helloworld\n")
		buff.Reset()

		testLogger.Infof("hello %s", "world")
		So(buff.String(), ShouldEndWith, "INFO hello world\n")
		buff.Reset()

		testLogger.Warn("hello")
		So(buff.String(), ShouldEndWith, "WARN hello\n")
		buff.Reset()

		testLogger.Warn("hello", "world")
		So(buff.String(), ShouldEndWith, "WARN helloworld\n")
		buff.Reset()

		testLogger.Warnf("hello %s", "world")
		So(buff.String(), ShouldEndWith, "WARN hello world\n")
		buff.Reset()
	})
}

repository: kung-foo/freki

repo_name: kung-foo/freki


text:
package main

import (
	"fmt"
	"io/ioutil"
	"os"

	"github.com/AlexGustafsson/bake/builtins"
	"github.com/AlexGustafsson/bake/runtime"
	log "github.com/sirupsen/logrus"
	"github.com/urfave/cli/v2"
)

func runCommand(context *cli.Context) error {
	inputPath := context.String("input")
	if inputPath == "" {
		inputPath = "Bakefile"
	}

	directory := context.String("in")
	if directory != "" {
		log.Debugf("changing directory to '%s'", directory)
		err := os.Chdir(directory)
		if err != nil {
			return err
		}
	}

	file, err := os.Open(inputPath)
	if err != nil {
		return err
	}

	inputBytes, err := ioutil.ReadAll(file)
	if err != nil {
		return err
	}

	input := string(inputBytes)
	program := runtime.CreateProgram(input, runtime.CreateDefaultRuntime())
	builtins.Register(program)

	err = program.Parse()
	if err != nil {
		PrintPrettyError(err, input)
		return fmt.Errorf("parsing failed")
	}

	errs := program.BuildSymbols()
	if len(errs) > 0 {
		PrintPrettyErrors(errs, input)
		return fmt.Errorf("validation failed")
	}

	program.DefineBuiltinSymbols()

	errs = program.Validate()
	if len(errs) > 0 {
		PrintPrettyErrors(errs, input)
		return fmt.Errorf("validation failed")
	}

	program.DefineBuiltinValues()

	err = program.Run()
	if err != nil {
		return err
	}

	for _, task := range context.Args().Slice() {
		err = program.RunTask(task)
		if err != nil {
			return err
		}
	}

	return nil
}

repository: AlexGustafsson/bake

repo_name: AlexGustafsson/bake


text:
//#TODO this is not finished yet

package solution

// you can also use imports, for example:
// import "fmt"
// import "os"

// you can write to stdout for debugging purposes, e.g.
// fmt.Println("this is a debug message")

func Solution(S string) int {
    brackets := make([]rune, 0)
    currentPosition := -1

    for _,value := range S{
        if value == '(' || value == '{' || value == '['{
            brackets = append(brackets,value)
            currentPosition ++
        }else{
            if(isMatching(value ,brackets[currentPosition])){
                brackets = brackets[:currentPosition]
                currentPosition--
            }else{
                brackets = append(brackets,value)
                currentPosition ++
            }
        }
    }

    if len(brackets) == 0{
        return 1
    }else{
        return 0
    }
}

func isMatching(first rune, second rune) bool{
    isMatching := false

    if first == '(' && second == ')'{
        isMatching = true
    }else if first == '{' && second == '}'{
        isMatching = true
    }else if first == '[' && second == ']'{
        isMatching = true
    }

    return isMatching
}

repository: sinderpl/dailyProgrammer

repo_name: sinderpl/dailyProgrammer


text:
package Subsets

import (
	"sort"
)

//Given a set of distinct integers, nums, return all possible subsets (the power set).
//
//Note: The solution set must not contain duplicate subsets.
//
//For example,
//If nums = [1,2,3], a solution is:
//
//[
//[3],
//[1],
//[2],
//[1,2,3],
//[1,3],
//[2,3],
//[1,2],
//[]
//]
//
//Accepted.

func subsets(nums []int) [][]int {
	results := make([][]int, 0)
	results = append(results, []int{})

	if nums == nil || len(nums) == 0 {
		return results
	}

	sort.Ints(nums)

	for _, i := range nums {
		size := len(results)
		for j := 0; j < size; j++ {
			l := make([]int, 0)
			for _, r := range results[j] {
				l = append(l, r)
			}
			l = append(l, i)
			results = append(results, l)
		}
	}

	return results
}


text:
SUMMARY = "Protocol Buffers"
DESCRIPTION = "Protocol Buffers are Google’s data interchange format"
HOMEPAGE = "https://developers.google.com/protocol-buffers/"
SECTION = "devel/python"

LICENSE = "BSD-3-Clause"
LIC_FILES_CHKSUM = "file://PKG-INFO;beginline=8;endline=8;md5=19e8f490f9526b1de84f8d949cfcfd4e"

inherit pypi setuptools

SRC_URI[md5sum] = "d634666c898148e4565ac62f3ba4a2ca"
SRC_URI[sha256sum] = "843f498e98ad1469ad54ecb4a7ccf48605a1c5d2bd26ae799c7a2cddab4a37ec"

# http://errors.yoctoproject.org/Errors/Details/184715/
# Can't find required file: ../src/google/protobuf/descriptor.proto
CLEANBROKEN = "1"

UPSTREAM_CHECK_REGEX = "protobuf/(?P<pver>\d+(\.\d+)+)/"

RDEPENDS:${PN} += " \
    ${PYTHON_PN}-datetime \
    ${PYTHON_PN}-json \
    ${PYTHON_PN}-logging \
    ${PYTHON_PN}-netclient \
    ${PYTHON_PN}-numbers \
    ${PYTHON_PN}-pkgutil \
    ${PYTHON_PN}-six \
    ${PYTHON_PN}-unittest \
"

# For usage in other recipies when compiling protobuf files (e.g. by grpcio-tools)
BBCLASSEXTEND = "native nativesdk"

SKIP_RECIPE[python-protobuf] ?= "${@bb.utils.contains('I_SWEAR_TO_MIGRATE_TO_PYTHON3', 'yes', '', 'python2 is out of support for long time, read https://www.python.org/doc/sunset-python-2/ https://python3statement.org/ and if you really have to temporarily use this, then set I_SWEAR_TO_MIGRATE_TO_PYTHON3 to "yes"', d)}"

branch_name: refs/heads/jansa/master

gha_language: BitBake


text:
package memory_test

import (
	"context"
	"testing"
	"time"

	"github.com/pthethanh/micro/broker"
	"github.com/pthethanh/micro/broker/memory"
	"github.com/pthethanh/micro/encoding"
)

func TestBroker(t *testing.T) {
	b := memory.New(memory.Worker(100, 1000))
	defer b.Close(context.Background())
	type Person struct {
		Name string
		Age  int
	}
	topic := "test"
	if err := b.Open(context.Background()); err != nil {
		t.Fatalf("unexpected error: %v\n", err)
	}
	if err := b.CheckHealth(context.TODO()); err != nil {
		t.Fatalf("unexpected error: %v\n", err)
	}
	ch := make(chan broker.Event, 100)
	// sub without group
	sub, err := b.Subscribe(context.Background(), topic, func(msg broker.Event) error {
		if err := msg.Ack(); err != nil {
			t.Error(err)
		}
		ch <- msg
		return nil
	})
	if err != nil {
		t.Fatal(err)
	}
	defer sub.Unsubscribe()
	if sub.Topic() != topic {
		t.Errorf("got topic=%s, want topic=%s", sub.Topic(), topic)
	}
	// sub on the queue q1
	subGroup1, err := b.Subscribe(context.Background(), topic, func(msg broker.Event) error {
		ch <- msg
		return nil
	}, broker.Queue("q1"))
	if err != nil {
		t.Fatal(err)
	}
	defer subGroup1.Unsubscribe()
	// sub with the same group as the previous one - queue q1
	subGroup2, err := b.Subscribe(context.Background(), topic, func(msg broker.Event) error {
		ch <- msg
		return nil
	}, broker.Queue("q1"))
	if err != nil {
		t.Fatal(err)
	}
	defer subGroup2.Unsubscribe()
	want := Person{
		Name: "jack",
		Age:  22,
	}
	// send n messages
	n := 2
	for i := 0; i < n; i++ {
		m := broker.Must(broker.NewMessage(want, encoding.ContentTypeJSON, "message-type", "person"))
		if err := b.Publish(context.Background(), topic, m); err != nil {
			t.Fatal(err)
		}
	}
	// send another message to a topic no one subscribe should not impact to the result.
	m := broker.Must(broker.NewMessage(want, encoding.ContentTypeJSON, "message-type", "person"))
	if err := b.Publish(context.Background(), "other-topic", m); err != nil {
		t.Fatal(err)
	}
	cnt := 0
	timeout := time.After(50 * time.Millisecond)
	for {
		select {
		case e := <-ch:
			cnt++
			if e.Topic() != topic {
				t.Fatalf("got topic=%s, want topic=test", e.Topic())
			}
			got := Person{}
			if err := e.Message().UnmarshalBodyTo(&got); err != nil {
				t.Fatal(err)
			}
			if typ, ok := e.Message().Header["message-type"]; !ok || typ != "person" {
				t.Fatalf("got type=%s, want type=%s", typ, "person")
			}
		case <-timeout:
			// should received n*2 messages: sub get n, subGroup1 + subGroup2 = n
			if cnt != n*2 {
				t.Fatalf("got number of messages=%d, want number of messages=%d", cnt, n*2)
			}
			return
		}
	}
}

repository: pthethanh/micro

repo_name: pthethanh/micro


text:
package logic

import (
	"encoding/json"
	"fmt"
	"log"
	"net/url"
	"strconv"
	"time"

	"github.com/thiago-scherrer/gotrader/internal/api"
	"github.com/thiago-scherrer/gotrader/internal/central"
	"github.com/thiago-scherrer/gotrader/internal/convert"
	"github.com/thiago-scherrer/gotrader/internal/display"
	rd "github.com/thiago-scherrer/gotrader/internal/reader"
)

// Path from api to view the orderbook
const orb string = "/api/v1/orderBook/L2?"

// CandleRunner verify the api and start the logic system
func CandleRunner() string {
	t := rd.Threshold()
	c := rd.Candle()
	var tsl int
	var cby int

	for i := int64(0); i < t; i++ {
		for ii := int64(0); ii < c; ii++ {
			res := returnDepth()
			if res == "Buy" {
				cby++
			} else if res == "Sell" {
				tsl++
			} else {
				i = -1
			}
		}
	}

	if cby > tsl {
		return "Buy"
	} else if tsl > cby {
		return "Sell"
	}

	return "Draw"
}

func returnDepth() string {
	var sell int
	var buy int

	poh := "/api/v1/trade?"
	ap := rd.APIArray()
	t := timeStamp()
	d := rd.Data()

	u := url.Values{}
	u.Set("symbol", rd.Asset())
	u.Add("partial", "false")
	u.Add("count", "500")
	u.Add("reverse", "false")
	u.Add("filter", t)

	for index := 1; index <= 60; index++ {
		u.Set("start", strconv.Itoa(index))

		p := poh + u.Encode()
		res, code := api.ClientRobot("GET", p, d)

		if code != 200 {
			log.Println("Something wrong with api:", code, "Response: ", convert.BytesToString(res))
			time.Sleep(time.Duration(2) * time.Second)
		}

		err := json.Unmarshal(res, &ap)
		if err != nil {
			break
		}
		if len(res) <= 5 {
			break
		}

		for _, v := range ap[:] {
			if v.Side == "Sell" {
				sell = sell + v.Size
			} else if v.Side == "Buy" {
				buy = buy + v.Size
			}

		}
		time.Sleep(time.Duration(1) * time.Second)

	}

	return logicSystem(buy, sell)
}

func timeStamp() string {
	ctm := rd.Candle()

	t := time.Now().UTC().Add(time.Duration(-ctm) * time.Minute)

	date := t.Format("2006-01-02")

	time := t.Format("15:04")

	return `{"timestamp.date": "` + date + `", "timestamp.minute": "` + time + `" }`
}

func logicSystem(buy, sell int) string {
	if buy > sell {
		return "Buy"
	} else if sell > buy {
		return "Sell"
	}

	return "Draw"
}

func stopLossBuy(pst float64, price float64) bool {
	return price <= (pst - ((pst / 100) * rd.StopLoss()))
}

func stopLossSell(pst float64, price float64) bool {
	return price >= (pst + ((pst / 100) * rd.StopLoss()))
}

func closePositionBuy(pst float64, price float64) bool {
	return price >= (pst + ((pst / 100) * rd.Profit()))
}

func closePositionSell(pst float64, price float64) bool {
	return price <= (pst - ((pst / 100) * rd.Profit()))
}

func priceCloseBuy(price float64) string {
	priceClose := fmt.Sprintf("%2.f",
		(price + 0.5),
	)

	return priceClose
}

func priceCloseSell(price float64) string {
	priceClose := fmt.Sprintf("%2.f",
		(price - 0.5),
	)

	return priceClose
}

func lossTargetBuy(price float64) string {
	priceClose := fmt.Sprintf("%2.f",
		(price - 0.5),
	)

	return priceClose
}

func lossTargetSell(price float64) string {
	priceClose := fmt.Sprintf("%2.f",
		(price + 0.5),
	)

	return priceClose
}

// ClosePositionProfitBuy is responsible for closing a Buy order
func ClosePositionProfitBuy() {
	pst := central.GetPosition()

	for {
		price := central.Price()

		if closePositionBuy(pst, price) {
			profitTarget := priceCloseBuy(price)

			log.Println(display.OrdertriggerMsg(rd.Asset()))

			central.ClosePosition(profitTarget)
			if central.GetProfit() {
				break
			}
		} else if stopLossBuy(pst, price) {
			log.Println(display.StopLossMsg(rd.Asset()))

			central.ClosePosition(lossTargetBuy(price))
			if central.GetProfit() {
				break
			}
		}
		time.Sleep(time.Duration(10) * time.Second)
	}
}

// ClosePositionProfitSell is responsible for closing a Sell position
func ClosePositionProfitSell() {
	pst := central.GetPosition()

	for {
		price := central.Price()

		if closePositionSell(pst, price) {
			profitTarget := priceCloseSell(price)

			log.Println(display.OrdertriggerMsg(rd.Asset()))

			central.ClosePosition(profitTarget)
			if central.GetProfit() {
				break
			}
		} else if stopLossSell(pst, price) {
			log.Println(display.StopLossMsg(rd.Asset()))

			central.ClosePosition(lossTargetSell(price))
			if central.GetProfit() {
				break
			}
		}
		time.Sleep(time.Duration(10) * time.Second)
	}
}

repository: thiago-scherrer/gotrader

repo_name: thiago-scherrer/gotrader


text:
// Fill out your copyright notice in the Description page of Project Settings.

#include "BTDecorator_IsInRange.h"

#include "BehaviorTree/BlackboardComponent.h"
#include "Classes/AIController.h"

#include "Utilities/CustomMacros.h"

void UBTDecorator_IsInRange::OnGameplayTaskDeactivated(UGameplayTask& Task)
{

}

void UBTDecorator_IsInRange::OnGameplayTaskActivated(UGameplayTask& Task)
{

}

bool UBTDecorator_IsInRange::CalculateRawConditionValue(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) const
{
	UBlackboardComponent* BlackboardComponent = OwnerComp.GetBlackboardComponent();
	if (validate(IsValid(BlackboardComponent)) == false) return false;

	AAIController* Controller = OwnerComp.GetAIOwner();
	if (validate(IsValid(Controller)) == false) return false;

	AActor* ControlledPawn = Cast<AActor>(Controller->GetPawn());
	if (validate(IsValid(ControlledPawn)) == false) return false;

	AActor* Target = Cast<AActor>(BlackboardComponent->GetValueAsObject(GetSelectedBlackboardKey()));
	if (validate(IsValid(Target)) == false) return false;;

	if (FVector::Dist(ControlledPawn->GetActorLocation(), Target->GetActorLocation()) <= TargetDistance) {
		return true;
	}
	return false;
}


text:
require wt3.inc

PR = "${INC_PR}.1"

SRC_URI += "file://src.patch \
           "

do_configure_append() {
        ${BUILD_CXX} ${BUILD_CXXFLAGS} -o src/filetostring src/web/skeleton/FileToString.C
}

SRC_URI[tarball.md5sum] = "3d35c181dfab7dfd3fe898738dffb421"
SRC_URI[tarball.sha256sum] = "64e6bd25d18e838e1c60693eccbd11926c65b228d6ac69c4dafc7ebe7341dbbf"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty