text:
add_compile_options(
    -DGTEST_LANG_CXX11=1
    -DBOOST_RESULT_OF_USE_DECLTYPE
    -DBOOST_SPIRIT_USE_PHOENIX_V3

    -DBOOST_MOVE_USE_STANDARD_LIBRARY_MOVE=1

    -DBOOST_ASIO_NO_THROW=1
    -DBOOST_ASIO_HAS_MOVE=1

    -DBOOST_THREAD_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V3_0_0=1

    -DSODIUM_STATIC=1

    $<$<NOT:$<CONFIG:Debug>>:-DNDEBUG>
    $<$<CONFIG:Debug>:-DDEBUG=1>
    $<$<CONFIG:Debug>:-D_DEBUG=1>
)

if(MSVC)
    add_definitions(
        /DBOOST_ALL_NO_LIB

        /D__TBB_NO_IMPLICIT_LINKAGE=1
        /D__TBBMALLOC_NO_IMPLICIT_LINKAGE=1

        /D_WINDOWS
        /DWIN32
        /DWIN32_LEAN_AND_MEAN
        /DVC_EXTRALEAN

        /DWINVER=0x0600
        /D_WIN32_WINNT=0x0600
        /DNTDDI_VERSION=0x06000000
        /DBOOST_USE_WINAPI_VERSION=0x0600

        /DPSAPI_VERSION=1
        /DNOMINMAX=1
        /D_CRT_SECURE_NO_WARNINGS
        /D_SCL_SECURE_NO_WARNINGS
        /D_SECURE_SCL=$<CONFIG:Debug>
        /D_HAS_ITERATOR_DEBUGGING=$<CONFIG:Debug>

        /D_HAS_AUTO_PTR_ETC=1 # Boost 1.65.1 does not support this.
        /D_SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING=1
        /D_SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING=1
        /D_SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING=1
        /D_SILENCE_CXX17_UNCAUGHT_EXCEPTION_DEPRECATION_WARNING=1
    )
    if (NOT ${MSVC_VERSION} VERSION_LESS 1912)
        # Boost 1.66 is not warning clean.
        add_definitions(
            -D_SILENCE_CXX17_RESULT_OF_DEPRECATION_WARNING
        )
    endif()
    if (${MSVC_VERSION} VERSION_LESS 1910)
        add_definitions(
            /D_ENABLE_ATOMIC_ALIGNMENT_FIX
        )
    endif()
endif()

if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    add_compile_options(
        -DPIC
    )
endif()

if(CMAKE_COMPILER_IS_GNUCXX)
    add_compile_options(
        -DPIC
        $<$<CONFIG:Debug>:-D_GLIBCXX_DEBUG=1>
        -DBOOST_NO_AUTO_PTR
    )
endif()

repository: edouarda/task-manager

repo_name: edouarda/task-manager


text:
@article{krzakala_temperature_2004,
 author = {Krzakała, F.},
 doi = {10.1209/epl/i2003-10261-5},
 file = {Full Text PDF:/Users/florentkrzakala/Zotero/storage/IIRDS8NL/Krzakała - 2004 - On temperature chaos in Ising and XY spin glasses.pdf:application/pdf;Snapshot:/Users/florentkrzakala/Zotero/storage/UN8JZXU9/i2003-10261-5.html:text/html},
 issn = {0295-5075},
 journal = {EPL},
 language = {en},
 month = {June},
 number = {6},
 pages = {847},
 title = {On temperature chaos in Ising and XY spin glasses},
 url = {https://iopscience.iop.org/article/10.1209/epl/i2003-10261-5/meta},
 urldate = {2019-07-01},
 volume = {66},
 year = {2004}
}

license: MIT

repository: krzakala/academic-kickstart

license_type: permissive

repo_name: krzakala/academic-kickstart

branch_name: refs/heads/master

extension: bib


text:
SUMMARY = "CLucene is a indexing and searching API"
HOMEPAGE = "http://www.sourceforge.net/projects/clucene"
LICENSE = "LGPL-2.0-or-later & Apache-2.0"
LIC_FILES_CHKSUM = " \
    file://APACHE.license;md5=86d3f3a95c324c9479bd8986968f4327 \
    file://LGPL.license;md5=464215a90afcdfbae965d89feb928c7e \
    file://COPYING;md5=b2e941b2872bb8566f505130d6d61ba4 \
"
SRC_URI = " \
    ${SOURCEFORGE_MIRROR}/project/clucene/${BPN}-unstable/2.3/${BPN}-${PV}.tar.gz \
    file://0001-cmake-remplace-CHECK_CXX_SOURCE_RUNS-by-CHECK_CXX_SO.patch \
    file://0002-exclude-external-sources-from-build.patch \
    file://0003-align-pkg-config.patch \
    file://0004-fix-location-s-for-our-cmake-config.patch \
    file://0005-install-contribs-lib.patch \
    file://0006-Fix-build-with-glibc-2.36.patch \
"
SRC_URI[md5sum] = "48d647fbd8ef8889e5a7f422c1bfda94"
SRC_URI[sha256sum] = "ddfdc433dd8ad31b5c5819cc4404a8d2127472a3b720d3e744e8c51d79732eab"

inherit cmake

DEPENDS = "boost zlib"

EXTRA_OECMAKE = " \
    -DLIB_SUFFIX=${@d.getVar('baselib').replace('lib', '')} \
    -DENABLE_COMPILE_TESTS=OFF \
    -DBUILD_CONTRIBS_LIB=ON"

BBCLASSEXTEND = "native"

repository: schnitzeltony/meta-office

repo_name: schnitzeltony/meta-office

gha_license_id: MIT

gha_language: BitBake

extension: bb


text:
SUMMARY = "Default audio samples for Owen Wilson Saying 'Wow' as a Service"
LICENSE = "CLOSED"

SRC_URI = "https://www.dropbox.com/s/7bl8jqvy4cexw1y/audio-samples.tar.xz?dl=1"
SRC_URI[md5sum] = "2f8ce19d1f8714548710cfffabf22b83"
SRC_URI[sha256sum] = "d575e710eb9acbd7781d1cf58e0cb95ce78a6b2ea94edff3d62d93d0cd7157f9"

# Hack around the annoying suffix. Thanks dr0pb0x.
do_configure() {
    cd ${WORKDIR}
    if [ -f ${WORKDIR}/audio-samples.tar.xz?dl=1 ]; then
        mv ${WORKDIR}/audio-samples.tar.xz?dl=1 ${WORKDIR}/audio-samples.tar.xz
    fi
    tar xf ${WORKDIR}/audio-samples.tar.xz
}

do_install() {
    mkdir -p ${D}/audio/

    cp -r ${WORKDIR}/audio-samples/wowz     ${D}/audio/wowz
    cp -r ${WORKDIR}/audio-samples/dlr      ${D}/audio/dlr
    cp -r ${WORKDIR}/audio-samples/movies   ${D}/audio/movies
    cp -r ${WORKDIR}/audio-samples/malort   ${D}/audio/malort

    chmod -R -w ${D}/audio
    chmod -R +r ${D}/audio

    chmod 555 ${D}/audio
    chmod 555 ${D}/audio/wowz
    chmod 555 ${D}/audio/dlr
    chmod 555 ${D}/audio/movies
    chmod 555 ${D}/audio/malort
}

PACKAGES = "${PN}"
FILES_${PN} = "/audio"

repository: jynik/meta-owswaas

repo_name: jynik/meta-owswaas


text:
require blueprobe.inc

PR = "r3"

SRC_URI += "file://hx4700.patch;patch=1 \
	    file://h2200-fixup.patch;patch=1 \
            file://htcuniversal.patch;patch=1 \
	    file://hwuart.patch;patch=1;pnum=2"

repository: jdegges/gumstix-pip-oe

repo_name: jdegges/gumstix-pip-oe


text:
SUMMARY = "DevIL cross platform image utility library"
DESCRIPTION = "Developer's Image Library (DevIL) is a cross-platform image \
               library utilizing simple syntax to load, save, convert, \
               manipulate, filter and display a variety of images."
HOMEPAGE = "https://github.com/DentonW/DevIL"
LICENSE = "LGPL-2.0-only"
LIC_FILES_CHKSUM = "file://LICENSE;md5=fc178bcd425090939a8b634d1d6a9594"

SRC_URI = "git://github.com/dentonw/devil.git;protocol=https;branch=master \
           file://Remove-ILUT-dependency.patch"

SRCREV = "e34284a7e07763769f671a74b4fec718174ad862"

PR = "r1"
S = "${WORKDIR}/git"

# Build only DevIL
OECMAKE_SOURCEPATH = "${S}/DevIL"

PACKAGECONFIG ??= "png"
PACKAGECONFIG[png] = "-DIL_NO_PNG=0,-DIL_NO_PNG=1,libpng,"

inherit pkgconfig cmake

repository: rcn-ee/meta-arago

repo_name: rcn-ee/meta-arago


text:
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: giraffe_service.proto

package alert

import (
	context "context"
	fmt "fmt"
	giraffe_micro "github.com/easyops-cn/giraffe-micro"
	go_proto_giraffe "github.com/easyops-cn/go-proto-giraffe"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
)

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

// Reference imports to suppress errors if they are not otherwise used.
var _ = io.EOF
var _ context.Context
var _ giraffe_micro.Client
var _ go_proto_giraffe.Contract

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

// Client is the client API for alert service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type Client interface {
	GetAlertCount(ctx context.Context, in *GetAlertCountRequest) (*GetAlertCountResponse, error)
	GetAlertEventDetail(ctx context.Context, in *GetAlertEventDetailRequest) (*GetAlertEventDetailResponse, error)
	GetAlertEventList(ctx context.Context, in *GetAlertEventListRequest) (*GetAlertEventListResponse, error)
	GetNotRecoverAlertEventList(ctx context.Context, in *GetNotRecoverAlertEventListRequest) (*GetNotRecoverAlertEventListResponse, error)
}

type client struct {
	c giraffe_micro.Client
}

func NewClient(c giraffe_micro.Client) Client {
	return &client{
		c: c,
	}
}

