text:
// Code generated by smithy-go-codegen DO NOT EDIT.

package rekognition

import (
	"context"
	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
	"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
	"github.com/aws/aws-sdk-go-v2/service/rekognition/types"
	"github.com/aws/smithy-go/middleware"
	smithyhttp "github.com/aws/smithy-go/transport/http"
)

// Starts the asynchronous search for faces in a collection that match the faces of
// persons detected in a stored video. The video must be stored in an Amazon S3
// bucket. Use Video to specify the bucket name and the filename of the video.
// StartFaceSearch returns a job identifier (JobId) which you use to get the search
// results once the search has completed. When searching is finished, Amazon
// Rekognition Video publishes a completion status to the Amazon Simple
// Notification Service topic that you specify in NotificationChannel. To get the
// search results, first check that the status value published to the Amazon SNS
// topic is SUCCEEDED. If so, call GetFaceSearch and pass the job identifier
// (JobId) from the initial call to StartFaceSearch. For more information, see
// procedure-person-search-videos.
func (c *Client) StartFaceSearch(ctx context.Context, params *StartFaceSearchInput, optFns ...func(*Options)) (*StartFaceSearchOutput, error) {
	if params == nil {
		params = &StartFaceSearchInput{}
	}

	result, metadata, err := c.invokeOperation(ctx, "StartFaceSearch", params, optFns, addOperationStartFaceSearchMiddlewares)
	if err != nil {
		return nil, err
	}

	out := result.(*StartFaceSearchOutput)
	out.ResultMetadata = metadata
	return out, nil
}

type StartFaceSearchInput struct {

	// ID of the collection that contains the faces you want to search for.
	//
	// This member is required.
	CollectionId *string

	// The video you want to search. The video must be stored in an Amazon S3 bucket.
	//
	// This member is required.
	Video *types.Video

	// Idempotent token used to identify the start request. If you use the same token
	// with multiple StartFaceSearch requests, the same JobId is returned. Use
	// ClientRequestToken to prevent the same job from being accidently started more
	// than once.
	ClientRequestToken *string

	// The minimum confidence in the person match to return. For example, don't return
	// any matches where confidence in matches is less than 70%. The default value is
	// 80%.
	FaceMatchThreshold *float32

	// An identifier you specify that's returned in the completion notification that's
	// published to your Amazon Simple Notification Service topic. For example, you can
	// use JobTag to group related jobs and identify them in the completion
	// notification.
	JobTag *string

	// The ARN of the Amazon SNS topic to which you want Amazon Rekognition Video to
	// publish the completion status of the search.
	NotificationChannel *types.NotificationChannel
}

type StartFaceSearchOutput struct {

	// The identifier for the search job. Use JobId to identify the job in a subsequent
	// call to GetFaceSearch.
	JobId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

func addOperationStartFaceSearchMiddlewares(stack *middleware.Stack, options Options) (err error) {
	err = stack.Serialize.Add(&awsAwsjson11_serializeOpStartFaceSearch{}, middleware.After)
	if err != nil {
		return err
	}
	err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpStartFaceSearch{}, middleware.After)
	if err != nil {
		return err
	}
	if err = addSetLoggerMiddleware(stack, options); err != nil {
		return err
	}
	if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
		return err
	}
	if err = addResolveEndpointMiddleware(stack, options); err != nil {
		return err
	}
	if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
		return err
	}
	if err = addRetryMiddlewares(stack, options); err != nil {
		return err
	}
	if err = addHTTPSignerV4Middleware(stack, options); err != nil {
		return err
	}
	if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
		return err
	}
	if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
		return err
	}
	if err = addClientUserAgent(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = addOpStartFaceSearchValidationMiddleware(stack); err != nil {
		return err
	}
	if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartFaceSearch(options.Region), middleware.Before); err != nil {
		return err
	}
	if err = addRequestIDRetrieverMiddleware(stack); err != nil {
		return err
	}
	if err = addResponseErrorMiddleware(stack); err != nil {
		return err
	}
	if err = addRequestResponseLogging(stack, options); err != nil {
		return err
	}
	return nil
}

func newServiceMetadataMiddleware_opStartFaceSearch(region string) *awsmiddleware.RegisterServiceMetadata {
	return &awsmiddleware.RegisterServiceMetadata{
		Region:        region,
		ServiceID:     ServiceID,
		SigningName:   "rekognition",
		OperationName: "StartFaceSearch",
	}
}


text:
#ifndef CONFLUO_ATOMIC_MULTILOG_METADATA_H_
#define CONFLUO_ATOMIC_MULTILOG_METADATA_H_

#include <cstdint>
#include <string>
#include <fstream>

#include "archival/archival_mode.h"
#include "types/numeric.h"
#include "types/type_manager.h"
#include "io_utils.h"
#include "schema/schema.h"
#include "storage/storage.h"

using namespace utils;

namespace confluo {

/**
 * Different types of metadata
 */
enum metadata_type
    : uint32_t {
  /** Metadata for the schema */
      D_SCHEMA_METADATA = 0,
  /** Metadata for the index */
      D_INDEX_METADATA = 1,
  /** Metadata for filters */
      D_FILTER_METADATA = 2,
  /** Metadata for aggregates */
      D_AGGREGATE_METADATA = 3,
  /** Metadata for triggers */
      D_TRIGGER_METADATA = 4,
  /** Metadata for storage mode */
      D_STORAGE_MODE_METADATA = 5,
  /** Metadata for archival mode */
      D_ARCHIVAL_MODE_METADATA = 6
};

/**
 * Efficient lookup for metadata
 */
struct index_metadata {
 public:
  /**
   * Constructs an index for the specified field name
   *
   * @param field_name The field_name to create an index for
   * @param bucket_size The bucket_size for lookup
   */
  index_metadata(const std::string &field_name, double bucket_size);

  /**
   * Gets the field name
   *
   * @return The field name for the metadata
   */
  std::string field_name() const;

  /**
   * Gets the bucket size
   *
   * @return The bucket size used for lookup
   */
  double bucket_size() const;

 private:
  std::string field_name_;
  double bucket_size_;
};

/**
 * Metadata for the filter
 */
struct filter_metadata {
 public:
  /**
   * Constructs metadata for a filter
   *
   * @param filter_name The name of the filter
   * @param expr The filter expression
   */
  filter_metadata(const std::string &filter_name, const std::string &expr);

  /**
   * Gets the filter name
   *
   * @return The name of the filter
   */
  const std::string &filter_name() const;

  /**
   * Gets the filter expression
   *
   * @return The filter expression
   */
  const std::string &expr() const;

 private:
  std::string filter_name_;
  std::string expr_;
};

/**
 * Metadata for the aggregate
 */
struct aggregate_metadata {
 public:
  /**
   * Constructs metadata for an aggregate
   *
   * @param name The name of the aggregate
   * @param filter_name The name of the associated filter
   * @param expr The expression of the associated filter
   */
  aggregate_metadata(const std::string &name, const std::string &filter_name,
                     const std::string &expr);

  /**
   * Gets the name of the aggregate
   *
   * @return The string containing the name of the aggregate
   */
  const std::string &aggregate_name() const;

  /**
   * Gets the name of the filter
   *
   * @return The filter name
   */
  const std::string &filter_name() const;

  /**
   * Gets the aggregate expression
   *
   * @return A string containing the expression for the aggregate
   */
  const std::string &aggregate_expression() const;

 private:
  std::string name_;
  std::string filter_name_;
  std::string expr_;
};

/**
 * Metadata for triggers
 */
struct trigger_metadata {
 public:
  /**
   * Constructs metadata for the trigger
   *
   * @param name The name of the trigger
   * @param expr The epxression
   * @param periodicity_ms The periodicity of the trigger measured in
   * milliseconds
   */
  trigger_metadata(const std::string &name, const std::string &expr,
                   uint64_t periodicity_ms);

  /**
   * Gets the name of the trigger
   *
   * @return The trigger name
   */
  const std::string &trigger_name() const;

  /**
   * Gets the expression for the trigger
   *
   * @return The trigger expression
   */
  const std::string &trigger_expression() const;

  /**
   * Gets the periodicity of the trigger
   *
   * @return The trigger periodicity in milliseconds
   */
  uint64_t periodicity_ms() const;

 private:
  std::string name_;
  std::string expr_;
  uint64_t periodicity_ms_;
};

/**
 * Writer for metadata
 */
class metadata_writer {
 public:
  typedef bool metadata_writer_state;
  static const metadata_writer_state UNINIT = false;
  static const metadata_writer_state INIT = true;

  /**
   * Default constructor
   */
  metadata_writer();

  /**
   * Constructor that initializes metadata writer
   * @param path The path of where the metadata is
   * @param overwrite Whether or not to overwrite previous contents of file
   */
  explicit metadata_writer(const std::string &path, bool overwrite = true);

  /**
   * Initializes the schema metadata writer
   *
   * @param schema The schema
   */
  metadata_writer(const metadata_writer &other);

  /**
   * Destructor
   */
  ~metadata_writer();

  /**
   * Assignment operator
   *
   * @param other A metadata writer instance
   * @return Updated metadata writer instance
   */
  metadata_writer &operator=(const metadata_writer &other);

  /**
   * Write the storage mode
   *
   * @param mode Storage mode to write
   */
  void write_storage_mode(storage::storage_mode mode);

  /**
   * Write the archival mode
   *
   * @param mode Archival mode to write
   */
  void write_archival_mode(archival::archival_mode mode);

  /**
   * Write the schema
   *
   * @param schema The schema to write
   */
  void write_schema(const schema_t &schema);

  /**
   * Writes metadata about an index
   *
   * @param name The name of the index
   * @param bucket_size The bucket_size used for lookup
   */
  void write_index_metadata(const std::string &name, double bucket_size);

  /**
   * Writes the metadata for a specified filter
   *
   * @param name The name of the filter
   * @param expr The filter expression
   */
  void write_filter_metadata(const std::string &name, const std::string &expr);

  /**
   * Writes the metadata for aggregates
   *
   * @param name The name of the aggregate
   * @param filter_name The name of the filter
   * @param expr The filter expression
   */
  void write_aggregate_metadata(const std::string &name, const std::string &filter_name, const std::string &expr);

  /**
   * Writes metadata for triggers
   *
   * @param trigger_name The name of the trigger
   * @param trigger_expr The trigger expression
   * @param periodicity_ms The periodicity of the trigger measured in
   * milliseconds
   */
  void write_trigger_metadata(const std::string &trigger_name,
                              const std::string &trigger_expr,
                              uint64_t periodicity_ms);
 private:
  std::string filename_;
  std::ofstream out_;
  metadata_writer_state state_;
};

/**
 * Reader metadata
 */
class metadata_reader {
 public:
  /**
   * Constructs an object to read metadata
   *
   * @param path The path of the file to read the metadata from
   */
  explicit metadata_reader(const std::string &path);

