text:
# ---------------------------------------------------------------
# Programmer:  Cody Balos @ LLNL
# ---------------------------------------------------------------
# SUNDIALS Copyright Start
# Copyright (c) 2002-2021, Lawrence Livermore National Security
# and Southern Methodist University.
# All rights reserved.
#
# See the top-level LICENSE and NOTICE files for details.
#
# SPDX-License-Identifier: BSD-3-Clause
# SUNDIALS Copyright End
# ---------------------------------------------------------------
# Based on the FindPackageMultipass module by Jed Brown.
# ---------------------------------------------------------------
# Copyright Jed Brown
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
#   notice, this list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above copyright
#   notice, this list of conditions and the following disclaimer in
#   the documentation and/or other materials provided with the
#   distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# ---------------------------------------------------------------
# PackageMultipass - this module defines two macros
#
# FIND_PACKAGE_MULTIPASS (Name CURRENT
#  STATES VAR0 VAR1 ...
#  DEPENDENTS DEP0 DEP1 ...)
#
#  This function creates a cache entry <UPPERCASED-Name>_CURRENT which
#  the user can set to "NO" to trigger a reconfiguration of the package.
#  The first time this function is called, the values of
#  <UPPERCASED-Name>_VAR0, ... are saved.  If <UPPERCASED-Name>_CURRENT
#  is false or if any STATE has changed since the last time
#  FIND_PACKAGE_MULTIPASS() was called, then CURRENT will be set to "NO",
#  otherwise CURRENT will be "YES".  IF not CURRENT, then
#  <UPPERCASED-Name>_DEP0, ... will be FORCED to NOTFOUND.
#  Example:
#    find_path (FOO_DIR include/foo.h)
#    FIND_PACKAGE_MULTIPASS (Foo foo_current
#      STATES DIR
#      DEPENDENTS INCLUDES LIBRARIES)
#    if (NOT foo_current)
#      # Make temporary files, run programs, etc, to determine FOO_INCLUDES and FOO_LIBRARIES
#    endif (NOT foo_current)
#
# MULTIPASS_SOURCE_RUNS (Name INCLUDES LIBRARIES SOURCE RUNS LANGUAGE)
#  Always runs the given test, use this when you need to re-run tests
#  because parent variables have made old cache entries stale. The LANGUAGE
#  variable is either C or CXX indicating which compiler the test should
#  use.
# ---------------------------------------------------------------

macro (FIND_PACKAGE_MULTIPASS _name _current)

  # convert the package name to all caps
  string (TOUPPER ${_name} _NAME)

  # copy all input args and remove _name and _current
  set (_args ${ARGV})
  list (REMOVE_AT _args 0 1)

  # initialize package status to current
  set (_states_current "YES")

  # check if the keyword STATES was input
  list (GET _args 0 _cmd)
  if (_cmd STREQUAL "STATES")

    # remove STATE from the args list and get the first state variable
    list (REMOVE_AT _args 0)
    list (GET _args 0 _state)

    # loop over the state variables until none are left or DEPENDENTS is reached
    while (_state AND NOT _state STREQUAL "DEPENDENTS")

      # get the name of the variable with the stored state variable value
      set (_stored_var PACKAGE_MULTIPASS_${_NAME}_${_state})

      # if the stored value is different from the current value, signal that
      # reconfiguration is necessary
      if (NOT "${${_stored_var}}" STREQUAL "${${_NAME}_${_state}}")
        set (_states_current "NO")
      endif ()

      # update the stored value
      set (${_stored_var} "${${_NAME}_${_state}}" CACHE INTERNAL "Stored state for ${_name}." FORCE)

      # remove the current state variable from the args list and get the next one
      list (REMOVE_AT _args 0)
      list (GET _args 0 _state)

    endwhile ()

  endif ()

  # get the name of the package status variable
  set (_stored ${_NAME}_CURRENT)

  # check if reconfiguration was requested
  if (NOT ${_stored})
    set (${_stored} "YES" CACHE BOOL "Is the configuration for ${_name} current?  Set to \"NO\" to reconfigure." FORCE)
    set (_states_current "NO")
  endif ()

  # set the output package status
  set (${_current} ${_states_current})

  # check the if dependent variables need to be cleared so that the calling
  # module can reset their values
  if (NOT ${_current} AND PACKAGE_MULTIPASS_${_name}_CALLED)

    message (STATUS "Clearing ${_name} dependent variables")

    # check if the keyword DEPENDENTS was input
    list (GET _args 0 _cmd)
    if (_cmd STREQUAL "DEPENDENTS")

      # remove the DEPENDENTS from the list
      list (REMOVE_AT _args 0)

      # clear the value of each dependent variable in the list
      foreach (dep ${_args})
        set (${_NAME}_${dep} "NOTFOUND" CACHE INTERNAL "Cleared" FORCE)
      endforeach ()

    endif ()

    # reset the package FOUND status
    set (${_NAME}_FOUND "NOTFOUND" CACHE INTERNAL "Cleared" FORCE)

  endif ()

  # signal that multipass has previously been called for this package
  set (PACKAGE_MULTIPASS_${_name}_CALLED YES CACHE INTERNAL "Private" FORCE)

endmacro (FIND_PACKAGE_MULTIPASS)

macro (MULTIPASS_SOURCE_RUNS includes libraries source runs language)
  # This is a ridiculous hack. CHECK_${language}_SOURCE_*
  # thinks that if the *name* of the return variable doesn't change,
  # then the test does not need to be re-run.  We keep an internal count
  # which we increment to guarantee that every test name is unique. If we've
  # gotten here, then the configuration has changed enough that the
  # test *needs* to be rerun.
  if (NOT MULTIPASS_TEST_COUNT)
    set (MULTIPASS_TEST_COUNT 00)
  endif (NOT MULTIPASS_TEST_COUNT)
  math (EXPR _tmp "${MULTIPASS_TEST_COUNT} + 1") # Why can't I add to a cache variable?
  set (MULTIPASS_TEST_COUNT ${_tmp} CACHE INTERNAL "Unique test ID")
  set (testname MULTIPASS_TEST_${MULTIPASS_TEST_COUNT}_${runs})
  set (testdir ${PROJECT_BINARY_DIR}/PETSC_test)
  if (NOT EXISTS ${testdir})
    file(MAKE_DIRECTORY ${testdir})
  endif ()
  set (CMAKE_REQUIRED_INCLUDES ${includes})
  set (CMAKE_REQUIRED_LIBRARIES ${libraries})
  # if MPI is available, use it for the test
  if (MPI_${language}_COMPILER)
    set (REQUIRED_COMPILER ${MPI_${language}_COMPILER})
  else ()
    set (REQUIRED_COMPILER ${CMAKE_${language}_COMPILER})
  endif ()
  if(${language} STREQUAL "C")
    set (extension c)
  else ()
    set (extension cxx)
  endif ()
  # Create simple test code
  file(WRITE ${testdir}/src.${extension} "${source}")
  # Create a CMakeLists.txt file for the test code
  file(WRITE ${testdir}/CMakeLists.txt
    "cmake_minimum_required(VERSION 3.5)\n"
    "project(ctest ${language})\n"
    "set(CMAKE_VERBOSE_MAKEFILE ON)\n"
    "set(CMAKE_${language}_COMPILER \"${REQUIRED_COMPILER}\")\n"
    "set(CMAKE_${language}_FLAGS \"${CMAKE_${language}_FLAGS}\")\n"
    "include_directories(${CMAKE_REQUIRED_INCLUDES})\n"
    "add_executable(ctest src.${extension})\n"
    "target_link_libraries(ctest ${CMAKE_REQUIRED_LIBRARIES})\n")
  # Attempt to compile the test code
  try_compile(${testname} ${testdir} ${testdir} ctest
    OUTPUT_VARIABLE _output)
  # Write output compiling the test code
  file(WRITE ${testdir}/src.out "${_output}")
  # To ensure we do not use stuff from the previous attempts,
  # we must remove the CMakeFiles directory.
  file(REMOVE_RECURSE ${testdir}/CMakeFiles)
  # Process test result
  if (${testname})
    set (${runs} TRUE)
  else ()
    set (${runs} FALSE)
  endif ()
  unset (_output)
endmacro (MULTIPASS_SOURCE_RUNS)

repository: ICB-DCM/parPE

repo_name: ICB-DCM/parPE


text:
inherit esw deploy

COMPATIBLE_MACHINE = ".*-zynqmp"

ESW_COMPONENT_SRC = "/lib/sw_apps/zynqmp_fsbl/src"

DEPENDS += "xilstandalone xiltimer xilffs xilsecure xilpm device-tree"

PSU_INIT = "${RECIPE_SYSROOT}/${includedir}/devicetree/psu_init*"

do_configure_prepend() {
    # Copy psu_init* files to fsbl source code
    cp ${PSU_INIT} ${S}/${ESW_COMPONENT_SRC}
}

do_install() {
    install -d ${D}/${base_libdir}/firmware
    # Note that we have to make the ELF executable for it to be stripped
    install -m 0755  ${B}/zynqmp_fsbl* ${D}/${base_libdir}/firmware
}

ZYNQMP_FSBL_BASE_NAME ?= "${BPN}-${PKGE}-${PKGV}-${PKGR}-${MACHINE}-${DATETIME}"
ZYNQMP_FSBL_BASE_NAME[vardepsexclude] = "DATETIME"

do_deploy() {

    # We need to deploy the stripped elf, hence why not doing it from ${D}
    install -Dm 0644 ${WORKDIR}/package/${base_libdir}/firmware/zynqmp_fsbl.elf ${DEPLOYDIR}/${ZYNQMP_FSBL_BASE_NAME}.elf
    ln -sf ${ZYNQMP_FSBL_BASE_NAME}.elf ${DEPLOYDIR}/${BPN}-${MACHINE}.elf
    ${OBJCOPY} -O binary ${WORKDIR}/package/${base_libdir}/firmware/zynqmp_fsbl.elf ${WORKDIR}/package/${base_libdir}/firmware/zynqmp_fsbl.bin
    install -m 0644 ${WORKDIR}/package/${base_libdir}/firmware/zynqmp_fsbl.bin ${DEPLOYDIR}/${ZYNQMP_FSBL_BASE_NAME}.bin
    ln -sf ${ZYNQMP_FSBL_BASE_NAME}.bin ${DEPLOYDIR}/${BPN}-${MACHINE}.bin
}

addtask deploy before do_build after do_package

CFLAGS_append_aarch64 = " -DARMA53_64"
CFLAGS_append_armrm = " -DARMR5"

FILES_${PN} = "${base_libdir}/firmware/zynqmp_fsbl*"

license: MIT

license_type: permissive

branch_name: refs/heads/master

gha_license_id: MIT

extension: bb


text:
package gmws

import (
	"testing"

	. "github.com/smartystreets/goconvey/convey"
	"github.com/svvu/gomws/mwsHttps"
)

var testConfig = MwsConfig{
	SellerId:  "SellerA",
	AuthToken: "Authtoken",
	Region:    "US",
	AccessKey: "accesskey",
	SecretKey: "secretKey",
}

func TestNewMwsBase(t *testing.T) {
	Convey("When Region is not provide", t, func() {
		testConfig.Region = ""
		client, _ := NewMwsBase(testConfig, "V1", "Test")

		Convey("Region defualt to US", func() {
			So(client.Region, ShouldEqual, "US")
		})

		testConfig.Region = "US"
	})

	Convey("When Unknow Region is provide", t, func() {
		testConfig.Region = "UnKnown"
		client, err := NewMwsBase(testConfig, "V1", "Test")

		Convey("Nil Client returned", func() {
			So(client, ShouldBeNil)
		})

		Convey("MarketPlace error returned", func() {
			So(err, ShouldNotBeNil)
			So(err.Error(), ShouldEqual, "Invalid region: UnKnown")
		})

		testConfig.Region = "US"
	})

	Convey("When Seller Id is not provide", t, func() {
		testConfig.SellerId = ""
		client, err := NewMwsBase(testConfig, "V1", "Test")

		Convey("Nil Client returned", func() {
			So(client, ShouldBeNil)
		})

		Convey("Seller id error returned", func() {
			So(err, ShouldNotBeNil)
			So(err.Error(), ShouldEqual, "No seller id provided")
		})

		testConfig.SellerId = "SellerA"
	})

	Convey("When AuthToken is not provide", t, func() {
		testConfig.AuthToken = ""
		client, err := NewMwsBase(testConfig, "V1", "Test")

		Convey("Nil Client returned", func() {
			So(client, ShouldBeNil)
		})

		Convey("Auth token error returned", func() {
			So(err, ShouldNotBeNil)
			So(err.Error(), ShouldEqual, "No auth token provided")
		})

		testConfig.AuthToken = "authtoken"
	})

	Convey("Valid configuration", t, func() {
		client, err := NewMwsBase(testConfig, "V1", "Test")

		Convey("No err returned", func() {
			So(err, ShouldBeNil)
		})

		Convey("New client returned", func() {
			So(client, ShouldNotBeNil)
		})
	})
}

func TestPath(t *testing.T) {
	Convey("Client has name and version", t, func() {
		client, _ := NewMwsBase(testConfig, "V1", "Test")
		path := client.Path()

		Convey("Path with name and version returned", func() {
			So(path, ShouldEqual, "/Test/V1")
		})
	})

	Convey("Client only has name", t, func() {
		client, _ := NewMwsBase(testConfig, "", "Test")
		path := client.Path()

		Convey("Path with name retuend", func() {
			So(path, ShouldEqual, "/Test")
		})
	})

	Convey("Client only has version", t, func() {
		client, _ := NewMwsBase(testConfig, "V1", "")
		path := client.Path()

		Convey("Path with version retuend", func() {
			So(path, ShouldEqual, "/V1")
		})
	})
}

func TestSignatureMethod(t *testing.T) {
	Convey("Signature method HmacSHA256 returned", t, func() {
		client, _ := NewMwsBase(testConfig, "V1", "Test")
		sm := client.SignatureMethod()
		So(sm, ShouldEqual, "HmacSHA256")
	})
}

func TestSignatureVersion(t *testing.T) {
	Convey("Signature version 2 returned", t, func() {
		client, _ := NewMwsBase(testConfig, "V1", "Test")
		sv := client.SignatureVersion()
		So(sv, ShouldEqual, "2")
	})
}

func TestParamsToAugment(t *testing.T) {
	Convey("Expected info returned", t, func() {
		client, _ := NewMwsBase(testConfig, "V1", "Test")
		pta := client.paramsToAugment()
		So(pta["SellerId"], ShouldEqual, testConfig.SellerId)
		So(pta["MWSAuthToken"], ShouldEqual, testConfig.AuthToken)
		So(pta["SignatureMethod"], ShouldEqual, "HmacSHA256")
		So(pta["SignatureVersion"], ShouldEqual, "2")
		So(pta["AWSAccessKeyId"], ShouldEqual, testConfig.AccessKey)
		So(pta["Version"], ShouldEqual, "V1")
	})
}

func TestGetCredential(t *testing.T) {
	Convey("Client have access key and secret key", t, func() {
		client, _ := NewMwsBase(testConfig, "V1", "Test")
		credential := client.getCredential()

		Convey("Keys from client retured", func() {
			So(credential.AccessKey, ShouldEqual, testConfig.AccessKey)
			So(credential.SecretKey, ShouldEqual, testConfig.SecretKey)
		})
	})

	// TODO
	// Add test for get credential from env
}

func TestHttpClient(t *testing.T) {
	client, _ := NewMwsBase(testConfig, "V1", "Test")
	params := mwsHttps.NewValues()
	httpClient := client.HTTPClient(params)

	Convey("Http client has expected host", t, func() {
		So(httpClient.Host, ShouldEqual, "mws.amazonservices.com")
	})

	Convey("Http client has expected path", t, func() {
		So(httpClient.Path, ShouldEqual, "/Test/V1")
	})
}

extension: go


text:
require foxtrotgps.inc