func (c *client) GetAlertCount(ctx context.Context, in *GetAlertCountRequest) (*GetAlertCountResponse, error) {
	out := new(GetAlertCountResponse)
	err := c.c.Invoke(ctx, _GetAlertCountMethodDesc, in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *client) GetAlertEventDetail(ctx context.Context, in *GetAlertEventDetailRequest) (*GetAlertEventDetailResponse, error) {
	out := new(GetAlertEventDetailResponse)
	err := c.c.Invoke(ctx, _GetAlertEventDetailMethodDesc, in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *client) GetAlertEventList(ctx context.Context, in *GetAlertEventListRequest) (*GetAlertEventListResponse, error) {
	out := new(GetAlertEventListResponse)
	err := c.c.Invoke(ctx, _GetAlertEventListMethodDesc, in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *client) GetNotRecoverAlertEventList(ctx context.Context, in *GetNotRecoverAlertEventListRequest) (*GetNotRecoverAlertEventListResponse, error) {
	out := new(GetNotRecoverAlertEventListResponse)
	err := c.c.Invoke(ctx, _GetNotRecoverAlertEventListMethodDesc, in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Service is the server API for alert service.
type Service interface {
	GetAlertCount(context.Context, *GetAlertCountRequest) (*GetAlertCountResponse, error)
	GetAlertEventDetail(context.Context, *GetAlertEventDetailRequest) (*GetAlertEventDetailResponse, error)
	GetAlertEventList(context.Context, *GetAlertEventListRequest) (*GetAlertEventListResponse, error)
	GetNotRecoverAlertEventList(context.Context, *GetNotRecoverAlertEventListRequest) (*GetNotRecoverAlertEventListResponse, error)
}

func _GetAlertCountEndpoint(s Service) giraffe_micro.UnaryEndpoint {
	return func(ctx context.Context, req interface{}) (interface{}, error) {
		return s.GetAlertCount(ctx, req.(*GetAlertCountRequest))
	}
}

func _GetAlertEventDetailEndpoint(s Service) giraffe_micro.UnaryEndpoint {
	return func(ctx context.Context, req interface{}) (interface{}, error) {
		return s.GetAlertEventDetail(ctx, req.(*GetAlertEventDetailRequest))
	}
}

func _GetAlertEventListEndpoint(s Service) giraffe_micro.UnaryEndpoint {
	return func(ctx context.Context, req interface{}) (interface{}, error) {
		return s.GetAlertEventList(ctx, req.(*GetAlertEventListRequest))
	}
}

func _GetNotRecoverAlertEventListEndpoint(s Service) giraffe_micro.UnaryEndpoint {
	return func(ctx context.Context, req interface{}) (interface{}, error) {
		return s.GetNotRecoverAlertEventList(ctx, req.(*GetNotRecoverAlertEventListRequest))
	}
}

func RegisterService(s giraffe_micro.Server, srv Service) {
	s.RegisterUnaryEndpoint(_GetAlertCountMethodDesc, _GetAlertCountEndpoint(srv))
	s.RegisterUnaryEndpoint(_GetAlertEventDetailMethodDesc, _GetAlertEventDetailEndpoint(srv))
	s.RegisterUnaryEndpoint(_GetAlertEventListMethodDesc, _GetAlertEventListEndpoint(srv))
	s.RegisterUnaryEndpoint(_GetNotRecoverAlertEventListMethodDesc, _GetNotRecoverAlertEventListEndpoint(srv))
}

// Method Description
var _GetAlertCountMethodDesc = &giraffe_micro.MethodDesc{
	Contract: &go_proto_giraffe.Contract{
		Name:    "easyops.api.monitor.alert.GetAlertCount",
		Version: "1.0",
	},
	ServiceName:  "alert.rpc",
	MethodName:   "GetAlertCount",
	RequestType:  (*GetAlertCountRequest)(nil),
	ResponseType: (*GetAlertCountResponse)(nil),
	HttpRule: &go_proto_giraffe.HttpRule{
		Pattern: &go_proto_giraffe.HttpRule_Get{
			Get: "/api/v1/alert/count",
		},
		Body:         "",
		ResponseBody: "",
	},
}

var _GetAlertEventDetailMethodDesc = &giraffe_micro.MethodDesc{
	Contract: &go_proto_giraffe.Contract{
		Name:    "easyops.api.monitor.alert.GetAlertEventDetail",
		Version: "1.0",
	},
	ServiceName:  "alert.rpc",
	MethodName:   "GetAlertEventDetail",
	RequestType:  (*GetAlertEventDetailRequest)(nil),
	ResponseType: (*GetAlertEventDetailResponse)(nil),
	HttpRule: &go_proto_giraffe.HttpRule{
		Pattern: &go_proto_giraffe.HttpRule_Get{
			Get: "/api/v1/alert",
		},
		Body:         "",
		ResponseBody: "",
	},
}

var _GetAlertEventListMethodDesc = &giraffe_micro.MethodDesc{
	Contract: &go_proto_giraffe.Contract{
		Name:    "easyops.api.monitor.alert.GetAlertEventList",
		Version: "1.0",
	},
	ServiceName:  "alert.rpc",
	MethodName:   "GetAlertEventList",
	RequestType:  (*GetAlertEventListRequest)(nil),
	ResponseType: (*GetAlertEventListResponse)(nil),
	HttpRule: &go_proto_giraffe.HttpRule{
		Pattern: &go_proto_giraffe.HttpRule_Get{
			Get: "/api/v1/alert",
		},
		Body:         "",
		ResponseBody: "",
	},
}

var _GetNotRecoverAlertEventListMethodDesc = &giraffe_micro.MethodDesc{
	Contract: &go_proto_giraffe.Contract{
		Name:    "easyops.api.monitor.alert.GetNotRecoverAlertEventList",
		Version: "1.0",
	},
	ServiceName:  "alert.rpc",
	MethodName:   "GetNotRecoverAlertEventList",
	RequestType:  (*GetNotRecoverAlertEventListRequest)(nil),
	ResponseType: (*GetNotRecoverAlertEventListResponse)(nil),
	HttpRule: &go_proto_giraffe.HttpRule{
		Pattern: &go_proto_giraffe.HttpRule_Get{
			Get: "/api/v1/alert/alert_status_not_recover",
		},
		Body:         "",
		ResponseBody: "",
	},
}

repository: easyopsapis/easyops-api-go

repo_name: easyopsapis/easyops-api-go

extension: go


text:
DESCRIPTION = "Enlightened Sound Daemon - GPE version"
SECTION = "gpe/base"
LICENSE = "GPL"
DEPENDS = "audiofile"
PR = "r4"

CVSDATE = "${PV}"
SRC_URI = "${HANDHELDS_CVS};module=gpe/base/esound \
	   file://audiofile-please.patch;patch=1 \
	   file://configure.patch;patch=1"

S = "${WORKDIR}/esound"

inherit autotools binconfig pkgconfig

EXTRA_OECONF = "--disable-alsa"

do_stage () {
	install -m 0644 esd.h ${STAGING_INCDIR}/esd.h
	oe_libinstall -C .libs -so libesd ${STAGING_LIBDIR}
	install -m 0644 esd.m4 ${STAGING_DATADIR}/aclocal
}

PACKAGES =+ "esddsp esd esd-utils"

FILES_esddsp = "${bindir}/esddsp ${libdir}/libesddsp.so.*"
FILES_esd = "${bindir}/esd"
FILES_esd-utils = "${bindir}"

repository: Terentyev/familiar-linux

repo_name: Terentyev/familiar-linux


text:
package switchboard_test

import (
	"bytes"
	"encoding/json"
	"time"

	"github.com/coreos/go-etcd/etcd"
	"github.com/jkakar/switchboard"
	. "gopkg.in/check.v1"
)

type ServiceTest struct {
	client *etcd.Client
}

var _ = Suite(&ServiceTest{})

func (s *ServiceTest) SetUpTest(c *C) {
	s.client = etcd.NewClient([]string{"http://127.0.0.1:4001"})
	s.client.Delete("test", true)
}

// Register creates a service record to represent the service and registers it
// in etcd.
func (s *ServiceTest) TestRegister(c *C) {
	address := "http://localhost:8080"
	routes := switchboard.Routes{"GET": []string{"/users", "/user/:id"}}
	service := switchboard.NewService("test", s.client, address, routes)
	record, err := service.Register(0)
	c.Assert(err, IsNil)

	key := "test/" + service.ID()
	sort := false
	recursive := true
	response, err := s.client.Get(key, sort, recursive)
	c.Assert(err, IsNil)
	recordJSON, _ := json.Marshal(record)
	c.Assert(response.Node.Value, Equals, bytes.NewBuffer(recordJSON).String())
}

// Register is effectively a no-op if the service record already exists in
// etcd.
func (s *ServiceTest) TestRegisterDuplicate(c *C) {
	address := "http://localhost:8080"
	routes := switchboard.Routes{"GET": []string{"/users", "/user/:id"}}
	service := switchboard.NewService("test", s.client, address, routes)
	_, err := service.Register(0)
	c.Assert(err, IsNil)
	_, err = service.Register(0)
	c.Assert(err, IsNil)
}

// Unregister returns an error if the service isn't registered in etcd.
func (s *ServiceTest) TestUnregisterUnregisteredService(c *C) {
	address := "http://localhost:8080"
	routes := switchboard.Routes{"GET": []string{"/users", "/user/:id"}}
	service := switchboard.NewService("test", s.client, address, routes)
	err := service.Unregister()
	c.Assert(err.(*etcd.EtcdError).ErrorCode, Equals, 100)
}

// Unregister deletes the service record in etcd.
func (s *ServiceTest) TestUnregister(c *C) {
	address := "http://localhost:8080"
	routes := switchboard.Routes{"GET": []string{"/users", "/user/:id"}}
	service := switchboard.NewService("test", s.client, address, routes)
	_, err := service.Register(0)
	c.Assert(err, IsNil)
	err = service.Unregister()
	c.Assert(err, IsNil)

	key := "test/" + service.ID()
	sort := false
	recursive := true
	_, err = s.client.Get(key, sort, recursive)
	c.Assert(err.(*etcd.EtcdError).ErrorCode, Equals, 100)
}

// Broadcast stops pushing changes to etcd when when a bool value is sent to
// the stop channel.
func (s *ServiceTest) TestBroadcastStops(c *C) {
	address := "http://localhost:8080"
	routes := switchboard.Routes{"GET": []string{"/users", "/user/:id"}}
	service := switchboard.NewService("test", s.client, address, routes)

	stop := make(chan bool)
	stopped := make(chan bool)
	go func() {
		service.Broadcast(2, 1, stop)
		stopped <- true
	}()

	stop <- true
	c.Assert(<-stopped, Equals, true)
}

// Broadcast registers a service with etcd.
func (s *ServiceTest) TestBroadcast(c *C) {
	// Create a new service.
	address := "http://localhost:8080"
	routes := switchboard.Routes{"GET": []string{"/users", "/user/:id"}}
	service := switchboard.NewService("test", s.client, address, routes)

	// Start broadcasting service changes to etcd.
	stop := make(chan bool)
	stopped := make(chan bool)
	go func() {
		service.Broadcast(2, 1, stop)
		stopped <- true
	}()

	// Cleanly shutdown the broadcaster no matter how the test finishes.
	defer func() {
		stop <- true
		c.Assert(<-stopped, Equals, true)
	}()

	// Janky logic to wait for the broadcaster to write a value to etcd that
	// can be read back will fail when service registration doesn't complete
	// within 500ms.
	receivedUpdate := false
	for i := 0; i < 500; i++ {
		key := "test/" + service.ID()
		sort := false
		recursive := true
		response, err := s.client.Get(key, sort, recursive)
		if err != nil {
			time.Sleep(time.Duration(1) * time.Millisecond)
			continue
		} else {
			record := switchboard.ServiceRecord{
				ID:      service.ID(),
				Address: service.Address(),
				Routes:  service.Routes()}
			recordJSON, _ := json.Marshal(record)
			c.Assert(response.Node.Value, Equals, bytes.NewBuffer(recordJSON).String())
			receivedUpdate = true
			break
		}
	}
	c.Assert(receivedUpdate, Equals, true)
}

repository: jkakar/switchboard

repo_name: jkakar/switchboard


text:
package etcd

import (
	"github.com/NetSys/quilt/db"
)

// Run synchronizes state in `conn` with the Etcd cluster.
func Run(conn db.Conn) {
	store := NewStore()
	makeEtcdDir(minionDir, store, 0)
	makeEtcdDir(subnetStore, store, 0)
	makeEtcdDir(nodeStore, store, 0)

	go runElection(conn, store)
	go runNetwork(conn, store)
	runMinionSync(conn, store)
}

repository: Baisang/quilt

repo_name: Baisang/quilt


text:
% Style guide for all types of paper:
%   - for `author`, use `Surname, Firstname` format
%   - use `doi` whenever known. If a DOI exists, there is no need for a separate
%     link to the publisher page in the `url` field
%   - use `pdf` for authors' preprints, and use `url` for the primary URL of a resource
%   - for arxiv preprints, use `eprint = {1806.10254}` (but not `url`);
%     for arxiv-only articles, use `url` linking to the abstract page (`/abs/...`)

% Style guide for conference papers:
%   - use `booktitle` for full name of the conference (not including "Proceedings of the")
%   - use `series` for conference abbreviation including 4-digit year
%   - keep `publisher` as short as possible: e.g. ACM, IEEE, Springer
%   - for volumes in a series, don't use `volume`, but put the number in the
%     `publisher` field instead, e.g. `publisher = {Springer LNCS volume 8460}`
%   - use `pages` and/or `articleno`, but not `number`
%   - don't use `editor`, `location`, `address`, or `organization`

% Style guide for tech reports:
%   - use `institution` for publishing organisation and `number` for report number
%   - use e.g. `type = {Research Report}` to customise the term "tech report"

% Records in this file are sorted in reverse chronological order (newest first)

% 2020

@inproceedings{Kleppmann2020moving,
author = {Kleppmann, Martin},
title = {Moving Elements in List {CRDTs}},
booktitle = {7th Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2020},
year = {2020},
month = apr,
publisher = {ACM},
articleno = {4},
doi = {10.1145/3380787.3393677},
pdf = {https://martin.kleppmann.com/papers/list-move-papoc20.pdf},
keywords = {text-editing}
}

@inproceedings{Yu2020causalLengths,
author = {Yu, Weihai and Rostad, Sigbj\o{}rn},
title = {A Low-Cost Set {CRDT} Based on Causal Lengths},
booktitle = {7th Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2020},
year = {2020},
month = apr,
publisher = {ACM},
articleno = {5},
doi = {10.1145/3380787.3393678},
keywords = {set-crdt}
}

@inproceedings{Grosch2020AutoCouch,
author = {Grosch, Pascal and Krafft, Roman and W\"{o}lki, Marcel and Bieniusa, Annette},
title = {{AutoCouch}: A {JSON} {CRDT} Framework},
booktitle = {7th Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2020},
year = {2020},
month = apr,
publisher = {ACM},
articleno = {6},
doi = {10.1145/3380787.3393679},
keywords = {systems, Automerge, AutoCouch}
}

@inproceedings{Grishchenko2020Chronofold,
author = {Grishchenko, Victor and Patrakeev, Mikhail},
title = {{Chronofold}: A Data Structure for Versioned Text},
booktitle = {7th Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2020},
year = {2020},
month = apr,
publisher = {ACM},
articleno = {7},
doi = {10.1145/3380787.3393680},
eprint = {2002.09511},
keywords = {text-editing, Chronofold}
}

@inproceedings{Nicolas2020renaming,
author = {Nicolas, Matthieu and Oster, G\'{e}rald and Perrin, Olivier},
title = {Efficient Renaming in Sequence {CRDTs}},
booktitle = {7th Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2020},
year = {2020},
month = apr,
publisher = {ACM},
articleno = {9},
doi = {10.1145/3380787.3393682},
pdf = {https://hal.inria.fr/hal-02526724/document},
keywords = {text-editing, LogootSplit}
}

@inproceedings{vanHardenberg2020PushPin,
author = {van Hardenberg, Peter and Kleppmann, Martin},
title = {{PushPin}: Towards Production-Quality Peer-to-Peer Collaboration},
booktitle = {7th Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2020},
year = {2020},
month = apr,
publisher = {ACM},
articleno = {10},
doi = {10.1145/3380787.3393683},
pdf = {https://martin.kleppmann.com/papers/pushpin-papoc20.pdf},
keywords = {systems, usability, PushPin}
}

@inproceedings{Bauwens2020Flec,
author = {Bauwens, Jim and Boix, Elisa Gonzalez},
title = {{Flec}: A Versatile Programming Framework for Eventually Consistent Systems},
booktitle = {7th Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2020},
year = {2020},
month = apr,
publisher = {ACM},
articleno = {12},
doi = {10.1145/3380787.3393685},
keywords = {systems, Flec}
}

% ACM version is a 2-page summary of arXiv version.
% TODO: update this when the full version is formally published
@inproceedings{Weidner2020composing,
author = {Weidner, Matthew and Miller, Heather and Meiklejohn, Christopher},
title = {Composing and Decomposing Op-Based {CRDTs} with Semidirect Products},
booktitle = {7th Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2020},
year = {2020},
month = apr,
publisher = {ACM},
articleno = {14},
doi = {10.1145/3380787.3393687},
eprint = {2004.04303},
keywords = {composition}
}

% 2019

@inproceedings{Yu2019undo,
author = {Yu, Weihai and Elvinger, Victorien and Ignat, Claudia-Lavinia},
title = {A Generic Undo Support for State-Based {CRDTs}},
booktitle = {23rd International Conference on Principles of Distributed Systems},
series = {OPODIS 2019},
year = {2019},
month = nov,
publisher = {Dagstuhl LIPIcs},
articleno = {14},
doi = {10.4230/LIPIcs.OPODIS.2019.14},
pdf = {https://drops.dagstuhl.de/opus/volltexte/2020/11800/pdf/LIPIcs-OPODIS-2019-14.pdf},
keywords = {state-based, undo}
}

@inproceedings{Kleppmann2019localfirst,
author = {Kleppmann, Martin and Wiggins, Adam and van Hardenberg, Peter and McGranaghan, Mark},
title = {Local-First Software: You own your data, in spite of the cloud},
booktitle = {ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software},
series = {Onward! 2019},
year = {2019},
month = oct,
publisher = {ACM},
pages = {154--178},
doi = {10.1145/3359591.3359737},
pdf = {https://martin.kleppmann.com/papers/local-first.pdf},
keywords = {systems, usability}
}

@article{Kaki2019mergeable,
author = {Kaki, Gowtham and Priya, Swarn and Sivaramakrishnan, KC and Jagannathan, Suresh},
title = {Mergeable Replicated Data Types},
journal = {Proceedings of the ACM on Programming Languages (PACMPL)},
year = {2019},
volume = {3},
number = {OOPSLA},
month = oct,
publisher = {ACM},
doi = {10.1145/3360580},
url = {https://gowthamk.github.io/docs/mrdt.pdf},
keywords = {crdt-related}
}

@article{Mogk2019faulttolerantRP,
author = {Mogk, Ragnar and Drechsler, Joscha and Salvaneschi, Guido and Mezini, Mira},
title = {A Fault-Tolerant Programming Model for Distributed Interactive Applications},
journal = {Proceedings of the ACM on Programming Languages (PACMPL)},
year = {2019},
volume = {3},
number = {OOPSLA},
month = oct,
publisher = {ACM},
doi = {10.1145/3360570},
keywords = {systems}
}

@article{Kollmann2019Snapdoc,
author = {Kollmann, Stephan A and Kleppmann, Martin and Beresford, Alastair R},
title = {{Snapdoc}: Authenticated snapshots with history privacy in peer-to-peer collaborative editing},
journal = {Proceedings on Privacy Enhancing Technologies (PoPETS)},
volume = {2019},
number = {3},
pages = {210--232},
year = {2019},
month = jul,
publisher = {De Gruyter},
doi = {10.2478/popets-2019-0044},
pdf = {https://www.petsymposium.org/2019/files/papers/issue3/popets-2019-0044.pdf},
keywords = {security}
}

@inproceedings{Enes2019synchronization,
author = {Enes, Vitor and Almeida, Paulo S{\'e}rgio and Baquero, Carlos and Leit\~{a}o, Jo\~{a}o},
title = {Efficient Synchronization of State-Based {CRDTs}},
booktitle = {35th IEEE International Conference on Data Engineering},
series = {ICDE 2019},
year = {2019},
month = apr,
pages = {148--159},
doi = {10.1109/ICDE.2019.00022},
eprint = {1803.02750},
keywords = {state-based}
}

@inproceedings{Leijnse2019higherorder,
author = {Leijnse, Adriaan and Almeida, Paulo S\'{e}rgio and Baquero, Carlos},
title = {Higher-Order Patterns in Replicated Data Types},
booktitle = {6th Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2019},
year = {2019},
month = mar,
publisher = {ACM},
articleno = {5},
doi = {10.1145/3301419.3323971},
pdf = {https://repositorio.inesctec.pt/bitstream/123456789/10536/1/P-00Q-WJM.pdf},
keywords = {composition}
}

@inproceedings{Kleppmann2019interleaving,
author = {Kleppmann, Martin and Gomes, Victor B. F. and Mulligan, Dominic P. and Beresford, Alastair R.},
title = {Interleaving Anomalies in Collaborative Text Editors},
booktitle = {6th Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2019},
year = {2019},
month = mar,
publisher = {ACM},
articleno = {6},
doi = {10.1145/3301419.3323972},
pdf = {https://martin.kleppmann.com/papers/interleaving-papoc19.pdf},
keywords = {text-editing}
}

@inproceedings{Mealha2019cloudEdge,
author = {Mealha, David and Pregui\c{c}a, Nuno and Gomes, Maria Cecilia and Leit\~{a}o, Jo\~{a}o},
title = {Data Replication on the Cloud/Edge},
booktitle = {6th Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2019},
year = {2019},
month = mar,
publisher = {ACM},
articleno = {7},
doi = {10.1145/3301419.3323973},
keywords = {systems}
}

@inproceedings{DePorre2019generic,
author = {De Porre, Kevin and Myter, Florian and De Troyer, Christophe and Scholliers, Christophe and De Meuter, Wolfgang and Boix, Elisa Gonzalez},
title = {A Generic Replicated Data Type for Strong Eventual Consistency},
booktitle = {6th Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2019},
year = {2019},
month = mar,
publisher = {ACM},
articleno = {8},
doi = {10.1145/3301419.3323974},
pdf = {http://soft.vub.ac.be/Publications/2019/vub-soft-tr-19-08.pdf},
keywords = {text-editing, operation-based}
}

% 2018

@article{Lv2018CAD,
author = {Lv, Xiao and He, Fazhi and Cheng, Yuan and Wu, Yiqi},
title = {A novel {CRDT}-based synchronization method for real-time collaborative {CAD} systems},
journal = {Advanced Engineering Informatics},
year = {2018},
month = aug,
volume = {38},
pages = {381--391},
publisher = {Elsevier},
doi = {10.1016/j.aei.2018.08.008},
keywords = {systems}
}

@inproceedings{Mogk2018distributedRP,
author = {Mogk, Ragnar and Baumg{\"a}rtner, Lars and Salvaneschi, Guido and Freisleben, Bernd and Mezini, Mira},
title = {Fault-tolerant Distributed Reactive Programming},
booktitle = {32nd European Conference on Object-Oriented Programming},
series = {ECOOP 2018},
ISBN = {978-3-95977-079-8},
ISSN = {1868-8969},
year = {2018},
month = jul,
volume = {109},
publisher = {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},
URN = {urn:nbn:de:0030-drops-92064},
doi = {10.4230/LIPIcs.ECOOP.2018.1},
keywords = {systems}
}

@inproceedings{Chandramouli2018Faster,
author = {Chandramouli, Badrish and Prasaad, Guna and Kossmann, Donald and Levandoski, Justin and Hunter, James and Barnett, Mike},
title = {{FASTER}: A Concurrent Key-Value Store with In-Place Updates},
booktitle = {International Conference on Management of Data},
series = {SIGMOD 2018},
year = {2018},
month = jun,
publisher = {ACM},
pages = {275--290},
doi = {10.1145/3183713.3196898},
pdf = {https://www.microsoft.com/en-us/research/uploads/prod/2018/03/faster-sigmod18.pdf},
keywords = {systems}
}

@article{Preguica2018crdts,
author = {Pregui{\c c}a, Nuno},
title = {Conflict-free Replicated Data Types: An Overview},
year = {2018},
month = jun,
eprint = {1806.10254},
url = {https://arxiv.org/abs/1806.10254},
keywords = {introduction}
}

@incollection{Preguica2018encyclopedia,
author = {Pregui{\c c}a, Nuno and Baquero, Carlos and Shapiro, Marc},
title = {Conflict-Free Replicated Data Types ({CRDT}s)},
booktitle = {Encyclopedia of Big Data Technologies},
year = {2018},
month = may,
publisher = {Springer},
doi = {10.1007/978-3-319-63962-8_185-1},
eprint = {1805.06358},
keywords = {introduction}
}

@article{Kleppmann2018OpSets,
author = {Kleppmann, Martin and Gomes, Victor B F and Mulligan, Dominic P and Beresford, Alastair R},
title = {{OpSets}: Sequential Specifications for Replicated Datatypes (Extended Version)},
year = {2018},
month = may,
eprint = {1805.04263},
url = {https://arxiv.org/abs/1805.04263},
keywords = {specification, verification}
}

@inproceedings{Shapiro2018referential,
author = {Shapiro, Marc and Bieniusa, Annette and Zeller, Peter and Petri, Gustavo},
title = {Ensuring Referential Integrity under Causal Consistency},
booktitle = {5th Workshop on the Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2018},
year = {2018},
month = apr,
publisher = {ACM},
articleno = {1},
doi = {10.1145/3194261.3194262},
pdf = {https://pages.lip6.fr/Marc.Shapiro/papers/causal-refs-papoc-2018-04.pdf},
keywords = {causal-consistency}
}

@inproceedings{Bauwens2018constraining,
author = {Bauwens, Jim and Myter, Florian and Boix, Elisa Gonzalez},
title = {Constraining the Eventual in Eventual Consistency},
booktitle = {5th Workshop on the Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2018},
year = {2018},
month = apr,
publisher = {ACM},
articleno = {2},
doi = {10.1145/3194261.3194263},
pdf = {http://myter.be/papers/papoc18.pdf},
keywords = {counters}
}

% https://blog.acolyer.org/2016/04/25/delta-state-replicated-data-types/
@article{Almeida2018delta,
author = {Almeida, Paulo S\'{e}rgio and Shoker, Ali and Baquero, Carlos},
title = {Delta state replicated data types},
journal = {Journal of Parallel and Distributed Computing},
volume = {111},
pages = {162--173},
year = {2018},
month = jan,
eprint = {1603.01529},
doi = {10.1016/j.jpdc.2017.08.003},
keywords = {state-based}
}

@inproceedings{Najafzadeh2018filesystem,
author = {Najafzadeh, Mahsa and Shapiro, Marc and Eugster, Patrick},
title = {Co-Design and Verification of an Available File System},
booktitle = {19th International Conference on Verification, Model Checking, and Abstract Interpretation},
series = {VMCAI 2018},
year = {2018},
pages = {358--381},
publisher = {Springer LNCS volume 10747},
month = jan,
doi = {10.1007/978-3-319-73721-8_17},
pdf = {https://pages.lip6.fr/Marc.Shapiro/papers/VMCAI-2018-filesys.pdf},
keywords = {trees}
}

% 2017

@mastersthesis{Enes2017sync,
author = {Enes, Vitor},
title = {Efficient Synchronization of State-based {CRDTs}},
school = {Universidade do Minho},
year = {2017},
month = nov,
url = {https://vitorenes.org/page/other/msc-thesis.pdf},
keywords = {state-based}
}

@article{Gomes2017verifying,
author = {Gomes, Victor B F and Kleppmann, Martin and Mulligan, Dominic P and Beresford, Alastair R},
title = {Verifying strong eventual consistency in distributed systems},
journal = {Proceedings of the ACM on Programming Languages (PACMPL)},
year = {2017},
volume = {1},
number = {OOPSLA},
month = oct,
publisher = {ACM},
doi = {10.1145/3133933},
eprint = {1707.01747},
keywords = {specification, verification}
}

@article{Baquero2017composition,
author = {Baquero, Carlos and Almeida, Paulo S{\'e}rgio and Cunha, Alcino and Ferreira, Carla},
title = {Composition in State-based Replicated Data Types},
journal = {Bulletin of the European Association for Theoretical Computer Science},
year = {2017},
month = oct,
number = {123},
pdf = {http://bulletin.eatcs.org/index.php/beatcs/article/viewFile/507/496},
keywords = {composition, state-based}
}

@article{Baquero2017pure,
author = {Baquero, Carlos and Almeida, Paulo S{\'e}rgio and Shoker, Ali},
title = {Pure Operation-Based Replicated Data Types},
year = {2017},
eprint = {1710.04469},
month = oct,
url = {https://arxiv.org/abs/1710.04469},
keywords = {operation-based}
}

@inproceedings{Yu2017disturbance,
author = {Yu, Weihai and Oster, G{\'e}rald and Ignat, Claudia-Lavinia},
title = {Handling Disturbance and Awareness of Concurrent Updates in a Collaborative Editor},
booktitle = {14th International Conference on Cooperative Design, Visualization, and Engineering},
series = {CDVE 2017},
year = {2017},
month = sep,
publisher = {Springer LNCS volume 10451},
pages = {39--47},
doi = {10.1007/978-3-319-66805-5_5},
pdf = {https://hal.inria.fr/hal-01652656/document},
keywords = {systems, usability}
}

@article{Kleppmann2017json,
author = {Kleppmann, Martin and Beresford, Alastair R},
title = {A Conflict-Free Replicated {JSON} Datatype},
journal = {IEEE Transactions on Parallel and Distributed Systems},
year = {2017},
volume = {28},
number = {10},
pages = {2733--2746},
month = apr,
publisher = {IEEE},
doi = {10.1109/TPDS.2017.2697382},
eprint = {1608.03960},
keywords = {trees}
}

@inproceedings{Jungnickel2017imap,
author = {Jungnickel, Tim and Oldenburg, Lennart},
title = {{Pluto}: The {CRDT}-Driven {IMAP} Server},
booktitle = {3rd International Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2017},
year = 2017,
month = apr,
publisher = {ACM},
articleno = {1},
doi = {10.1145/3064889.3064891},
pdf = {http://www.redaktion.tu-berlin.de/fileadmin/a34331500/paper/papoc17-jungnickel.pdf},
keywords = {systems}
}

@inproceedings{Younes2017resettable,
author = {Younes, Georges and Almeida, Paulo S\'{e}rgio and Baquero, Carlos},
title = {Compact Resettable Counters through Causal Stability},
booktitle = {3rd International Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2017},
year = {2017},
month = apr,
publisher = {ACM},
articleno = {2},
doi = {10.1145/3064889.3064892},
pdf = {https://haslab.uminho.pt/cbm/files/a3-younes.pdf},
keywords = {counters}
}

@inproceedings{Zeller2017Repliss,
author = {Zeller, Peter},
title = {Testing Properties of Weakly Consistent Programs with {Repliss}},
booktitle = {3rd International Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2017},
year = {2017},
month = apr,
publisher = {ACM},
articleno = {3},
doi = {10.1145/3064889.3064893},
pdf = {https://dl.acm.org/authorize?N37605},
keywords = {testing, verification}
}

@inproceedings{Enes2017borrowing,
author = {Enes, Vitor and Baquero, Carlos and Almeida, Paulo S\'{e}rgio and Leit\~{a}o, Jo\~{a}o},
title = {Borrowing an Identity for a Distributed Counter: Work in Progress Report},
booktitle = {3rd International Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2017},
year = {2017},
month = apr,
publisher = {ACM},
doi = {10.1145/3064889.3064894},
pdf = {https://haslab.uminho.pt/sites/default/files/cbm/files/a5-enes.pdf},
keywords = {counters}
}

@inproceedings{vanderLinde2017Legion,
author = {van der Linde, Albert and Fouto, Pedro and Leit{\~a}o, Jo{\~a}o and Pregui{\c c}a, Nuno and Casti{\~n}eira, Santiago and Bieniusa, Annette},
title = {{Legion}: Enriching Internet Services with Peer-to-Peer Interactions},
booktitle = {26th International Conference on World Wide Web},
series = {WWW 2017},
year = {2017},
month = apr,
publisher = {ACM},
pages = {283--292},
doi = {10.1145/3038912.3052673},
pdf = {http://novasys.di.fct.unl.pt/~alinde/publications/fp0964-vanderlinde.pdf},
keywords = {systems, Legion}
}

% 2016

% RGASplit and similar block-wise variants of other algorithms
@inproceedings{Briot2016group,
author = {Briot, Lo{\"\i}ck and Urso, Pascal and Shapiro, Marc},
title = {High Responsiveness for Group Editing {CRDTs}},
booktitle = {19th International Conference on Supporting Group Work},
series = {GROUP 2016},
year = {2016},
pages = {51--60},
publisher = {ACM},
month = nov,
doi = {10.1145/2957276.2957300},
pdf = {https://hal.inria.fr/hal-01343941/document},
keywords = {text-editing, RGASplit}
}

% YATA / Yjs
@inproceedings{Nicolaescu2016YATA,
author = {Nicolaescu, Petru and Jahns, Kevin and Derntl, Michael and Klamma, Ralf},
title = {Near Real-Time Peer-to-Peer Shared Editing on Extensible Data Types},
booktitle = {19th International Conference on Supporting Group Work},
series = {GROUP 2016},
year = {2016},
pages = {39--49},
publisher = {ACM},
month = nov,
doi = {10.1145/2957276.2957310},
pdf = {https://www.researchgate.net/publication/310212186_Near_Real-Time_Peer-to-Peer_Shared_Editing_on_Extensible_Data_Types},
keywords = {text-editing, Yjs}
}

% No open access version found
@inproceedings{Lv2016stringbased,
author = {Lv, Xiao and He, Fazhi and Cai, Weiwei and Cheng, Yuan},
title = {An efficient collaborative editing algorithm supporting string-based operations},
booktitle = {20th IEEE International Conference on Computer Supported Cooperative Work in Design},
series = {CSCWD 2016},
year = {2016},
pages = {45--50},
publisher = {IEEE},
month = sep,
doi = {10.1109/CSCWD.2016.7565961},
keywords = {text-editing}
}

@inproceedings{Attiya2016text,
author = {Attiya, Hagit and Burckhardt, Sebastian and Gotsman, Alexey and Morrison, Adam and Yang, Hongseok and Zawirski, Marek},
title = {Specification and Complexity of Collaborative Text Editing},
booktitle = {ACM Symposium on Principles of Distributed Computing},
series = {PODC 2016},
year = {2016},
month = jul,
publisher = {ACM},
pages = {259--268},
doi = {10.1145/2933057.2933090},
pdf = {http://www.cs.ox.ac.uk/people/hongseok.yang/paper/podc16-full.pdf},
keywords = {text-editing, specification, verification}
}

@inproceedings{Akkoorath2016Cure,
author = {Akkoorath, Deepthi Devaki and Tomsic, Alejandro Z. and Bravo, Manuel and Li, Zhongmiao and Crain, Tyler and Bieniusa, Annette and Pregui{\c c}a, Nuno and Shapiro, Marc},
title = {{Cure}: Strong Semantics Meets High Availability and Low Latency},
booktitle = {36th IEEE International Conference on Distributed Computing Systems},
series = {ICDCS 2016},
year = {2016},
month = jun,
publisher = {IEEE},
pages = {405--414},
doi = {10.1109/ICDCS.2016.98},
pdf = {https://pages.lip6.fr/Marc.Shapiro/papers/Cure-final-ICDCS16.pdf},
keywords = {systems}
}

@inproceedings{Brown2016bigsets,
author = {Brown, Russell and Lakhani, Zeeshan and Place, Paul},
title = {Big(Ger) Sets: Decomposed Delta {CRDT} Sets in {Riak}},
booktitle = {2nd Workshop on the Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2016},
year = {2016},
month = apr,
articleno = {5},
publisher = {ACM},
doi = {10.1145/2911151.2911156},
eprint = {1605.06424},
keywords = {set-crdt, systems, composition}
}

@inproceedings{Zawirski2016register,
author = {Zawirski, Marek and Baquero, Carlos and Bieniusa, Annette and Pregui\c{c}a, Nuno and Shapiro, Marc},
title = {Eventually Consistent Register Revisited},
booktitle = {2nd Workshop on the Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2016},
year = {2016},
month = apr,
articleno = {9},
publisher = {ACM},
doi = {10.1145/2911151.2911157},
url = {https://core.ac.uk/download/pdf/154274593.pdf},
eprint = {1511.05010},
keywords = {state-based}
}

@inproceedings{Baquero2016embedded,
author = {Baquero, Carlos and Almeida, Paulo S{\'e}rgio and Lerche, Carl},
title = {The problem with embedded {CRDT} counters and a solution},
booktitle = {2nd Workshop on the Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2016},
year = {2016},
month = apr,
articleno = {10},
publisher = {ACM},
doi = {10.1145/2911151.2911159},
url = {http://haslab.uminho.pt/cbm/files/abstractcounterpapocfinal.pdf},
keywords = {composition, counters}
}

% Replikativ
@inproceedings{Weilbach2016cdvcs,
author = {Weilbach, Christian and K\"{u}hne, Konrad and Bieniusa, Annette},
title = {Decoupling Conflict Resolution with {CDVCS}},
booktitle = {2nd Workshop on the Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2016},
year = {2016},
month = apr,
articleno = {11},
publisher = {ACM},
doi = {10.1145/2911151.2911154},
keywords = {systems, Replikativ}
}

@inproceedings{vanderLinde06delta,
author = {van der Linde, Albert and Leit\~{a}o, Jo\~{a}o and Pregui\c{c}a, Nuno},
title = {{$\Delta$-CRDTs}: Making {$\delta$-CRDTs} Delta-based},
booktitle = {2nd Workshop on the Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2016},
year = {2016},
month = apr,
articleno = {12},
publisher = {ACM},
doi = {10.1145/2911151.2911163},
pdf = {https://novasys.di.fct.unl.pt/~alinde/publications/a12-van_der_linde.pdf},
keywords = {state-based}
}

@inproceedings{Akkoorath2016objects,
author = {Akkoorath, Deepthi Devaki and Bieniusa, Annette},
title = {Highly-Scalable Concurrent Objects},
booktitle = {2nd Workshop on the Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2016},
year = {2016},
month = apr,
articleno = {13},
publisher = {ACM},
doi = {10.1145/2911151.2911158},
pdf = {https://softech.cs.uni-kl.de/homepage/publications/Akkoorath.Bieniusa2016.pdf},
keywords = {shared-memory concurrency}
}

@inproceedings{Nedelec2016CRATE,
author = {N{\'e}delec, Brice and Molli, Pascal and Mostefaoui, Achour},
title = {{CRATE}: Writing Stories Together with our Browsers},
booktitle = {25th International World Wide Web Conference},
series = {WWW 2016},
year = {2016},
pages = {231--234},
publisher = {ACM},
month = apr,
doi = {10.1145/2872518.2890539},
pdf = {https://hal.archives-ouvertes.fr/hal-01303333},
keywords = {text-editing, LSEQ}
}

@inproceedings{Gotsman2016CISE,
author = {Gotsman, Alexey and Yang, Hongseok and Ferreira, Carla and Najafzadeh, Mahsa and Shapiro, Marc},
title = {{'Cause I'm Strong Enough}: Reasoning About Consistency Choices in Distributed Systems},
booktitle = {43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
series = {POPL 2016},
year = {2016},
month = jan,
publisher = {ACM},
pages = {371--384},
numpages = {14},
doi = {10.1145/2837614.2837625},
pdf = {http://software.imdea.org/~gotsman/papers/logic-popl16.pdf},
keywords = {specification, verification}
}

% 2015

% Supercedes "SwiftCloud: Fault-Tolerant Geo-Replication Integrated all the Way to the Client Machine"
% https://arxiv.org/abs/1310.3107 / https://ieeexplore.ieee.org/document/7000132
@inproceedings{Zawirski2015SwiftCloud,
author = {Zawirski, Marek and Pregui{\c c}a, Nuno and Duarte, S{\'e}rgio and Bieniusa, Annette and Balegas, Valter and Shapiro, Marc},
title = {Write Fast, Read in the Past: Causal Consistency for Client-side Applications},
booktitle = {16th Annual Middleware Conference},
year = {2015},
month = dec,
publisher = {ACM/IFIP/USENIX},
pages = {75--87},
doi = {10.1145/2814576.2814733},
pdf = {http://lip6.fr/Marc.Shapiro/papers/write-fast-read-past-middleware-2015.pdf},
keywords = {systems, SwiftCloud}
}

@inproceedings{Briquemont2015partial,
author = {Iwan Briquemont and Manuel Bravo and Zhongmiao Li and Peter Van Roy},
title = {Conflict-free Partially Replicated Data Types},
booktitle = {7th IEEE International Conference on Cloud Computing Technology and Science},
series = {CloudCom 2015},
year = {2015},
month = nov,
publisher = {IEEE},
doi = {10.1109/CloudCom.2015.81},
url = {https://dial.uclouvain.be/pr/boreal/object/boreal%3A214300/datastream/PDF_01/view},
keywords = {systems, SwiftCloud}
}

@inproceedings{Balegas2015invariants,
author = {Balegas, Valter and Serra, Diogo and Duarte, S\'{e}rgio and Ferreira, Carla and Shapiro, Marc and Rodrigues, Rodrigo and Pregui\c{c}a, Nuno},
title = {Extending Eventually Consistent Cloud Databases for Enforcing Numeric Invariants},
booktitle = {34th IEEE Symposium on Reliable Distributed Systems},
series = {SRDS 2015},
year = {2015},
month = sep,
publisher = {IEEE},
pages = {31--36},
doi = {10.1109/SRDS.2015.32},
eprint = {1503.09052},
keywords = {counters}
}

@inproceedings{Meiklejohn2015Lasp2,
author = {Meiklejohn, Christopher and Van Roy, Peter},
title = {{Lasp}: A Language for Distributed, Coordination-free Programming},
booktitle = {17th International Symposium on Principles and Practice of Declarative Programming},
series = {PPDP 2015},
year = {2015},
month = jul,
publisher = {ACM},
pages = {184--195},
doi = {10.1145/2790449.2790525},
pdf = {https://www.info.ucl.ac.be/~pvr/ppdp-2015-cr.pdf},
keywords = {computation, systems}
}

@inproceedings{Nicolaescu2015Yjs,
author = {Nicolaescu, Petru and Jahns, Kevin and Derntl, Michael and Klamma, Ralf},
title = {{Yjs}: A Framework for Near Real-Time {P2P} Shared Editing on Arbitrary Data Types},
booktitle = {15th International Conference on Web Engineering},
series = {ICWE 2015},
year = {2015},
month = jun,
publisher = {Springer LNCS volume 9114},
pages = {675--678},
doi = {10.1007/978-3-319-19890-3_55},
url = {http://dbis.rwth-aachen.de/~derntl/papers/preprints/icwe2015-preprint.pdf},
keywords = {systems, Yjs}
}

@inproceedings{Yu2015undo,
author = {Yu, Weihai and Andr{\'e}, Luc and Ignat, Claudia-Lavinia},
title = {A {CRDT} Supporting Selective Undo for Collaborative Text Editing},
booktitle = {15th IFIP WG 6.1 International Conference on Distributed Applications and Interoperable Systems},
series = {DAIS 2015},
year = {2015},
pages = {193--206},
publisher = {Springer LNCS volume 9038},
month = jun,
doi = {10.1007/978-3-319-19129-4_16},
pdf = {https://members.loria.fr/CIgnat/files/pdf/YuDAIS15.pdf},
keywords = {text-editing, undo}
}

@inproceedings{Tao2015filesystems,
author = {Tao, Vinh and Shapiro, Marc and Rancurel, Vianney},
title = {Merging semantics for conflict updates in geo-distributed file systems},
booktitle = {8th ACM International Systems and Storage Conference},
series = {SYSTOR 2015},
year = {2015},
publisher = {ACM},
month = may,
articleno = {10},
doi = {10.1145/2757667.2757683},
pdf = {https://pages.lip6.fr/Marc.Shapiro/papers/geodistr-FS-Systor-2015.pdf},
keywords = {trees}
}

@techreport{Baquero2015composition,
author = {Baquero, Carlos and Almeida, Paulo S{\'e}rgio and Cunha, Alcino and Ferreira, Carla},
title = {Composition of State-based {CRDTs}},
year = {2015},
month = may,
institution = {HASLab, INESC TEC},
url = {http://haslab.uminho.pt/cbm/files/crdtcompositionreport.pdf},
keywords = {state-based}
}

@inproceedings{Almeida2015delta,
author = {Almeida, Paulo S{\'e}rgio and Shoker, Ali and Baquero, Carlos},
title = {Efficient State-Based {CRDT}s by Delta-Mutation},
booktitle = {International Conference on Networked Systems},
series = {NETYS 2015},
year = 2015,
pages = {62--76},
month = may,
publisher = {Springer LNCS volume 9466},
doi = {10.1007/978-3-319-26850-7_5},
eprint = {1410.2803},
keywords = {state-based}
}

@inproceedings{Navalho2015computations,
author = {Navalho, David and Duarte, S\'{e}rgio and Pregui\c{c}a, Nuno},
title = {A Study of {CRDTs} That Do Computations},
booktitle = {1st Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2015},
year = {2015},
month = apr,
articleno = {1},
publisher = {ACM},
doi = {10.1145/2745947.2745948},
pdf = {http://asc.di.fct.unl.pt/~nmp/pubs/papoc-2015-1.pdf},
keywords = {computation}
}

@inproceedings{Holt2015claret,
author = {Holt, Brandon and Zhang, Irene and Ports, Dan and Oskin, Mark and Ceze, Luis},
title = {{Claret}: Using Data Types for Highly Concurrent Distributed Transactions},
booktitle = {1st Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2015},
year = {2015},
month = apr,
articleno = {4},
publisher = {ACM},
doi = {10.1145/2745947.2745951},
pdf = {http://irenezhang.net/papers/claret-papoc15.pdf},
keywords = {transactions, systems},
}

% Associated master's thesis: https://www.dropbox.com/s/t0cyzfvmah9cldw/Master%20Thesis%20-%20Santiago%20Casti%C3%B1eira.pdf
@inproceedings{Castineira2015offline,
author = {Casti{\~n}eira, Santiago J and Bieniusa, Annette},
title = {Collaborative offline web applications using conflict-free replicated data types},
booktitle = {1st Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2015},
year = {2015},
month = apr,
articleno = {5},
publisher = {ACM},
doi = {10.1145/2745947.2745952},
keywords = {systems}
}

@inproceedings{Meiklejohn2015Lasp1,
author = {Meiklejohn, Christopher and Van Roy, Peter},
title = {Lasp: A Language for Distributed, Eventually Consistent Computations with CRDTs},
booktitle = {1st Workshop on Principles and Practice of Consistency for Distributed Data},
series = {PaPoC 2015},
year = {2015},
month = apr,
articleno = {7},
publisher = {ACM},
doi = {10.1145/2745947.2745954},
url = {https://www.info.ucl.ac.be/~pvr/papoc-2015-lasp-abstract.pdf},
keywords = {computation}
}

% 2014

@article{Burckhardt2014principles,
author = {Burckhardt, Sebastian},
title = {Principles of Eventual Consistency},
journal = {Foundations and Trends in Programming Languages},
year = {2014},
volume = {1},
number = {1-2},
pages = {1--150},
month = oct,
publisher = {now publishers},
doi = {10.1561/2500000011},
pdf = {https://www.nowpublishers.com/article/Download/PGL-011},
keywords = {introduction}
}

% safety analysis
@inproceedings{Li2014Sieve,
author = {Li, Cheng and Leit\~{a}o, Jo\~{a}o and Clement, Allen and Pregui{\c c}a, Nuno and Rodrigues, Rodrigo and Vafeiadis, Viktor},
title = {Automating the Choice of Consistency Levels in Replicated Systems},
booktitle = {USENIX Annual Technical Conference},
series = {ATC 2014},
year = {2014},
month = jun,
publisher = {USENIX},
pages = {281--292},
url = {https://www.usenix.org/conference/atc14/technical-sessions/presentation/li_cheng_2},
keywords = {verification}
}

@incollection{Zeller2014verification,
author = {Zeller, Peter and Bieniusa, Annette and Poetzsch-Heffter, Arnd},
title = {Formal Specification and Verification of {CRDTs}},
booktitle = {34th IFIP International Conference on Formal Techniques for Distributed Objects, Components and Systems},
series = {FORTE 2014},
year = {2014},
month = jun,
pages = {33--48},
publisher = {Springer LNCS volume 8461},
doi = {10.1007/978-3-662-43613-4_3},
url = {https://softech.cs.uni-kl.de/homepage/publications/Zeller.Bieniusa.Poetzsch-Heffter.Forte2014.pdf},
keywords = {specification, verification}
}

@inproceedings{Baquero2014opbased,
author = {Baquero, Carlos and Almeida, Paulo S{\'e}rgio and Shoker, Ali},
title = {Making Operation-Based {CRDT}s Operation-Based},
booktitle = {14th IFIP WG 6.1 International Conference on Distributed Applications and Interoperable Systems},
series = {DAIS 2014},
pages = {126--140},
month = jun,
year = 2014,
publisher = {Springer LNCS volume 8460},
doi = {10.1007/978-3-662-43352-2_11},
pdf = {http://gsd.di.uminho.pt/members/cbm/ps/crdtOpsMiddleware.pdf},
keywords = {operation-based},
note = {A shorter paper with the same title appears in PaPEC 2014}
}

@inproceedings{Brown2014Riak,
author = {Brown, Russell and Cribbs, Sean and Meiklejohn, Christopher and Elliott, Sam},
title = {{Riak DT Map}: A Composable, Convergent Replicated Dictionary},
booktitle = {1st Workshop on Principles and Practice of Eventual Consistency},
series = {PaPEC 2014},
year = {2014},
month = apr,
articleno = {1},
publisher = {ACM},
doi = {10.1145/2596631.2596633},
pdf = {https://pages.lip6.fr/syncfree/attachments/article/46/WP3-report.pdf#page=31},
keywords = {systems, composition}
}

@inproceedings{Almeida2014decomposition,
author = {Almeida, Paulo S{\'e}rgio and Shoker, Ali and Baquero, Carlos},
title = {Efficient State-based {CRDT}s by Decomposition (Work in progress report)},
booktitle = {1st Workshop on Principles and Practice of Eventual Consistency},
series = {PaPEC 2014},
year = {2014},
month = apr,
publisher = {ACM},
articleno = {3},
doi = {10.1145/2596631.2596634},
pdf = {https://core.ac.uk/download/pdf/154274611.pdf},
keywords = {composition}
}

@inproceedings{AhmedNacer2014merging,
author = {Ahmed-Nacer, Mehdi and Urso, Pascal and Balegas, Valter and Pergui{\c c}a, Nuno},
title = {Merging {OT} and {CRDT} algorithms},
booktitle = {1st Workshop on Principles and Practice of Eventual Consistency},
series = {PaPEC 2014},
year = {2014},
month = apr,
articleno = {9},
publisher = {ACM},
doi = {10.1145/2596631.2596636},
pdf = {https://hal.inria.fr/file/index/docid/957167/filename/main.pdf},
keywords = {text-editing}
}

@inproceedings{Meiklejohn2014composability,
author = {Meiklejohn, Christopher},
title = {On the Composability of the {Riak DT Map}: Expanding from Embedded to Multi-key Structures},
booktitle = {1st Workshop on Principles and Practice of Eventual Consistency},
series = {PaPEC 2014},
year = {2014},
articleno = {13},
publisher = {ACM},
doi = {10.1145/2596631.2596635},
pdf = {https://pages.lip6.fr/syncfree/attachments/article/46/WP3-report.pdf#page=34},
keywords = {composition}
}

@inproceedings{Grishchenko2014oplogs,
author = {Grishchenko, Victor},
title = {{Citrea} and {Swarm}: Partially ordered op logs in the browser},
booktitle = {1st Workshop on Principles and Practice of Eventual Consistency},
series = {PaPEC 2014},
year = {2014},
month = apr,
articleno = {8},
publisher = {ACM},
doi = {10.1145/2596631.2596641},
url = {http://www.ds.ewi.tudelft.nl/~victor/polo.pdf},
keywords = {text-editing, operation-based}
}

@inproceedings{Kuper2014LVars,
author = {Kuper, Lindsey and Newton, Ryan R},
title = {Joining Forces: Toward a Unified Account of {LVars} and Convergent Replicated Data Types},
booktitle = {5th Workshop on Determinism and Correctness in Parallel Programming},
series = {WoDet 2014},
year = {2014},
month = mar,
url = {http://wodet.cs.washington.edu/wp-content/uploads/2014/02/wodet2014-final1.pdf},
keywords = {crdt-related, shared-memory concurrency}
}

@inproceedings{Burckhardt2014specification,
author = {Burckhardt, Sebastian and Gotsman, Alexey and Yang, Hongseok and Zawirski, Marek},
title = {Replicated Data Types: Specification, Verification, Optimality},
booktitle = {41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
series = {POPL 2014},
year = {2014},
month = jan,
publisher = {ACM},
pages = {271--284},
doi = {10.1145/2535838.2535848},
pdf = {http://software.imdea.org/~gotsman/papers/distrmm-popl14-ext.pdf},
keywords = {specification, verification}
}

% 2013

% Move operation for text
@inproceedings{AhmedNacer2013concurrency,
author = {Ahmed-Nacer, Mehdi and Urso, Pascal and Balegas, Valter and Pregui{\c c}a, Nuno},
title = {Concurrency Control and Awareness Support for Multi-synchronous Collaborative Editing},
booktitle = {9th IEEE International Conference on Collaborative Computing},
series = {CollaborateCom 2013},
year = {2013},
publisher = {ICST},
month = oct,
doi = {10.4108/icst.collaboratecom.2013.254113},
pdf = {http://asc.di.fct.unl.pt/~nmp/pubs/collaboratecom-2013.pdf},
keywords = {text-editing}
}

@inproceedings{Nedelec2013LSEQ,
author = {N{\'e}delec, Brice and Molli, Pascal and Mostefaoui, Achour and Desmontils, Emmanuel},
title = {{LSEQ}: an Adaptive Structure for Sequences in Distributed Collaborative Editing},
booktitle = {13th ACM Symposium on Document Engineering},
series = {DocEng 2013},
year = {2013},
pages = {37--46},
publisher = {ACM},
month = sep,
doi = {10.1145/2494266.2494278},
pdf = {https://hal.archives-ouvertes.fr/file/index/docid/921633/filename/fp025-nedelec.pdf},
keywords = {text-editing, LSEQ}
}

@article{Almeida2013counters,
author = {Almeida, Paulo S\'{e}rgio and Baquero, Carlos},
title = {Scalable Eventually Consistent Counters over Unreliable Networks},
year = {2013},
month = jul,
eprint = {1307.3207},
url = {https://arxiv.org/abs/1307.3207},
keywords = {counters}
}

@inproceedings{LeMerrer2013Bitbox,
author = {Le Merrer, Erwan and Le Scouarnec, Nicolas and Straub, Gilles},
title = {{Bitbox}: Eventually Consistent File Sharing},
booktitle = {1st International Conference on Networked Systems},
series = {NETYS 2013},
year = {2013},
month = may,
pages = {274–278},
publisher = {Springer LNCS volume 7853},
doi = {10.1007/978-3-642-40148-0_23},
keywords = {systems, Bitbox}
}

@inproceedings{Navalho2013stream,
author = {Navalho, David and Duarte, S\'{e}rgio and Pregui\c{c}a, Nuno and Shapiro, Marc},
title = {Incremental Stream Processing Using Computational Conflict-Free Replicated Data Types},
booktitle = {3rd International Workshop on Cloud Data and Platforms},
series = {CloudDP 2013},
year = {2013},
month = apr,
isbn = {9781450320757},
publisher = {ACM},
pages = {31--36},
doi = {10.1145/2460756.2460762},
pdf = {https://pages.lip6.fr/Marc.Shapiro/papers/computational-CRDTs-CloudDP-2013.pdf},
keywords = {computation}
}

% 2012

@inproceedings{Truong2012authenticating,
author = {Truong, Hien Thi Thu and Ignat, Claudia-Lavinia and Molli, Pascal},
title = {Authenticating operation-based history in collaborative systems},
booktitle = {17th ACM International Conference on Supporting Group Work},
series = {GROUP 2012},
year = {2012},
month = oct,
pages = {131--140},
publisher = {ACM},
doi = {10.1145/2389176.2389197},
url = {https://hal.inria.fr/hal-00761045/document},
keywords = {security}
}

@inproceedings{Conway2012lattices,
author = {Conway, Neil and Marczak, William R. and Alvaro, Peter and Hellerstein, Joseph M. and Maier, David},
title = {Logic and Lattices for Distributed Programming},
booktitle = {3rd ACM Symposium on Cloud Computing},
series = {SoCC 2012},
year = {2012},
month = oct,
publisher = {ACM},
articleno = {1},
pages = {1--14},
doi = {10.1145/2391229.2391230},
pdf = {https://www2.eecs.berkeley.edu/Pubs/TechRpts/2012/EECS-2012-167.pdf},
keywords = {crdt-related}
}

@inproceedings{Bieniusa2012sets,
author = {Bieniusa, Annette and Zawirski, Marek and Pregui\c{c}a, Nuno and Shapiro, Marc and Baquero, Carlos and Balegas, Valter and Duarte, S{\'e}rgio},
title = {Brief Announcement: Semantics of Eventually Consistent Replicated Sets},
booktitle = {26th International Symposium on Distributed Computing},
series = {DISC 2012},
year = {2012},
month = oct,
publisher = {Springer LNCS volume 7611},
pages = {441--442},
doi = {10.1007/978-3-642-33651-5_48},
url = {https://pages.lip6.fr/Marc.Shapiro/papers/semantics-sets-BA-DISC-2012.pdf},
keywords = {set-crdt, specification}
}

@techreport{Bieniusa2012optimized,
author = {Bieniusa, Annette and Zawirski, Marek and Pregui{\c c}a, Nuno and Shapiro, Marc and Baquero, Carlos and Balegas, Valter and Duarte, S{\'e}rgio},
title = {An Optimized Conflict-free Replicated Set},
type = {Research Report},
institution = {INRIA},
number = {RR-8083},
year = {2012},
month = oct,
eprint = {1210.3368},
pdf = {http://hal.inria.fr/hal-00738680/PDF/RR-8083.pdf},
keywords = {set-crdt}
}

@techreport{AhmedNacer2012filesystem,
author = {Ahmed-Nacer, Mehdi and Martin, St{\'e}phane and Urso, Pascal},
title = {File system on {CRDT}},
institution = {INRIA},
year = {2012},
month = jul,
number = {RR-8027},
publisher = {INRIA},
type = {Research Report},
eprint = {1207.5990},
url = {https://hal.inria.fr/hal-00720681/},
keywords = {trees}
}

@inproceedings{Burckhardt2012CloudTypes,
author = {Burckhardt, Sebastian and F{\"a}hndrich, Manuel and Leijen, Daan and Wood, Benjamin P},
title = {Cloud Types for Eventual Consistency},
booktitle = {26th European Conference on Object-Oriented Programming},
series = {ECOOP 2012},
year = {2012},
month = jun,
pages = {283--307},
publisher = {Springer LNCS volume 7313},
doi = {10.1007/978-3-642-31057-7_14},
url = {https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/final-with-color.pdf},
keywords = {crdt-related}
}

@inproceedings{Burckhardt2012transactions,
author = {Burckhardt, Sebastian and Leijen, Daan and F{\"a}hndrich, Manuel and Sagiv, Mooly},
title = {Eventually Consistent Transactions},
booktitle = {21st European Symposium on Programming},
series = {ESOP 2012},
year = {2012},
month = mar,
publisher = {Springer LNCS volume 7211},
pages = {67--86},
doi = {10.1007/978-3-642-28869-2_4},
pdf = {https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/ecr-esop2012.pdf},
keywords = {crdt-related, transactions}
}

% 2011

@inproceedings{Shapiro2011CRDTs,
author = {Shapiro, Marc and Pregui\c{c}a, Nuno and Baquero, Carlos and Zawirski, Marek},
title = {Conflict-free Replicated Data Types},
booktitle = {13th International Conference on Stabilization, Safety, and Security of Distributed Systems},
series = {SSS 2011},
year = {2011},
month = oct,
pages = {386--400},
doi = {10.1007/978-3-642-24550-3_29},
pdf = {https://pages.lip6.fr/Marek.Zawirski/papers/RR-7687.pdf},
publisher = {Springer LNCS volume 6976},
keywords = {introduction}
}

@inproceedings{AhmedNacer2011evaluating,
author = {Ahmed-Nacer, Mehdi and Ignat, Claudia-Lavinia and Oster, G{\'e}rald and Roh, Hyun-Gul and Urso, Pascal},
title = {Evaluating {CRDTs} for real-time document editing},
booktitle = {11th ACM Symposium on Document Engineering},
series = {DocEng 2011},
year = {2011},
pages = {103--112},
publisher = {ACM},
month = sep,
doi = {10.1145/2034691.2034717},
pdf = {https://hal.inria.fr/docs/00/62/95/03/PDF/doce63-ahmednacer.pdf},
keywords = {text-editing}
}

@article{Roh2011RGA,
author = {Roh, Hyun-Gul and Jeon, Myeongjae and Kim, Jin-Soo and Lee, Joonwon},
title = {Replicated Abstract Data Types: Building Blocks for Collaborative Applications},
journal = {Journal of Parallel and Distributed Computing},
volume = {71},
number = {3},
month = mar,
year = {2011},
issn = {0743-7315},
pages = {354--368},
publisher = {Elsevier},
doi = {10.1016/j.jpdc.2010.12.006},
pdf = {http://csl.snu.ac.kr/papers/jpdc11.pdf},
keywords = {text-editing, RGA}
}

@techreport{Shapiro2011comprehensive,
author = {Shapiro, Marc and Pregui{\c c}a, Nuno and Baquero, Carlos and Zawirski, Marek},
title = {A comprehensive study of Convergent and Commutative Replicated Data Types},
year = {2011},
number = {7506},
month = jan,
institution = {INRIA},
type = {Research Report},
url = {http://hal.inria.fr/inria-00555588/},
keywords = {introduction}
}

% 2010

% Extended version available as INRIA tech report RR-7362 https://hal.inria.fr/inria-00508436/
@inproceedings{Martin2010xml,
author = {Martin, St{\'e}phane and Urso, Pascal and Weiss, St{\'e}phane},
title = {Scalable {XML} Collaborative Editing with Undo},
booktitle = {On the Move to Meaningful Internet Systems (OTM)},
year = {2010},
pages = {507--514},
publisher = {Springer LNCS volume 6426},
month = oct,
doi = {10.1007/978-3-642-16934-2_37},
eprint = {1010.3615},
keywords = {trees, undo}
}

@article{Weiss2010LogootUndo,
author = {Weiss, Stephane and Urso, Pascal and Molli, Pascal},
title = {{Logoot-Undo}: Distributed Collaborative Editing System on {P2P} Networks},
journal = {IEEE Transactions on Parallel and Distributed Systems},
volume = {21},
number = {8},
month = aug,
year = {2010},
issn = {1045-9219},
pages = {1162--1174},
publisher = {IEEE},
doi = {10.1109/TPDS.2009.173},
pdf = {https://www.researchgate.net/profile/Pascal_Urso/publication/233882440_Logoot-Undo_Distributed_Collaborative_Editing_System/links/0fcfd50c84f5194937000000.pdf},
keywords = {text-editing, Logoot, undo}
}

@inproceedings{Grishchenko2010hypertext,
author = {Grishchenko, Victor},
title = {Deep Hypertext with Embedded Revision Control Implemented in Regular Expressions},
booktitle = {6th International Symposium on Wikis and Open Collaboration},
series = {WikiSym 2010},
year = {2010},
month = jul,
publisher = {ACM},
articleno = {3},
doi = {10.1145/1832772.1832777},
url = {http://www.st.ewi.tudelft.nl/victor/articles/ctre.pdf},
keywords = {text-editing}
}

@article{Letia2010consistency,
author = {Letia, Mihai and Pregui{\c c}a, Nuno and Shapiro, Marc},
title = {Consistency without concurrency control in large, dynamic systems},
journal = {ACM SIGOPS Operating Systems Review},
year = {2010},
volume = {44},
number = {2},
pages = {29--34},
month = apr,
publisher = {ACM},
doi = {10.1145/1773912.1773921},
pdf = {http://asc.di.fct.unl.pt/~nmp/pubs/osr-2010.pdf},
keywords = {introduction}
}

% 2009

@inproceedings{Preguica2009Treedoc,
author = {Pregui{\c c}a, Nuno and Marques, Joan Manuel and Shapiro, Marc and Letia, Mihai},
title = {A Commutative Replicated Data Type for Cooperative Editing},
booktitle = {29th IEEE International Conference on Distributed Computing Systems},
series = {ICDCS 2009},
year = {2009},
pages = {395--403},
publisher = {IEEE},
doi = {10.1109/ICDCS.2009.20},
pdf = {https://hal.inria.fr/inria-00445975/document},
keywords = {text-editing, Treedoc}
}

@inproceedings{Weiss2009Logoot,
author = {Weiss, Stephane and Urso, Pascal and Molli, Pascal},
title = {{Logoot}: A Scalable Optimistic Replication Algorithm for Collaborative Editing on {P2P} Networks},
booktitle = {29th IEEE International Conference on Distributed Computing Systems},
series = {ICDCS 2009},
year = {2009},
pages = {404--412},
publisher = {IEEE},
doi = {10.1109/ICDCS.2009.75},
pdf = {https://hal.inria.fr/inria-00432368/document},
keywords = {text-editing, Logoot}
}

% 2008

% 2007

@inproceedings{Weiss2007Wooki,
author = {Weiss, St{\'e}phane and Urso, Pascal and Molli, Pascal},
title = {{Wooki}: A {P2P} Wiki-Based Collaborative Writing Tool},
booktitle = {8th International Conference on Web Information Systems Engineering},
series = {WISE 2007},
year = {2007},
pages = {503--512},
publisher = {Springer LNCS volume 4831},
month = dec,
doi = {10.1007/978-3-540-76993-4_42},
pdf = {http://pagesperso.lina.univ-nantes.fr/~molli-p/pmwiki/uploads/Main/weiss07.pdf},
keywords = {text-editing, WOOTO}
}

% 2006

@inproceedings{Oster2006WOOT,
author = {Oster, G{\'e}rald and Urso, Pascal and Molli, Pascal and Imine, Abdessamad},
title = {Data consistency for {P2P} collaborative editing},
booktitle = {20th ACM Conference on Computer Supported Cooperative Work},
series = {CSCW 2006},
year = {2006},
pages = {259--268},
publisher = {ACM},
month = nov,
doi = {10.1145/1180875.1180916},
pdf = {https://hal.inria.fr/file/index/docid/108523/filename/OsterCSCW06.pdf},
keywords = {text-editing, WOOT}
}

% 2005

% Detailed specification and analysis of WOOT CRDT
@techreport{Oster2005WOOT,
author = {Oster, G{\'e}rald and Urso, Pascal and Molli, Pascal and Imine, Abdessamad},
title = {Real time group editors without operational transformation},
year = {2005},
number = {RR-5580},
month = may,
institution = {INRIA},
type = {Research Report},
url = {https://hal.inria.fr/inria-00071240/document},
keywords = {text-editing, WOOT}
}

repository: postwait/crdt-website

repo_name: postwait/crdt-website


text: 2,5,6,7,8,10,11,11,11,11,13,14,15,18,18,20,22,22,22,23,24,24,27,29,31,37,37,41,42,43,46,46,53,57,58,58,79

repository: cydemily/CLOUD-ENGINE

repo_name: cydemily/CLOUD-ENGINE


text:
// Advent of Code 2018: Day 2, Part 2
// https://adventofcode.com/2018/day/2#part2
// Jesse Williams
// Answer: revtaubfniyhsgxdoajwkqilp

#include <fstream>
#include <iostream>
#include <string>
#include <vector>

int similarCount(std::string strA, std::string strB) {
    // Checks two strings for similarity and returns number of characters in common.
    if (strA.size() != strB.size()) { return -1; }

    int count = 0;
    for (int i = 0; i < strA.size(); i++) {
        if (strA[i] == strB[i]) {
            count++;  // count characters in common
        }
    }
    return count;
}

std::string removeDiffChar(std::string strA, std::string strB) {
    // Removes characters not in common between two strings and returns only common letters (in order)
    int count = 0;
    std::string outStr = "";
    for (int i = 0; i < strA.size(); i++) {
        if (strA[i] == strB[i]) {
            outStr += strA[i];  // count characters in common
        }
    }
    return outStr;
}

int main() {
    std::ifstream input;
    input.open("day2_input.txt");

    std::vector<std::string> allIDs;
    std::string boxID;
    while (input >> boxID) {  // passes one 'word' at a time
        allIDs.emplace_back(boxID);  // store all words in array
    }

    for (int i = 0; i < allIDs.size(); i++) {
        for (int j = i+1; j < allIDs.size(); j++) {
            if (similarCount(allIDs[i], allIDs[j]) == allIDs[i].size()-1) {
                std::string commonChars = removeDiffChar(allIDs[i], allIDs[j]);
                std::cout << "~ " << allIDs[i] << "\n~ " << allIDs[j] << "\nLetters in common: '" << commonChars << "'";
                return 0;
            }
        }
    }
    input.close();
    return 0;
}

extension: cpp


text:
%%% -*-BibTeX-*-
@article{Generalized2010Shen,
   author   = {Chunhua Shen and Junae Kim and Hanzi Wang},
   title    = {Generalized Kernel-based Visual Tracking},
   journal  = {IEEE Transactions on Circuits and Systems for Video Technology},
   volume   = {20},
   number   = {1},
   year     = {2010},
   month    = {January},
   pages    = {119--130},
   publisher= {},
   url      = {http://dx.doi.org/10.1109/TCSVT.2009.2031393},
   pdf      = {http://sites.google.com/site/chhshen/publication/TCSVT2010.pdf},
   eprint    = {0905.2463},
   venue    = {TCSVT},
   project  = {https://github.com/chhshen/KernelTracking},
}


text:
# Based on linux-yocto-custom.bb:
#
# Notes:
#
#   patches: patches can be merged into to the source git tree itself,
#            added via the SRC_URI, or controlled via a BSP
#            configuration.
#
#   defconfig: When a defconfig is provided, the linux-yocto configuration
#              uses the filename as a trigger to use a 'allnoconfig' baseline
#              before merging the defconfig into the build.
#
#              If the defconfig file was created with make_savedefconfig,
#              not all options are specified, and should be restored with their
#              defaults, not set to 'n'. To properly expand a defconfig like
#              this, specify: KCONFIG_MODE="--alldefconfig" in the kernel
#              recipe.
#
#   example configuration addition:
#            SRC_URI += "file://smp.cfg"
#   example patch addition (for kernel v3.4 only):
#            SRC_URI += "file://0001-linux-version-tweak.patch
#   example feature addition (for kernel v3.4 only):
#            SRC_URI += "file://feature.scc"
#

inherit kernel
require recipes-kernel/linux/linux-yocto.inc
KBRANCH = "linux-4.4.y"

# Override SRC_URI in a bbappend file to point at a different source
# tree if you do not want to build from Linus' tree.
#SRC_URI = "git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git;protocol=git;nocheckout=1;name=machine"
#SRC_URI = "git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git;protocol=git;nocheckout=1;name=machine"
SRC_URI = "git:///mnt/devel/git-repos/linux-stable.git;protocol=file;branch=${KBRANCH};nocheckout=1;name=machine"

SRC_URI += "file://defconfig"
FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"

#LINUX_VERSION = "3.19"
LINUX_VERSION = "4.4.4"
LINUX_VERSION_EXTENSION = "-rationalist"

# Override SRCREV to point to a different commit in a bbappend file to
# build a different release of the Linux kernel.
# tag: v3.4 76e10d158efb6d4516018846f60c2ab5501900bc
#SRCREV = "96e199f1751e707a7a8c04d9b079f84df2e0d4ff"
SRCREV = "c252409a688a831385fb71097db7a86ffe595b74"

PR = "r2"
PV = "${LINUX_VERSION}+git${SRCPV}"

COMPATIBLE_MACHINE = "mousetrap_hw|pcengines-apu2"

repository: acooks/meta-rationalist

repo_name: acooks/meta-rationalist


text:
#
# Copyright (C) 2014 Eric Mauser
#

SUMMARY = "default tools package groups"
LICENSE = "MIT"

inherit packagegroup

RDEPENDS_${PN} = "\
    udev-extraconf \
	psmisc \
	util-linux \
    htop \
    vim \
	screen \
    "

repository: shagu/meta-teapot

repo_name: shagu/meta-teapot


text:
package wdl

import (
    "os"
    "io/ioutil"
    "sort"
)

type File struct {
    Size int64      // 文件大小
    Path string     // 地址
    Pieces []Piece
}

type Piece struct {
    Path string
    Body []byte     // 数据
    Index int
}

func (this *Piece) Length() int {
    return len(this.Body)
}

func (this *File) PieceNum() int {
    return len(this.Pieces)
}

func (this *File) SortPieces() []Piece {
    sort.Slice(this.Pieces, func (i, j int) bool {
        return this.Pieces[i].Index < this.Pieces[j].Index
    })
    return this.Pieces
}

func (this *File) AddPieceFromPath(filepath string) error{

    _, err := os.OpenFile(filepath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
    if err != nil {
        return err
    }

    body, err := ioutil.ReadFile(filepath)
    if err != nil {
        return err
    }

    piece := Piece{Path: filepath, Body: body}

    this.Pieces = append(this.Pieces, piece)

    return nil
}

func (this *File) AddPieceFromBytes(index int, body []byte) error {

    piece := Piece{Index: index, Body: body}

    this.Pieces = append(this.Pieces, piece)

    return nil
}

func (this *File) Save() error {
    pieces := this.SortPieces()
    file, err := os.OpenFile(this.Path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
    if err != nil {
        return err
    }
    for _, d := range pieces {
        file.Write(d.Body)
    }
    file.Close()
    return nil
}

func NewFile(path string) *File {
    return &File{
        Path: path,
    }
}

repository: wxnacy/wdl

repo_name: wxnacy/wdl


text:
#===============================================================================
# Copyright 2018 Intel Corporation
#
# 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.
#===============================================================================

# Utils for managing threading-related configuration
#===============================================================================

if(Threading_cmake_included)
    return()
endif()
set(Threading_cmake_included true)

# Replace existing define for threading (if any) with a new one
macro(set_threading threading)
    if(MKLDNN_THR_CURRENT)
        remove_definitions(-DMKLDNN_THR=${MKLDNN_THR_CURRENT})
    endif()
    set(MKLDNN_THR_CURRENT MKLDNN_THR_${threading})
    add_definitions(-DMKLDNN_THR=${MKLDNN_THR_CURRENT})
endmacro()

# While MKL-DNN defaults to OpenMP (if _OPENMP is defined) without CMake, here
# we default to sequential threading and let OpenMP.cmake and TBB.cmake to
# figure things out. This is especially important because OpenMP is used both
# for threading and vectorization via #pragma omp simd
set_threading("SEQ")

extension: cmake


text:
package main

import (
	"fmt"
)

// START OMIT
var str = "string" // will be string
var integer = 5    //         int
var float = 3.4    //         float64
// END OMIT

func main() {
	fmt.Printf("str = %t\n", str)
	fmt.Printf("integer = %t\n", integer)
	fmt.Printf("float = %t\n", float)
}

repository: xperimental/go-intro

repo_name: xperimental/go-intro


text:
// Copyright 2019 The Nym Mixnet Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/*
	Package topology implements all useful topology-related functions
	which are used in the code of anonymous messaging system.
*/

package topology

import (
	"encoding/base64"
	"encoding/json"
	"errors"
	"io/ioutil"
	"net"
	"net/http"

	"github.com/nymtech/nym-directory/models"
	"github.com/nymtech/nym-mixnet/config"
)

// MixPresence defines map containing presence information of all mix nodes in given topology.
type MixPresence []models.MixNodePresence

// MixPresence defines map containing presence information of all providers in given topology.
type ProviderPresence []models.MixProviderPresence

// LayeredMixes defines map of list of mix nodes corresponding to particular layer in given topology.
type LayeredMixes map[uint][]config.MixConfig

const (
	DefaultClientHost = "0.0.0.0"
	DefaultClientPort = "42"
)

func GetNetworkTopology(endpoint string) (*models.Topology, error) {
	resp, err := http.Get(endpoint)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	model := &models.Topology{}
	if err := json.Unmarshal(body, model); err != nil {
		return nil, err
	}

	return model, nil
}

// GetMixesPKI returns PKI data for mix nodes, grouped by layer
func GetMixesPKI(mixPresence MixPresence) (LayeredMixes, error) {
	mixes := make(LayeredMixes)
	for k, v := range mixPresence {
		b, err := base64.URLEncoding.DecodeString(v.PubKey)
		if err != nil {
			continue
		}
		host, port, err := net.SplitHostPort(v.Host) // TODO: do we want to split them?
		if err != nil {
			continue
		}
		newMixEntry := config.MixConfig{
			Id:     mixPresence[k].PubKey,
			Host:   host,
			Port:   port,
			PubKey: b,
			Layer:  uint64(v.Layer),
		}
		if layerMixes, ok := mixes[v.Layer]; ok {
			extendedLayer := append(layerMixes, newMixEntry)
			mixes[v.Layer] = extendedLayer
		} else {
			mixes[v.Layer] = []config.MixConfig{newMixEntry}
		}
	}
	return mixes, nil
}

func ProviderPresenceToConfig(presence models.MixProviderPresence) (config.MixConfig, error) {
	b, err := base64.URLEncoding.DecodeString(presence.PubKey)
	if err != nil {
		return config.MixConfig{}, errors.New("invalid provider presence")
	}
	host, port, err := net.SplitHostPort(presence.Host) // TODO: do we want to split them?
	if err != nil {
		return config.MixConfig{}, err
	}

	return config.NewMixConfig(presence.Host, host, port, b, config.ProviderLayer), nil
}

func RegisteredClientToConfig(client models.RegisteredClient) (config.ClientConfig, error) {
	b, err := base64.URLEncoding.DecodeString(client.PubKey)
	if err != nil {
		return config.ClientConfig{}, errors.New("invalid client information")
	}

	return config.ClientConfig{
		Id:     client.PubKey,
		Host:   DefaultClientHost,
		Port:   DefaultClientPort,
		PubKey: b,
	}, nil
}

// GetClientPKI returns a map of the current client PKI from the PKI database
func GetClientPKI(providerPresence ProviderPresence) ([]config.ClientConfig, error) {
	var clientsNum int = 0
	for _, v := range providerPresence {
		clientsNum += len(v.RegisteredClients)
	}

	clients := make([]config.ClientConfig, 0, clientsNum)
	for _, provider := range providerPresence {
		providerCfg, err := ProviderPresenceToConfig(provider)
		if err != nil {
			continue
		}
		for _, client := range provider.RegisteredClients {
			clientCfg, err := RegisteredClientToConfig(client)
			if err != nil {
				continue
			}
			clientCfg.Provider = &providerCfg
			clients = append(clients, clientCfg)
		}
	}
	return clients, nil
}

repository: nymtech/nym-mixnet

repo_name: nymtech/nym-mixnet

branch_name: refs/heads/develop

gha_language: Go


text:
require libunwind.inc
PR = "${INC_PR}.0"

SRC_URI[archive.md5sum] = "3e9ca08118e22165a7f07d01d61a2d0d"
SRC_URI[archive.sha256sum] = "56083aae17eab3ccb7a36b95f0430f5a5f258755bf193bb5ca4fd4b918356164"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
// Package project handles project.toml parsing
package project

import (
	"github.com/pkg/errors"

	"github.com/BurntSushi/toml"
	"github.com/SAP/jenkins-library/pkg/cnbutils"
	"github.com/SAP/jenkins-library/pkg/cnbutils/project/types"
	v01 "github.com/SAP/jenkins-library/pkg/cnbutils/project/v01"
	v02 "github.com/SAP/jenkins-library/pkg/cnbutils/project/v02"
	"github.com/SAP/jenkins-library/pkg/cnbutils/registry"
	piperhttp "github.com/SAP/jenkins-library/pkg/http"
	"github.com/SAP/jenkins-library/pkg/log"
	ignore "github.com/sabhiram/go-gitignore"
)

type project struct {
	Version string `toml:"schema-version"`
}

type versionDescriptor struct {
	Project project `toml:"_"`
}

var parsers = map[string]func(string) (types.Descriptor, error){
	"0.1": v01.NewDescriptor,
	"0.2": v02.NewDescriptor,
}

type Descriptor struct {
	Exclude        *ignore.GitIgnore
	Include        *ignore.GitIgnore
	EnvVars        map[string]interface{}
	Buildpacks     []string
	PreBuildpacks  []string
	PostBuildpacks []string
	ProjectID      string
}

func ParseDescriptor(descriptorPath string, utils cnbutils.BuildUtils, httpClient piperhttp.Sender) (*Descriptor, error) {
	descriptor := &Descriptor{}

	descriptorContent, err := utils.FileRead(descriptorPath)
	if err != nil {
		return nil, err
	}

	var versionDescriptor versionDescriptor
	_, err = toml.Decode(string(descriptorContent), &versionDescriptor)
	if err != nil {
		return &Descriptor{}, errors.Wrapf(err, "parsing schema version")
	}

	version := versionDescriptor.Project.Version
	if version == "" {
		version = "0.1"
	}

	rawDescriptor, err := parsers[version](string(descriptorContent))
	if err != nil {
		return &Descriptor{}, err
	}

	if len(rawDescriptor.Build.Buildpacks) > 0 {
		descriptor.Buildpacks, err = searchBuildpacks(rawDescriptor.Build.Buildpacks, httpClient)
		if err != nil {
			return nil, err
		}
	}

	if len(rawDescriptor.Build.Pre.Buildpacks) > 0 {
		descriptor.PreBuildpacks, err = searchBuildpacks(rawDescriptor.Build.Pre.Buildpacks, httpClient)
		if err != nil {
			return nil, err
		}
	}

	if len(rawDescriptor.Build.Post.Buildpacks) > 0 {
		descriptor.PostBuildpacks, err = searchBuildpacks(rawDescriptor.Build.Post.Buildpacks, httpClient)
		if err != nil {
			return nil, err
		}
	}

	if len(rawDescriptor.Build.Env) > 0 {
		descriptor.EnvVars = envToMap(rawDescriptor.Build.Env)
	}

	if len(rawDescriptor.Build.Exclude) > 0 && len(rawDescriptor.Build.Include) > 0 {
		return nil, errors.New("project descriptor options 'exclude' and 'include' are mutually exclusive")
	}

	if len(rawDescriptor.Build.Exclude) > 0 {
		descriptor.Exclude = ignore.CompileIgnoreLines(rawDescriptor.Build.Exclude...)
	}

	if len(rawDescriptor.Build.Include) > 0 {
		descriptor.Include = ignore.CompileIgnoreLines(rawDescriptor.Build.Include...)
	}

	if len(rawDescriptor.Project.ID) > 0 {
		descriptor.ProjectID = rawDescriptor.Project.ID
	}

	return descriptor, nil
}

func envToMap(env []types.EnvVar) map[string]interface{} {
	envMap := map[string]interface{}{}

	for _, e := range env {
		if len(e.Name) == 0 {
			continue
		}

		envMap[e.Name] = e.Value
	}

	return envMap
}

func searchBuildpacks(buildpacks []types.Buildpack, httpClient piperhttp.Sender) ([]string, error) {
	var bpackImg []string

	for _, bpack := range buildpacks {
		if bpack.Script != (types.Script{}) {
			return nil, errors.New("inline buildpacks are not supported")
		}

		if bpack.URI != "" {
			log.Entry().Debugf("Adding buildpack using URI: %s", bpack.URI)
			bpackImg = append(bpackImg, bpack.URI)
		} else if bpack.ID != "" {
			imgURL, err := registry.SearchBuildpack(bpack.ID, bpack.Version, httpClient, "")
			if err != nil {
				return nil, err
			}

			bpackImg = append(bpackImg, imgURL)
		} else {
			return nil, errors.New("invalid buildpack entry in project.toml, either URI or ID should be specified")
		}

	}

	return bpackImg, nil
}

repository: SAP/jenkins-library

repo_name: SAP/jenkins-library


text:
DESCRIPTION = "Multiproc transport layer for KeyStone devices: Provide basic transport layer for moving data between different processing nodes"
HOMEPAGE = "http://git.ti.com/cgit/cgit.cgi/keystone-linux/mpm-transport.git"
LICENSE = "BSD-3-Clause & MIT"
LIC_FILES_CHKSUM = "file://LICENSE.txt;md5=122b7757f366f3f6fe11988715258fc9"
COMPATIBLE_MACHINE = "keystone"

DEPENDS = "common-csl-ip edma3-lld mmap-lld cmem rm-lld qmss-lld cppi-lld uio-module-drv syslog-ng"
DEPENDS_append_k2hk = " hyplnk-lld srio-lld"
DEPENDS_append_k2e = " hyplnk-lld"

RDEPENDS_${PN} = "syslog-ng"

PACKAGE_ARCH = "${MACHINE_ARCH}"

SRC_URI = "git://git.ti.com/keystone-linux/mpm-transport.git;protocol=git;branch=${BRANCH}"

BRANCH = "master"
# This commit corresponds to tag DEV.MPM-TRANSPORT-02.00.04.00
SRCREV = "e0e44fe55bef7ddf89f7ff3574f07fa906e72a37"

PV = "2.0.4.0"
PR = "r0"

EXTRA_OEMAKE = "PDK_INSTALL_PATH=${STAGING_INCDIR}"
EXTRA_OEMAKE_append_k2hk += "HYPLNK_TRANSPORT=true SRIO_TRANSPORT=true"
EXTRA_OEMAKE_append_k2e += "HYPLNK_TRANSPORT=true"
INSANE_SKIP_${PN} += "ldflags"

S = "${WORKDIR}/git"

PACKAGES =+ "${PN}-test"
FILES_${PN}-test = "${bindir}/mpm_transport_test.out \
					${bindir}/mpm_transport_hyplnk_loopback.out \
					${bindir}/mpm_transport_hyplnk_remote.out \
					${bindir}/mpm_transport_hyplnk_loopback_dma.out \
					${bindir}/mpm_transport_hyplnk_loopback64.out \
					${bindir}/mpm_transport_qmss_arm_mt.out \
					${bindir}/mpm_transport_srio_arm_mt.out"

do_install() {
	oe_runmake installbin BASE_DIR=${S} INSTALL_BIN_BASE_DIR=${D}/${bindir}

	install -d ${D}${includedir}/
	install -c -m 644 ${S}/include/* ${D}${includedir}/

	install -d ${D}${libdir}/
	cp  -a --preserve=mode,timestamps --no-preserve=ownership ${S}/lib/* ${D}${libdir}/

	install -d ${D}${sysconfdir}/mpm/
	install -c -m 644 ${S}/scripts/mpm_config.json ${D}${sysconfdir}/mpm/mpm_config.json
}


text:
# Maintainer: joaander

##################################
## Find CUDA
# If CUDA is enabled, set it up
if (ENABLE_CUDA)
	# the package is needed
	find_package(CUDA REQUIRED REQUIRED)

	if (${CUDA_VERSION} VERSION_LESS 5.0)
		message(SEND_ERROR "CUDA 5.0 or newer is required")
	endif (${CUDA_VERSION} VERSION_LESS 5.0)

    # Find Thrust
    find_package(Thrust)

    if (${THRUST_VERSION} VERSION_LESS 1.5.0)
        message(SEND_ERROR "Thrust version ${THRUST_VERSION} found, >= 1.5.0 is required")
    endif (${THRUST_VERSION} VERSION_LESS 1.5.0)

    # first thrust, then CUDA (to allow for local thrust installation
    # that overrides CUDA toolkit)
    include_directories(${THRUST_INCLUDE_DIR})

	include_directories(${CUDA_INCLUDE_DIRS})

    get_directory_property(DIRS INCLUDE_DIRECTORIES SYSTEM)
    # hide some variables users don't need to see
    mark_as_advanced(CUDA_SDK_ROOT_DIR)
    if (CUDA_TOOLKIT_ROOT_DIR)
        mark_as_advanced(CUDA_TOOLKIT_ROOT_DIR)
    endif (CUDA_TOOLKIT_ROOT_DIR)
    mark_as_advanced(CUDA_VERBOSE_BUILD)
    mark_as_advanced(CUDA_BUILD_EMULATION)
    mark_as_advanced(CUDA_HOST_COMPILER)
    mark_as_advanced(CUDA_dl_LIBRARY)
    mark_as_advanced(CUDA_rt_LIBRARY)
    mark_as_advanced(THRUST_INCLUDE_DIR)

    if (ENABLE_NVTOOLS)
        find_library(CUDA_nvToolsExt_LIBRARY
                     NAMES nvToolsExt
                     PATHS "${CUDA_TOOLKIT_ROOT_DIR}/lib64"
                           "${CUDA_TOOLKIT_ROOT_DIR}/lib"
                     ENV CUDA_LIB_PATH
                     DOC "nvTools library"
                     NO_DEFAULT_PATH
                     )

        mark_as_advanced(CUDA_nvToolsExt_LIBRARY)
    endif()
endif (ENABLE_CUDA)

# setup CUDA compile options
if (ENABLE_CUDA)
    # setup nvcc to build for all CUDA architectures. Allow user to modify the list if desired
    if (CUDA_VERSION VERSION_GREATER 5.99)
        set(CUDA_ARCH_LIST 20 30 35 50 CACHE STRING "List of target sm_ architectures to compile CUDA code for. Separate with semicolons.")
    else (CUDA_VERSION VERSION_GREATER 4.99)
        set(CUDA_ARCH_LIST 20 30 35 CACHE STRING "List of target sm_ architectures to compile CUDA code for. Separate with semicolons.")
    endif()

    foreach(_cuda_arch ${CUDA_ARCH_LIST})
        list(APPEND CUDA_NVCC_FLAGS "-gencode=arch=compute_${_cuda_arch},code=sm_${_cuda_arch}")
    endforeach (_cuda_arch)

    # need to know the minumum supported CUDA_ARCH
    set(_cuda_arch_list_sorted ${CUDA_ARCH_LIST})
    list(SORT _cuda_arch_list_sorted)
    list(GET _cuda_arch_list_sorted 0 _cuda_min_arch)
    add_definitions(-DCUDA_ARCH=${_cuda_min_arch})

    if (_cuda_min_arch LESS 20)
        message(SEND_ERROR "SM1x builds are not supported")
    endif ()

    # only generage ptx code for the maximum supported CUDA_ARCH (saves on file size)
    list(REVERSE _cuda_arch_list_sorted)
    list(GET _cuda_arch_list_sorted 0 _cuda_max_arch)
    list(APPEND CUDA_NVCC_FLAGS "-gencode=arch=compute_${_cuda_max_arch},code=compute_${_cuda_max_arch}")

# embed the CUDA libraries into the lib dir
if (ENABLE_EMBED_CUDA)
    # determine the directory of the found cuda libs
    get_filename_component(_cuda_libdir ${CUDA_CUDART_LIBRARY} PATH)
    FILE(GLOB _cuda_libs ${_cuda_libdir}/libcurand.* ${_cuda_libdir}/libcufft.* ${_cuda_libdir}/libcusolver.* ${_cuda_libdir}/libcusparse.*)
    install(PROGRAMS ${_cuda_libs} DESTINATION ${PYTHON_MODULE_BASE_DIR})
endif ()

    if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
        # clang does not seem to work with host flag passing
        set(CUDA_PROPAGATE_HOST_FLAGS OFF)
        list(APPEND CUDA_NVCC_FLAGS "-std=c++11")
    endif()

endif (ENABLE_CUDA)

# automatically handle setting ccbin to /usr when needed
if (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_VERSION VERSION_GREATER 2.8.7)
    # CMAKE_CXX_COMPILER_VERSION is only available on 2.8.8 and newer

    # need to set ccbin to  when gcc is unsupported
    # this assumes that the user is on a system where CUDA is supported and /usr/bin/gcc will work - if they aren't, then it is their problem

    if (CUDA_VERSION VERSION_EQUAL 4.1)
        if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.5.99)
            message(STATUS "CUDA 4.1 doesn't support gcc >= 4.6, falling back on /usr/bin/gcc")
            list(APPEND CUDA_NVCC_FLAGS "-ccbin;/usr/bin/gcc")
        endif()
    endif()

    if (CUDA_VERSION VERSION_EQUAL 4.2)
        if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.6.99)
            message(STATUS "CUDA 4.2 doesn't support gcc >= 4.7, falling back on /usr/bin/gcc")
            list(APPEND CUDA_NVCC_FLAGS "-ccbin;/usr/bin/gcc")
        endif()
    endif()

    if (CUDA_VERSION VERSION_EQUAL 5.0)
        if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.6.99)
            message(STATUS "CUDA 5.0 doesn't support gcc >= 4.7, falling back on /usr/bin/gcc")
            list(APPEND CUDA_NVCC_FLAGS "-ccbin;/usr/bin/gcc")
        endif()
    endif()
endif()

# set CUSOLVER_AVAILABLE depending on CUDA Toolkit version
if (ENABLE_CUDA)
    if(${CUDA_VERSION} VERSION_LESS 7.5)
        set(CUSOLVER_AVAILABLE FALSE CACHE BOOL "TRUE if cusolver library is available")
    else()
        if (NOT CUSOLVER_AVAILABLE)
            # message at first time
            message(STATUS "CUDA version >= 7.5, looking for cusolver library")
            if (NOT ${CUDA_cusolver_LIBRARY} STREQUAL "")
                set(CUSOLVER_AVAILABLE TRUE CACHE BOOL "TRUE if cusolver library is available")
                message(STATUS "cuSolver library found.")
            else()
                set(CUSOLVER_AVAILABLE FALSE CACHE BOOL "TRUE if cusolver library is available")
                message(STATUS "Could not find cusolver library, constraints will be slower, perhaps old CMake?")
            endif()
        endif()
    endif()
    mark_as_advanced(CUSOLVER_AVAILABLE)
endif()

repository: damenpurt/hoomd-blue

repo_name: damenpurt/hoomd-blue


text:
SUMMARY = "Virtual Console lock program"
DESCRIPTION = "Sometimes a malicious local user could cause more problems \
  than a sophisticated remote one. vlock is a program that locks one or more \
  sessions on the Linux console to prevent attackers from gaining physical \
  access to the machine. \
  "
SECTION = "utils"

LICENSE = "GPL-2.0-only"
LIC_FILES_CHKSUM = "file://COPYING;md5=a17cb0a873d252440acfdf9b3d0e7fbf"

SRC_URI = "${GENTOO_MIRROR}/${BP}.tar.gz \
       file://disable_vlockrc.patch \
       file://vlock_pam_tally2_reset.patch \
       file://vlock-no_tally.patch \
       file://vlock_pam \
       "

SRC_URI[md5sum] = "378175c7692a8f288e65fd4dbf8a38eb"
SRC_URI[sha256sum] = "85aa5aed1ae49351378a0bd527a013078f0f969372a63164b1944174ae1a5e39"

inherit autotools-brokensep update-alternatives

# authentification method: either pam or shadow
PACKAGECONFIG ?= "${@bb.utils.contains('DISTRO_FEATURES', 'pam', 'pam', 'shadow', d)}"
PACKAGECONFIG[pam] = "--enable-pam,,libpam,"
PACKAGECONFIG[shadow] = "--enable-shadow,,shadow,"

CFLAGS += "-Wall -W -pedantic -std=gnu99"

do_configure () {
    # The configure tries to use 'getent' to get the group
    # info from the host, which should be avoided.
    sed -i 's/\(ROOT_GROUP=\).*/\1"root"/' ${CONFIGURE_SCRIPT}

    ${CONFIGURE_SCRIPT} \
        VLOCK_GROUP=root \
        ROOT_GROUP=root \
        CC="${CC}" \
        CFLAGS="${CFLAGS}" \
        LDFLAGS="${LDFLAGS}" \
        --prefix=${prefix} \
        --libdir=${libdir} \
        --mandir=${mandir} \
        --with-modules="all.so new.so nosysrq.so ttyblank.so vesablank.so" \
        --disable-root-password --enable-debug --disable-fail-count \
        ${PACKAGECONFIG_CONFARGS}
}

do_install:append () {
    if [ ${@bb.utils.contains('DISTRO_FEATURES', 'pam', 'yes', '', d)} = yes ]; then
        install -d -m 0755 ${D}/${sysconfdir}/pam.d
        install -m 0644 ${WORKDIR}/vlock_pam ${D}${sysconfdir}/pam.d/vlock
    fi
}

ALTERNATIVE:${PN} = "vlock"
ALTERNATIVE_PRIORITY = "60"
ALTERNATIVE_LINK_NAME[vlock] = "${bindir}/vlock"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded