text:
package accessgrouprule

import (
	"sort"
	"time"

	"github.com/go-openapi/strfmt"
	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	runtimev1alpha1 "github.com/crossplane/crossplane-runtime/apis/core/v1alpha1"
	"github.com/crossplane/crossplane-runtime/pkg/logging"
	"github.com/crossplane/crossplane-runtime/pkg/reference"

	iamagv2 "github.com/IBM/platform-services-go-sdk/iamaccessgroupsv2"

	"github.com/crossplane-contrib/provider-ibm-cloud/apis/iamaccessgroupsv2/v1alpha1"
	ibmc "github.com/crossplane-contrib/provider-ibm-cloud/pkg/clients"
)

const (
	// StateActive represents an access group rule in a running, available, and ready state
	StateActive = "active"
	// StateInactive represents an inactive access group rule
	StateInactive = "inactive"
)

// LateInitializeSpec fills optional and unassigned fields with the values in *iamagv2.Rule object.
func LateInitializeSpec(spec *v1alpha1.AccessGroupRuleParameters, in *iamagv2.Rule) error { // nolint:gocyclo
	return nil
}

// GenerateAddAccessGroupRuleOptions produces AddAccessGroupRuleOptions object from AccessGroupRuleParameters object.
func GenerateAddAccessGroupRuleOptions(in v1alpha1.AccessGroupRuleParameters, o *iamagv2.AddAccessGroupRuleOptions) error {
	o.AccessGroupID = in.AccessGroupID
	o.TransactionID = in.TransactionID
	o.Conditions = GenerateSDKRuleConditions(in.Conditions)
	o.Expiration = ibmc.Int64Ptr(in.Expiration)
	o.Name = reference.ToPtrValue(in.Name)
	o.RealmName = reference.ToPtrValue(in.RealmName)
	return nil
}

// GenerateReplaceAccessGroupRuleOptions produces ReplaceAccessGroupRuleOptions object from AccessGroupRuleParameters object.
func GenerateReplaceAccessGroupRuleOptions(id, eTag string, in v1alpha1.AccessGroupRuleParameters, o *iamagv2.ReplaceAccessGroupRuleOptions) error {
	o.RuleID = reference.ToPtrValue(id)
	o.AccessGroupID = in.AccessGroupID
	o.TransactionID = in.TransactionID
	o.Conditions = GenerateSDKRuleConditions(in.Conditions)
	o.Expiration = ibmc.Int64Ptr(in.Expiration)
	o.Name = reference.ToPtrValue(in.Name)
	o.RealmName = reference.ToPtrValue(in.RealmName)
	o.IfMatch = reference.ToPtrValue(eTag)
	return nil
}

// GenerateSDKRuleConditions -
func GenerateSDKRuleConditions(in []v1alpha1.RuleCondition) []iamagv2.RuleConditions {
	o := []iamagv2.RuleConditions{}
	for _, c := range in {
		item := iamagv2.RuleConditions{
			Claim:    reference.ToPtrValue(c.Claim),
			Operator: reference.ToPtrValue(c.Operator),
			Value:    reference.ToPtrValue(c.Value),
		}
		o = append(o, item)
	}
	return o
}

// GenerateCRRuleConditions -
func GenerateCRRuleConditions(in []iamagv2.RuleConditions) []v1alpha1.RuleCondition {
	o := []v1alpha1.RuleCondition{}
	for _, c := range in {
		item := v1alpha1.RuleCondition{
			Claim:    reference.FromPtrValue(c.Claim),
			Operator: reference.FromPtrValue(c.Operator),
			Value:    reference.FromPtrValue(c.Value),
		}
		o = append(o, item)
	}
	return o
}

// GenerateObservation produces AccessGroupRuleObservation object from *iamagv2.Group object.
func GenerateObservation(in *iamagv2.Rule) (v1alpha1.AccessGroupRuleObservation, error) {
	o := v1alpha1.AccessGroupRuleObservation{
		ID:               reference.FromPtrValue(in.ID),
		AccountID:        reference.FromPtrValue(in.AccountID),
		CreatedAt:        GenerateMetaV1Time(in.CreatedAt),
		CreatedByID:      reference.FromPtrValue(in.CreatedByID),
		LastModifiedAt:   GenerateMetaV1Time(in.LastModifiedAt),
		LastModifiedByID: reference.FromPtrValue(in.LastModifiedByID),
	}
	return o, nil
}

// GenerateMetaV1Time converts strfmt.DateTime to metav1.Time
// TODO - extract this to parent `clients` package
func GenerateMetaV1Time(t *strfmt.DateTime) *metav1.Time {
	if t == nil {
		return nil
	}
	tx := metav1.NewTime(time.Time(*t))
	return &tx
}

// IsUpToDate checks whether current state is up-to-date compared to the given
// set of parameters.
func IsUpToDate(in *v1alpha1.AccessGroupRuleParameters, observed *iamagv2.Rule, l logging.Logger) (bool, error) {
	desired := in.DeepCopy()
	actual, err := GenerateAccessGroupRuleParameters(observed)
	if err != nil {
		return false, err
	}
	sort.Slice(desired.Conditions, func(i, j int) bool {
		return desired.Conditions[i].Claim < desired.Conditions[j].Claim
	})
	sort.Slice(actual.Conditions, func(i, j int) bool {
		return actual.Conditions[i].Claim < actual.Conditions[j].Claim
	})

	l.Info(cmp.Diff(desired, actual, cmpopts.EquateEmpty(),
		cmpopts.IgnoreFields(v1alpha1.AccessGroupRuleParameters{}, "AccessGroupID"),
		cmpopts.IgnoreFields(v1alpha1.AccessGroupRuleParameters{}, "TransactionID"),
		cmpopts.IgnoreTypes(&runtimev1alpha1.Reference{}, &runtimev1alpha1.Selector{}, []runtimev1alpha1.Reference{})))

	return cmp.Equal(desired, actual, cmpopts.EquateEmpty(),
		cmpopts.IgnoreFields(v1alpha1.AccessGroupRuleParameters{}, "AccessGroupID"),
		cmpopts.IgnoreFields(v1alpha1.AccessGroupRuleParameters{}, "TransactionID"),
		cmpopts.IgnoreTypes(&runtimev1alpha1.Reference{}, &runtimev1alpha1.Selector{}, []runtimev1alpha1.Reference{})), nil
}

// GenerateAccessGroupRuleParameters generates service instance parameters from resource instance
func GenerateAccessGroupRuleParameters(in *iamagv2.Rule) (*v1alpha1.AccessGroupRuleParameters, error) {
	o := &v1alpha1.AccessGroupRuleParameters{
		AccessGroupID: in.AccessGroupID,
		Expiration:    ibmc.Int64Value(in.Expiration),
		RealmName:     reference.FromPtrValue(in.RealmName),
		Conditions:    GenerateCRRuleConditions(in.Conditions),
		Name:          reference.FromPtrValue(in.Name),
	}
	return o, nil
}

// GenerateCRAddGroupMembersRequestMembersItem -
func GenerateCRAddGroupMembersRequestMembersItem(in *iamagv2.GroupMembersList) []v1alpha1.AddGroupMembersRequestMembersItem {
	o := []v1alpha1.AddGroupMembersRequestMembersItem{}
	if in == nil {
		return o
	}
	for _, m := range in.Members {
		item := v1alpha1.AddGroupMembersRequestMembersItem{
			IamID: reference.FromPtrValue(m.IamID),
			Type:  reference.FromPtrValue(m.Type),
		}
		o = append(o, item)
	}
	return o
}