  /**
   * Checks if the reader has another element to read
   *
   * @return True if the reader has another element, otherwise false.
   */
  bool has_next();

  /**
   * Reads the next metadata type
   *
   * @return The metadata type that was read
   */
  metadata_type next_type();

  /**
   * Reads the next schema
   *
   * @return The schema that was read
   */
  schema_t next_schema();

  /**
   * Reads the next metadata for an index
   *
   * @return The index metadata that was read
   */
  index_metadata next_index_metadata();

  /**
   * Reads the next metadata for a filter
   *
   * @return The filter metadata that was read
   */
  filter_metadata next_filter_metadata();

  /**
   * Reads the next metadata for an aggregate
   *
   * @return The aggregate metadata that was read
   */
  aggregate_metadata next_aggregate_metadata();

  /**
   * Reads the next metadata for a trigger
   *
   * @return The trigger metadata that was read
   */
  trigger_metadata next_trigger_metadata();

  /**
   * Reads the next storage mode
   *
   * @return The next storage mode
   */
  storage::storage_mode next_storage_mode();

  /**
   * Reads the next archival mode
   *
   * @return The next archival mode
   */
  archival::archival_mode next_archival_mode();

 private:
  std::string filename_;
  std::ifstream in_;
};

}

#endif /* CONFLUO_ATOMIC_MULTILOG_METADATA_H_ */

repository: ucbrise/confluo

license_type: permissive

repo_name: ucbrise/confluo

branch_name: refs/heads/single-machine

extension: h


text:
package models

import (
	"time"

	"github.com/jinzhu/gorm"
	"github.com/tosone/worklyzer/common/constants"
)

// Log the request info wakatime log
type Log struct {
	gorm.Model
	Url         string
	QueryString string
	Type        constants.RequestType
	Method      constants.RequestMethod
	Body        []byte
	Msg         string
	Status      constants.RequestStatus
	Start       time.Time
	End         time.Time
}

// Create create a record
func (log *Log) Create() error {
	return engine.Create(log).Error
}

license: MIT

repository: tosone/worklyzer

repo_name: tosone/worklyzer

branch_name: refs/heads/master

extension: go


text:
---
---

@inproceedings{elamin2023multilingual,
  title={Multilingual Automatic Speech Recognition for Kinyarwanda, Swahili, and Luganda: Advancing ASR in Select East African Languages},
  author={Chanie, Yonas and Elamin, Moayad and Ewuzie, Paul and Rutunda, Samuel},
  booktitle={4th Workshop on African Natural Language Processing},
  year={2023}
}

extension: bib


text:
package helix

// Pagination stores a cursor for the Twitch Helix API.
type Pagination struct {
	Cursor string `json:"cursor"`
}

repository: kekleovr/go-twitch

repo_name: kekleovr/go-twitch


text:
# generated from genmsg/cmake/pkg-msg-paths.cmake.installspace.in

_prepend_path("${a3_help_DIR}/.." "" a3_help_MSG_INCLUDE_DIRS UNIQUE)
set(a3_help_MSG_DEPENDENCIES sensor_msgs)

extension: cmake


text:
package test_env

import (
	"context"
	"fmt"
	"time"

	"github.com/google/uuid"
	"github.com/rs/zerolog/log"
	tc "github.com/testcontainers/testcontainers-go"
	tcwait "github.com/testcontainers/testcontainers-go/wait"
)

type PostgresDb struct {
	EnvComponent
	User     string
	Password string
	DbName   string
	Port     string
}

type PostgresDbOption = func(c *PostgresDb)

// Sets custom container name if name is not empty
func WithPostgresDbContainerName(name string) PostgresDbOption {
	return func(c *PostgresDb) {
		if name != "" {
			c.ContainerName = name
		}
	}
}

func NewPostgresDb(networks []string, opts ...PostgresDbOption) *PostgresDb {
	pg := &PostgresDb{
		EnvComponent: EnvComponent{
			ContainerName: fmt.Sprintf("%s-%s", "postgres-db", uuid.NewString()[0:8]),
			Networks:      networks,
		},
		User:     "postgres",
		Password: "mysecretpassword",
		DbName:   "testdb",
		Port:     "5432",
	}
	for _, opt := range opts {
		opt(pg)
	}
	return pg
}

func (pg *PostgresDb) StartContainer() error {
	req := pg.getContainerRequest()
	c, err := tc.GenericContainer(context.Background(), tc.GenericContainerRequest{
		ContainerRequest: *req,
		Started:          true,
		Reuse:            true,
	})
	if err != nil {
		return err
	}
	pg.Container = c

	log.Info().Str("containerName", pg.ContainerName).
		Msg("Started Postgres DB container")

	return nil
}

func (pg *PostgresDb) getContainerRequest() *tc.ContainerRequest {
	return &tc.ContainerRequest{
		Name:         pg.ContainerName,
		Image:        "postgres:15.3",
		ExposedPorts: []string{fmt.Sprintf("%s/tcp", pg.Port)},
		Env: map[string]string{
			"POSTGRES_USER":     pg.User,
			"POSTGRES_DB":       pg.DbName,
			"POSTGRES_PASSWORD": pg.Password,
		},
		Networks: pg.Networks,
		WaitingFor: tcwait.ForExec([]string{"psql", "-h", "localhost",
			"-U", pg.User, "-c", "select", "1", "-d", pg.DbName}).
			WithStartupTimeout(10 * time.Second),
	}
}

repository: smartcontractkit/chainlink

repo_name: smartcontractkit/chainlink

branch_name: refs/heads/develop

gha_license_id: MIT

gha_language: Go


text:
package simplefactorial

import (
	"fmt"
	"math/big"
	"strconv"
	"testing"
)

var one00, _ = new(big.Int).SetString("93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000", 10)
var benchmarks = []uint64{
	100,
	1000,
	10000,
	100000,
}

func BenchmarkFactorial(b *testing.B) {
	for _, benchmark := range benchmarks {
		b.Run(fmt.Sprintf("%d", benchmark), func(b *testing.B) {
			for j := 0; j < b.N; j++ {
				Factorial(benchmark)
			}
		})
	}
}

// func info(a *big.Int, n uint) {
// 	dtrunc := int64(float64(a.BitLen())*.30103) - 10
// 	var first, rest big.Int
// 	rest.Exp(first.SetInt64(10), rest.SetInt64(dtrunc), nil)
// 	first.Quo(a, &rest)
// 	fstr := first.String()
// 	fmt.Printf("%d! begins %s... and has %d digits.\n",
// 		n, fstr, int64(len(fstr))+dtrunc)
// }

func TestFactorial(t *testing.T) {
	tests := []struct {
		input    uint64
		expected *big.Int
	}{
		{0, big.NewInt(1)},
		{1, big.NewInt(1)},
		{2, big.NewInt(2)},
		{3, big.NewInt(6)},
		{4, big.NewInt(24)},
		{5, big.NewInt(120)},
		{100, one00},
	}
	for ii, tt := range tests {
		t.Run(strconv.Itoa(ii), func(t *testing.T) {
			if gotR := Factorial(tt.input); gotR.Cmp(tt.expected) != 0 {
				t.Errorf("Factorial() = %v, want %v", gotR, tt.expected)
			}
		})
	}
}

repository: PeterLuschny/Fast-Factorial-Functions

repo_name: PeterLuschny/Fast-Factorial-Functions

gha_language: C#


text:
//      © Christian Sommerfeldt Øien
//      All rights reserved
#ifndef BUILDERS_HPP
#define BUILDERS_HPP

#include "envelopes.hpp"
#include "filters.hpp"
#include <set>

struct sound : builder
{
    en_ptr e;
    double t;
    bu_ptr b;

    sound(bu_ptr && b, double t, en_ptr e);
    ug_ptr build();
};

struct wave : builder
{
    en_ptr freq;
    en_ptr e; // one period [0,1) of wave

    wave(en_ptr freq, en_ptr e);
    ug_ptr build();
};

struct cross : builder
{
    bu_ptr a;
    bu_ptr b;
    double t;
    en_ptr c;

    cross(bu_ptr && a, bu_ptr && b, double t, en_ptr c);
    ug_ptr build();
};

struct harmonics : builder
{
    en_ptr freq;
    en_ptr e;
    double m;
    double even;
    double a(double f, unsigned i);
    double p(double b);

    harmonics(en_ptr freq, double m, en_ptr e, double even);
    ug_ptr build();
};

struct chorus : builder
{
    en_ptr freq;
    en_ptr t;
    en_ptr w;
    unsigned n;

    chorus(en_ptr freq, en_ptr t, en_ptr w, unsigned n);
    ug_ptr build();
};

struct am : builder
{
    bu_ptr a;
    bu_ptr b;

    am(bu_ptr && a, bu_ptr && b);
    ug_ptr build();
};

struct fm : builder
{
    bu_ptr m;
    double t;
    en_ptr i;
    en_ptr carrier_freq;

    fm(bu_ptr && m, double t, en_ptr i, en_ptr carrier_freq);
    ug_ptr build();
};

struct karpluss_strong : builder
{
    en_ptr freq;
    double a;
    double b;

    karpluss_strong(en_ptr freq, double a, double b);
    ug_ptr build();
};

struct timed_filter : builder
{
    bu_ptr i;
    fl_ptr l;
    double t;

    timed_filter(bu_ptr i, fl_ptr l, double t);
    ug_ptr build();
};

struct score : builder
{
    struct event
    {
        bs_ptr b;
        double t;
        unsigned i;

        event(bs_ptr b, double t, unsigned i);
        bool operator<(event const & e) const;
    };
    unsigned i;
    std::set<event> v;
    void add(double t, bs_ptr b);

    score();
    ug_ptr build();
};

typedef std::unique_ptr<score> sc_ptr;

#endif

repository: biotty/rmg

repo_name: biotty/rmg

extension: hpp


text:
package deathnode

import (
	"fmt"
	"github.com/alanbover/deathnode/monitor"
	"strings"
)

func newRecommender(recommenderType string) (recommender, error) {
	switch recommenderType {
	case "firstAvailableAgent":
		return &firstAvailableAgent{}, nil
	case "smallestInstanceId":
		return &smallestInstanceID{}, nil
	default:
		return nil, fmt.Errorf("Recommender type %v not found", recommenderType)
	}
}