SRC_URI[md5sum] = "1b9f5959740e3bbeb4b232aa7f0fcbee"
SRC_URI[sha256sum] = "24f789294ae4f4251adccdb5f0c677b3fd6dea9bce2b6a17497f87a0dc3d056a"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
@article{Bruckdorfer,
    author    = {T. Bruckdorfer and
               S. Cornelsen and
               C. Gutwenger and
               M. Kaufmann and
               F. Montecchiani and
               M. N{\"{o}}llenburg and
               A. Wolff},
    title     = {Progress on Partial Edge Drawings},
    journal   = {CoRR},
    volume    = {abs/1209.0830},
    year      = {2012},
    url       = {http://arxiv.org/abs/1209.0830},
    archivePrefix = {arXiv},
    eprint    = {1209.0830},
}

@article{Becker,
    author    = {R. A. {Becker} and
               S. G. {Eick} and
               A. R. {Wilks}},
    journal   = {IEEE Transactions on Visualization and Computer Graphics},
    title     = {Visualizing network data},
    year      = {1995},
    url       = {https://ieeexplore.ieee.org/document/468391},
    volume    = {1},
    number    = {1},
    pages     = {16-28},
}

@inproceedings{Burch,
    author = {M. Burch and
            C. Vehlow and
            N. Konevtsova and
            D. Weiskopf},
    title  = {Evaluating Partially Drawn Links for Directed Graph Edges},
    booktitle  = {Lecture Notes in Computer Science},
    year   = {2012},
    publisher = {Springer Berlin Heidelberg},
    volume = {7034},
}

@inproceedings{BK,
    author    = {T. Bruckdorfer and
                 M. Kaufmann},
    title     = {Mad at Edge Crossings? Break the Edges!},
    booktitle = {Fun with Algorithms},
    year      = {2012},
    publisher = {Springer Berlin Heidelberg},
    address   = {Berlin, Heidelberg},
    pages     = {40--50},
}

@article{Erdos,
    author = {P. Erd\H{o}s and
              G. Szekeres},
    journal = {Compositio Mathematica},
    keywords = {Geometry},
    language = {eng},
    pages = {463-470},
    publisher = {Johnson Reprint Corporation},
    title = {A combinatorial problem in geometry},
    url = {http://eudml.org/doc/88611},
    volume = {2},
    year = {1935},
}

repository: LorRF/pedestrian-detection

repo_name: LorRF/pedestrian-detection

branch_name: refs/heads/main

extension: bib


text:
require dsplink.inc

INSANE_SKIP_ti-codec-engine-apps = True
INSANE_SKIP_ti-dsplink-apps = True
INSANE_SKIP_${PN} = True

DESCRIPTION = "Codec Engine for TI ARM/DSP processors"

DEPENDS = "virtual/kernel perl-native"
RDEPENDS = "update-modules"

inherit module

# tconf from xdctools dislikes '.' in pwd :/
PV = "221"

# Get CE tarball from TI website, place in sources and calculate
# md5sum
# Look for tarball at https://www-a.ti.com/downloads/sds_support/targetcontent/CE/index.html

SRC_URI = "http://install.tarball.in.source.dir/codec_engine_2_21.tar.gz \
           file://cmem-class-device-27-and-sched-include-fix.patch;patch=1 \
           file://sdma-class-device-and-includes-fix.patch;patch=1 \
           file://dsplink-semaphore-27.patch;patch=1 \
           file://dsplink-add-class-device-create-support.patch;patch=1 \
           file://lpm-device-create-and-semaphore-include-fix.patch;patch=1 \
           file://lpm-make-symbol-warnings-fix.patch;patch=1 \
           file://Makefile-dsplink-gpp \
           file://Makefile-dsplink-dsp \
           file://loadmodules-ti-dsplink-apps.sh \
           file://unloadmodules-ti-dsplink-apps.sh \
           file://loadmodules-ti-codec-engine-apps.sh \
           file://unloadmodules-ti-codec-engine-apps.sh \
"

S = "${WORKDIR}/codec_engine_2_21"

require ti-paths.inc

export DSPLINK="${S}/cetools/packages/dsplink"

PARALLEL_MAKE = ""

# the include files on top define do_compile for the submodules
do_compile_append() {

#dsplink already done from inclusion of require dsplink.inc

#lpm bits
	if [ -e ${S}/cetools/packages/ti/bios/power/ ] ; then

		# Build the DSP power manager kernel module
		cd ${S}/cetools/packages/ti/bios/power/modules/${DSPPOWERSOC}/lpm

		# Still need to move this into the patch file
		if [ $(echo ${KERNEL_VERSION} | cut -c5,6) -gt 26 ] ; then
			sed -i -e s:asm/semaphore:linux/semaphore: lpm_driver.c
		fi

		#what is this for?
		rm -f *o

		# lpm also needs KERNEL_INSTALL_DIR and MVTOOL_PREFIX which come from ti-paths.inc
		export DSPLINK_REPO=${DSPLINK}/..
		# should move the clean step into the clean stage..
		#oe_runmake clean
		oe_runmake
	fi

#cmemk bits
	if [ -e ${S}/cetools/packages/ti/sdo/linuxutils/cmem ] ; then
                echo "MVTOOL_PREFIX=${TARGET_PREFIX}" > ${S}/Rules.make
                echo "UCTOOL_PREFIX=${TARGET_PREFIX}" >> ${S}/Rules.make
                echo "LINUXKERNEL_INSTALL_DIR=${STAGING_KERNEL_DIR}"  >> ${S}/Rules.make
                #export DSPLINK=${STAGING_DIR}/${MULTIMACH_TARGET_SYS}/dsplink

		# Build the cmem kernel module and associated test apps
		# We unset CFLAGS because kernel modules need different ones, this is basically a verbatim copy of kernel.bbclass and module-base.bbclass
		unset CFLAGS CPPFLAGS CXXFLAGS LDFLAGS

		cd ${S}/cetools/packages/ti/sdo/linuxutils/cmem
		oe_runmake clean
		oe_runmake KERNEL_PATH=${STAGING_KERNEL_DIR}   \
   	        KERNEL_SRC=${STAGING_KERNEL_DIR}    \
   	        KERNEL_VERSION=${KERNEL_VERSION}    \
   	        CC="${KERNEL_CC}" LD="${KERNEL_LD}" \
   	        AR="${KERNEL_AR}"
	fi

#sdma bits
        if [ -e ${S}/cetools/packages/ti/sdo/linuxutils/sdma ] ; then
               echo "MVTOOL_PREFIX=${TARGET_PREFIX}" > ${S}/Rules.make
               echo "UCTOOL_PREFIX=${TARGET_PREFIX}" >> ${S}/Rules.make
               echo "LINUXKERNEL_INSTALL_DIR=${STAGING_KERNEL_DIR}"  >> ${S}/Rules.make

                # Build the sdma kernel module and associated test apps
                # We unset CFLAGS because kernel modules need different ones, this is basically a verbatim copy of kernel.bbclass and module-base.bbclass
                unset CFLAGS CPPFLAGS CXXFLAGS LDFLAGS

                cd ${S}/cetools/packages/ti/sdo/linuxutils/sdma
                oe_runmake clean
                oe_runmake KERNEL_PATH=${STAGING_KERNEL_DIR}   \
                KERNEL_SRC=${STAGING_KERNEL_DIR}    \
                KERNEL_VERSION=${KERNEL_VERSION}    \
                CC="${KERNEL_CC}" LD="${KERNEL_LD}" \
                AR="${KERNEL_AR}"
        fi

#need to add other modules here, like IRQ, etc

#now build the CE examples
	cd ${S}/examples

	# Fix paths to arm crosstools, c6x codegen and x86 gcc
	# Also disable uclibc and x86 builds
	sed -i -e s:/db/toolsrc/library/tools/vendors/cs/arm/arm-2007q3:${CROSS_DIR}:g \
        -e s:/db/toolsrc/library/tools/vendors/ti/c6x/6.0.16/Linux:${TITOOLSDIR}/${TICGTOOLSDIR}:g \
        -e s:/db/toolsrc/library/tools/vendors/opensource/gcc/4.1.0/Linux/gcc-4.1.0-glibc-2.3.6/i686-unknown-linux-gnu:/usr:g \
        -e s:arm-none-linux-gnueabi-:${TARGET_PREFIX}:g \
        -e 's:true, // build for uC Linux:false,:g' \
        -e 's:true,  // build for PC Linux:false,:g' \
        ${S}/examples/user.bld

        # For now, remove all targets, except dm6446 and omap3530
        sed -i \
        -e '/evmDM357/d' \
        -e '/evmDM6446/d' \
        -e '/evmDM6467/d' \
        -e '/evmDM355/d' \
        -e '/evmDM6437/d' \
        -e '/evmDM648/d' \
        -e '/sdp3430/d' \
        -e '/evm2530/d' \
        ${S}/examples/user.bld

	# Fix path to c6x codegen
	sed -i -e s:/db/toolsrc/library/tools/vendors/ti/c6x/6.0.16/Linux:${TITOOLSDIR}/${TICGTOOLSDIR}:g \
	        xdcpaths.mak

	# Start building the CE examples: codecs, extensions, servers (codec bundles) and ARM side apps
	# the DSP side uses CC to point to the c6x codegen, but would get the gcc tool
	unset CC

	# Make clean doesn't do what you'd expect, it only cleans stuff you've enabled, so some cruft remains

	# First clean
	for i in codecs extensions servers apps ; do
		make -e -C ${S}/examples/ti/sdo/ce/examples/$i clean
	done

	# Then build the examples
	for i in codecs extensions servers apps ; do
		make -e -C ${S}/examples/ti/sdo/ce/examples/$i
	done
}

do_install_append () {
    #driver - kernel module
	install -d ${D}/lib/modules/${KERNEL_VERSION}/kernel/drivers/dsp
        cp ${S}/cetools/packages/ti/bios/power/modules/${DSPPOWERSOC}/lpm/*.ko ${D}/lib/modules/${KERNEL_VERSION}/kernel/drivers/dsp || true
	cp ${S}/cetools/packages/ti/sdo/linuxutils/cmem/src/module/cmemk.ko ${D}/lib/modules/${KERNEL_VERSION}/kernel/drivers/dsp || true
        cp ${S}/cetools/packages/ti/sdo/linuxutils/sdma/src/module/sdmak.ko ${D}/lib/modules/${KERNEL_VERSION}/kernel/drivers/dsp || true

    #library
	#install -d ${D}/${libdir}
	#install -m 0755 ${DSPLINK}/gpp/BUILD/EXPORT/RELEASE/dsplink.lib  ${D}/${libdir}

    #sample apps - this is very 64x / v5T specific at the moment - we really need CE to give us this list...
	install -d ${D}/${datadir}/ti-codec-engine
	# we change pwd so that find gives us relative path to the files, which we use to create the same structure on the target
	cd ${S}/examples/ti/sdo/ce

    #test app module un/load scripts
	install ${WORKDIR}/loadmodules-ti-dsplink-apps.sh ${D}/${datadir}/ti-dsplink
	install ${WORKDIR}/unloadmodules-ti-dsplink-apps.sh ${D}/${datadir}/ti-dsplink

    #ce samples
	# first find all the app files named '.out'
	for i in $(find . -name "*.out") ; do
		# first create the directory
		install -d ${D}/${datadir}/ti-codec-engine/`dirname ${i}`
		# now copy the file
		install ${i} ${D}/${datadir}/ti-codec-engine/`dirname ${i}`
	done

	# next find all the app files named '.xv5T'
	for i in $(find . -name "*.xv5T") ; do
		# first create the directory
		install -d ${D}/${datadir}/ti-codec-engine/`dirname ${i}`
		# now copy the file
		install ${i} ${D}/${datadir}/ti-codec-engine/`dirname ${i}`
	done

	# then find all the app/server files named '.x64P'
	for i in $(find . -name "*.x64P") ; do
		# first create the directory
		install -d ${D}/${datadir}/ti-codec-engine/`dirname ${i}`
		# now copy the file
		install ${i} ${D}/${datadir}/ti-codec-engine/`dirname ${i}`
	done

	# finally find all the app files named '.dat'
	for i in $(find . -name "*.dat") ; do
		# first create the directory
		install -d ${D}/${datadir}/ti-codec-engine/`dirname ${i}`
		# now copy the file
		install ${i} ${D}/${datadir}/ti-codec-engine/`dirname ${i}`
	done

    #test app module un/load scripts
	install ${WORKDIR}/loadmodules-ti-codec-engine-apps.sh ${D}/${datadir}/ti-codec-engine
	install ${WORKDIR}/unloadmodules-ti-codec-engine-apps.sh ${D}/${datadir}/ti-codec-engine

	# we should install the CMEM apps as well here

	# finally, strip targets that we're not supporting here
	# - TODO...
}

PACKAGES =+ "ti-lpm-module ti-cmem-module ti-sdma-module ti-codec-engine-apps"

FILES_ti-lpm-module = "/lib/modules/${KERNEL_VERSION}/kernel/drivers/dsp/*lpm*ko"
FILES_ti-cmem-module = "/lib/modules/${KERNEL_VERSION}/kernel/drivers/dsp/cmemk.ko"
FILES_ti-sdma-module = "/lib/modules/${KERNEL_VERSION}/kernel/drivers/dsp/sdmak.ko"
FILES_ti-codec-engine-apps = "${datadir}/ti-codec-engine/*"

pkg_postinst_ti-lpm-module () {
	if [ -n "$D" ]; then
		exit 1
	fi
	depmod -a
	update-modules || true
}

pkg_postrm_ti-lpm-module () {
	update-modules || true
}

pkg_postinst_ti-cmem-module () {
	if [ -n "$D" ]; then
                exit 1
        fi
        depmod -a
        update-modules || true
}

pkg_postrm_ti-cmem-module () {
        update-modules || true
}

pkg_postinst_ti-sdma-module () {
        if [ -n "$D" ]; then
                exit 1
        fi
        depmod -a
        update-modules || true
}

pkg_postrm_ti-sdma-module () {
        update-modules || true
}

INHIBIT_PACKAGE_STRIP = "1"

PACKAGE_ARCH = "${MACHINE_ARCH}"

#legacy upgrade helpers
RPROVIDES_ti-cmem-module += "ti-cmemk-module"
RREPLACES_ti-cmem-module += "ti-cmemk-module"

# ti-dsplink-module can be built by either codec-engine or standalone dsplink - tell it to use this one, else unwanted dependence
PREFERRED_PROVIDER_ti-dsplink-module = "ti-codec-engine"

#add run-time dependencies - note for kernel module we can only use RRECOMMENDS, since modules might be built into the kernel
RRECOMMENDS_ti-codec-engine-apps += "ti-dsplink-module ti-lpm-module ti-cmem-module ti-sdma-module"


text:
DESCRIPTION = "ARM Trusted Firmware"

LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://license.md;md5=829bdeb34c1d9044f393d5a16c068371"

PACKAGE_ARCH = "${MACHINE_ARCH}"

inherit deploy

DEPENDS += "u-boot-mkimage-native"

S = "${WORKDIR}/git"

BRANCH = "master"
SRC_URI = "git://github.com/Xilinx/arm-trusted-firmware.git;protocol=https;branch=${BRANCH}"

# This points at the 'xilinx-v2016.2' tag
SRCREV ?= "1058495c23e3c759c1c3785432b4d8eaa4fc7340"

PV = "1.2+xilinx+git${SRCPV}"

COMPATIBLE_MACHINE = "zynqmp"
PLATFORM_zynqmp = "zynqmp"

# requires CROSS_COMPILE set by hand as there is no configure script
export CROSS_COMPILE="${TARGET_PREFIX}"

# Let the Makefile handle setting up the CFLAGS and LDFLAGS as it is a standalone application
CFLAGS[unexport] = "1"
LDFLAGS[unexport] = "1"
AS[unexport] = "1"
LD[unexport] = "1"

do_configure() {
	:
}

do_compile() {
	oe_runmake PLAT=${PLATFORM} RESET_TO_BL31=1 bl31
}

do_install() {
	:
}

do_deploy() {
	install -d ${DEPLOYDIR}
	install -m 0644 ${S}/build/${PLATFORM}/release/bl31/bl31.elf ${DEPLOYDIR}/bl31-${MACHINE}.elf
	install -m 0644 ${S}/build/${PLATFORM}/release/bl31.bin ${DEPLOYDIR}/bl31-${MACHINE}.bin
	mkimage -A arm64 -O linux -T kernel -C none -a 0xfffe5000 -e 0xfffe5000 -d ${S}/build/${PLATFORM}/release/bl31.bin ${DEPLOYDIR}/atf.ub
}
addtask deploy before do_build after do_compile

repository: hdmartinezv/meta-xilinx

repo_name: hdmartinezv/meta-xilinx


text:
@article{taatjes2017hydroxyacetone,
 author = {Taatjes, Craig A and Liu, Fang and Rotavera, Brandon and Kumar, Manoj and Caravan, Rebecca and Osborn, David L and Thompson, Ward H and Lester, Marsha I},
 day = {21},
 doi = {https://doi.org/10.1021/acs.jpca.6b07712},
 journal = {The Journal of Physical Chemistry A},
 month = {12},
 number = {1},
 pages = {16--23},
 publisher = {ACS Publications},
 title = {Hydroxyacetone production from C$_3$ Criegee intermediates},
 volume = {121},
 year = {2017}
}


text:
add_library(Qt5::QM3uPlaylistPlugin MODULE IMPORTED)

_populate_Multimedia_plugin_properties(QM3uPlaylistPlugin RELEASE "playlistformats/libqtmultimedia_m3u.dylib")
_populate_Multimedia_plugin_properties(QM3uPlaylistPlugin DEBUG "playlistformats/libqtmultimedia_m3u.dylib")

list(APPEND Qt5Multimedia_PLUGINS Qt5::QM3uPlaylistPlugin)

repository: timi-liuliang/echo

repo_name: timi-liuliang/echo

extension: cmake


text:
package main

import (
	"github.com/prometheus/client_golang/prometheus"
)

const (
	cvnStatsBlocks = 10
)

var (
	// blockchain related
	mCurrentHeight = prometheus.NewGauge(prometheus.GaugeOpts{
		Name:      "current_height",
		Subsystem: "faircoin",
		Help:      "Height of the block chain",
	})

	mLastBlockTimestamp = prometheus.NewGauge(prometheus.GaugeOpts{
		Name:      "last_block_timestamp",
		Subsystem: "faircoin",
		Help:      "Timestamp of the last block",
	})

	mLastBlockHeardTimestamp = prometheus.NewGauge(prometheus.GaugeOpts{
		Name:      "last_block_heard_timestamp",
		Subsystem: "faircoin",
		Help:      "Timestamp the last block was heard",
	})

	// cvn related
	mCvnCount = prometheus.NewGauge(prometheus.GaugeOpts{
		Name:      "cvn_count",
		Subsystem: "faircoin",
		Help:      "How many CVNs are registered",
	})

	mLastBlockSigned = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name:      "cvn_last_block_signed",
			Subsystem: "faircoin",
			Help:      "Was the last block signed by a CVN",
		},
		[]string{"node_id"})
)

func registerMetrics() {
	prometheus.MustRegister(mCurrentHeight)
	prometheus.MustRegister(mLastBlockTimestamp)
	prometheus.MustRegister(mLastBlockHeardTimestamp)

	prometheus.MustRegister(mCvnCount)
	prometheus.MustRegister(mLastBlockSigned)
}


text:
package peerwatch

import (
	"fmt"
	"sort"
)

// podSet will hold set of ready pods' ip addresses
type podSet map[string]bool

func (podSet podSet) Keys() []string {
	keys := make([]string, len(podSet))
	i := 0
	for key := range podSet {
		keys[i] = key
		i++
	}
	sort.Strings(keys)
	return keys
}

func (podSet podSet) String() string {
	return fmt.Sprintf("%v", podSet.Keys())
}

repository: gleez/peer-watch

repo_name: gleez/peer-watch


text:
@Book{SantosMartinetal2014EcosystemsBiodiversity,
  title = {Ecosystems and biodiversity for human wellbeing. {{Spanish National Ecosystem Assessment}}. {{Synthesis}} of key findings.},
  author = {Fernando Santos-Mart{\a'\i}n and Carlos Montes and Berta Mart{\a'\i}n-L{\a'o}pez and Jos{\a'e} A. Gonz{\a'a}lez and Mateo Aguado and Javier Benayas and Concepci{\a'o}n Pi{\~n}eiro and Jorge Navacerrada and Pedro Zorrilla and Marina Garc{\a'\i}a Llorente and Irene Iniesta and Elisa Oteros and Ignacio Palomo and C{\a'e}sar L{\a'o}pez Santiago and Paloma Alcorlo and M{\textordfeminine} Rosario Vidal and Viviana L{\a'o}pez and Diana Forero and Francisco D{\a'\i}az Pineda and Bel{\a'e}n Acosta Gallo and M. Royo Ayuso and D. Ruiz-Labourdette and Alfonso San Miguel Ayanz and Ram{\a'o}n Perea Garc{\a'\i}a-Calvo and Sonia Roig G{\a'o}mez and Mariana Fern{\a'a}ndez Olalla and Miguel {\a'A}. {\a'A}lvarez Garc{\a'\i}a and Jos{\a'e} Valent{\a'\i}n Roces D{\a'\i}az and Laura Garc{\a'\i}a De La Fuente and Arturo Colina Vuelta and Pedro {\a'A}lvarez {\a'A}lvarez and {\a'U}rsula Garc{\a'\i}a Rubio and Federico Fillat Estaqu{\a'e} and Javier Aguirre and Ferr{\a'a}n Paun{\a'e} and Cristian Fondevilla and Regino Zamora Rodr{\a'\i}guez and Ricardo A. Moreno Llorca and Pablo Gonz{\a'a}lez Moreno and Irene Navarro Gonz{\a'a}lez and Francisco J. Bonet Garc{\a'\i}a and Antonio J. P{\a'e}rez Luque and M{\textordfeminine} Luisa Su{\a'a}rez Alonso and Francisca Carre{\~n}o and Javier Mart{\a'\i}nez L{\a'o}pez and C{\a'e}sar Borja Barrera and M{\a'a}ximo Flor{\a'\i}n Beltr{\a'a}n and Antonio Camacho and Marisol Manzano and Lu{\a'\i}s Javier Lamb{\a'a}n and Juan Manuel Barrag{\a'a}n and Francisco Borja Barrera and Carlos M. Duarte and Inma F{\a'e}rriz Murillo and Laura Royo Mar{\a'\i} and Jos{\a'e} M{\textordfeminine} Fern{\a'a}ndez-Palacios and Giuseppe Nerilli and Agust{\a'\i}n Naranjo Cigala and Juan Puig De F{\a'a}bregas Tom{\a'a}s and M{\textordfeminine} Eugenia S{\a'a}nchez Cruz and Juan Carlos Barrios and {\a'O}scar Carpintero and Carmelo Marc{\a'e}n Albero and Mar{\a'\i}a Z{\a'u}{\~n}iga Ant{\a'o}n and {\a'A}ngel Pueyo Campos and Yayo Herrero and Emilio Men{\a'e}ndez and Marga G{\a'o}mez-Reino and Carlos Taibo and Jorge Riechmann and Miren Onaindia and Igone Palacios and Izaskun Casado-Arzuaga and Xabier Arana and Iosu Madariaga and Antonio Castro and B{\a'a}rbara Willarts and Mar{\a'\i}a Del Mar Bayo and Pedro Aguilera and {Pedro} and Antonio G{\a'o}mez Sal},
  year = {2014},
  publisher = {{Ministerio de Agricultura, Alimentación y Medio Ambiente}},
  url = {http://rgdoi.net/10.13140/2.1.2415.1842},
  doi = {10.13140/2.1.2415.1842},
  date = {2014-01-01},
}

repository: ajpelu/ajperez

repo_name: ajpelu/ajperez


text:
SUMMARY = "All packages required for musician image"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

# fluidsynth-bin gets dynamically renamed
PACKAGE_ARCH = "${TUNE_PKGARCH}"

inherit packagegroup

RDEPENDS:${PN} = " \
    musicians-world \
    mixxx \
    qmmp \
    alsa-utils alsa-utils-scripts \
    jack-utils \
    pulseaudio-module-alsa-card \
    pulseaudio-module-jack-sink \
    pulseaudio-module-jack-source \
    pulseaudio-module-jackdbus-detect \
    sox \
    a2jmidid \
    fluidsynth-bin \
    xfce4-mixer \
"

repository: ZeraGmbH/meta-mortsgna

repo_name: ZeraGmbH/meta-mortsgna


text:
package service

import (
	"github.com/gin-gonic/gin"
	"github.com/godcong/ipfs-node-service/config"
	"github.com/micro/go-micro/registry/consul"

	"github.com/micro/go-web"
	log "github.com/sirupsen/logrus"
	"io/ioutil"
	"net/http"
	"path/filepath"
	"strings"
)

// ContentTypeJSON ...
const ContentTypeJSON = "application/json"

// RestServer ...
type RestServer struct {
	*gin.Engine
	config *config.Configure
	//server *http.Server
	service web.Service
	Port    string
}

// NewRestServer ...
func NewRestServer(cfg *config.Configure) *RestServer {
	s := &RestServer{
		Engine: gin.Default(),
		config: cfg,
		Port:   config.DefaultString(cfg.Node.REST.Port, ":7787"),
	}
	return s
}

// Start ...
func (s *RestServer) Start() {
	if !s.config.Node.EnableREST {
		return
	}
	reg := consul.NewRegistry()
	s.service = web.NewService(
		web.Name("vlavr.rest.node"),
		web.Registry(reg),
	)

	_ = s.service.Init()

	Router(s.Engine)

	s.service.Handle("/", s.Engine)

	//s.server = &http.Server{
	//	Addr:    s.Port,
	//	Handler: s.Engine,
	//}
	go func() {
		//log.Printf("Listening and serving HTTP on %s\n", s.Port)
		//if err := s.server.ListenAndServe(); err != nil {
		//	log.Printf("Httpserver: ListenAndServe() error: %s", err)
		//}
		// Run server
		if err := s.service.Run(); err != nil {
			log.Fatal(err)
		}
	}()

}

// Stop ...
func (s *RestServer) Stop() {
	//if err := s.server.Shutdown(nil); err != nil {
	//	panic(err) // failure/timeout shutting down the server gracefully
	//}
}

type restBack struct {
	BackURL string
	Version string
}

// NewRestBack ...
func NewRestBack(cfg *config.Configure) StreamerCallback {
	return &restBack{
		BackURL: config.DefaultString(cfg.Callback.BackAddr, "localhost:7780"),
		Version: config.DefaultString(cfg.Callback.Version, "v0"),
	}
}

// Callback ...
func (s *restBack) Callback(result *QueueResult) error {
	back := filepath.Join(CheckPrefix(s.BackURL), s.Version, "node/callback")
	log.Println(back)

	resp, err := http.Post(back, ContentTypeJSON, strings.NewReader(result.JSON()))
	if err != nil {
		log.Println(err)
		return err
	}
	bytes, err := ioutil.ReadAll(resp.Body)
	log.Println(string(bytes), err)
	return err
}

// CheckPrefix ...
func CheckPrefix(url string) string {
	if strings.Index(url, "http") != 0 {
		return "http://" + url
	}
	return url
}

// JSON ...
func JSON(code int, msg string, detail ...gin.H) gin.H {
	if detail == nil {
		return gin.H{
			"code": code,
			"msg":  msg,
		}
	}
	return gin.H{
		"code":   code,
		"msg":    msg,
		"detail": detail[0],
	}
}

repository: godcong/ipfs-node-service

repo_name: godcong/ipfs-node-service


text:
@article{Henneman2019rev,
 author = {Henneman, Lucas RF and Dedoussi, Irene C and Casey, Joan and Choirat, Christine and Zigler, Corwin},
 doi = {https://doi.org/10.1038/s41370-020-0219-1},
 file = {:Users/lhenneman/Dropbox/Harvard/Papers/Hennemanetal2020.pdf:pdf},
 journal = {Journal of Exposure Science and Environmental Epidemiology},
 title = {Comparisons of simple and complex methods for quantifying exposure to point source air pollution emissions},
 year = {2020}
}

repository: lhenneman/WebsiteHugo

repo_name: lhenneman/WebsiteHugo


text:
KBRANCH ?= "dev-4.6"
LINUX_VERSION ?= "4.6"
SRCREV="6bf0b62ef667270f8a8cce46abc6c1f9b68785a5"

require linux-obmc.inc

gha_language: Python


text:
DESCRIPTION = "Basic code for QT compilation testing"
SECTION = "extras"
LICENSE = "GPLv2+ & LGPLv2.1+"
PR = "r0"
LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0;md5=801f80980d171dd6425610833a22dbe6"

inherit systemd externalsrc
EXTERNALSRC_pn-st-etal-strade = "${ST_LOCAL_SRC}st-etal/strade"

inherit pkgconfig

include recipes-qt/qt5/qt5.inc
DEPENDS += "st-etal qtbase qtmultimedia"
RDEPENDS_${PN} += "bash"

FILES_${PN} =  "${bindir}/st_dab_radio"
FILES_${PN} += "${bindir}/st_dab_radio_start.sh"
FILES_${PN} += "${bindir}/radio_logos"
FILES_${PN} += "${bindir}/image_sls"
FILES_${PN} += "${bindir}/Scripts"
FILES_${PN} += "${bindir}/settings"
FILES_${PN} += "${systemd_system_unitdir}/st_dab_radio.service"

SYSTEMD_SERVICE_${PN} = "st_dab_radio.service"
SYSTEMD_AUTO_ENABLE_${PN} = "enable"

EXTRA_QMAKEVARS_PRE += "-d CONFIG+=Etal"
EXTRA_QMAKEVARS_POST += "LIBS+=-L${S}/etal/lib/MTD_LINUX/ LIBS+=-letal LIBS+=-lrt"

EXTRA_QMAKEVARS_POST += "LIBS+=${@bb.utils.contains('ETAL_OPTION', 'DAB_HOST_SD', "`pkg-config --libs alsa`", '', d)}"
EXTRA_QMAKEVARS_POST += "LIBS+=${@bb.utils.contains('ETAL_OPTION', 'DAB_HOST_SD', '-lciDec', '', d)}"

#OE_QMAKE_CXXFLAGS += "-I${STAGING_INCDIR}/qt5 -DQT_NO_DEBUG_OUTPUT"
OE_QMAKE_CXXFLAGS += "-I${STAGING_INCDIR}/qt5 -mno-unaligned-access -faligned-new -DCUSTOM_QTDEBUG_LOGFILE"

QMAKE_PROFILES="${S}/st_dab_radio.pro"

do_compile() {
	mkdir -p ${S}/etal/lib/MTD_LINUX
	cd ${S}/etal/lib/MTD_LINUX
	rm -rf libetal.a etal.lib
	cp -rf ${STAGING_DIR_HOST}/etal_exports/etal.a libetal.a
	if [ "${ETAL_OPTION}" = "DAB_HOST_SD" ] ; then
		cp -rf ${STAGING_DIR_HOST}/etal_exports/libciDec.a libciDec.a
	fi
	cp -rf ${STAGING_DIR_HOST}/etal_exports/*.h ../..
	cp -rf ${STAGING_DIR_HOST}/etal_exports/target_config.h ../../etal_target_config.h
	cp -rf ${STAGING_DIR_HOST}/etal_exports/target_config.mak ../../etal_target_config.mak
	cd -
	oe_runmake
}

do_install() {
	install -d ${D}${bindir}
	install -m 0755 ${B}/st_dab_radio ${D}${bindir}
	install -d ${D}${bindir}/radio_logos
#	install -m 644 ${S}/radio_logos/* ${D}${bindir}/radio_logos
	install -d ${D}${bindir}/image_sls
#	install -m 644 ${S}/image_sls/* ${D}${bindir}/image_sls
	install -m 0755 ${THISDIR}/files/st_dab_radio_start.sh ${D}${bindir}
	install -d ${D}${systemd_system_unitdir}
	install -m 0777 ${THISDIR}/files/st_dab_radio.service ${D}${systemd_system_unitdir}
	install -d ${D}${bindir}/settings
	install -m 644 ${S}/settings/* ${D}${bindir}/settings
	install -d ${D}${bindir}/Scripts
	install -d ${D}${bindir}/Scripts/TDA7707EB_OM_v7.4.2
	install -d ${D}${bindir}/Scripts/TDA7707DA_OM_v6.3.5
	install -m 644 ${S}/Scripts/TDA7707EB_OM_v7.4.2/* ${D}${bindir}/Scripts/TDA7707EB_OM_v7.4.2
	install -m 644 ${S}/Scripts/TDA7707DA_OM_v6.3.5/* ${D}${bindir}/Scripts/TDA7707DA_OM_v6.3.5
#	install -m 644 ${S}/Scripts/* ${D}${bindir}/Scripts
}


text:
@online{
	wiki:sicurezza,
	editor = {Wikipedia},
	title = {Sicurezza},
	year = {2015},
	url = {http://it.wikipedia.org/wiki/Sicurezza},
}
@online{
	wiki:vigilanza,
	editor = {Wikipedia},
	title = {Vigilanza Privata},
	year = {2015},
	url = {http://it.wikipedia.org/wiki/Vigilanza_privata},
}
@online{
	lis:chisiamo,
	editor = {LIS s.r.l.},
	title = {LIS, Chi Siamo},
	year = {2015},
	url = {http://www.lis-srl.it/chi-siamo.asp},
}
@online{
	dallmeier:premote,
	editor = {Dallmeier},
	title = {PRemote-HD},
	year = {2015},
	url = {http://www.dallmeier.com/fileadmin/user_upload/upload_dallmeier.com/PDFs/Downloads/Broschures/PRemote-Handout_en.pdf},
}
@techreport{
	c++11,
	author = {ISO},
	Institution = {International Organization for Standardization},
	address = {Geneva, Switzerland},
	Title = {Information technology -- Programming languages -- C++},
	number = {ISO/IEC JTC 1/SC 22},
	Type = {ISO},
	Year = {2011},
}
@online{
	pugi,
	editor = {pugixml},
	title = {Pugixml},
	year = {2014},
	url = {http://pugixml.org},
}

@online{
	zmq,
	editor = {ZeroMQ},
	title = {ZeroMQ},
	year = {2014},
	url = {http://zeromq.org/},
}
@online{
	openssl,
	editor = {Openssl},
	title = {OpenSSL},
	url = {https://www.openssl.org},
}

@online{
	wireshark,
	editor = { Wireshark Foundation },
	title = {WireShark},
	url = {https://www.wireshark.org/},
}
@online{jboss,
	title = {WildFly},
	date = {2015},
	url = {http://www.wildfly.org/},
}
@manual{dc07,
	ALTeditor = {Security Industry Association},
	title = {SIA Digital Communications Standard Receiver-to-Computer Interface Protocol for Central Station Equipment Communications },
	date = {2012},
	OPTurl = {http://www.siaonline.org/SiteAssets/Standards/Intrusion%20Subcommittee/DC-07%20Going%20through%20SIA%20Public%20Review.pdf},
}
@manual{dc09,
	ALTeditor = {Security Industry Association},
	title = {SIA Digital Communications Standard Receiver-to-Computer Interface Protocol for Central Station Equipment Communications },
	date = {2013},
	OPTurl = {http://www.siaonline.org/SiteAssets/Standards/Intrusion%20Subcommittee/DC-09%20Preparing%20for%20ANSI%20Public%20Review.pdf},
}


text:
@inProceedings{butz16b,
  title = {Relevant Path Separation: A Faster Method for Testing Independencies in {B}ayesian Networks},
  author = {Butz, Cory J. and Santos, Andr\'e E. dos and Oliveira, Jhonatan S.},
  pages = {74-85},
  abstract = {\emph{Directed separation} (d-separation) played a fundamental role in the founding of \emph{Bayesian networks} (BNs) and continues to be useful today in a wide range of applications. Given an independence to be tested, current implementations of d-separation explore the \emph{active} part of a BN. On the other hand, an overlooked property of d-separation implies that d-separation need only consider the \emph{relevant} part of a BN. We propose a new method for testing independencies in BNs, called \emph{relevant path separation} (rp-separation), which explores the intersection between the active and relevant parts of a BN. Favourable experimental results are reported.},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX


text:
@inproceedings{Vlasenko_combiningframe,
author = {Vlasenko, Bogdan and Schuller, Bjorn and Wendemuth, Andreas and Rigoll, Gerhard},
year = {2007},
month = {01},
pages = {2249-2252},
title = {Combining frame and turn-level information for robust recognition of emotions within speech},
journal = {Proceedings of Interspeech}
}

repository: tensorflow/datasets

repo_name: tensorflow/datasets


text:
/*
Copyright 2015 All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

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

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

package main

import (
	"fmt"
	"time"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/service/s3"
	"github.com/codegangsta/cli"
)

func (r cliCommand) listBuckets(o *formater, cx *cli.Context) error {
	// step: get a list of buckets
	buckets, err := r.listS3Buckets()
	if err != nil {
		return err
	}

	// step: produce the entries
	for _, x := range buckets {
		o.fields(map[string]interface{}{
			"created": (*x.CreationDate).Format(time.RFC822Z),
			"bucket":  *x.Name,
		}).log("%-42s %20s\n", *x.Name, (*x.CreationDate).Format(time.RFC822))
	}

	return nil
}

func (r cliCommand) createBucket(o *formater, cx *cli.Context) error {
	name := cx.String("name")

	if found, err := r.hasBucket(name); err != nil {
		return err
	} else if found {
		return fmt.Errorf("the bucket already exists")
	}

	if _, err := r.s3Client.CreateBucket(&s3.CreateBucketInput{
		Bucket: aws.String(name),
	}); err != nil {
		return err
	}

	o.fields(map[string]interface{}{
		"operation": "created",
		"bucket":    name,
		"created":   time.Now().Format(time.RFC822Z),
	}).log("successfully created the bucket: %s\n", name)

	return nil
}

func (r cliCommand) deleteBucket(o *formater, cx *cli.Context) error {
	name := cx.String("name")
	force := cx.Bool("force")

	// step: check the bucket exists
	found, err := r.hasBucket(name)
	if err != nil {
		return err
	} else if !found {
		return fmt.Errorf("the bucket does not exist")
	}

	// step: check if the bucket is empty
	count, err := r.sizeOfBucket(name)
	if err != nil {
		return err
	} else if count > 0 && !force {
		return fmt.Errorf("the bucket is not empty, either force (--force) deletion or empty the bucket")
	}

	if _, err := r.s3Client.DeleteBucket(&s3.DeleteBucketInput{
		Bucket: aws.String(name),
	}); err != nil {
		return err
	}

	o.fields(map[string]interface{}{
		"operation": "delete",
		"bucket":    name,
		"created":   time.Now().Format(time.RFC822Z),
	}).log("successfully deleted the bucket: %s\n", name)

	return nil
}

// listS3Buckets gets a list of buckets
func (r cliCommand) listS3Buckets() ([]*s3.Bucket, error) {
	list, err := r.s3Client.ListBuckets(&s3.ListBucketsInput{})
	if err != nil {
		return nil, err
	}

	return list.Buckets, nil
}

repository: Cloudxtreme/kmsctl

repo_name: Cloudxtreme/kmsctl


text:
# Copyright (C) 2014 Gernot Tenchio <gernot.tenchio@securepoint.de>
# Released under the MIT license (see COPYING.MIT for the terms)

SUMMARY = "PPTP Server"
DESCRIPTION = "\
PoPToP is the PPTP Server solution for Linux. PoPToP allows Linux servers\
to function seamlessly in the PPTP VPN environment. This enables\
administrators to leverage the considerable benefits of both Microsoft and\
Linux. The current pre-release version supports Windows 95/98/NT/2000 PPTP\
clients and PPTP Linux clients.\
"
HOMEPAGE = "http://poptop.sourceforge.net/"
LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://COPYING;md5=8ca43cbc842c2336e835926c2166c28b"
SECTION = "extra/network"
PR = "r0"

SRC_URI = "\
    http://dl.sourceforge.net/sourceforge/poptop/pptpd-1.3.4.tar.gz \
    file://pptpd-install.patch \
    file://etc_sv_pptpd_run \
    file://etc_sv_pptpd_down \
"
SRC_URI[md5sum] = "b38df9c431041922c997c1148bedf591"
SRC_URI[sha256sum] = "c23a9bdd219a0a36ae7ca20e7c9749f2efdcdbf108aabeeeb5066ba442ec88b6"

inherit autotools-brokensep runit

RUNIT_SERVICES = "pptpd"

do_configure_append () {
    # remove hardcoded gcc dependency to fix cross copiling issue
    sed -i -e "s/^CC.*gcc//" ${S}/plugins/Makefile
}

do_install_prepend () {
    mkdir -p ${D}/usr/lib/pptpd
}

repository: Securepoint/yocto-meta-securepoint

repo_name: Securepoint/yocto-meta-securepoint


text:
package session

import (
	"fmt"
	"net/http"

	"github.com/moisespsena-go/i18n-modular/i18nmod"
	"github.com/moisespsena/template/html/template"
)

// ManagerInterface session manager interface
type ManagerInterface interface {
	// Add value to session data, if value is not string, will marshal it into JSON encoding and save it into session data.
	Add(w http.ResponseWriter, req *http.Request, key string, value interface{}) error
	// Get value from session data
	Get(req *http.Request, key string) string
	// Pop value from session data
	Pop(w http.ResponseWriter, req *http.Request, key string) string

	// Flash add flash message to session data
	Flash(w http.ResponseWriter, req *http.Request, message Message) error
	// Flashes returns a slice of flash messages from session data
	Flashes(w http.ResponseWriter, req *http.Request) []Message

	// Load get value from session data and unmarshal it into result
	Load(req *http.Request, key string, result interface{}) error
	// PopLoad pop value from session data and unmarshal it into result
	PopLoad(w http.ResponseWriter, req *http.Request, key string, result interface{}) error

	// Middleware returns a new session manager middleware instance.
	Middleware(http.Handler) http.Handler
}

// Message message struct
type Message struct {
	Message template.HTML
	Type    string
}

type RequestSessionManager interface {
	// Add value to session data, if value is not string, will marshal it into JSON encoding and save it into session data.
	Add(key string, value interface{}) error
	// Get value from session data
	Get(key string) string
	// Pop value from session data
	Pop(key string) string

	// Flash add flash message to session data
	Flash(message Message) error
	// Flashes returns a slice of flash messages from session data
	Flashes() []Message

	// Load get value from session data and unmarshal it into result
	Load(key string, result interface{}) error
	// PopLoad pop value from session data and unmarshal it into result
	PopLoad(key string, result interface{}) error

	Middleware(http.Handler) http.Handler

	ResponseWriter() http.ResponseWriter

	Request() *http.Request
}

func TranslatedMessage(ctx i18nmod.Context, msg interface{}, typ string) Message {
	switch t := msg.(type) {
	case i18nmod.Translater:
		return Message{template.HTML(t.Translate(ctx)), typ}
	case error:
		return Message{ctx.T(t.Error()).GetHtml(), typ}
	case string:
		return Message{ctx.T(t).GetHtml(), typ}
	default:
		return Message{ctx.T(fmt.Sprint(t)).GetHtml(), typ}
	}
}

func TranslatedMessageE(ctx i18nmod.Context, msg interface{}) Message {
	return TranslatedMessage(ctx, msg, "error")
}

repository: ecletus/session

repo_name: ecletus/session


text:
@inproceedings{vardy03lowlevel,
 author = {A. Vardy and F. Oppacher},
 booktitle = {Proceedings of the 7th European Conference on Artificial Life (ECAL)},
 date-added = {2019-10-06 21:33:55 -0230},
 date-modified = {2019-10-06 21:33:55 -0230},
 pages = {875-884},
 publisher = {Springer},
 series = {Lecture Notes in Artificial Intelligence},
 title = {Low-Level Visual Homing},
 volume = {2801},
 year = {2003}
}

repository: ooooxy/academic-kickstart

repo_name: ooooxy/academic-kickstart


text:
require jakarta-commons.inc

DESCRIPTION = "Set of Java classes that provide helper methods for the standard java.lang classes"

SRC_URI = "http://www.apache.org/dist/commons/lang/source/${BP}-src.tar.gz"

SRC_URI[md5sum] = "625ff5f2f968dd908bca43c9469d6e6b"
SRC_URI[sha256sum] = "2445238cd0eb167e99a1147394f61325490559f3df7e7e8f628043fb70cbf2f4"


text:
@article{AcharyaCK18,
 author = {Acharya, Jayadev and Canonne, Clément L. and Kamath, Gautam},
 journal = {Theory of Computing},
 month = {December},
 number = {19},
 pages = {1--46},
 title = {A Chasm Between Identity and Equivalence Testing with Conditional Queries},
 url = {https://arxiv.org/abs/1411.7346},
 volume = {14},
 year = {2018}
}

repository: TheSalon/academic-kickstart

repo_name: TheSalon/academic-kickstart


text:
@Manual{citeR,
    title = {R: A Language and Environment for Statistical Computing},
    author = {{R Core Team}},
    organization = {R Foundation for Statistical Computing},
    address = {Vienna, Austria},
    year = {2020},
    url = {https://www.R-project.org/},
  }
@misc {citepsd,
    title={IPUMS USA: Version 10.0 [dataset]},
    url={https://doi.org/10.18128/D010.V10.0},
    address = {Minneapolis, MN: IPUMS, 2020.},
    author={Steven Ruggles, Sarah Flood, Ronald Goeken, Josiah Grover, Erin Meyer, Jose Pacas and Matthew Sobek.}
  }
@misc {citesurvey,
    title = {emocracy Fund + UCLA Nationscape, October 10-
    17, 2019 (version 20200814)},
    url = {https://www.voterstudygroup.org/publication/nationscape-data-set},
    year = {2020},
    author = {Tausanovitch, Chris and Lynn Vavreck .}
  }
@Article{citetidyverse,
    title = {Welcome to the {tidyverse}},
    author = {Hadley Wickham and Mara Averick and Jennifer Bryan and Winston Chang and Lucy D'Agostino McGowan and Romain François and Garrett Grolemund and Alex Hayes and Lionel Henry and Jim Hester and Max Kuhn and Thomas Lin Pedersen and Evan Miller and Stephan Milton Bache and Kirill Müller and Jeroen Ooms and David Robinson and Dana Paige Seidel and Vitalie Spinu and Kohske Takahashi and Davis Vaughan and Claus Wilke and Kara Woo and Hiroaki Yutani},
    year = {2019},
    journal = {Journal of Open Source Software},
    volume = {4},
    number = {43},
    pages = {1686},
    doi = {10.21105/joss.01686},
  }
@Manual{citehaven,
    title = {haven: Import and Export 'SPSS', 'Stata' and 'SAS' Files},
    author = {Hadley Wickham and Evan Miller},
    year = {2020},
    note = {R package version 2.3.1},
    url = {https://CRAN.R-project.org/package=haven},
  }
@Manual{citetidybayes,
    title = {{tidybayes}: Tidy Data and Geoms for {Bayesian} Models},
    author = {Matthew Kay},
    year = {2020},
    note = {R package version 2.1.1},
    url = {http://mjskay.github.io/tidybayes/},
    doi = {10.5281/zenodo.1308151},
  }
@Manual{citebroom,
    title = {broom: Convert Statistical Objects into Tidy Tibbles},
    author = {David Robinson and Alex Hayes and Simon Couch},
    year = {2020},
    note = {R package version 0.7.0},
    url = {https://CRAN.R-project.org/package=broom},
  }
@Manual{citeknitr,
  title = {knitr: A General-Purpose Package for Dynamic Report Generation in R},
  author = {Yihui Xie},
  year = {2020},
  note = {R package version 1.29},
  url = {https://yihui.org/knitr/},
  }
@Article{citebrms,
  title = {{brms}: An {R} Package for {Bayesian} Multilevel Models Using {Stan}},
  author = {Paul-Christian Bürkner},
  journal = {Journal of Statistical Software},
  year = {2017},
  volume = {80},
  number = {1},
  pages = {1--28},
  doi = {10.18637/jss.v080.i01},
  encoding = {UTF-8},
  }

@Article{citebrms2,
  title = {Advanced {Bayesian} Multilevel Modeling with the {R} Package {brms}},
  author = {Paul-Christian Bürkner},
  journal = {The R Journal},
  year = {2018},
  volume = {10},
  number = {1},
  pages = {395--411},
  doi = {10.32614/RJ-2018-017},
  encoding = {UTF-8},
  }
@Manual{citeskimr,
  title = {skimr: Compact and Flexible Summaries of Data},
  author = {Elin Waring and Michael Quinn and Amelia McNamara and Eduardo {Arino de la Rubia} and Hao Zhu and Shannon Ellis},
  year = {2020},
  note = {R package version 2.1.2},
  url = {https://CRAN.R-project.org/package=skimr},
  }
@Manual{citenaniar,
  title = {naniar: Data Structures, Summaries, and Visualisations for Missing Data},
  author = {Nicholas Tierney and Di Cook and Miles McBain and Colin Fay},
  year = {2020},
  note = {R package version 0.6.0},
  url = {https://CRAN.R-project.org/package=naniar},
  }
@Manual{citestatebins,
  title = {statebins: Create United States Uniform Cartogram Heatmaps},
  author = {Bob Rudis},
  year = {2020},
  note = {R package version 1.4.0},
  url = {https://CRAN.R-project.org/package=statebins},
  }
@Book{citeggplot,
  author = {Hadley Wickham},
  title = {ggplot2: Elegant Graphics for Data Analysis},
  publisher = {Springer-Verlag New York},
  year = {2016},
  isbn = {978-3-319-24277-4},
  url = {https://ggplot2.tidyverse.org},
  }
@Manual{citedata,
    title = {kableExtra: Construct Complex Table with 'kable' and Pipe Syntax},
    author = {Hao Zhu},
    year = {2020},
    note = {R package version 1.3.1},
    url = {https://CRAN.R-project.org/package=kableExtra},
  }
@Manual{citekable,
    title = {data.table: Extension of `data.frame`},
    author = {Matt Dowle and Arun Srinivasan},
    year = {2019},
    note = {R package version 1.12.8},
    url = {https://CRAN.R-project.org/package=data.table},
  }
@Article{citeperform,
    title = {performance: Assessment of Regression Models Performance},
    author = {Daniel Lüdecke and Dominique Makowski and Philip Waggoner and Indrajeet Patil},
    journal = {CRAN},
    year = {2020},
    note = {R package},
    doi = {10.5281/zenodo.3952174},
    url = {https://easystats.github.io/performance/},
  }
@Manual{citeclickR,
    title = {clickR: Fix Data and Create Report Tables from Different Objects},
    author = {Victoria Fornes Ferrer and David Hervas Marin},
    year = {2020},
    note = {R package version 0.4.47},
    url = {https://CRAN.R-project.org/package=clickR},
  }
@Article{citepROC,
    title = {pROC: an open-source package for R and S+ to analyze and compare ROC curves},
    author = {Xavier Robin and Natacha Turck and Alexandre Hainard and Natalia Tiberti and Frédérique Lisacek and Jean-Charles Sanchez and Markus Müller},
    year = {2011},
    journal = {BMC Bioinformatics},
    volume = {12},
    pages = {77},
  }


text:
/*
*Copyright (c) 2019-2021, Alibaba Group Holding Limited;
*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 workflow

import (
	"encoding/json"
	"k8s.io/apimachinery/pkg/util/uuid"
	"polardb-sms/pkg/common"
	smslog "polardb-sms/pkg/log"
	"polardb-sms/pkg/manager/domain"
	"polardb-sms/pkg/manager/domain/workflow/stage"
	"time"
)

type ExecStatus int

const (
	NotStarted ExecStatus = iota
	Started
	Success
	Fail
	SuccessRollback
	FailRollback
)

type WorkMode int

const (
	Run WorkMode = iota
	Rollback
)

type WflType int

const (
	DummyWfl WflType = iota
	Rescan
	PrCheck
	PrLock
	ClusterLvCreate
	ClusterLvExpand
	ClusterLvFormat
	ClusterLvFsExpand
	ClusterLvDelete
	ClusterLunCreate
	ClusterLunExpand
	ClusterLunFsExpand
	ClusterLunFormat
	ClusterLunFormatAndLock
	PvcCreate
	PvcRelease
	PvcFormatAndLock
	PvcFsExpand
	PvcFormat
	PvcDelete
	PvcBind
)

var DummyWorkflow = &WorkflowEntity{Id: domain.DummyWorkflowId}

type WflContext struct {
	startTime   int64
	timeout     int
	currentStep int
	Mode        WorkMode
	data        interface{}
}

type WorkflowEntity struct {
	WflContext
	Id           string
	WflType      WflType
	Step         int
	Stages       []StageRunner
	Status       ExecStatus
	LastErrMsg   string
	CreateTime   time.Time
	TraceContext common.TraceContext
	VolumeId     string
	VolumeClass  string
}

func (w *WorkflowEntity) SetTraceContext(value map[string]string) {
	if value == nil {
		w.TraceContext = map[string]string{"workflow": w.Id}
	} else {
		w.TraceContext = value
		w.TraceContext["workflow"] = w.Id
	}
}

func (w *WorkflowEntity) GetTraceContext() map[string]string {
	if w.TraceContext == nil {
		w.TraceContext = make(map[string]string)
	}
	return w.TraceContext
}

func (w *WorkflowEntity) Valid() bool {
	now := time.Now()
	overdue := w.CreateTime.Add(1 * time.Minute)
	if now.After(overdue) {
		smslog.Debugf("workflow %s overdue, ignore", w.Id)
		return false
	}
	return true
}

func (w *WorkflowEntity) IsFinished() bool {
	return w.SuccessfullyRun() || w.SuccessfullyRollback() || w.Failed()
}

func (w *WorkflowEntity) SuccessfullyRun() bool {
	return w.Status == Success && w.Step >= len(w.Stages)
}

func (w *WorkflowEntity) SuccessfullyRollback() bool {
	return w.Status == SuccessRollback && w.Step < 0
}

func (w *WorkflowEntity) Failed() bool {
	return w.Status == Fail
}

func (w *WorkflowEntity) GetExecResult() string {
	if w.SuccessfullyRun() {
		return "success run"
	}
	if w.SuccessfullyRollback() {
		return "success rollback"
	}
	if w.Failed() {
		if w.Step >= 0 {
			return w.Stages[w.Step].GetExecResult().ErrMsg
		}
		return "failed"
	}
	return "unknown status"
}

func (w *WorkflowEntity) String() string {
	msg, err := json.Marshal(w)
	if err != nil {
		return ""
	}
	return string(msg)
}

func (w *WorkflowEntity) AddStage(s StageRunner) {
	w.Stages = append(w.Stages, s)
}

func (w *WorkflowEntity) SetVolumeId(volumeId string) {
	w.VolumeId = volumeId
}

func (w *WorkflowEntity) SetVolumeClass(volumeClass string) {
	w.VolumeClass = volumeClass
}

func (w *WorkflowEntity) Run() {

}

type WflBuilder struct {
	wflType WflType
	step    int
	stages  []StageRunner
	ctx     WflContext
}

func NewWflBuilder() *WflBuilder {
	return &WflBuilder{}
}

func (b *WflBuilder) WithType(t WflType) *WflBuilder {
	b.wflType = t
	return b
}

func (b *WflBuilder) WithStageRunner(stageRunner StageRunner) *WflBuilder {
	b.stages = append(b.stages, stageRunner)
	return b
}

func (b *WflBuilder) WithStageRunners(stages []StageRunner) *WflBuilder {

	b.stages = append(b.stages, stages...)
	return b
}

func (b *WflBuilder) Build() *WorkflowEntity {
	return &WorkflowEntity{
		Id:         string(uuid.NewUUID()),
		WflType:    b.wflType,
		Step:       0,
		Stages:     b.stages,
		WflContext: b.ctx,
	}
}

type StageRunner interface {
	//TODO remove this method
	GetExecResult() *stage.StageExecResult
	Run(ctx common.TraceContext) *stage.StageExecResult
	Rollback(ctx common.TraceContext) *stage.StageExecResult
	StageType() stage.StageType
}

repository: ZhaoDiankui/PolarDB-Stack-Storage

repo_name: ZhaoDiankui/PolarDB-Stack-Storage


text:
@incollection{dijkstra2002go,
  title={{Go to Statement Considered Harmful}},
  author={Dijkstra, Edsger W},
  booktitle={Software pioneers},
  pages={351--355},
  year={2002},
  publisher={Springer}
}

@incollection{asperti2012,
  Author = {Asperti, Andrea and Ricciotti, Wilmer},
  Booktitle = {Logic, Language, Information and Computation},
  Date-Added = {2014-03-22 12:38:40 +0000},
  Date-Modified = {2014-03-22 18:38:50 +0000},
  Pages = {1--25},
  Publisher = {Springer},
  Title = {{Formalizing Turing Machines}},
  Year = {2012}
}

@article{asperti2015,
  title={{A formalization of multi-tape Turing machines}},
  author={Asperti, Andrea and Ricciotti, Wilmer},
  journal={Theoretical Computer Science},
  volume=603,
  pages={23--42},
  year=2015,
  publisher={Elsevier}
}

@article{Invariance,
  title = "The problem of space invariance for sequential machines",
  journal = "Information and Computation",
  volume = "77",
  number = "2",
  pages = "93 - 122",
  year = "1988",
  note = "",
  issn = "0890-5401",
  doi = "http://dx.doi.org/10.1016/0890-5401(88)90052-1",
  url = "http://www.sciencedirect.com/science/article/pii/0890540188900521",
  author = "Cees Slot and Peter van Emde Boas",
}

@inproceedings{Pous13,
  author    = {Damien Pous},
  title     = {{Kleene Algebra with Tests and Coq Tools for while Programs}},
  booktitle = {ITP 2013},
  pages     = {180--196},
  year      = {2013},
  url       = {http://dx.doi.org/10.1007/978-3-642-39634-2_15},
  doi       = {10.1007/978-3-642-39634-2_15},
  timestamp = {Wed, 24 Jul 2013 20:48:35 +0200},
  biburl    = {http://dblp.uni-trier.de/rec/bib/conf/itp/Pous13},
  bibsource = {dblp computer science bibliography, http://dblp.org}
}

@article{indeed,
  author    = {Beniamino Accattoli and Ugo Dal Lago},
  title     = {({Leftmost-Outermost) Beta Reduction is Invariant, Indeed}},
  journal   = {Logical Methods in Computer Science},
  volume    = 12,
  number    = 1,
  year      = 2016,
  url       = {http://dx.doi.org/10.2168/LMCS-12(1:4)2016},
  doi       = {10.2168/LMCS-12(1:4)2016},
  timestamp = {Mon, 04 Apr 2016 13:16:34 +0200},
  biburl    = {http://dblp.uni-trier.de/rec/bib/journals/corr/AccattoliL16},
  bibsource = {dblp computer science bibliography, http://dblp.org}
}

@misc{Coq,
  author = {{The Coq Proof Assistant}},
  howpublished = {\url{http://coq.inria.fr}}
}

@inproceedings{asperti2011matita,
  title={{The Matita Interactive Theorem Prover}},
  author={Asperti, Andrea and Ricciotti, Wilmer and Coen, Claudio Sacerdoti and Tassi, Enrico},
  booktitle={International Conference on Automated Deduction},
  pages={64--69},
  year=2011,
  organization={Springer}
}

@inproceedings{xu2013,
  title={{Mechanising Turing machines and computability theory in Isabelle/HOL}},
  author={Xu, Jian and Zhang, Xingyuan and Urban, Christian},
  booktitle={International Conference on Interactive Theorem Proving},
  pages={147--162},
  year={2013},
  organization={Springer}
}

@article{ciaffaglione2016,
  title={{Towards Turing computability via coinduction}},
  author={Ciaffaglione, Alberto},
  journal={Science of Computer Programming},
  volume={126},
  pages={31--51},
  year={2016},
  publisher={Elsevier}
}

@inproceedings{forster2018verification,
  title={{Verification of PCP-Related Computational Reductions in Coq}},
  author={Forster, Yannick and Heiter, Edith and Smolka, Gert},
  booktitle={International Conference on Interactive Theorem Proving},
  pages={253--269},
  year={2018},
  organization={Springer}
}

@inproceedings{forster2017weak,
  title={{Weak Call-by-Value Lambda Calculus as a Model of Computation in Coq}},
  author={Forster, Yannick and Smolka, Gert},
  booktitle={International Conference on Interactive Theorem Proving},
  pages={189--206},
  year={2017},
  organization={Springer}
}

@inproceedings{forster2016verified,
  title={{Verified extraction from coq to a lambda-calculus}},
  author={Forster, Yannick and Kunze, Fabian},
  booktitle={Coq Workshop},
  volume={2016},
  year={2016}
}

@article{DalLago,
  Author = {Ugo {Dal Lago} and Simone Martini},
  Date-Added = {2014-04-01 17:24:02 +0000},
  Date-Modified = {2014-04-03 10:26:20 +0000},
  Journal = {Theor. Comput. Sci.},
  Number = {1-3},
  Pages = {32-50},
  Title = {{The weak lambda calculus as a reasonable machine}},
  Volume = {398},
  Year = {2008}
}

@TECHREPORT{KunzeEtAl:2018:Formal,
  title = {{Formal Small-step Verification of a Call-by-value Lambda Calculus Machine}},
  author = {Fabian Kunze and Gert Smolka and Yannick Forster},
  year = 2018,
  month = {Jun},
  institution = {arxiv 1806.03205},
}

@CONFERENCE{ForsterSmolka:2017:L-Computability,
  title = {{Weak Call-by-Value Lambda Calculus as a Model of Computation in Coq}},
  author = {Yannick Forster and Gert Smolka},
  year = {2017},
  month = {Apr},
  booktitle = { Interactive Theorem Proving - 8th International Conference, ITP 2017, Brasilia, Brazil, September 26-29, 2017},
}

@misc{boolos2007computability,
  title={{Computability and Logic. 5th}},
  author={Boolos, George S and Burgess, John P and Jeffrey, Richard C},
  year=2007,
  publisher={New York, NY: Cambridge University Press}
}

@mastersthesis{JanMenz,
  title = {{A Coq Library for Finite Types}},
  author = {Jan Christian Menz},
  year = 2016,
  url = {https://www.ps.uni-saarland.de/~menz/bachelor.php},
  type = {Bachelor's thesis},
  school = {Universität des Saarlandes}
}

@unpublished{ForsterLOLA2017,
  title = {{The strong invariance thesis for a $\lambda$-calculus}},
  author = {Yannick Forster and Fabian Kunze and Marc Roth},
  note = {{\itshape LOLA workshop 2017, Reykjavik, Iceland}},
  url = {https://www.ps.uni-saarland.de/~forster/downloads/LOLA-2017-strong-invariance-thesis.pdf},
  year = 2017
}

@unpublished{ForsterLOLA2018,
  title = {{Towards a library of formalised undecidable problems in Coq: The undecidability of intuitionistic linear logic}},
  author = {Yannick Forster and Dominique Larchey-Wendling},
  note = {{\itshape LOLA workshop 2018, Oxford, UK}},
  url = {https://www.ps.uni-saarland.de/~forster/downloads/LOLA-2018-coq-library-undecidability.pdf},
  year = 2018
}

@techreport{casteran2012gentle,
  title={{A Gentle Introduction to Type Classes and Relations in Coq}},
  author={Cast{\'e}ran, Pierre and Sozeau, Matthieu},
  year={2012},
  institution={Technical Report hal-00702455, version 1}
}

@inproceedings{norrish2011mechanised,
  title={Mechanised computability theory},
  author={Norrish, Michael},
  booktitle={International Conference on Interactive Theorem Proving},
  pages={297--311},
  year={2011},
  organization={Springer}
}

repository: uds-psl/CoqTM

repo_name: uds-psl/CoqTM

gha_language: Coq


text:
DESCRIPTION = "Meta-package for SDL"
LICENSE = MIT
RDEPENDS = "task-sdl-libs task-sdl-games task-sdl-emulators"
PR = "r2"

ALLOW_EMPTY = 1
BUILD_ALL_DEPS = 1

# no need to add libsdl as all libsdl-* already rdepend on it
RDEPENDS_task-sdl-libs = "libsdl-gfx libsdl-image libsdl-mixer libsdl-ttf libsdl-net"

RDEPENDS_task-sdl-games = "abuse freedroid lbreakout2 openttd prboom quake1 rott supertux xmame"

RDEPENDS_task-sdl-emulators = "dgen-sdl e-uae frodo snes9x"

repository: BackupTheBerlios/openslug-svn

repo_name: BackupTheBerlios/openslug-svn


text:
# Copyright (c) 2020 Hartmut Kaiser
#
# SPDX-License-Identifier: BSL-1.0
# Distributed under the Boost Software License, Version 1.0. (See accompanying
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

include(Phylanx_AddConfigTests)

# ##############################################################################
# C++ feature tests
# ##############################################################################
function(phylanx_perform_cxx_feature_tests)
  phylanx_check_for_cxx17_shared_ptr_array(
    DEFINITIONS PHYLANX_HAVE_CXX17_SHARED_PTR_ARRAY
  )
endfunction()

repository: STEllAR-GROUP/phylanx

repo_name: STEllAR-GROUP/phylanx


text:
package onnx

import (
	"testing"

	"github.com/owulveryck/onnx-go/internal/onnx/ir"
	"github.com/stretchr/testify/assert"
)

/*
	AttributeProto_UNDEFINED AttributeProto_AttributeType = 0
	AttributeProto_FLOAT     AttributeProto_AttributeType = 1
	AttributeProto_INT       AttributeProto_AttributeType = 2
	AttributeProto_STRING    AttributeProto_AttributeType = 3
	AttributeProto_TENSOR    AttributeProto_AttributeType = 4
	AttributeProto_GRAPH     AttributeProto_AttributeType = 5
	AttributeProto_FLOATS    AttributeProto_AttributeType = 6
	AttributeProto_INTS      AttributeProto_AttributeType = 7
	AttributeProto_STRINGS   AttributeProto_AttributeType = 8
	AttributeProto_TENSORS   AttributeProto_AttributeType = 9
	AttributeProto_GRAPHS    AttributeProto_AttributeType = 10
*/

func GetTestPBAttributeProto() []*ir.AttributeProto {
	return []*ir.AttributeProto{
		{
			Name:   "floats",
			Type:   ir.AttributeProto_FLOATS,
			Floats: []float32{1, 2},
		},
		{
			Name: "float",
			Type: ir.AttributeProto_FLOAT,
			F:    1,
		},
		{
			Name: "int",
			Type: ir.AttributeProto_INT,
			I:    1,
		},
		{
			Name: "ints",
			Type: ir.AttributeProto_INTS,
			Ints: []int64{1, 2},
		},
		{
			Name: "string",
			Type: ir.AttributeProto_STRING,
			S:    []byte("a"),
		},
		{
			Name:    "strings",
			Type:    ir.AttributeProto_STRINGS,
			Strings: [][]byte{[]byte("a"), []byte("b")},
		},
	}
}

func TestToOperationAttributes_Strings(t *testing.T) {
	attrs, err := toOperationAttributes(GetTestPBAttributeProto())
	assert.NoError(t, err)

	v, ok := attrs["strings"]
	assert.True(t, ok)
	value, ok := v.([]string)
	assert.True(t, ok)
	expected := []string{"a", "b"}
	for i, v := range value {
		assert.Equal(t, expected[i], v)
	}
}

func TestToOperationAttributes_Ints(t *testing.T) {
	attrs, err := toOperationAttributes(GetTestPBAttributeProto())
	assert.NoError(t, err)

	v, ok := attrs["ints"]
	assert.True(t, ok)
	value, ok := v.([]int64)
	assert.True(t, ok)
	expected := []int64{1, 2}
	for i, v := range value {
		assert.Equal(t, expected[i], v)
	}
}

func TestToOperationAttributes_Floats(t *testing.T) {
	attrs, err := toOperationAttributes(GetTestPBAttributeProto())
	assert.NoError(t, err)

	v, ok := attrs["floats"]
	assert.True(t, ok)
	value, ok := v.([]float32)
	assert.True(t, ok)
	expected := []float32{1, 2}
	for i, v := range value {
		assert.Equal(t, expected[i], v)
	}
}

func TestToOperationAttributes_String(t *testing.T) {
	attrs, err := toOperationAttributes(GetTestPBAttributeProto())
	assert.NoError(t, err)

	v, ok := attrs["string"]
	assert.True(t, ok)
	assert.Equal(t, v.(string), "a")
}

func TestToOperationAttributes_Int(t *testing.T) {
	attrs, err := toOperationAttributes(GetTestPBAttributeProto())
	assert.NoError(t, err)

	v, ok := attrs["int"]
	assert.True(t, ok)
	assert.Equal(t, v.(int64), int64(1))
}

func TestToOperationAttributes_Float(t *testing.T) {
	attrs, err := toOperationAttributes(GetTestPBAttributeProto())
	assert.NoError(t, err)

	v, ok := attrs["float"]
	assert.True(t, ok)
	assert.Equal(t, v.(float32), float32(1))
}

func TestToOperationAttributes_NotImplemented(t *testing.T) {
	_, err := toOperationAttributes([]*ir.AttributeProto{
		{
			Type: ir.AttributeProto_GRAPH,
		},
	})
	_, ok := err.(*ErrNotImplemented)
	assert.True(t, ok)
	_, err = toOperationAttributes([]*ir.AttributeProto{
		{
			Type: ir.AttributeProto_TENSORS,
		},
	})
	_, ok = err.(*ErrNotImplemented)
	assert.True(t, ok)
	_, err = toOperationAttributes([]*ir.AttributeProto{
		{
			Type: ir.AttributeProto_GRAPHS,
		},
	})
	_, ok = err.(*ErrNotImplemented)
	assert.True(t, ok)
	_, err = toOperationAttributes([]*ir.AttributeProto{
		{
			Type: ir.AttributeProto_AttributeType(-1),
		},
	})
	_, ok = err.(*ErrNotImplemented)
	assert.True(t, ok)
}

func TestToOperationAttributes_Undefined(t *testing.T) {
	attrs, err := toOperationAttributes([]*ir.AttributeProto{
		nil,
	})
	assert.NoError(t, err)

	v, ok := attrs[""]
	assert.True(t, ok)
	expected := struct{}{}
	assert.Equal(t, expected, v)
}

repository: owulveryck/onnx-go

repo_name: owulveryck/onnx-go

gha_language: Go


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

// Dirserver is a wrapper for a directory implementation that presents it as an
// HTTP interface that stores its data in a GCS implementation
// of the Store service.
package main // import "github.com/palager/gcp/cmd/dirserver-gcp"

import (
	"flag"

	cloudLog "github.com/palager/gcp/cloud/log"
	"github.com/palager/upspin/log"
	"github.com/palager/upspin/metric"
	"github.com/palager/upspin/serverutil/dirserver"

	"github.com/palager/gcp/cloud/gcpmetric"
	"github.com/palager/gcp/cloud/https"

	// TODO: Which of these are actually needed?

	// Load useful packers
	_ "github.com/palager/upspin/pack/ee"
	_ "github.com/palager/upspin/pack/eeintegrity"
	_ "github.com/palager/upspin/pack/plain"

	// Load required transports
	_ "github.com/palager/upspin/transports"
)

const (
	serverName    = "dirserver"
	samplingRatio = 1    // report all metrics
	maxQPS        = 1000 // unlimited metric reports per second
)

func main() {
	project := flag.String("project", "", "GCP `project` name")

	ready := dirserver.Main()

	if *project != "" {
		cloudLog.Connect(*project, serverName)
		svr, err := gcpmetric.NewSaver(*project, samplingRatio, maxQPS, "serverName", serverName)
		if err != nil {
			log.Fatalf("Can't start a metric saver for GCP project %q: %s", *project, err)
		} else {
			metric.RegisterSaver(svr)
		}
	}

	https.ListenAndServe(ready, serverName)
}

repository: palager/gcp

repo_name: palager/gcp


text:
package logic

import (
	"github.com/linuxkerneltravel/lmp/dao/influxdb"
	"github.com/linuxkerneltravel/lmp/logger"
	"github.com/linuxkerneltravel/lmp/models"

	client "github.com/influxdata/influxdb1-client/v2"
)

func DoCollect(frontPlugins *models.PluginMessage) (err error) {
	//todo:save all pids

	plugins, err := CreatePluginStorage(frontPlugins)
	if err != nil {
		logger.Error("error in plugins.CreatePluginStorage(frontPlugins)", err)
		return err
	}

	if err = plugins.CollectData(); err != nil {
		return err
	}

	return nil
}

func DoQueryIRQ() (res []client.Result, err error) {
	// 调用dao层influxdb API
	res, err = influxdb.QueryDB(`select last("duration") from "irq"`)
	if err != nil {
		logger.Error("ERROR in DoQueryIRQ():", err)
		return nil, err
	}
	return
}

func DoQueryCpuUtilize() (res []client.Result, err error) {
	res, err = influxdb.QueryDB(`select last("perce") from "cpuutilize"`)
	if err != nil {
		logger.Error("ERROR in DoQueryIRQ():", err)
		return nil, err
	}
	return
}

func DoQueryPickNext() (res []client.Result, err error) {
	res, err = influxdb.QueryDB(`select last("duration") from "picknext"`)
	if err != nil {
		logger.Error("ERROR in DoQueryPickNext():", err)
		return nil, err
	}
	return
}

func DoQueryTaskSwitch() (res []client.Result, err error) {
	res, err = influxdb.QueryDB(`select last("duration") from "taskswitch"`)
	if err != nil {
		logger.Error("ERROR in DoQueryTaskSwitch():", err)
		return nil, err
	}
	return
}

func DoQueryHardDiskReadWriteTime() (res []client.Result, err error) {
	res, err = influxdb.QueryDB(`select last("lat") from "HardDiskReadWriteTime"`)
	if err != nil {
		logger.Error("ERROR in DoQueryHardDiskReadWriteTime():", err)
		return nil, err
	}
	return
}

func DoQueryWaterMark() (res []client.Result, err error) {
	res, err = influxdb.QueryDB(`select last("normal") from "memusage"`)
	if err != nil {
		logger.Error("ERROR in DoQueryWaterMark():", err)
		return nil, err
	}
	return
}

repository: ljrcore/lmp

repo_name: ljrcore/lmp


text:
DESCRIPTION = "A fast, lightweight OSGi R3 framework implementation"
LICENSE = "BSD"
DEPENDS = "fastjar-native"

SRCREV = "246"
PV = "1.0+svnr${SRCREV}"
PR = "r0"

SRC_URI = "svn://concierge.svn.sourceforge.net/svnroot/concierge/tags/Concierge/1.0.0/trunk;module=framework;proto=http;localdir=framework \
                   file://fix-EE-string.patch \
                   file://run-in-place.patch;striplevel=1 \
                  "
S = "${WORKDIR}/framework"

inherit bug-java-library

do_compile() {
  mkdir -p build
  javac -sourcepath src/main/java -d build `find src/main/java -name \*.java`
  fastjar -0 -C build -c -f ${JARFILENAME} .
}

PACKAGE_ARCH = "all"
# override java-library's naming conventions
PACKAGES = "${PN}"

FILES_${PN} += "${datadir_java}/${PN}.jar"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty


text:
require xorg-app-common.inc
PE = "1"

DEPENDS += " libice libxt virtual/libx11 xproxymngproto"


text:
% This file was created with JabRef 2.7.
% Encoding: Cp1252
@INPROCEEDINGS{LZ2006,
  author = {John Yung San Li and Hao Zhang},
  title = {Nonobtuse remeshing and mesh decimation},
  booktitle = {Eurographics Symposium on Geometry Processing},
  year = {2006},
  pages = {235-238}
}

@ARTICLE{SCWYLL2011,
  author = {Feng Sun and Yi-King Choi and Wenping Wang and Dong-Ming Yan and Yang Liu and Bruno L$\grave{e}$vy},
  title = {Obtuse triangle suppression in anisotropic meshes},
  journal = {Computer Aided Geometric Design},
  year = {2011},
  volume = {28},
  pages = {537-548},
  number = {9}
}

@ARTICLE{LC1987,
  author = {William E. Lorensen and Harvey E. Cline},
  title = {Marching cubes: A high resolution 3D surface construction algorithm},
  journal = {ACM SIGGRAPH Computer Graphics},
  year = {1987},
  volume = {21},
  pages = {163-169},
  number = {4}
}

@INPROCEEDINGS{C1993,
  author = {L. Paul Chew},
  title = {Guaranteed-quality mesh generation for curved surfaces},
  booktitle = {ACM Symposium on Computational Geometry},
  year = {1993},
  pages = {274-280}
}

@ARTICLE{JKKS2009,
  author = {Jan Brandts and Sergey Korotov and Michal K$\check{k}$$\acute{i}$$\breve{z}$k and Jakub $\check{S}$olc},
  title = {On nonobtuse simplicial partitions},
  journal = {AIAM Review},
  year = {2009},
  volume = {51},
  pages = {317-335},
  number = {2}
}

@ARTICLE{AUGA2008,
  author = {Pierre Alliez and Giuliana Ucelli and Craig Gotsman and Marco Attene},
  title = {Recent advances in remeshing of surfaces},
  journal = {Shape Analysis and Structuring},
  year = {2008},
  pages = {53-82}
}

@ARTICLE{KS1998,
  author = {R. Kimmel and J. A. Sethian},
  title = {Computing geodesic paths on manifolds},
  journal = {Proc. of National Academy of Science USA},
  year = {1998},
  volume = {95},
  pages = {8431-8435},
  number = {15}
}

@INPROCEEDINGS{AYZ2012,
  author = {Nima Aghdaii and Hamid Younesy and Hao Zhang},
  title = {5-6-7 meshes},
  booktitle = {Graphics Interace},
  year = {2012},
  pages = {27-34}
}

@INPROCEEDINGS{AVDI2003,
  author = {Pierre Alliez and Eric Colin de Verdiere and Olivier Devillers and Martin Isenburg},
  title = {Isotropic surface remeshing},
  booktitle = {Proceedings of Shape Modeling International},
  year = {2003},
  pages = {49-58}
}

@ARTICLE{G2007,
  author = {Igor Guskov},
  title = {Manifold-based approach to semi-regular remeshing},
  journal = {Graphical Models},
  year = {2007},
  volume = {69},
  pages = {1-18},
  number = {1}
}

@INPROCEEDINGS{S2002,
  author = {Jonathan Richard Shewchuk},
  title = {What is a good linear element? Interpolation, conditioning, and quality measures},
  booktitle = {Proceedings of 11th International Meshing Roundtable},
  year = {2002},
  pages = {115-126}
}

@ARTICLE{ACDLD2003,
  author = {Pierre Alliez and David Cohen-Steiner and Olivier Devillers and Bruno L$\grave{e}$vy and Mathieu Desbrun},
  title = {Anisotropic polygonal remeshing},
  journal = {ACM Transactions on Graphics},
  year = {2003},
  volume = {22},
  pages = {485-493},
  number = {3}
}

repository: vivzqs/non-obtuse-remeshing

repo_name: vivzqs/non-obtuse-remeshing


text:
@proceedings{ws-2016-sigmorphon,
    title = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    editor = "Elsner, Micha  and
      Kuebler, Sandra",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2000",
    doi = "10.18653/v1/W16-20",
}
@inproceedings{zhang-2016-mining,
    title = "Mining linguistic tone patterns with symbolic representation",
    author = "Zhang, Shuo",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2001",
    doi = "10.18653/v1/W16-2001",
    pages = "1--9",
}
@inproceedings{cotterell-etal-2016-sigmorphon,
    title = "The {SIGMORPHON} 2016 Shared {T}ask{---}{M}orphological Reinflection",
    author = "Cotterell, Ryan  and
      Kirov, Christo  and
      Sylak-Glassman, John  and
      Yarowsky, David  and
      Eisner, Jason  and
      Hulden, Mans",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2002",
    doi = "10.18653/v1/W16-2002",
    pages = "10--22",
}
@inproceedings{ostling-2016-morphological,
    title = "Morphological reinflection with convolutional neural networks",
    author = {{\"O}stling, Robert},
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2003",
    doi = "10.18653/v1/W16-2003",
    pages = "23--26",
}
@inproceedings{alegria-etxeberria-2016-ehu,
    title = "{EHU} at the {SIGMORPHON} 2016 Shared Task. A Simple Proposal: Grapheme-to-Phoneme for Inflection",
    author = "Alegria, I{\~n}aki  and
      Etxeberria, Izaskun",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2004",
    doi = "10.18653/v1/W16-2004",
    pages = "27--30",
}
@inproceedings{nicolai-etal-2016-morphological,
    title = "Morphological Reinflection via Discriminative String Transduction",
    author = "Nicolai, Garrett  and
      Hauer, Bradley  and
      St Arnaud, Adam  and
      Kondrak, Grzegorz",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2005",
    doi = "10.18653/v1/W16-2005",
    pages = "31--35",
}
@inproceedings{liu-mao-2016-morphological,
    title = "Morphological reinflection with conditional random fields and unsupervised features",
    author = "Liu, Ling  and
      Mao, Lingshuang Jack",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2006",
    doi = "10.18653/v1/W16-2006",
    pages = "36--40",
}
@inproceedings{aharoni-etal-2016-improving,
    title = "Improving Sequence to Sequence Learning for Morphological Inflection Generation: The {BIU}-{MIT} Systems for the {SIGMORPHON} 2016 Shared Task for Morphological Reinflection",
    author = "Aharoni, Roee  and
      Goldberg, Yoav  and
      Belinkov, Yonatan",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2007",
    doi = "10.18653/v1/W16-2007",
    pages = "41--48",
}
@inproceedings{king-2016-evaluating,
    title = "Evaluating Sequence Alignment for Learning Inflectional Morphology",
    author = "King, David",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2008",
    doi = "10.18653/v1/W16-2008",
    pages = "49--53",
}
@inproceedings{sorokin-2016-using,
    title = "Using longest common subsequence and character models to predict word forms",
    author = "Sorokin, Alexey",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2009",
    doi = "10.18653/v1/W16-2009",
    pages = "54--61",
}
@inproceedings{kann-schutze-2016-med,
    title = "{MED}: The {LMU} System for the {SIGMORPHON} 2016 Shared Task on Morphological Reinflection",
    author = {Kann, Katharina  and
      Sch{\"u}tze, Hinrich},
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2010",
    doi = "10.18653/v1/W16-2010",
    pages = "62--70",
}
@inproceedings{taji-etal-2016-columbia,
    title = "The {C}olumbia University - New York University Abu Dhabi {SIGMORPHON} 2016 Morphological Reinflection Shared Task Submission",
    author = "Taji, Dima  and
      Eskander, Ramy  and
      Habash, Nizar  and
      Rambow, Owen",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2011",
    doi = "10.18653/v1/W16-2011",
    pages = "71--75",
}
@inproceedings{ma-etal-2016-letter,
    title = "Letter Sequence Labeling for Compound Splitting",
    author = "Ma, Jianqiang  and
      Henrich, Verena  and
      Hinrichs, Erhard",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2012",
    doi = "10.18653/v1/W16-2012",
    pages = "76--81",
}
@inproceedings{nguyen-cornips-2016-automatic,
    title = "Automatic Detection of Intra-Word Code-Switching",
    author = "Nguyen, Dong  and
      Cornips, Leonie",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2013",
    doi = "10.18653/v1/W16-2013",
    pages = "82--86",
}
@inproceedings{james-wieling-2016-read,
    title = "Read my points: Effect of animation type when speech-reading from {EMA} data",
    author = "James, Kristy  and
      Wieling, Martijn",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2014",
    doi = "10.18653/v1/W16-2014",
    pages = "87--92",
}
@inproceedings{kisselew-etal-2016-predicting,
    title = "Predicting the Direction of Derivation in {E}nglish Conversion",
    author = "Kisselew, Max  and
      Rimell, Laura  and
      Palmer, Alexis  and
      Pad{\'o}, Sebastian",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2015",
    doi = "10.18653/v1/W16-2015",
    pages = "93--98",
}
@inproceedings{nicolai-etal-2016-morphological-segmentation,
    title = "Morphological Segmentation Can Improve Syllabification",
    author = "Nicolai, Garrett  and
      Yao, Lei  and
      Kondrak, Grzegorz",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2016",
    doi = "10.18653/v1/W16-2016",
    pages = "99--103",
}
@inproceedings{declerck-lendvai-2016-towards,
    title = "Towards a Formal Representation of Components of {G}erman Compounds",
    author = "Declerck, Thierry  and
      Lendvai, Piroska",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2017",
    doi = "10.18653/v1/W16-2017",
    pages = "104--109",
}
@inproceedings{shoemark-etal-2016-towards,
    title = "Towards robust cross-linguistic comparisons of phonological networks",
    author = "Shoemark, Philippa  and
      Goldwater, Sharon  and
      Kirby, James  and
      Sarkar, Rik",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2018",
    doi = "10.18653/v1/W16-2018",
    pages = "110--120",
}
@inproceedings{aksenova-etal-2016-morphotactics,
    title = "Morphotactics as Tier-Based Strictly Local Dependencies",
    author = {Aks{\"e}nova, Al{\"e}na  and
      Graf, Thomas  and
      Moradi, Sedigheh},
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2019",
    doi = "10.18653/v1/W16-2019",
    pages = "121--130",
}
@inproceedings{meyer-dickinson-2016-multilinear,
    title = "A Multilinear Approach to the Unsupervised Learning of Morphology",
    author = "Meyer, Anthony  and
      Dickinson, Markus",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2020",
    doi = "10.18653/v1/W16-2020",
    pages = "131--140",
}
@inproceedings{zamaraeva-2016-inferring,
    title = "Inferring Morphotactics from Interlinear Glossed Text: Combining Clustering and Precision Grammars",
    author = "Zamaraeva, Olga",
    booktitle = "Proceedings of the 14th {SIGMORPHON} Workshop on Computational Research in Phonetics, Phonology, and Morphology",
    month = aug,
    year = "2016",
    address = "Berlin, Germany",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W16-2021",
    doi = "10.18653/v1/W16-2021",
    pages = "141--150",
}

repository: emorynlp/nlprankings

repo_name: emorynlp/nlprankings

gha_license_id: NOASSERTION


text:
const {
    MessageAttachment,
    MessageEmbed
} = require("discord.js");
const sendError = require("../util/error")
const api = require('canvacord')

    module.exports.run = async (client, message, args) => {
    	let userArray = message.content.split(" ");
    	let userArgs = userArray.slice(1);

    	let member = message.mentions.members.first() || message.guild.members.cache.get(userArgs[0]) || message.guild.members.cache.find(x => x.user.username.toLowerCase() === userArgs.slice(0).join(" ") || x.user.username === userArgs[0]) || message.member;

        let avatar = member.user.displayAvatarURL({dynamic: false, format: "png"});
		var rn = require('random-number');
		var options = {
  		min:  1,
		max:  100,
		integer: true
		}
        let image = await api.Canvas.brightness(avatar, rn(options));

        let brightness = new MessageAttachment(image, "brightness.gif")
        message.channel.send("Have you been moisturizing?", brightness);
		}
	module.exports.config = {
    	name: "brightness",
    	aliases: []
}

repository: ZerooCoding/MelloTunes

repo_name: ZerooCoding/MelloTunes

extension: js


text:
require mojomail.inc

SUMMARY = "SMTP transport service for sending emails"

DEPENDS += "mojomail-common c-ares"

inherit webos_system_bus

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

repository: Tofee/meta-webos-ports

repo_name: Tofee/meta-webos-ports

gha_language: BitBake


text:
SUMMARY = "Mobile device API extensions for Qt/Embedded 4.x"
SECTION = "libs"
qtm_embedded := "embedded"
qtm_dir = "qtopia"
qtm_glflags := "-=opengl"
qtm_extra_config := "gstreamer-photography_enabled = no"

inherit qt4e
require qt-mobility_${PV}.inc

repository: rdm-dev/meta-openembedded

repo_name: rdm-dev/meta-openembedded

branch_name: refs/heads/jethro


text:
package model

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"os"
	"strconv"
	"time"
)

// ResponseBody struct
type ResponseBody struct {
	Code    int
	Message string
}

type RequestData struct {
	ServerId   int64  `json:"serverId"`
	Type       int    `json:"type"`
	Item       string `json:"item"`
	Value      string `json:"value"`
	ReportTime string `json:"reportTime"`
}

// ResponseFail response state type
const (
	ResponseFail = iota
)

const (
	_ = iota
	TypeCPU
	TypeRAM
	TypeLoadavg
	TypeTcp
	TypePubNet
	TypeLoNet
	TypeDiskUsage
	TypeDiskIO
)

// DB init when the program start
var goployURL string
var goployServerID int64
var gClient = &http.Client{Timeout: 5 * time.Second}

// Init -
func Init() {
	goployURL = os.Getenv("GOPLOY_URL")
	goployServerID, _ = strconv.ParseInt(os.Getenv("GOPLOY_SERVER_ID"), 10, 64)

}

func Request(data RequestData) error {
	data.ServerId = goployServerID
	_url := fmt.Sprintf("%s%s", goployURL, "/agent/report")
	requestData := new(bytes.Buffer)
	_ = json.NewEncoder(requestData).Encode(data)
	requestStr := requestData.String()
	resp, err := gClient.Post(_url, "application/json", requestData)
	if err != nil {
		return errors.New(_url + " " + err.Error())
	}
	defer resp.Body.Close()
	var responseBody ResponseBody
	err = json.NewDecoder(resp.Body).Decode(&responseBody)
	if err != nil {
		return errors.New(_url + ", body: " + requestStr + " err: " + err.Error())
	} else if responseBody.Code > 0 {
		return errors.New(_url + ", body: " + requestStr + " message: " + responseBody.Message)
	}
	return nil
}

repository: EvanSung/goploy-agent

repo_name: EvanSung/goploy-agent


text:
@InProceedings{triantafillou10a,
  title = {Learning Causal Structure from Overlapping Variable Sets},
  author = {Sofia Triantafillou and Ioannis Tsamardinos and Ioannis Tollis},
  pages = {860--867},
  abstract = {We present an algorithm name cSAT+ for learning the causal structure in a domain from datasets measuring different variables sets. The algorithm outputs a graph with edges corresponding to all possible pairwise causal relations between two variables, named Pairwise Causal Graph (PCG). Examples of interesting inferences include the induction of the absence or presence of some causal relation between two variables never measured together. cSAT+ converts the problem to a series of SAT problems, obtaining leverage from the efficiency of state-of-the-art solvers. In our empirical evaluation, it is shown to outperform ION, the first algorithm solving a similar but more general problem, by two orders of magnitude.},
  pdf = {http://jmlr.org/proceedings/papers/v9/triantafillou10a/triantafillou10a.pdf},
}

repository: mreid/papersite

repo_name: mreid/papersite