text:
package json

import (
	"bytes"
	"testing"
	"time"
)

func TestValue(t *testing.T) {
	cases := map[string]struct {
		setter   func(Value)
		expected string
	}{
		"string value": {
			setter: func(value Value) {
				value.String("foo")
			},
			expected: `"foo"`,
		},
		"string escaped": {
			setter: func(value Value) {
				value.String(`{"foo":"bar"}`)
			},
			expected: `"{\"foo\":\"bar\"}"`,
		},
		"integer": {
			setter: func(value Value) {
				value.Integer(1024)
			},
			expected: `1024`,
		},
		"float": {
			setter: func(value Value) {
				value.Float(1e20)
			},
			expected: `100000000000000000000`,
		},
		"float exponent component": {
			setter: func(value Value) {
				value.Float(3e22)
			},
			expected: `3e+22`,
		},
		"boolean true": {
			setter: func(value Value) {
				value.Boolean(true)
			},
			expected: `true`,
		},
		"boolean false": {
			setter: func(value Value) {
				value.Boolean(false)
			},
			expected: `false`,
		},
		"byte slice": {
			setter: func(value Value) {
				value.ByteSlice([]byte("foo bar"))
			},
			expected: `"Zm9vIGJhcg=="`,
		},
		"byte slice nil": {
			setter: func(value Value) {
				value.ByteSlice(nil)
			},
			expected: `null`,
		},
		"time": {
			setter: func(value Value) {
				value.Time(time.Date(2019, 1, 2, 3, 4, 5, 6, time.UTC), "iso8601")
			},
			expected: `"2019-01-02T03:04:05Z"`,
		},
		"object": {
			setter: func(value Value) {
				o := value.Object()
				defer o.Close()
				o.Key("key").String("value")
			},
			expected: `{"key":"value"}`,
		},
		"array": {
			setter: func(value Value) {
				o := value.Array()
				defer o.Close()
				o.Value().String("value1")
				o.Value().String("value2")
			},
			expected: `["value1","value2"]`,
		},
		"null": {
			setter: func(value Value) {
				value.Null()
			},
			expected: `null`,
		},
	}
	scratch := make([]byte, 64)

	for name, tt := range cases {
		t.Run(name, func(t *testing.T) {
			var b bytes.Buffer
			value := newValue(&b, &scratch)

			tt.setter(value)

			if e, a := []byte(tt.expected), b.Bytes(); bytes.Compare(e, a) != 0 {
				t.Errorf("expected %+q, but got %+q", e, a)
			}
		})
	}
}