type recommender interface {
	find(mesosAgents []*monitor.InstanceMonitor) *monitor.InstanceMonitor
}

type firstAvailableAgent struct{}

func (c *firstAvailableAgent) find(mesosAgents []*monitor.InstanceMonitor) *monitor.InstanceMonitor {
	return mesosAgents[0]
}

type smallestInstanceID struct{}

func (c *smallestInstanceID) find(mesosAgents []*monitor.InstanceMonitor) *monitor.InstanceMonitor {
	mesosAgentSmallestInstanceID := mesosAgents[0]
	for _, mesosAgent := range mesosAgents {
		if strings.Compare(*mesosAgent.InstanceID(), *mesosAgentSmallestInstanceID.InstanceID()) < 0 {
			mesosAgentSmallestInstanceID = mesosAgent
		}
	}

	return mesosAgentSmallestInstanceID
}

repository: alanbover/deathnode

repo_name: alanbover/deathnode


text:
# Copyright (c) 2010-2013 LG Electronics, Inc.

SUMMARY = "WebAppMgr is responsible for running Enyo applications on webOS"
SECTION = "webos/base"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Apache-2.0;md5=89aea4e17d99a7cacdbeed46a0096b10"

DEPENDS = "cjson luna-service2 sqlite3 luna-sysmgr-common luna-sysmgr-ipc luna-sysmgr-ipc-messages qt4-webos librolegen nyx-lib openssl luna-webkit-api webkit-webos luna-prefs libpbnjson npapi-headers freetype serviceinstaller"

DEPENDS_append = " ${@base_conditional('WEBOS_TARGET_MACHINE_IMPL','device','qt-webos-plugin','',d)}"

# webappmgr's upstart conf expects to be able to LD_PRELOAD ptmalloc3
RDEPENDS_${PN} = "ptmalloc3"
# webappmgr's upstart conf expects to have ionice available. Under OE-core, this is supplied by util-linux.
RDEPENDS_${PN} += "util-linux"
#  webappmgr's upstart conf expects setcpushares-task to be available
VIRTUAL-RUNTIME_cpushareholder ?= "cpushareholder-stub"
RDEPENDS_${PN} += "${VIRTUAL-RUNTIME_cpushareholder}"

WEBOS_VERSION = "3.0.0-3_9305987f31cc2f84f99e2bd442c2bf2a330fb961"

RDEPENDS_${PN}_append = " ${@base_conditional('WEBOS_TARGET_MACHINE_IMPL','device','qt-webos-plugin','',d)}"

# Don't uncomment until all of the do_*() tasks have been moved out of the recipe
#inherit webos_component
inherit webos_public_repo
inherit webos_enhanced_submissions
inherit webos_qmake
inherit webos_system_bus
inherit webos_machine_dep

SRC_URI = "${OPENWEBOS_GIT_REPO_COMPLETE}"
S = "${WORKDIR}/git"

inherit webos-ports-submissions
SRCREV = "811afcf9ba31f7c058a49fa29ed3087c51ebc3a1"

EXTRA_OEMAKE += "MACHINE=${MACHINE}"

do_configure() {
    MACHINE=${MACHINE} ${QMAKE}
}

do_install() {
    oe_runmake install
    install -d ${D}${bindir}
    install -v -m 750 release-${MACHINE}/WebAppMgr ${D}${bindir}

    install -d ${D}${webos_upstartconfdir}
    install -v -m 644 WebAppMgr.upstart ${D}${webos_upstartconfdir}/WebAppMgr
}

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

# /usr/bin/WebAppMgr contains RPATH pointing to sysroot
INSANE_SKIP_${PN} = "rpaths"

repository: skrishnakar/meta-webos-ports

repo_name: skrishnakar/meta-webos-ports

extension: bb


text:
package job

/*
Copyright 2020 Crunchy Data Solutions, Inc.
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.
*/

