text:
// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.

package computing

import (
	"context"

	"github.com/aokumasan/nifcloud-sdk-go-v2/internal/nifcloudutil"
	"github.com/aws/aws-sdk-go-v2/aws"
)

type NiftyCreateDhcpStaticMappingInput struct {
	_ struct{} `type:"structure"`

	Description *string `locationName:"Description" type:"string"`

	DhcpConfigId *string `locationName:"DhcpConfigId" type:"string"`

	IpAddress *string `locationName:"IpAddress" type:"string"`

	MacAddress *string `locationName:"MacAddress" type:"string"`
}

// String returns the string representation
func (s NiftyCreateDhcpStaticMappingInput) String() string {
	return nifcloudutil.Prettify(s)
}

type NiftyCreateDhcpStaticMappingOutput struct {
	_ struct{} `type:"structure"`

	RequestId *string `locationName:"requestId" type:"string"`

	Return *bool `locationName:"return" type:"boolean"`
}

// String returns the string representation
func (s NiftyCreateDhcpStaticMappingOutput) String() string {
	return nifcloudutil.Prettify(s)
}

const opNiftyCreateDhcpStaticMapping = "NiftyCreateDhcpStaticMapping"

// NiftyCreateDhcpStaticMappingRequest returns a request value for making API operation for
// NIFCLOUD Computing.
//
//    // Example sending a request using NiftyCreateDhcpStaticMappingRequest.
//    req := client.NiftyCreateDhcpStaticMappingRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/computing-2016-11-15/NiftyCreateDhcpStaticMapping
func (c *Client) NiftyCreateDhcpStaticMappingRequest(input *NiftyCreateDhcpStaticMappingInput) NiftyCreateDhcpStaticMappingRequest {
	op := &aws.Operation{
		Name:       opNiftyCreateDhcpStaticMapping,
		HTTPMethod: "POST",
		HTTPPath:   "/api/",
	}

	if input == nil {
		input = &NiftyCreateDhcpStaticMappingInput{}
	}

	req := c.newRequest(op, input, &NiftyCreateDhcpStaticMappingOutput{})
	return NiftyCreateDhcpStaticMappingRequest{Request: req, Input: input, Copy: c.NiftyCreateDhcpStaticMappingRequest}
}

// NiftyCreateDhcpStaticMappingRequest is the request type for the
// NiftyCreateDhcpStaticMapping API operation.
type NiftyCreateDhcpStaticMappingRequest struct {
	*aws.Request
	Input *NiftyCreateDhcpStaticMappingInput
	Copy  func(*NiftyCreateDhcpStaticMappingInput) NiftyCreateDhcpStaticMappingRequest
}

// Send marshals and sends the NiftyCreateDhcpStaticMapping API request.
func (r NiftyCreateDhcpStaticMappingRequest) Send(ctx context.Context) (*NiftyCreateDhcpStaticMappingResponse, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	resp := &NiftyCreateDhcpStaticMappingResponse{
		NiftyCreateDhcpStaticMappingOutput: r.Request.Data.(*NiftyCreateDhcpStaticMappingOutput),
		response:                           &aws.Response{Request: r.Request},
	}

	return resp, nil
}

// NiftyCreateDhcpStaticMappingResponse is the response type for the
// NiftyCreateDhcpStaticMapping API operation.
type NiftyCreateDhcpStaticMappingResponse struct {
	*NiftyCreateDhcpStaticMappingOutput

	response *aws.Response
}

// SDKResponseMetdata returns the response metadata for the
// NiftyCreateDhcpStaticMapping request.
func (r *NiftyCreateDhcpStaticMappingResponse) SDKResponseMetdata() *aws.Response {
	return r.response
}


text:
// run

package main

import "fmt"

func main() {
	b := map[interface{}]interface{}{
		nil: true,
	}
	fmt.Print(b)
}

license_type: permissive

branch_name: refs/heads/main

extension: go


text:
// Copyright 2020 PingCAP, 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,
// See the License for the specific language governing permissions and
// limitations under the License.

package archive

import (
	"github.com/gin-gonic/gin"

	"github.com/pingcap/chaos-mesh/pkg/core"

	"sigs.k8s.io/controller-runtime/pkg/client"

	"github.com/pingcap/chaos-mesh/pkg/config"
)

// Service defines a handler service for archive experiments.
type Service struct {
	conf    *config.ChaosServerConfig
	kubeCli client.Client
	archive core.ExperimentStore
	event   core.EventStore
}

// NewService returns an archive experiment service instance.
func NewService(
	conf *config.ChaosServerConfig,
	cli client.Client,
	archive core.ExperimentStore,
	event core.EventStore,
) *Service {
	return &Service{
		conf:    conf,
		kubeCli: cli,
		archive: archive,
		event:   event,
	}
}

// Register mounts our HTTP handler on the mux.
func Register(r *gin.RouterGroup, s *Service) {
	endpoint := r.Group("/archive")

	// TODO: add more api handlers
	endpoint.GET("/all", s.listExperiments)
}

// TODO: need to be implemented
func (s *Service) listExperiments(c *gin.Context) {}

branch_name: refs/heads/master

gha_language: Go


text:
# Generated by superflore -- DO NOT EDIT
#
# Copyright Open Source Robotics Foundation

inherit ros_distro_foxy
inherit ros_superflore_generated

DESCRIPTION = "Provides an Interface to read the sensor output of a SICK   Safety Scanner"
AUTHOR = "Lennart Puck <puck@fzi.de>"
ROS_AUTHOR = "Lennart Puck"
HOMEPAGE = "https://wiki.ros.org"
SECTION = "devel"
LICENSE = "ALv2"
LIC_FILES_CHKSUM = "file://package.xml;beginline=12;endline=12;md5=48a602c865794401f5c0c56e309d9596"

ROS_CN = "sick_safetyscanners_base"
ROS_BPN = "sick_safetyscanners_base"

ROS_BUILD_DEPENDS = " \
    boost \
"

ROS_BUILDTOOL_DEPENDS = " \
    cmake-native \
"

ROS_EXPORT_DEPENDS = " \
    boost \
"

ROS_BUILDTOOL_EXPORT_DEPENDS = ""

ROS_EXEC_DEPENDS = " \
    boost \
"

# Currently informational only -- see http://www.ros.org/reps/rep-0149.html#dependency-tags.
ROS_TEST_DEPENDS = ""

DEPENDS = "${ROS_BUILD_DEPENDS} ${ROS_BUILDTOOL_DEPENDS}"
# Bitbake doesn't support the "export" concept, so build them as if we needed them to build this package (even though we actually
# don't) so that they're guaranteed to have been staged should this package appear in another's DEPENDS.
DEPENDS += "${ROS_EXPORT_DEPENDS} ${ROS_BUILDTOOL_EXPORT_DEPENDS}"

RDEPENDS:${PN} += "${ROS_EXEC_DEPENDS}"

# matches with: https://github.com/SICKAG/sick_safetyscanners_base-release/archive/release/foxy/sick_safetyscanners_base/1.0.0-2.tar.gz
ROS_BRANCH ?= "branch=release/foxy/sick_safetyscanners_base"
SRC_URI = "git://github.com/SICKAG/sick_safetyscanners_base-release;${ROS_BRANCH};protocol=https"
SRCREV = "9ef14e52c7bfdacbb5b516c7b6b1b1abfc66f894"
S = "${WORKDIR}/git"

ROS_BUILD_TYPE = "cmake"

inherit ros_${ROS_BUILD_TYPE}

license: MIT

repository: DasRoteSkelett/meta-ros

repo_name: DasRoteSkelett/meta-ros

gha_license_id: MIT

extension: bb