text:
@online{noauthor_bayesian_nodate,
	title = {Bayesian Inference Using {OpenBUGS} R Tutorial},
	url = {http://www.r-tutor.com/bayesian-statistics/openbugs},
	urldate = {2013-09-03}
}

repository: pmean/build-website

license_type: permissive

repo_name: pmean/build-website

branch_name: refs/heads/master

extension: bib


text:
package models

import "time"

type Board struct {
	Name     string `json:"name"`
	Id       string `json:"id"`
	ShortUrl string `json:"shortUrl"`
}

type Action struct {
	Id       string `json:"id"`
	ListId   string `json:"idList"`
	Name     string `json:"name"`
	Badge    Badge  `json:"badges"`
	Comments []Comment
}

type Badge struct {
	Comments    int `json:"comments"`
	Attachments int `json:"attachments"`
}

type List struct {
	Id       string `json:"id"`
	Name     string `json:"name"`
	Position int64  `json:"pos"`
}

type ListMap struct {
	Id      string
	Name    string
	Actions []Action
}

type Comment struct {
	Type   string    `json:"type"`
	Data   Data      `json:"data"`
	Date   time.Time `json:"date"`
	Member Member    `json:"memberCreator"`
}

type Data struct {
	Text string `json:"text"`
	Card Card   `json:"card"`
}

type Member struct {
	Id       string `json:"id"`
	UserName string `json:"username"`
	FullName string `json:"fullName"`
}

type Card struct {
	Id          string `json:"id"`
	Name        string `json:"name"`
	Description string `json:"desc"`
}

license: MIT

repository: Elpulgo/trello

repo_name: Elpulgo/trello

extension: go


text:
DESCRIPTION = "Node nvd3"
HOMEPAGE = "https://www.npmjs.com/package/nvd3"
MAINTAINER = "Dmitry Dvorkin <dvorkin@tibbo.com>"
LICENSE = "MIT"
SECTION = "nodejs/module"

LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

inherit npm

SRC_URI  = "git://github.com/novus/nvd3.git;protocol=git;tag=v${PV}"

S = "${WORKDIR}/git"

extension: bb


text:
@Inbook{editor00,
  author = 	 "",
  editor =       "Ian Editor",
  title =        "The title of book one",
  subtitle =     "The book subtitle",
  series =       "The name of the series one",
  year =         "2007",
  volume = 	 "9",
  address =      "Chicago",
  edition =      "1st.",
  publisher =    "University of Chicago Press",
  doi = 	 "10.1007/3-540-09237-4",
  url = 	 "http://dx.doi.org/10.1007/3-540-09456-9",
  OPTchapter = 	 "",
  OPTpages = 	 "",
  OPTnumber = 	 "",
  OPTtype = 	 "",
  OPTmonth = 	 "",
  OPTnote = 	 "",
}

@Inbook{las_gergor00,
  author = 	 "Gregor von Laszewski",
  editor =       "Ian Editor",
  title =        "The title of book one",
  subtitle =     "The book subtitle",
  series =       "The name of the series one",
  year =         "2007",
  volume = 	 "9",
  address =      "Chicago",
  edition =      "1st.",
  publisher =    "University of Chicago Press",
  doi = 	 "10.1007/3-540-09237-4",
  url = 	 "http://dx.doi.org/10.1007/3-540-09456-9",
  OPTchapter = 	 "",
  OPTpages = 	 "",
  OPTnumber = 	 "",
  OPTtype = 	 "",
  OPTmonth = 	 "",
  OPTnote = 	 "",
}


text:
var mimg;
var cimg;
var imimg;
var ieimg;
var enimg;
var seimg;
var eximg;

function uploadMainImage(){
  var can1 = document.getElementById("can1");
  var imgfile = document.getElementById("mimgfile")
  mimg = new SimpleImage(imgfile);
  mimg.drawTo(can1);
}

function uploadToHideImage(){
  var can2 = document.getElementById("can2");
  var imgfile = document.getElementById("cimgfile")
  cimg = new SimpleImage(imgfile);
  cimg.drawTo(can2);
}

function front4bits(colorvalue){
  var x = Math.floor(colorvalue/16) * 16;
  return x;
}
function last4bits(colorvalue){
  var x = colorvalue/16;
  return x;
}

function generateIMI(){
  imimg = mimg;
  var can3 = document.getElementById("can3");
  for(var px of imimg.values()){
    px.setRed(front4bits(px.getRed()));
    px.setBlue(front4bits(px.getBlue()));
    px.setGreen(front4bits(px.getGreen()));

  }
  imimg.drawTo(can3);
}

function generateIHI(){
  ieimg = cimg;
  var can4 = document.getElementById("can4");
  for(var px of ieimg.values()){
    px.setRed(last4bits(px.getRed()));
    px.setBlue(last4bits(px.getBlue()));
    px.setGreen(last4bits(px.getGreen()));

  }
  ieimg.drawTo(can4);
}

function composite(){
  var can5 = document.getElementById("can5");
  enimg = new SimpleImage(ieimg.getWidth(),ieimg.getHeight());

  for(var px of enimg.values()){
    var x = px.getX();
    var y = px.getY();
    var mp = imimg.getPixel(x,y);
    var ep = ieimg.getPixel(x,y);
    px.setRed(mp.getRed() + ep.getRed());
    px.setBlue(mp.getBlue() + ep.getBlue());
    px.setGreen(mp.getGreen() + ep.getGreen());
  }

  enimg.drawTo(can5);
  seimg = new SimpleImage(enimg);
}

function selectfor(){
  var can6 = document.getElementById("can6");

  seimg.drawTo(can6);

}

function reset(){
  mimg=cimg=imimg=ieimg=enimg=null;
}

function uploadencryptedimage(){

  var can6 = document.getElementById("can6");
  var imgfile = document.getElementById("enfile");
  seimg = new SimpleImage(imgfile);
  seimg.drawTo(can6);
}

function extract(){
  var eximg = new SimpleImage(seimg.getWidth(),seimg.getHeight());

  var can7 = document.getElementById("can7");
  for(var px of eximg.values())
  {
    var x = px.getX();
    var y = px.getY();
    var ep = seimg.getPixel(x,y);
    px.setRed((ep.getRed()%16)*16);
    px.setBlue((ep.getBlue()%16)*16);
    px.setGreen((ep.getGreen()%16)*16);
  }
  eximg.drawTo(can7);
}

repository: Mishra-Sagar/Steganographer

repo_name: Mishra-Sagar/Steganographer

extension: js


text:
package chunkstore

import (
	"compress/gzip"
	"compress/zlib"
	"encoding/binary"
	"fmt"
	"io"
	"os"
	"path"

	. "chunkymonkey/types"
	"chunkymonkey/util"
)

const (
	regionFileEdge       = 32
	regionFileEdgeShift  = 5
	regionFileSectorSize = 4096
)

type chunkStoreBeta struct {
	regionPath  string
	regionFiles map[uint64]*regionFileReader
}

// Creates a chunkStoreBeta that reads the Minecraft Beta world format.
func newChunkStoreBeta(worldPath string, dimension DimensionId) *chunkStoreBeta {
	s := &chunkStoreBeta{
		regionFiles: make(map[uint64]*regionFileReader),
	}

	if dimension == DimensionNormal {
		s.regionPath = path.Join(worldPath, "region")
	} else {
		s.regionPath = path.Join(worldPath, fmt.Sprintf("DIM%d", dimension), "region")
	}

	return s
}

func (s *chunkStoreBeta) LoadChunk(chunkLoc ChunkXz) (reader IChunkReader, err os.Error) {
	regionLoc := regionLocForChunkXz(chunkLoc)

	var cfr *regionFileReader
	cfr, ok := s.regionFiles[regionLoc.regionKey()]
	if !ok {
		// TODO limit number of regionFileReader objs to a maximum number of
		// most-frequently-used regions. Close regionFileReader objects when no
		// longer needed.
		filePath := regionLoc.regionFilePath(s.regionPath)
		cfr, err = newRegionFileReader(filePath)
		if err != nil {
			if errno, ok := util.Errno(err); ok && errno == os.ENOENT {
				err = NoSuchChunkError(false)
			}
			return
		}
		s.regionFiles[regionLoc.regionKey()] = cfr
	}

	chunkReader, err := cfr.ReadChunkData(chunkLoc)
	if chunkReader != nil {
		reader = chunkReader
	}

	return
}

// A chunk file header entry.
type chunkOffset uint32

// Returns true if the offset value states that the chunk is present in the
// file.
func (o chunkOffset) IsPresent() bool {
	return o != 0
}

func (o chunkOffset) Get() (sectorCount, sectorIndex uint32) {
	sectorCount = uint32(o & 0xff)
	sectorIndex = uint32(o >> 8)
	return
}

// Represents a chunk file header containing chunk data offsets.
type regionFileHeader [regionFileEdge * regionFileEdge]chunkOffset

// Returns the chunk offset data for the given chunk. It assumes that chunkLoc
// is within the chunk file - discarding upper bits of the X and Z coords.
func (h regionFileHeader) Offset(chunkLoc ChunkXz) chunkOffset {
	x := chunkLoc.X & (regionFileEdge - 1)
	z := chunkLoc.Z & (regionFileEdge - 1)
	return h[x+(z<<regionFileEdgeShift)]
}

// Represents the header of a single chunk of data within a chunkfile.
type chunkDataHeader struct {
	DataSize uint32
	Version  byte
}

// Returns an io.Reader to correctly decompress data from the chunk data.
// The reader passed in must be just after the chunkDataHeader in the source
// data stream. The caller is responsible for closing the returned ReadCloser.
func (cdh *chunkDataHeader) DataReader(raw io.Reader) (output io.ReadCloser, err os.Error) {
	limitReader := io.LimitReader(raw, int64(cdh.DataSize))
	switch cdh.Version {
	case 1:
		output, err = gzip.NewReader(limitReader)
	case 2:
		output, err = zlib.NewReader(limitReader)
	default:
		err = os.NewError("Chunk data header contained unknown version number.")
	}
	return
}

// Handle on a chunk file - used to read chunk data from the file.
type regionFileReader struct {
	offsets regionFileHeader
	file    *os.File
}

func newRegionFileReader(filePath string) (cfr *regionFileReader, err os.Error) {
	file, err := os.Open(filePath)
	if err != nil {
		if sysErr, ok := err.(*os.SyscallError); ok && sysErr.Errno == os.ENOENT {
			err = NoSuchChunkError(false)
		}
		return
	}

	cfr = &regionFileReader{
		file: file,
	}

	err = binary.Read(file, binary.BigEndian, &cfr.offsets)
	if err != nil {
		cfr = nil
		return
	}

	return
}

func (cfr *regionFileReader) Close() {
	cfr.file.Close()
}

func (cfr *regionFileReader) ReadChunkData(chunkLoc ChunkXz) (r *nbtChunkReader, err os.Error) {
	offset := cfr.offsets.Offset(chunkLoc)

	if !offset.IsPresent() {
		// Chunk doesn't exist in file
		err = NoSuchChunkError(false)
		return
	}

	sectorCount, sectorIndex := offset.Get()

	if sectorIndex == 0 || sectorCount == 0 {
		err = os.NewError("Header gave bad chunk offset.")
		return
	}

	cfr.file.Seek(int64(sectorIndex)*regionFileSectorSize, 0)

	// 5 is the size of chunkDataHeader in bytes.
	maxChunkDataSize := (sectorCount * regionFileSectorSize) - 5

	var header chunkDataHeader
	binary.Read(cfr.file, binary.BigEndian, &header)
	if header.DataSize > maxChunkDataSize {
		err = os.NewError("Chunk is too big for the sectors it is within.")
		return
	}

	dataReader, err := header.DataReader(cfr.file)
	if err != nil {
		return
	}
	defer dataReader.Close()

	r, err = newNbtChunkReader(dataReader)

	return
}

type regionCoord int32

type regionLoc struct {
	X, Z regionCoord
}

func regionLocForChunkXz(chunkLoc ChunkXz) regionLoc {
	return regionLoc{
		regionCoord(chunkLoc.X >> regionFileEdgeShift),
		regionCoord(chunkLoc.Z >> regionFileEdgeShift),
	}
}

func (loc *regionLoc) regionKey() uint64 {
	return uint64(loc.X)<<32 | uint64(uint32(loc.Z))
}

func (loc *regionLoc) regionFilePath(regionPath string) string {
	return path.Join(
		regionPath,
		fmt.Sprintf("r.%d.%d.mcr", loc.X, loc.Z),
	)
}

repository: nictuku/chunkymonkey

repo_name: nictuku/chunkymonkey


text:
DESCRIPTION = "Programmable Completion for Bash"
SECTION = "console/utils"
RDEPENDS_${PN} = "bash"
LICENSE = "GPL"
PR = "r1"

SRC_URI = "http://www.caliban.org/files/bash/bash-completion-${PV}.tar.gz \
	   file://bash_completion.sh"
S = "${WORKDIR}/bash_completion"

do_configure() {
	:
}

do_compile() {
	:
}

do_install() {
	install -d ${D}${sysconfdir}/profile.d
	install -m 0755 ${WORKDIR}/bash_completion.sh ${D}${sysconfdir}/profile.d
	install -m 0755 bash_completion ${D}${sysconfdir}
	install -d ${D}${sysconfdir}/bash_completion.d/
	install -m 0755 contrib/* ${D}${sysconfdir}/bash_completion.d/
}

SRC_URI[md5sum] = "90ee706965dbf7b24515220d3bdc1f85"
SRC_URI[sha256sum] = "8e4ddca8aa5ae4261bfcba056292aec4c8bf26fe847e01b67f4b3065fc512a54"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
################################################################################
#
# T:N.U.N. Main build (compiler&linker) options file.
#
# Copyright (c) 2016 - 2017. Domagoj Saric.
#
################################################################################

################################################################################
#
# add_compile_options()
#
################################################################################

# Similar to the builtin add_compile_options, but receives build configuration as a first
# parameter. Abstracts-away usage of generator expressions.
function( TNUN_add_compile_options configuration )
    # Implementation note:
    # The builtin add_compile_options() seems broken (w/ CMake 3.5.2) when used
    # with multiple options: the "$<1" and ">" suffix end up in the compiler
    # options.
    # https://cmake.org/cmake/help/v3.5/command/add_compile_options.html
    # https://cmake.org/pipermail/cmake-developers/2012-August/016617.html
    # http://stackoverflow.com/a/35361099/6041906
    #                                         (14.05.2016.) (Domagoj Saric)
    foreach( arg ${ARGN} )
        add_compile_options( $<$<CONFIG:${configuration}>:${arg}> )
    endforeach()
endfunction()

function( TNUN_target_compile_options configuration target visibility )
    foreach( arg ${ARGN} )
        target_compile_options( ${target} ${visibility} $<$<CONFIG:${configuration}>:${arg}> )
    endforeach()
endfunction()

# Similar to the builtin add_compile_options, but applies given options
# only to the c++ sources.
function( TNUN_add_cxx_compile_options )
    if( ${CMAKE_GENERATOR} MATCHES "Visual Studio" )
        add_compile_options( ${ARGV} )
    else()
        foreach( arg ${ARGV} )
            add_compile_options( $<$<COMPILE_LANGUAGE:CXX>:${arg}> )
        endforeach()
    endif()
endfunction()

# Behaves as the combination of TNUN_add_compile_options and
# TNUN_add_cxx_compile_options - it applies given options to only
# C++ sources for given build configuration.
function( TNUN_add_cxx_compile_options_for_config configuration )
    if( ${CMAKE_GENERATOR} MATCHES "Visual Studio" )
        foreach( arg ${ARGN} )
            add_compile_options( $<$<CONFIG:${configuration}>:${arg}> )
        endforeach()
    else()
        foreach( arg ${ARGN} )
            add_compile_options( $<$<AND:$<CONFIG:${configuration}>,$<COMPILE_LANGUAGE:CXX>>:${arg}> )
        endforeach()
    endif()
endfunction()

# Removes already set compile options for given configuration.
# Useful for unsetting flags set with the TNUN_add_compile_options
function( TNUN_remove_compile_options_for_config configuration )
    string( TOUPPER ${configuration} configuration )
    get_directory_property( current_compile_options COMPILE_OPTIONS )
    foreach( arg ${ARGN} )
        set( option $<$<CONFIG:${configuration}>:${arg}> )
        string( REPLACE "${option}" "" current_compile_options "${current_compile_options}" )
    endforeach()
    set_directory_properties( PROPERTIES COMPILE_OPTIONS "${current_compile_options}" )
endfunction()

# Removes given compile options if they are already set.
# Useful for undoing CMake's builtin add_compile_options.
function( TNUN_remove_compile_options )
    get_directory_property( current_compile_options COMPILE_OPTIONS )
    foreach( option ${ARGN} )
        string( REPLACE "${option}" "" current_compile_options "${current_compile_options}" )
    endforeach()
    set_directory_properties( PROPERTIES COMPILE_OPTIONS "${current_compile_options}" )
endfunction()

# Removes given compile options from given target for given build type.
# Useful for undoing CMake's builtin target_compile_options
function( TNUN_target_remove_compile_options_for_config target configuration )
    string( TOUPPER ${configuration} configuration )
    get_target_property( current_compile_options ${target} COMPILE_OPTIONS )
    foreach( arg ${ARGN} )
        set( option $<$<CONFIG:${configuration}>:${arg}> )
        string( REPLACE "${option}" "" current_compile_options "${current_compile_options}" )
    endforeach()
    set_target_properties( ${target} PROPERTIES COMPILE_OPTIONS "${current_compile_options}" )
endfunction()

# Removes given compile options from given target.
# Useful for undoing CMake's builtin target_compile_options
function( TNUN_target_remove_compile_options target )
    string( TOUPPER ${configuration} configuration )
    get_target_property( current_compile_options ${target} COMPILE_OPTIONS )
    foreach( arg ${ARGN} )
        set( option ${arg} )
        string( REPLACE "${option}" "" current_compile_options "${current_compile_options}" )
    endforeach()
    set_target_properties( ${target} PROPERTIES COMPILE_OPTIONS "${current_compile_options}" )
endfunction()

################################################################################
#
# add_link_options()
#
################################################################################

# Similar to CMake's builtin add_link_options, but applies given options only
# to given build type.
function( TNUN_add_link_options configuration )
    # Implementation note:
    # The documented feature of link_libraries(), that it also accepts linker
    # options, is (ab)used here to simulate add_compile_options() behaviour.
    # https://cmake.org/cmake/help/latest/prop_tgt/LINK_LIBRARIES.html
    #                                         (01.06.2016.) (Domagoj Saric)
    foreach( arg ${ARGN} )
        add_link_options( $<$<CONFIG:${configuration}>:${arg}> )
    endforeach()
endfunction()

function( TNUN_target_link_options configuration target visibility )
    foreach( arg ${ARGN} )
        target_link_options( ${target} ${visibility} $<$<CONFIG:${configuration}>:${arg}> )
    endforeach()
endfunction()

# Removes given link options for given build type.
# Useful for undoing the effect of TNUN_add_link_options
function( TNUN_remove_link_options_for_config configuration )
    string( TOUPPER ${configuration} configuration )
    get_directory_property( current_link_options LINK_OPTIONS )
    foreach( arg ${ARGN} )
        set( option $<$<CONFIG:${configuration}>:${arg}> )
        string( REPLACE "${option}" "" current_link_options "${current_link_options}" )
    endforeach()
    set_directory_properties( PROPERTIES LINK_OPTIONS "${current_link_options}" )
endfunction()

# Removes given link options.
# Useful for undoing CMake's builtin add_link_options.
function( TNUN_remove_link_options )
    get_directory_property( current_link_options LINK_OPTIONS )
    foreach( option ${ARGN} )
        string( REPLACE "${option}" "" current_link_options "${current_link_options}" )
    endforeach()
    set_directory_properties( PROPERTIES LINK_OPTIONS "${current_link_options}" )
endfunction()

# Removes given link options from given target for given build type.
# Useful for undoing CMake's builtin target_link_options.
function( TNUN_target_remove_link_options_for_config target configuration )
    string( TOUPPER ${configuration} configuration )
    get_target_property( current_link_options ${target} LINK_OPTIONS )
    foreach( arg ${ARGN} )
        set( option $<$<CONFIG:${configuration}>:${arg}> )
        string( REPLACE "${option}" "" current_link_options "${current_link_options}" )
    endforeach()
    set_target_properties( ${target} PROPERTIES LINK_OPTIONS "${current_link_options}" )
endfunction()

# Removes given link options from given target.
# Useful for undoing CMake's builtin target_link_options.
function( TNUN_target_remove_link_options target )
    string( TOUPPER ${configuration} configuration )
    get_target_property( current_link_options ${target} LINK_OPTIONS )
    foreach( arg ${ARGN} )
        set( option ${arg} )
        string( REPLACE "${option}" "" current_link_options "${current_link_options}" )
    endforeach()
    set_target_properties( ${target} PROPERTIES LINK_OPTIONS "${current_link_options}" )
endfunction()

################################################################################
# default options
################################################################################

# http://www.cmake.org/Wiki/CMake_Cross_Compiling
# https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html
# http://stackoverflow.com/questions/12802377/in-cmake-how-can-i-find-the-directory-of-an-included-file
if ( WIN32 ) # TODO: add detection of Windows Phone / Windows Universal platform
    include( "${CMAKE_CURRENT_LIST_DIR}/toolchains/windows.toolchain.cmake" )
elseif( APPLE AND NOT iOS )
    include( "${CMAKE_CURRENT_LIST_DIR}/toolchains/osx.toolchain.cmake" )
elseif( ${CMAKE_SYSTEM_NAME} MATCHES "Linux" )
    include( "${CMAKE_CURRENT_LIST_DIR}/toolchains/linux.toolchain.cmake" )
elseif( ANDROID_TOOLCHAIN ) # TNUN android.toolchain.cmake does not define this variable, while native Android Studio toolchain does
    include( "${CMAKE_CURRENT_LIST_DIR}/toolchains/android-studio.toolchain.cmake" )
elseif( EMSCRIPTEN )
    include( "${CMAKE_CURRENT_LIST_DIR}/toolchains/emscripten.cmake" )
else()
    # Android and iOS (crosscompiling platforms) have to specify the toolchain
    # file explicitly.
endif()

################################################################################
# malloc overcommit policies
# https://www.etalabs.net/overcommit.html
################################################################################

list( APPEND TNUN_common_compile_definitions
    TNUN_OVERCOMMIT_Disabled=0
    TNUN_OVERCOMMIT_Partial=1
    TNUN_OVERCOMMIT_Full=2
    TNUN_MALLOC_OVERCOMMIT=TNUN_OVERCOMMIT_${TNUN_MALLOC_OVERCOMMIT_POLICY}
)

if ( TNUN_MALLOC_OVERCOMMIT_POLICY STREQUAL Full )
    list( APPEND TNUN_common_compile_definitions TNUN_NOEXCEPT_EXCEPT_BADALLOC=noexcept )
else()
    list( APPEND TNUN_common_compile_definitions TNUN_NOEXCEPT_EXCEPT_BADALLOC= )
endif()

# Implementation note:
# A workaround for the fact that the ios.universal_build.sh script uses
# 'intermediate' configuration types (*-iphoneos and *-simulator) one of which
# ends up being passed to CPack.
#                                             (15.03.2016.) (Domagoj Saric)
if ( iOS )
    set( install_configs "" )
else()
    set( install_configs Release )
endif()

set( TNUN_compiler_dev_release_flags ${TNUN_compiler_release_flags} )
if ( CMAKE_CXX_COMPILER_ID STREQUAL "MSVC"  ) # real MSVC, not clang-cl
    string( REPLACE "MD" "MDd" TNUN_compiler_dev_release_flags "${TNUN_compiler_dev_release_flags}" )
endif()
list( APPEND TNUN_compiler_release_flags -DNDEBUG )
if( NOT TNUN_DO_NOT_ADD_DEFAULT_BUILD_FLAGS )
    TNUN_add_compile_options( Debug          ${TNUN_compiler_debug_flags}       ${TNUN_compiler_debug_symbols} )
    TNUN_add_compile_options( Release        ${TNUN_compiler_release_flags}                                    )
    TNUN_add_compile_options( RelWithDebInfo ${TNUN_compiler_dev_release_flags} ${TNUN_compiler_debug_symbols} )

    add_compile_options    ( ${TNUN_common_compiler_options} ${TNUN_default_warnings} )
    add_compile_definitions( ${TNUN_common_compile_definitions}                       )
    add_link_options       ( ${TNUN_common_link_options}                              )
    TNUN_add_link_options  ( Debug          ${TNUN_linker_debug_flags}                )
    TNUN_add_link_options  ( Release        ${TNUN_linker_release_flags}              )
    TNUN_add_link_options  ( RelWithDebInfo ${TNUN_linker_dev_release_flags}          )
endif()

repository: microblink/build

repo_name: microblink/build

gha_language: CMake

extension: cmake


text:
DESCRIPTION = "Tokyo Cabinet is a library of routines for managing a database. The database is a simple data file containing records, each is a pair of a key and a value. Every key and value is serial bytes with variable length. Both binary data and character string can be used as a key and a value. There is neither concept of data tables nor data types. Records are organized in hash table, B+ tree, or fixed-length array."
SECTION = "database"
LICENSE = "GPL"
LIC_FILES_CHKSUM = "file://COPYING;md5=7fbc338309ac38fefcd64b04bb903e34"

SRC_URI = "http://fallabs.com/tokyocabinet/${PN}-${PV}.tar.gz"
SRC_URI[md5sum] = "fd03df6965f8f56dd5b8518ca43b4f5e"
SRC_URI[sha256sum] = "a003f47c39a91e22d76bc4fe68b9b3de0f38851b160bbb1ca07a4f6441de1f90"

DEPENDS = "zlib bzip2"

inherit gettext autotools-brokensep

EXTRA_OEMAKE += " PREFIX=/usr "

do_configure_prepend(){
    sed -i 's/^PATH=.*//g' configure.in
    sed -i 's/^CPATH=.*//g' configure.in
    sed -i 's/^LIBRARY_PATH=.*//g' configure.in
    sed -i 's/^LD_LIBRARY_PATH=.*//g' configure.in
    sed -i 's/^PKG_CONFIG_PATH=.*//g' configure.in
    sed -i -e "s:^MYCPPFLAGS=\"-I.*:MYCPPFLAGS=\"-I. -I${STAGING_INCDIR}\":" configure.in
    sed -i 's/^MYLDFLAGS=.*/MYLDFLAGS=\"-L\.\"/g' configure.in

}

repository: Securepoint/yocto-meta-securepoint

repo_name: Securepoint/yocto-meta-securepoint


text:
// Copyright (c) 2016 Eric Barkie. All rights reserved.
// Use of this source code is governed by the MIT license
// that can be found in the LICENSE file.

package query

import (
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestIndexedWC(t *testing.T) {
	d := Data{}
	d.SetIntf(Indexed{Format: "hum#", Begin: 1, Zero: 1, Width: 2}, 1)
	d.SetIntf(Indexed{Format: "hum#", Begin: 1, Zero: 1, Width: 2}, 2)
	assert.Equal(t, map[string]string{
		"hum":   "1",
		"hum02": "2",
	}, d.Values())
}

func TestIndexedWU(t *testing.T) {
	d := Data{}
	d.SetFloatf(Indexed{Format: "temp#f", Begin: 1, Zero: 1}, 1.0)
	d.SetFloatf(Indexed{Format: "temp#f", Begin: 1, Zero: 1}, 2.0)
	assert.Equal(t, map[string]string{
		"tempf":  "1",
		"temp2f": "2",
	}, d.Values())
}

repository: ebarkie/http

repo_name: ebarkie/http


text:
@inproceedings{andresen_design_2016,
 address = {Baltimore, Maryland, United States},
 author = {Shafique, Atia and Durmaz, Emre C. and Cetindogan, Barbaros and Yazici, Melik and Kaynak, Mehmet and Kaynak, Canan B. and Gurbuz, Yasar},
 doi = {10.1117/12.2224778},
 editor = {Andresen, Bjørn F. and Fulop, Gabor F. and Hanson, Charles M. and Miller, John L. and Norton, Paul R.},
 month = {May},
 pages = {98191T},
 title = {Design of monocrystalline Si/SiGe multi-quantum well microbolometer detector for infrared imaging systems},
 url = {http://proceedings.spiedigitallibrary.org/proceeding.aspx?doi=10.1117/12.2224778},
 urldate = {2019-08-14},
 year = {2016}
}

repository: melikyazici/academic-kickstart

repo_name: melikyazici/academic-kickstart


text:
@inproceedings{rizvi2020,
    title = {NIT-Agartala-NLP-Team at EXIST 2022: Sexism Identification in Social Networks},
   author = {Rizvi, Amaan  and Jamatia, Anupam},
    booktitle = {Proceedings of the Iberian Languages Evaluation Forum (IberLEF 2022)},
    month = {Sept},
    year = {2022},
    address = {A Coruña, Spain},
    publisher = {CEUR Workshop Proceedings (CEUR-WS.org) Free Open-Access Proceedings for Computer Science Workshops},
    volume={Vol-3202},
    pages = {},
    url = {http://ceur-ws.org/Vol-3202/},
    doi = {urn:nbn:de:0074-3202-9}
 }

@inproceedings{swamyEA2019-000,
    title = {Studying Generalisability across Abusive Language Detection Datasets},
   uthor = {Swamy, Steve Durairaj  and
      Jamatia, Anupam  and Gamb{\"a}ck, Bj{\"o}rn},
    booktitle = {Proceedings of the 23rd Conference on Computational Natural Language Learning (CoNLL)},
    month = {nov},
    year = {2019},
    address = {Hong Kong, China},
    publisher = {Association for Computational Linguistics},
    pages = {940--950},
    url = {https://www.aclweb.org/anthology/K19-1088},
    doi = {10.18653/v1/K19-1088}
 }

@InProceedings{PendyalaEA2019-000,
  author    = {Pendyala, Vamsi Krishna  and  Sinha, Simran  and  Prakash, Satya  and  Reddy, Shriya  and  Jamatia, Anupam},
  title     = {Validation of Facts Against Textual Sources},
  booktitle = {Natural Language Processing in a Deep Learning World},
  month     = {September},
  year      = {2019},
  address   = {Varna, Bulgaria},
  publisher = {INCOMA Ltd.},
  pages     = {895--903},
  url       = {https://doi.org/10.26615/978-954-452-056-4_104}
}

@InProceedings{jamatiaEA2015-000,
  author = {Jamatia, Anupam  and Gamb{\"a}ck, Bj{\"o}rn and Das, Amitava},
  title = {Part-of-Speech Tagging for Code-Mixed English-Hindi Twitter and Facebook Chat Messages},
  booktitle ={Proceedings of the International Conference Recent Advances in Natural Language Processing},
  year = {2015},
  publisher = {INCOMA Ltd. Shoumen, Bulgaria},
  pages =   "239--248"
}

@inproceedings{jamatiaEA2018a-000,
  title={Rating Prediction of Tourist Destinations Based on Supervised Machine Learning Algorithms},
  author={Jamatia, Anupam and
          Baidya, Udayan and
          Paul, Sonalika and
          Debbarma Swaraj and
          Dey, Subham},
  booktitle={Proceedings of the International Conference on Computational Intelligence in Data Mining (In Press)},
  year={2018}
}

@inproceedings{MaheshwariEA2017-000,
  author = {Maheshwari, Tushar
    and Reganti, Aishwarya N.
    and Gupta, Samiksha
    and Jamatia, Anupam
    and Kumar, Upendra
    and Gamb{\"a}ck, Bj{\"o}rn
    and Das, Amitava},
  title = {A Societal Sentiment Analysis: Predicting the Values and Ethics of Individuals by Analysing Social Media Content},
  booktitle = {Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 1},
  publisher =  {Association for Computational Linguistics},
  pages =   {731--741},
  year =  {2017}
 }

@inproceedings{jamatiaEA2018-000,
  author    = {Anupam Jamatia and
               Bj{\"{o}}rn Gamb{\"{a}}ck and
               Amitava Das},
  title     = {Collecting and Annotating Indian Social Media Code-Mixed Corpora},
  booktitle = {CICLing {(2)}},
  series    = {Lecture Notes in Computer Science},
  volume    = {9624},
  pages     = {406--417},
  publisher = {Springer},
  year      = {2016}
}

@inproceedings{RudrapalEA2015-000,
  author = {Rudrapal, Dwijen
    and Jamatia, Anupam
    and Chakma, Kunal
    and Das, Amitava
    and Gamb{\"a}ck, Bj{\"o}rn},
  title = {Sentence Boundary Detection for Social Media Text},
  booktitle = {Proceedings of the 12th International Conference on Natural Language Processing (ICON)},
  year = {2015},
  publisher =  {NLP Association of India},
  pages = {254--260}

}

@inproceedings{Jamatia_Das2014-000,
  title={Part-of-speech tagging system for indian social media text on twitter},
  author={Jamatia, Anupam and Das, Amitava},
  booktitle={Social-India 2014, First Workshop on Language Technologies for Indian Social Media Text, at the Eleventh International Conference on Natural Language Processing (ICON-2014)},
  pages={21--28},
  year={2014}
}

@inproceedings{Jamatia_Das2016-000,
  title={Task Report: Tool Contest on POS Tagging for Code-mixed Indian Social Media (Facebook, Twitter, and Whatsapp) Text@ ICON 2016.”},
  author={Jamatia, Anupam and Das, Amitava},
  journal={the proceeding of ICON 2016},
  year={2016}
}

@InProceedings{SwamyEASemEval2019task6-000,
  author    = {Steve Durairaj Swamy, Anupam Jamatia, Bj\"orn Gamb\"ack, Amitava Das},
  title     = {NIT_Agartala_NLP_Team at SemEval-2019 Task 6:An Ensemble Approach to Identifying and Categorizing Offensive Language in Twitter Social Media Corpora},
  booktitle = {Proceedings of the Thirteenth International Workshop on Semantic Evaluation},
  series    = {SemEval '19},
  month     = {June},
  year      = {2019},
  address   = {Minneapolis, Minnesota, USA},
  publisher = {Association for Computational Linguistics},
  pages = "692--699",
}

@InProceedings{SwamyEASemEval2020task8,
  author    = {Steve Durairaj Swamy, Shubham Laddha, Basil Abdussalam, Debayan Datta and Anupam Jamatia},
  title     = {NIT-Agartala-NLP-Team at SemEval-2020 Task 8: Building Multimodal Classifiers to tackle Internet Humor},
  booktitle = {Proceedings of the Fourteen International Workshop on Semantic Evaluation},
  series    = {SemEval '20},
  month     = {June},
  year      = {2020},
  address   = {},
  publisher = {Association for Computational Linguistics},
  pages = {},
}

@article{JamatiaEA_J2018-000,
	journal = {Journal of Intelligent Systems},
	author = {Anupam Jamatia and Amitava Das and Bj\"orn Gamb\"ack},
	title = {Deep Learning-Based Language Identification in English-Hindi-Bengali Code-Mixed Social Media Corpora},
	year = {2018}
}

@article{JamatiaEA2018-000,
  journal   = {Research in Computing Science (In Press)},
	author    = {Anupam Jamatia and  Kanishka Joshi and  Kundan Kumar and  Shivam Kumar and Subrito Haldar},
	title     = {Customer Feedback Analysis Using Machine Learning Techniques},
  year      = {2018}
}

@article{JamatiaEA2020-000,
  journal   = {International Journal on Artificial Intelligence Tools},
	author    = {Anupam Jamatia, Steve Durairaj Swamy, Bj\"orn Gamb\"ack, Amitava Das, Swapan Debbarma},
	title     = {Deep Learning Based Sentiment Analysis in a Code-Mixed English-Hindi and English-Bengali Social Media Corpus},
  year      = {2020},
  doi = https://doi.org/10.1142/S0218213020500141
}

gha_license_id: MIT

gha_language: HTML


text:
@article{Pride2008,
 abstract = {Background: Among patients with ST-segment elevation myocardial infarction (STEMI), evidence of restoration of both normal epicardial arterial flow and myocardial perfusion early after the administration of fibrinolytic agents has been associated with improved clinical outcomes. In STEMI patients treated with fibrinolytic therapy and scheduled for angiography later during hospital admission, however, the association of later indices of flow and perfusion with clinical outcomes has not been assessed. Methods: Clopidogrel as Adjunctive Reperfusion Therapy-Thrombolysis in Myocardial Infarction (CLARITY-TIMI) 28 enrolled 3,491 STEMI patients treated with fibrinolytic therapy. Angiography was scheduled 48-192 h (median 84) after randomization. The Angiographic Perfusion Score (APS) (the sum of the TIMI Flow Grade and Myocardial Perfusion Grade before and after percutaneous coronary intervention (PCI), range of 0-12) was assessed in the 1,460 patients treated with PCI at late angiography, and its association with morbidity and mortality at 30 days was examined. Results: Full perfusion, defined as an APS of 10-12, was associated with the lowest mortality (0.8%), while partial perfusion (APS 4-9) (2.3%) and failed perfusion (APS 0-3) (18.0%) were associated with a higher incidence of mortality at 30 days (P \textless 0.001 for full perfusion vs. partial perfusion, P \textless 0.0001 for overall trend). In addition, full perfusion was associated with a lower incidence of recurrent myocardial infarction (MI), a composite of death and MI, recurrent myocardial ischemia, ventricular tachyarrhythmia, congestive heart failure and shock (P \textless 0.05 for all trends). Conclusion: Among STEMI patients treated with late PCI following fibrinolytic therapy, higher APS is associated with reduced morbidity and mortality. \textcopyright Springer Science+Business Media, LLC 2007.},
 author = {Pride, Y.B. and Buros, J.L. and Lord, E. and Southard, M.C. and Harrigan, C.J. and Ciaglo, L.N. and Sabatine, M.S. and Cannon, C.P. and Gibson, C.M.},
 doi = {10.1007/s11239-007-0075-z},
 issn = {09295305},
 journal = {Journal of Thrombosis and Thrombolysis},
 keywords = {[Angiographic Perfusion Score, ST-segment elevatio},
 number = {2},
 title = {Angiographic perfusion score in patients treated with PCI at late angiography following fibrinolytic administration for ST-segment elevation myocardial infarction is associated with morbidity and mortality at 30 days},
 volume = {26},
 year = {2008}
}

repository: jburos/another-biostats-blog

repo_name: jburos/another-biostats-blog

gha_language: TeX


text:
SUMMARY = "Fast Log processor and Forwarder"
DESCRIPTION = "Fluent Bit is a data collector, processor and  \
forwarder for Linux. It supports several input sources and \
backends (destinations) for your data. \
"

HOMEPAGE = "http://fluentbit.io"
BUGTRACKER = "https://github.com/fluent/fluent-bit/issues"

LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=2ee41112a44fe7014dce33e26468ba93"
SECTION = "net"

SRC_URI = "\
           http://fluentbit.io/releases/1.7/fluent-bit-${PV}.tar.gz \
           file://fluent-bit.service \
           "
SRC_URI[md5sum] = "f0e66d99e03d3a438a172aac61a55511"
SRC_URI[sha256sum] = "1f80b21f98b51306caa7aa13db47803f0465ec8e09061f4a938586d0185025b8"

DEPENDS = "zlib openssl bison-native flex-native"

# Use CMake 'Unix Makefiles' generator
OECMAKE_GENERATOR ?= "Unix Makefiles"

# Fluent Bit build options
# ========================

# Disable Debug symbols
EXTRA_OECMAKE += "-DFLB_DEBUG=Off "

# Host related setup
EXTRA_OECMAKE += "-DGNU_HOST=${HOST_SYS} "

# Disable LuaJIT and filter_lua support
EXTRA_OECMAKE += "-DFLB_LUAJIT=Off -DFLB_FILTER_LUA=Off "

# Disable Library and examples
EXTRA_OECMAKE += "-DFLB_SHARED_LIB=Off -DFLB_EXAMPLES=Off "

# Systemd support
DEPENDS += "systemd"
EXTRA_OECMAKE += "-DFLB_IN_SYSTEMD=On "

# Enable Kafka Output plugin
EXTRA_OECMAKE += "-DFLB_OUT_KAFKA=On "

inherit cmake systemd

SYSTEMD_SERVICE_${PN} = "fluent-bit.service"
SYSTEMD_AUTO_ENABLE = "disable"

do_install_append() {
    # fluent-bit unconditionally install init scripts, let's remove them to install our own
    rm -Rf ${D}/lib ${D}/etc/init

    install -d ${D}${systemd_unitdir}/system
    install -m 0644 ${WORKDIR}/fluent-bit.service ${D}${systemd_unitdir}/system/fluent-bit.service
}

repository: drewmoseley/meta-fleet-monitoring-poc

repo_name: drewmoseley/meta-fleet-monitoring-poc

branch_name: refs/heads/main


text:
@incollection{DongRunlength2008,
 abstract = {In this paper, a simple but efficient approach for blind image splicing detection is proposed. Image splicing is a common and fundamental operation used for image forgery. The detection of image splicing is a preliminary but desirable study for image forensics. Passive detection approaches of image splicing are usually regarded as pattern recognition problems based on features which are sensitive to splicing. In the proposed approach, we analyze the discontinuity of image pixel correlation and coherency caused by splicing in terms of image run-length representation and sharp image characteristics. The statistical features extracted from image run-length representation and image edge statistics are used for splicing detection. The support vector machine (SVM) is used as the classifier. Our experimental results demonstrate that the two proposed features outperform existing ones both in detection accuracy and computational complexity. © Springer-Verlag Berlin Heidelberg 2009.},
 author = {Dong, Jing and Wang, Wei and Tan, Tieniu and Shi, Yun Q},
 booktitle = {Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)},
 doi = {10.1007/978-3-642-04438-0_7},
 isbn = {3642044379},
 issn = {03029743},
 keywords = {Characteristic functions,Edge detection,Image splicing,Run-length,Support vector machine (SVM)},
 pages = {76--87},
 title = {Run-Length and Edge Statistics Based Approach for Image Splicing Detection},
 url = {http://link.springer.com/10.1007/978-3-642-04438-0_7},
 volume = {5450 LNCS},
 year = {2009}
}


text:
package system

import (
	"io"
	"io/ioutil"
	"strings"

	"github.com/mlab-lattice/lattice/pkg/api/v1"
	"github.com/mlab-lattice/lattice/pkg/definition/tree"
)

type BuildBackend struct {
	systemID v1.SystemID
	backend  *Backend
}

func (b *BuildBackend) CreateFromPath(p tree.Path) (*v1.Build, error) {
	return b.create(&p, nil)
}

func (b *BuildBackend) CreateFromVersion(v v1.Version) (*v1.Build, error) {
	return b.create(nil, &v)
}

func (b *BuildBackend) create(p *tree.Path, v *v1.Version) (*v1.Build, error) {
	b.backend.registry.Lock()
	defer b.backend.registry.Unlock()

	record, err := b.backend.systemRecordInitialized(b.systemID)
	if err != nil {
		return nil, err
	}

	build := b.backend.registry.CreateBuild(p, v, record)

	// run the build
	b.backend.controller.RunBuild(build, record)

	// copy the build so we don't return a pointer into the backend
	// so we can release the lock
	return build.DeepCopy(), nil
}

func (b *BuildBackend) List() ([]v1.Build, error) {
	b.backend.registry.Lock()
	defer b.backend.registry.Unlock()

	record, err := b.backend.systemRecordInitialized(b.systemID)
	if err != nil {
		return nil, err
	}

	var builds []v1.Build
	for _, build := range record.Builds {
		builds = append(builds, *build.Build.DeepCopy())
	}

	return builds, nil
}

func (b *BuildBackend) Get(id v1.BuildID) (*v1.Build, error) {
	b.backend.registry.Lock()
	defer b.backend.registry.Unlock()

	record, err := b.backend.systemRecordInitialized(b.systemID)
	if err != nil {
		return nil, err
	}

	build, ok := record.Builds[id]
	if !ok {
		return nil, v1.NewInvalidBuildIDError()
	}

	// copy the build so we don't return a pointer into the backend
	// so we can release the lock
	return build.Build.DeepCopy(), nil
}

func (b *BuildBackend) Logs(
	id v1.BuildID,
	path tree.Path,
	sidecar *string,
	logOptions *v1.ContainerLogOptions,
) (io.ReadCloser, error) {
	_, err := b.Get(id)
	if err != nil {
		return nil, err
	}

	return ioutil.NopCloser(strings.NewReader("this is a long line")), nil
}

repository: willshulman/lattice

repo_name: willshulman/lattice


text:
set(CMAKE_PROJECT_NAME "mat-sdk")

set(ONEDS_SDK_INC_DIR "${PROJECT_SOURCE_DIR}/lib/include/public")
set(CPACK_SYSTEM_NAME "${OS_RELEASE_ID}-${OS_RELEASE_VERSION_ID}")

set(CPACK_PACKAGING_INSTALL_PREFIX "/usr/local")
set(CPACK_GENERATOR "TGZ")

set(MAJOR_VERSION "3")
set(MINOR_VERSION "4")
string(TIMESTAMP DAYNUMBER "%j")
set(PATCH_VERSION "${DAYNUMBER}")

set(CPACK_PACKAGE_DESCRIPTION "Microsoft Applications Telemetry C/C++ SDK for Unix")
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Microsoft Applications Telemetry SDK for events ingestion from Unix hosts")
set(CPACK_PACKAGE_VENDOR "Microsoft")
set(CPACK_PACKAGE_CONTACT "1ds.sdk.cpp@service.microsoft.com")
set(CPACK_PACKAGE_VERSION_MAJOR "${MAJOR_VERSION}")
set(CPACK_PACKAGE_VERSION_MINOR "${MINOR_VERSION}")
set(CPACK_PACKAGE_VERSION_PATCH "${PATCH_VERSION}")

file(GLOB ALL_TARGET_LIBS "${CMAKE_CURRENT_BINARY_DIR}/lib/libmat.*")

install(FILES ${ALL_TARGET_LIBS} DESTINATION lib COMPONENT libraries)
#install(FILES ${MAT_SDK_INC_DIR}/*.* DESTINATION include/mat COMPONENT libraries)

# FIXME: add architecture name in file name
set(CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}-${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION}-${CPACK_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
message("-- Package name: ${CPACK_PACKAGE_FILE_NAME}.tgz")

include(CPack)


text:
execute_process(COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/src/htslib-1.6)

ExternalProject_Add(htslib
        DOWNLOAD_COMMAND  wget https://github.com/samtools/htslib/releases/download/1.6/htslib-1.6.tar.bz2 --timestamping
        DOWNLOAD_DIR      "${CMAKE_CURRENT_BINARY_DIR}/download"
        CONFIGURE_COMMAND bash -c "cd ${CMAKE_CURRENT_BINARY_DIR}/src/htslib-1.6 && autoheader && autoconf && env CPPFLAGS=-I${CMAKE_CURRENT_BINARY_DIR}/include LDFLAGS=-L${CMAKE_CURRENT_BINARY_DIR}/lib ./configure --prefix=${CMAKE_CURRENT_BINARY_DIR}"
        BUILD_COMMAND     bash -c "cd ${CMAKE_CURRENT_BINARY_DIR}/src/htslib-1.6 && make && make install"
        INSTALL_COMMAND   ""
        TEST_COMMAND      "")

ExternalProject_Add_Step(htslib extract_tar
        COMMAND tar -xjf ${CMAKE_CURRENT_BINARY_DIR}/download/htslib-1.6.tar.bz2 -C ${CMAKE_CURRENT_BINARY_DIR}/src
        DEPENDEES download
        DEPENDERS configure)

repository: leoisl/gramtools

repo_name: leoisl/gramtools


text:
// package cache defines containers for in-memory storage.
package cache

import (
	"sync"

	"github.com/huangml/proxycache/lru"
)

// Cache is an LRU cache.
// It auto removes least-recently-used entry when cache is full.
type Cache struct {
	maxEntry int
	entries  map[string]*Entry
	use      *lru.LRU
	mtx      sync.Mutex
}

// NewCache creates a new Cache.
// If maxEntry is 0, the cache has no limit size.
func NewCache(maxEntry int) *Cache {
	return &Cache{
		maxEntry: maxEntry,
		entries:  make(map[string]*Entry),
		use:      lru.New(),
	}
}

// SetMaxEntry setup a new maxEntry.
// Extra entries will be removed immediately.
func (c *Cache) SetMaxEntry(maxEntry int) {
	c.mtx.Lock()
	defer c.mtx.Unlock()

	c.maxEntry = maxEntry
	c.checkMaxEntryWithLock()
}

// Get looks up entry by a key.
// It marks the key as recently-used.
func (c *Cache) Get(key string) *Entry {
	c.mtx.Lock()
	defer c.mtx.Unlock()

	if e, ok := c.entries[key]; ok {
		c.use.Touch(key)
		return e
	} else {
		return nil
	}
}

// Put puts an entry to the cache.
// It marks the key as rencently-used.
func (c *Cache) Put(entry *Entry) {
	c.mtx.Lock()
	defer c.mtx.Unlock()

	c.entries[entry.Key] = entry
	c.use.Touch(entry.Key)
	c.checkMaxEntryWithLock()
}

// MaxEntry returns maxEntry of the cache.
func (c *Cache) MaxEntry() int {
	c.mtx.Lock()
	defer c.mtx.Unlock()

	return c.maxEntry
}

func (c *Cache) checkMaxEntryWithLock() {
	for c.maxEntry > 0 && len(c.entries) > c.maxEntry {
		if k, ok := c.use.Pop().(string); ok {
			delete(c.entries, k)
		} else {
			break
		}
	}
}

// CacheStatus is used for runtime performance profiling.
type CacheStatus struct {
	MaxEntry  int `json:"maxEntry"`
	CacheSize int `json:"cacheSize"`
}

// Status returns Cache's runtime performance status.
func (c *Cache) Status() CacheStatus {
	c.mtx.Lock()
	defer c.mtx.Unlock()

	return CacheStatus{
		MaxEntry:  c.maxEntry,
		CacheSize: len(c.entries),
	}
}

repository: swwowgm/proxycache

repo_name: swwowgm/proxycache


text:
SUMMARY = "PCSX ReARMed game client for XBMC"
HOMEPAGE = "https://github.com/kodi-game/game.libretro.pcsx-rearmed"
BUGTRACKER = "https://github.com/kodi-game/game.libretro.pcsx-rearmed/issues"

LICENSE = "GPL-2.0-only"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/GPL-2.0;md5=801f80980d171dd6425610833a22dbe6"

inherit kodi-addon

DEPENDS += "pcsx-rearmed-libretro"
RDEPENDS:${PN} += "kodi"

PV = "22.0.0.19-Matrix"

SRCREV = "${PV}"
SRC_URI = "git://github.com/kodi-game/game.libretro.pcsx-rearmed;nobranch=1;protocol=https"
S = "${WORKDIR}/git"

KODIADDONNAME = "game.libretro.pcsx-rearmed"

gha_language: BitBake


text:
DESCRIPTION = "WBXML parsing and encoding library"
LICENSE = "LGPL"

DEPENDS = "expat popt"

SRC_URI = "${SOURCEFORGE_MIRROR}/wbxmllib/${PN}-${PV}.tar.gz \
	   file://00-fix-includes.patch;patch=1 \
	   file://01-anonymous-support-and-misc-fixes.patch;patch=1 \
	   file://02-namespaces.patch;patch=1 \
	   file://04_saxlike_entity_parsing.patch;patch=1 \
	   file://05-syncml-fixes.patch;patch=1 \
	   file://06-no-install-docs.patch;patch=1 \
	   file://07-current_attr_null.patch;patch=1 \
	   file://08-maxsize-translation-table.patch;patch=1;pnum=0 \
	   "

inherit autotools pkgconfig

do_stage() {
	autotools_stage_all
}

PACKAGES += "${PN}-tools"

FILES_${PN}-tools = "${bindir}"
FILES_${PN} = "${libdir}/*.so.*"


text:
SUMMARY = "Set permission on i2c devices"
LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0;md5=801f80980d171dd6425610833a22dbe6"

SRC_URI = "file://99-i2c.rules"

do_install[nostamp] = "1"
do_unpack[nostamp] = "1"

do_install () {
    install -d ${D}/etc/udev/rules.d
    install -m 0666 ${WORKDIR}/99-i2c.rules        ${D}/etc/udev/rules.d/99-i2c.rules
}

FILES_${PN} += " /etc/udev/rules.d/99-i2c.rules"

PACKAGES = "${PN}"
PROVIDES = "i2c-udev-rules"

repository: jeonghanlee/yocto-ess

repo_name: jeonghanlee/yocto-ess


text:
import React from 'react';
export function RemovableBackdrop() {
  return (
    <div
      className="removableBackdrop noselect"
      oncontextmenu="return false;"
      unselectable="on"
      onselectstart="return false;"
    />
  );
}
export default RemovableBackdrop;

repository: maltempi/react-viewerbase

repo_name: maltempi/react-viewerbase


text:
if (NOT NRFJPROG)
   message(STATUS "nrfjprog not found")
endif ()

if (NOT MERGEHEX)
   message(STATUS "mergehex not found")
endif ()

if (NRFJPROG AND MERGEHEX)
    add_custom_target(merge)
    function(add_flash_target target)
        # Both the manual <merge> and <flash> target and depends on
        # the custom command that generates the merged hexfile.
        add_custom_target(merge_${target}
            DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${target}_merged.hex)

        add_dependencies(merge merge_${target})

        add_custom_target(flash_erase
            COMMAND ${NRFJPROG} --eraseall
            COMMENT "erasing flashing")

        add_custom_target(flash_SoftDevice${target}
            COMMAND ${NRFJPROG} --program ${${SOFTDEVICE}_HEX_FILE} --sectorerase
            COMMAND ${NRFJPROG} --reset
            COMMENT "flashing SoftDevice.hex")

        add_custom_target(flash_${target}
            COMMAND ${NRFJPROG} --program ${CMAKE_CURRENT_BINARY_DIR}/${target}.hex --sectorerase
            COMMAND ${NRFJPROG} --reset
            COMMENT "flashing ${target}.hex")

        add_custom_target(flash_merged_${target}
            COMMAND ${NRFJPROG} --eraseall
            COMMAND ${NRFJPROG} --program ${CMAKE_CURRENT_BINARY_DIR}/${target}_merged.hex
            COMMAND ${NRFJPROG} --reset
            DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${target}_merged.hex
            COMMENT "flashing ${target}_merged.hex")

        add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${target}_merged.hex
            COMMAND ${MERGEHEX} -m ${${SOFTDEVICE}_HEX_FILE} ${CMAKE_CURRENT_BINARY_DIR}/${target}.hex -o ${CMAKE_CURRENT_BINARY_DIR}/${target}_merged.hex
            DEPENDS ${target}
            VERBATIM)
    endfunction(add_flash_target)
else ()
    message(STATUS "Could not find nRFx command line tools (`nrfjprog` and `mergehex`).
   See http://infocenter.nordicsemi.com/topic/com.nordic.infocenter.tools/dita/tools/nrf5x_command_line_tools/nrf5x_installation.html?cp=5_1_1.
   Flash target will not be supported.")
    function(add_flash_target target)
        # Not supported
    endfunction(add_flash_target)
endif (NRFJPROG AND MERGEHEX)

repository: TheTosters/HeaterControl

repo_name: TheTosters/HeaterControl


text:
@article{kots2019allosteric157364776,
 address = {United States},
 author = {Kots, Ekaterina D. and Khrenova, Maria G. and Nemukhin, Alexander V.},
 doi = {10.1021/acs.jcim.8b00666},
 issn = {1549-9596; 1549-960X},
 journal = {Journal of Chemical Information and Modeling},
 language = {english},
 number = {5},
 pages = {2299--2308},
 publisher = {United States},
 title = {Allosteric Control of N-Acetyl-Aspartate Hydrolysis by the Y231C and F295S Mutants of Human Aspartoacylase},
 volume = {59},
 year = {2019}
}

repository: polyakoviv/LCC

repo_name: polyakoviv/LCC


text:
@inproceedings{P17-3001,
 address = {Vancouver, Canada},
 author = {Carrillo, Facundo},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {1--3},
 publisher = {Association for Computational Linguistics},
 title = {Computational Characterization of Mental States: A Natural Language Processing Approach},
 year = {2017}
}

@inproceedings{P17-3002,
 address = {Vancouver, Canada},
 author = {Jawahar, Ganesh},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {4--10},
 publisher = {Association for Computational Linguistics},
 title = {Improving Distributed Representations of Tweets - Present and Future},
 year = {2017}
}

@inproceedings{P17-3003,
 address = {Vancouver, Canada},
 author = {Grover, Jeenu  and  Mitra, Pabitra},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {11--16},
 publisher = {Association for Computational Linguistics},
 title = {Bilingual Word Embeddings with Bucketed CNN for Parallel Sentence Extraction},
 year = {2017}
}

@inproceedings{P17-3004,
 address = {Vancouver, Canada},
 author = {Sukthankar, Nandan  and  Maharnawar, Sanket  and  Deshmukh, Pranay  and  Haribhakta, Yashodhara  and  Kamble, Vibhavari},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {17--23},
 publisher = {Association for Computational Linguistics},
 title = {nQuery - A Natural Language Statement to SQL Query Generator},
 year = {2017}
}

@inproceedings{P17-3005,
 address = {Vancouver, Canada},
 author = {Nayak, Nihal V.  and  Chinchore, Tanmay  and  Hanumanth Rao, Aishwarya  and  Martin, Shane Michael  and  Simha, Sagar Nagaraj  and  Lingaraju, G. M.  and  Jamadagni, H. S.},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {24--29},
 publisher = {Association for Computational Linguistics},
 title = {V for Vocab: An Intelligent Flashcard Application},
 year = {2017}
}

@inproceedings{P17-3006,
 address = {Vancouver, Canada},
 author = {Rao, Sudha},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {30--35},
 publisher = {Association for Computational Linguistics},
 title = {Are You Asking the Right Questions? Teaching Machines to Ask Clarification Questions},
 year = {2017}
}

@inproceedings{P17-3007,
 address = {Vancouver, Canada},
 author = {Suzuki, Yui  and  Kajiwara, Tomoyuki  and  Komachi, Mamoru},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {36--42},
 publisher = {Association for Computational Linguistics},
 title = {Building a Non-Trivial Paraphrase Corpus Using Multiple Machine Translation Systems},
 year = {2017}
}

@inproceedings{P17-3008,
 address = {Vancouver, Canada},
 author = {Sharma, Vasu  and  Bishnu, Ankita  and  Patel, Labhesh},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {43--48},
 publisher = {Association for Computational Linguistics},
 title = {Segmentation Guided Attention Networks for Visual Question Answering},
 year = {2017}
}

@inproceedings{P17-3009,
 address = {Vancouver, Canada},
 author = {Ma, Kaixin  and  Xiao, Catherine  and  Choi, Jinho D.},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {49--55},
 publisher = {Association for Computational Linguistics},
 title = {Text-based Speaker Identification on Multiparty Dialogues Using Multi-document Convolutional Neural Networks},
 year = {2017}
}

@inproceedings{P17-3010,
 address = {Vancouver, Canada},
 author = {Li, Hang  and  Wang, Haozheng  and  Yang, Zhenglu  and  Odagaki, Masato},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {56--61},
 publisher = {Association for Computational Linguistics},
 title = {Variation Autoencoder Based Network Representation Learning for Classification},
 year = {2017}
}

@inproceedings{P17-3011,
 address = {Vancouver, Canada},
 author = {Michel, Paul  and  R\"{a}s\"{a}nen, Okko  and  Thiolli\'{e}re, Roland  and  Dupoux, Emmanuel},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {62--68},
 publisher = {Association for Computational Linguistics},
 title = {Blind Phoneme Segmentation With Temporal Prediction Errors},
 year = {2017}
}

@inproceedings{P17-3012,
 address = {Vancouver, Canada},
 author = {Aggarwal, Srishti  and  Mamidi, Radhika},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {69--74},
 publisher = {Association for Computational Linguistics},
 title = {Automatic Generation of Jokes in Hindi},
 year = {2017}
}

@inproceedings{P17-3013,
 address = {Vancouver, Canada},
 author = {Zhang, Haoran  and  Litman, Diane},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {75--81},
 publisher = {Association for Computational Linguistics},
 title = {Word Embedding for Response-To-Text Assessment of Evidence},
 year = {2017}
}

@inproceedings{P17-3014,
 address = {Vancouver, Canada},
 author = {Soleymanzadeh, Katira},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {82--88},
 publisher = {Association for Computational Linguistics},
 title = {Domain Specific Automatic Question Generation from Text},
 year = {2017}
}

@inproceedings{P17-3015,
 address = {Vancouver, Canada},
 author = {Ramirez, Jose  and  Garber, Matthew  and  Wang, Xinhao},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {89--94},
 publisher = {Association for Computational Linguistics},
 title = {SoccEval: An Annotation Schema for Rating Soccer Players},
 year = {2017}
}

@inproceedings{P17-3016,
 address = {Vancouver, Canada},
 author = {Garber, Matthew  and  Singer, Meital  and  Ward, Christopher},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {95--99},
 publisher = {Association for Computational Linguistics},
 title = {Accent Adaptation for the Air Traffic Control Domain},
 year = {2017}
}

@inproceedings{P17-3017,
 address = {Vancouver, Canada},
 author = {Fang, Tina  and  Jaggi, Martin  and  Argyraki, Katerina},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {100--106},
 publisher = {Association for Computational Linguistics},
 title = {Generating Steganographic Text with LSTMs},
 year = {2017}
}

@inproceedings{P17-3018,
 address = {Vancouver, Canada},
 author = {Hiraga, Misato},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {107--113},
 publisher = {Association for Computational Linguistics},
 title = {Predicting Depression for Japanese Blog Text},
 year = {2017}
}

@inproceedings{P17-3019,
 address = {Vancouver, Canada},
 author = {Babkin, Petr  and  Nirenburg, Sergei},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {114--119},
 publisher = {Association for Computational Linguistics},
 title = {Fast Forward Through Opportunistic Incremental Meaning Representation Construction},
 year = {2017}
}

@inproceedings{P17-3020,
 address = {Vancouver, Canada},
 author = {Sato, Shoetsu  and  Yoshinaga, Naoki  and  Toyoda, Masashi  and  Kitsuregawa, Masaru},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {120--127},
 publisher = {Association for Computational Linguistics},
 title = {Modeling Situations in Neural Chat Bots},
 year = {2017}
}

@inproceedings{P17-3021,
 address = {Vancouver, Canada},
 author = {Espinosa, Kurt Junshean},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {128--135},
 publisher = {Association for Computational Linguistics},
 title = {An Empirical Study on End-to-End Sentence Modelling},
 year = {2017}
}

@inproceedings{P17-3022,
 address = {Vancouver, Canada},
 author = {Na'aman, Noa  and  Provenza, Hannah  and  Montoya, Orion},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {136--141},
 publisher = {Association for Computational Linguistics},
 title = {Varying Linguistic Purposes of Emoji in (Twitter) Context},
 year = {2017}
}

@inproceedings{P17-3023,
 address = {Vancouver, Canada},
 author = {Wang, Nan},
 booktitle = {Proceedings of ACL 2017, Student Research Workshop},
 month = {July},
 pages = {142--149},
 publisher = {Association for Computational Linguistics},
 title = {Negotiation of Antibiotic Treatment in Medical Consultations: A Corpus Based Study},
 year = {2017}
}


text:
h2 {
text-align: center;
font-family: 'Trebuchet MS', 'Lucida Sans Unicode', 'Lucida Grande', 'Lucida Sans', Arial, sans-serif;
font-weight: bold;
font-size: 20px;
}

extension: css


text:
SECTION = "console/network"
DESCRIPTION = "Raw Fake AP"
HOMEPAGE = "http://rfakeap.tuxfamily.org/"
LICENSE = "GPLv2"
DEPENDS = "libpcap"
PV="0.2"
PR ="r1"

SRC_URI = "http://rfakeap.tuxfamily.org/rfakeap-0.2.tar.gz"

#EXTRA_OEMAKE = "CFLAGS='${CFLAGS} -O3'"

oe_compile() {
	oe_runmake CC="${CC}" CXX="${CXX}" CFLAGS="-O3 ${CFLAGS}" CXXFLAGS="${CXXFLAGS}" LD="${LD}" LDFLAGS="${LDFLAGS}"
}

do_install() {
        install -d ${D}/${sbindir}
	install -d ${D}/${sysconfdir}
        install -m 0755 ${WORKDIR}/${PN}-${PV}/rfakeap           ${D}/${sbindir}
#	install -m 0644 ap_manuf	  ${D}/${sysconfdir}
}

SRC_URI[md5sum] = "38f159681196b566f20bf837aff1e8f8"
SRC_URI[sha256sum] = "4e5f63d8488b0fbd1a709429feb797c8c679de48f47ef93ab4741f8506830667"