text:
@inproceedings{las-11-imagerepo-a,
 address = {Athens and Greece},
 author = {Javier Diaz and von Laszewski, Gregor and Fugang Wang and Younge, Andrew J and Fox, Geoffrey C.},
 booktitle = {Third IEEE International Conference on Coud Computing Technology and Science (CloudCom2011)},
 doi = {10.1109/CloudCom.2011.85},
 keywords = {image repository},
 month = {December},
 pages = {560-564},
 title = {FutureGrid Image Repository: A Generic Catalog and Storage System for Heterogeneous Virtual Machine Images},
 type = {paper},
 url = {https://laszewski.github.io/papers/vonLaszewski-draft-11-imagerepo.pdf},
 year = {2011}
}

license: MIT

license_type: permissive

branch_name: refs/heads/main

extension: bib


text:
@article{Weise2020,
 abstract = {Declines in abundance and genetic diversity in plant and animal populations are increasingly of conservation concern. Genetic rescue, or the supplementation of declining populations with individuals from genetically different sources, may aid in demographic and genetic recovery efforts, assuming introduced individuals successfully reproduce following translocation. However, the relative reproductive contributions of resident and translocated individuals are not frequently evaluated. In the northern lower peninsula of Michigan, USA, fourteen brown trout (Salmo trutta) from each of three different tributaries were introduced into a research stream (Hunt Creek) to supplement a small, isolated resident brown trout population. Mean expected heterozygosity and mean allelic richness differed between the three translocated populations compared to residents. Additionally, inter-population variance in allele frequency (FST) between resident and translocated populations ranged from 0.024 to 0.098. Using genetic parentage assignments, we documented that translocated and resident brown trout did interbreed; however, intra-population mating events were more common. Simulations indicated that increases in genetic diversity among age-1 offspring were the result of reproduction by translocated adults, as genetic variation was significantly above levels expected by reproduction among residents alone (p \textless 0.001). To achieve management goals for genetic rescue programs, managers would be advised to conduct simulations and hypothesis testing in addition to collection of empirical genetic data to evaluate introduction outcomes.},
 author = {Weise, Ellen M. and Sard, Nicholas M. and Nehfer, Andrew and Scribner, Kim T.},
 doi = {10.1007/s10592-020-01249-7},
 file = {:Users/ellenweise/Downloads/10.1007_s10592-020-01249-7-2.pdf:pdf},
 issn = {15729737},
 journal = {Conservation Genetics},
 keywords = {Adaptive management,Assortative mating,Genetic rescue,Parentage analysis,Relatedness},
 number = {2},
 pages = {277--287},
 publisher = {Springer Netherlands},
 title = {Adaptive genetic management: assessing the benefits of translocations},
 volume = {21},
 year = {2020}
}

repository: weiseell/website

repo_name: weiseell/website


text:
package day12

import (
	"errors"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/segwin/adventofcode-2020/internal/geometry"
)

func TestTransformPart1(t *testing.T) {
	t.Parallel()

	type Test struct {
		// inputs
		Direction rune
		Magnitude int64
		Ship      geometry.Point
		Waypoint  geometry.Point

		// outputs
		ExpectedShip     geometry.Point
		ExpectedWaypoint geometry.Point
		ExpectedErr      error
	}

	testFn := func(t *testing.T, cfg Test) {
		t.Parallel()

		ship, waypoint, err := Transform(cfg.Direction, cfg.Magnitude, cfg.Ship, cfg.Waypoint, false)

		if got, expected := err, cfg.ExpectedErr; !errors.Is(got, expected) {
			t.Errorf("Got %v, expected %v", got, expected)
		}

		if diff := cmp.Diff(cfg.ExpectedShip, ship); diff != "" {
			t.Errorf("Unexpected diff:\n%v", diff)
		}

		if diff := cmp.Diff(cfg.ExpectedWaypoint, waypoint); diff != "" {
			t.Errorf("Unexpected diff:\n%v", diff)
		}
	}

	tests := map[string]Test{
		"F10, prev=East": {
			Direction: 'F',
			Magnitude: 10,

			Ship:             geometry.NewInts(0, 0),
			Waypoint:         geometry.NewInts(1, 0),
			ExpectedShip:     geometry.NewInts(10, 0),
			ExpectedWaypoint: geometry.NewInts(1, 0),
		},

		"N3, prev=East": {
			Direction: 'N',
			Magnitude: 3,

			Ship:             geometry.NewInts(10, 0),
			Waypoint:         geometry.NewInts(1, 0),
			ExpectedShip:     geometry.NewInts(10, 3),
			ExpectedWaypoint: geometry.NewInts(1, 0),
		},

		"F7, prev=East": {
			Direction: 'F',
			Magnitude: 7,

			Ship:             geometry.NewInts(10, 3),
			Waypoint:         geometry.NewInts(1, 0),
			ExpectedShip:     geometry.NewInts(17, 3),
			ExpectedWaypoint: geometry.NewInts(1, 0),
		},

		"R90, prev=East": {
			Direction: 'R',
			Magnitude: 90,

			Ship:             geometry.NewInts(17, 3),
			Waypoint:         geometry.NewInts(1, 0),
			ExpectedShip:     geometry.NewInts(17, 3),
			ExpectedWaypoint: geometry.NewInts(0, -1),
		},

		"F11, prev=South": {
			Direction: 'F',
			Magnitude: 11,

			Ship:             geometry.NewInts(17, 3),
			Waypoint:         geometry.NewInts(0, -1),
			ExpectedShip:     geometry.NewInts(17, -8),
			ExpectedWaypoint: geometry.NewInts(0, -1),
		},

		"L90, prev=South": {
			Direction: 'L',
			Magnitude: 90,

			Ship:             geometry.NewInts(17, -8),
			Waypoint:         geometry.NewInts(0, -1),
			ExpectedShip:     geometry.NewInts(17, -8),
			ExpectedWaypoint: geometry.NewInts(1, 0),
		},

		"R270, prev=East": {
			Direction: 'R',
			Magnitude: 270,

			Ship:             geometry.NewInts(17, -8),
			Waypoint:         geometry.NewInts(1, 0),
			ExpectedShip:     geometry.NewInts(17, -8),
			ExpectedWaypoint: geometry.NewInts(0, 1),
		},

		"L270, prev=North": {
			Direction: 'L',
			Magnitude: 270,

			Ship:             geometry.NewInts(17, -8),
			Waypoint:         geometry.NewInts(0, 1),
			ExpectedShip:     geometry.NewInts(17, -8),
			ExpectedWaypoint: geometry.NewInts(1, 0),
		},
	}

	for name, cfg := range tests {
		t.Run(name, func(t *testing.T) { testFn(t, cfg) })
	}
}

func TestTransformPart2(t *testing.T) {
	t.Parallel()

	type Test struct {
		// inputs
		Direction rune
		Magnitude int64
		Ship      geometry.Point
		Waypoint  geometry.Point

		// outputs
		ExpectedShip     geometry.Point
		ExpectedWaypoint geometry.Point
		ExpectedErr      error
	}

	testFn := func(t *testing.T, cfg Test) {
		t.Parallel()

		ship, waypoint, err := Transform(cfg.Direction, cfg.Magnitude, cfg.Ship, cfg.Waypoint, true)

		if got, expected := err, cfg.ExpectedErr; !errors.Is(got, expected) {
			t.Errorf("Got %v, expected %v", got, expected)
		}

		if diff := cmp.Diff(cfg.ExpectedShip, ship); diff != "" {
			t.Errorf("Unexpected diff:\n%v", diff)
		}

		if diff := cmp.Diff(cfg.ExpectedWaypoint, waypoint); diff != "" {
			t.Errorf("Unexpected diff:\n%v", diff)
		}
	}

	tests := map[string]Test{
		"F10, prev=East": {
			Direction: 'F',
			Magnitude: 10,

			Ship:             geometry.NewInts(0, 0),
			Waypoint:         geometry.NewInts(10, 1),
			ExpectedShip:     geometry.NewInts(100, 10),
			ExpectedWaypoint: geometry.NewInts(10, 1),
		},

		"N3, prev=East": {
			Direction: 'N',
			Magnitude: 3,

			Ship:             geometry.NewInts(100, 10),
			Waypoint:         geometry.NewInts(10, 1),
			ExpectedShip:     geometry.NewInts(100, 10),
			ExpectedWaypoint: geometry.NewInts(10, 4),
		},

		"F7, prev=East": {
			Direction: 'F',
			Magnitude: 7,

			Ship:             geometry.NewInts(100, 10),
			Waypoint:         geometry.NewInts(10, 4),
			ExpectedShip:     geometry.NewInts(170, 38),
			ExpectedWaypoint: geometry.NewInts(10, 4),
		},

		"R90, prev=East": {
			Direction: 'R',
			Magnitude: 90,

			Ship:             geometry.NewInts(170, 38),
			Waypoint:         geometry.NewInts(10, 4),
			ExpectedShip:     geometry.NewInts(170, 38),
			ExpectedWaypoint: geometry.NewInts(4, -10),
		},

		"F11, prev=South": {
			Direction: 'F',
			Magnitude: 11,

			Ship:             geometry.NewInts(170, 38),
			Waypoint:         geometry.NewInts(4, -10),
			ExpectedShip:     geometry.NewInts(214, -72),
			ExpectedWaypoint: geometry.NewInts(4, -10),
		},
	}

	for name, cfg := range tests {
		t.Run(name, func(t *testing.T) { testFn(t, cfg) })
	}
}

extension: go


text:
@article{govindjeemihalic1996,
    title   = "Computational methods for inverse finite elastostatics",
    volume  = "136",
    DOI     = "10.1016/0045-7825(96)01045-6",
    number  = "1-2",
    journal = "Computer Methods in Applied Mechanics and Engineering",
    author  = "Govindjee, Sanjay and Mihalic, Paul A.",
    year    = "1996", pages="47–57"
    }

@misc{fenics_project,
    title="FEniCS Project",
    howpublished = {\url{https://fenicsproject.org/}},
    note         = {Accessed: Nov. 2016}
}

@book{fenicsbook,
    place     = "Berlin",
    title     = "Automated Solution of Differential Equations by the Finite Element Method: The FEniCS Book",
    publisher = "Springer Berlin",
    author    = "Logg, Anders and Mardal, Kent-Andre and Wells, Garth",
    year      = "2016"
}

@book{chadwick_1999,
    place     = "Mineola, NY",
    title     = "Continuum mechanics: concise theory and problems",
    publisher = "Dover Publications",
    author    = "Peter Chadwick",
    year      = "1999"
}

@book{hughes_2007,
    place     = "New York",
    title     = "The finite element method: linear static and dynamic finite element analysis",
    publisher = "Dover publication, Inc",
    author    = "Hughes, Thomas J. R.",
    year      = "2007"
}

@article{guccione_1995,
    title   = {Finite element stress analysis of left ventricular mechanics in the beating dog heart},
    volume  = {28},
    DOI     = {10.1016/0021-9290(94)00174-3},
    number  = {10},
    journal = {Journal of Biomechanics},
    author  = {Guccione, Julius M. and Costa, Kevin D. and Mcculloch, Andrew D.},
    year    = {1995},
    pages   = {1167–1177}
}

@article{land_2015,
    title= {Verification of cardiac mechanics software: benchmark problems and solutions for testing active and passive material behaviour},
    volume={471},
    DOI={10.1098/rspa.2015.0641},
    number={2184},
    journal={Proceedings of the Royal Society A: Mathematical, Physical and Engineering Science},
    author={Land, Sander and Gurev, Viatcheslav and Arens, Sander and Augustin, Christoph M. and Baron, Lukas and Blake, Robert and Bradley, Chris and Castro, Sebastian and Crozier, Andrew and Favino, Marco and et al.},
    year={2015},
    month={Aug},
    pages={20150641}
}

branch_name: refs/heads/master


text:
SUMMARY = "Settings app written from scratch for Open webOS"
SECTION = "webos/apps"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Apache-2.0;md5=89aea4e17d99a7cacdbeed46a0096b10"

inherit webos_public_repo
inherit webos_enyojs_application

# For the sake of the webOS build system we need to provide the webOS component version
# and even a submission number, even if we don't use any.
WEBOS_COMPONENT_VERSION = "0.3.0"
WEBOS_SUBMISSION = "0"
PV = "${WEBOS_COMPONENT_VERSION}+gitr${SRCPV}"

inherit webos_component

SRCREV = "68b78b28e396a96f8ade9d6bcd1ec44ec5e22d3d"
SRC_URI = "git://github.com/webOS-ports/${PN};protocol=git"
S = "${WORKDIR}/git"

repository: nizovn/meta-webos-ports

repo_name: nizovn/meta-webos-ports

extension: bb


text:
# Currently very minimal.

include(FindPackageHandleStandardArgs)

find_path(GLM_INCLUDE_DIR glm/glm.hpp)
set(GLM_INCLUDE_DIRS ${GLM_INCLUDE_DIR})

find_package_handle_standard_args(GLM DEFAULT_MSG
    GLM_INCLUDE_DIRS
    )

repository: torss/BinaryMeshFitting

repo_name: torss/BinaryMeshFitting

gha_license_id: MIT

extension: cmake


text:
@article{jordan_detection_2019,
 author = {Jordan, M. I. and Krzakala, Florent and Alaoui, A. E.},
 title = {DETECTION LIMITS IN THE SPIKED WIGNER MODEL},
 url = {https://www.imstat.org/journals-and-publications/annals-of-statistics/annals-of-statistics-future-papers/},
 journal = {annals of statistics},
 year = {2019}
}


text:
DESCRIPTION = "An "HTTP::Message" object contains some headers and a content body. The \
following methods are available:"

SECTION = "libs"
LICENSE = "Artistic-1.0 | GPL-1.0-or-later"
PR = "r0"

MAINTAINER=	"Poky <poky@yoctoproject.org>"
HOMEPAGE=	"https://metacpan.org/release/HTTP-Message"

LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Artistic-1.0;md5=cda03bbdc3c1951996392b872397b798 \
file://${COMMON_LICENSE_DIR}/GPL-1.0-or-later;md5=30c0b8a5048cc2f4be5ff15ef0d8cf61"

SRC_URI = "https://cpan.metacpan.org/authors/id/O/OA/OALDERS/HTTP-Message-6.36.tar.gz"

SRC_URI[md5sum] = "e847fb3e297e740080ab6fd1ac127f7f"
SRC_URI[sha256sum] = "576a53b486af87db56261a36099776370c06f0087d179fc8c7bb803b48cddd76"
RDEPENDS:${PN} += "encode-locale-perl"
RDEPENDS:${PN} += "http-date-perl"
RDEPENDS:${PN} += "io-html-perl"
RDEPENDS:${PN} += "lwp-mediatypes-perl"
RDEPENDS:${PN} += "uri-perl"
DEPENDS += "try-tiny-perl-native"

S = "${WORKDIR}/HTTP-Message-${PV}"

inherit cpan allarch

BBCLASSEXTEND = "native"

repository: rehsack/meta-cpan

repo_name: rehsack/meta-cpan

gha_language: BitBake


text:
@InProceedings{las14cloudmeshmultiple,
  title =	 {{Accessing Multiple Clouds with Cloudmesh}},
  author =	 {von Laszewski, Gregor and Wang, Fugang and Lee,
                  Hyungro and Chen, Heng and Fox, Geoffrey C.},
  booktitle =	 {Proceedings of the 2014 ACM International Workshop
                  on Software-defined Ecosystems},
  year =	 2014,
  address =	 {New York, NY, USA},
  pages =	 {21--28},
  publisher =	 {ACM},
  series =	 {BigSystem '14},
  acmid =	 2609638,
  doi =		 {10.1145/2609441.2609638},
  isbn =	 {978-1-4503-2909-5},
  keywords =	 {cloud computing},
  location =	 {Vancouver, BC, Canada},
  numpages =	 8,
  url =		 {http://doi.acm.org/10.1145/2609441.2609638}
}

@Misc{www-git,
	title = {{Home}},
	author = {{Mike Bostock}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {https://github.com/d3/d3/wiki}
}

@article{paper-d3,
  title = {D3: Data-Driven Documents},
  author = {Michael Bostock AND Vadim Ogievetsky AND Jeffrey Heer},
  journal = {IEEE Trans. Visualization \& Comp. Graphics (Proc. InfoVis)},
  year = {2011},
  url = {http://vis.stanford.edu/papers/d3}
}

@Misc{www-gallery,
	title = {{Gallery}},
	author = {{Mike Bostock}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {https://github.com/d3/d3/wiki/Gallery}
}

@Misc{www-cook,
	title = {{Wimbledon 2013 Data Visualisations}},
	author = {{Peter Cook}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {http://charts.animateddata.co.uk/tennis/index.html}
}

@Misc{www-tennis,
	title = {{Tennis-Data.co.uk}},
	author = {{Joseph}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {http://www.tennis-data.co.uk/wimbledon.php}
}

@Misc{www-cmt,
	title = {{Wimbledon 2013 Circular Match Tree}},
	author = {{Peter Cook}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {http://charts.animateddata.co.uk/tennis/matchTree.html}
}

@Misc{www-bubble,
	title = {{Wimbledon 2013 David and Goliath}},
	author = {{Peter Cook}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {http://charts.animateddata.co.uk/tennis/davidgoliath.html}
}

@Misc{www-hist,
	title = {{Wimbledon 2013 Top 32 Players}},
	author = {{Peter Cook}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {http://charts.animateddata.co.uk/tennis/top32.html}
}

@Misc{www-map,
	title = {{Earthquakes in Chile since 1900}},
	author = {{Pablo Navarro}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {http://pnavarrc.github.io/earthquake/}
}

@Misc{www-fdm,
	title = {{Visualizing The Racial Divide}},
	author = {{Jim Vallandingham}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {http://vallandingham.me/racial_divide/}
}

@Misc{www-chicago,
	title = {{Visualizing The Racial Divide}},
	author = {{Jim Vallandingham}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {http://vallandingham.me/racial_divide/#ch}
}

@Misc{www-mike,
	title = {{Mike Bostock}},
	author = {{Mike Bostock}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {https://github.com/mbostock}
}

@Misc{www-d3,
	title = {{D3 Data Driven Documents}},
	author = {{Mike Bostock}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {https://d3js.org/}
}

@Misc{www-av,
	title = {{Newbie to D3.js Expert: Complete path to create interactive visualization using D3.js}},
	author = {{Analytics Vidhya}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {https://www.analyticsvidhya.com/learning-paths-data-science-business-analytics-business-intelligence-big-data/newbie-d3-js-expert-complete-path-create-interactive-visualization-d3-js/}
}

@Misc{www-tut,
	title = {{Tutorials}},
	author = {{Mike Bostock}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-25},
	owner = {S17-IR-2035},
	url = {https://github.com/d3/d3/wiki/Tutorials}
}

@Misc{www-jquery,
	title = {{jQuery}},
	author = {{jQuery Foundation}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {https://jquery.com/}
}

@Misc{www-raphael,
	title = {{Raphaël}},
	author = {{Dmitry Baranovskiy}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {http://dmitrybaranovskiy.github.io/raphael/}
}

@Misc{www-protovis,
	title = {{Protovis}},
	author = {{Mike Bostock}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {http://mbostock.github.io/protovis/}
}

@Misc{www-w3c,
	title = {{W3C}},
	author = {{Anne van Kesteren and Lachlan Hunt}},
	howpublished = {Web Page},
	note = {Accessed: 2017-03-24},
	owner = {S17-IR-2035},
	url = {https://www.w3.org/TR/selectors-api/}
}

gha_language: TeX


text:
DESCRIPTION = "itstool"
HOMEPAGE = ""
SECTION = "console/utils"
LICENSE = "GPLv2"

LIC_FILES_CHKSUM = "file://COPYING;md5=59c57b95fd7d0e9e238ebbc7ad47c5a5"

SRCREV ?= "${AUTOREV}"
PV = "${SRCPV}"
PR = "1"

SRC_URI = "git://github.com/itstool/itstool.git;protocol=http \
"

S = "${WORKDIR}/git"

inherit autotools

BBCLASSEXTEND = "native nativesdk"

FILES_${PN}_append += "/usr/share"

branch_name: refs/heads/krogoth


text:
include ipc-transport-qmss.inc

DEPENDS = "ipc-transport-qmss ti-ipc"

#FILES_${PN}-test = "${bindir}/multiProcessTest_*.out"

CHOICELIST = "yes no"

DEVICELIST = "k2h k2k k2e k2l"

do_compile () {
#   Now build the test code
	for device in ${DEVICELIST}
	do
		for choice in ${CHOICELIST}
		do
			oe_runmake tests \
				IPC_DEVKIT_INSTALL_PATH=${STAGING_INCDIR} \
				USEDYNAMIC_LIB="$choice" DEVICE="$device"
		done
	done
}

do_install () {
	for device in ${DEVICELIST}
	do
		oe_runmake installbin \
			INSTALL_BIN_BASE_DIR=${D}${bindir} DEVICE="$device"
	done

}

repository: joelagnel/meta-ti

repo_name: joelagnel/meta-ti


text:
package model

import (
	"fmt"

	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
)

// MutableReachabilityData represents a node in the reachability tree
// of some DAG block. It mainly provides the ability to query *tree*
// reachability with O(1) query time. It does so by managing an
// index interval for each node and making sure all nodes in its
// subtree are indexed within the interval, so the query
// B ∈ subtree(A) simply becomes B.interval ⊂ A.interval.
//
// The main challenge of maintaining such intervals is that our tree
// is an ever-growing tree and as such pre-allocated intervals may
// not suffice as per future events. This is where the reindexing
// algorithm below comes into place.
// We use the reasonable assumption that the initial root interval
// (e.g., [0, 2^64-1]) should always suffice for any practical use-
// case, and so reindexing should always succeed unless more than
// 2^64 blocks are added to the DAG/tree.
//
// In addition, we keep a future covering set for every node.
// This set allows to query reachability over the entirety of the DAG.
// See documentation of FutureCoveringTreeNodeSet for additional details.

// ReachabilityData is a read-only version of a block's MutableReachabilityData
// Use CloneWritable to edit the MutableReachabilityData.
type ReachabilityData interface {
	Children() []*externalapi.DomainHash
	Parent() *externalapi.DomainHash
	Interval() *ReachabilityInterval
	FutureCoveringSet() FutureCoveringTreeNodeSet
	CloneMutable() MutableReachabilityData
	Equal(other ReachabilityData) bool
}

// MutableReachabilityData represents a block's MutableReachabilityData, with ability to edit it
type MutableReachabilityData interface {
	ReachabilityData

	AddChild(child *externalapi.DomainHash)
	SetParent(parent *externalapi.DomainHash)
	SetInterval(interval *ReachabilityInterval)
	SetFutureCoveringSet(futureCoveringSet FutureCoveringTreeNodeSet)
}

// ReachabilityInterval represents an interval to be used within the
// tree reachability algorithm. See ReachabilityTreeNode for further
// details.
type ReachabilityInterval struct {
	Start uint64
	End   uint64
}

// If this doesn't compile, it means the type definition has been changed, so it's
// an indication to update Equal and Clone accordingly.
var _ = &ReachabilityInterval{0, 0}

// Equal returns whether ri equals to other
func (ri *ReachabilityInterval) Equal(other *ReachabilityInterval) bool {
	if ri == nil || other == nil {
		return ri == other
	}

	if ri.Start != other.Start {
		return false
	}

	if ri.End != other.End {
		return false
	}

	return true
}

// Clone returns a clone of ReachabilityInterval
func (ri *ReachabilityInterval) Clone() *ReachabilityInterval {
	return &ReachabilityInterval{
		Start: ri.Start,
		End:   ri.End,
	}
}

func (ri *ReachabilityInterval) String() string {
	return fmt.Sprintf("[%d,%d]", ri.Start, ri.End)
}

// FutureCoveringTreeNodeSet represents a collection of blocks in the future of
// a certain block. Once a block B is added to the DAG, every block A_i in
// B's selected parent anticone must register B in its FutureCoveringTreeNodeSet. This allows
// to relatively quickly (O(log(|FutureCoveringTreeNodeSet|))) query whether B
// is a descendent (is in the "future") of any block that previously
// registered it.
//
// Note that FutureCoveringTreeNodeSet is meant to be queried only if B is not
// a reachability tree descendant of the block in question, as reachability
// tree queries are always O(1).
//
// See insertNode, hasAncestorOf, and isInPast for further details.
type FutureCoveringTreeNodeSet []*externalapi.DomainHash

// Clone returns a clone of FutureCoveringTreeNodeSet
func (fctns FutureCoveringTreeNodeSet) Clone() FutureCoveringTreeNodeSet {
	//return fctns
	return externalapi.CloneHashes(fctns)
}

// If this doesn't compile, it means the type definition has been changed, so it's
// an indication to update Equal and Clone accordingly.
var _ FutureCoveringTreeNodeSet = []*externalapi.DomainHash{}

// Equal returns whether fctns equals to other
func (fctns FutureCoveringTreeNodeSet) Equal(other FutureCoveringTreeNodeSet) bool {
	return externalapi.HashesEqual(fctns, other)
}

license: ISC

repository: kaspanet/kaspad

repo_name: kaspanet/kaspad

gha_license_id: ISC

gha_language: Go


text:
@techreport{Mahadevan2013a,
 abstract = {Rising software complexity in aerospace systems makes them very dicult to analyze and prepare for all possible fault scenarios at design-time. Therefore, classical run-time fault-tolerance techniques, such as self-checking pairs and triple modular redundancy are used. However, several recent incidents have made it clear that existing software fault tolerance techniques alone are not sucient. To improve system dependability, simpler, yet formally specied and veried run-time monitoring, diagnosis, and fault mitigation are needed. Such architectures are already in use for managing the health of vehicles and systems. Software health management is the application of adapting and applying these techniques to software. In this paper, we briey describe the software health management technique and architecture developed by our research group. The foundation of the architecture is a real-time component framework (built upon ARINC-653 platform services) that denes a model of computation for software components. Dedicated architectural elements: the Component Level Health Manager (CLHM) and System Level Health Manager (SLHM) are providing health management services: anomaly detection, fault source isolation, and fault mitigation. The SLHM includes a diagnosis engine that uses a Timed Failure Propagation (TFPG) model derived from the component assembly model, and it reasons about cascading fault eects in the system and isolates the fault source component(s). Thereafter, the appropriate system level mitigation action is taken. The main focus of this article is the description of the fault mitigation architecture that uses goal-based deliberative reasoning to determine the best mitigation actions for recovering the system from the identied failure mode.},
 attachments = {http://www.isis.vanderbilt.edu/sites/default/files/TechReport2013.pdf},
 author = {Mahadevan, Nagabhushan and Abhishek Dubey and Balasubramanian, Daniel and Karsai, Gabor},
 file = {:Mahadevan2013a-Deliberative_reasoning_in_software_health_management.pdf:PDF},
 institution = {Institute for Software Integrated Systems, Vanderbilt University},
 issn = {ISIS-13-101},
 keywords = {},
 month = {04},
 number = {ISIS-13-101},
 oldkeywords = {performance, reliability},
 tag = {platform},
 title = {Deliberative Reasoning in Software Health Management},
 type = {techreport},
 year = {2013}
}


text:
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Go-import-redirector is an HTTP server for a custom Go import domain. It responds to requests in
// a given import path root with a meta tag specifying the source repository for the ``go get''
// command and an HTML redirect to the godoc.org documentation page for that package.
//
// Usage:
//
//	go-import-redirector [-listen address] [-grace period] [-vcs sys] <import> <repo> ...
//
// Go-import-redirector listens on an address (default ``:9001'') and responds to requests for URLs
// in one of the the given import path roots with one meta tag specifying the given source
// repository for ``go get'' and another meta tag causing a redirect to the corresponding godoc.org
// documentation page.
//
// Multiple pairs of import paths and repository URLs may be specified.
//
// For example, if invoked as:
//
//	go-import-redirector 9fans.net/go https://github.com/9fans/go
//
// then the response for 9fans.net/go/acme/editinacme will include these tags:
//
//	<meta name="go-import" content="9fans.net/go git https://github.com/9fans/go">
//	<meta http-equiv="refresh" content="0; url=https://godoc.org/9fans.net/go/acme/editinacme">
//
// If both <import> and <repo> end in /*, the corresponding path element is taken from the import
// path and substituted in repo on each request. For example, if invoked as:
//
//	go-import-redirector rsc.io/* https://github.com/rsc/*
//
// then the response for rsc.io/x86/x86asm will include these tags:
//
//	<meta name="go-import" content="rsc.io/x86 git https://github.com/rsc/x86">
//	<meta http-equiv="refresh" content="0; url=https://godoc.org/rsc.io/x86/x86asm">
//
// Note that the wildcard element (x86) has been included in the Git repo path.
//
// The -listen option specifies the address to serve from (default ``:9001'').
// If the listen address begins with "unix:", then redirects are served from a Unix domain socket.
//
// The -vcs option specifies the default version control system, git, hg, or svn (default ``git'').
// This can be changed per-repo by beginning the repo URL with the VCS name followed by a plus
// (``+''), such as "git+https://github.com/name/*".
//
package main

import (
	"bytes"
	"context"
	"errors"
	"flag"
	"fmt"
	"html/template"
	"log"
	"net"
	"net/http"
	"net/url"
	"os"
	"os/signal"
	"path"
	"strings"
	"time"

	"golang.org/x/sync/errgroup"
	"golang.org/x/sys/unix"
)

var (
	listenAddr  = flag.String("listen", ":9001", "serve http on `address`")
	defaultVCS  = flag.String("vcs", "git", "set default version control `system`")
	gracePeriod = flag.Duration("grace", time.Second*5, "grace `period` for HTTP shutdowns")
)

func usage() {
	fmt.Fprintln(os.Stderr, "Usage: go-import-redirector [options] <import> <repo> ...\n")
	fmt.Fprintln(os.Stderr, "options:")
	flag.PrintDefaults()
	fmt.Fprintln(os.Stderr, "examples:")
	fmt.Fprintln(os.Stderr, "\tgo-import-redirector rsc.io/* https://github.com/rsc/*")
	fmt.Fprintln(os.Stderr, "\tgo-import-redirector 9fans.net/go https://github.com/9fans/go")
	os.Exit(2)
}

func main() {
	// log.SetFlags(0)
	log.SetPrefix("go-import-redirector: ")
	flag.Usage = usage
	flag.Parse()

	narg := flag.NArg()
	if narg < 2 || narg%2 != 0 {
		flag.Usage()
	}

	mux := http.NewServeMux()
	for i := 0; i < narg; i += 2 {
		importPath := flag.Arg(i)
		repoPath := flag.Arg(i + 1)
		redirect, err := newRedirect(importPath, repoPath)
		if err != nil {
			log.Fatalf("error creating redirect %s -> %s: %v", err)
		}
		mux.Handle(redirect.root(), redirect)
	}

	network, addr := "tcp", *listenAddr
	if strings.HasPrefix(addr, "unix:") {
		network, addr = "unix", addr[5:]
	}

	listener, err := net.Listen(network, addr)
	if err != nil {
		log.Fatalf("error creating listener")
	}
	defer listener.Close()

	server := &http.Server{
		Handler: mux,
	}

	var wg errgroup.Group
	defer func() {
		if err := wg.Wait(); err != nil {
			log.Panicf("fatal error: %v", err)
		}
	}()

	wg.Go(func() error {
		sig := make(chan os.Signal, 1)
		signal.Notify(sig, os.Interrupt, unix.SIGTERM, unix.SIGHUP)
		defer signal.Stop(sig)

		note := <-sig
		log.Printf("received signal %v; shutting down", note)

		period := *gracePeriod
		if period <= 0 {
			return server.Close()
		}

		ctx, cancel := context.WithTimeout(context.Background(), *gracePeriod)
		defer cancel()
		err := server.Shutdown(ctx)
		if err != nil {
			log.Printf("")
			return err
		}
		return nil
	})

	wg.Go(func() error {
		err := server.Serve(listener)
		if err != nil && err != http.ErrServerClosed {
			return err
		}
		return nil
	})
}

var tmpl = template.Must(template.New("main").Parse(`<!DOCTYPE html>

<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<meta name="go-import" content="{{.ImportRoot}} {{.VCS}} {{.VCSRoot}}">
<meta http-equiv="refresh" content="0; url=https://godoc.org/{{.ImportRoot}}{{.Suffix}}">

Redirecting to docs at godoc.org/{{.ImportRoot}}{{.Suffix}}...

`))

type data struct {
	ImportRoot string
	VCS        string
	VCSRoot    string
	Suffix     string
}

type redirectPath struct {
	wildcard   bool
	importPath string
	repo       *url.URL
	vcs        string
}

func newRedirect(importPath, repoPath string) (*redirectPath, error) {
	if !strings.Contains(repoPath, "://") {
		return nil, errors.New("repo path must be full URL")
	}
	wildcard := strings.HasSuffix(importPath, "/*")
	if wildcard != strings.HasSuffix(repoPath, "/*") {
		return nil, errors.New("either both import and repo must have /* or neither")
	}
	if wildcard {
		importPath = strings.TrimSuffix(importPath, "/*")
		repoPath = strings.TrimSuffix(repoPath, "/*")
	}

	importPath = strings.TrimSuffix(importPath, "/")
	repo, err := url.Parse(repoPath)
	if err != nil {
		return nil, err
	}

	vcs := *defaultVCS
	if sep := strings.IndexByte(repo.Scheme, '+'); sep != -1 {
		vcs, repo.Scheme = repo.Scheme[:sep], repo.Scheme[sep+1:]
	}

	r := &redirectPath{
		wildcard:   wildcard,
		importPath: importPath,
		repo:       repo,
		vcs:        vcs,
	}
	return r, nil
}

func (r *redirectPath) root() string {
	return r.importPath + "/"
}

func (r *redirectPath) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	reqPath := strings.TrimSuffix(req.Host+req.URL.Path, "/")
	var importRoot, repoRoot, suffix string
	if r.wildcard {
		if reqPath == r.importPath {
			http.Redirect(w, req, "https://godoc.org/"+r.importPath, http.StatusFound)
			return
		}
		if !strings.HasPrefix(reqPath, r.root()) {
			http.NotFound(w, req)
			return
		}
		elem := reqPath[len(r.importPath)+1:]
		if i := strings.Index(elem, "/"); i >= 0 {
			log.Print("chopping")
			elem, suffix = elem[:i], elem[i:]
		}

		importRoot = path.Join(r.importPath, elem)
		repo := *r.repo
		repo.Path = path.Join(repo.Path, elem)
		repoRoot = repo.String()
	} else {
		if reqPath != r.importPath && !strings.HasPrefix(reqPath, r.root()) {
			http.NotFound(w, req)
			return
		}
		importRoot = r.importPath
		repoRoot = r.repo.String()
		suffix = reqPath[len(r.importPath):]
	}
	d := &data{
		ImportRoot: importRoot,
		VCS:        r.vcs,
		VCSRoot:    repoRoot,
		Suffix:     suffix,
	}
	var buf bytes.Buffer
	err := tmpl.Execute(&buf, d)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.Write(buf.Bytes())
}

func pong(w http.ResponseWriter, req *http.Request) {
	fmt.Fprintf(w, "pong")
}

repository: nilium/go-import-redirector

repo_name: nilium/go-import-redirector


text:
package url

import (
	"short/app/entity"
	"short/app/usecase/keygen"
	"short/app/usecase/repo"
)

var _ Creator = (*CreatorPersist)(nil)

type ErrAliasExist string

func (e ErrAliasExist) Error() string {
	return string(e)
}

// Creator represents a URL alias creator
type Creator interface {
	CreateURL(url entity.URL, userEmail string) (entity.URL, error)
	CreateURLWithCustomAlias(url entity.URL, alias string, userEmail string) (entity.URL, error)
}

// CreatorPersist represents a URL alias creator which persist the generated
// alias in the repository
type CreatorPersist struct {
	urlRepo             repo.URL
	userURLRelationRepo repo.UserURLRelation
	keyGen              keygen.KeyGenerator
}

// CreateURL persists a new url with a generated alias in the repository.
func (a CreatorPersist) CreateURL(url entity.URL, userEmail string) (entity.URL, error) {
	key, err := a.keyGen.NewKey()
	if err != nil {
		return entity.URL{}, err
	}
	randomAlias := string(key)
	return a.CreateURLWithCustomAlias(url, randomAlias, userEmail)
}

// CreateURLWithCustomAlias persists a new url with a custom alias in
// the repository.
func (a CreatorPersist) CreateURLWithCustomAlias(url entity.URL, alias string, userEmail string) (entity.URL, error) {
	url.Alias = alias

	isExist, err := a.urlRepo.IsAliasExist(alias)
	if err != nil {
		return entity.URL{}, err
	}

	if isExist {
		return entity.URL{}, ErrAliasExist("url alias already exist")
	}

	err = a.urlRepo.Create(url)
	if err != nil {
		return entity.URL{}, err
	}

	err = a.userURLRelationRepo.CreateRelation(userEmail, url.Alias)
	return url, err
}

// NewCreatorPersist creates CreatorPersist
func NewCreatorPersist(
	urlRepo repo.URL,
	userURLRelationRepo repo.UserURLRelation,
	keyGen keygen.KeyGenerator,
) CreatorPersist {
	return CreatorPersist{
		urlRepo:             urlRepo,
		userURLRelationRepo: userURLRelationRepo,
		keyGen:              keyGen,
	}
}

repository: obukhov/short

repo_name: obukhov/short


text:
package configurator

import (
	"errors"
	"io/ioutil"
	"net/http"
	"os"
	"strings"

	"gopkg.in/yaml.v2"
)

// LoginEmailDomain is a type which contains Google oauth settings
type LoginEmailDomain struct {
	Domain            string `yaml:"domain"`
	Provider          string `yaml:"provider"`
	OAuthClientID     string `yaml:"oauth_client_id"`
	OAuthClientSecret string `yaml:"oauth_client_secret"`
}

// DomainConfig is the type which an entire site's config is within
type DomainConfig struct {
	Domain               string             `yaml:"domain"`
	AuthPageTitle        string             `yaml:"auth_pages_title"`
	Enabled              bool               `yaml:"enabled"`
	LoginEmailDomains    []LoginEmailDomain `yaml:"login_email_domains"`
	SessionCookieName    string             `yaml:"session_cookie_name"`
	SessionServerToken   string             `yaml:"session_server_token"`
	SecurityHeaders      map[string]string  `yaml:"security_headers"`
	UnauthenticatedPaths []string           `yaml:"unauthenticated_paths"`
}

// Config is the master configuration type, it has an array of DomainConfig objects
type Config struct {
	DomainConfigs []DomainConfig `yaml:"domains"`
}

// ReadConfigFile takes a yaml filename, attempts to parse and returns Config object
func ReadConfigFile(filename string) (Config, error) {
	var c Config

	data, err := ioutil.ReadFile(filename)
	if err != nil {
		//fmt.Printf("ReadConfigFile: Couldn't read: '%s'\n", filename)
		return c, err
	}

	err = yaml.Unmarshal(data, &c)
	if err != nil {
		return c, err
	}

	return c, nil
}

// GetDomainConfigFromRequest returns DomainConfig (and error) from a request and DOMAIN_CONFIG_FILEPATH env var
func GetDomainConfigFromRequest(request *http.Request) (DomainConfig, error) {
	hsn := request.URL.Hostname()
	dcf := os.Getenv("DOMAIN_CONFIG_FILEPATH")
	if dcf == "" {
		dcf = "config/default.yml"
	}
	//fmt.Printf("hsn: %s\n", hsn)
	//fmt.Printf("dcf: %s\n", dcf)
	return GetDomainConfig(hsn, dcf)
}

// Get returns the DomainConfig for a specific domain
func (c Config) Get(domain string) DomainConfig {
	var dc DomainConfig
	for _, d := range c.DomainConfigs {
		if strings.ToLower(domain) == strings.ToLower(d.Domain) && d.Enabled {
			dc = d
			break
		}
	}
	return dc
}

// GetLoginEmailDomain returns the GoogleEmailDomain for a specific domain out of DomainConfig
func (c DomainConfig) GetLoginEmailDomain(domain string, provider string) LoginEmailDomain {
	var led LoginEmailDomain
	for _, d := range c.LoginEmailDomains {
		if strings.ToLower(domain) == strings.ToLower(d.Domain) && strings.ToLower(provider) == strings.ToLower(d.Provider) {
			led = d
			break
		}
	}
	return led
}

// GetLoginProviders returns the providers for a specific domain out of DomainConfig
func (c DomainConfig) GetLoginProviders(domain string) []string {
	var res []string
	for _, d := range c.LoginEmailDomains {
		if strings.ToLower(domain) == strings.ToLower(d.Domain) {
			res = append(res, strings.ToLower(d.Provider))
		}
	}
	return res
}

// GetDomainConfig returns DomainConfig (and error) from domain and filepath
func GetDomainConfig(domain string, filename string) (DomainConfig, error) {
	var err error

	c, err := ReadConfigFile(filename)
	if err != nil {
		//fmt.Printf("GetDomainConfig: Couldn't find '%s' in '%s'\n", domain, filename)
		return DomainConfig{}, err
	}

	dc := c.Get(domain)
	if dc.Enabled == false {
		err = errors.New("Domain not found in config file")
		return DomainConfig{}, err
	}

	return dc, nil
}

// IsUnauthPath will return true if the request domain config matches and authenticated path
func IsUnauthPath(request *http.Request) bool {
	res := false

	dc, err := GetDomainConfigFromRequest(request)
	if err != nil {
		return res
	}

	for _, uap := range dc.UnauthenticatedPaths {
		if strings.HasPrefix(request.URL.EscapedPath(), uap) {
			res = true
			break
		}
	}

	return res
}

repository: alphagov/authenticating-route-service

repo_name: alphagov/authenticating-route-service


text:
DESCRIPTION = "fru-print"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${S}/LICENSE.txt;md5=cbe895ca02dfa53a3d54f227d1b1967c"

RDEPENDS:${PN} = "python3-core python3-pyyaml"
inherit python3-dir

REPO = "git://github.com/genotrance/fru-tool.git;protocol=https"
BRANCH = "master"
SRCREV = "96f02c8897f89e297dfde88f5ad266163d166168"

BRANCHARG = "${@['nobranch=1', 'branch=${BRANCH}'][d.getVar('BRANCH', True) != '']}"
SRC_URI = "${REPO};${BRANCHARG}"

SRC_URI:append = " \
    file://fru-print.py \
    file://0001-fru.py-Modifying-for-xilinx-specific-specs.patch \
    "

S = "${WORKDIR}/git"

do_install() {
    install -d ${D}${PYTHON_SITEPACKAGES_DIR}/
    install -d ${D}${bindir}/
    install -m 0755 ${S}/fru.py ${D}${PYTHON_SITEPACKAGES_DIR}/
    install -m 0755 ${WORKDIR}/fru-print.py ${D}${bindir}/
}

FILES:${PN} += "${PYTHON_SITEPACKAGES_DIR}/fru.py ${bindir}/fru-print.py"

repository: foundriesio/meta-lmp

repo_name: foundriesio/meta-lmp


text:
package wrapper

import (
	"fmt"
	"log"
	"path/filepath"
	"runtime"
)

// Quiet mode will not show any informative output
func (b *OGame) Quiet(quiet bool) {
	b.quiet = quiet
}

// SetLogger set a custom logger for the bot
func (b *OGame) SetLogger(logger *log.Logger) {
	b.logger = logger
}

// Terminal styling constants
const (
	knrm = "\x1B[0m"
	kred = "\x1B[31m"
	//kgrn = "\x1B[32m"
	kyel = "\x1B[33m"
	//kblu = "\x1B[34m"
	kmag = "\x1B[35m"
	kcyn = "\x1B[36m"
	kwht = "\x1B[37m"
)

func (b *OGame) log(prefix, color string, v ...any) {
	if !b.quiet {
		_, f, l, _ := runtime.Caller(2)
		args := append([]any{fmt.Sprintf(color+"%s"+knrm+" [%s:%d]", prefix, filepath.Base(f), l)}, v...)
		b.logger.Println(args...)
	}
}

func (b *OGame) trace(v ...any) {
	b.log("TRAC", kwht, v...)
}

func (b *OGame) info(v ...any) {
	b.log("INFO", kcyn, v...)
}

func (b *OGame) warn(v ...any) {
	b.log("WARN", kyel, v...)
}

func (b *OGame) error(v ...any) {
	b.log("ERRO", kred, v...)
}

func (b *OGame) critical(v ...any) {
	b.log("CRIT", kred, v...)
}

func (b *OGame) debug(v ...any) {
	b.log("DEBU", kmag, v...)
}

func (b *OGame) println(v ...any) {
	b.log("PRIN", kwht, v...)
}


text:
import "./App.css";
import NavBar from "./components/NavBar/NavBar";
import Footer from "./components/Footer/Footer";
import AboutMe from "./pages/AboutMe/AboutMe";
import Portfolio from "./components/Portfolio/Portfolio";
import Contact from "./pages/Contact/Contact";

import { BrowserRouter as Router, Route, Switch } from "react-router-dom";
// import {
//   ApolloClient,
//   InMemoryCache,
//   ApolloProvider,
//   createHttpLink,
//   useQuery,
//   gql,
// } from "@apollo/client";
// import { setContext } from "@apollo/client/link/context";
// const client = new ApolloClient({
//   uri: "/graphql",
//   cache: new InMemoryCache(),
// });

function App() {
  return (
    <Router>
      <NavBar />
      <Route exact path="/">
        <AboutMe />
      </Route>
      <Route exact path="/portfolio">
        <Portfolio />
      </Route>
      <Route exact path="/contact">
        <Contact />
      </Route>
      <Footer />
    </Router>
  );
}

export default App;

extension: js


text:
// Code generated by protoc-gen-go.
// source: hapi/chart/metadata.proto
// DO NOT EDIT!

package chart

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

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

type Metadata_Engine int32

const (
	Metadata_UNKNOWN Metadata_Engine = 0
	Metadata_GOTPL   Metadata_Engine = 1
)

var Metadata_Engine_name = map[int32]string{
	0: "UNKNOWN",
	1: "GOTPL",
}
var Metadata_Engine_value = map[string]int32{
	"UNKNOWN": 0,
	"GOTPL":   1,
}

func (x Metadata_Engine) String() string {
	return proto.EnumName(Metadata_Engine_name, int32(x))
}
func (Metadata_Engine) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{1, 0} }

// Maintainer describes a Chart maintainer.
type Maintainer struct {
	// Name is a user name or organization name
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// Email is an optional email address to contact the named maintainer
	Email string `protobuf:"bytes,2,opt,name=email" json:"email,omitempty"`
}

func (m *Maintainer) Reset()                    { *m = Maintainer{} }
func (m *Maintainer) String() string            { return proto.CompactTextString(m) }
func (*Maintainer) ProtoMessage()               {}
func (*Maintainer) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }

// 	Metadata for a Chart file. This models the structure of a Chart.yaml file.
//
// 	Spec: https://k8s.io/helm/blob/master/docs/design/chart_format.md#the-chart-file
type Metadata struct {
	// The name of the chart
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// The URL to a relevant project page, git repo, or contact person
	Home string `protobuf:"bytes,2,opt,name=home" json:"home,omitempty"`
	// Source is the URL to the source code of this chart
	Sources []string `protobuf:"bytes,3,rep,name=sources" json:"sources,omitempty"`
	// A SemVer 2 conformant version string of the chart
	Version string `protobuf:"bytes,4,opt,name=version" json:"version,omitempty"`
	// A one-sentence description of the chart
	Description string `protobuf:"bytes,5,opt,name=description" json:"description,omitempty"`
	// A list of string keywords
	Keywords []string `protobuf:"bytes,6,rep,name=keywords" json:"keywords,omitempty"`
	// A list of name and URL/email address combinations for the maintainer(s)
	Maintainers []*Maintainer `protobuf:"bytes,7,rep,name=maintainers" json:"maintainers,omitempty"`
	// The name of the template engine to use. Defaults to 'gotpl'.
	Engine string `protobuf:"bytes,8,opt,name=engine" json:"engine,omitempty"`
}

func (m *Metadata) Reset()                    { *m = Metadata{} }
func (m *Metadata) String() string            { return proto.CompactTextString(m) }
func (*Metadata) ProtoMessage()               {}
func (*Metadata) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }

func (m *Metadata) GetMaintainers() []*Maintainer {
	if m != nil {
		return m.Maintainers
	}
	return nil
}

func init() {
	proto.RegisterType((*Maintainer)(nil), "hapi.chart.Maintainer")
	proto.RegisterType((*Metadata)(nil), "hapi.chart.Metadata")
	proto.RegisterEnum("hapi.chart.Metadata_Engine", Metadata_Engine_name, Metadata_Engine_value)
}

var fileDescriptor2 = []byte{
	// 266 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x90, 0x4b, 0x4b, 0xc4, 0x40,
	0x10, 0x84, 0xdd, 0x47, 0x1e, 0xdb, 0xb9, 0x2c, 0x8d, 0x2c, 0xa3, 0xa7, 0x90, 0x93, 0xa7, 0x2c,
	0x28, 0x88, 0x67, 0x41, 0x3c, 0xe8, 0x66, 0x65, 0x51, 0x04, 0x6f, 0x63, 0xd2, 0x98, 0x41, 0x93,
	0x09, 0x33, 0xa3, 0xe2, 0x3f, 0xf1, 0xe7, 0x3a, 0xe9, 0x7d, 0x1e, 0x3c, 0x04, 0xaa, 0xea, 0x4b,
	0xd7, 0xd0, 0x0d, 0x27, 0xb5, 0xec, 0xd4, 0xbc, 0xac, 0xa5, 0x71, 0xf3, 0x86, 0x9c, 0xac, 0xa4,
	0x93, 0x79, 0x67, 0xb4, 0xd3, 0x08, 0x3d, 0xca, 0x19, 0x65, 0x97, 0x00, 0x0b, 0xa9, 0x5a, 0xe7,
	0x3f, 0x32, 0x88, 0x30, 0x6e, 0x65, 0x43, 0x62, 0x90, 0x0e, 0xce, 0x26, 0x2b, 0xd6, 0x78, 0x0c,
	0x01, 0x35, 0x52, 0x7d, 0x88, 0x21, 0x87, 0x6b, 0x93, 0xfd, 0x0e, 0x21, 0x5e, 0x6c, 0x6a, 0xff,
	0x1d, 0xf3, 0x59, 0xad, 0x7d, 0xb6, 0x9e, 0x62, 0x8d, 0x02, 0x22, 0xab, 0x3f, 0x4d, 0x49, 0x56,
	0x8c, 0xd2, 0x91, 0x8f, 0xb7, 0xb6, 0x27, 0x5f, 0x64, 0xac, 0xd2, 0xad, 0x18, 0xf3, 0xc0, 0xd6,
	0x62, 0x0a, 0x49, 0x45, 0xb6, 0x34, 0xaa, 0x73, 0x3d, 0x0d, 0x98, 0x1e, 0x46, 0x78, 0x0a, 0xf1,
	0x3b, 0xfd, 0x7c, 0x6b, 0x53, 0x59, 0x11, 0x72, 0xed, 0xce, 0xe3, 0x15, 0x24, 0xcd, 0x6e, 0x3d,
	0x2b, 0x22, 0x8f, 0x93, 0xf3, 0x59, 0xbe, 0x3f, 0x40, 0xbe, 0xdf, 0x7e, 0x75, 0xf8, 0x2b, 0xce,
	0x20, 0xa4, 0xf6, 0xcd, 0x6b, 0x11, 0xf3, 0x93, 0x1b, 0x97, 0xa5, 0x10, 0xde, 0xb0, 0xc2, 0x04,
	0xa2, 0xa7, 0xe2, 0xae, 0x58, 0x3e, 0x17, 0xd3, 0x23, 0x9c, 0x40, 0x70, 0xbb, 0x7c, 0x7c, 0xb8,
	0x9f, 0x0e, 0xae, 0xa3, 0x97, 0x80, 0xab, 0x5f, 0x43, 0x3e, 0xf7, 0xc5, 0x5f, 0x00, 0x00, 0x00,
	0xff, 0xff, 0xe5, 0xf8, 0x57, 0xee, 0x8b, 0x01, 0x00, 0x00,
}

repository: skippbox/kmachine

repo_name: skippbox/kmachine

branch_name: refs/heads/kmachine


text:
include(FetchContent)

FetchContent_Declare(
    cmakepp
    GIT_REPOSITORY /data/git/cmakepp.git
    GIT_TAG master
)
FetchContent_GetProperties(cmakepp)
if(NOT cmakepp_POPULATED)
    FetchContent_Populate(cmakepp)
endif()

# include dependencies for cmakepp
include(CheckCXXSourceCompiles)
include(CheckIncludeFile)
include(CheckSymbolExists)
include(CheckLibraryExists)

# set policy for version to work
#cmake_policy(SET CMP0048 NEW)

include(debuglog)
include(${cmakepp_SOURCE_DIR}/cmakepp.cmake)

repository: kettlewell/BuildSys

repo_name: kettlewell/BuildSys


text:
@book{Brown:1977,
  Author = {{Brown}, K.~E.},
  Booktitle = {The Technology of Artificial Lift Methods: Volume 1: Inflow Performance, Multiphase Flow in Pipes, the Flowing Well},
  Publisher = {Petroleum Publishing Co.},
  Title = {{The Technology of Artificial Lift Methods}},
  Year = 1977
}

@article{Griffith:1961,
  Author = {{Griffith}, P. and {Wallis}, G.~B.},
  Title = "{Two-Phase Slug Flow}",
  journal = {J. of Heat Transfer},
  year = 1961,
  month = aug,
  volume = 83,
  number = 3,
  pages = {307--318},
  doi={10.1115/1.3682268},
  url={https://doi.org/10.1115/1.3682268}
}

@article{Beggs:1973,
  Author = {{Beggs}, H.~D. and {Brill}, J.~P.},
  Title = "{A Study of Two-Phase Flow in Inclined Pipes}",
  journal = {Journal of Petroleum Technology},
  year = 1973,
  month = may,
  volume = 25,
  number = 5,
  doi={10.2118/4007-PA},
  url={https://doi.org/10.2118/4007-PA}
}

@article{Payne:1979,
  Author = {{Payne}, G.~A. and {Palmer}, C.~M. and {Brill}, J.~P. and {Beggs}, H.~D.},
  Title = "{Evaluation of Inclined-Pipe, Two-Phase Liquid Holdup and Pressure-Loss Correlations using Experimental Data}",
  journal = {Journal of Petroleum Technology},
  year = 1979,
  month = sep,
  volume=31,
  number=9,
  doi={10.2118/6874-PA},
  url={https://doi.org/10.2118/6874-PA}
}

@article{Ramey:1962,
  Author = {{Ramey}, H.~J.},
  Title = "{Wellbore Heat Transmission}",
  journal = {Journal of Petroleum Technology},
  year = 1962,
  month = apr,
  volume=14,
  number=4,
  doi={10.2118/96-PA},
  url={https://doi.org/10.2118/96-PA}
}

@article{Shiu:1980,
  title="{Predicting temperatures in flowing oil wells}",
  author={{Shiu}, K.~C. and {Beggs}, H.~D.},
  journal={Journal of Energy Resources Technology},
  volume={102},
  number={1},
  year={1980},
  publisher={American Society of Mechanical Engineers},
  doi={10.1115/1.3227845},
  url={https://doi.org/10.1115/1.3227845}
}

@misc{Jones:2019,
  author       = {Daniel C. Jones and
                  Ben Arthur and
                  Tamas Nagy and
                  Mattriks and
                  Shashi Gowda and
                  Godisemo and
                  Tim Holy and
                  Andreas Noack and
                  Avik Sengupta and
                  Darwin Darakananda and
                  Adam B and
                  Simon Leblanc and
                  Iain Dunning and
                  Keno Fischer and
                  David Chudzicki and
                  Morten Piibeleht and
                  Yichao Yu and
                  Tom Breloff and
                  Dave Kleinschmidt and
                  Alex Mellnik and
                  john verzani and
                  inkyu and
                  Mike J Innes and
                  Joey Huchette and
                  Katharine Hyatt and
                  Jared Forsyth and
                  Gio Borje and
                  Elliot Saba and
                  Calder Coalson and
                  Artem Pelenitsyn},
  title        = {GiovineItalia/Gadfly.jl: v1.1.0},
  month        = jul,
  year         = 2019,
  doi          = {10.5281/zenodo.593105},
  url          = {https://doi.org/10.5281/zenodo.593105}
}

gha_language: Julia


text:
@inproceedings{xu18feast,
 address = {Toronto, Canada},
 author = {Xiaoyang Xu and Wenhao Wang and Kevin W. Hamlen and Zhiqiang Lin},
 booktitle = {Proceedings of the 3rd Workshop on Forming an Ecosystem Around Software Transformation (FEAST)},
 month = {October},
 title = {Towards Interface-Driven COTS Binary Hardening},
 year = {2018}
}


text:
SECTION = "devel/chicken"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://gochan.meta;md5=6c97bb6c4de278983b88c8ea3773dfb7"

SRC_URI = "http://code.call-cc.org/egg-tarballs/4/gochan/gochan-${PV}.tar.gz"

SRC_URI[md5sum] = "80a191224ef2e5749c6a152f203435e7"
SRC_URI[sha256sum] = "b4206a86600e9cc8605b1805cc802848d5659bc71da5774b27415a73c0174ee6"

S = "${WORKDIR}/gochan-${PV}"

inherit chicken_install

BBCLASSEXTEND = "cross crosssdk nativesdk"

repository: vulcanoio/meta-chicken

repo_name: vulcanoio/meta-chicken


text:
@InProceedings{bryan13,
  pdf = {http://jmlr.org/proceedings/papers/v28/bryan13.pdf},
  number = {3},
  section = {cycle-3},
  title = {An Efficient Posterior Regularized Latent Variable Model for Interactive Sound Source Separation},
  author = {Bryan, Nicholas and Mysore, Gautham},
  pages = {208-216},
  abstract = {In applications such as audio denoising, music transcription, music remixing, and audio-based forensics, it is desirable to decompose a single-channel recording into its respective sources.  One of the current most effective class of methods to do so is based on non-negative matrix factorization and related latent variable models.  Such techniques, however, typically perform poorly when no isolated training data is given and do not allow user feedback to correct for poor results. To overcome these issues, we allow a user to interactively constrain a latent variable model by painting on a time-frequency display of sound to guide the learning process.  The annotations are used within the framework of posterior regularization to impose linear grouping constraints that would otherwise be difficult to achieve via standard priors.  For the constraints considered, an efficient expectation-maximization algorithm is derived with closed-form multiplicative updates, drawing connections to non-negative matrix factorization methods, and allowing for high-quality interactive-rate separation without explicit training data.},
}

repository: mreid/papersite

repo_name: mreid/papersite


text:
@article{krishna19a,
  title={Compositional Abstractions for Verifying Concurrent Data Structures},
  author={Siddharth Krishna},
  year={2019},
}

@article{krishna19b,
  title={Local Reasoning for Global Graph Properties},
  author={Siddharth Krishna and Alexander J. Summers and Thomas Wies},
  journal={ArXiv},
  year={2019},
  volume={abs/1911.08632}
}

@article{krishna20,
  author    = {Siddharth Krishna and
               Alexander J. Summers and
               Thomas Wies},
  editor    = {Peter M{\"{u}}ller},
  title     = {Local Reasoning for Global Graph Properties},
  booktitle = {Programming Languages and Systems - 29th European Symposium on Programming,
               {ESOP} 2020, Held as Part of the European Joint Conferences on Theory
               and Practice of Software, {ETAPS} 2020, Dublin, Ireland, April 25-30,
               2020, Proceedings},
  series    = {Lecture Notes in Computer Science},
  volume    = {12075},
  pages     = {308--335},
  publisher = {Springer},
  year      = {2020},
  url       = {https://doi.org/10.1007/978-3-030-44914-8\_12},
  doi       = {10.1007/978-3-030-44914-8\_12},
}

repository: bpoettinger/Flow

repo_name: bpoettinger/Flow


text:
SUMMARY = "Hawaii desktop package collection"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COREBASE}/LICENSE;md5=4d92cd373abda3937c2bc47fbc49d690"

inherit packagegroup

RDEPENDS_${PN} = " \
    cinema \
    eyesight \
    greenisland \
    hawaii-icon-theme \
    ${@bb.utils.contains("DISTRO_FEATURES", "wayland", "hawaii-shell", "",d)} \
    hawaii-system-preferences \
    hawaii-terminal \
    hawaii-wallpapers \
    hawaii-widget-styles \
    hawaii-workspace \
    libhawaii \
    qtaccountsservice \
    qtconfiguration \
    swordfish \
"

# wind was a X11 mauios approach. For dependencies (kdeclarative does not build
# for raspi) keep out
# wind


text:
@article{PromotingCoordinatedDevelopment_hucka_2015,
 abstract = {COMBINE (Computational Modeling in Biology Network) is a consortium of groups involved in the development of open community standards and formats used in computational modeling in biology. COMBINE's aim is to act as a coordinator, facilitator, and resource for different standardization efforts whose domains of use cover related areas of the computational biology space. In this perspective article, we summarize COMBINE, its general organization, and the community standards and other efforts involved in it. Our goals are to help guide readers toward standards that may be suitable for their research activities, as well as to direct interested readers to relevant communities where they can best expect to receive assistance in how to develop interoperable computational models.},
 annotation = {00000},
 author = {Hucka, Michael and Nickerson, David P. and Bader, Gary D. and Bergmann, Frank T. and Cooper, Jonathan and Demir, Emek and Garny, Alan and Golebiewski, Martin and Myers, Chris J. and Schreiber, Falk and Waltemath, Dagmar and Le Novère, Nicolas},
 doi = {10.3389/fbioe.2015.00019},
 issn = {2296-4185},
 journal = {Frontiers in Bioengineering and Biotechnology},
 keywords = {Biology,computational modeling,data sharing,File formats,reproducible science,standardization},
 language = {English},
 shorttitle = {Promoting Coordinated Development of Community-Based Information Standards for Modeling in Biology},
 title = {Promoting Coordinated Development of Community-Based Information Standards for Modeling in Biology: The COMBINE Initiative},
 volume = {3},
 year = {2015}
}


text:
LINUX_VERSION = "5.4.54"
LINUX_VERSION_SUFFIX = "-lts"

LIC_FILES_CHKSUM = "file://COPYING;md5=bbea815ee2795b2f4230826c0c6b8814"

SRCREV = "be87fdd9e66c1bdea063b7771af74fdb2b389571"

include linux-socfpga.inc

FILESEXTRAPATHS_prepend := "${THISDIR}/config:"

SRC_URI_append_cyclone5 = " file://lbdaf.scc "
SRC_URI_append_arria5 = " file://lbdaf.scc "
SRC_URI_append_arria10 = " file://lbdaf.scc "
SRC_URI_append_stratix10 = " file://jffs2.scc file://gpio_sys.scc "
SRC_URI_append_agilex = " file://jffs2.scc file://gpio_sys.scc "

repository: acrlinux/acrlinux-yocto

repo_name: acrlinux/acrlinux-yocto


text:
SUMMARY = "IPython Kernel for Jupyter"
SECTION = "devel/python"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://COPYING.md;md5=86d7909bba8bb8a03637ab8020bf6071"

SRC_URI = "https://pypi.python.org/packages/23/7a/a82c599760efe61862154120fece1d877a18657cf9d9b5baf75da4931c8f/ipykernel-4.5.1.tar.gz"

SRC_URI[md5sum] = "08cb3910312d5304d6a9f38957d14b4d"
SRC_URI[sha256sum] = "520c855c6652651c6796a3dd8bc89d533023ac65c5ccf812908187d6f0e461da"

UPSTREAM_CHECK_URI = "https://pypi.python.org/pypi/ipykernel/"
UPSTREAM_CHECK_REGEX = "/ipykernel/(?P<pver>(\d+[\.\-_]*)+)"

S = "${WORKDIR}/ipykernel-${PV}"

inherit setuptools3

RDEPENDS_${PN} += "python3-traitlets python3-tornado python3-jupyter-client python3-ipython"

repository: qtec/meta-qtec-core

repo_name: qtec/meta-qtec-core


text:
@article{reledmac,
  	Author = {Rouquette, Maïeul and Wilson, Peter R.},
    Day = {21},
  	Month = {May},
  	Year = {2018},
  	Publisher = {CTAN},
  	Title = {Reledmac: Typeset scholarly editions with LaTeX},
    Url = {https://www.ctan.org/pkg/reledmac},
    }

repository: stenskjaer/samewords

repo_name: stenskjaer/samewords

gha_language: Python


text:
package main

import (
	. "github.com/onsi/gomega"
	//. "github.com/onsi/gomega/gstruct"
	. "github.com/onsi/gomega/types"
)

func ExpectEntriesToBeEqual(entry1 Entry, entry2 Entry) {
	Expect(entry1.Header).To(Equal(entry2.Header))
	Expect(entry1.Key).To(Equal(entry2.Key))
	Expect(entry1.Value).To(Equal(entry2.Value))
}

func ExpectEntryArraysToBeEqual(entries1 []Entry, entries2 []Entry) bool {
	Expect(entries1).To(HaveLen(len(entries2)))

	for i := 0; i < len(entries1); i++ {
		ExpectEntriesToBeEqual(entries1[i], entries2[i])
	}

	return true
}

func ExpectEntryArraysToBeEqual_IgnoreHead(entries1 []Entry, entries2 []Entry) bool {
	Expect(entries1).To(HaveLen(len(entries2)))

	for i := 0; i < len(entries1); i++ {
		if len(entries1[i].Key) == 0 && len(entries2[i].Key) == 0 {
			continue
		}

		ExpectEntriesToBeEqual(entries1[i], entries2[i])
	}

	return true
}

func ExpectEntriesToBeEquivalent(entry1 Entry, entry2 Entry) {
	header1 := entry1.Header
	header2 := entry2.Header

	Expect(header1.TotalSize).To(Equal(header2.TotalSize))
	Expect(header1.KeySize).To(Equal(header2.KeySize))
	Expect(header1.KeyFormat).To(Equal(header2.KeyFormat))
	Expect(header1.ValueFormat).To(Equal(header2.ValueFormat))
	Expect(header1.EncryptionMethod).To(Equal(header2.EncryptionMethod))

	Expect(entry1.Key).To(Equal(entry2.Key))
	Expect(entry1.Value).To(Equal(entry2.Value))
}

func ExpectEntriesToHaveCommitTimestamp(entries []Entry, commitTimestamp int64) {
	for i := 0; i < len(entries); i++ {
		Expect(entries[i].Header.CommitTime).To(Equal(commitTimestamp))
	}
}
func ExpectEntryArraysToBeEquivalent(entries1 []Entry, entries2 []Entry) {
	Expect(entries1).To(HaveLen(len(entries2)))

	for i := 0; i < len(entries1); i++ {
		if len(entries1[i].Key) == 0 && len(entries2[i].Key) == 0 {
			continue
		}

		ExpectEntriesToBeEquivalent(entries1[i], entries2[i])
	}
}

func ExpectEntryArraysToBeEquivalentWhenCompacted(entries1 []Entry, entries2 []Entry) {
	ExpectEntryArraysToBeEquivalent(CompactEntries(entries1), CompactEntries(entries2))
}

func EqualNumber(expected interface{}) GomegaMatcher {
	return BeNumerically("==", expected)
}

repository: zincbase/zincserver

repo_name: zincbase/zincserver


text:
// Package provides constants that are consumable when designing test suites
package constants

const (
	SuiteInforming = "[Suite: informing] "
	SuiteOperators = "[Suite: operators] "
	// SuiteDummy is used for testing a specific test
	SuiteDummy = "[Suite: dummy] "
)


text:
---
---
@article{khanna2023hssd,
  abbr= {HSSD},
  author={{Khanna*}, Mukul and {Mao*}, Yongsen and Jiang, Hanxiao and Haresh, Sanjay and Shacklett, Brennan and Batra, Dhruv and Clegg, Alexander and Undersander, Eric and Chang, Angel X. and Savva, Manolis},
  title={{Habitat Synthetic Scenes Dataset (HSSD-200): An Analysis of 3D Scene Scale and Realism Tradeoffs for ObjectGoal Navigation 🏘}},
  journal={arXiv preprint},
  year={2023},
  selected={true},
  arxiv={2306.11290},
  html={https://3dlg-hcvc.github.io/hssd},
  code={https://github.com/3dlg-hcvc/hssd/},
  img={assets/img/publications/hssd.gif}
}

@article{homerobotovmm,
  abbr= {OVMM},
  title         =     {HomeRobot: Open Vocab Mobile Manipulation 🤖 🦾},
  author        =     {Sriram Yenamandra and Arun Ramachandran and Karmesh Yadav and Austin Wang and Mukul Khanna and Theophile Gervet and Tsung-Yen Yang and Vidhi Jain and Alex William Clegg and John Turner and Zsolt Kira and Manolis Savva and Angel Chang and Devendra Singh Chaplot and Dhruv Batra and Roozbeh Mottaghi and Yonatan Bisk and Chris Paxton},
  url           =     {https://aihabitat.org/static/challenge/home_robot_ovmm_2023/OVMM.pdf},
  year          =     {2023},
  selected={true},
  journal={arXiv preprint},
  img={assets/img/publications/ovmm.gif},
  arxiv={2306.11565},
  code={https://github.com/facebookresearch/home-robot},
  html={https://ovmm.github.io}
}

@INPROCEEDINGS{emqa,
  abbr= {EMQA},
  author={Datta, Samyak and Dharur, Sameer and Cartillier, Vincent and Desai, Ruta and Khanna, Mukul and Batra, Dhruv and Parikh, Devi},
  year={2022},
  booktitle={CVPR},
  title={Episodic Memory Question Answering 🤖 🎞},
  volume={},
  number={},
  selected={true},
  html={https://samyak-268.github.io/emqa},
  pdf={https://openaccess.thecvf.com/content/CVPR2022/papers/Datta_Episodic_Memory_Question_Answering_CVPR_2022_paper.pdf},
  img={assets/img/publications/emqa2.png},
  doi={}}

@INPROCEEDINGS{emqa,
  abbr= {DeepHS-HDRV},
  author={Khan, Zeeshan and Shettiwar, Parth and Khanna, Mukul and Raman, Shanmuganathan},
  year={2022},
  booktitle={ICPR},
  title={DeepHS-HDRVideo: Deep High Speed High Dynamic Range Video Reconstruction 📸},
  volume={},
  number={},
  arxiv={https://arxiv.org/pdf/2210.04429},
  doi={},
  img={assets/img/publications/deephdrv.gif}
  }

@INPROCEEDINGS{9469450,
  abbr= {BF2NormalNet},
  author={Khanna, Mukul and Sharma, Tanu and Thatavarthy, Ayyappa Swamy and Krishna, K. Madhava},
  year={2021},
  abstract={Surface normal estimation is an essential component of several computer and robot vision pipelines. While this problem has been extensively studied, most approaches are geared towards indoor scenes and often rely on multiple modalities (depth, multiple views) for accurate estimation of normal maps. Outdoor scenes pose a greater challenge as they exhibit significant lighting variation, often contain occluders, and structures like building facades are often ridden with numerous windows and protrusions. Conventional supervised learning schemes excel in indoor scenes, but do not exhibit competitive performance when trained and deployed in outdoor environments. Furthermore, they involve complex network architectures and require many more trainable parameters. To tackle these challenges, we present an adversarial learning scheme that regularizes the output normal maps from a neural network to appear more realistic, by using a small number of precisely annotated examples. Our method presents a lightweight and simpler architecture, while improving performance by at least 1.5x across most metrics. We evaluate our approaches against the state-of-the-art on normal map estimation, on a synthetic and a real outdoor dataset, and observe significant performance enhancements.},
  booktitle={Conference on Robots and Vision (CRV)},
  title={Building Facades to Normal Maps: Adversarial Learning from Single View Images 🏢},
  volume={},
  number={},
  pages={33-40},
  code={https://github.com/mukulkhanna/bf2normalnet},
  html={/building-facade-normal-estimation-crv},
  img={assets/img/publications/teaser.png},
  doi={10.1109/CRV52889.2021.00009}},
  }

@INPROCEEDINGS{8969167,
  abbr= {FHDR},
  author={Khan, Zeeshan and Khanna, Mukul and Raman, Shanmuganathan},
  booktitle={GlobalSIP},
  title={FHDR: HDR Image Reconstruction from a Single LDR Image using Feedback Network 📸},
  year={2019},
  volume={},
  number={},
  pages={1-5},
  abstract={High dynamic range (HDR) image generation from a single exposure low dynamic range (LDR) image has been made possible due to the recent advances in Deep Learning. Various feed-forward Convolutional Neural Networks (CNNs) have been proposed for learning LDR to HDR representations. To better utilize the power of CNNs, we exploit the idea of feedback, where the initial low level features are guided by the high level features using a hidden state of a Recurrent Neural Network. Unlike a single forward pass in a conventional feed-forward network, the reconstruction from LDR to HDR in a feedback network is learned over multiple iterations. This enables us to create a coarse-to-fine representation, leading to an improved reconstruction at every iteration. Various advantages over standard feed-forward networks include early reconstruction ability and better reconstruction quality with fewer network parameters. We design a dense feedback block and propose an end-to-end feedback network-FHDR for HDR image generation from a single exposure LDR image. Qualitative and quantitative evaluations show the superiority of our approach over the state-of-the-art methods.},
  keywords={HDR imaging;Feedback Networks;RNN;Deep Learning},
  doi={10.1109/GlobalSIP45357.2019.8969167},
  ISSN={},
  code={http://github.com/mukulkhanna/fhdr},
  arxiv={1912.11463},
  img={assets/img/publications/fhdr.png},
}

@INPROCEEDINGS{8734309,
  abbr= {URSIM},
  author={Katara, Pushkal and Khanna, Mukul and Nagar, Harshit and Panaiyappan, A.},
  booktitle={Underwater Technology (UT)},
  title={Open Source Simulator for Unmanned Underwater Vehicles using ROS and Unity3D 🐟},
  year={2019},
  volume={},
  number={},
  pages={1-7},
  abstract={The paper presents URSim: an open source 3D underwater simulation framework for Unmanned Underwater Vehicles (UUVs) developed using Robotics Operating System (ROS) and a real-time game engine called Unity3D. Simulation systems like these enable to implement, test, study and analyze complex systems while minimizing cost and disruption to the environment. URSim provides the user an intuitive way to simulate underwater vehicles and robots. It is capable of simulating feedback control systems, dynamic model, underwater vision and mission planning for underwater vehicles and robots. The simulation provides support for underwater sensor modules, underwater physics, collision kinematics and is highly configurable to simulate a realistic underwater environment. The software architecture is adaptive to algorithms for control systems, image processing, navigation and manipulation.},
  keywords={Three-dimensional displays;Solid modeling;Games;Engines;Cameras;Robots;Physics;Simulation;Underwater Robotics;Unity3D;Robotics Operating System},
  doi={10.1109/UT.2019.8734309},
  code={https://github.com/srmauvsoftware/URSim},
  selected={},
  html={https://ieeexplore.ieee.org/document/8734309},
  ISSN={2573-3796},
  img={assets/img/publications/srmauv.gif},
}


text:
package solutions

func reorderList(head *ListNode)  {
    if head == nil {
        return
    }

    var reversed *ListNode

    middle := findListMiddle(head)
    next := middle.Next
    middle.Next = nil

    if next != nil {
        reversed = reverseList(next)
    }

    if reversed != nil {
        mergeList(head, reversed)
    }
}

func reverseList(head *ListNode) *ListNode {
    var previous *ListNode

    current, next := head, head.Next

    for ; current != nil ; {
        current.Next = previous
        previous = current
        current = next

        if next != nil {
            next = next.Next
        }
    }

    return previous
}

func findListMiddle(head *ListNode) *ListNode {
    fast, slow := head, head
    moveSlow := false

    for ; fast.Next != nil; {
        fast = fast.Next

        if moveSlow {
            moveSlow = false
            slow = slow.Next
        } else {
            moveSlow = true
        }
    }

    return slow
}

func mergeList(firstHead *ListNode, secondHead *ListNode) {
    for ; secondHead != nil && firstHead != nil; {
        firstNext := firstHead.Next
        secondNext := secondHead.Next

        firstHead.Next = secondHead
        secondHead.Next = firstNext

        firstHead = firstNext
        secondHead = secondNext
    }
}

repository: justdomepaul/leetcode-golang

repo_name: justdomepaul/leetcode-golang


text:
##############################################################################
# Adding OpenSplics DDS Data Model related files to the build.
#
# $Id: SciOSPLMacros.cmake 792 2015-04-17 14:07:44Z jrobcary $
#
# Copyright 2010-2015, Tech-X Corporation, Boulder, CO.
# See LICENSE file (EclipseLicense.txt) for conditions of use.
#
#
##############################################################################
#
# User should include this macro definition file and use ADD_OSPL_DATAMODEL
# You must include the extension .idl in the name of the data file.  After
# the macro is executed successfully, the variable
#
#        ${datamodel_name}_OSPLDDS_DATAMODEL
#
# will contain a list of all generated files which should be added as source files
# to appropriate executables or libraries.
#
# Typical usage(Add the following to your CMakeLists.txt):
#
#    # Generate DDS bindings from Chat.idl file
#    include(SciOSPLMacros)
#    ADD_OSPL_DATAMODEL(NAME CHAT_KA
#                       IDLS Chat.idl MoreIDLAllowed.idl
#                       IDL_PREFIX ${CMAKE_CURRENT_SOURCE_DIR}
#                       GENDIR "gen"
#    )
#
#    INCLUDE_DIRECTORIES(${INCLUDES} ${CMAKE_CURRENT_BINARY_DIR}/gen)
#
#    SET(CHATTER_KA_SRCS Chatter.cpp CheckStatus.cpp ${CHAT_KA_OSPLDDS_DATAMODEL})
#    ADD_EXECUTABLE(chat_ka_ospl ${CHATTER_KA_SRCS})
#
# TO-DOs:
#
#    * Better and more informative messages
#    * More comments?
#    * Better error handling/robustness.
#
##############################################################################

# Macro to create a list with all the generated source files for a given .idl filename
macro(DEFINE_OpenSplice_LANG_SOURCES lang idl)
        set(gensources)
        get_filename_component(icore ${idl} NAME_WE)
        if ("${lang}" STREQUAL "cpp")
                set(gensources ${gensources} ${icore}.cpp ${icore}.h)
                set(gensources ${gensources} ${icore}Dcps.cpp ${icore}Dcps.h)
                set(gensources ${gensources} ${icore}Dcps_impl.cpp ${icore}Dcps_impl.h)
                set(gensources ${gensources} ${icore}SplDcps.cpp ${icore}SplDcps.h)
                set(gensources ${gensources} ccpp_${icore}.h)
        elseif ("${lang}" STREQUAL "c")
                set(gensources ${gensources} ${icore}.h)
                set(gensources ${gensources} ${icore}Dcps.h)
                set(gensources ${gensources} ${icore}SacDcps.c ${icore}SacDcps.h)
                set(gensources ${gensources} ${icore}SplDcps.c ${icore}SplDcps.h)
        endif ()
endmacro(DEFINE_OpenSplice_LANG_SOURCES)

#####
# Macro:
#       ADD_OSPL_DATAMODEL(NAME datamodel_name  # Name of the data model
#                          IDLS idl1 idl2 ...   # A list of IDL files
#                                               # defining the data model
#                                               # can be referred by relative
#                                               # or absolute paths
#                          LANG [cpp|c|java]    # Only cpp and c are supported
#                                               # for now.  If not defined,
#                                               # cpp mapping will be used
#                          IDL_PREFIX           # Optional IDL path prefix
#                                               # No trailing slash(fix me)
#                          IDL_INCLUDES p1 p2.. # Optional list of IDL include
#                                               # paths
#                          GENDIR path          # Optional directory for
#                                               # generated files
#                                               # No trailing slash(fix me)
#                          GENERATED_IDLS       # IDL files are generated at run time
#                                               # Define this option to skip file
#                                               # existence checks
#       )
#
# Assumption:
#       This macro assumes the OpenSplice_IDLGEN_BINARY and OSPL_HOME
#       have been properly defined.  Cmake 2.8.3 or above is requires.
#
# Output:
#       The following variables are defined after the
#       ADD_OSPL_DATAMODEL is executed successfully.
#       ${datamodel_name}_OSPLDDS_DATAMODEL contains all the generated
#       files(header and implementation files.)  Obviously, if GENDIR
#       option is defined, it needs to be "included" for compilation.
#
# bugs:
#       LANG is currently ignored.  assume we always deal with cpp mapping.
#       not a whole lot of error checkings now.

include(CMakeParseArguments)
macro(ADD_OSPL_DATAMODEL)
    CMAKE_PARSE_ARGUMENTS(SCIADM
        "GENERATED_IDLS"
        "NAME;GENDIR;LANG;IDL_PREFIX"
        "IDLS;IDL_INCLUDES"
        ${ARGN}
        )

# We must have a target name, or else, no way to proceed
    if (DEFINED SCIADM_NAME)
        message(INFO " Add datamodel: ${SCIADM_NAME}")
    else ()
        message(FATAL_ERROR "ADD_OSPL_DATAMODEL: No datamodel name defined.")
    endif ()

# Check if a non-supported language mapping is used
    if (NOT SCIADM_LANG)
        message("Use default cpp mapping for datamodel ${SCIADM_NAME}")
        set(SCIADM_LANG "cpp")
    endif ()
    if ((NOT "${SCIADM_LANG}" STREQUAL "cpp") AND(NOT "${SCIADM_LANG}" STREQUAL "c"))
       message(FATAL_ERROR "Langauage mapping for ${SCIADM_LANG} is not supported by ADD_OSPL_DATAMODEL.  Use either cpp or c mappings.")
    else ()
       message("Language mapping for ${SCIADM_NAME} is ${SCIADM_LANG}")
    endif ()

# Go thru all the IDL files.  Prepend IDL_PREFIX if defined.(IDL_PREFIX must not end with '/').
# We can easily fix this.
    set(allidls)
    foreach (idl ${SCIADM_IDLS})
        # check existance of all IDLS
        if (DEFINED SCIADM_IDL_PREFIX)
            set(idl ${SCIADM_IDL_PREFIX}/${idl})
        endif ()
        if (${SCIADM_GENERATED_IDLS})
            set(allidls ${allidls} ${idl})
        elseif (EXISTS ${idl})
            message("Adding ${idl} to ${SCIADM_NAME} datamodel")
            set(allidls ${allidls} ${idl})
        else ()
            message(WARNING "IDL file(${idl}) does not exist, skipped!")
        endif ()
    endforeach (idl)

    if ("${allidls}" STREQUAL "")
        message(FATAL_ERROR "ADD_OSPL_DATAMODEL: Must provide at least one valid datamodel IDL.")
    endif ()

    set(ospl_idlgen_include_dirs)
    if (DEFINED SCIADM_IDL_INCLUDES)
        foreach (dir ${SCIADM_IDL_INCLUDES})
            # @@ We should probably check if the dir actually exists and warn otherwise?
            set(ospl_idlgen_include_dirs ${ospl_idlgen_include_dirs} "-I${dir}")
        endforeach (dir)
    endif ()

    set(iall_ospldds_datamodel)
    foreach (idl ${allidls})
        get_filename_component(ipath ${idl} PATH)
        get_filename_component(iname ${idl} NAME)
        set(idlgen_args "-S" "-l" "${SCIADM_LANG}" "-I${ipath}")
        DEFINE_OpenSplice_LANG_SOURCES(${SCIADM_LANG} ${iname})
        if (DEFINED SCIADM_GENDIR)
            set(idlgen_args ${idlgen_args} "-d" ${SCIADM_GENDIR})
            set(igensources)
            foreach (igen ${gensources})
                set(igensources ${igensources} "${SCIADM_GENDIR}/${igen}")
            endforeach (igen)
        else ()
            set(igensources ${gensources})
        endif ()
        ADD_CUSTOM_COMMAND(
                OUTPUT ${igensources}
                COMMAND ${OpenSplice_EXEC}
                ARGS ${OpenSplice_idlpp} ${idlgen_args} ${idl}
                DEPENDS ${idl}
        )
        set(iall_ospldds_datamodel ${iall_ospldds_datamodel} ${igensources})
    endforeach (idl)

    set(${SCIADM_NAME}_OSPLDDS_DATAMODEL ${iall_ospldds_datamodel})

endmacro(ADD_OSPL_DATAMODEL)

repository: UKFELs/Puffin

repo_name: UKFELs/Puffin

gha_license_id: NOASSERTION

gha_language: Fortran


text:
jQuery(document).ready(function($){
	function toggleNav(bool) {
		$('.cd-nav-container, .cd-overlay').toggleClass('is-visible', bool);
		$('main').toggleClass('scale-down', bool);
		$('body').toggleClass('navigation-visible', bool);
	}

	//open navigation clicking the menu icon
	$('.cd-nav-trigger').on('click', function(event){
		event.preventDefault();
		toggleNav(true);
	});

	//close the navigation
	$('.cd-close-nav, .cd-overlay').on('click', function(event){
		event.preventDefault();
		toggleNav(false);
	});
if (navigator.userAgent.indexOf('Mac OS X') != -1) {
	$("body").addClass("mac");
	} else {
	$("body").addClass("pc");
}

	$(".listview").click(function (e) {
		$(".listview").removeClass('active');
		$(".grigview").addClass('active');
	});
	$(".grigview").click(function (e) {
		$(".listview").addClass('active');
		$(".grigview").removeClass('active');
	});
	    $( "#draggable_area" ).sortable();
    $( "#draggable_area" ).disableSelection();
	$("select#children").on("change", function() {
    var number = parseInt($("#children").val());
    var newDropLabel = $("#childrenAge").append("<label>Age of children: </label>");
    var newDropList = $('<select class="Age"><option value="0">0</option><option value="1">1</option><option value="2">2</option><option value="3">3</option><option value="4">4</option><option value="5">5</option><option value="6">6</option><option value="7">7</option><option value="8">8</option><option value="9">9</option><option value="10">10</option><option value="11">11</option><option value="12">12</option><option value="13">13</option><option value="14">14</option><option value="15">15</option><option value="16">16</option></select>');
    $("div#childrenAge").append(newDropLabel);
    for (i = 0; i < number; i++) {
       $("div#childrenAge").append(newDropList);
    };
});

});

repository: sarkeralamin/htmljquery

repo_name: sarkeralamin/htmljquery


text:
SECTION = "console/network"
DESCRIPTION ="tinc is a Virtual Private Network (VPN) daemon"
HOMEPAGE = "http://www.tinc-vpn.org/"
LICENSE = "GPLv2"
PR = "r2"

SRC_URI="file://tinc.tar.gz \
         file://config.h \
        "

DEPENDS = "openssl lzo zlib"
RRECOMMENDS_${PN} = "kernel-module-tun"

LIC_FILES_CHKSUM = "file://COPYING;md5=484c42304943a26b6d93144f89a2636c"

S = "${WORKDIR}/tinc"

inherit autotools

EXTRA_OECONF = "--disable-maintainer-mode"

do_configure() {
	oe_runconf
}

do_fixsource() {
	cp "${THISDIR}"/files/config.h "${S}"
	sed -i 's/SUBDIRS = m4 src doc/SUBDIRS = m4 src/' "${B}"/Makefile
}

do_compile() {
	oe_runmake
}

do_install() {
        oe_runmake install DESTDIR=${D}
}

addtask fixsource before do_compile after do_configure

SRC_URI[md5sum] = "a8c168227fa42cbfcd4983247bf609ca"
SRC_URI[sha256sum] = "2b4319ddb3bd2867e72532a233f640a58c2f4d83f1088183ae544b268646ba21"

repository: sogaard/meta-ubmc

repo_name: sogaard/meta-ubmc


text:
package oam

import (
	"free5gc/lib/http_wrapper"
	"free5gc/lib/openapi"
	"free5gc/lib/openapi/models"
	"free5gc/src/amf/logger"
	"free5gc/src/amf/producer"
	"github.com/gin-gonic/gin"
	"net/http"
)

func setCorsHeader(c *gin.Context) {
	c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
	c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
	c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
	c.Writer.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS, GET, PUT, PATCH, DELETE")
}

func HTTPRegisteredUEContext(c *gin.Context) {
	setCorsHeader(c)

	req := http_wrapper.NewRequest(c.Request, nil)
	if supi, exists := c.Params.Get("supi"); exists {
		req.Params["supi"] = supi
	}

	rsp := producer.HandleOAMRegisteredUEContext(req)

	responseBody, err := openapi.Serialize(rsp.Body, "application/json")
	if err != nil {
		logger.MtLog.Errorln(err)
		problemDetails := models.ProblemDetails{
			Status: http.StatusInternalServerError,
			Cause:  "SYSTEM_FAILURE",
			Detail: err.Error(),
		}
		c.JSON(http.StatusInternalServerError, problemDetails)
	} else {
		c.Data(rsp.Status, "application/json", responseBody)
	}
}


text:
require recipes/dreambox/dreambox-dvb-modules.inc

PR = "${INC_PR}.0"

SRC_URI[modules.md5sum] = "c610ff233018f9b07fda859073559859"
SRC_URI[modules.sha256sum] = "d0bd78c9722141d2d892a1e9e21f5851011fccde3428bff21e224dcca199febc"

FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"

repository: kiyala/op

repo_name: kiyala/op


text:
package encoder

import (
	syst "github.com/cortezaproject/corteza-server/system/types"
)

type (
	multiple uint

	field struct {
		name           string
		encodeAllMulti bool
	}

	FlatWriter interface {
		Write([]string) error
		Flush()
	}

	StructuredEncoder interface {
		Encode(interface{}) error
	}

	userFinder func(ID uint64) (*syst.User, error)

	flatWriter struct {
		w  FlatWriter
		ff []field
		u  userFinder
		tz string
	}

	structuredEncoder struct {
		w  StructuredEncoder
		ff []field
		u  userFinder
		tz string
	}
)

func Field(name string) field {
	return field{name: name}
}

func MakeFields(nn ...string) []field {
	ff := make([]field, len(nn))
	for i := range nn {
		ff[i] = field{name: nn[i]}
	}

	return ff
}

func preprocessHeader(hh []field, tz string) []field {
	nhh := make([]field, 0)

	// We need to prepare additional header fields for exporting
	if tz != "" && tz != "UTC" {
		for _, f := range hh {
			switch f.name {
			case "createdAt",
				"updatedAt",
				"deletedAt":

				nhh = append(nhh, f, field{name: f.name + "_date"}, field{name: f.name + "_time"})
				break
			default:
				nhh = append(nhh, f)
				break
			}
		}
	} else {
		return hh
	}
	return nhh
}

func MultiValueField(name string) field {
	return field{name: name, encodeAllMulti: true}
}

func NewFlatWriter(w FlatWriter, header bool, u userFinder, tz string, ff ...field) *flatWriter {
	f := &flatWriter{
		w:  w,
		ff: preprocessHeader(ff, tz),
		u:  u,
		tz: tz,
	}

	if header {
		f.writeHeader()
	}

	return f
}

func (enc flatWriter) Flush() {
	enc.w.Flush()
}

func (enc flatWriter) writeHeader() {
	ss := make([]string, len(enc.ff))
	for i := range enc.ff {
		ss[i] = enc.ff[i].name
	}

	_ = enc.w.Write(ss)
}

func NewStructuredEncoder(w StructuredEncoder, u userFinder, tz string, ff ...field) *structuredEncoder {
	return &structuredEncoder{
		w: w,
		// No need for additional timezone headers, since the output is structured
		ff: ff,
		u:  u,
		tz: tz,
	}
}

func (enc structuredEncoder) Flush() {
	// noop
}


text:
@inproceedings{chen2020named,
    title = "Named Entity Recognition in Multi-level Contexts",
    author = "Chen, Yubo  and
      Wu, Chuhan  and
      Qi, Tao  and
      Yuan, Zhigang  and
      Huang, Yongfeng",
    booktitle = "Proceedings of the 1st Conference of the Asia-Pacific Chapter of the Association for Computational Linguistics and the 10th International Joint Conference on Natural Language Processing",
    month = dec,
    year = "2020",
    address = "Suzhou, China",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2020.aacl-main.22",
    pages = "181--190",
}

url: https://raw.githubusercontent.com/rbt-c/DL-NLP-Readings/82ca76e9184a3b00ac87129d99391477c85cfcd2/Bibtex/Named Entity Recognition in Multi-level Contexts.bib

repository: rbt-c/DL-NLP-Readings

repo_name: rbt-c/DL-NLP-Readings


text:
@inproceedings{agis2004,
  title = {Sistema de control basado en visión y propiacepción de robots con FPGA},
  author = {Agís, R. and Ros, E. and Díaz, J. and Mota, S. and Carrillo, R. and Ortigosa, E. and Pelayo, F. and Prieto, A.},
  booktitle = {JCRA'2004: IV Jornadas sobre Computación Reconfigurable y Aplicaciones},
  pages = {667--674},
  year = {2004},
  organization = {Cephis, Escuela Técnica Superior de Ingenierias, Universitat Autònoma de Barcelona}
}

repository: EduardoRosLab/neurorobotics-website

repo_name: EduardoRosLab/neurorobotics-website


text:
This BibTeX file is made available under the Public Domain Dedication and License v1.0 whose full text can be found in the accompanying README file or online at http://www.opendatacommons.org/licenses/pddl/1.0/

@Article{2006-Perlovsky,
	Author = "Leonid I. Perlovsky",
	Title = "{Toward physics of the mind: concepts, emotions, consciousness, and symbols}",
	Journal = "Physics of Life Reviews",
	Volume = "3",
	Pages = "23–55",
	keywords = "creativity",
	localfile = {2006 - Toward physics of the mind: concepts, emotions, consciousness, and symbols.pdf},
	read = "2013-08-01",
	year = 2006
}

@Article{2009-Perlovsky,
	Author = "Leonid Perlovsky",
	Title = "{Language and cognition}",
	Journal = "Neural Networks",
	Volume = "22",
	Pages = "247–257",
	doi = "10.1016/j.neunet.2009.03.007",
	keywords = "language; cognition",
	localfile = {2009 - Language and cognition.pdf},
	rating = "2",
	read = "2013-07-12",
	year = 2009
}

@Article{2010-Khashman,
	Author = "Adnan Khashman",
	Title = "{Modeling congitive and emotional processes: a novel neural network architecture}",
	Journal = "Neural Networks",
	Volume = "23",
	Pages = "1155–1163",
	Note = "Page 1156: Our hypothesis is that the emotional and cognitive processes which are activated by visual stimuli, such as an image, can be modeled in machines, and the way to model these two kinds of processes, is to clearly define separate 'routes' for emotional and congitive information within the model, while processing the information collectively. (...) We associate the ventral/emotional information with global representation of input visual stimuli and the dorsal/cognitive information with the local representation.",
	doi = "10.1016/j.neunet.2010.07.004",
	keywords = "neural network; emotion; cognition",
	localfile = {2010 - Modeling cognitive and emotional processes: a novel neural network architecture.pdf},
	rating = "2",
	read = "2013-08-20",
	year = 2010
}

@Article{2010-Neuman-Nave,
	Author = "Yair Neuman and Ophir Nave",
	Title = "{Why the brain needs language in order ot be self-conscious}",
	Journal = "New Ideas Psychol.",
	Volume = "38",
	Pages = "37–48",
	Note = "Gathers some stimulating ideas from previous literature and suggests a general mechanism by which the capacity of language to refer to itself is central to the ability of the human mind to reflect on itself. The discussion is grounded in dynamical systems, the reconstruction of their phase space trajectories and recurrent points, although the technical details of how this applies to the brain this are not substantial.",
	doi = "10.1016/j.newideapsych.2009.05.001",
	keywords = "self-consciousness; inner speech; dynamical systems",
	localfile = {2010 - Why the brain needs language in order to be self-conscious.pdf},
	rating = "2",
	read = "2013-08-17",
	year = 2010
}

@Article{2012-Rabinovich-ABV,
	Author = "Mikhail I. Rabinovich and Valentin S. Afraimovich and Christian Bick and Pablo Varona",
	Title = "{Information flow dynamics in the brain}",
	Journal = "Physics of Life Reviews",
	Volume = "9",
	Pages = "51–73",
	Note = "The math is not very clear, but provides a good overview and entry points to more detailed literature.",
	doi = "10.1016/j.plrev.2011.11.002",
	keywords = "information creation; information flow; mental disorders; heteroclinic channel",
	localfile = {2012 - Information flow dynamics in the brain.pdf},
	rating = "2",
	read = "2013-10-05",
	year = 2012
}

@Article{2013-Ridder-VV,
	Author = "Dirk De Ridder and Jan Verplaetse and Sven Vanneste",
	Title = "{The predictive brain and the 'free will' illusion}",
	Journal = "Front. Psychol.",
	Volume = "4",
	Number = "131",
	Note = "Intruiging comments about the evolutionary basis of the experience of free will.",
	doi = "10.3389/fpsyg.2013.00131",
	localfile = {2013 - The predictive brain and the 'free will' illusion.pdf},
	rating = "2",
	read = "2013-06-19",
	type = "Commentary",
	year = 2013
}

@Article{2015-Joels-LE,
	Author = "Marian Joëls and Monica Di Luca and Barry J. Everitt",
	Title = "{Neuro opinion: reforming the academic system is a joint responsibility}",
	Journal = "Eur. J. Neurosci.",
	doi = "10.1111/ejn.12886",
	localfile = {2015 - Neuro opinion: reforming the academic system is a joint responsibility.pdf},
	read = "2015-04-28",
	type = "Opinion",
	year = 2015
}

repository: langner/library

repo_name: langner/library