text:
%%% -*-BibTeX-*-
@inproceedings{Object2007Li,
   author    = {Hongdong Li and Chunhua Shen},
   title     = {Object-respecting colour image segmentation: An {LP} approach},
   booktitle = {IEEE International Conference on Image Processing (ICIP'07)},
   year      = {2007},
   pages     = {257--260},
   volume    = {2},
   address   = {San Antonio, Texas},
   month     = {September},
   publisher = {IEEE Press},
   pdf       = {},
   url       = {http://dx.doi.org/10.1109/ICIP.2007.4379141},
   venue     = {ICIP},
}

extension: bib


text:
package awsdirectoryservice

import (
	"reflect"

	_jsii_ "github.com/aws/jsii-runtime-go/runtime"
)

func init() {
	_jsii_.RegisterClass(
		"monocdk.aws_directoryservice.CfnMicrosoftAD",
		reflect.TypeOf((*CfnMicrosoftAD)(nil)).Elem(),
		[]_jsii_.Member{
			_jsii_.MemberMethod{JsiiMethod: "addDeletionOverride", GoMethod: "AddDeletionOverride"},
			_jsii_.MemberMethod{JsiiMethod: "addDependsOn", GoMethod: "AddDependsOn"},
			_jsii_.MemberMethod{JsiiMethod: "addMetadata", GoMethod: "AddMetadata"},
			_jsii_.MemberMethod{JsiiMethod: "addOverride", GoMethod: "AddOverride"},
			_jsii_.MemberMethod{JsiiMethod: "addPropertyDeletionOverride", GoMethod: "AddPropertyDeletionOverride"},
			_jsii_.MemberMethod{JsiiMethod: "addPropertyOverride", GoMethod: "AddPropertyOverride"},
			_jsii_.MemberMethod{JsiiMethod: "applyRemovalPolicy", GoMethod: "ApplyRemovalPolicy"},
			_jsii_.MemberProperty{JsiiProperty: "attrAlias", GoGetter: "AttrAlias"},
			_jsii_.MemberProperty{JsiiProperty: "attrDnsIpAddresses", GoGetter: "AttrDnsIpAddresses"},
			_jsii_.MemberProperty{JsiiProperty: "cfnOptions", GoGetter: "CfnOptions"},
			_jsii_.MemberProperty{JsiiProperty: "cfnProperties", GoGetter: "CfnProperties"},
			_jsii_.MemberProperty{JsiiProperty: "cfnResourceType", GoGetter: "CfnResourceType"},
			_jsii_.MemberProperty{JsiiProperty: "createAlias", GoGetter: "CreateAlias"},
			_jsii_.MemberProperty{JsiiProperty: "creationStack", GoGetter: "CreationStack"},
			_jsii_.MemberProperty{JsiiProperty: "edition", GoGetter: "Edition"},
			_jsii_.MemberProperty{JsiiProperty: "enableSso", GoGetter: "EnableSso"},
			_jsii_.MemberMethod{JsiiMethod: "getAtt", GoMethod: "GetAtt"},
			_jsii_.MemberMethod{JsiiMethod: "getMetadata", GoMethod: "GetMetadata"},
			_jsii_.MemberMethod{JsiiMethod: "inspect", GoMethod: "Inspect"},
			_jsii_.MemberProperty{JsiiProperty: "logicalId", GoGetter: "LogicalId"},
			_jsii_.MemberProperty{JsiiProperty: "name", GoGetter: "Name"},
			_jsii_.MemberProperty{JsiiProperty: "node", GoGetter: "Node"},
			_jsii_.MemberMethod{JsiiMethod: "onPrepare", GoMethod: "OnPrepare"},
			_jsii_.MemberMethod{JsiiMethod: "onSynthesize", GoMethod: "OnSynthesize"},
			_jsii_.MemberMethod{JsiiMethod: "onValidate", GoMethod: "OnValidate"},
			_jsii_.MemberMethod{JsiiMethod: "overrideLogicalId", GoMethod: "OverrideLogicalId"},
			_jsii_.MemberProperty{JsiiProperty: "password", GoGetter: "Password"},
			_jsii_.MemberMethod{JsiiMethod: "prepare", GoMethod: "Prepare"},
			_jsii_.MemberProperty{JsiiProperty: "ref", GoGetter: "Ref"},
			_jsii_.MemberMethod{JsiiMethod: "renderProperties", GoMethod: "RenderProperties"},
			_jsii_.MemberProperty{JsiiProperty: "shortName", GoGetter: "ShortName"},
			_jsii_.MemberMethod{JsiiMethod: "shouldSynthesize", GoMethod: "ShouldSynthesize"},
			_jsii_.MemberProperty{JsiiProperty: "stack", GoGetter: "Stack"},
			_jsii_.MemberMethod{JsiiMethod: "synthesize", GoMethod: "Synthesize"},
			_jsii_.MemberMethod{JsiiMethod: "toString", GoMethod: "ToString"},
			_jsii_.MemberProperty{JsiiProperty: "updatedProperites", GoGetter: "UpdatedProperites"},
			_jsii_.MemberMethod{JsiiMethod: "validate", GoMethod: "Validate"},
			_jsii_.MemberMethod{JsiiMethod: "validateProperties", GoMethod: "ValidateProperties"},
			_jsii_.MemberProperty{JsiiProperty: "vpcSettings", GoGetter: "VpcSettings"},
		},
		func() interface{} {
			j := jsiiProxy_CfnMicrosoftAD{}
			_jsii_.InitJsiiProxy(&j.Type__awscdkCfnResource)
			_jsii_.InitJsiiProxy(&j.Type__awscdkIInspectable)
			return &j
		},
	)
	_jsii_.RegisterStruct(
		"monocdk.aws_directoryservice.CfnMicrosoftAD.VpcSettingsProperty",
		reflect.TypeOf((*CfnMicrosoftAD_VpcSettingsProperty)(nil)).Elem(),
	)
	_jsii_.RegisterStruct(
		"monocdk.aws_directoryservice.CfnMicrosoftADProps",
		reflect.TypeOf((*CfnMicrosoftADProps)(nil)).Elem(),
	)
	_jsii_.RegisterClass(
		"monocdk.aws_directoryservice.CfnSimpleAD",
		reflect.TypeOf((*CfnSimpleAD)(nil)).Elem(),
		[]_jsii_.Member{
			_jsii_.MemberMethod{JsiiMethod: "addDeletionOverride", GoMethod: "AddDeletionOverride"},
			_jsii_.MemberMethod{JsiiMethod: "addDependsOn", GoMethod: "AddDependsOn"},
			_jsii_.MemberMethod{JsiiMethod: "addMetadata", GoMethod: "AddMetadata"},
			_jsii_.MemberMethod{JsiiMethod: "addOverride", GoMethod: "AddOverride"},
			_jsii_.MemberMethod{JsiiMethod: "addPropertyDeletionOverride", GoMethod: "AddPropertyDeletionOverride"},
			_jsii_.MemberMethod{JsiiMethod: "addPropertyOverride", GoMethod: "AddPropertyOverride"},
			_jsii_.MemberMethod{JsiiMethod: "applyRemovalPolicy", GoMethod: "ApplyRemovalPolicy"},
			_jsii_.MemberProperty{JsiiProperty: "attrAlias", GoGetter: "AttrAlias"},
			_jsii_.MemberProperty{JsiiProperty: "attrDnsIpAddresses", GoGetter: "AttrDnsIpAddresses"},
			_jsii_.MemberProperty{JsiiProperty: "cfnOptions", GoGetter: "CfnOptions"},
			_jsii_.MemberProperty{JsiiProperty: "cfnProperties", GoGetter: "CfnProperties"},
			_jsii_.MemberProperty{JsiiProperty: "cfnResourceType", GoGetter: "CfnResourceType"},
			_jsii_.MemberProperty{JsiiProperty: "createAlias", GoGetter: "CreateAlias"},
			_jsii_.MemberProperty{JsiiProperty: "creationStack", GoGetter: "CreationStack"},
			_jsii_.MemberProperty{JsiiProperty: "description", GoGetter: "Description"},
			_jsii_.MemberProperty{JsiiProperty: "enableSso", GoGetter: "EnableSso"},
			_jsii_.MemberMethod{JsiiMethod: "getAtt", GoMethod: "GetAtt"},
			_jsii_.MemberMethod{JsiiMethod: "getMetadata", GoMethod: "GetMetadata"},
			_jsii_.MemberMethod{JsiiMethod: "inspect", GoMethod: "Inspect"},
			_jsii_.MemberProperty{JsiiProperty: "logicalId", GoGetter: "LogicalId"},
			_jsii_.MemberProperty{JsiiProperty: "name", GoGetter: "Name"},
			_jsii_.MemberProperty{JsiiProperty: "node", GoGetter: "Node"},
			_jsii_.MemberMethod{JsiiMethod: "onPrepare", GoMethod: "OnPrepare"},
			_jsii_.MemberMethod{JsiiMethod: "onSynthesize", GoMethod: "OnSynthesize"},
			_jsii_.MemberMethod{JsiiMethod: "onValidate", GoMethod: "OnValidate"},
			_jsii_.MemberMethod{JsiiMethod: "overrideLogicalId", GoMethod: "OverrideLogicalId"},
			_jsii_.MemberProperty{JsiiProperty: "password", GoGetter: "Password"},
			_jsii_.MemberMethod{JsiiMethod: "prepare", GoMethod: "Prepare"},
			_jsii_.MemberProperty{JsiiProperty: "ref", GoGetter: "Ref"},
			_jsii_.MemberMethod{JsiiMethod: "renderProperties", GoMethod: "RenderProperties"},
			_jsii_.MemberProperty{JsiiProperty: "shortName", GoGetter: "ShortName"},
			_jsii_.MemberMethod{JsiiMethod: "shouldSynthesize", GoMethod: "ShouldSynthesize"},
			_jsii_.MemberProperty{JsiiProperty: "size", GoGetter: "Size"},
			_jsii_.MemberProperty{JsiiProperty: "stack", GoGetter: "Stack"},
			_jsii_.MemberMethod{JsiiMethod: "synthesize", GoMethod: "Synthesize"},
			_jsii_.MemberMethod{JsiiMethod: "toString", GoMethod: "ToString"},
			_jsii_.MemberProperty{JsiiProperty: "updatedProperites", GoGetter: "UpdatedProperites"},
			_jsii_.MemberMethod{JsiiMethod: "validate", GoMethod: "Validate"},
			_jsii_.MemberMethod{JsiiMethod: "validateProperties", GoMethod: "ValidateProperties"},
			_jsii_.MemberProperty{JsiiProperty: "vpcSettings", GoGetter: "VpcSettings"},
		},
		func() interface{} {
			j := jsiiProxy_CfnSimpleAD{}
			_jsii_.InitJsiiProxy(&j.Type__awscdkCfnResource)
			_jsii_.InitJsiiProxy(&j.Type__awscdkIInspectable)
			return &j
		},
	)
	_jsii_.RegisterStruct(
		"monocdk.aws_directoryservice.CfnSimpleAD.VpcSettingsProperty",
		reflect.TypeOf((*CfnSimpleAD_VpcSettingsProperty)(nil)).Elem(),
	)
	_jsii_.RegisterStruct(
		"monocdk.aws_directoryservice.CfnSimpleADProps",
		reflect.TypeOf((*CfnSimpleADProps)(nil)).Elem(),
	)
}

repository: QPC-database/aws-cdk-go

repo_name: QPC-database/aws-cdk-go


text:
@incollection{diaz2018stochastic,
  title={Stochastic Treatment Regimes},
  author={D{\'\i}az, Iv{\'a}n and {van der Laan}, Mark J},
  booktitle={Targeted Learning in Data Science: Causal Inference for Complex
    Longitudinal Studies},
  pages={167--180},
  year={2018},
  publisher={Springer Science \& Business Media}
}

@article{diaz2012population,
  title={Population intervention causal effects based on stochastic
    interventions},
  author={D{\'\i}az, Iv{\'a}n and {van der Laan}, Mark J},
  journal={Biometrics},
  volume={68},
  number={2},
  pages={541--549},
  year={2012},
  publisher={Wiley Online Library}
}

@book{vdl2018targeted,
  title={Targeted Learning in Data Science: Causal Inference for Complex
    Longitudinal Studies},
  author={{van der Laan}, Mark J and Rose, Sherri},
  year={2018},
  publisher={Springer Science \& Business Media}
}

@book{vdl2011targeted,
  title={Targeted Learning: Causal Inference for Observational and Experimental
    Data},
  author={{van der Laan}, Mark J and Rose, Sherri},
  year={2011},
  publisher={Springer Science \& Business Media}
}

@article{diaz2011super,
  title={Super learner based conditional density estimation with application to
    marginal structural models},
  author={D{\'\i}az, Iv{\'a}n and {van der Laan}, Mark J},
  journal={International Journal of Biostatistics},
  volume={7},
  number={1},
  pages={1--20},
  year={2011},
  publisher={De Gruyter}
}

@article{diaz2020causal,
  title={Causal mediation analysis for stochastic interventions},
  author={D{\'\i}az, Iv{\'a}n and Hejazi, Nima S},
  year={2020},
  url = {https://doi.org/10.1111/rssb.12362},
  doi = {10.1111/rssb.12362},
  journal={Journal of the Royal Statistical Society: Series B (Statistical
    Methodology)},
  volume = {82},
  number = {3},
  pages = {661-683},
  publisher={Wiley Online Library}
}

@incollection{vdl2018highly,
  title={Highly Adaptive Lasso {(HAL)}},
  author={{van der Laan}, Mark J and Benkeser, David},
  booktitle={Targeted Learning in Data Science: Causal Inference for Complex
    Longitudinal Studies},
  pages={77--94},
  year={2018},
  publisher={Springer}
}

@article{vdl2017generally,
  title={A Generally Efficient Targeted Minimum Loss Based Estimator based on
    the Highly Adaptive Lasso},
  author={{van der Laan}, Mark J},
  journal={International Journal of Biostatistics},
  volume={13},
  number={2},
  year={2017},
  publisher={De Gruyter}
}

@manual{coyle2022hal9001-rpkg,
  author = {Coyle, Jeremy R and Hejazi, Nima S and Phillips, Rachael V and
    {van der Laan}, Lars WP and {van der Laan}, Mark J},
  title = {{hal9001}: The scalable highly adaptive lasso},
  year  = {2022},
  url = {https://CRAN.R-project.org/package=hal9001},
  doi = {10.5281/zenodo.3558313},
  note = {{R} package version 0.4.2}
}

@article{hejazi2020hal9001-joss,
  author = {Hejazi, Nima S and Coyle, Jeremy R and {van der Laan}, Mark J},
  title = {{hal9001}: Scalable highly adaptive lasso regression in {R}},
  year  = {2020},
  url = {https://doi.org/10.21105/joss.02526},
  doi = {10.21105/joss.02526},
  journal = {Journal of Open Source Software},
  publisher = {The Open Journal}
}

@inproceedings{benkeser2016highly,
  title={The highly adaptive lasso estimator},
  author={Benkeser, David and {van der Laan}, Mark J},
  booktitle={Proceedings of the International Conference on Data Science and
    Advanced Analytics},
  volume={2016},
  pages={689},
  year={2016},
  organization={NIH Public Access}
}

@article{hirano2004propensity,
  title={The propensity score with continuous treatments},
  author={Hirano, Keisuke and Imbens, Guido W},
  journal={Applied Bayesian Modeling and Causal Inference from Incomplete-data
    Perspectives},
  volume={226164},
  pages={73--84},
  year={2004}
}

@article{zhu2015boosting,
  title={A boosting algorithm for estimating generalized propensity scores with
    continuous treatments},
  author={Zhu, Yeying and Coffman, Donna L and Ghosh, Debashis},
  journal={Journal of Causal Inference},
  volume={3},
  number={1},
  pages={25--40},
  year={2015},
  publisher={De Gruyter}
}

@article{imai2004causal,
  title={Causal inference with general treatment regimes: Generalizing the
    propensity score},
  author={Imai, Kosuke and Van Dyk, David A},
  journal={Journal of the American Statistical Association},
  volume={99},
  number={467},
  pages={854--866},
  year={2004},
  publisher={Taylor \& Francis}
}

@article{ertefaie2022nonparametric,
  doi = {},
  url = {https://arxiv.org/abs/2005.11303},
  year = {2022},
  publisher = {},
  journal = {\textnormal{revision invited at} Biometrics},
  volume = {},
  number = {},
  pages = {},
  author = {Ertefaie, Ashkan and Hejazi, Nima S and {van der Laan}, Mark J},
  title = {Nonparametric inverse probability weighted estimators based on the
    highly adaptive lasso}
}

@article{hejazi2022efficient,
  doi = {},
  url = {},
  year = {2022},
  publisher = {},
  journal = {\textnormal{forthcoming}},
  volume = {},
  number = {},
  pages = {},
  author = {Hejazi, Nima S and Benkeser, David C and D{\'\i}az, Iv{\'a}n and
    {van der Laan}, Mark J},
  title = {Efficient estimation of modified treatment policy effects based on
    the generalized propensity score}
}

repository: cran/haldensify

repo_name: cran/haldensify


text:
package customizations

import (
	"context"
	"fmt"
	"net/url"
	"strings"

	"github.com/aws/smithy-go/middleware"
	smithyhttp "github.com/aws/smithy-go/transport/http"

	"github.com/aws/aws-sdk-go-v2/aws"
	awsarn "github.com/aws/aws-sdk-go-v2/aws/arn"
	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
	"github.com/aws/aws-sdk-go-v2/service/internal/s3shared"
	"github.com/aws/aws-sdk-go-v2/service/internal/s3shared/arn"
	s3endpoints "github.com/aws/aws-sdk-go-v2/service/s3control/internal/endpoints/s3"
)

const (
	// outpost id header
	outpostIDHeader = "x-amz-outpost-id"

	// account id header
	accountIDHeader = "x-amz-account-id"
)

// processARNResource is used to process an ARN resource.
type processARNResource struct {

	// CopyInput creates a copy of input to be modified, this ensures the original input is not modified.
	CopyInput func(interface{}) (interface{}, error)

	// UpdateARNField points to a function that takes in a copy of input, updates the ARN field with
	// the provided value and returns the input
	UpdateARNField func(interface{}, string) error

	// UseARNRegion indicates if region parsed from an ARN should be used.
	UseARNRegion bool

	// EndpointResolver used to resolve endpoints. This may be a custom endpoint resolver
	EndpointResolver EndpointResolver

	// EndpointResolverOptions used by endpoint resolver
	EndpointResolverOptions EndpointResolverOptions
}

// ID returns the middleware ID.
func (*processARNResource) ID() string { return "S3Control:ProcessARNResourceMiddleware" }

func (m *processARNResource) HandleSerialize(
	ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler,
) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	if !awsmiddleware.GetRequiresLegacyEndpoints(ctx) {
		return next.HandleSerialize(ctx, in)
	}

	// if arn region resolves to custom endpoint that is mutable
	if smithyhttp.GetHostnameImmutable(ctx) {
		return next.HandleSerialize(ctx, in)
	}

	// check if arn was provided, if not skip this middleware
	arnValue, ok := s3shared.GetARNResourceFromContext(ctx)
	if !ok {
		return next.HandleSerialize(ctx, in)
	}

	req, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, fmt.Errorf("unknown request type %T", req)
	}

	// parse arn into an endpoint arn wrt to service
	resource, err := parseEndpointARN(arnValue)
	if err != nil {
		return out, metadata, err
	}

	resourceRequest := s3shared.ResourceRequest{
		Resource:      resource,
		RequestRegion: awsmiddleware.GetRegion(ctx),
		SigningRegion: awsmiddleware.GetSigningRegion(ctx),
		PartitionID:   awsmiddleware.GetPartitionID(ctx),
		UseARNRegion:  m.UseARNRegion,
	}

	// validate resource request
	if err := validateResourceRequest(resourceRequest); err != nil {
		return out, metadata, err
	}

	// if not done already, clone the input and reassign it to in.Parameters
	if !s3shared.IsClonedInput(ctx) {
		in.Parameters, err = m.CopyInput(in.Parameters)
		if err != nil {
			return out, metadata, fmt.Errorf("error creating a copy of input while processing arn")
		}
		// set copy input key on context
		ctx = s3shared.SetClonedInputKey(ctx, true)
	}

	// switch to correct endpoint updater
	switch tv := resource.(type) {
	case arn.OutpostAccessPointARN:
		// validations
		// check if dual stack
		if m.EndpointResolverOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled {
			return out, metadata, s3shared.NewClientConfiguredForDualStackError(tv,
				resourceRequest.PartitionID, resourceRequest.RequestRegion, nil)
		}

		// Disable endpoint host prefix for s3-control
		ctx = smithyhttp.DisableEndpointHostPrefix(ctx, true)

		if m.UpdateARNField == nil {
			return out, metadata, fmt.Errorf("error updating arnable field while serializing")
		}

		// update the arnable field with access point name
		err = m.UpdateARNField(in.Parameters, tv.AccessPointName)
		if err != nil {
			return out, metadata, fmt.Errorf("error updating arnable field while serializing")
		}

		// Add outpostID header
		req.Header.Add(outpostIDHeader, tv.OutpostID)

		// build outpost access point request
		ctx, err = buildOutpostAccessPointRequest(ctx, outpostAccessPointOptions{
			processARNResource: *m,
			request:            req,
			resource:           tv,
			partitionID:        resourceRequest.PartitionID,
			requestRegion:      resourceRequest.RequestRegion,
		})
		if err != nil {
			return out, metadata, err
		}

	// process outpost accesspoint ARN
	case arn.OutpostBucketARN:
		// check if dual stack
		if m.EndpointResolverOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled {
			return out, metadata, s3shared.NewClientConfiguredForDualStackError(tv,
				resourceRequest.PartitionID, resourceRequest.RequestRegion, nil)
		}

		// Disable endpoint host prefix for s3-control
		ctx = smithyhttp.DisableEndpointHostPrefix(ctx, true)

		if m.UpdateARNField == nil {
			return out, metadata, fmt.Errorf("error updating arnable field while serializing")
		}

		// update the arnable field with bucket name
		err = m.UpdateARNField(in.Parameters, tv.BucketName)
		if err != nil {
			return out, metadata, fmt.Errorf("error updating arnable field while serializing")
		}

		// Add outpostID header
		req.Header.Add(outpostIDHeader, tv.OutpostID)

		// build outpost bucket request
		ctx, err = buildOutpostBucketRequest(ctx, outpostBucketOptions{
			processARNResource: *m,
			request:            req,
			resource:           tv,
			partitionID:        resourceRequest.PartitionID,
			requestRegion:      resourceRequest.RequestRegion,
		})
		if err != nil {
			return out, metadata, err
		}

	default:
		return out, metadata, s3shared.NewInvalidARNError(resource, nil)
	}

	// Add account-id header for the request if not present.
	// SDK must always send the x-amz-account-id header for all requests
	// where an accountId has been extracted from an ARN or the accountId field modeled as a header.
	if h := req.Header.Get(accountIDHeader); len(h) == 0 {
		req.Header.Add(accountIDHeader, resource.GetARN().AccountID)
	}

	return next.HandleSerialize(ctx, in)
}

// validate if s3 resource and request config is compatible.
func validateResourceRequest(resourceRequest s3shared.ResourceRequest) error {
	// check if resourceRequest leads to a cross partition error
	v, err := resourceRequest.IsCrossPartition()
	if err != nil {
		return err
	}
	if v {
		// if cross partition
		return s3shared.NewClientPartitionMismatchError(resourceRequest.Resource,
			resourceRequest.PartitionID, resourceRequest.RequestRegion, nil)
	}

	// check if resourceRequest leads to a cross region error
	if !resourceRequest.AllowCrossRegion() && resourceRequest.IsCrossRegion() {
		// if cross region, but not use ARN region is not enabled
		return s3shared.NewClientRegionMismatchError(resourceRequest.Resource,
			resourceRequest.PartitionID, resourceRequest.RequestRegion, nil)
	}

	return nil
}

// Used by shapes with members decorated as endpoint ARN.
func parseEndpointARN(v awsarn.ARN) (arn.Resource, error) {
	return arn.ParseResource(v, resourceParser)
}

func resourceParser(a awsarn.ARN) (arn.Resource, error) {
	resParts := arn.SplitResource(a.Resource)
	switch resParts[0] {
	case "outpost":
		return arn.ParseOutpostARNResource(a, resParts[1:])
	default:
		return nil, arn.InvalidARNError{ARN: a, Reason: "unknown resource type"}
	}
}

// ====== Outpost Accesspoint ========

type outpostAccessPointOptions struct {
	processARNResource
	request       *smithyhttp.Request
	resource      arn.OutpostAccessPointARN
	partitionID   string
	requestRegion string
}

func buildOutpostAccessPointRequest(ctx context.Context, options outpostAccessPointOptions) (context.Context, error) {
	tv := options.resource
	req := options.request

	// Build outpost access point resource
	resolveRegion := tv.Region
	resolveService := tv.Service

	endpointsID := resolveService
	if resolveService == "s3-outposts" {
		endpointsID = "s3"
	}

	// resolve regional endpoint for resolved region.
	var endpoint aws.Endpoint
	var err error

	endpointSource := awsmiddleware.GetEndpointSource(ctx)

	eo := options.EndpointResolverOptions
	eo.Logger = middleware.GetLogger(ctx)
	eo.ResolvedRegion = ""

	if endpointsID == "s3" && endpointSource == aws.EndpointSourceServiceMetadata {
		// use s3 endpoint resolver
		endpoint, err = s3endpoints.New().ResolveEndpoint(resolveRegion, s3endpoints.Options{
			LogDeprecated:        eo.LogDeprecated,
			DisableHTTPS:         eo.DisableHTTPS,
			UseFIPSEndpoint:      eo.UseFIPSEndpoint,
			UseDualStackEndpoint: eo.UseDualStackEndpoint,
		})
	} else {
		endpoint, err = options.EndpointResolver.ResolveEndpoint(resolveRegion, eo)
	}

	if err != nil {
		return ctx, s3shared.NewFailedToResolveEndpointError(
			tv,
			options.partitionID,
			options.requestRegion,
			err,
		)
	}

	req.URL, err = url.Parse(endpoint.URL)
	if err != nil {
		return ctx, fmt.Errorf("failed to parse endpoint URL: %w", err)
	}

	// redirect signer to use resolved endpoint signing name and region
	if len(endpoint.SigningName) != 0 {
		ctx = awsmiddleware.SetSigningName(ctx, endpoint.SigningName)
	} else {
		// assign resolved service from arn as signing name
		ctx = awsmiddleware.SetSigningName(ctx, resolveService)
	}

	if len(endpoint.SigningRegion) != 0 {
		// redirect signer to use resolved endpoint signing name and region
		ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
	} else {
		ctx = awsmiddleware.SetSigningRegion(ctx, resolveRegion)
	}

	// skip arn processing, if arn region resolves to a immutable endpoint
	if endpoint.HostnameImmutable {
		return ctx, nil
	}

	// add url host as s3-outposts
	cfgHost := req.URL.Host
	if strings.HasPrefix(cfgHost, endpointsID) {
		req.URL.Host = resolveService + cfgHost[len(endpointsID):]

		// update serviceID to resolved service
		ctx = awsmiddleware.SetServiceID(ctx, resolveService)
	}

	// validate the endpoint host
	if err := smithyhttp.ValidateEndpointHost(req.URL.Host); err != nil {
		return ctx, s3shared.NewInvalidARNError(tv, err)
	}

	// Disable endpoint host prefix for s3-control
	ctx = smithyhttp.DisableEndpointHostPrefix(ctx, true)

	return ctx, nil
}

// ======= Outpost Bucket =========
type outpostBucketOptions struct {
	processARNResource
	request       *smithyhttp.Request
	resource      arn.OutpostBucketARN
	partitionID   string
	requestRegion string
}

func buildOutpostBucketRequest(ctx context.Context, options outpostBucketOptions) (context.Context, error) {
	tv := options.resource
	req := options.request

	// Build endpoint from outpost bucket arn
	resolveRegion := tv.Region
	resolveService := tv.Service
	// Outpost bucket resource uses `s3-control` as serviceEndpointLabel
	endpointsID := "s3-control"

	// resolve regional endpoint for resolved region.
	eo := options.EndpointResolverOptions
	eo.Logger = middleware.GetLogger(ctx)
	eo.ResolvedRegion = ""

	endpoint, err := options.EndpointResolver.ResolveEndpoint(resolveRegion, eo)
	if err != nil {
		return ctx, s3shared.NewFailedToResolveEndpointError(
			tv,
			options.partitionID,
			options.requestRegion,
			err,
		)
	}

	// assign resolved endpoint url to request url
	req.URL, err = url.Parse(endpoint.URL)
	if err != nil {
		return ctx, fmt.Errorf("failed to parse endpoint URL: %w", err)
	}

	if len(endpoint.SigningName) != 0 {
		ctx = awsmiddleware.SetSigningName(ctx, endpoint.SigningName)
	} else {
		// assign resolved service from arn as signing name
		ctx = awsmiddleware.SetSigningName(ctx, resolveService)
	}

	if len(endpoint.SigningRegion) != 0 {
		// redirect signer to use resolved endpoint signing name and region
		ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
	} else {
		ctx = awsmiddleware.SetSigningRegion(ctx, resolveRegion)
	}

	// skip arn processing, if arn region resolves to a immutable endpoint
	if endpoint.HostnameImmutable {
		return ctx, nil
	}

	cfgHost := req.URL.Host
	if strings.HasPrefix(cfgHost, endpointsID) {
		// replace service endpointID label with resolved service
		req.URL.Host = resolveService + cfgHost[len(endpointsID):]

		// update serviceID to resolved service
		ctx = awsmiddleware.SetServiceID(ctx, resolveService)
	}

	// validate the endpoint host
	if err := smithyhttp.ValidateEndpointHost(req.URL.Host); err != nil {
		return ctx, s3shared.NewInvalidARNError(tv, err)
	}

	// Disable endpoint host prefix for s3-control
	ctx = smithyhttp.DisableEndpointHostPrefix(ctx, true)

	return ctx, nil
}


text:
package keys

import (
	"encoding/json"
	"errors"

	"github.com/hyperledger/fabric/core/chaincode/shim"
	"github.com/ivaylopivanov/chaincode-samples/storage/codes"
)

// Keys obj
type Keys struct {
	Public  string
	Private string
}

// Get keys
func Get(stub shim.ChaincodeStubInterface, id string) ([]byte, error) {
	b, err := stub.GetState(id)

	if err != nil {
		return nil, errors.New(codes.GetState)
	}

	return b, nil
}

// PublicKey for id
func PublicKey(stub shim.ChaincodeStubInterface, id string) ([]byte, error) {
	b, err := stub.GetState(id)
	if err != nil {
		return nil, errors.New(codes.GetState)
	}

	k := &Keys{}
	json.Unmarshal(b, k)

	if err != nil {
		return nil, errors.New(codes.NotFound)
	}

	return []byte(k.Public), nil
}

// PrivateKey for id
func PrivateKey(stub shim.ChaincodeStubInterface, id string) ([]byte, error) {
	b, err := stub.GetState(id)
	if err != nil {
		return nil, errors.New(codes.GetState)
	}

	k := &Keys{}
	json.Unmarshal(b, k)

	if err != nil {
		return nil, errors.New(codes.NotFound)
	}

	return []byte(k.Private), nil
}


text:
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_VERSION 1)

# Specify the sdk path
set(SDK_PATH /opt/rpi-sdk/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64)

# specify the cross compiler
set(CMAKE_C_COMPILER   "${SDK_PATH}/bin/arm-linux-gnueabihf-gcc")
set(CMAKE_CXX_COMPILER "${SDK_PATH}/bin/arm-linux-gnueabihf-g++")

# Specify flags
#set(COMMON_FLAGS "-march=armv7-a -marm -mfpu=neon  -mfloat-abi=hard -mcpu=cortex-a9")
set(COMMON_FLAGS "")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COMMON_FLAGS}" CACHE STRING "")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMMON_FLAGS}" CACHE STRING "")

# Specify the system sysroot
set(CMAKE_SYSROOT "/mnt/ggrasp")

# search for programs in the build host directories
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)

# for libraries and headers in the target directories
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

set(ENV{PKG_CONFIG_DIR} "")
set(ENV{PKG_CONFIG_LIBDIR} "${CMAKE_SYSROOT}/usr/lib/pkgconfig:${CMAKE_SYSROOT}/usr/share/pkgconfig")
set(ENV{PKG_CONFIG_SYSROOT_DIR} ${CMAKE_SYSROOT})

repository: giursino/DomoGu

repo_name: giursino/DomoGu

extension: cmake


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

package session

import (
	"context"
	"net/http"

	"github.com/astaxie/beego/server/web/session"
)

// FileSessionStore File session store
type FileSessionStore session.FileSessionStore

// Set value to file session
func (fs *FileSessionStore) Set(key, value interface{}) error {
	return (*session.FileSessionStore)(fs).Set(context.Background(), key, value)
}

// Get value from file session
func (fs *FileSessionStore) Get(key interface{}) interface{} {
	return (*session.FileSessionStore)(fs).Get(context.Background(), key)
}

// Delete value in file session by given key
func (fs *FileSessionStore) Delete(key interface{}) error {
	return (*session.FileSessionStore)(fs).Delete(context.Background(), key)
}

// Flush Clean all values in file session
func (fs *FileSessionStore) Flush() error {
	return (*session.FileSessionStore)(fs).Flush(context.Background())
}

// SessionID Get file session store id
func (fs *FileSessionStore) SessionID() string {
	return (*session.FileSessionStore)(fs).SessionID(context.Background())
}

// SessionRelease Write file session to local file with Gob string
func (fs *FileSessionStore) SessionRelease(w http.ResponseWriter) {
	(*session.FileSessionStore)(fs).SessionRelease(context.Background(), w)
}

// FileProvider File session provider
type FileProvider session.FileProvider

// SessionInit Init file session provider.
// savePath sets the session files path.
func (fp *FileProvider) SessionInit(maxlifetime int64, savePath string) error {
	return (*session.FileProvider)(fp).SessionInit(context.Background(), maxlifetime, savePath)
}

// SessionRead Read file session by sid.
// if file is not exist, create it.
// the file path is generated from sid string.
func (fp *FileProvider) SessionRead(sid string) (Store, error) {
	s, err := (*session.FileProvider)(fp).SessionRead(context.Background(), sid)
	return &NewToOldStoreAdapter{
		delegate: s,
	}, err
}

// SessionExist Check file session exist.
// it checks the file named from sid exist or not.
func (fp *FileProvider) SessionExist(sid string) bool {
	res, _ := (*session.FileProvider)(fp).SessionExist(context.Background(), sid)
	return res
}

// SessionDestroy Remove all files in this save path
func (fp *FileProvider) SessionDestroy(sid string) error {
	return (*session.FileProvider)(fp).SessionDestroy(context.Background(), sid)
}

// SessionGC Recycle files in save path
func (fp *FileProvider) SessionGC() {
	(*session.FileProvider)(fp).SessionGC(context.Background())
}

// SessionAll Get active file session number.
// it walks save path to count files.
func (fp *FileProvider) SessionAll() int {
	return (*session.FileProvider)(fp).SessionAll(context.Background())
}

// SessionRegenerate Generate new sid for file session.
// it delete old file and create new file named from new sid.
func (fp *FileProvider) SessionRegenerate(oldsid, sid string) (Store, error) {
	s, err := (*session.FileProvider)(fp).SessionRegenerate(context.Background(), oldsid, sid)
	return &NewToOldStoreAdapter{
		delegate: s,
	}, err
}

repository: astaxie/beego

repo_name: astaxie/beego

branch_name: refs/heads/develop

gha_license_id: NOASSERTION


text:
package appstore

import (
	"time"
)

// Receipt is struct for iap receipt data
type Receipt struct {
	responseVersion int
	rawReceipt      string
	Status          int
	Environment     string

	ReceiptType                string
	AdamID                     int64
	AppItemID                  int64
	BundleID                   string
	ApplicationVersion         string
	DownloadID                 int64
	OriginalApplicationVersion string
	RequestDate                time.Time
	OriginalPurchaseDate       time.Time
	InApps                     ReceiptInApps

	LatestReceiptInfo ReceiptInApps
	LatestReceipt     string

	PendingRenewalInfo ReceiptPendingRenewalInfos
	IsRetryable        bool
}

func (r *Receipt) String() string {
	return r.rawReceipt
}

// ResponseVersion returns receipt style;
// iOS6 style returns `6`
// iOS7 style returns `7`
func (r *Receipt) ResponseVersion() int {
	if r.responseVersion == 0 {
		return verIOS7
	}
	return r.responseVersion
}

// GetStatus returns status code of the receipt
// see: https://developer.apple.com/library/ios/releasenotes/General/ValidateAppStoreReceipt/Chapters/ValidateRemotely.html
func (r *Receipt) GetStatus() int {
	return r.Status
}

func (r *Receipt) GetEnvironment() string {
	return r.Environment
}

// LatestReceiptString returns raw receipt of `latest_receipt`
func (r *Receipt) LatestReceiptString() string {
	return r.LatestReceipt
}

// IsValidReceipt checks this receipt is valid receipt or not
// if this receipt is auto-renewable and iOS6 style, expired one returns false
func (r *Receipt) IsValidReceipt() bool {
	return r.Status == 0
}

// IsAutoRenewable checks this receipt is auto-renewable subscription or not
func (r *Receipt) IsAutoRenewable() bool {
	return r.InApps.IsAutoRenewable()
}

func (r *Receipt) HasError() error {
	return HandleError(r.Status)
}

// HasExpired checks this receipt is expired or not (only for iOS6 style)
func (r *Receipt) HasExpired() bool {
	return r.Status == 21006
}

// ShouldSendToTestEnvironment checks this receipt status is 21007
// this receipt is from the test environment, but it was sent to the production environment for verification
func (r *Receipt) ShouldSendToTestEnvironment() bool {
	return r.Status == 21007
}

// ShouldSendToProductionEnvironment checks this receipt status is 21008
// this receipt is from the production environment, but it was sent to the test environment for verification
func (r *Receipt) ShouldSendToProductionEnvironment() bool {
	return r.Status == 21008
}

// GetTransactionIDs returns all of transaction_id from `in_app`
func (r *Receipt) GetTransactionIDs() []int64 {
	return r.InApps.TransactionIDs()
}

// GetTransactionIDsByProduct returns all of transaction_id from `in_app` filtered by `product_id`
func (r *Receipt) GetTransactionIDsByProduct(product string) []int64 {
	checked := make(map[int64]bool)
	var matched []int64
	latest := r.LatestReceiptInfo.LastExpiresByProductIDForLatest(product)
	if latest != nil {
		txID := latest.TransactionID
		checked[txID] = true
		matched = append(matched, txID)
	}

	for _, v := range r.InApps {
		txID := v.TransactionID
		if checked[txID] {
			continue
		}
		checked[txID] = true
		if v.ProductID != product {
			continue
		}
		matched = append(matched, txID)
	}
	return matched
}

// GetTransactionIDsWithoutExpired returns all of transaction_id except expired
func (r *Receipt) GetTransactionIDsWithoutExpired() []int64 {
	checked := make(map[int64]bool)
	now := time.Now()
	var matched []int64
	matchedIDs := func(rc ReceiptInApps) {
		for _, v := range rc {
			if checked[v.TransactionID] {
				continue
			}
			checked[v.TransactionID] = true

			switch {
			case !v.ExpiresDate.IsZero() && v.ExpiresDate.Before(now):
				continue
			}
			matched = append(matched, v.TransactionID)
		}
	}
	matchedIDs(r.InApps)
	matchedIDs(r.LatestReceiptInfo)
	return matched
}

// GetTransactionIDsByProductWithoutExpired returns all of transaction_id filtered by `product_id` except expired
func (r *Receipt) GetTransactionIDsByProductWithoutExpired(product string) []int64 {
	checked := make(map[int64]bool)
	now := time.Now()
	var matched []int64
	matchedIDs := func(rc ReceiptInApps) {
		for _, v := range rc {
			if checked[v.TransactionID] {
				continue
			}
			checked[v.TransactionID] = true

			switch {
			case v.ProductID != product:
				continue
			case !v.ExpiresDate.IsZero() && v.ExpiresDate.Before(now):
				continue
			}
			matched = append(matched, v.TransactionID)
		}
	}
	matchedIDs(r.InApps)
	matchedIDs(r.LatestReceiptInfo)
	return matched
}

// GetByTransactionID returns receipt data by `transaction_id`
func (r *Receipt) GetByTransactionID(id int64) *ReceiptInApp {
	return r.InApps.ByTransactionID(id)
}

// GetLastExpiresByProductID returns latest expires receipt data by `product_id`
func (r *Receipt) GetLastExpiresByProductID(productID string) *ReceiptInApp {
	inAppLatest := r.LatestReceiptInfo.LastExpiresByProductIDForLatest(productID)
	inApp := r.InApps.LastExpiresByProductID(productID)
	switch {
	case inApp == nil:
		return inAppLatest
	case inAppLatest == nil:
		return inApp
	case inApp.ExpiresDate.After(inAppLatest.ExpiresDate):
		return inApp
	}
	return inAppLatest
}

// GetLastExpiresByTransactionIDs returns latest expires receipt data from `transaction_id` list
func (r *Receipt) GetLastExpiresByTransactionIDs(ids []int64) *ReceiptInApp {
	inAppLatest := r.LatestReceiptInfo.LastExpiresByTransactionIDsForLatest(ids)
	inApp := r.InApps.LastExpiresByTransactionIDs(ids)
	switch {
	case inApp == nil:
		return inAppLatest
	case inAppLatest == nil:
		return inApp
	case inApp.ExpiresDate.After(inAppLatest.ExpiresDate):
		return inApp
	}
	return inAppLatest
}

repository: evalphobia/go-iap

repo_name: evalphobia/go-iap


text:
#ifndef ROUTING_TESTING_H
#define ROUTING_TESTING_H

#define TEST_CONFIG_PATH "../config/test_application.properties"

#include <gtest/gtest.h>
#include <spdlog/fmt/ostr.h>

#include <ostream>
#include <system_error>

// std::string const Config_constant::k_config_path =
//
//
namespace routing
{

#define EXPECT_ERROR_CODE(ec, msg) EXPECT_FALSE(ec) << msg \
    << " failed due to: " << ec.message()

inline void
expect_error_code(std::error_code ec, std::string const& msg)
{
    EXPECT_FALSE(ec) << msg << "failed due to : " <<  ec.message();
}

struct Source_location
{
     char const* file;
     char const* function;
     int line;
};

#define SOURCE_LOCATION() \
    Source_location{__FILE__, __PRETTY_FUNCTION__, __LINE__}

#define DEFINED(name) \
    fmt::format("{} defined at {}", name, SOURCE_LOCATION())

inline std::ostream&
operator<<(std::ostream& oss, Source_location source_location)
{
    oss << source_location.file << ":" << source_location.function << ":"
        << source_location.line;

    return oss;
}

}

#endif

repository: honzatran/llvm-message-routing

repo_name: honzatran/llvm-message-routing

extension: h


text:
// +build devtest

package main

import (
	"fmt"
	"github.com/GeoNet/fits/dapper/dapperlib"
	"log"
	"os"
	"time"
)

var fhStream = os.Getenv("DAPPER_FH_STREAM")

func main() {
	sc, err := dapperlib.NewSendClient(fhStream)

	if err != nil {
		log.Fatalf("failed to create dapper SendClient: %v", err)
	}

	now := time.Now().Truncate(time.Minute)

	vals := make([]dapperlib.Record, 0)

	dmns := []string{
		"datalogger",
		"fdmp",
		"geodetic",
	}

	keys := []string{
		"logger-temaari",
		"cellular-whakari",
		"RHCD",
	}

	fields := []string{
		"temperature",
		"voltage",
		"ping",
		"ssam",
	}

	for _, d := range dmns {
		for _, k := range keys {
			for _, f := range fields {
				for i := 0; i <= 60; i++ {
					t := now.Add(-time.Minute * time.Duration(i))

					vals = append(vals, dapperlib.Record{
						Domain: d,
						Key:    k,
						Field:  f,
						Time:   t,
						Value:  fmt.Sprintf("%v", i),
					})
				}
			}
		}
	}

	err = sc.Send(vals)
	if err != nil {
		log.Fatalf("failed to send: %v", err)
	}
}

repository: kellettR/fits

repo_name: kellettR/fits


text:
package cloudesl

//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//
//http://www.apache.org/licenses/LICENSE-2.0
//
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
//
// Code generated by Alibaba Cloud SDK Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

// EslDeviceInfo is a nested struct in cloudesl response
type EslDeviceInfo struct {
	CompanyId           string `json:"CompanyId" xml:"CompanyId"`
	StoreId             string `json:"StoreId" xml:"StoreId"`
	Mac                 string `json:"Mac" xml:"Mac"`
	EslBarCode          string `json:"EslBarCode" xml:"EslBarCode"`
	ItemBarCode         string `json:"ItemBarCode" xml:"ItemBarCode"`
	Vendor              string `json:"Vendor" xml:"Vendor"`
	ConnectAp           string `json:"ConnectAp" xml:"ConnectAp"`
	Type                string `json:"Type" xml:"Type"`
	Model               string `json:"Model" xml:"Model"`
	BeBind              string `json:"BeBind" xml:"BeBind"`
	ScreenWidth         string `json:"ScreenWidth" xml:"ScreenWidth"`
	ScreenHeight        string `json:"ScreenHeight" xml:"ScreenHeight"`
	LastCommunicateTime string `json:"LastCommunicateTime" xml:"LastCommunicateTime"`
	BatteryLevel        int    `json:"BatteryLevel" xml:"BatteryLevel"`
	EslStatus           string `json:"EslStatus" xml:"EslStatus"`
	ShelfCode           string `json:"ShelfCode" xml:"ShelfCode"`
	PositionCode        string `json:"PositionCode" xml:"PositionCode"`
	ItemId              int    `json:"ItemId" xml:"ItemId"`
	ItemTitle           string `json:"ItemTitle" xml:"ItemTitle"`
	ItemActionPrice     int    `json:"ItemActionPrice" xml:"ItemActionPrice"`
	ItemPriceUnit       string `json:"ItemPriceUnit" xml:"ItemPriceUnit"`
}


text:
@misc{erkok2019sbv,
	author = {Erk{\"o}k, L},
	title = {{SBV: SMT based verification in Haskell}},
	howpublished = "Software library",
	year = {2019}
}

@inproceedings{Marlowe:2018,
	Author = {Lamela Seijas, Pablo and Thompson, Simon},
	Booktitle = {Leveraging Applications of Formal Methods, Verification and Validation. Industrial Practice. ISoLA 2018.},
	Publisher = {Springer},
	Title = {Marlowe: Financial Contracts on Blockchain},
	Year = {2018}}

@misc{marlowe2020,
	author = {{Lamela Seijas}, Pablo and Nemish, Alexander and Smith, David and Thompson, Simon},
	title = {Marlowe: implementing and analysing financial contracts on blockchain},
	year = {2020},
	howpublished = "Workshop on Trusted Smart Contracts, to appear",
}

@inproceedings{gulwani2008program,
	author = {Gulwani, Sumit and Srivastava, Saurabh and Venkatesan, Ramarathnam},
	booktitle = {Proceedings of the 29th ACM SIGPLAN Conference PLDI},
	title = {Program analysis as constraint solving},
	year = {2008}
}

@article{jackson2000finding,
	author = {Jackson, Daniel and Vaziri, Mandana},
	journal = {ACM SIGSOFT Software Engineering Notes},
	number = {5},
	publisher = {ACM New York, NY, USA},
	title = {Finding bugs with a constraint solver},
	volume = {25},
	year = {2000}
}

@inproceedings{clarke2004tool,
	author = {Clarke, Edmund and Kroening, Daniel and Lerda, Flavio},
	booktitle = {International Conference on Tools and Algorithms for the Construction and Analysis of Systems},
	organization = {Springer},
	title = {{A tool for checking ANSI-C programs}},
	year = {2004}
}

@book{nipkow2002isabelle,
	author = {Nipkow, Tobias and Paulson, Lawrence C and Wenzel, Markus},
	publisher = {Springer Science \& Business Media},
	title = {{Isabelle/HOL: a proof assistant for higher-order logic}},
	volume = {2283},
	year = {2002}
}

@inproceedings{mokhov2019formal,
	author = {Mokhov, Andrey and Lukyanov, Georgy and Lechner, Jakob},
	booktitle = {Proceedings of the 12th ACM SIGPLAN International Symposium on Haskell},
	title = {Formal verification of spacecraft control programs (experience report)},
	year = {2019}
}

@inproceedings{xie2005saturn,
	author = {Xie, Yichen and Aiken, Alex},
	booktitle = {International Conference on Computer Aided Verification},
	organization = {Springer},
	title = {{Saturn: A SAT-based tool for bug detection}},
	year = {2005}
}

@inproceedings{ball2001automatically,
	author = {Ball, Thomas and Rajamani, Sriram K},
	booktitle = {SPIN Workshop on Model Checking of Software},
	organization = {Springer},
	title = {Automatically validating temporal safety properties of interfaces},
	year = {2001}
}

@inproceedings{keshishzadeh2013early,
	author = {Keshishzadeh, Sarmen and Mooij, Arjan J and Mousavi, Mohammad Reza},
	booktitle = {International Conference on Software Engineering and Formal Methods},
	organization = {Springer},
	title = {{Early fault detection in DSLs using SMT solving and automated debugging}},
	year = {2013}
}

@misc{perf,
	howpublished = {\url{https://github.com/torvalds/linux/tree/master/tools/perf} [last visited 20-05-2020]},
	title = {{Performance analysis tools for Linux}}
}

@inproceedings{de2008z3,
	author = {{De Moura}, Leonardo and Bj{\o}rner, Nikolaj},
	booktitle = {Internat.\ Conf.\ on Tools and Algorithms for the Construction and Analysis of Systems},
	organization = {Springer},
	title = {{Z3: An efficient SMT solver}},
	year = {2008}
}

@misc{keppel1998gnu,
	author = {Keppel, David and MacKenzie, David and Juul, Arne Henrik and Pinard, Francois},
	howpublished = {\url{https://www.gnu.org/software/time/} [last visited 20-05-2020]},
	title = {{GNU} time tool},
	year = {1998}
}

@inproceedings{sheard2002template,
	author = {Sheard, Tim and Jones, Simon Peyton},
	booktitle = {Proceedings of the 2002 ACM SIGPLAN workshop on Haskell},
	title = {{Template meta-programming for Haskell}},
	year = {2002}
}

@inproceedings{barrett2010smt,
	author = {Barrett, Clark and Stump, Aaron and Tinelli, Cesare and others},
	booktitle = {{Proc.\ 8th International Workshop on Satisfiability Modulo Theories}},
	title = {{The SMT-LIB standard: Version 2.0}},
	year = {2010}
}

@article{quickcheck,
	author = {Claessen, Koen and Hughes, John},
	journal = {Proceedings of the ACM SIGPLAN International Conference on Functional Programming, ICFP},
	title = {{QuickCheck: A Lightweight Tool for Random Testing of {Haskell} Programs}},
	volume = {46},
	year = {2000}
}

repository: triggerNZ/marlowe

repo_name: triggerNZ/marlowe


text:
DESCRIPTION = "A SID Player for the Qt/Embedded based Palmtop Environments"
SECTION = "opie/multimedia"
PRIORITY = "optional"
LICENSE = "GPL"
HOMEPAGE = "http://sidplayer.sourceforge.net/"
DEPENDS = "libsidplay"
PR = "r1"

SRC_URI = "http://sidplayer.sourceforge.net/sidplayer.tar.gz \
           file://use-external-libsidplay.patch \
           file://gcc3.patch \
	   file://gcc34.patch"
S = "${WORKDIR}/sidplayer"

EXTRA_QMAKEVARS_POST += "INCLUDEPATH+=${STAGING_INCDIR}/sidplay"

inherit palmtop

do_install() {
        install -d ${D}${palmtopdir}/bin \
        	   ${D}${palmtopdir}/apps/Applications \
        	   ${D}${palmtopdir}/pics
	cp -pPR ../apps ../bin ../pics ${D}${palmtopdir}/
}

SRC_URI[md5sum] = "bba4a99e59581066e905c9326a724ba5"
SRC_URI[sha256sum] = "bc6bfd100c495e74baa651c470252484b19bfc2e6fa8520f591b0c01b9fcfb5d"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
---
---

@INPROCEEDINGS{DSK2021a,
	abbr		= {KONVENS},
	author	= {Niclas Hildebrandt and Benedikt Bönninghoff and Dennis Orth and Christopher Schymura},
	booktitle	= {Konferenz zur Verarbeitung natürlicher Sprache/Conference on Natural Language Processing (KONVENS)},
	publisher = {German Society for Computational Linguistics & Language Technology},
	title	= {Data Science Kitchen at GermEval 2021: A Fine Selection of Hand-Picked Features, Delivered Fresh from the Oven},
	year		= {2021},
	abstract	= {This paper presents the contribution of the Data Science Kitchen at GermEval 2021 shared task on the identification of toxic, engaging, and fact-claiming comments. The task aims at extending the identification of offensive language, by including additional subtasks that identify comments which should be prioritized for fact-checking by moderators and community managers. Our contribution focuses on a feature-engineering approach with a conventional classification backend. We combine semantic and writing style embeddings derived from pre-trained deep neural networks with additional numerical features, specifically designed for this task. Ensembles of Logistic Regression classifiers and Support Vector Machines are used to derive predictions for each subtask via a majority voting scheme. Our best submission achieved macro-averaged F1-scores of 66.8%, 69.9% and 72.5% for the identification of toxic, engaging, and fact-claiming comments.},
	pdf		= {https://netlibrary.aau.at/obvukloa/content/pageview/6435304}
}

@inproceedings{Orth2017b,
author = {Orth, Dennis and Sch{\"{o}}mig, Nadja and Mark, Christian and Jagiellowicz-Kaufmann, Monika and Kolossa, Dorothea and Heckmann, Martin},
booktitle = {Proceedings of the 9th International Conference on Automotive User Interfaces and Interactive Vehicular Applications - AutomotiveUI '17},
doi = {10.1145/3122986.3123004},
keywords = {ADAS,Critical gap,Gap acceptance,Personalization,Speech-based},
pages = {193--201},
publisher = {ACM Press},
title = {Benefits of Personalization in the Context of a Speech-Based Left-Turn Assistant},
year = {2017},
pdf = {https://www.honda-ri.de/pubs/pdf/3499.pdf},
abstract = {We have previously introduced a novel Assistance On Demand (AOD) concept in the context of an urban speech-based left-turn assistant which supports the driver in monitoring and decision making by providing recommendations for suitable time gaps to enter the intersection. In a first user study participants showed a clear preference for the AOD system, yet also frequently mentioned that the recommended gaps did not fit their driving behavior. In the user study we present here, we investigate in how far the acceptance and efficiency of the AOD system can be increased by a personalization of the recommended gaps to the individual driver. For this purpose, we estimate individual drivers’ gap acceptance from observations of their manual driving and use it to evaluate a default and a personalized variant of the AOD system. Results reveal a clear preference for the personalized assistant compared to the default one and to driving manually.}
}

@inproceedings{Orth2017a,
address = {Yokohama, Japan},
author = {Orth, Dennis and Kolossa, Dorothea and Heckmann, Martin},
booktitle = {IEEE International Conference on Intelligent Transportation Systems (ITSC)},
doi = {10.1109/ITSC.2017.8317721},
pages = {1121--1126},
publisher = {IEEE},
title = {Predicting Driver Left-Turn Behavior from Few Training Samples using a Maximum A-Posteriori Method},
year = {2017},
pdf = {https://ieeexplore.ieee.org/document/8317721},
abstract = {In this work, we introduce a novel maximum a posteriori (MAP) method, which can predict driver left-turn behavior from only a few training samples. For the prediction of the driver behavior in this scenario we utilize the so-called critical gap. It signifies how large a gap minimally has to be for the driver to accept it and take the turn. The latter is especially important for the personalization of an intersection assistant, which we are currently developing. In contrast to Troutbeck's critical gap estimation method, we define a likelihood over all observable accepted and rejected gaps, thus we provide a model that does not require the driver to behave consistently. Subsequently, we extend it to a MAP estimation by incorporating prior knowledge of the critical gap. Using this approach, we obtain a maximum prediction error of 13.8% if only one training sample is used, which is a relative improvement of 35.2% compared to Troutbeck's method.}
}

@inproceedings{Orth2017c,
address = {Redondo Beach, CA, USA},
author = {Orth, Dennis and Kolossa, Dorothea and Paja, Milton Sarria and Schaller, Kersten and Pech, Andreas and Heckmann, Martin},
booktitle = {IEEE Intelligent Vehicles Symposium (IV)},
doi = {10.1109/IVS.2017.7995776},
pages = {553--558},
publisher = {IEEE},
title = {A Maximum Likelihood Method for Driver-Specific Critical-Gap Estimation},
year = {2017},
pdf = {https://ieeexplore.ieee.org/document/7995776},
abstract = {In this work, we introduce a maximum likelihood (ML) method to estimate the smallest accepted gap of a specific driver, the so-called critical gap. Previous methods, like Troutbeck's or Raff's method, are well known and widely used but require a consistently behaving driver, which is usually not met. The methods will be investigated for the personalization of an intersection assistant, which we are currently developing. We start with the hypothesis that the size that constitutes an acceptable gap is driver-dependent. To test this hypothesis, we have performed a simulator study with 9 participants. The results reveal that there is a significant inter-individual difference in the critical gap between the drivers, as postulated. Next we investigate how well we can predict which gap the driver will take when we use the previously estimated personalized critical gap versus a driver independent one. Using the personalized gap compared to a driver independent one reduces the error from 11.8 % to 9 8 %. These results are a clear indication that personalization can be utilized to increase the effectiveness and usability of an intersection assistant.}
}

@inproceedings{Heckmann2020,
author = {Heckmann, Martin and Orth, Dennis and Kolossa, Dorothea},
title = {Method for Assisting a Driver of an Ego-Vehicle in Making Use of a Gap Between Vehicles, Corresponding Driver Assistance System and Vehicle Equipped with such Driving Assistance System},
year = {2020},
publisher={Google Patents},
url = {https://www.freepatentsonline.com/y2020/0160077.html},
booktitle = {United States Patent Application 20200160077},
abstract = {A method for assisting a driver of an ego-vehicle in making use of a gap between vehicles to enter a traffic flow at an intersection is suggested, comprising the following method steps: First, other vehicles in the environment of the ego-vehicle are physically sensed using at least one environment sensor mounted on the ego-vehicle. Second, a gap size of at least one gap between two successive vehicles are calculated in a processor based on the sensor's/sensors' output. An ego-vehicle driver's gazing behavior using at least one driver sensor mounted on the ego-vehicle is observed and analyzed and an assistance signal is generated based on the result of the analysis and the determined size of the at least one gap. Finally, a recommendation or warning perceivable for the ego-vehicle's driver is output in accordance with the assistance signal.}
}

@article{Heckmann2017,
author = {Heckmann, Martin and Orth, Dennis and Wersing, Heiko and Kolossa, Dorothea},
doi = {10.1007/s38311-017-0021-4},
issn = {2192-9076},
journal = {ATZ worldwide},
number = {5},
pages = {36--41},
title = {Development of a personalised intersection assistant},
volume = {119},
year = {2017},
pdf = {https://ipg-automotive.com/fileadmin/user_upload/content/Download/PDF/Articles/1705_ATZworldwide_HondaResearchInstitute_Development_of_a_Personalised_Intersection_Assistant_EN.pdf},
abstract = {Advanced driver assistance systems have great potential to significantly improve the safety and comfort of driving. Honda Research Institute Europe and Ruhr University Bochum show how personalisation could improve the acceptance and impact of driver assistance functions by using an intuitive and speech-based intersection assistant.}
}

@inproceedings{Heckmann2019,
address = {Utrecht, Netherlands},
author = {Heckmann, Martin and Orth, Dennis and Dunn, Mark and Steinhardt, Nico and Bolder, Bram and Kolossa, Dorothea},
booktitle = {Proceedings of the 11th International Conference on Automotive User Interfaces and Interactive Vehicular Applications Adjunct Proceedings - AutomotiveUI '19},
doi = {10.1145/3349263.3349599},
isbn = {9781450369206},
pages = {483--488},
publisher = {ACM Press},
title = {CORA, a prototype for a cooperative speech-based on-demand intersection assistant},
year = {2019},
pdf = {https://dl.acm.org/doi/10.1145/3349263.3349599},
abstract = {We present the first speech-based advanced driver assistance prototype. It is based on our previously proposed on-demand communication concept for the interaction between the driver and his or her vehicle. Using this concept, drivers can flexibly activate the system via speech whenever they want to receive assistance. We could show via driver simulator studies that an instantiation of this concept as an intersection assistant, supporting the driver in turning left, was well received by drivers and preferred to an alternative, vision-based system. In this paper, we present a prototype implementation and give details on how we adapted it to the intricacy of urban traffic as well as to the shortcomings of current sensor technology in establishing an adequate environment perception. The accompanying video gives an impression of the interaction between the driver and the system when cooperatively turning left from a subordinate road into crossing traffic.}
}

@inproceedings{Orth,
address = {Changshu, Suzhou, China},
author = {Orth, Dennis and Bolder, Bram and Steinhardt, Nico and Dunn, Mark and Kolossa, Dorothea and Heckmann, Martin},
booktitle = {IEEE Intelligent Vehicles Symposium (IV)},
doi = {10.1109/IVS.2018.8500402},
isbn = {9781538644515},
pages = {2048--2053},
title = {A Speech-Based On-Demand Intersection Assistant Prototype},
year = {2018},
abstract = {We have recently proposed a speech-based on- demand intersection assistant which helps the driver to handle urban intersections by informing him of the traffic situation on the right hand side and recommending suitable gaps in traffic. In a previous user study, conducted in a simulator, we could show that the system is in general well accepted and preferred by drivers compared to driving without assistance or with only visual support. In this paper, we report on an implementation of this system and its evaluation in real urban traffic. We use LIDAR sensors for the perception of the traffic environment. A scene analyzer estimates the gaps between the vehicles in real time. The result of this analysis is provided to a dialog manager, which uses it to inform the driver of approaching vehicles and suitable gaps. While approaching the intersection, the driver can activate the system via a wake-up-word and control it with subsequent speech commands. The design of the data analyzer and dialog manager is based on evaluations at real intersections. The resulting system can provide suitable support to the driver in a wide range of traffic situations.},
pdf = {https://ieeexplore.ieee.org/document/8500402}
}

@inproceedings{Orth2018,
address = {Maui, Hawaii, USA},
author = {Orth, Dennis and Steinhardt, Nico and Bolder, Bram and Dunn, Mark and Kolossa, Dorothea and Heckmann, Martin},
booktitle = {IEEE International Conference on Intelligent Transportation Systems (ITSC)},
doi = {10.1109/ITSC.2018.8569821},
isbn = {978-1-7281-0321-1},
pages = {1273--1278},
publisher = {IEEE},
title = {Analysis of a Speech-Based Intersection Assistant in Real Urban Traffic},
year = {2018},
abstract = {Previously, we have presented a speech-based intersection assistant prototype. The system is activated on-demand by the driver and gives afterwards, via speech, information on suitable gaps between the traffic vehicles approaching from the right. It is comparable to a front seat passenger which helps in the maneuver decision for an intended turn left. This system has assumed a more or less constant flow of the traffic. To also handle situations of more dynamic urban traffic, including vehicles that may be slowing down or stopping, we have now extended our previous approach by a dynamic vehicle model. This model predicts the future traffic vehicle state based on second-order vehicle dynamics. We perform an in depth analysis of our system on a set of recordings under various traffic conditions. In this analysis we compare in particular the previous and the novel vehicle model. Both approaches lead to a correct recommendation in approximately 90% of the cases. Unexpectedly, the dynamic model does not lead to significant improvements in the system behavior, despite its increased accuracy.},
pdf = {https://ieeexplore.ieee.org/document/8569821}
}

@inproceedings{Acl2018,
address = {Oldenburg, Germany},
author = {Heckmann, Martin and Orth, Dennis and Kolossa, Dorothea},
booktitle = {Speech Communication; 13th ITG-Symposium},
isbn = {9783800747672},
pages = {326--330},
publisher = {VDE},
title = {"Gap After the Next Two Vehicles": A Spatio-temporally Situated Dialog for a Cooperative Driving Assistant},
year = {2018},
abstract = {We present a spatio-temporally situated dialog that is implemented in a driver assistance system. The system supports the driver in turning left at a busy urban intersection by providing verbal information on the vehicles arriving from the right. This is a highly dynamic scenario, as the location of the vehicles significantly changes while the system is referring to them. Consequently, the time the system needs for producing the utterances and the time drivers need to comprehend them and prepare their action has to be taken into account in the dialog management. We introduce a dialog concept, which predicts the future traffic participants state and plans the utterances such that they align with the driver's expectations. We have implemented and evaluated this system in a prototype vehicle.},
pdf = {https://ieeexplore.ieee.org/document/8578048}
}


text:
# Copyright (C) 2015 Khem Raj <raj.khem@gmail.com>
# Released under the MIT license (see COPYING.MIT for the terms)

DESCRIPTION = "libc++ is a new implementation of the C++ standard library, targeting C++11"
HOMEPAGE = "http://libcxx.llvm.org/"
SECTION = "base"

require clang.inc
require common-source.inc

inherit cmake pythonnative

DEPENDS += "ninja-native"
BASEDEPENDS_remove_toolchain-clang = "libcxx"
DEPENDS_append_toolchain-clang = " virtual/${TARGET_PREFIX}compilerlibs"

TARGET_CXXFLAGS_remove_toolchain-clang = "--stdlib=libc++"
TUNE_CCARGS_remove_toolchain-clang = "--unwindlib=libunwind --stdlib=libc++"

PACKAGECONFIG ??= "${@bb.utils.contains('PREFERRED_PROVIDER_libunwind', 'libcxx', 'unwind', '', d)}"
PACKAGECONFIG_powerpc = ""
PACKAGECONFIG_riscv64 = ""
PACKAGECONFIG_riscv32 = ""

PACKAGECONFIG[unwind] = "-DLIBCXXABI_USE_LLVM_UNWINDER=ON -DLIBUNWIND_ENABLE_SHARED=ON -DLIBCXXABI_ENABLE_STATIC_UNWINDER=ON -DLIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY=OFF -DLIBCXXABI_LIBUNWIND_INCLUDES=${S}/projects/libunwind/include, -DLIBCXXABI_USE_LLVM_UNWINDER=OFF -DCMAKE_SHARED_LINKER_FLAGS='-lgcc_s',"

PROVIDES += "${@bb.utils.contains('PACKAGECONFIG', 'unwind', 'libunwind', '', d)}"
LIBUNWIND = "${@bb.utils.contains('PACKAGECONFIG', 'unwind', ';libunwind', '', d)}"

LIC_FILES_CHKSUM = "file://libcxx/LICENSE.TXT;md5=55d89dd7eec8d3b4204b680e27da3953 \
                    file://libcxxabi/LICENSE.TXT;md5=7b9334635b542c56868400a46b272b1e \
                    file://libunwind/LICENSE.TXT;md5=f66970035d12f196030658b11725e1a1 \
"
THUMB_TUNE_CCARGS = ""
#TUNE_CCARGS += "-nostdlib"

EXTRA_OECMAKE += "\
                  -DCMAKE_CROSSCOMPILING=ON \
                  -DLIBCXX_CXX_ABI=libcxxabi \
                  -DLIBCXX_USE_COMPILER_RT=ON \
                  -DLIBCXXABI_USE_COMPILER_RT=ON \
                  -DLIBCXX_INSTALL_EXPERIMENTAL_LIBRARY=ON \
                  -DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON \
                  -DLIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY=OFF \
                  -DLIBCXXABI_LIBCXX_INCLUDES=${S}/libcxx/include \
                  -DLIBCXX_CXX_ABI_INCLUDE_PATHS=${S}/libcxxabi/include \
                  -DLIBCXX_CXX_ABI_LIBRARY_PATH=${B}/lib \
                  -DCMAKE_AR=${STAGING_BINDIR_TOOLCHAIN}/${AR} \
                  -DCMAKE_NM=${STAGING_BINDIR_TOOLCHAIN}/${NM} \
                  -DCMAKE_RANLIB=${STAGING_BINDIR_TOOLCHAIN}/${RANLIB} \
                  -DLLVM_ENABLE_PROJECTS='libcxx;libcxxabi${LIBUNWIND}' \
                  -G Ninja \
                  ${S}/llvm \
"

EXTRA_OECMAKE_append_class-native = " -DLIBCXX_ENABLE_ABI_LINKER_SCRIPT=OFF"
EXTRA_OECMAKE_append_class-nativesdk = " -DLIBCXX_ENABLE_ABI_LINKER_SCRIPT=OFF"
EXTRA_OECMAKE_append_libc-musl = " -DLIBCXX_HAS_MUSL_LIBC=ON "
EXTRA_OECMAKE_append_riscv64 = " -DLIBCXXABI_ENABLE_EXCEPTIONS=ON \
                                 -DLIBCXX_ENABLE_EXCEPTIONS=ON \
                                 -DLIBOMP_LIBFLAGS='-latomic' \
                                 -DCMAKE_SHARED_LINKER_FLAGS='-lgcc_s -latomic' \
                                 "

EXTRA_OECMAKE_append_armv5 = " -D_LIBCXXABI_HAS_ATOMIC_BUILTINS=OFF"

EXTRA_OECMAKE_append_arm = " -DCMAKE_REQUIRED_FLAGS='-fno-exceptions'"

EXTRA_OECMAKE_append_riscv32 = " -DLIBCXXABI_ENABLE_EXCEPTIONS=ON \
                                 -DLIBCXX_ENABLE_EXCEPTIONS=ON \
                                 -DLIBOMP_LIBFLAGS='-latomic' \
                                 -DCMAKE_SHARED_LINKER_FLAGS='-lgcc_s -latomic' \
                                 "
EXTRA_OECMAKE_append_powerpc = " -DLIBCXXABI_ENABLE_EXCEPTIONS=ON \
                                 -DLIBCXX_ENABLE_EXCEPTIONS=ON \
                                 -DLIBOMP_LIBFLAGS='-latomic' \
                                 -DCMAKE_SHARED_LINKER_FLAGS='-lgcc_s -latomic' \
                                 "
do_compile() {
    if ${@bb.utils.contains('PACKAGECONFIG', 'unwind', 'true', 'false', d)}; then
        ninja -v ${PARALLEL_MAKE} unwind
    fi
    ninja -v ${PARALLEL_MAKE} cxxabi
    ninja -v ${PARALLEL_MAKE} cxx
}

do_install() {
    if ${@bb.utils.contains('PACKAGECONFIG', 'unwind', 'true', 'false', d)}; then
        DESTDIR=${D} ninja ${PARALLEL_MAKE} install-unwind
    fi
    DESTDIR=${D} ninja ${PARALLEL_MAKE} install-cxx install-cxxabi
}

ALLOW_EMPTY_${PN} = "1"

RPROVIDES_${PN} += "${@bb.utils.contains('PACKAGECONFIG', 'unwind', 'libunwind', '', d)}"
RPROVIDES_${PN}-dbg += "${@bb.utils.contains('PACKAGECONFIG', 'unwind', 'libunwind-dbg', '', d)}"
RPROVIDES_${PN}-dev += "${@bb.utils.contains('PACKAGECONFIG', 'unwind', 'libunwind-dev', '', d)}"
RPROVIDES_${PN}-doc += "${@bb.utils.contains('PACKAGECONFIG', 'unwind', 'libunwind-doc', '', d)}"
RPROVIDES_${PN}-staticdev += "${@bb.utils.contains('PACKAGECONFIG', 'unwind', 'libunwind-staticdev', '', d)}"
RPROVIDES_${PN}-locale += "${@bb.utils.contains('PACKAGECONFIG', 'unwind', 'libunwind-locale', '', d)}"
RPROVIDES_${PN}-src += "${@bb.utils.contains('PACKAGECONFIG', 'unwind', 'libunwind-src', '', d)}"

PACKAGES_DYNAMIC += "${@bb.utils.contains('PACKAGECONFIG', 'unwind', '^libunwind-locale-.*', '', d)}"

BBCLASSEXTEND = "native nativesdk"
TOOLCHAIN = "clang"

repository: dwrobel/meta-clang

repo_name: dwrobel/meta-clang


text:
/*

You are given a positive integer N. You have to print exactly N+1 positive integers satisfying the following conditions:

Exactly one value should appear twice, all the remaining values should appear only once.
Sum of all these values should be equal to 2^N.
You have to print the values in non-decreasing order. If there are multiple solutions, you can print any of them.

Input Format

The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
The first and only line of each test case contains a single integer N.

Output Format

For each test case, print a single line containing N+1 positive integers in non-decreasing order that satisfy the given conditions. If there are multiple solutions, you may print any of them.

Constraints
1≤T≤60
1≤N≤60

*/

package main

import (
	"fmt"
)

func main() {
	test(1)
	test(3)
	test(4)
}

func assert(x bool) {
	if !x {
		panic("assertion failed")
	}
}

func test(n int) {
	p := values(n)
	fmt.Println(p)
	assert(len(p) == n+1)
	assert(sum(p) == 1<<n)
}

func sum(a []int) int {
	v := 0
	for i := range a {
		v += a[i]
	}
	return v
}

func values(n int) []int {
	r := []int{1}
	for i := 0; i < n; i++ {
		r = append(r, 1<<i)
	}
	return r
}

repository: qeedquan/challenges

repo_name: qeedquan/challenges


text:
package advent

import (
	"sort"
	"strconv"
	"strings"

	"github.com/mdwhatcott/advent-of-code-go-lib/util"
)

func Part1() int {
	var max int
	for _, line := range util.InputLines() {
		id := parseSeatID(line)
		if id > max {
			max = id
		}
	}
	return max
}

func Part2() interface{} {
	var all []int
	for _, line := range util.InputLines() {
		all = append(all, parseSeatID(line))
	}

	sort.Ints(all)

	for x := 1; x < len(all)-1; x++ {
		last := all[x-1]
		this := all[x]
		next := all[x+1]
		if last+1 != this {
			return last + 1
		}
		if this+1 != next {
			return this + 1
		}
	}
	panic("NOT FOUND")
}

func parseSeatID(raw string) int {
	raw = strings.ReplaceAll(raw, "F", "0")
	raw = strings.ReplaceAll(raw, "B", "1")
	raw = strings.ReplaceAll(raw, "L", "0")
	raw = strings.ReplaceAll(raw, "R", "1")
	parsed, _ := strconv.ParseInt(raw, 2, 16)
	return int(parsed)
}

repository: mdwhatcott/advent-of-code

repo_name: mdwhatcott/advent-of-code


text:
#include <iostream>
#include <vector>
#include <string>
using namespace std;

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if(strs.size() == 0)
            return "";

        string result = strs[0];
        for(string comp:strs)
        {
            int size = result.size();
            if(size == 0)
                return "";

            for(int i = 0; i < size; i++)
            {
                if(result[i] != comp[i])
                {
                    result = result.substr(0,i);
                    break;
                }
            }
        }
        return result;
    }
};

int main()
{
    Solution solution;
    auto test = [&](vector<string> strs)
    {
        string pre = solution.longestCommonPrefix(strs);
        cout << pre << endl;
    };

    test({"flower", "flow", "flight"});
    test({"dog", "racecar", "car"});

    return 0;
}

extension: cpp


text:
// Copyright (c) 2017 Uber Technologies, Inc.
//
// 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.

package aggregation

import (
	"testing"

	"github.com/m3db/m3/src/x/instrument"

	"github.com/stretchr/testify/require"
	yaml "gopkg.in/yaml.v2"
)

func TestTypesConfiguration(t *testing.T) {
	str := `
defaultGaugeAggregationTypes: [Max]
defaultTimerAggregationTypes:
  - P50
  - P99
  - P9999
counterTransformFnType: empty
timerTransformFnType: suffix
gaugeTransformFnType: empty
`

	var cfg TypesConfiguration
	require.NoError(t, yaml.Unmarshal([]byte(str), &cfg))
	opts, err := cfg.NewOptions(instrument.NewOptions())
	require.NoError(t, err)
	require.Equal(t, defaultDefaultCounterAggregationTypes, opts.DefaultCounterAggregationTypes())
	require.Equal(t, Types{Max}, opts.DefaultGaugeAggregationTypes())
	require.Equal(t, Types{P50, P99, P9999}, opts.DefaultTimerAggregationTypes())
	require.Equal(t, []byte(nil), opts.TypeStringForCounter(Mean))
	require.Equal(t, []byte(nil), opts.TypeStringForCounter(Sum))
	require.Equal(t, []byte(".sum"), opts.TypeStringForTimer(Sum))
	require.Equal(t, []byte(".mean"), opts.TypeStringForTimer(Mean))
	require.Equal(t, []byte(".p50"), opts.TypeStringForTimer(P50))
	require.Equal(t, []byte(".p999"), opts.TypeStringForTimer(P999))
	require.Equal(t, []byte(nil), opts.TypeStringForGauge(Last))
}

func TestTypesConfigurationNoTransformFnType(t *testing.T) {
	str := `
defaultGaugeAggregationTypes: [Max]
defaultTimerAggregationTypes:
  - P50
  - P99
  - P9999
`

	var cfg TypesConfiguration
	require.NoError(t, yaml.Unmarshal([]byte(str), &cfg))
	opts, err := cfg.NewOptions(instrument.NewOptions())
	require.NoError(t, err)
	require.Equal(t, []byte("mean"), opts.TypeStringForCounter(Mean))
	require.Equal(t, []byte("sum"), opts.TypeStringForCounter(Sum))
	require.Equal(t, []byte("sum"), opts.TypeStringForTimer(Sum))
	require.Equal(t, []byte("mean"), opts.TypeStringForTimer(Mean))
	require.Equal(t, []byte("p50"), opts.TypeStringForTimer(P50))
	require.Equal(t, []byte("p999"), opts.TypeStringForTimer(P999))
	require.Equal(t, []byte("last"), opts.TypeStringForGauge(Last))
}

func TestTypesConfigurationError(t *testing.T) {
	str := `
defaultGaugeAggregationTypes: [Max]
defaultTimerAggregationTypes:
  - P50
  - P99
  - P9999
timerTransformFnType: bla
`

	var cfg TypesConfiguration
	require.Error(t, yaml.Unmarshal([]byte(str), &cfg))
}


text:
@article{ankner,
 author = {Zachary Ankner and Naomi Saphra and Davis Blalock and Jonathan Frankle and Matthew L. Leavitt},
 journal = {arXiv preprint arXiv:2305.15096},
 title = {Dynamic Masking Rate Schedules for MLM Pretraining},
 year = {2023}
}


text:
SUMMARY = "decoding library for DTS Coherent Acoustics streams"
SECTION = "libs/multimedia"
LICENSE = "GPLv2+"
LIC_FILES_CHKSUM = "file://COPYING;md5=751419260aa954499f7abaabaa882bbe"
SRCREV = "2ee6732527a7cc7c0b972415eb6c5186e0410ff2"
PV = "0.0.6+git${SRCPV}"

SRC_URI = "git://code.videolan.org/videolan/${BPN}.git;protocol=https"

S = "${WORKDIR}/git"

inherit autotools lib_package pkgconfig

do_compile_prepend() {
        # single precision is enough and speeds up libdca by about 10-15%
        sed -i -e 's/double/sample_t/g' ${S}/libdca/*.c ${S}/libdca/*.h
}

repository: opendreambox/opendreambox

repo_name: opendreambox/opendreambox

branch_name: refs/heads/pyro

gha_language: BitBake


text:
@TECHREPORT{Itoh2002,
  author = {Takayuki Itoh and Yasumasa Kajinaga and Yuko Ikehata and Yumi Yamaguchi},
  title = {Data Jewelry Box: A Graphics Showcase for Large-Scale Hierarchical Data Visualization},
  institution = {IBM Research},
  year = {2002},
  number = {RT0427},
  abstract = {We see many kinds of large-scale hierarchical data in our daily lives, such as file systems of computers, company organizations, and category-based Web search sites such as Yahoo. Most of the GUIs for these data sources first represent a higher level of the data, and provide an interface so that users can select an interesting portion of the data and locally explore the lower levels. On the other hand, there are not many visualization techniques that give an overview of the data by placing all of the lower-level data onto a display region. How can we implement such a technique that represents all the data in one display, just like the showcases of a jewelry store displays all the jewels in the shop? That is the motivation of this research. The report presents a visualization technique that places all of the lowest-level portions of a hierarchical data set on a display space. It first groups icons that denote the lowest-level data, and then generates rectangles that enclose each group of icons. It repeats the process of generating rectangles that enclose the lower-level rectangles, until the highest-level rectangles are enclosed by the largest rectangle. To use the display space most reasonably, our technique efficiently searches for gaps where rectangles can be located without overlapping adjacent rectangles. We use Delaunay triangular meshes that connect the centers of the rectangles to quickly find the gaps.},
  url = {http://domino.research.ibm.com/library/cyberdig.nsf/1e4115aea78b6e7c85256b360066f0d4/65ee18867a4cf82385256b870028fa47}
}

repository: vis-au/treevisnet

repo_name: vis-au/treevisnet

gha_language: TeX


text:
// ************************************************************************** //
//                                                                            //
//                                                        :::      ::::::::   //
//   ex04.cpp                                           :+:      :+:    :+:   //
//                                                    +:+ +:+         +:+     //
//   By: anowak <anowak@student.42.fr>              +#+  +:+       +#+        //
//                                                +#+#+#+#+#+   +#+           //
//   Created: 2016/01/06 20:22:01 by anowak            #+#    #+#             //
//   Updated: 2016/01/06 20:28:32 by anowak           ###   ########.fr       //
//                                                                            //
// ************************************************************************** //

#include <iostream>
#include <string>

int	main() {
	std::string Hi = "HI THIS IS BRAIN";

	std::string* ptr = &Hi;
	std::string& ref = Hi;

	std::cout << "Showing ptr : " << *ptr << std::endl;
	std::cout << "Showing ref : " << ref << std::endl;
	return (0);
}

repository: NowakAydm/anowak

repo_name: NowakAydm/anowak


text:
package cmd

import (
	"fmt"
	"github.com/spf13/cobra"
	"github.com/virtualops/cli/pkg/config"
	"github.com/virtualops/cli/pkg/docker"
	"github.com/virtualops/cli/pkg/installer"
	"io"
	"os"
	"os/exec"
	"os/signal"
	"strings"
	"syscall"
)

var devCmd = &cobra.Command{
	Use: "dev",
	Run: func(cmd *cobra.Command, args []string) {
		installer.InstallOrVerifyTilt()
		installer.InstallOrVerifyHelm()
		buildDevFiles()
		buildK8sFiles()
		go removeDevFilesOnExit()
		RunTilt()
	},
}

func buildDevFiles() {
	os.Mkdir(".breezedev", 0777)

	switch Config.Build.GetPreset() {
	case "laravel":
		configuration, err := Config.Build.ToLaravel()

		if err != nil {
			panic(err)
		}

		buildLaravelFiles(configuration)
	}

	fmt.Println("Generated dev files")
}

func buildLaravelFiles(configuration *config.LaravelBuildConfiguration) {
	releaseName := Config.ReleaseName()
	dockerImageName := Config.ImageName()

	dockerfilePath := "Dockerfile"

	if f, err := os.Open(dockerfilePath); os.IsNotExist(err) {
		dockerfilePath = ".breezedev/Dockerfile"
		f, err := os.Create(dockerfilePath)

		if err != nil {
			fmt.Println("failed to create file", err)
		}
		dockerfile := &docker.Dockerfile{}
		dockerfile.Build(
			docker.PHP("7.4-fpm-alpine"),
			docker.Workdir("/var/www/html"),
			docker.Composer(),
			docker.Copy(".", "/var/www/html", docker.Chown("www-data", "www-data")),
			docker.ComposerAutoload,
			docker.Preload(),
		)
		f.WriteString(dockerfile.String())
		f.Close()
	} else {
		f.Close()
	}
	f, err := os.Create(".breezedev/nginx.Dockerfile")

	if err != nil {
		fmt.Println("failed to create file", err)
	}
	f.WriteString(config.NginxDockerfile)
	f.Close()

	f, err = os.Create(".breezedev/opcache.ini")
	f.WriteString(config.Opcache)
	f.Close()

	f, err = os.Create(".breezedev/preload.php")
	f.WriteString(config.PreloadClass)
	f.Close()

	f, err = os.Create(".breezedev/Tiltfile")
	f.WriteString(`k8s_yaml(helm(
  'kubernetes',
  name='` + releaseName + `',
  set=['image=` + dockerImageName + `', 'nginxImage=`)

	if configuration.Api {
		f.WriteString("nginx")
	} else {
		f.WriteString(dockerImageName + "-nginx")
	}

	paths := Config.Deploy.Paths

	if len(paths) == 0 {
		paths = append(paths, Config.Deploy.Path)
	}

	f.WriteString(`', 'ingress.paths={` + strings.Join(paths, ",") + `}']
))
docker_build('` + dockerImageName + `', '..', dockerfile='../` + dockerfilePath + `',ignore=['/vendor', '/node_modules'])
`)
	if !configuration.Api {
		f.WriteString(`docker_build('` + dockerImageName + `-nginx', '../public', dockerfile='nginx.Dockerfile')`)
	}
	f.Close()
}

func buildK8sFiles() {
	os.MkdirAll(".breezedev/kubernetes/templates", 0777)
	f, err := os.Create(".breezedev/kubernetes/templates/deployment.yaml")

	if err != nil {
		fmt.Println("failed to create file", err)
	}
	f.WriteString(config.Deployment)
	f.Close()

	f, err = os.Create(".breezedev/kubernetes/templates/service.yaml")

	if err != nil {
		fmt.Println("failed to create file", err)
	}
	f.WriteString(config.Service)
	f.Close()

	f, err = os.Create(".breezedev/kubernetes/templates/secret.yaml")

	if err != nil {
		fmt.Println("failed to create file", err)
	}
	f.WriteString(config.Secret)
	f.Close()

	f, err = os.Create(".breezedev/kubernetes/templates/nginx-config.yaml")

	if err != nil {
		fmt.Println("failed to create file", err)
	}
	f.WriteString(config.NginxConfig)
	f.Close()

	f, err = os.Create(".breezedev/kubernetes/templates/fpm-config.yaml")

	if err != nil {
		fmt.Println("failed to create file", err)
	}
	f.WriteString(config.FPMConfigMap)
	f.Close()

	f, err = os.Create(".breezedev/kubernetes/templates/ingress.yaml")

	if err != nil {
		fmt.Println("failed to create file", err)
	}
	f.WriteString(config.Ingress)
	f.Close()

	f, err = os.Create(".breezedev/kubernetes/Chart.yaml")

	if err != nil {
		fmt.Println("failed to create file", err)
	}
	f.WriteString(config.Chart)
	f.Close()
}

func RunTilt() {
	cmd := exec.Command("tilt", "up", "-f", ".breezedev/Tiltfile", "--port", "0")
	cmd.Stdout = io.MultiWriter(os.Stdout)
	err := cmd.Run()

	if err != nil {
		fmt.Println("Tilt failed", err.Error())
	}
}

func removeDevFilesOnExit() {
	c := make(chan os.Signal)
	signal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGKILL, syscall.SIGINT)
	<-c
	err := os.RemoveAll(".breezedev")
	if err != nil {
		fmt.Println(err)
	}
}

repository: virtualops/cli

repo_name: virtualops/cli


text:
@article{xiang2019comparative,
  title={A Comparative Study of High-Recall Real-Time Semantic Segmentation Based on Swift Factorized Network},
  author={Xiang, Kaite and Wang, Kaiwei and Yang, Kailun},
  journal={arXiv preprint arXiv:1907.11394},
  year={2019}
}


text:
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
  "CXX"
  )
# The set of files for implicit dependencies of each language:
set(CMAKE_DEPENDS_CHECK_CXX
  "/data/telloproject-BONYE/src/land.cpp" "/data/telloproject-BONYE/bin/CMakeFiles/TelloPro.dir/src/land.cpp.o"
  "/data/telloproject-BONYE/src/python_interface.cpp" "/data/telloproject-BONYE/bin/CMakeFiles/TelloPro.dir/src/python_interface.cpp.o"
  "/data/telloproject-BONYE/src/takeoff.cpp" "/data/telloproject-BONYE/bin/CMakeFiles/TelloPro.dir/src/takeoff.cpp.o"
  "/data/telloproject-BONYE/src/up.cpp" "/data/telloproject-BONYE/bin/CMakeFiles/TelloPro.dir/src/up.cpp.o"
  )
set(CMAKE_CXX_COMPILER_ID "GNU")

# The include file search paths:
set(CMAKE_CXX_TARGET_INCLUDE_PATH
  "/usr/include/python3.6m"
  "/usr/local/include"
  )

# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
  )

# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")


text:
SUMMARY = 'Class::Load - a working (require "Class::Name") and more'
AUTHOR = "Dave Rolsky <autarch@urth.org>"
HOMEPAGE = "https://metacpan.org/module/Class::Load"
SECTION = "libs"
LICENSE = "Artistic-1.0 | GPL-1.0+"
LIC_FILES_CHKSUM = "file://LICENSE;md5=d108ac5ca8319465973748e873c24653"

SRC_URI = "http://cpan.metacpan.org/authors/id/D/DR/DROLSKY/Class-Load-${PV}.tar.gz"
SRC_URI[md5sum] = "9ccb131338a6cf1318599c08c095cf72"
SRC_URI[sha256sum] = "823c45885e1d29feef6867282b881d402f42af6413c7e0e9f8fe32086aee8c20"

S = "${WORKDIR}/Class-Load-${PV}"

inherit cpan

RDEPENDS_${PN} += "perl-module-strict \
                   perl-module-warnings \
                   perl-module-carp \
                   libdata-optlist-perl \
                   libmodule-runtime-perl \
                   perl-module-scalar-util \
                   libtry-tiny-perl \
                   "

BBCLASSEXTEND = "native"


text:
package main

import (
	"github.com/orivej/go-nix/nix/eval"
	"github.com/orivej/go-nix/nix/parser"
	"log"
	"os"
)

func loadDepsNix(filePath string) map[string]*Package {
	ret := make(map[string]*Package)

	stat, err := os.Stat(filePath)
	if err != nil {
		return ret
	}
	if stat.Size() == 0 {
		return ret
	}

	p, err := parser.ParseFile(filePath)
	if err != nil {
		log.Println("Failed reading deps.nix")
		return ret
	}

	evalResult := eval.ParseResult(p)
	for _, pkgAttrsExpr := range evalResult.(eval.List) {
		pkgAttrs, ok := pkgAttrsExpr.Eval().(eval.Set)
		if !ok {
			continue
		}
		fetch, ok := pkgAttrs[eval.Intern("fetch")].Eval().(eval.Set)
		if !ok {
			continue
		}

		goPackagePath, ok := pkgAttrs[eval.Intern("goPackagePath")].Eval().(string)
		if !ok {
			continue
		}

		url, ok := fetch[eval.Intern("url")].Eval().(string)
		if !ok {
			continue
		}
		rev, ok := fetch[eval.Intern("rev")].Eval().(string)
		if !ok {
			continue
		}
		sha256, ok := fetch[eval.Intern("sha256")].Eval().(string)
		if !ok {
			continue
		}

		ret[goPackagePath] = &Package{
			GoPackagePath: goPackagePath,
			URL:           url,
			Rev:           rev,
			Sha256:        sha256,
		}
	}

	return ret
}