import (
	apiv1 "k8s.io/api/batch/v1"
	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// isJobSuccessful returns true if the job provided completed successfully.  Otherwise
// it returns false.  Per the Kubernetes documentation, "the completion time is only set
// when the job finishes successfully".  Therefore, the presence of a completion time can
// be utilized to determine whether or not the job was successful.
func isJobSuccessful(job *apiv1.Job) bool {
	return job.Status.CompletionTime != nil
}

// isJobInForegroundDeletion determines if a job is currently being deleted using foreground
// cascading deletion, as indicated by the presence of value “foregroundDeletion” in the jobs
// metadata.finalizers.
func isJobInForegroundDeletion(job *apiv1.Job) bool {
	for _, finalizer := range job.Finalizers {
		if finalizer == meta_v1.FinalizerDeleteDependents {
			return true
		}
	}
	return false
}


text:
package main

// A Location is any place that can hold an Item
type Location struct {
	Name     string `json:"name"`
	Address  uint32 `json:"address"`
	Address2 uint32 `json:"address2"`
	Default  uint16 `json:"default"`
	Scene    byte   `json:"scene"`
	Type     string `json:"type"`
}

repository: L-P/OoT-DeRandomizer

repo_name: L-P/OoT-DeRandomizer


text:
require linux-omap3.inc

DESCRIPTION = "Linux kernel for TI33x EVM from PSP, based on am335x-kernel"

COMPATIBLE_MACHINE = "ti33x"

BRANCH = "v3.2-staging"

#DEFAULT_PREFERENCE = "-1"

SRCREV = "${AUTOREV}"
PV = "3.2"

# Append to the MACHINE_KERNEL_PR so that a new SRCREV will cause a rebuild
MACHINE_KERNEL_PR_append = "+gitr${SRCPV}"

KVER = ${PV}
PSPREL = "autorev"

# Override the SRC_URI from the linux-omap3.inc file
SRC_URI = "git://arago-project.org/git/projects/linux-am33x.git;protocol=git;branch=${BRANCH} \
           file://0001-omap_hsmmc-make-default-dto-value-14.patch \
           file://0001-musb-update-PIO-mode-help-information-in-Kconfig.patch \
           file://0001-am335x_evm_defconfig-turn-off-MUSB-DMA.patch \
           file://defconfig"


text:
package inmemory_test

import (
	"fmt"
	"io"
	"net/http"
	"testing"
	"time"

	"github.com/go-gnss/ntrip"
	"github.com/go-gnss/ntrip/internal/inmemory"
	"github.com/sirupsen/logrus"
)

type auth struct{}

func (_ *auth) Authorise(action inmemory.Action, mount string, username string, password string) (authorised bool, err error) {
	if username == "foo" {
		return false, fmt.Errorf("intentionally triggered auth error")
	}

	if username != "username" || password != "password" {
		return false, nil
	}

	return true, nil
}

// TODO: Actually write some tests for this, once I work out a direction for it
func _TestInMemoryService(t *testing.T) {
	caster := ntrip.NewCaster(":2101", inmemory.NewSourceService(&auth{}), logrus.StandardLogger())

	go func() {
		r, w := io.Pipe()
		for {
			req, _ := ntrip.NewServerRequest("http://localhost:2101/TEST00AUS0", r)
			req.SetBasicAuth("username", "password")
			resp, err := http.DefaultClient.Do(req)
			if err == nil && resp.StatusCode == 200 {
				break
			}
			fmt.Println(resp, err)
			time.Sleep(100 * time.Millisecond)
		}

		for {
			fmt.Fprintf(w, "%s\n", time.Now())
			time.Sleep(100 * time.Millisecond)
		}
	}()

	caster.ListenAndServe()
}

repository: go-gnss/ntrip

repo_name: go-gnss/ntrip


text:
include(tacklelib/ForwardVariables)
include(tacklelib/Handlers)

function(return_pre_handler)
  tkl_test_assert_true(1)

  return()

  tkl_test_assert_true(0 "1 unreachable code")
endfunction()

tkl_copy_vars(all_vars_list1)
tkl_enable_handlers(PRE_ONLY macro return)
tkl_copy_vars(all_vars_list2)

list(REMOVE_ITEM all_vars_list2 all_vars_list1)

set(vars_before ${all_vars_list1})
list(REMOVE_ITEM vars_before ${all_vars_list2})

set(vars_after ${all_vars_list2})
list(REMOVE_ITEM vars_after ${all_vars_list1})

tkl_test_assert_true("vars_before STREQUAL \"\"" "vars_before=${vars_before}")
tkl_test_assert_true("vars_after STREQUAL \"\"" "vars_after=${vars_after}")

unset(all_vars_list1)
unset(all_vars_list2)

tkl_copy_vars(all_vars_list1)
tkl_add_last_handler(PRE return return_pre_handler)
tkl_copy_vars(all_vars_list2)

list(REMOVE_ITEM all_vars_list2 all_vars_list1)

set(vars_before ${all_vars_list1})
list(REMOVE_ITEM vars_before ${all_vars_list2})

set(vars_after ${all_vars_list2})
list(REMOVE_ITEM vars_after ${all_vars_list1})

tkl_test_assert_true("vars_before STREQUAL \"\"" "vars_before=${vars_before}")
tkl_test_assert_true("vars_after STREQUAL \"\"" "vars_after=${vars_after}")

return()

tkl_test_assert_true(0 "2 unreachable code")


text:
SUMMARY = "A service type script to initialize the probes"
DESCRIPTION = "A service type script to initialize the probes"
LICENSE="MIT"
LIC_FILES_CHKSUM = "file://${COREBASE}/LICENSE;md5=4d92cd373abda3937c2bc47fbc49d690 \
                    file://${COREBASE}/meta/COPYING.MIT;md5=3da9cfbcb788c80a0384361b4de20420"

FILESEXTRAPATHS_prepend := "${THISDIR}:"

inherit systemd

SYSTEMD_PACKAGES = "${PN}"
SYSTEMD_SERVICE_${PN} = "acme-iio-init.service acme-iio-wakeup.service"

SRC_URI = "file://acme-iio-init \
           file://acme-iio-wakeup \
           file://acme-iio-init.service \
           file://acme-iio-wakeup.service \
	   file://acme-iio-modules.conf"

do_install_append() {
    install -d ${D}${sysconfdir}/init.d/
    install -d ${D}${systemd_unitdir}/system/
    install -d ${D}${sysconfdir}/modules-load.d/
    install -d ${D}${bindir}
    install -m 0755 ${WORKDIR}/acme-iio-init ${D}${bindir}
    install -m 0755 ${WORKDIR}/acme-iio-wakeup ${D}${bindir}
    ln -s ${bindir}/acme-iio-init ${D}${sysconfdir}/init.d/acme-iio-init
    ln -s ${bindir}/acme-iio-wakeup ${D}${sysconfdir}/init.d/acme-iio-wakeup
    install -m 0644 ${WORKDIR}/acme-iio-init.service ${D}${systemd_unitdir}/system
    install -m 0644 ${WORKDIR}/acme-iio-wakeup.service ${D}${systemd_unitdir}/system
    sed -i -e 's,@BINDIR@,${bindir},g' ${D}${systemd_unitdir}/system/acme-iio-init.service
    sed -i -e 's,@BINDIR@,${bindir},g' ${D}${systemd_unitdir}/system/acme-iio-wakeup.service
    install -m 0644 ${WORKDIR}/acme-iio-modules.conf ${D}${sysconfdir}/modules-load.d/
}

repository: baylibre-acme/meta-baylibre

repo_name: baylibre-acme/meta-baylibre

branch_name: refs/heads/krogoth

gha_language: BitBake


text:
# Copyright (C) 2017-2021 Advanced Micro Devices, Inc. All Rights Reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.

# Try to find ROCR (Radeon Open Compute Runtime)
#
# Once found, this will define:
#   - ROCR_FOUND     - ROCR status (found or not found)
#   - ROCR_INCLUDES  - Required ROCR include directories
#   - ROCR_LIBRARIES - Required ROCR libraries
find_path(FIND_ROCR_INCLUDES hsa.h HINTS /opt/rocm/include /opt/rocm/hsa/include PATH_SUFFIXES hsa)
find_library(FIND_ROCR_LIBRARIES hsa-runtime64 HINTS /opt/rocm/lib /opt/rocm/hsa/lib)

include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(ROCR DEFAULT_MSG
                                  FIND_ROCR_INCLUDES FIND_ROCR_LIBRARIES)
mark_as_advanced(FIND_ROCR_INCLUDES FIND_ROCR_LIBRARIES)

set(ROCR_INCLUDES ${FIND_ROCR_INCLUDES})
set(ROCR_LIBRARIES ${FIND_ROCR_LIBRARIES})

repository: SJTU-IPADS/reef-artifacts

repo_name: SJTU-IPADS/reef-artifacts


text:
SUMMARY = "A Qt netdisp image"
LICENSE = "MIT"

inherit core-image

QT_TOOLS = " \
    qtbase \
    qtbase-mkspecs \
    qtbase-plugins \
    qt5-env \
"

FONTS = " \
    fontconfig \
    fontconfig-utils \
    ttf-bitstream-vera \
"

QT_SERIALPORT = " \
    qtserialport-mkspecs \
"

TSLIB = " \
    tslib \
    tslib-conf \
    tslib-calibrate \
    tslib-tests \
"

IMAGE_INSTALL += " \
    ${FONTS} \
    ${QT_TOOLS} \
    ${QT_SERIALPORT} \
    ${TSLIB} \
    netdisp \
"

# Install QtWebKit even though we do not use it. This is because we also
# use this distro recipe for 3rd parties that use it for Qt development.
IMAGE_INSTALL += " qtwebkit"

# Since we want this for 3rd party development, include libs, etc
IMAGE_FEATURES += "dev-pkgs"

export IMAGE_BASENAME = "netdisp-image"

# We only want a tarball output as we are extracting to an SD card.
IMAGE_FSTYPES = "tar.bz2"

repository: pedwo/meta-netdisp

repo_name: pedwo/meta-netdisp


text:
package zeekio

import (
	"bytes"
	"errors"
	"net"

	"github.com/brimdata/zed"
	"github.com/brimdata/zed/pkg/byteconv"
	"github.com/brimdata/zed/pkg/nano"
	"github.com/brimdata/zed/zcode"
	"github.com/brimdata/zed/zio/tzngio"
)

type builder struct {
	zcode.Builder
	buf             []byte
	fields          [][]byte
	reorderedFields [][]byte
}

func (b *builder) build(typ *zed.TypeRecord, sourceFields []int, path []byte, data []byte) (*zed.Value, error) {
	b.Reset()
	b.Grow(len(data))
	columns := typ.Columns
	if path != nil {
		if columns[0].Name != "_path" {
			return nil, errors.New("no _path in column 0")
		}
		columns = columns[1:]
		b.AppendPrimitive(path)
	}
	b.fields = b.fields[:0]
	var start int

	const separator = '\t'

	for i, c := range data {
		if c == separator {
			b.fields = append(b.fields, data[start:i])
			start = i + 1
		}
	}
	b.fields = append(b.fields, data[start:])
	if actual, expected := len(b.fields), len(sourceFields); actual > expected {
		return nil, errors.New("too many values")
	} else if actual < expected {
		return nil, errors.New("too few values")
	}
	b.reorderedFields = b.reorderedFields[:0]
	for _, s := range sourceFields {
		b.reorderedFields = append(b.reorderedFields, b.fields[s])
	}
	leftoverFields, err := b.appendColumns(columns, b.reorderedFields)
	if err != nil {
		return nil, err
	}
	if len(leftoverFields) != 0 {
		return nil, errors.New("too many values")
	}
	return zed.NewValue(typ, b.Bytes()), nil
}

func (b *builder) appendColumns(columns []zed.Column, fields [][]byte) ([][]byte, error) {
	const setSeparator = ','
	const emptyContainer = "(empty)"
	for _, c := range columns {
		if len(fields) == 0 {
			return nil, errors.New("too few values")
		}
		switch typ := c.Type.(type) {
		case *zed.TypeArray, *zed.TypeSet:
			val := fields[0]
			fields = fields[1:]
			if string(val) == "-" {
				b.AppendContainer(nil)
				continue
			}
			b.BeginContainer()
			if bytes.Equal(val, []byte(emptyContainer)) {
				b.EndContainer()
				continue
			}
			inner := zed.InnerType(typ)
			var cstart int
			for i, ch := range val {
				if ch == setSeparator {
					if err := b.appendPrimitive(inner, val[cstart:i]); err != nil {
						return nil, err
					}
					cstart = i + 1
				}
			}
			if err := b.appendPrimitive(inner, val[cstart:]); err != nil {
				return nil, err
			}
			if _, ok := typ.(*zed.TypeSet); ok {
				b.TransformContainer(zed.NormalizeSet)
			}
			b.EndContainer()
		case *zed.TypeRecord:
			b.BeginContainer()
			var err error
			if fields, err = b.appendColumns(typ.Columns, fields); err != nil {
				return nil, err
			}
			b.EndContainer()
		default:
			if err := b.appendPrimitive(c.Type, fields[0]); err != nil {
				return nil, err
			}
			fields = fields[1:]
		}
	}
	return fields, nil
}

func (b *builder) appendPrimitive(typ zed.Type, val []byte) error {
	if string(val) == "-" {
		b.AppendPrimitive(nil)
		return nil
	}
	switch typ.ID() {
	case zed.IDInt64:
		v, err := byteconv.ParseInt64(val)
		if err != nil {
			return err
		}
		b.buf = zed.AppendInt(b.buf[:0], v)
	case zed.IDUint16:
		// Zeek's port type is aliased to uint16.
		v, err := byteconv.ParseUint16(val)
		if err != nil {
			return err
		}
		b.buf = zed.AppendUint(b.buf[:0], uint64(v))
	case zed.IDUint64:
		v, err := byteconv.ParseUint64(val)
		if err != nil {
			return err
		}
		b.buf = zed.AppendUint(b.buf[:0], v)
	case zed.IDDuration:
		v, err := nano.Parse(val) // zeek-style fractional ts
		if err != nil {
			return err
		}
		b.buf = zed.AppendDuration(b.buf[:0], nano.Duration(v))
	case zed.IDTime:
		v, err := nano.Parse(val)
		if err != nil {
			return err
		}
		b.buf = zed.AppendTime(b.buf[:0], v)
	case zed.IDFloat64:
		v, err := byteconv.ParseFloat64(val)
		if err != nil {
			return err
		}
		b.buf = zed.AppendFloat64(b.buf[:0], v)
	case zed.IDBool:
		v, err := byteconv.ParseBool(val)
		if err != nil {
			return err
		}
		b.buf = zed.AppendBool(b.buf[:0], v)
	case zed.IDString:
		// Zeek's enum type is aliased to string.
		zb, err := tzngio.ParseString(val)
		if err != nil {
			return err
		}
		b.AppendPrimitive(zb)
		return nil
	case zed.IDBstring:
		zb, err := tzngio.ParseBstring(val)
		if err != nil {
			return err
		}
		b.AppendPrimitive(zb)
		return nil
	case zed.IDIP:
		v, err := byteconv.ParseIP(val)
		if err != nil {
			return err
		}
		b.buf = zed.AppendIP(b.buf[:0], v)
	case zed.IDNet:
		_, v, err := net.ParseCIDR(string(val))
		if err != nil {
			return err
		}
		b.buf = zed.AppendNet(b.buf[:0], v)
	default:
		panic(typ)
	}
	b.AppendPrimitive(b.buf)
	return nil
}

repository: AnonymousCyberWarrior/zed

repo_name: AnonymousCyberWarrior/zed

branch_name: refs/heads/main


text:
LICENSE     = "GPL"
PR          = "r1"
DESCRIPTION = "GPE to-do list"
DEPENDS     = "libgpewidget-hildon libgpepimc-hildon libtododb sdk-default-icons libosso"
RDEPENDS_${PN}    = "sdk-default-icons"
SECTION = "gpe"
PRIORITY    = "optional"

inherit gpe autotools pkgconfig

EXTRA_OECONF = "--enable-hildon"

SRC_URI="${GPE_MIRROR}/gpe-todo-${PV}.tar.bz2"

S = "${WORKDIR}/gpe-todo-${PV}"

FILES_${PN} += "${datadir}/gpe-todo ${libdir}/dbus-1.0"

SRC_URI[md5sum] = "e8c08165d9723779473e3390a949afac"
SRC_URI[sha256sum] = "ec2ef95c967acce5834c8b4985c610014c16242d223d233947d67b4514ebe298"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
package k8s

import (
	"bytes"
	"context"
	"fmt"
	"testing"
	"text/template"
	"time"

	"github.com/dbunion/com/scheduler"
)

func TestCreateNamespace(t *testing.T) {
	if env == defaultEnv {
		return
	}
	client, err := newClient(&opt)
	if err != nil {
		t.Fatalf("%v", err)
	}

	if err := client.GetNamespaceOperator().Create(context.Background(), &scheduler.Namespace{
		Name:   fmt.Sprintf("%s-%v", defaultNamespace, time.Now().UnixNano()),
		Labels: map[string]string{"app": defaultLabelApp, "component": defaultLabelComponent},
	}, scheduler.Options{}); err != nil {
		t.Fatalf("create namespace failure, err:%v", err)
	}
	t.Logf("create namespace success")
}

func TestListNamespace(t *testing.T) {
	if env == defaultEnv {
		return
	}
	client, err := newClient(&opt)
	if err != nil {
		t.Fatalf("%v", err)
	}

	options := make(scheduler.Options)
	options[listOptionsKeyLimit] = 10
	options[listOptionsKeyLabelSelector] = fmt.Sprintf("app=%s", defaultLabelApp)

	list, err := client.GetNamespaceOperator().List(context.Background(), options)
	if err != nil {
		t.Fatalf("%v", err)
	}

	for i := 0; i < len(list); i++ {
		t.Logf("index:%v name:%v", i, list[i].Name)
	}
}

func TestUpdateNamespace(t *testing.T) {
	if env == defaultEnv {
		return
	}
	client, err := newClient(&opt)
	if err != nil {
		t.Fatalf("%v", err)
	}

	options := make(scheduler.Options)
	options[listOptionsKeyLabelSelector] = fmt.Sprintf("app=%s", defaultLabelApp)

	list, err := client.GetNamespaceOperator().List(context.Background(), options)
	if err != nil {
		t.Fatalf("%v", err)
	}

	// only update first one
	if len(list) > 0 {
		param := list[0]
		param.Labels["Update"] = time.Now().Format("20060102150405")
		if err := client.GetNamespaceOperator().Update(context.Background(), param); err != nil {
			t.Fatalf("update namespace err:%v", err)
		}
	}
}

func TestDeleteNamespace(t *testing.T) {
	if env == defaultEnv {
		return
	}
	client, err := newClient(&opt)
	if err != nil {
		t.Fatalf("%v", err)
	}

	options := make(scheduler.Options)
	options[listOptionsKeyLabelSelector] = fmt.Sprintf("app=%s", defaultLabelApp)

	list, err := client.GetNamespaceOperator().List(context.Background(), options)
	if err != nil {
		t.Fatalf("%v", err)
	}

	// only delete last one
	if len(list) > 0 {
		param := list[len(list)-1]
		if err := client.GetNamespaceOperator().Delete(context.Background(), param, scheduler.Options{}); err != nil {
			t.Fatalf("delete namespace err:%v", err)
		}
		t.Logf("success delete namespace %v", param.Name)
	}
}

func TestCreateNamespaceByYaml(t *testing.T) {
	if env == defaultEnv {
		return
	}
	client, err := newClient(&opt)
	if err != nil {
		t.Fatalf("%v", err)
	}

	name := fmt.Sprintf("%s-%v", defaultNamespace, time.Now().UnixNano())
	tpl, err := template.New("create_namespace_yaml").Parse(namespaceYamlTpl)
	if err != nil {
		t.Fatalf("parse yalm template error:%v", err)
	}

	var buffer bytes.Buffer
	m := map[string]interface{}{"Name": name, "LabelApp": defaultLabelApp, "LabelComponent": defaultLabelComponent}
	if err := tpl.Execute(&buffer, m); err != nil {
		t.Fatalf("execute tmplate error:%v", err)
	}

	param := &scheduler.Config{
		Name:      name,
		Namespace: defaultNamespace,
		YAML:      buffer.Bytes(),
	}
	if err := client.GetConfigOperator().CreateWithYaml(context.Background(), param, scheduler.Options{}); err != nil {
		t.Fatalf("CreateWithYaml error:%v", err)
	}

	cfg, err := client.GetConfigOperator().Get(context.Background(), defaultNamespace, param)
	if err != nil {
		t.Fatalf("get config error:%v", err)
	}

	t.Logf("config content:%+v", cfg)

	if err := client.GetConfigOperator().Delete(context.Background(), param, scheduler.Options{}); err != nil {
		t.Fatalf("delete config err:%v", err)
	}
}

var namespaceYamlTpl = `
apiVersion: v1
kind: Namespace
metadata:
  labels:
    app: {{ .LabelApp }}
    component: {{ .LabelComponent }}
  name: {{ .Name }}
`

repository: dbunion/com

repo_name: dbunion/com


text:
@article{stocker15esd,
 author = {Stocker, B. D. and Joos, F.},
 bdsk-url-1 = {http://www.earth-syst-dynam.net/6/731/2015/},
 bdsk-url-2 = {http://dx.doi.org/10.5194/esd-6-731-2015},
 doi = {10.5194/esd-6-731-2015},
 journal = {Earth System Dynamics},
 number = {2},
 pages = {731--744},
 title = {Quantifying differences in land use emission estimates implied by definition discrepancies},
 url = {http://www.earth-syst-dynam.net/6/731/2015/},
 volume = {6},
 year = {2015}
}


text:
// CADMesh //
#include "Reader.hh"

namespace CADMesh
{

namespace File
{

Reader::Reader(G4String reader_name) : name_(reader_name)
{
}

Reader::~Reader()
{
}

G4String Reader::GetName()
{
    return name_;
}

std::shared_ptr<Mesh> Reader::GetMesh()
{
    if (meshes_.size() > 0)
    {
        return meshes_[0];
    }

    return nullptr;
}

std::shared_ptr<Mesh> Reader::GetMesh(size_t index)
{
    if (index < meshes_.size())
    {
        return meshes_[index];
    }

    return nullptr;
}

std::shared_ptr<Mesh> Reader::GetMesh(G4String /*name*/)
{
    //TODO: Return mesh based on its name.

    return nullptr;
}

Meshes Reader::GetMeshes()
{
    return meshes_;
}

size_t Reader::AddMesh(std::shared_ptr<Mesh> mesh)
{
    meshes_.push_back(mesh);

    return meshes_.size();
}

void Reader::SetMeshes(Meshes meshes)
{
    meshes_ = meshes;
}

}

}

repository: dksim/CADMesh

repo_name: dksim/CADMesh

extension: cc


text:
SECTION = "base"
LICENSE = "GPL"
DESCRIPTION = "A small, C implementation of hotplug."

SRC_URI = "${KERNELORG_MIRROR}/pub/linux/utils/kernel/hotplug/diethotplug-${PV}.tar.gz \
           file://modules.usbmap \
           file://modules.pcimap \
           file://modules.ieee1394map"

export KLIBC = ""

do_compile () {
	perl convert_usb.pl ${WORKDIR}/modules.usbmap > usb_modules.h
	perl convert_pci.pl ${WORKDIR}/modules.pcimap > pci_modules.h
	perl convert_ieee1394.pl ${WORKDIR}/modules.ieee1394map > ieee1394_modules.h
	oe_runmake
}

do_install () {
	install -d ${D}${sbindir}
	install -m 0755 hotplug ${D}${sbindir}/
}

SRC_URI[md5sum] = "1fd89c902006271f00a774cc3183c15d"
SRC_URI[sha256sum] = "dcc1809e8477b95317a7ff503cdd8b6d3f85b8d83a3245252ff47cf631523620"


text:
@inproceedings{10.1145/3255780,
author = {Hull, Richard},
title = {Session Details: Keynote Address},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3255780},
doi = {10.1145/3255780},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
numpages = {1},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594561,
author = {Libkin, Leonid},
title = {Incomplete Data: What Went Wrong, and How to Fix It},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594561},
doi = {10.1145/2594538.2594561},
abstract = {Incomplete data is ubiquitous: the more data we accumulate and the more widespread tools for integrating and exchanging data become, the more instances of incompleteness we have. And yet the subject is poorly handled by both practice and theory. Many queries for which students get full marks in their undergraduate courses will not work correctly in the presence of incomplete data, but these ways of evaluating queries are cast in stone -- SQL standard. We have many theoretical results on handling incomplete data but they are, by and large, about showing high complexity bounds, and thus are often dismissed by practitioners. Even worse, we have a basic theoretical notion of what it means to answer queries over incomplete data, and yet this is not at all what practical systems do.Is there a way out of this predicament? Can we have a theory of incompleteness that will appeal to theoreticians and practitioners alike, by explaining incompleteness and being at the same time implementable and useful for applications? After giving a critique of both the practice and the theory of handling incompleteness in databases, the paper outlines a possible way out of this crisis. The key idea is to combine three hitherto used approaches to incompleteness: one based on certain answers and representation systems, one based on viewing incomplete databases as logical theories, and one based on orderings expressing relative value of information.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {1–13},
numpages = {13},
keywords = {query evaluation, incomplete information},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/3255781,
author = {Abiteboul, Serge},
title = {Session Details: Web Queries and Big Data},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3255781},
doi = {10.1145/3255781},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
numpages = {1},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594555,
author = {Arenas, Marcelo and Gottlob, Georg and Pieris, Andreas},
title = {Expressive Languages for Querying the Semantic Web},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594555},
doi = {10.1145/2594538.2594555},
abstract = {The problem of querying RDF data is a central issue for the development of the Semantic Web. The query language SPARQL has become the standard language for querying RDF, since its standardization in 2008. However, the 2008 version of this language missed some important functionalities: reasoning capabilities to deal with RDFS and OWL vocabularies, navigational capabilities to exploit the graph structure of RDF data, and a general form of recursion much needed to express some natural queries. To overcome these limitations, a new version of SPARQL, called SPARQL 1.1, was recently released, which includes entailment regimes for RDFS and OWL vocabularies, and a mechanism to express navigation patterns through regular expressions. Unfortunately, there are still some useful navigation patterns that cannot be expressed in SPARQL 1.1, and the language lacks of a general mechanism to express recursive queries.To the best of our knowledge, there is no RDF query language that combines the above functionalities, and which can also be evaluated efficiently. It is the aim of this work to fill this gap. Towards this direction, we focus on the OWL 2 QL profile of OWL 2, and we show that every SPARQL query enriched with the above features can be naturally translated into a query expressed in a language which is based on an extension of Datalog which allows for value invention and stratified negation. However, the query evaluation problem for this language is highly intractable, which is not surprising since it is expressive enough to encode some inherently hard queries. We identify a natural fragment of it, and we show it to be tractable and powerful enough to define SPARQL queries enhanced with the desired functionalities.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {14–26},
numpages = {13},
keywords = {sparql, rdf, query answering, datalog-based languages, semantic web},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594556,
author = {Gottlob, Georg and Rudolph, Sebastian and Simkus, Mantas},
title = {Expressiveness of Guarded Existential Rule Languages},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594556},
doi = {10.1145/2594538.2594556},
abstract = {The so-called existential rules have recently gained attention, mainly due to their adequate expressiveness for ontological query answering. Several decidable fragments of such rules have been introduced, employing restriction such as various forms of guardedness to ensure decidability. Some of the more well-known languages in this arena are (weakly) guarded and (weakly) frontier-guarded fragments of existential rules. In this paper, we explore their relative and absolute expressiveness. In particular, we provide a new proof that queries expressed via frontier-guarded and guarded rules can be translated into plain Datalog queries. Since the converse translations are impossible, we develop generalizations of frontier-guarded and guarded rules to nearly frontier-guarded and nearly guarded rules, respectively, which have exactly the expressive power of Datalog. We further show that weakly frontier-guarded rules can be translated into weakly guarded rules, and thus, weakly frontier-guarded and weakly guarded rules have exactly the same expressive power. Such rules cannot be translated into Datalog since their query answering problem is ExpTime-complete in data complexity. We strengthen this result by showing that on ordered databases and with input negation available, weakly guarded rules capture all queries decidable in exponential time. We then show that weakly guarded rules extended with stratified negation are expressive enough to capture all database queries decidable in exponential time, without any assumptions about input databases. Finally, we note that the translations of this paper are, in general, exponential in size, but lead to worst-case optimal algorithms for query answering with considered languages.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {27–38},
numpages = {12},
keywords = {descriptive complexity, existential rules, expressiveness},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594542,
author = {Pichler, Reinhard and Skritek, Sebastian},
title = {Containment and Equivalence of Well-Designed SPARQL},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594542},
doi = {10.1145/2594538.2594542},
abstract = {Query containment and query equivalence constitute important computational problems in the context of static query analysis and optimization. While these problems have been intensively studied for fragments of relational calculus, almost no works exist for the semantic web query language SPARQL. In this paper, we carry out a comprehensive complexity analysis of containment and equivalence for several fragments of SPARQL: we start with the fundamental fragment of well-designed SPARQL restricted to the AND and OPTIONAL operator. We then study basic extensions in the form of the UNION operator and/or projection. The results obtained range from NP-completeness to undecidability.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {39–50},
numpages = {12},
keywords = {RDF, query containment, semantic web, SPARQL},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594551,
author = {Fan, Wenfei and Geerts, Floris and Libkin, Leonid},
title = {On Scale Independence for Querying Big Data},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594551},
doi = {10.1145/2594538.2594551},
abstract = {To make query answering feasible in big datasets, practitioners have been looking into the notion of scale independence of queries. Intuitively, such queries require only a relatively small subset of the data, whose size is determined by the query and access methods rather than the size of the dataset itself. This paper aims to formalize this notion and study its properties. We start by defining what it means to be scale-independent, and provide matching upper and lower bounds for checking scale independence, for queries in various languages, and for combined and data complexity. Since the complexity turns out to be rather high, and since scale-independent queries cannot be captured syntactically, we develop sufficient conditions for scale independence. We formulate them based on access schemas, which combine indexing and constraints together with bounds on the sizes of retrieved data sets. We then study two variations of scale-independent query answering, inspired by existing practical systems. One concerns incremental query answering: we check when query answers can be maintained in response to updates scale-independently. The other explores scale-independent query rewriting using views.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {51–62},
numpages = {12},
keywords = {scale independence, query answering, big data},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/3255782,
author = {Hull, Richard and Fan, Wenfei and Geerts, Floris and Suciu, Dan},
title = {Session Details: Awards Session},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3255782},
doi = {10.1145/3255782},
abstract = {The ACM PODS Alberto O. Mendelzon: test-of-time award 2014},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
numpages = {1},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594541,
author = {Ameloot, Tom J. and Ketsman, Bas and Neven, Frank and Zinn, Daniel},
title = {Weaker Forms of Monotonicity for Declarative Networking: A More Fine-Grained Answer to the Calm-Conjecture},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594541},
doi = {10.1145/2594538.2594541},
abstract = {The CALM-conjecture, first stated by Hellerstein [23] and proved in its revised form by Ameloot et al. [13] within the framework of relational transducer networks, asserts that a query has a coordination-free execution strategy if and only if the query is monotone. Zinn et al. [32] extended the framework of relational transducer networks to allow for specific data distribution strategies and showed that the nonmonotone win-move query is coordination-free for domain-guided data distributions. In this paper, we complete the story by equating increasingly larger classes of coordination-free computations with increasingly weaker forms of monotonicity and make Datalog variants explicit that capture each of these classes. One such fragment is based on stratified Datalog where rules are required to be connected with the exception of the last stratum. In addition, we characterize coordination-freeness as those computations that do not require knowledge about all other nodes in the network, and therefore, can not globally coordinate. The results in this paper can be interpreted as a more fine-grained answer to the CALM-conjecture.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {64–75},
numpages = {12},
keywords = {cloud programming, expressive power, distributed database, relational transducer, coordination, consistency},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/3255783,
author = {van den Bussche, Jan},
title = {Session Details: Tutorial 1},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3255783},
doi = {10.1145/3255783},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
numpages = {1},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594562,
author = {Haas, Peter J.},
title = {Model-Data Ecosystems: Challenges, Tools, and Trends},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594562},
doi = {10.1145/2594538.2594562},
abstract = {In the past few years, research around (big) data management has begun to intertwine with research around predictive modeling and simulation in novel and interesting ways. Driving this trend is an increasing recognition that information contained in real-world data must be combined with information from domain experts, as embodied in simulation models, in order to enable robust decision making under uncertainty. Simulation models of large, complex systems (traffic, biology, population well-being) consume and produce massive amounts of data and compound the challenges of traditional information management. We survey some challenges, mathematical tools, and future directions in the emerging research area of model-data ecosystems. Topics include (i) methods for enabling data-intensive simulation, (ii) simulation and information integration, and (iii) simulation metamodeling for guiding the generation of simulated data and the collection of real-world data.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {76–87},
numpages = {12},
keywords = {decision support, simulation, data assimilation, information integration},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/3255784,
author = {Tao, Yufei},
title = {Session Details: Sketching and Sampling},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3255784},
doi = {10.1145/3255784},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
numpages = {1},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594546,
author = {Cohen, Edith},
title = {All-Distances Sketches, Revisited: HIP Estimators for Massive Graphs Analysis},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594546},
doi = {10.1145/2594538.2594546},
abstract = {Graph datasets with billions of edges, such as social and Web graphs, are prevalent. To be feasible, computation on such large graphs should scale linearly with graph size. All-distances sketches (ADSs) are emerging as a powerful tool for scalable computation of some basic properties of individual nodes or the whole graph.ADSs were first proposed two decades ago (Cohen 1994) and more recent algorithms include ANF (Palmer, Gibbons, and Faloutsos 2002) and hyperANF (Boldi, Rosa, and Vigna 2011). A sketch of logarithmic size is computed for each node in the graph and the computation in total requires only a near linear number of edge relaxations. From the ADS of a node, we can estimate neighborhood cardinalities (the number of nodes within some query distance) and closeness centrality. More generally we can estimate the distance distribution, effective diameter, similarities, and other parameters of the full graph. We make several contributions which facilitate a more effective use of ADSs for scalable analysis of massive graphs.We provide, for the first time, a unified exposition of ADS algorithms and applications. We present the Historic Inverse Probability (HIP) estimators which are applied to the ADS of a node to estimate a large natural class of queries including neighborhood cardinalities and closeness centralities. We show that our HIP estimators have at most half the variance of previous neighborhood cardinality estimators and that this is essentially optimal. Moreover, HIP obtains a polynomial improvement over state of the art for more general domain queries and the estimators are simple, flexible, unbiased, and elegant.The ADS generalizes Min-Hash sketches, used for approximating cardinality (distinct count) on data streams. We obtain lower bounds on Min-Hash cardinality estimation using classic estimation theory. We illustrate the power of HIP, both in terms of ease of application and estimation quality, by comparing it to the HyperLogLog algorithm (Flajolet et al. 2007), demonstrating a significant improvement over this state-of-the-art practical algorithm.We also study the quality of ADS estimation of distance ranges, generalizing the near-linear time factor-2 approximation of the diameter.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {88–99},
numpages = {12},
keywords = {approximate distinct counters, closeness centrality, estimation, min-hash sketch, all-distances sketch},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594560,
author = {Indyk, Piotr and Mahabadi, Sepideh and Mahdian, Mohammad and Mirrokni, Vahab S.},
title = {Composable Core-Sets for Diversity and Coverage Maximization},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594560},
doi = {10.1145/2594538.2594560},
abstract = {In this paper we consider efficient construction of "composable core-sets" for basic diversity and coverage maximization problems. A core-set for a point-set in a metric space is a subset of the point-set with the property that an approximate solution to the whole point-set can be obtained given the core-set alone. A composable core-set has the property that for a collection of sets, the approximate solution to the union of the sets in the collection can be obtained given the union of the composable core-sets for the point sets in the collection. Using composable core-sets one can obtain efficient solutions to a wide variety of massive data processing applications, including nearest neighbor search, streaming algorithms and map-reduce computation.Our main results are algorithms for constructing composable core-sets for several notions of "diversity objective functions", a topic that attracted a significant amount of research over the last few years. The composable core-sets we construct are small and accurate: their approximation factor almost matches that of the best "off-line" algorithms for the relevant optimization problems (up to a constant factor). Moreover, we also show applications of our results to diverse nearest neighbor search, streaming algorithms and map-reduce computation. Finally, we show that for an alternative notion of diversity maximization based on the maximum coverage problem small composable core-sets do not exist.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {100–108},
numpages = {9},
keywords = {streaming, nearest neighbor, map-reduce, core-set, diversity},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594554,
author = {Pagh, Rasmus and St\"{o}ckel, Morten and Woodruff, David P.},
title = {Is Min-Wise Hashing Optimal for Summarizing Set Intersection?},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594554},
doi = {10.1145/2594538.2594554},
abstract = {Min-wise hashing is an important method for estimating the size of the intersection of sets, based on a succinct summary (a "min-hash") of each set. One application is estimation of the number of data points that satisfy the conjunction of m >= 2 simple predicates, where a min-hash is available for the set of points satisfying each predicate. This has application in query optimization and for approximate computation of COUNT aggregates.In this paper we address the question: How many bits is it necessary to allocate to each summary in order to get an estimate with (1 +/- epsilon)-relative error? The state-of-the-art technique for minimizing the encoding size, for any desired estimation error, is b-bit min-wise hashing due to Li and K\"{o}nig (Communications of the ACM, 2011). We give new lower and upper bounds:Using information complexity arguments, we show that b-bit min-wise hashing is em space optimal for m=2 predicates in the sense that the estimator's variance is within a constant factor of the smallest possible among all summaries with the given space usage. But for conjunctions of m>2 predicates we show that the performance of b-bit min-wise hashing (and more generally any method based on "k-permutation" min-hash) deteriorates as m grows.We describe a new summary that nearly matches our lower bound for m >= 2. It asymptotically outperform all k-permutation schemes (by around a factor Omega(m/log m)), as well as methods based on subsampling (by a factor Omega(log n_max), where n_max is the maximum set size).},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {109–120},
numpages = {12},
keywords = {min-wise hashing, lower bound, communication complexity, set intersection},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/3255785,
author = {Suciu, Dan},
title = {Session Details: Enumeration, Counting, and Probabilities},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3255785},
doi = {10.1145/3255785},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
numpages = {1},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594539,
author = {Durand, Arnaud and Schweikardt, Nicole and Segoufin, Luc},
title = {Enumerating Answers to First-Order Queries over Databases of Low Degree},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594539},
doi = {10.1145/2594538.2594539},
abstract = {A class of relational databases has low degree if for all δ, all but finitely many databases in the class have degree at most nδ, where n is the size of the database. Typical examples are databases of bounded degree or of degree bounded by log n. It is known that over a class of databases having low degree, first-order boolean queries can be checked in pseudo-linear time, i.e. in time bounded by n1+ε, for all ε. We generalise this result by considering query evaluation.We show that counting the number of answers to a query can be done in pseudo-linear time and that enumerating the answers to a query can be done with constant delay after a pseudo-linear time preprocessing.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {121–131},
numpages = {11},
keywords = {algorithm, enumeration, low degree, query evaluation},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594559,
author = {Greco, Gianluigi and Scarcello, Francesco},
title = {Counting Solutions to Conjunctive Queries: Structural and Hybrid Tractability},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594559},
doi = {10.1145/2594538.2594559},
abstract = {Counting the number of answers to conjunctive queries is an intractable problem, formally #P-hard, even over classes of acyclic queries. However, Durand and Mengel have recently introduced the notion of quantified star size that, combined with hypertree decompositions, identifies islands of tractability for the problem. They also wonder whether such a notion precisely characterizes those classes for which the counting problem is tractable. We show that this is the case only for bounded-arity simple queries, where relation symbols cannot be shared by different query atoms. Indeed, we give a negative answer to the question in the general case, by exhibiting a more powerful structural method based on the novel concept of #-generalized hypertree decomposition. On classes of queries with bounded #-generalized hypertree width, counting answers is shown to be feasible in polynomial time, after a fixed-parameter polynomial-time preprocessing that only depends on the query structure. A weaker variant (but still more general than the technique based on the quantified starsize) is also proposed, for which tractability is established without any exponential dependency on the query size. Based on #-generalized hypertree decompositions, a hybrid decomposition method is eventually conceived, where structural properties of the query are exploited in combination with properties of the given database, such as keys or other (weaker) dependencies among attributes that limit the allowed combinations of values. Intuitively, such features may induce different structural properties that are not identified by the worst-possible database perspective of purely structural methods.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {132–143},
numpages = {12},
keywords = {counting problems, structural decomposition methods},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594549,
author = {Fink, Robert and Olteanu, Dan},
title = {A Dichotomy for Non-Repeating Queries with Negation in Probabilistic Databases},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594549},
doi = {10.1145/2594538.2594549},
abstract = {This paper shows that any non-repeating conjunctive relational query with negation has either polynomial time or #P-hard data complexity on tuple-independent probabilistic databases. This result extends a dichotomy by Dalvi and Suciu for non-repeating conjunctive queries to queries with negation. The tractable queries with negation are precisely the hierarchical ones and can be recognized efficiently.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {144–155},
numpages = {12},
keywords = {probabilistic databases, query evaluation, complexity dischotomy, negation},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/3255786,
author = {Barcel\'{o}, Pablo},
title = {Session Details: Tutorial 2},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3255786},
doi = {10.1145/3255786},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
numpages = {1},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594563,
author = {Kimelfeld, Benny},
title = {Database Principles in Information Extraction},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594563},
doi = {10.1145/2594538.2594563},
abstract = {Information Extraction commonly refers to the task of populating a relational schema, having predefined underlying semantics, from textual content. This task is pervasive in contemporary computational challenges associated with Big Data. This tutorial gives an overview of the algorithmic concepts and techniques used for performing Information Extraction tasks, and describes some of the declarative frameworks that provide abstractions and infrastructure for programming extractors. In addition, the tutorial highlights opportunities for research impact through principles of data management, illustrates these opportunities through recent work, and proposes directions for future research.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {156–163},
numpages = {8},
keywords = {database repairs, document spanners, database inconsistency, regular expressions, prioritized repairs, information extraction, finite-state transducers},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594540,
author = {Fagin, Ronald and Kimelfeld, Benny and Reiss, Frederick and Vansummeren, Stijn},
title = {Cleaning Inconsistencies in Information Extraction via Prioritized Repairs},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594540},
doi = {10.1145/2594538.2594540},
abstract = {The population of a predefined relational schema from textual content, commonly known as Information Extraction (IE), is a pervasive task in contemporary computational challenges associated with Big Data. Since the textual content varies widely in nature and structure (from machine logs to informal natural language), it is notoriously difficult to write IE programs that extract the sought information without any inconsistencies (e.g., a substring should not be annotated as both an address and a person name). Dealing with inconsistencies is hence of crucial importance in IE systems. Industrial-strength IE systems like GATE and IBM SystemT therefore provide a built-in collection of cleaning operations to remove inconsistencies from extracted relations. These operations, however, are collected in an ad-hoc fashion through use cases. Ideally, we would like to allow IE developers to declare their own policies. But existing cleaning operations are defined in an algorithmic way and, hence, it is not clear how to extend the built-in operations without requiring low-level coding of internal or external functions. We embark on the establishment of a framework for declarative cleaning of inconsistencies in IE, though principles of database theory. Specifically, building upon the formalism of document spanners for IE, we adopt the concept of prioritized repairs, which has been recently proposed as an extension of the traditional database repairs to incorporate priorities among conflicting facts. We show that our framework captures the popular cleaning policies, as well as the POSIX semantics for extraction through regular expressions. We explore the problem of determining whether a cleaning declaration is unambiguous (i.e., always results in a single repair), and whether it increases the expressive power of the extraction language. We give both positive and negative results, some of which are general, and some of which apply to policies used in practice.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {164–175},
numpages = {12},
keywords = {regular expressions, information extraction, document spanners, extraction inconsistency, prioritized repairs, database repairs},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/3255787,
author = {Schweikardt, Nicole},
title = {Session Details: Classics},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3255787},
doi = {10.1145/3255787},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
numpages = {1},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594544,
author = {Kolaitis, Phokion G. and Pichler, Reinhard and Sallinger, Emanuel and Savenkov, Vadim},
title = {Nested Dependencies: Structure and Reasoning},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594544},
doi = {10.1145/2594538.2594544},
abstract = {During the past decade, schema mappings have been extensively used in formalizing and studying such critical data interoperability tasks as data exchange and data integration. Much of the work has focused on GLAV mappings, i.e., schema mappings specified by source-to-target tuple-generating dependencies (s-t tgds), and on schema mappings specified by second-order tgds (SO tgds), which constitute the closure of GLAV mappings under composition. In addition, nested GLAV mappings have also been considered, i.e., schema mappings specified by nested tgds, which have expressive power intermediate between s-t tgds and SO tgds. Even though nested GLAV mappings have been used in data exchange systems, such as IBM's Clio, no systematic investigation of this class of schema mappings has been carried out so far. In this paper, we embark on such an investigation by focusing on the basic reasoning tasks, algorithmic problems, and structural properties of nested GLAV mappings. One of our main results is the decidability of the implication problem for nested tgds. We also analyze the structure of the core of universal solutions with respect to nested GLAV mappings and develop useful tools for telling apart SO tgds from nested tgds. By discovering deeper structural properties of nested GLAV mappings, we show that also the following problem is decidable: given a nested GLAV mapping, is it logically equivalent to a GLAV mapping?},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {176–187},
numpages = {12},
keywords = {nested dependencies, second-order dependencies, schema mappings, data integration, data exchange},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594553,
author = {Barcel\'{o}, Pablo and Romero, Miguel and Vardi, Moshe Y.},
title = {Does Query Evaluation Tractability Help Query Containment?},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594553},
doi = {10.1145/2594538.2594553},
abstract = {While checking containment of Datalog programs is undecidable, checking whether a Datalog program is contained in a union of conjunctive queries (UCQ), in the context of relational databases, or a union of conjunctive 2-way regular path queries (UC2RPQ), in the context of graph databases, is decidable. The complexity of these problems is, however, prohibitive: 2exptime-complete. We investigate to which extent restrictions on UCQs and UC2RPQs, which have been known to reduce the complexity of query containment for these classes, yield a more "manageable" single-exponential time bound, which is the norm for several static analysis and verification tasks.Checking containment of a UCQ Theta' in a UCQ Theta is NP-hard, in general, but better bounds can be obtained if Theta is restricted to belong to a "tractable" class of UCQs, e.g., a class of bounded treewidth or hypertreewidth. Also, each Datalog program Pi is equivalent to an infinite union of CQs. This motivated us to study the question of whether restricting Theta to belong to a tractable class also helps alleviate the complexity of checking whether Pi is contained in Theta.We study such question in detail and show that the situation is much more delicate than expected: First, tractability of UCQs does not help in general, but further restricting Theta to be acyclic and have a bounded number of shared variables between atoms yields better complexity bounds. As corollaries, we obtain that checking containment of Pi in Theta is in exptime if Theta is of treewidth one, or it is acyclic and the arity of the schema is fixed. In the case of UC2RPQs we show an exptime bound when queries are acyclic and have a bounded number of edges connecting pairs of variables. As a corollary, we obtain that checking whether Pi is contained in UC2RPQ Gamma is in exptime if Gamma is a strongly acyclic UC2RPQ. Our positive results for UCQs and UC2RPQs are optimal, in a sense, since slightly extending the conditions turns the problem 2exptime-complete.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {188–199},
numpages = {12},
keywords = {conjunctive queries, containment, tree automata, conjunctive regular path queries, datalog},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594550,
author = {Benedikt, Michael and ten Cate, Balder and Tsamoura, Efthymia},
title = {Generating Low-Cost Plans from Proofs},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594550},
doi = {10.1145/2594538.2594550},
abstract = {We look at generating plans that answer queries over restricted interfaces, making use of information about source integrity constraints, access restrictions, and access costs. Our method can exploit the integrity constraints to find low-cost access plans even when there is no direct access to relations appearing in the query. The key idea of our method is to move from a search for a plan to a search for a proof that a query is answerable, and then emph{generate a plan from a proof}. Discovery of one proof allows us to find a single plan that answers the query; exploration of several alternative proofs allows us to find low-cost plans. We start by overviewing a correspondence between proofs and restricted-interface plans in the context of arbitrary first-order constraints, based on interpolation. The correspondence clarifies the connection between preservation and interpolation theorems and reformulation problems, while generalizing it in several dimensions. We then provide direct plan-generation algorithms for schemas based on tuple-generating dependencies. Finally, we show how the direct plan-generation approach can be adapted to take into account the cost of plans.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {200–211},
numpages = {12},
keywords = {proofs, access, interpolation, views, plans},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/3255788,
author = {Tan, Tony},
title = {Session Details: Computing Joins},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3255788},
doi = {10.1145/3255788},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
numpages = {1},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594558,
author = {Beame, Paul and Koutris, Paraschos and Suciu, Dan},
title = {Skew in Parallel Query Processing},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594558},
doi = {10.1145/2594538.2594558},
abstract = {We study the problem of computing a conjunctive query q in parallel, using p of servers, on a large database. We consider algorithms with one round of communication, and study the complexity of the communication. We are especially interested in the case where the data is skewed, which is a major challenge for scalable parallel query processing. We establish a tight connection between the fractional edge packing of the query and the amount of communication in two cases. First, in the case when the only statistics on the database are the cardinalities of the input relations, and the data is skew-free, we provide matching upper and lower bounds (up to a polylogarithmic factor of p) expressed in terms of fractional edge packings of the query q. Second, in the case when the relations are skewed and the heavy hitters and their frequencies are known, we provide upper and lower bounds expressed in terms of packings of residual queries obtained by specializing the query to a heavy hitter. All our lower bounds are expressed in the strongest form, as number of bits needed to be communicated between processors with unlimited computational power. Our results generalize prior results on uniform databases (where each relation is a matching) [4], and lower bounds for the MapReduce model [1].},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {212–223},
numpages = {12},
keywords = {skew, parallel computation, lower bounds},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594552,
author = {Pagh, Rasmus and Silvestri, Francesco},
title = {The Input/Output Complexity of Triangle Enumeration},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594552},
doi = {10.1145/2594538.2594552},
abstract = {We consider the well-known problem of enumerating all triangles of an undirected graph. Our focus is on determining the input/output (I/O) complexity of this problem. Let E be the number of edges, M<E the size of internal memory, and B the block size. The best results obtained previously are sortE3/2) I/Os (Dementiev, PhD thesis 2006) and O(E2/MB) I/Os (Hu et al., SIGMOD 2013), where sort(n) denotes the number of I/Os for sorting n items. We improve the I/O complexity to O(E3/2/(√MB) expected I/Os, which improves the previous bounds by a factor min(√E/M),√M). Our algorithm is cache-oblivious and also I/O optimal: We show that any algorithm enumerating t distinct triangles must always use Ω(√MB) I/Os, and there are graphs for which t=Ω(E3/2). Finally, we give a deterministic cache-aware algorithm using O(E3/2/√MB) I/Os assuming M > Ec for a constant c > 0. Our results are based on a new color coding technique, which may be of independent interest.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {224–233},
numpages = {10},
keywords = {cache-aware, lower bound, external memory, cache-oblivious, triangle listing},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594547,
author = {Ngo, Hung Q. and Nguyen, Dung T. and Re, Christopher and Rudra, Atri},
title = {Beyond Worst-Case Analysis for Joins with Minesweeper},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594547},
doi = {10.1145/2594538.2594547},
abstract = {We describe a new algorithm, Minesweeper, that is able to satisfy stronger runtime guarantees than previous join algorithms (colloquially ``beyond worst-case'' guarantees) for data in indexed search trees. Our first contribution is developing a framework to measure this stronger notion of complexity, which we call "certificate complexity," that extends notions of Barbay et al. and Demaine et al.; a certificate is a set of propositional formulae that certifies that the output is correct. This notion captures a natural class of join algorithms. In addition, the certificate allows us to define a strictly stronger notion of runtime complexity than traditional worst-case guarantees. Our second contribution is to develop a dichotomy theorem for the certificate-based notion of complexity. Roughly, we show that Minesweeper evaluates $beta$-acyclic queries in time linear in the certificate plus the output size, while for any $beta$-cyclic query, there is some instance that takes superlinear time in the certificate (and for which the output is no larger than the certificate size). We also extend our certificate-complexity analysis to queries with bounded treewidth and the triangle query. We present empirical results that certificates can be much smaller than the input size, which suggests that ideas in minesweeper might lead to faster algorithms in practice.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {234–245},
numpages = {12},
keywords = {certificate, adaptive algorithm, bounded treewidth, beta-acyclic queries, triangle query, join algorithms, instance optimality},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/3255789,
author = {Grohe, Martin},
title = {Session Details: Data Structures and Range Queries},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3255789},
doi = {10.1145/3255789},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
numpages = {1},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594545,
author = {Hu, Xiaocheng and Qiao, Miao and Tao, Yufei},
title = {Independent Range Sampling},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594545},
doi = {10.1145/2594538.2594545},
abstract = {This paper studies the independent range sampling problem. The input is a set P of n points in R. Given an interval q = [x, y] and an integer t ≥ 1, a query returns t elements uniformly sampled (with/without replacement) from P ∩ q. The sampling result must be independent from those returned by the previous queries. The objective is to store P in a structure for answering all queries efficiently.If P fits in memory, the problem is interesting when P is dynamic (i.e., allowing insertions and deletions). The state of the art is a structure of O(n) space that answers a query in O(t log n) time, and supports an update in O(log n) time. We describe a new structure of O(n) space that answers a query in O(log n + t) expected time, and supports an update in O(log n) time.If P does not fit in memory, the problem is challenging even when P is static. The best known structure incurs O(logB n + t) I/Os per query, where B is the block size. We develop a new structure of O(n/B) space that answers a query in O(log* (n/B) + logB n + (t/B) logM/B (n/B)) amortized expected I/Os, where M is the memory size, and log* (n/B) is the number of iterative log2(.) operations we need to perform on n/B before going below a constant. We also give a lower bound argument showing that this is nearly optimal---in particular, the multiplicative term logM/B (n/B) is necessary.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {246–255},
numpages = {10},
keywords = {independent range sampling, lower bound, range reporting},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594543,
author = {Tao, Yufei},
title = {A Dynamic I/O-Efficient Structure for One-Dimensional Top-k Range Reporting},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594543},
doi = {10.1145/2594538.2594543},
abstract = {We present a structure in external memory for top-k range reporting, which uses linear space, answers a query in O(lgB n + k/B) I/Os, and supports an update in O(lgB n) amortized I/Os, where n is the input size, and B is the block size. This improves the state of the art which incurs O(lg2B n) amortized I/Os per update.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {256–265},
numpages = {10},
keywords = {range reporting, top-k, dynamic data structure},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594557,
author = {Patil, Manish and Thankachan, Sharma V. and Shah, Rahul and Nekrich, Yakov and Vitter, Jeffrey Scott},
title = {Categorical Range Maxima Queries},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594557},
doi = {10.1145/2594538.2594557},
abstract = {Given an array A[1...n] of n distinct elements from the set {1, 2, ..., n} a range maximum query RMQ(a, b) returns the highest element in A[a...b] along with its position. In this paper, we study a generalization of this classical problem called Categorical Range Maxima Query (CRMQ) problem, in which each element A[i] in the array has an associated category (color) given by C[i] ∈ [σ]. A query then asks to report each distinct color c appearing in C[a...b] along with the highest element (and its position) in A[a...b] with color c. Let pc denote the position of the highest element in A[a...b] with color c. We investigate two variants of this problem: a threshold version and a top-k version. In threshold version, we only need to output the colors with A[pc] more than the input threshold τ, whereas top-k variant asks for k colors with the highest A[pc] values. In the word RAM model, we achieve linear space structure along with O(k) query time, that can report colors in sorted order of A[•]. In external memory, we present a data structure that answers queries in optimal O(1+k/B) I/O's using almost-linear O(n log* n) space, as well as a linear space data structure with O(log* n + k/B) query I/Os. Here k represents the output size, log* n is the iterated logarithm of n and B is the block size. CRMQ has applications to document retrieval and categorical range reporting -- giving a one-shot framework to obtain improved results in both these problems. Our results for CRMQ not only improve the existing best known results for three-sided categorical range reporting but also overcome the hurdle of maintaining color uniqueness in the output set.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {266–277},
numpages = {12},
keywords = {I/O efficiency, categorical queries},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

@inproceedings{10.1145/2594538.2594548,
author = {Bender, Michael A. and Farach-Colton, Martin and Fekete, Sandor P. and Fineman, Jeremy T. and Gilbert, Seth},
title = {Cost-Oblivious Storage Reallocation},
year = {2014},
isbn = {9781450323758},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2594538.2594548},
doi = {10.1145/2594538.2594548},
abstract = {Databases allocate and free blocks of storage on disk. Freed blocks introduce holes where no data is stored. Allocation systems attempt to reuse such deallocated regions in order to minimize the footprint on disk. When previously allocated blocks cannot be moved, this problem is called the memory allocation problem. It is known to have a logarithmic overhead in the footprint size. This paper defines the storage reallocation problem, where previously allocated blocks can be moved, or reallocated, but at some cost. This cost is determined by the allocation/reallocation cost function. The algorithms presented here are cost oblivious, in that they work for a broad and reasonable class of cost functions, even when they do not know what the cost function actually is.The objective is to minimize the storage footprint, that is, the largest memory address containing an allocated object, while simultaneously minimizing the reallocation costs. This paper gives asymptotically optimal algorithms for storage reallocation, in which the storage footprint is at most (1+ε) times optimal, and the reallocation cost is at most O((1/ε)log(1/ε)) times the original allocation cost, which is asymptotically optimal for constant ε. The algorithms are cost oblivious, which means they achieve these bounds with no knowledge of the allocation/reallocation cost function, as long as the cost function is subadditive.},
booktitle = {Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems},
pages = {278–288},
numpages = {11},
keywords = {physical layout, cost oblivious, storage allocation, reallocation, scheduling},
location = {Snowbird, Utah, USA},
series = {PODS '14}
}

license: Unlicense

repository: goyalkaraniit/acm-cr

repo_name: goyalkaraniit/acm-cr