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

package controllers

import (
	"context"
	"fmt"

	"github.com/FoundationDB/fdb-kubernetes-operator/pkg/fdbadminclient/mock"

	"k8s.io/utils/pointer"

	"github.com/FoundationDB/fdb-kubernetes-operator/internal"

	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"

	fdbv1beta2 "github.com/FoundationDB/fdb-kubernetes-operator/api/v1beta2"
)

var _ = Describe("remove_process_groups", func() {
	var cluster *fdbv1beta2.FoundationDBCluster
	var result *requeue

	Context("validating process removal", func() {
		BeforeEach(func() {
			cluster = internal.CreateDefaultCluster()
			err := k8sClient.Create(context.TODO(), cluster)
			Expect(err).NotTo(HaveOccurred())

			result, err := reconcileCluster(cluster)
			Expect(err).NotTo(HaveOccurred())
			Expect(result.Requeue).To(BeFalse())

			generation, err := reloadCluster(cluster)
			Expect(err).NotTo(HaveOccurred())
			Expect(generation).To(Equal(int64(1)))
		})

		JustBeforeEach(func() {
			result = removeProcessGroups{}.reconcile(context.TODO(), clusterReconciler, cluster, nil, globalControllerLogger)
		})

		When("trying to remove a coordinator", func() {
			coordinatorIP := "1.1.1.1"
			coordinatorID := fdbv1beta2.ProcessGroupID("storage-1")

			BeforeEach(func() {
				marked, processGroup := fdbv1beta2.MarkProcessGroupForRemoval(cluster.Status.ProcessGroups, coordinatorID, fdbv1beta2.ProcessClassStorage, coordinatorIP)
				Expect(marked).To(BeTrue())
				Expect(processGroup).To(BeNil())
			})

			It("should not remove the coordinator", func() {
				Expect(result).NotTo(BeNil())
				Expect(result.message).To(Equal("Reconciliation needs to exclude more processes"))
			})

			It("should exclude the coordinator from the process group list to remove", func() {
				remaining := map[string]bool{
					coordinatorIP: false,
				}

				coordSet := map[string]fdbv1beta2.None{
					coordinatorIP: {},
				}

				allExcluded, newExclusions, processes := clusterReconciler.getProcessGroupsToRemove(globalControllerLogger, cluster, remaining, coordSet)
				Expect(allExcluded).To(BeFalse())
				Expect(processes).To(BeEmpty())
				Expect(newExclusions).To(BeFalse())
			})
		})

		When("removing a process group", func() {
			var removedProcessGroup *fdbv1beta2.ProcessGroupStatus

			BeforeEach(func() {
				removedProcessGroup = cluster.Status.ProcessGroups[0]
				marked, processGroup := fdbv1beta2.MarkProcessGroupForRemoval(cluster.Status.ProcessGroups, removedProcessGroup.ProcessGroupID, removedProcessGroup.ProcessClass, removedProcessGroup.Addresses[0])
				Expect(marked).To(BeTrue())
				Expect(processGroup).To(BeNil())
				// Exclude the process group
				adminClient, err := mock.NewMockAdminClientUncast(cluster, k8sClient)
				Expect(err).NotTo(HaveOccurred())
				for _, address := range removedProcessGroup.Addresses {
					adminClient.ExcludedAddresses[address] = fdbv1beta2.None{}
				}
			})

			When("using the default setting of EnforceFullReplicationForDeletion", func() {
				When("the cluster is fully replicated", func() {
					It("should successfully remove that process group", func() {
						Expect(result).To(BeNil())
						// Ensure resources are deleted
						removed, include, err := confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, removedProcessGroup.ProcessGroupID)
						Expect(err).To(BeNil())
						Expect(removed).To(BeTrue())
						Expect(include).To(BeTrue())
					})
				})

				When("the cluster has degraded availability fault tolerance", func() {
					BeforeEach(func() {
						adminClient, err := mock.NewMockAdminClientUncast(cluster, k8sClient)
						Expect(err).NotTo(HaveOccurred())
						adminClient.MaxZoneFailuresWithoutLosingAvailability = pointer.Int(0)
					})

					It("should not remove that process group", func() {
						Expect(result).NotTo(BeNil())
						Expect(result.message).To(Equal("Removals cannot proceed because cluster has degraded fault tolerance"))
						// Ensure resources are not deleted
						removed, include, err := confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, removedProcessGroup.ProcessGroupID)
						Expect(err).To(BeNil())
						Expect(removed).To(BeFalse())
						Expect(include).To(BeFalse())
					})
				})

				When("the cluster has degraded data fault tolerance", func() {
					BeforeEach(func() {
						adminClient, err := mock.NewMockAdminClientUncast(cluster, k8sClient)
						Expect(err).NotTo(HaveOccurred())
						adminClient.MaxZoneFailuresWithoutLosingData = pointer.Int(0)
					})

					It("should not remove that process group", func() {
						Expect(result).NotTo(BeNil())
						Expect(result.message).To(Equal("Removals cannot proceed because cluster has degraded fault tolerance"))
						// Ensure resources are not deleted
						removed, include, err := confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, removedProcessGroup.ProcessGroupID)
						Expect(err).To(BeNil())
						Expect(removed).To(BeFalse())
						Expect(include).To(BeFalse())
					})
				})

				When("the cluster is not available", func() {
					BeforeEach(func() {
						adminClient, err := mock.NewMockAdminClientUncast(cluster, k8sClient)
						Expect(err).NotTo(HaveOccurred())
						adminClient.FrozenStatus = &fdbv1beta2.FoundationDBStatus{
							Client: fdbv1beta2.FoundationDBStatusLocalClientInfo{
								DatabaseStatus: fdbv1beta2.FoundationDBStatusClientDBStatus{
									Available: false,
								},
							},
						}
					})

					It("should not remove the process group and should not exclude processes", func() {
						Expect(result).NotTo(BeNil())
						Expect(result.message).To(Equal("Reconciliation needs to exclude more processes"))
						// Ensure resources are not deleted
						removed, include, err := confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, removedProcessGroup.ProcessGroupID)
						Expect(err).To(BeNil())
						Expect(removed).To(BeFalse())
						Expect(include).To(BeFalse())
					})
				})
			})

			When("Removing multiple process groups", func() {
				var initialCnt int
				var secondRemovedProcessGroup *fdbv1beta2.ProcessGroupStatus

				When("the removal mode is the default zone", func() {
					BeforeEach(func() {
						Expect(cluster.Spec.AutomationOptions.RemovalMode).To(BeEmpty())
						initialCnt = len(cluster.Status.ProcessGroups)
						secondRemovedProcessGroup = cluster.Status.ProcessGroups[1]
						marked, processGroup := fdbv1beta2.MarkProcessGroupForRemoval(cluster.Status.ProcessGroups, secondRemovedProcessGroup.ProcessGroupID, secondRemovedProcessGroup.ProcessClass, removedProcessGroup.Addresses[0])
						Expect(marked).To(BeTrue())
						Expect(processGroup).To(BeNil())
						// Exclude the process group
						adminClient, err := mock.NewMockAdminClientUncast(cluster, k8sClient)
						Expect(err).NotTo(HaveOccurred())
						for _, address := range secondRemovedProcessGroup.Addresses {
							adminClient.ExcludedAddresses[address] = fdbv1beta2.None{}
						}
					})

					It("should remove only one process group", func() {
						Expect(result).To(BeNil())
						Expect(initialCnt - len(cluster.Status.ProcessGroups)).To(BeNumerically("==", 1))
						// Check if resources are deleted
						removed, include, err := confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, removedProcessGroup.ProcessGroupID)
						Expect(err).To(BeNil())
						// Check if resources are deleted
						removedSecondary, includeSecondary, err := confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, secondRemovedProcessGroup.ProcessGroupID)
						Expect(err).To(BeNil())
						// Make sure only one of the process groups was deleted.
						Expect(removed).NotTo(Equal(removedSecondary))
						Expect(include).NotTo(Equal(includeSecondary))
					})

					When("a process group is marked as terminating and all resources are removed it should be removed", func() {
						BeforeEach(func() {
							secondRemovedProcessGroup.ProcessGroupConditions = append(secondRemovedProcessGroup.ProcessGroupConditions, fdbv1beta2.NewProcessGroupCondition(fdbv1beta2.ResourcesTerminating))
							Expect(removeProcessGroup(context.Background(), clusterReconciler, cluster, secondRemovedProcessGroup.ProcessGroupID)).NotTo(HaveOccurred())
						})

						It("should remove the process group and the terminated process group", func() {
							Expect(result).To(BeNil())
							Expect(initialCnt - len(cluster.Status.ProcessGroups)).To(BeNumerically("==", 2))
							// Ensure resources are deleted
							removed, include, err := confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, secondRemovedProcessGroup.ProcessGroupID)
							Expect(err).To(BeNil())
							Expect(removed).To(BeTrue())
							Expect(include).To(BeTrue())
							// Ensure resources are deleted
							removed, include, err = confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, removedProcessGroup.ProcessGroupID)
							Expect(err).To(BeNil())
							Expect(removed).To(BeTrue())
							Expect(include).To(BeTrue())
						})
					})

					When("a process group is marked as terminating and the resources are not removed", func() {
						BeforeEach(func() {
							secondRemovedProcessGroup.ProcessGroupConditions = append(secondRemovedProcessGroup.ProcessGroupConditions, fdbv1beta2.NewProcessGroupCondition(fdbv1beta2.ResourcesTerminating))
						})

						It("should remove the process group and the terminated process group", func() {
							Expect(result).To(BeNil())
							Expect(initialCnt - len(cluster.Status.ProcessGroups)).To(BeNumerically("==", 2))
							// Ensure resources are deleted
							removed, include, err := confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, secondRemovedProcessGroup.ProcessGroupID)
							Expect(err).To(BeNil())
							Expect(removed).To(BeTrue())
							Expect(include).To(BeTrue())
							// Ensure resources are deleted
							removed, include, err = confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, removedProcessGroup.ProcessGroupID)
							Expect(err).To(BeNil())
							Expect(removed).To(BeTrue())
							Expect(include).To(BeTrue())
						})
					})

					When("a process group is marked as terminating and not fully removed", func() {
						BeforeEach(func() {
							secondRemovedProcessGroup.ProcessGroupConditions = append(secondRemovedProcessGroup.ProcessGroupConditions, fdbv1beta2.NewProcessGroupCondition(fdbv1beta2.ResourcesTerminating))
							// Set the wait time to the default value
							cluster.Spec.AutomationOptions.WaitBetweenRemovalsSeconds = pointer.Int(60)
						})

						It("should remove only one process group", func() {
							Expect(result).NotTo(BeNil())
							Expect(result.message).To(HavePrefix("not allowed to remove process groups, waiting:"))
							Expect(initialCnt - len(cluster.Status.ProcessGroups)).To(BeNumerically("==", 0))
							// Ensure resources are not deleted
							removed, include, err := confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, removedProcessGroup.ProcessGroupID)
							Expect(err).To(BeNil())
							Expect(removed).To(BeFalse())
							Expect(include).To(BeFalse())
							// Ensure resources are deleted
							removed, include, err = confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, secondRemovedProcessGroup.ProcessGroupID)
							Expect(err).To(BeNil())
							Expect(removed).To(BeFalse())
							Expect(include).To(BeFalse())
						})
					})
				})

				When("the removal mode is PodUpdateModeAll", func() {
					BeforeEach(func() {
						// To allow multiple process groups to be removed we have to use the update mode all
						cluster.Spec.AutomationOptions.RemovalMode = fdbv1beta2.PodUpdateModeAll
						err := k8sClient.Update(context.TODO(), cluster)
						Expect(err).NotTo(HaveOccurred())

						initialCnt = len(cluster.Status.ProcessGroups)
						secondRemovedProcessGroup = cluster.Status.ProcessGroups[1]
						marked, processGroup := fdbv1beta2.MarkProcessGroupForRemoval(cluster.Status.ProcessGroups, secondRemovedProcessGroup.ProcessGroupID, secondRemovedProcessGroup.ProcessClass, removedProcessGroup.Addresses[0])
						Expect(marked).To(BeTrue())
						Expect(processGroup).To(BeNil())
						// Exclude the process group
						adminClient, err := mock.NewMockAdminClientUncast(cluster, k8sClient)
						Expect(err).NotTo(HaveOccurred())
						for _, address := range secondRemovedProcessGroup.Addresses {
							adminClient.ExcludedAddresses[address] = fdbv1beta2.None{}
						}
					})

					It("should remove two process groups", func() {
						Expect(result).To(BeNil())
						Expect(initialCnt - len(cluster.Status.ProcessGroups)).To(BeNumerically("==", 2))
						// Ensure resources are deleted
						removed, include, err := confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, removedProcessGroup.ProcessGroupID)
						Expect(err).To(BeNil())
						Expect(removed).To(BeTrue())
						Expect(include).To(BeTrue())
						// Ensure resources are deleted as the RemovalMode is PodUpdateModeAll
						removed, include, err = confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, secondRemovedProcessGroup.ProcessGroupID)
						Expect(err).To(BeNil())
						Expect(removed).To(BeTrue())
						Expect(include).To(BeTrue())
					})

					When("a process group is marked as terminating and all resources are removed it should be removed", func() {
						BeforeEach(func() {
							secondRemovedProcessGroup.ProcessGroupConditions = append(secondRemovedProcessGroup.ProcessGroupConditions, fdbv1beta2.NewProcessGroupCondition(fdbv1beta2.ResourcesTerminating))
							err := removeProcessGroup(context.Background(), clusterReconciler, cluster, secondRemovedProcessGroup.ProcessGroupID)
							Expect(err).NotTo(HaveOccurred())
						})

						It("should remove the process group and the terminated process group", func() {
							Expect(result).To(BeNil())
							Expect(initialCnt - len(cluster.Status.ProcessGroups)).To(BeNumerically("==", 2))
							// Ensure resources are deleted
							removed, include, err := confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, secondRemovedProcessGroup.ProcessGroupID)
							Expect(err).To(BeNil())
							Expect(removed).To(BeTrue())
							Expect(include).To(BeTrue())
							// Ensure resources are deleted
							removed, include, err = confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, removedProcessGroup.ProcessGroupID)
							Expect(err).To(BeNil())
							Expect(removed).To(BeTrue())
							Expect(include).To(BeTrue())
						})
					})

					When("a process group is marked as terminating and the resources are not removed", func() {
						BeforeEach(func() {
							secondRemovedProcessGroup.ProcessGroupConditions = append(secondRemovedProcessGroup.ProcessGroupConditions, fdbv1beta2.NewProcessGroupCondition(fdbv1beta2.ResourcesTerminating))
						})

						It("should remove the process group and the terminated process group", func() {
							Expect(result).To(BeNil())
							Expect(initialCnt - len(cluster.Status.ProcessGroups)).To(BeNumerically("==", 2))
							// Ensure resources are deleted
							removed, include, err := confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, secondRemovedProcessGroup.ProcessGroupID)
							Expect(err).To(BeNil())
							Expect(removed).To(BeTrue())
							Expect(include).To(BeTrue())
							// Ensure resources are deleted
							removed, include, err = confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, removedProcessGroup.ProcessGroupID)
							Expect(err).To(BeNil())
							Expect(removed).To(BeTrue())
							Expect(include).To(BeTrue())
						})
					})

					When("a process group is marked as terminating and not fully removed", func() {
						BeforeEach(func() {
							secondRemovedProcessGroup.ProcessGroupConditions = append(secondRemovedProcessGroup.ProcessGroupConditions, fdbv1beta2.NewProcessGroupCondition(fdbv1beta2.ResourcesTerminating))
							// Set the wait time to the default value
							cluster.Spec.AutomationOptions.WaitBetweenRemovalsSeconds = pointer.Int(60)
						})

						It("should remove all process groups", func() {
							Expect(result).To(BeNil())
							Expect(initialCnt - len(cluster.Status.ProcessGroups)).To(BeNumerically("==", 2))
							// Ensure resources are not deleted
							removed, include, err := confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, removedProcessGroup.ProcessGroupID)
							Expect(err).To(BeNil())
							Expect(removed).To(BeTrue())
							Expect(include).To(BeTrue())
							// Ensure resources are deleted
							removed, include, err = confirmRemoval(context.Background(), globalControllerLogger, clusterReconciler, cluster, secondRemovedProcessGroup.ProcessGroupID)
							Expect(err).To(BeNil())
							Expect(removed).To(BeTrue())
							Expect(include).To(BeTrue())
						})
					})
				})
			})
		})

		AfterEach(func() {
			k8sClient.Clear()
		})
	})

	Context("validating getProcessesToInclude", func() {
		var removedProcessGroups map[fdbv1beta2.ProcessGroupID]bool

		BeforeEach(func() {
			cluster = &fdbv1beta2.FoundationDBCluster{
				Status: fdbv1beta2.FoundationDBClusterStatus{
					ProcessGroups: []*fdbv1beta2.ProcessGroupStatus{
						{ProcessGroupID: "storage-1", ProcessClass: "storage", Addresses: []string{"1.1.1.1"}},
						{ProcessGroupID: "storage-2", ProcessClass: "storage", Addresses: []string{"1.1.1.2"}},
						{ProcessGroupID: "storage-3", ProcessClass: "storage", Addresses: []string{"1.1.1.3"}},
						{ProcessGroupID: "stateless-1", ProcessClass: "stateless", Addresses: []string{"1.1.1.4"}},
						{ProcessGroupID: "stateless-2", ProcessClass: "stateless", Addresses: []string{"1.1.1.5"}},
						{ProcessGroupID: "stateless-3", ProcessClass: "stateless", Addresses: []string{"1.1.1.6"}},
						{ProcessGroupID: "stateless-4", ProcessClass: "stateless", Addresses: []string{"1.1.1.7"}},
						{ProcessGroupID: "stateless-5", ProcessClass: "stateless", Addresses: []string{"1.1.1.8"}},
						{ProcessGroupID: "stateless-6", ProcessClass: "stateless", Addresses: []string{"1.1.1.9"}},
						{ProcessGroupID: "stateless-7", ProcessClass: "stateless", Addresses: []string{"1.1.2.1"}},
						{ProcessGroupID: "stateless-8", ProcessClass: "stateless", Addresses: []string{"1.1.2.2"}},
						{ProcessGroupID: "stateless-9", ProcessClass: "stateless", Addresses: []string{"1.1.2.3"}},
						{ProcessGroupID: "globalControllerLogger-1", ProcessClass: "globalControllerLogger", Addresses: []string{"1.1.2.4"}},
						{ProcessGroupID: "globalControllerLogger-2", ProcessClass: "globalControllerLogger", Addresses: []string{"1.1.2.5"}},
						{ProcessGroupID: "globalControllerLogger-3", ProcessClass: "globalControllerLogger", Addresses: []string{"1.1.2.6"}},
						{ProcessGroupID: "globalControllerLogger-4", ProcessClass: "globalControllerLogger", Addresses: []string{"1.1.2.7"}},
					},
				},
				Spec: fdbv1beta2.FoundationDBClusterSpec{
					AutomationOptions: fdbv1beta2.FoundationDBClusterAutomationOptions{
						UseLocalitiesForExclusion: pointer.Bool(true),
					},
				},
			}
			removedProcessGroups = make(map[fdbv1beta2.ProcessGroupID]bool)
		})

		Context("cluster doesn't support inclusions using locality", func() {
			BeforeEach(func() {
				cluster.Spec.Version = fdbv1beta2.Versions.Default.String()
			})

			When("including no process", func() {
				It("should not include any process", func() {
					Expect(len(getProcessesToInclude(cluster, removedProcessGroups))).To(Equal(0))
				})
			})

			When("including one process", func() {
				BeforeEach(func() {
					processGroup := cluster.Status.ProcessGroups[0]
					Expect(processGroup.ProcessGroupID).To(Equal(fdbv1beta2.ProcessGroupID("storage-1")))
					processGroup.MarkForRemoval()
					cluster.Status.ProcessGroups[0] = processGroup

					removedProcessGroups[processGroup.ProcessGroupID] = true
				})

				It("should include one process", func() {
					fdbProcessesToInclude := getProcessesToInclude(cluster, removedProcessGroups)
					Expect(len(fdbProcessesToInclude)).To(Equal(1))
					Expect(fdbv1beta2.ProcessAddressesString(fdbProcessesToInclude, " ")).To(Equal("1.1.1.1"))
					Expect(len(cluster.Status.ProcessGroups)).To(Equal(15))
				})
			})
		})

		Context("cluster support inclusions using locality", func() {
			BeforeEach(func() {
				cluster.Spec.Version = fdbv1beta2.Versions.NextMajorVersion.String()
			})

			When("including no process", func() {
				It("should not include any process", func() {
					fdbProcessesToInclude := getProcessesToInclude(cluster, removedProcessGroups)
					Expect(len(fdbProcessesToInclude)).To(Equal(0))
					Expect(len(cluster.Status.ProcessGroups)).To(Equal(16))
				})
			})

			When("including one process", func() {
				var removedProcessGroup *fdbv1beta2.ProcessGroupStatus

				BeforeEach(func() {
					removedProcessGroup = cluster.Status.ProcessGroups[0]
					Expect(removedProcessGroup.ProcessGroupID).To(Equal(fdbv1beta2.ProcessGroupID("storage-1")))
					removedProcessGroup.MarkForRemoval()
					cluster.Status.ProcessGroups[0] = removedProcessGroup

					removedProcessGroups[removedProcessGroup.ProcessGroupID] = true
				})

				It("should include one process", func() {
					fdbProcessesToInclude := getProcessesToInclude(cluster, removedProcessGroups)
					Expect(len(fdbProcessesToInclude)).To(Equal(2))
					Expect(fdbv1beta2.ProcessAddressesString(fdbProcessesToInclude, " ")).To(Equal(fmt.Sprintf("%s %s", removedProcessGroup.GetExclusionString(), removedProcessGroup.Addresses[0])))
					Expect(len(cluster.Status.ProcessGroups)).To(Equal(15))
				})
			})
		})
	})
})

repository: FoundationDB/fdb-kubernetes-operator

repo_name: FoundationDB/fdb-kubernetes-operator


text:
// This file was taken from:
// https://github.com/OpenBazaar/openbazaar-go/blob/master/core/ulimit_non_unix.go

//go:build !darwin && !linux && !netbsd && !openbsd

package ulimit

// Set is a no-op on non-unix systems
func Set(uint64) error { return nil }

repository: Rwinwij/thresher

license_type: permissive

repo_name: Rwinwij/thresher

branch_name: refs/heads/master

gha_license_id: NOASSERTION

extension: go


text:
@manual{flynn_alastair_daepy,
	title = {DAEpy: a Python library for solving boundary value problems of differential algebraic equations with advanced and retarded (forward and backward) delays},
	url = {https://lcvmwww.epfl.ch/software/daepy/},
	organization = {LCVMM, EPFL},
	author = {Flynn, Alastair},
	year = {2019},
	note = {version 1.0.1}
}

license: MIT

repository: alastairflynn/daepy

repo_name: alastairflynn/daepy

extension: bib


text:
# Filename: Python.cmake
#
# Description: This file provides support functions for building/installing
#   Python extension modules and/or pure-Python packages.
#
# Functions:
#   add_python_target(target [source1 [source2 ...]])
#   install_python_package(path [ARCH/LIB])
#

#
# Function: add_python_target(target [EXPORT exp] [COMPONENT comp]
#                                    [source1 [source2 ...]])
# Build the provided source(s) as a Python extension module, linked against the
# Python runtime library.
#
# Note that this also takes care of installation, unlike other target creation
# commands in CMake.  The EXPORT and COMPONENT keywords allow passing the
# corresponding options to install(), but default to "Python" otherwise.
#
function(add_python_target target)
  if(NOT HAVE_PYTHON)
    return()
  endif()

  string(REGEX REPLACE "^.*\\." "" basename "${target}")
  set(sources)
  set(component "Python")
  set(export "Python")
  foreach(arg ${ARGN})
    if(arg STREQUAL "COMPONENT")
      set(keyword "component")

    elseif(arg STREQUAL "EXPORT")
      set(keyword "export")

    elseif(keyword)
      set(${keyword} "${arg}")
      unset(keyword)

    else()
      list(APPEND sources "${arg}")

    endif()
  endforeach(arg)

  string(REGEX REPLACE "\\.[^.]+$" "" namespace "${target}")
  string(REPLACE "." "/" slash_namespace "${namespace}")

  add_library(${target} ${MODULE_TYPE} ${sources})
  target_link_libraries(${target} PKG::PYTHON)

  if(BUILD_SHARED_LIBS)
    set(_outdir "${PANDA_OUTPUT_DIR}/${slash_namespace}")

    set_target_properties(${target} PROPERTIES
      LIBRARY_OUTPUT_DIRECTORY "${_outdir}"
      OUTPUT_NAME "${basename}"
      PREFIX ""
      SUFFIX "${PYTHON_EXTENSION_SUFFIX}")

    # This is explained over in CompilerFlags.cmake
    foreach(_config ${CMAKE_CONFIGURATION_TYPES})
      string(TOUPPER "${_config}" _config)
      set_target_properties(${target} PROPERTIES
        LIBRARY_OUTPUT_DIRECTORY_${_config} "${_outdir}")
    endforeach(_config)

    if(PYTHON_ARCH_INSTALL_DIR)
      install(TARGETS ${target} EXPORT "${export}" COMPONENT "${component}" DESTINATION "${PYTHON_ARCH_INSTALL_DIR}/${slash_namespace}")
    endif()

  else()
    set_target_properties(${target} PROPERTIES
      OUTPUT_NAME "${basename}"
      PREFIX "libpy.${namespace}.")

    install(TARGETS ${target} EXPORT "${export}" COMPONENT "${component}" DESTINATION ${CMAKE_INSTALL_LIBDIR})

  endif()

endfunction(add_python_target)

#
# Function: install_python_package(name [SOURCE path] [ARCH/LIB] [COMPONENT component])
#
# Installs the Python package `name` (which may have its source at `path`).
#
# The package is copied to (or created in) the build directory so that the user
# may import it before the install step.
#
# Note that this handles more than just installation; it will also invoke
# Python's compileall utility to pregenerate .pyc/.pyo files.  This will only
# happen if the Python interpreter is found.
#
# The ARCH or LIB keyword may be used to specify whether this package should be
# installed into Python's architecture-dependent or architecture-independent
# package path.  The default, if unspecified, is LIB.
#
# The COMPONENT keyword overrides the install component (see CMake's
# documentation for more information on what this does).  The default is
# "Python".
#
function(install_python_package package_name)
  set(type "LIB")
  unset(keyword)
  set(component "Python")
  unset(src_path)
  foreach(arg ${ARGN})
    if(arg STREQUAL "ARCH")
      set(type "ARCH")

    elseif(arg STREQUAL "LIB")
      set(type "LIB")

    elseif(arg STREQUAL "COMPONENT")
      set(keyword "${arg}")

    elseif(keyword STREQUAL "COMPONENT")
      set(component "${arg}")
      unset(keyword)

    elseif(arg STREQUAL "SOURCE")
      set(keyword "${arg}")

    elseif(keyword STREQUAL "SOURCE")
      set(src_path "${arg}")
      unset(keyword)

    else()
      message(FATAL_ERROR "install_python_package got unexpected argument: ${ARGN}")

    endif()
  endforeach(arg)

  if(NOT DEFINED src_path AND type STREQUAL "ARCH" AND WIN32 AND NOT CYGWIN)
    # Win32 needs a special fixup so the DLLs in "bin" can be on the path;
    # let's set src_path to the directory containing our fixup __init__.py
    set(src_path "${CMAKE_SOURCE_DIR}/cmake/templates/win32_python")
  endif()

  set(path "${PANDA_OUTPUT_DIR}/${package_name}")

  set(args -D "OUTPUT_DIR=${path}")
  if(src_path)
    list(APPEND args -D "SOURCE_DIR=${src_path}")
  endif()
  if(PYTHON_EXECUTABLE)
    list(APPEND args -D "PYTHON_EXECUTABLES=${PYTHON_EXECUTABLE}")
  endif()
  add_custom_target(${package_name} ALL
    COMMAND ${CMAKE_COMMAND}
      ${args}
      -P "${CMAKE_SOURCE_DIR}/cmake/scripts/CopyPython.cmake")

  set(dir "${PYTHON_${type}_INSTALL_DIR}")
  if(dir)
    install(DIRECTORY "${path}" DESTINATION "${dir}"
      COMPONENT "${component}"
      FILES_MATCHING REGEX "\\.py[co]?$")
  endif()

endfunction(install_python_package)

extension: cmake


text:
SECTION = "base"
DESCRIPTION = "Miscellaneous utilities specific to Debian"
LICENSE = "GPL BSD BSD SMAIL"

SRC_URI = "${DEBIAN_MIRROR}/main/d/${PN}/${PN}_${PV}.tar.gz"

inherit autotools

repository: BackupTheBerlios/openslug-svn

repo_name: BackupTheBerlios/openslug-svn

extension: bb


text:
/*--------------------------------*- C++ -*----------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Version:  7
     \\/     M anipulation  |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       dictionary;
    location    "constant/polyMesh";
    object      meshMetaDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

surfaceFile     "geom.stl";

surfaceMeta
{
    nPoints         2659;
    nFacets         5042;
    nPatches        4;
    nFeatureEdges   0;
    patches
    {
        AMI
        {
            type            empty;
            nFacets         1656;
        }
        pump
        {
            type            empty;
            nFacets         3386;
        }
        AMI_0
        {
            type            empty;
            nFacets         1226;
        }
        AMI_1
        {
            type            empty;
            nFacets         142;
        }
        AMI_2
        {
            type            empty;
            nFacets         288;
        }
        pump_3
        {
            type            empty;
            nFacets         124;
        }
        pump_4
        {
            type            empty;
            nFacets         252;
        }
        pump_5
        {
            type            empty;
            nFacets         591;
        }
        pump_6
        {
            type            empty;
            nFacets         263;
        }
        pump_7
        {
            type            empty;
            nFacets         297;
        }
        pump_8
        {
            type            empty;
            nFacets         297;
        }
        pump_9
        {
            type            empty;
            nFacets         297;
        }
        pump_10
        {
            type            empty;
            nFacets         297;
        }
        pump_11
        {
            type            empty;
            nFacets         67;
        }
        pump_12
        {
            type            empty;
            nFacets         124;
        }
        pump_13
        {
            type            empty;
            nFacets         67;
        }
        pump_14
        {
            type            empty;
            nFacets         67;
        }
        pump_15
        {
            type            empty;
            nFacets         67;
        }
        pump_16
        {
            type            empty;
            nFacets         144;
        }
        pump_17
        {
            type            empty;
            nFacets         144;
        }
        pump_18
        {
            type            empty;
            nFacets         144;
        }
        pump_19
        {
            type            empty;
            nFacets         144;
        }
    }
    pointSubsets
    {
    }
    facetSubsets
    {
    }
    featureEdgeSubsets
    {
    }
}

branch_name: refs/heads/main

filename: meshMetaDict


text:
package checker_test

func idealExpressions() {
	// No negations:
	_ = true
	_ = true
}

func negationOK() {
	_ = !true
	_ = !false
}

func otherBinOps() {
	_ = true != false
	_ = true && false
	_ = true || false
}

func cantCombine() {
	fn := func() int { return 0 }

	var x, y, z int

	// OK: not safe expressions.
	_ = fn() > y || fn() == y
	_ = fn() == y || fn() > y
	_ = x > fn() || x == fn()
	_ = x == fn() || x > fn()
	_ = fn() > fn() || fn() == fn()
	_ = fn() == fn() || fn() > fn()

	// OK: different operands.
	_ = x > y || x == z
	_ = x == z || x > y
	_ = x > z || x == y
	_ = x == y || x > z

	// OK: unrelated operations.
	_ = x < y || x > z
	_ = x > z || x < y
}

repository: AlisherGM/go-critic

repo_name: AlisherGM/go-critic

gha_license_id: MIT


text:
@ARTICLE{BowJS83,
   author = {{Bowers}, P.~F. and {Johnston}, K.~J. and {Spencer}, J.~H.},
   title = "{Circumstellar envelope structure of late-type stars}",
   journal = apj,
   year = 1983,
   month = nov,
   volume = 274,
   pages = {733-754},
adsurl =
{http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1983ApJ...274..733B&db_key=AST},
  adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{ComWestGay94,
    author = {{Combrinck}, W.~L. and {West}, M.~E. and {Gaylard}, M.~J.},
    title = "{Coexisting with GLONASS: Observing the 1612 MHz hydroxyl
    line}",
    journal = pasp,
    year = 1994,
    month = jul,
    volume = 106,
    pages = {807-812},
adsurl =
{http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1994PASP..106..807C&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{DavEtoLS96,
   author = {{David}, P. and {Etoka}, S. and {Le Squeren}, A.~M.},
   title = "{A new expectation function for fitting the OH curves of
circumstellar maser lines.}",
   journal = aas,
   year = 1996,
   month = feb,
   volume = 115,
   pages = {387-+},
adsurl =
{http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1996A%26AS..115..387D&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{EK88,
    author = {{Edelson}, R.~A. and {Krolik}, J.~H.},
    title = "{The discrete correlation function - A new method for analyzing
    unevenly sampled variability data}",
    journal = apj,
    year = 1988,
    month = oct,
    volume = 333,
    pages = {646-659},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1988ApJ...333..646E&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@PHDTHESIS{Herman83,
    author = {{Herman}, J.},
    title = "{The nature of OH/IR stars - Properties and characteristics of
    an evolved stellar population}",
    year = {1983},
    school = {Sterrewacht Leiden, University of Leiden, The Netherlands}
}

@ARTICLE{HerHab85,
    author = {{Herman}, J. and {Habing}, H.~J.},
    title = "{Time variations and shell sizes of OH masers in late-type
    stars}",
    journal = aas,
    year = 1985,
    month = mar,
    volume = 59,
    pages = {523-555},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1985A%26AS...59..523H&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{IbenRen83,
   author = {{Iben}, I. and {Renzini}, A.},
   title = "{Asymptotic giant branch evolution and beyond}",
   journal = araa,
   year = 1983,
   volume = 21,
   pages = {271-342},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1983ARA%26A..21..271I&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{Jewell79,
    author = {{Jewell}, P.~R. and {Elitzur}, M. and {Webber}, J.~C. and
    {Snyder}, L.~E.},
    title = "{Monitoring of OH maser emission from late-type stars}",
    journal = apjss,
    year = 1979,
    month = oct,
    volume = 41,
    pages = {191-207},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1979ApJS...41..191J&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{JewWebSny80,
    author = {{Jewell}, P.~R. and {Webber}, J.~C. and {Snyder}, L.~E.},
    title = "{The Linear Shell Diameter of IRC+10011}",
    journal = apjl,
    year = 1980,
    month = nov,
    volume = 242,
    pages = {L29+},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1980ApJ...242L..29J&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{Lehar92,
    author = {{Lehar}, J. and {Hewitt}, J.~N. and {Burke}, B.~F. and
    {Roberts}, D.~H.},
    title = "{The radio time delay in the double quasar 0957 + 561}",
    journal = apj,
    year = 1992,
    month = jan,
    volume = 384,
    pages = {453-466},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1992ApJ...384..453L&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{OliWhtlkMar01,
   author = {{Olivier}, E.~A. and {Whitelock}, P. and {Marang}, F.},
   title = "{Dust-enshrouded asymptotic giant branch stars in the solar
   neighbourhood}",
   journal = mn,
   year = 2001,
   month = sep,
   volume = 326,
   pages = {490-514},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=2001MNRAS.326..490O&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{Ott94,
    author = {{Ott}, M. and {Witzel}, A. and {Quirrenbach}, A. and
    {Krichbaum}, T.~P. and {Standke}, K.~J. and {Schalinski}, C.~J. and
    {Hummel}, C.~A.},
    title = "{An updated list of radio flux density calibrators}",
    journal = aa,
    year = 1994,
    month = apr,
    volume = 284,
    pages = {331-339},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1994A%26A...284..331O&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{PhLGil-M02,
    author = {{Gil-Merino}, R. and {Wisotzki}, L. and {Wambsganss}, J.},
    title = "{The Double Quasar HE 1104-1805: A case study for time delay
    determination with poorly sampled lightcurves}",
    journal = aa,
    year = 2002,
    month = jan,
    volume = 381,
    pages = {428-439},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=2002A%26A...381..428G&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{PhLOscoz01,
    author = {{Oscoz}, A. and {Alcalde}, D. and {Serra-Ricart}, M. and
    {Mediavilla}, E. and {Abajas}, C. and {Barrena}, R. and {Licandro}, J. and {Motta}, V.
    and	{Mu{\~ n}oz}, J.~A.},
    title = "{Time Delay in QSO 0957+561 From 1984-1999 Optical Data}",
    journal = apj,
    year = 2001,
    month = may,
    volume = 552,
    pages = {81-90},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=2001ApJ...552...81O&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{PhLPelt96,
    author = {{Pelt}, J. and {Kayser}, R. and {Refsdal}, S. and {Schramm},
    T.},
    title = "{The light curve and the time delay of QSO 0957+561.}",
    journal = aa,
    year = 1996,
    month = jan,
    volume = 305,
    pages = {97-+},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1996A%26A...305...97P&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{PhLPress92,
    author = {{Press}, W.~H. and {Rybicki}, G.~B. and {Hewitt}, J.~N.},
    title = "{The time delay of gravitational lens 0957 + 561. I -
    Methodology and analysis of optical photometric data. II - Analysis of
    radio data and combined optical-radio analysis}",
    journal = apj,
    year = 1992,
    month = feb,
    volume = 385,
    pages = {404-420},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1992ApJ...385..404P&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{RJC89,
    author = {{Cohen}, R.~J.},
    title = "{Compact maser sources.}",
    journal = rpp,
    year = 1989,
    volume = 52,
    pages = {881-943},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1989RPPh...52..881C&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{ReidMMJS77,
   author = {{Reid}, M.~J. and {Muhleman}, D.~O. and {Moran}, J.~M. and
   {Johnston}, K.~J. and {Schwartz}, P.~R.},
   title = "{The structure of stellar hydroxyl masers}",
   journal = apj,
   year = 1977,
   month = may,
   volume = 214,
   pages = {60-77},
adsurl =
{http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1977ApJ...214...60R&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{SchSherWin78,
    author = {{Schultz}, G.~V. and {Sherwood}, W.~A. and {Winnberg}, A.},
    title = "{Radial diameters of Type II OH/IR sources}",
    journal = aa,
    year = 1978,
    month = feb,
    volume = 63,
    pages = {L5-L7},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1978A%26A....63L...5S&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@PHDTHESIS{Shepherd91,
    author = {{Shepherd}, M.~C.},
    title = "{The nature of OH/IR stars and their use as distance
    indicators}",
    year = {1991},
    school = {Nuffield Radio Astronomy Laboratories, University of
    Manchester, United Kingdom}
}

@ARTICLE{Shepherd93,
   author = {{Shepherd}, M.~C. and {West}, M.~E. and {Cohen}, R.~J. and
   {Gaylard}, M.~J.},
   title = "{Distance measurements of OH-IR sources}",
   journal = {Lecture Notes in Physics, Berlin Springer Verlag},
   year = 1993,
   volume = 412,
   pages = {380-383},
adsurl =
{http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1993LNP...412..380S&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{vLvdHvS90,
    author = {{van Langevelde}, H.~J. and {van der Heiden}, R. and {van
    Schooneveld}, C.},
    title = "{Phase lags from multiple flux curves of OH/IR stars}",
    journal = aa,
    year = 1990,
    month = nov,
    volume = 239,
    pages = {193-204},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1990A%26A...239..193V&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@PHDTHESIS{vanLangevelde92,
    author = {{van Langevelde}, H.~J.},
    title = "{Radio astronomy studies of OH/IR stars in the inner Galaxy}",
    year = {1992},
    school = {Sterrewacht Leiden, University of Leiden, The Netherlands}
}

@ARTICLE{Vio01,
    author = {{Vio}, R. and {Wamsteker}, W.},
    title = "{Limits of the Cross-Correlation Function in the Analysis of
    Short Time Series}",
    journal = pasp,
    year = 2001,
    month = jan,
    volume = 113,
    pages = {86-97},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=2001PASP..113...86V&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{VolkCohen89,
   author = {{Volk}, K. and {Cohen}, M.},
   title = "{New LRS spectra for 356 bright IRAS sources}",
   journal = aj,
   year = 1989,
   month = sep,
   volume = 98,
   pages = {931-975},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1989AJ.....98..931V&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{Welsh99,
    author = {{Welsh}, W.~F.},
    title = "{On the Reliability of Cross-Correlation Function Lag
    Determinations in Active Galactic Nuclei}",
    journal = pasp,
    year = 1999,
    month = nov,
    volume = 111,
    pages = {1347-1366},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1999PASP..111.1347W&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@INPROCEEDINGS{West92,
    author = {{West}, M.~E. and {Gaylard}, M.~J. and {Combrinck}, W.~L. and
    {Cohen}, R.~J. and {Shepherd}, M.~C.},
    title = "{Mira and OH/IR Maser Characteristics and Distance
    Determination}",
    booktitle = {ASP Conf. Ser.  30: Variable Stars and Galaxies, in honor of M.
    W. Feast on his retirement},
    year = 1992,
    pages = {277-+},
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1992vsg..conf..277W&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@BOOK{West98,
    author = {{West}, M.~E.},
    title = "{Characteristics of the variability of OH/IR stars and
    estimation of their distances}",
    publisher = {M.Sc. Thesis, University of Potchefstroom, South Africa},
    year = {1998},
}

@ARTICLE{WilBar68,
   author = {{Wilson}, W.~J. and {Barrett}, A.~H.},
   title = "{Discovery of Hydroxyl Radio Emission from Infrared Stars}",
   journal = sc,
   year = 1968,
   month = aug,
   volume = 161,
   pages = {778-779},
adsurl =
{http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1968Sci...161..778W&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}

@ARTICLE{WilBar72,
   author = {{Wilson}, W.~J. and {Barrett}, A.~H.},
   title = "{Characteristics of OH emission from infrared stars.}",
   journal = aa,
   year = 1972,
   month = mar,
   volume = 17,
   pages = {385-+},
adsurl =
{http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1972A%26A....17..385W&db_key=AST},
  adsnote = {Provided by the NASA Astrophysics Data System}
}

ADS-ABS for Herman's Thesis:
===========================
@BOOK{1983nois.book.....H,
    author = {{Herman}, J.},
    title = "{The nature of OH/IR stars. Properties and characteristics of
    an evolved stellar population}",
    publisher = {Leiden: Rijksuniversitet, 1983},
    year = 1983,
adsurl = {http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=1983nois.book.
....H&db_key=AST},
adsnote = {Provided by the NASA Astrophysics Data System}
}


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

package container

import (
	"bytes"
	"context"
	"fmt"
	"io/ioutil"

	"github.com/docker/docker/api/types"
	"github.com/docker/docker/api/types/container"
	"github.com/docker/docker/api/types/mount"
	"github.com/docker/docker/client"
	"github.com/docker/docker/pkg/stdcopy"
	environmenttypes "github.com/konveyor/move2kube/types/environment"
	"github.com/sirupsen/logrus"
	"github.com/spf13/cast"
)

const (
	testimage = "quay.io/konveyor/hello-world"
)

type dockerEngine struct {
	availableImages map[string]bool
	cli             *client.Client
	ctx             context.Context
}

// newDockerEngine creates a new docker engine instance
func newDockerEngine() (*dockerEngine, error) {
	ctx := context.Background()
	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
	if err != nil {
		logrus.Debugf("Unable to create docker client : %s", err)
		return nil, err
	}
	e := &dockerEngine{
		availableImages: map[string]bool{},
		cli:             cli,
		ctx:             ctx,
	}
	_, _, err = e.RunContainer(testimage, environmenttypes.Command{}, "", "")
	if err != nil {
		logrus.Errorf("Unable to run test container : %s", err)
		return nil, err
	}
	return e, nil
}

func (e *dockerEngine) pullImage(image string) bool {
	if a, ok := e.availableImages[image]; ok {
		return a
	}
	logrus.Infof("Pulling container image %s. This could take a few mins.", image)
	out, err := e.cli.ImagePull(e.ctx, image, types.ImagePullOptions{})
	if err != nil {
		logrus.Debugf("Unable to pull image %s : %s", image, err)
		e.availableImages[image] = false
		return false
	}
	if b, err := ioutil.ReadAll(out); err == nil {
		logrus.Debug(cast.ToString(b))
	}
	e.availableImages[image] = true
	return true
}

// RunCmdInContainer executes a container
func (e *dockerEngine) RunCmdInContainer(containerID string, cmd environmenttypes.Command, workingdir string, env []string) (stdout, stderr string, exitCode int, err error) {
	execConfig := types.ExecConfig{
		AttachStdout: true,
		AttachStderr: true,
		Cmd:          cmd,
		WorkingDir:   workingdir,
		Env:          env,
	}
	cresp, err := e.cli.ContainerExecCreate(e.ctx, containerID, execConfig)
	if err != nil {
		return
	}
	aresp, err := e.cli.ContainerExecAttach(e.ctx, cresp.ID, types.ExecStartCheck{})
	if err != nil {
		return
	}
	defer aresp.Close()

	var outBuf, errBuf bytes.Buffer
	outputDone := make(chan error)
	go func() {
		_, err = stdcopy.StdCopy(&outBuf, &errBuf, aresp.Reader)
		outputDone <- err
	}()

	select {
	case err = <-outputDone:
		if err != nil {
			return
		}
		break

	case <-e.ctx.Done():
		return "", "", 0, e.ctx.Err()
	}

	stdoutbytes, err := ioutil.ReadAll(&outBuf)
	if err != nil {
		return
	}
	stderrbytes, err := ioutil.ReadAll(&errBuf)
	if err != nil {
		return
	}
	res, err := e.cli.ContainerExecInspect(e.ctx, cresp.ID)
	if err != nil {
		return
	}
	exitCode = res.ExitCode
	stdout = string(stdoutbytes)
	stderr = string(stderrbytes)
	return
}

// InspectImage returns inspect output for an image
func (e *dockerEngine) InspectImage(image string) (types.ImageInspect, error) {
	inspectOutput, _, err := e.cli.ImageInspectWithRaw(e.ctx, image)
	if err != nil {
		return types.ImageInspect{}, err
	}

	return inspectOutput, nil
}

// CreateContainer creates a container
func (e *dockerEngine) CreateContainer(image string) (containerid string, err error) {
	if !e.pullImage(image) {
		logrus.Debugf("Unable to pull image using docker : %s", image)
		return "", fmt.Errorf("unable to pull image")
	}
	contconfig := &container.Config{
		Image: image,
		Cmd:   []string{"sh", "-c", "tail -f /dev/null"},
	}
	resp, err := e.cli.ContainerCreate(e.ctx, contconfig, nil, nil, nil, "")
	if err != nil {
		logrus.Debugf("Container creation failed with image %s with no volumes", image)
		return "", err
	}
	err = e.cli.ContainerStart(e.ctx, resp.ID, types.ContainerStartOptions{})
	if err != nil {
		logrus.Debugf("Container creation failed with image %s with no volumes", image)
		return "", err
	}
	logrus.Debugf("Container %s created with image %s", resp.ID, image)
	return resp.ID, nil
}

// CreateContainer creates a container
func (e *dockerEngine) StopAndRemoveContainer(containerID string) (err error) {
	err = e.cli.ContainerRemove(e.ctx, containerID, types.ContainerRemoveOptions{Force: true})
	if err != nil {
		logrus.Errorf("Unable to delete container with containerid %s : %s", containerID, err)
		return err
	}
	return nil
}

// CopyDirsIntoImage creates a container
func (e *dockerEngine) CopyDirsIntoImage(image, newImageName string, paths map[string]string) (err error) {
	if !e.pullImage(image) {
		logrus.Debugf("Unable to pull image using docker : %s", image)
		return fmt.Errorf("unable to pull image")
	}
	cid, err := e.CreateContainer(image)
	if err != nil {
		logrus.Errorf("Unable to create container with base image %s : %s", image, err)
		return err
	}
	for sp, dp := range paths {
		err = copyDirToContainer(e.ctx, e.cli, cid, sp, dp)
		if err != nil {
			logrus.Debugf("Container data copy failed for image %s with volume %s:%s : %s", image, sp, dp, err)
			return err
		}
	}
	_, err = e.cli.ContainerCommit(e.ctx, cid, types.ContainerCommitOptions{
		Reference: newImageName,
	})
	if err != nil {
		logrus.Errorf("Unable to commit container as image : %s", err)
		return err
	}
	e.availableImages[newImageName] = true
	err = e.StopAndRemoveContainer(cid)
	if err != nil {
		logrus.Errorf("Unable to stop and remove container %s : %s", cid, err)
	}
	return nil
}

func (e *dockerEngine) CopyDirsIntoContainer(containerID string, paths map[string]string) (err error) {
	for sp, dp := range paths {
		err = copyDirToContainer(e.ctx, e.cli, containerID, sp, dp)
		if err != nil {
			logrus.Debugf("Container data copy failed for image %s with volume %s:%s : %s", containerID, sp, dp, err)
			return err
		}
	}
	return nil
}

// CopyDirsFromContainer creates a container
func (e *dockerEngine) CopyDirsFromContainer(containerID string, paths map[string]string) (err error) {
	for sp, dp := range paths {
		err = copyFromContainer(e.ctx, e.cli, containerID, sp, dp)
		if err != nil {
			logrus.Debugf("Container data copy failed for image %s with volume %s:%s : %s", containerID, sp, dp, err)
			return err
		}
	}
	return nil
}

// BuildImage creates a container
func (e *dockerEngine) BuildImage(image, context, dockerfile string) (err error) {
	logrus.Infof("Building container image %s. This could take a few mins.", image)
	reader := readDirAsTar(context, "")
	resp, err := e.cli.ImageBuild(e.ctx, reader, types.ImageBuildOptions{
		Dockerfile: dockerfile,
		Tags:       []string{image},
	})
	if err != nil {
		logrus.Infof("Image creation failed with image %s with no volumes : %s", image, err)
		return err
	}
	defer resp.Body.Close()
	response, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		logrus.Errorf("Unable to read data from image build process : %s", err)
		return err
	}
	logrus.Debugf("%s", response)
	e.availableImages[image] = true
	logrus.Debugf("Built image %s", image)
	return nil
}

// RemoveImage creates a container
func (e *dockerEngine) RemoveImage(image string) (err error) {
	_, err = e.cli.ImageRemove(e.ctx, image, types.ImageRemoveOptions{Force: true})
	if err != nil {
		logrus.Debugf("Container deletion failed with image %s", image)
		return err
	}
	return nil
}

// RunContainer executes a container
func (e *dockerEngine) RunContainer(image string, cmd environmenttypes.Command, volsrc string, voldest string) (output string, containerStarted bool, err error) {
	if !e.pullImage(image) {
		logrus.Debugf("Unable to pull image using docker : %s", image)
		return "", false, fmt.Errorf("unable to pull image")
	}
	ctx := context.Background()
	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
	if err != nil {
		logrus.Debugf("Error during docker client creation : %s", err)
		return "", false, err
	}
	contconfig := &container.Config{
		Image: image,
	}
	if (volsrc == "" && voldest != "") || (volsrc != "" && voldest == "") {
		logrus.Warnf("Either volume source (%s) or destination (%s) is empty. Ingoring volume mount.", volsrc, voldest)
	}
	hostconfig := &container.HostConfig{}
	if volsrc != "" && voldest != "" {
		hostconfig.Mounts = []mount.Mount{
			{
				Type:     mount.TypeBind,
				Source:   volsrc,
				Target:   voldest,
				ReadOnly: true,
			},
		}
	}
	resp, err := cli.ContainerCreate(ctx, contconfig, hostconfig, nil, nil, "")
	if err != nil {
		logrus.Debugf("Error during container creation : %s", err)
		resp, err = cli.ContainerCreate(ctx, contconfig, nil, nil, nil, "")
		if err != nil {
			logrus.Debugf("Container creation failed with image %s with no volumes", image)
			return "", false, err
		}
		logrus.Debugf("Container %s created with image %s with no volumes", resp.ID, image)
		defer cli.ContainerRemove(ctx, resp.ID, types.ContainerRemoveOptions{Force: true})
		if volsrc != "" && voldest != "" {
			err = copyDir(ctx, cli, resp.ID, volsrc, voldest)
			if err != nil {
				logrus.Debugf("Container data copy failed for image %s with volume %s:%s : %s", image, volsrc, voldest, err)
				return "", false, err
			}
			logrus.Debugf("Data copied from %s to %s in container %s with image %s", volsrc, voldest, resp.ID, image)
		}
	}
	logrus.Debugf("Container %s created with image %s", resp.ID, image)
	defer cli.ContainerRemove(ctx, resp.ID, types.ContainerRemoveOptions{Force: true})
	if err = cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
		logrus.Debugf("Error during container startup of container %s : %s", resp.ID, err)
		return "", false, err
	}
	statusCh, errCh := cli.ContainerWait(
		ctx,
		resp.ID,
		container.WaitConditionNotRunning,
	)
	select {
	case err := <-errCh:
		if err != nil {
			logrus.Debugf("Error during waiting for container : %s", err)
			return "", false, err
		}
	case status := <-statusCh:
		logrus.Debugf("Container exited with status code: %#+v", status.StatusCode)
		options := types.ContainerLogsOptions{ShowStdout: true}
		out, err := cli.ContainerLogs(ctx, resp.ID, options)
		if err != nil {
			logrus.Debugf("Error while getting container logs : %s", err)
			return "", true, err
		}
		logs := ""
		if b, err := ioutil.ReadAll(out); err == nil {
			logs = cast.ToString(b)
		}
		if status.StatusCode != 0 {
			return logs, true, fmt.Errorf("container execution terminated with error code : %d", status.StatusCode)
		}
		return logs, true, nil
	}
	return "", false, err
}


text:
find_path(CATCH_INCLUDE_DIRS catch.hpp)

include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Catch DEFAULT_MSG CATCH_INCLUDE_DIRS)

mark_as_advanced(CATCH_INCLUDE_DIRS)

repository: OpusV/AstroMechanics

repo_name: OpusV/AstroMechanics


text:
# Copyright (c) 2015-2016, Ruslan Baratov
# All rights reserved.

include(hunter_apply_copy_rules)
include(hunter_apply_gate_settings)
include(hunter_calculate_self)
include(hunter_create_cache_file)
include(hunter_fatal_error)
include(hunter_internal_error)
include(hunter_sanity_checks)
include(hunter_status_debug)
include(hunter_status_print)
include(hunter_assert_not_empty_string)

# Continue initialization of key variables (also see 'hunter_initialize')
#   * calculate toolchain-id
#   * calculate config-id
macro(hunter_finalize)
  # Check preconditions
  hunter_sanity_checks()

  string(COMPARE EQUAL "${HUNTER_CACHE_SERVERS}" "" _is_empty)
  if(_is_empty)
    hunter_status_debug("Using default cache server")
    set(HUNTER_CACHE_SERVERS "https://github.com/cpp-pm/hunter-cache")
  endif()

  hunter_status_debug("List of cache servers:")
  foreach(_server ${HUNTER_CACHE_SERVERS})
    hunter_status_debug("  * ${_server}")
  endforeach()

  get_property(_enabled_languages GLOBAL PROPERTY ENABLED_LANGUAGES)

  list(FIND _enabled_languages "C" _c_enabled_result)
  if(_c_enabled_result EQUAL -1)
    set(_c_enabled FALSE)
  else()
    set(_c_enabled TRUE)
  endif()

  list(FIND _enabled_languages "CXX" _cxx_enabled_result)
  if(_cxx_enabled_result EQUAL -1)
    set(_cxx_enabled FALSE)
  else()
    set(_cxx_enabled TRUE)
  endif()

  if(_c_enabled AND NOT CMAKE_C_ABI_COMPILED)
    hunter_fatal_error(
        "ABI not detected for C compiler" ERROR_PAGE "error.abi.detection.failure"
    )
  endif()

  if(_cxx_enabled AND NOT CMAKE_CXX_ABI_COMPILED)
    hunter_fatal_error(
        "ABI not detected for CXX compiler" ERROR_PAGE "error.abi.detection.failure"
    )
  endif()

  string(COMPARE NOTEQUAL "$ENV{HUNTER_BINARY_DIR}" "" _env_not_empty)
  if(_env_not_empty)
    get_filename_component(HUNTER_BINARY_DIR "$ENV{HUNTER_BINARY_DIR}" ABSOLUTE)
    hunter_status_debug("HUNTER_BINARY_DIR: ${HUNTER_BINARY_DIR}")
  endif()

  # * Read HUNTER_GATE_* variables
  # * Check cache HUNTER_* variables is up-to-date
  # * Update cache if needed
  # * define HUNTER_ID_PATH
  # * define HUNTER_TOOLCHAIN_ID_PATH
  # * define HUNTER_CONFIG_ID_PATH
  hunter_apply_gate_settings()

  string(SUBSTRING "${HUNTER_SHA1}" 0 7 HUNTER_ID)
  string(SUBSTRING "${HUNTER_CONFIG_SHA1}" 0 7 HUNTER_CONFIG_ID)
  string(SUBSTRING "${HUNTER_TOOLCHAIN_SHA1}" 0 7 HUNTER_TOOLCHAIN_ID)

  set(HUNTER_INSTALL_PREFIX "${HUNTER_CONFIG_ID_PATH}/Install")
  list(APPEND CMAKE_PREFIX_PATH "${HUNTER_INSTALL_PREFIX}")

  # Override pkg-config default search path
  # https://github.com/ruslo/hunter/issues/762
  if(NOT MSVC)
    set(_pkg_config_dir1 "${HUNTER_INSTALL_PREFIX}/lib/pkgconfig")
    set(_pkg_config_dir2 "${HUNTER_INSTALL_PREFIX}/share/pkgconfig")
    # This info is also in hunter_autotools_project.cmake
    set(ENV{PKG_CONFIG_LIBDIR} "${_pkg_config_dir1}:${_pkg_config_dir2}")
  endif()

  if(ANDROID)
    # OpenCV support: https://github.com/ruslo/hunter/issues/153
    list(APPEND CMAKE_PREFIX_PATH "${HUNTER_INSTALL_PREFIX}/sdk/native/jni")
  endif()
  list(APPEND CMAKE_FIND_ROOT_PATH "${HUNTER_INSTALL_PREFIX}")

  hunter_status_print("HUNTER_ROOT: ${HUNTER_CACHED_ROOT}")
  hunter_status_debug("HUNTER_TOOLCHAIN_ID_PATH: ${HUNTER_TOOLCHAIN_ID_PATH}")
  hunter_status_debug(
      "HUNTER_CONFIGURATION_TYPES: ${HUNTER_CACHED_CONFIGURATION_TYPES}"
  )
  hunter_status_debug(
      "HUNTER_BUILD_SHARED_LIBS: ${HUNTER_BUILD_SHARED_LIBS}"
  )

  set(_id_info "[ Hunter-ID: ${HUNTER_ID} |")
  set(_id_info "${_id_info} Toolchain-ID: ${HUNTER_TOOLCHAIN_ID} |")
  set(_id_info "${_id_info} Config-ID: ${HUNTER_CONFIG_ID} ]")

  hunter_status_print("${_id_info}")

  set(HUNTER_CACHE_FILE "${HUNTER_CONFIG_ID_PATH}/cache.cmake")
  hunter_create_cache_file("${HUNTER_CACHE_FILE}")

  if(MSVC)
    include(hunter_setup_msvc)
    hunter_setup_msvc()
  endif()

  ### Disable package registry
  ### http://www.cmake.org/cmake/help/v3.1/manual/cmake-packages.7.html#disabling-the-package-registry
  set(CMAKE_EXPORT_NO_PACKAGE_REGISTRY ON)
  set(CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY ON)
  set(CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY ON)
  ### -- end

  ### Disable environment variables
  ### http://www.cmake.org/cmake/help/v3.3/command/find_package.html
  set(ENV{CMAKE_PREFIX_PATH} "")
  set(ENV{CMAKE_FRAMEWORK_PATH} "")
  set(ENV{CMAKE_APPBUNDLE_PATH} "")
  ### -- end

  ### 1. Clear all '<NAME>_ROOT' variables (cache, environment, ...)
  ### 2. Set '<NAME>_ROOT' or 'HUNTER_<name>_VERSION' variables
  set(__HUNTER_ALLOW_FINAL_CONFIG_LOADING YES)
  include("${HUNTER_CONFIG_ID_PATH}/config.cmake")
  set(__HUNTER_ALLOW_FINAL_CONFIG_LOADING NO)

  hunter_assert_not_empty_string("${HUNTER_INSTALL_PREFIX}")
  hunter_assert_not_empty_string("${CMAKE_BINARY_DIR}")

  file(
      WRITE
      "${CMAKE_BINARY_DIR}/_3rdParty/Hunter/install-root-dir"
      "${HUNTER_INSTALL_PREFIX}"
  )

  hunter_apply_copy_rules()

  if(ANDROID AND CMAKE_VERSION VERSION_LESS "3.7.1")
    hunter_user_error(
        "CMake version 3.7.1+ required for Android platforms, see"
        " https://hunter.readthedocs.io/en/latest/quick-start/cmake.html"
    )
  endif()

  # Android GDBSERVER moved to
  # https://github.com/hunter-packages/android-apk/commit/32531adeb287d3e3b20498ff1a0f76336cbe0551

  # Fix backslashed provided by user:
  # * https://github.com/ruslo/hunter/issues/693
  # Note: we can't use 'get_filename_component(... ABSOLUTE)' because sometimes
  # original path expected. E.g. NMake build:
  # * https://ci.appveyor.com/project/ingenue/hunter/build/1.0.1412/job/o8a21ue85ivt5d0p
  string(REPLACE "\\" "\\\\" CMAKE_MAKE_PROGRAM "${CMAKE_MAKE_PROGRAM}")

  if(CMAKE_INTERPROCEDURAL_OPTIMIZATION AND NOT POLICY CMP0069)
    hunter_user_error("Unsuitable CMake version")
  endif()

  if(IOS AND NOT CMAKE_CROSSCOMPILING)
    hunter_user_error(
        "CMAKE_CROSSCOMPILING should be set on iOS."
        " Please update your toolchain."
    )
  endif()

  string(COMPARE EQUAL "${HUNTER_TLS_VERIFY}" "" _is_empty)
  if(_is_empty)
    hunter_user_error(
        "HUNTER_TLS_VERIFY is empty, please update HunterGate module"
    )
  endif()
endmacro()

repository: cpp-pm/hunter

repo_name: cpp-pm/hunter

gha_language: CMake


text:
require barebox.inc

SRCREV = "1b3990c50f6137efa4c9c95d5344bdda18d92096"

repository: idlesse/meta-barebox

repo_name: idlesse/meta-barebox


text:
package main

import (
	"fmt"
	"github.com/Shopify/sysv_mq"
	"log"
	"time"
)

func main() {
	mq, err := sysv_mq.NewMessageQueue(&sysv_mq.QueueConfig{
		Key:     0x0000303d,               // SysV IPC key
		MaxSize: 1024,                     // Max size of a message
		Mode:    sysv_mq.IPC_CREAT | 0666, // Creates if it doesn't exist, 0600 permissions
	})
	if err != nil {
		log.Fatal(err)
	}
	defer mq.Destroy()

	for {
		data, mtype, err := mq.ReceiveString(1, 0)
		if err == nil {
			fmt.Printf("[%d] %s", mtype, data)
		} else {
			break
		}

		time.Sleep(time.Second)
	}
}

repository: gonejack/node-sarama

repo_name: gonejack/node-sarama


text:
DESCRIPTION = "OpenSLP 1.2.1"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://${WORKDIR}/${PN}-${PV}/COPYING;md5=69974e24a9fae771ced9240f7eb0770f"
PR = "r1"

inherit autotools

PN = "openslp"

SRC_URI="http://sourceforge.net/projects/openslp/files/OpenSLP/1.2.1/openslp-1.2.1.tar.gz \
        file://slp.conf"

do_configure_append() {
    cp ${WORKDIR}/slp.conf ${S}/etc/
}

FILES_${PN} += "usr/*"

SRC_URI[md5sum] = "ff9999d1b44017281dd00ed2c4d32330"
SRC_URI[sha256sum] = "08c7ec1e76fdd66461b3784d52047f594405f31ba2791ab0c1ec7c97639f5fbd"

repository: hsuthram/customboard

repo_name: hsuthram/customboard

gha_language: HTML


text:
package listing

// DownloadRecord defines the stored download metadata
type DownloadRecord struct {
	ID        int64  `json:"id"`
	URL       string `json:"url"`
	Subfolder string `json:"subfolder"`
	Output    string `json:"output"`
	Errors    string `json:"errors"`
	Finished  string `json:"finished"`
	Filename  string `json:"filename"`
	Title     string `json:"title"`
}

repository: Mike-Dunton/chronicler

repo_name: Mike-Dunton/chronicler


text:
// Copyright 2020 The Scriggo Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package compiler

import (
	"sort"
	"strconv"

	"github.com/open2b/scriggo/ast"
)

// A compilation holds the state of a single compilation.
//
// This is necessary to store information across compilation of different
// packages/template files, where a new type checker is created for every
// package/template file.
//
// Currently the compilation is used only by the typechecker.
//
type compilation struct {
	// pkgPathToIndex maps the path of a package to an unique int identifier.
	pkgPathToIndex map[string]int

	// pkgInfos maps the packages path to their respective package infos.
	pkgInfos map[string]*packageInfo

	// typeInfos associates a TypeInfo to the nodes of the AST that is
	// currently being type checked.
	//
	// It is correct to store type infos in the compilation because we
	// guarantee that an AST node is type checked always in the same way, no
	// matter what "path" is taken to reach it.
	typeInfos map[ast.Node]*typeInfo

	// alreadySortedPkgs tracks the packages that have already been sorted.
	// Sorting a package twice is wrong because it may have been transformed by
	// the type checker.
	alreadySortedPkgs map[*ast.Package]bool

	// indirectVars contains the list of all declarations of variables which
	// must be emitted as "indirect".
	indirectVars map[*ast.Identifier]bool

	// renderImportMacro stores the dummy 'import' nodes and the dummy macro
	// declarations that are used to implement the 'render' expression. This
	// maps avoid making useless copies of AST nodes that may lead to
	// inconsistent type checks and invalid behaviors.
	renderImportMacro map[*ast.Tree]renderIR

	// iteaToUsingCheck maps 'itea' identifiers ($itea0, $itea1... ) to their
	// corresponding usingCheck.
	iteaToUsingCheck map[string]usingCheck

	// currentIteaIndex is the index used to generate the name of the current
	// 'itea' identifier.
	// After initialization, it should be accessed exclusively by the method
	// 'generateIteaName'.
	currentIteaIndex int

	// iteaName is the current name of the predeclared 'itea' identifier that
	// should be used in tree transformations, something like '$itea0'.
	iteaName string

	// globalScope is the global scope.
	globalScope map[string]scopeName

	// extendingTrees reports if a tree with a certain path is extending
	// another file.
	// This information must be kept here because it becomes lost after
	// transforming the tree in case of extends.
	extendingTrees map[string]bool

	// extendedTrees reports if a tree with a certain path has been extended by
	// another file.
	// This information must be kept here because it becomes lost after
	// transforming the tree in case of extends.
	extendedTrees map[string]bool
}

type renderIR struct {
	Import *ast.Import
	Macro  *ast.Func
}

// newCompilation returns a new compilation.
func newCompilation(globalScope map[string]scopeName) *compilation {
	return &compilation{
		pkgInfos:          map[string]*packageInfo{},
		pkgPathToIndex:    map[string]int{},
		typeInfos:         map[ast.Node]*typeInfo{},
		alreadySortedPkgs: map[*ast.Package]bool{},
		indirectVars:      map[*ast.Identifier]bool{},
		renderImportMacro: map[*ast.Tree]renderIR{},
		currentIteaIndex:  -1,
		globalScope:       globalScope,
		extendingTrees:    map[string]bool{},
		extendedTrees:     map[string]bool{},
	}
}

// UniqueIndex returns an index related to the current package; such index is
// unique for every package path.
//
// TODO(Gianluca): we should keep an index of the last (or the next) package
// index, instead of recalculate it every time.
func (compilation *compilation) UniqueIndex(path string) int {
	i, ok := compilation.pkgPathToIndex[path]
	if ok {
		return i
	}
	max := -1
	for _, i := range compilation.pkgPathToIndex {
		if i > max {
			max = i
		}
	}
	compilation.pkgPathToIndex[path] = max + 1
	return max + 1
}

// generateIteaName generates a new name that can be used when transforming the
// predeclared identifier 'itea'.
func (compilation *compilation) generateIteaName() string {
	compilation.currentIteaIndex++
	return "$itea" + strconv.Itoa(compilation.currentIteaIndex)
}

// finalizeUsingStatements finalizes the 'using' statements neutralizing 'itea'
// declarations that should not be emitted. It also returns a type checking
// error if the 'itea' identifier of a 'using' statement is not used.
func (compilation *compilation) finalizeUsingStatements(tc *typechecker) error {
	names := make([]string, 0, len(compilation.iteaToUsingCheck))
	for name := range compilation.iteaToUsingCheck {
		names = append(names, name)
	}
	sort.Strings(names)
	for _, name := range names {
		uc := compilation.iteaToUsingCheck[name]
		if !uc.used {
			return tc.errorf(uc.pos, "predeclared identifier itea not used")
		}
		if !uc.toBeEmitted {
			if len(uc.itea.Lhs) != 1 || len(uc.itea.Rhs) != 1 {
				panic(internalError("unexpected"))
			}
			uc.itea.Lhs = []*ast.Identifier{ast.NewIdentifier(nil, "_")}
			uc.itea.Rhs = []ast.Expression{ast.NewBasicLiteral(nil, ast.IntLiteral, "0")}
			tc.checkNodes([]ast.Node{uc.itea})
		}
	}
	return nil
}


text:
require ${PN}.inc

SRC_URI = "https://github.com/bus1/dbus-broker/releases/download/v${PV}/dbus-broker-${PV}.tar.xz"
SRC_URI[md5sum] = "46ff06202e903e02b745e46115868c0b"
SRC_URI[sha256sum] = "f1ef696e751d4d09fc5729b8ef3ce0d3c12c333136ab50f4f8c52bde48eb06e8"


text:
require task-sdk-host.bb
PR = "r1"
DESCRIPTION = "Packages for a standalone SlugOS external toolchain"
ALLOW_EMPTY = "1"

PACKAGES = "${PN}"

RDEPENDS_${PN} += "\
    devio-sdk \
"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
@article{1998ApJ...508L..17D,
 abstract = {We present spectroscopic observations of the host galaxy of GRB 980703.
Several emission and absorption features are detected, making
the redshift (z=0.966) completely unambiguous. This is only the
third known redshift for a \ensuremathγ-ray burst (GRB)
host. The implied isotropic \ensuremathγ-ray energy
release from the burst is in excess of 10$^53$ ergs for a
reasonable choice of cosmological parameters. The spectroscopic
properties of the host galaxy are typical for a star formation-
powered object. Using the observed value of the Balmer
decrement, we derived the extinction in the galaxy's rest frame:
A$_V$åisebox-0.5ex~0.3+/-0.3 mag. Using
three different star formation rate (SFR) indicators, we
estimate SFR\i̊sebox-0.5ex~10 M$_solar$
yr$^-1$ or higher, depending on the extinction, with a lower
limit of SFR>7 M$_solar$ yr$^-1$. This is the highest
value of the SFR measured for a GRB galaxy so far, and it gives
some support to the idea that GRBs are closely related to
massive star formation. <P />Based in part on observations
obtained at the W. K. Keck Observatory, which is operated by the
California Association for Research in Astronomy, a scientific
partnership among the California Institute of Technology, the
University of California, and the National Aeronautics and Space
Administration.},
 adsnote = {Provided by the SAO/NASA Astrophysics Data System},
 adsurl = {https://ui.adsabs.harvard.edu/abs/1998ApJ...508L..17D},
 archiveprefix = {arXiv},
 author = {Djorgovski, S.~G. and Kulkarni, S.~R. and Bloom, J.~S. and
Goodrich, R. and Frail, D.~A. and Piro, L. and Palazzi, E.},
 doi = {10.1086/311729},
 eprint = {astro-ph/9808188},
 journal = {\apjl},
 keywords = {COSMOLOGY: MISCELLANEOUS, COSMOLOGY: OBSERVATIONS, GAMMA RAYS: BURSTS, Cosmology: Miscellaneous, Cosmology: Observations, Gamma Rays: Bursts, Astrophysics},
 month = {Nov},
 number = {1},
 pages = {L17-L20},
 primaryclass = {astro-ph},
 title = {Spectroscopy of the Host Galaxy of the Gamma-Ray Burst 980703},
 volume = {508},
 year = {1998}
}

repository: profjsb/my-content

repo_name: profjsb/my-content

gha_language: TeX


text:
@book{Wilks2011,
author = {Wilks, Daniel S.},
edition = {3},
isbn = {9780123850225},
issn = {01621459},
publisher = {Academic press},
title = {{Statistical Methods in the Atmospheric Sciences}},
volume = {100},
year = {2011}
}

@Manual{R-base,
  title = {R: A Language and Environment for Statistical
           Computing},
  author = {{R Core Team}},
  organization = {R Foundation for Statistical Computing},
  address = {Vienna, Austria},
  year = {2019},
  url = {https://www.R-project.org},
}

license: Unlicense

repository: isezen/CDA

repo_name: isezen/CDA


text:
package main

import (
	"crypto/md5"
	"fmt"
)

const (
	IMAGE_URL string = "https://www.gravatar.com/avatar/%s"
)

func main() {

	fmt.Println("Testing MD5 hash")
	defaultImageURL := DefaultGravatarImageURL("fred.leclerc@gmail.com")
	fmt.Printf("DefaultImageURL : %s", defaultImageURL)

}

func DefaultGravatarImageURL(email string) string {
	emailBytes := []byte(email)
	hash := fmt.Sprintf("%x", md5.Sum(emailBytes))
	return fmt.Sprintf(IMAGE_URL, hash)
}

repository: spacemojo/govatar

repo_name: spacemojo/govatar


text:
#ifndef __ui_base_l10n_util_h__
#define __ui_base_l10n_util_h__

#pragma once

#include "base/string16.h"

namespace ui
{

    // Pulls resource string from the string bundle and returns it.
    std::string GetStringUTF8(int message_id);
    string16 GetStringUTF16(int message_id);

    // Get a resource string and replace $1-$2-$3 with |a| and |b|
    // respectively.  Additionally, $$ is replaced by $.
    string16 GetStringFUTF16(int message_id, const string16& a);

} //namespace ui

#endif //__ui_base_l10n_util_h__

extension: h


text:
include( ${OF_CMAKE_MODULES}/addOnsMacros.cmake )

# --- INTERNAL
OF_include_internal_addOn( ofxOsc )
OF_include_internal_addOn( ofxPoco )
OF_include_internal_addOn( ofxXmlSettings )
OF_include_internal_addOn( ofxGui )
OF_include_internal_addOn( ofxKinect )
OF_include_internal_addOn( ofxNetwork )
OF_include_internal_addOn( ofxSvg )
OF_include_internal_addOn( ofxVectorGraphics )
OF_include_internal_addOn( ofxOpenCv )
OF_include_internal_addOn( ofxThreadedImageLoader )
OF_include_internal_addOn( ofxAssimpModelLoader )
OF_include_internal_addOn( ofxEmscripten )

# --- EXTERNAL
OF_include_external_addOn( ofxTwistedRibbon )
OF_include_external_addOn( ofxOneEuroFilter )
OF_include_external_addOn( ofxFlowTools )
OF_include_external_addOn( ofxMidi )
OF_include_external_addOn( ofxPiMapper )
OF_include_external_addOn( ofxIO )
OF_include_external_addOn( ofxQuadWarp )
OF_include_external_addOn( ofxGrt )
OF_include_external_addOn( ofxEliza )
OF_include_external_addOn( ofxSpeech )
OF_include_external_addOn( ofxUI )
OF_include_external_addOn( ofxSoundProcessor )
OF_include_external_addOn( ofxSyphon )
OF_include_external_addOn( ofxOscHandShake )
OF_include_external_addOn( ofxTextAlign )
OF_include_external_addOn( ofxVideoRecorder )


text:
SECTION = "console/network"
DESCRIPTION = "port of the OpenBSD TFTP server"
LICENSE = "BSD"
SRC_URI = "http://www.kernel.org/pub/software/network/tftp/${P}.tar.bz2"

DEPENDS += "readline update-rc.d"
RDEPENDS += "update-rc.d"

COMPATIBLE_HOST = ".*-linux"

FILES_tftp-hpa = "/tftpboot/ ${bindir} ${sbindir}"

#inherit autotools

#EXTRA_OECONF += "--without-tcpwrappers"

inherit autotools

do_configure () {
	oe_runconf ${EXTRA_OECONF}
}

do_install () {
#	oe_runmake install

	install -d ${D}${bindir}
	install -m 0755 tftp/tftp ${D}${bindir}

	install -d ${D}${sbindir}
	install -m 0755 tftpd/tftpd ${D}${sbindir}/in.tftpd

	install -d ${D}${sysconfdir}/init.d
	install -m 0755 ${FILESDIR}/init ${D}${sysconfdir}/init.d/tftpd
}

# xinetd will start tftpd automatically
#pkg_postinst_tftp-hpa () {
#if test "x$D" != "x"; then
#	D="-r $D"
#else
#	D="-s"
#fi
#update-rc.d $D tftpd defaults
#}


text:
require bug-osgi.inc
PR = "${INC_PR}.3+svnr${SRCREV}"
DEPENDS += "com.buglabs.common com.buglabs.osgi.http servlet2.3"
EXTRA_CP += "servlet-2.3.1"


text:
package errors

import (
	e "errors"
	"testing"

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

func TestErrorInterface(t *testing.T) {
	assert.Equal(t, "error", error(Error{Message: "error"}).Error())
}

func TestNew(t *testing.T) {
	assert.Equal(t, Error{
		Message: "error",
		Field:   "error",
		Code:    1000,
	}, New("error", "error", 1000))
}

func TestUnexpectedError(t *testing.T) {
	err := UnexpectedError("error")

	assert.Equal(t, "error", err.Error())
	assert.Equal(t, "", err.Field)
	assert.True(t, err.UnexpectedError())
}

func TestNotFoundError(t *testing.T) {
	err := NotFoundError("error")

	assert.Equal(t, "error", err.Error())
	assert.Equal(t, "", err.Field)
	assert.True(t, err.NotFoundError())
}

func TestChangesetError(t *testing.T) {
	err := ChangesetError("error", "field")

	assert.Equal(t, "error", err.Error())
	assert.Equal(t, "field", err.Field)
	assert.True(t, err.ChangesetError())
}

func TestDuplicateError(t *testing.T) {
	err := DuplicateError("error", "field")

	assert.Equal(t, "error", err.Error())
	assert.Equal(t, "field", err.Field)
	assert.True(t, err.DuplicateError())
}

func TestWrap(t *testing.T) {
	assert.Equal(t, nil, Wrap(nil))
	assert.Equal(t, Error{}, Wrap(Error{}))
	assert.Equal(t, UnexpectedError("error"), Wrap(e.New("error")))
}


text:
@misc{Doe2020,
  title = {Test title of test book},
  author = {Doe, Jane},
  year = {2020},
  weirdfield = {Blam},
  wonderfield = {Bla}
}

url: https://raw.githubusercontent.com/retorquere/bibtex-parser/05fd68b215b96634dea5a7e6ea5e1be187caf3ed/test/better-bibtex/export/Changing item type for only BibLaTeX does not work #1694.bibtex

repository: retorquere/bibtex-parser

repo_name: retorquere/bibtex-parser

extension: bibtex


text:
@inproceedings{chowdhury2014design,
  title={Design and performance of noncoherent massive SIMO systems},
  author={Chowdhury, Mainak and Manolakos, Alexandros and Goldsmith, Andrea J},
  booktitle={2014 48th Annual Conference on Information Sciences and Systems (CISS)},
  pages={1--6},
  year={2014},
  organization={IEEE}
}

@inproceedings{manolakos2014csi,
  title={CSI is not needed for optimal scaling in multiuser massive SIMO systems},
  author={Manolakos, Alexandros and Chowdhury, Mainak and Goldsmith, Andrea J},
  booktitle={2014 IEEE International Symposium on Information Theory},
  pages={3117--3121},
  year={2014},
  organization={IEEE}
}

@inproceedings{manolakos2014constellation,
  title={Constellation design in noncoherent massive SIMO systems},
  author={Manolakos, Alexandras and Chowdhury, Mainak and Goldsmith, Andrea J},
  booktitle={2014 IEEE Global Communications Conference},
  pages={3690--3695},
  year={2014},
  organization={IEEE}
}

@inproceedings{chowdhury2012per,
  title={The per-user number of receive antennas in uncoded non-Cooperating Transmissions can be Arbitrarily Small},
  author={Chowdhury, M and Goldsmith, A and Weissman, T},
  booktitle={Proceedings of the 50th Annual Allerton Conference on Communication, Control, and Computing, Monticello, IL},
  year={2012}
}

@article{chowdhury2014reliable,
  title={Reliable uncoded communication in the SIMO MAC},
  author={Chowdhury, Mainak and Goldsmith, Andrea},
  journal={IEEE Transactions on Information Theory},
  volume={61},
  number={1},
  pages={388--403},
  year={2014},
  publisher={IEEE}
}

@inproceedings{knott2015benefits,
  title={Benefits of coding in a noncoherent massive SIMO system},
  author={Knott, Brian and Chowdhury, Mainak and Manolakos, Alexandros and Goldsmith, Andrea J},
  booktitle={2015 IEEE International Conference on Communications (ICC)},
  pages={2350--2355},
  year={2015},
  organization={IEEE}
}

@inproceedings{rao2015value,
  title={Value of storage for wind power producers in forward power markets},
  author={Rao, Milind and Chowdhury, Mainak and Zhao, Yue and Javidi, Tara and Goldsmith, Andrea},
  booktitle={2015 American Control Conference (ACC)},
  pages={5686--5691},
  year={2015},
  organization={IEEE}
}

@inproceedings{chowdhury2015capacity,
  title={Capacity scaling in noncoherent wideband massive SIMO systems},
  author={Chowdhury, Mainak and Manolakos, Alexandros and Gomez-Cuba, Felipe and Erkip, Elza and Goldsmith, Andrea J},
  booktitle={2015 IEEE Information Theory Workshop (ITW)},
  pages={1--5},
  year={2015},
  organization={IEEE}
}

@inproceedings{chowdhury2015coherent,
  title={Coherent versus noncoherent massive SIMO systems: Which has better performance?},
  author={Chowdhury, Mainak and Manolakos, Alexandros and Goldsmith, Andrea J},
  booktitle={2015 IEEE International Conference on Communications (ICC)},
  pages={1691--1696},
  year={2015},
  organization={IEEE}
}

@inproceedings{chowdhur2015reliable,
  title={Reliable uncoded communication in the quantized SIMO MAC},
  author={Chowdhur, Mainak and Kipnis, Alon and Goldsmith, Andrea},
  booktitle={2015 IEEE International Symposium on Information Theory (ISIT)},
  pages={2141--2145},
  year={2015},
  organization={IEEE}
}

@article{manolakos2016energy,
  title={Energy-based modulation for noncoherent massive SIMO systems},
  author={Manolakos, Alexandros and Chowdhury, Mainak and Goldsmith, Andrea},
  journal={IEEE Transactions on Wireless Communications},
  volume={15},
  number={11},
  pages={7831--7846},
  year={2016},
  publisher={IEEE}
}

@article{alizadeh2016joint,
  title={Joint management of electric vehicles in coupled power and transportation networks},
  author={Alizadeh, Mahnoosh and Wai, Hoi-To and Chowdhury, Mainak and Goldsmith, Andrea and Scaglione, Anna and Javidi, Tara},
  journal={IEEE Transactions on Control of Network Systems},
  year={2016}
}

@article{chowdhury2016scaling,
  title={Scaling laws for noncoherent energy-based communications in the SIMO MAC},
  author={Chowdhury, Mainak and Manolakos, Alexandros and Goldsmith, Andrea},
  journal={IEEE Transactions on Information Theory},
  volume={62},
  number={4},
  pages={1980--1992},
  year={2016},
  publisher={IEEE}
}

@inproceedings{chowdhury2015multiplexing,
  title={Multiplexing-diversity tradeoffs in noncoherent massive MIMO systems},
  author={Chowdhury, Mainak and Manolakos, Alexandras and Goldsmith, Andrea J},
  booktitle={2015 49th Asilomar Conference on Signals, Systems and Computers},
  pages={312--316},
  year={2015},
  organization={IEEE}
}

@inproceedings{murin2016time,
  title={On time-slotted communication over molecular timing channels},
  author={Murin, Yonathan and Farsad, Nariman and Chowdhury, Mainak and Goldsmith, Andrea},
  booktitle={Proceedings of the 3rd ACM International Conference on Nanoscale Computing and Communication},
  pages={1--6},
  year={2016}
}

@article{chowdhury2016benefits,
  title={Benefits of storage control for wind power producers in power markets},
  author={Chowdhury, Mainak and Rao, Milind and Zhao, Yue and Javidi, Tara and Goldsmith, Andrea},
  journal={IEEE Transactions on Sustainable Energy},
  volume={7},
  number={4},
  pages={1492--1505},
  year={2016},
  publisher={IEEE}
}

@article{chowdhury2015noncoherent,
  title={Noncoherent energy-based communications for the massive SIMO MAC},
  author={Chowdhury, M and Manolakos, A and Goldsmith, AJ},
  journal={under revision, IEEE Transactions on Information Theory},
  year={2015}
}

@article{alizadeh2016optimal,
  title={Optimal pricing to manage electric vehicles in coupled power and transportation networks},
  author={Alizadeh, Mahnoosh and Wai, Hoi-To and Chowdhury, Mainak and Goldsmith, Andrea and Scaglione, Anna and Javidi, Tara},
  journal={IEEE Transactions on control of network systems},
  volume={4},
  number={4},
  pages={863--875},
  year={2016},
  publisher={IEEE}
}

@inproceedings{chowdhury2016capacity,
  title={Capacity of block Rayleigh fading channels without CSI},
  author={Chowdhury, Mainak and Goldsmith, Andrea},
  booktitle={2016 IEEE International Symposium on Information Theory (ISIT)},
  pages={1884--1888},
  year={2016},
  organization={IEEE}
}

@article{chowdhury2016multiplexing,
  title={Multiplexing and diversity gains in noncoherent massive MIMO systems},
  author={Chowdhury, Mainak and Manolakos, Alexandros and Goldsmith, Andrea},
  journal={IEEE Transactions on Wireless Communications},
  volume={16},
  number={1},
  pages={265--277},
  year={2016},
  publisher={IEEE}
}

@inproceedings{murin2016communication,
  title={Communication over diffusion-based molecular timing channels},
  author={Murin, Yonathan and Farsad, Nariman and Chowdhury, Mainak and Goldsmith, Andrea},
  booktitle={2016 IEEE Global Communications Conference (GLOBECOM)},
  pages={1--6},
  year={2016},
  organization={IEEE}
}

@article{murin2017time,
  title={Time-slotted transmission over molecular timing channels},
  author={Murin, Yonathan and Farsad, Nariman and Chowdhury, Mainak and Goldsmith, Andrea},
  journal={Nano communication networks},
  volume={12},
  pages={12--24},
  year={2017},
  publisher={Elsevier}
}

@inproceedings{gebremariam2017resource,
  title={Resource pooling via dynamic spectrum-level slicing across heterogeneous networks},
  author={Gebremariam, Anteneh A and Chowdhury, Mainak and Goldsmith, Andrea and Granelli, Fabrizio},
  booktitle={2017 14th IEEE Annual Consumer Communications \& Networking Conference (CCNC)},
  pages={818--823},
  year={2017},
  organization={IEEE}
}

@inproceedings{chowdhury2017coherence,
  title={Coherence time of wireless channels with large antenna arrays},
  author={Chowdhury, Mainak and Nam, Junyoung and Goldsmith, Andrea J},
  booktitle={2017 IEEE Wireless Communications and Networking Conference (WCNC)},
  pages={1--6},
  year={2017},
  organization={IEEE}
}

@article{murin2017optimal,
  title={Optimal detection for diffusion-based molecular timing channels},
  author={Murin, Yonathan and Farsad, Nariman and Chowdhury, Mainak and Goldsmith, Andrea},
  journal={arXiv preprint arXiv:1709.02977},
  year={2017}
}

@inproceedings{dean2017new,
  title={A new modulation technique for Doppler compensation in frequency-dispersive channels},
  author={Dean, Thomas and Chowdhury, Mainak and Goldsmith, Andrea},
  booktitle={2017 IEEE 28th Annual International Symposium on Personal, Indoor, and Mobile Radio Communications (PIMRC)},
  pages={1--7},
  year={2017},
  organization={IEEE}
}

@inproceedings{gebremariam2017openairlnterface,
  title={An OpenAirlnterface based implementation of dynamic spectrum-level slicing across heterogeneous networks},
  author={Gebremariam, Anteneh A and Chowdhury, Mainak and Goldsmith, Andrea and Granelli, Fabrizio},
  booktitle={2017 14th IEEE Annual Consumer Communications \& Networking Conference (CCNC)},
  pages={609--610},
  year={2017},
  organization={IEEE}
}

@inproceedings{murin2017diversity,
  title={Diversity gain of one-shot communication over molecular timing channels},
  author={Murin, Yonathan and Chowdhury, Mainak and Farsad, Nariman and Goldsmith, Andrea},
  booktitle={GLOBECOM 2017-2017 IEEE Global Communications Conference},
  pages={1--6},
  year={2017},
  organization={IEEE}
}

@inproceedings{chowdhury2017direction,
  title={Direction finding using non-coherent measurements in large antenna arrays},
  author={Chowdhury, Mainak and Rao, Milind and Goldsmith, Andrea},
  booktitle={2017 51st Asilomar Conference on Signals, Systems, and Computers},
  pages={1231--1236},
  year={2017},
  organization={IEEE}
}

@article{murin2018exploiting,
  title={Exploiting diversity in molecular timing channels via order statistics},
  author={Murin, Yonathan and Farsad, Nariman and Chowdhury, Mainak and Goldsmith, Andrea},
  journal={arXiv preprint arXiv:1801.05567},
  year={2018}
}

@inproceedings{gebremariam2018softslice,
  title={SoftSLICE: Policy-based dynamic spectrum slicing in 5G cellular networks},
  author={Gebremariam, Anteneh A and Chowdhury, Mainak and Usman, Muhammad and Goldsmith, Andrea and Granelli, Fabrizio},
  booktitle={2018 IEEE International Conference on Communications (ICC)},
  pages={1--6},
  year={2018},
  organization={IEEE}
}

@article{murin2018exploiting,
  title={Exploiting diversity in one-shot molecular timing channels via order statistics},
  author={Murin, Yonathan and Farsad, Nariman and Chowdhury, Mainak and Goldsmith, Andrea},
  journal={IEEE Transactions on Molecular, Biological and Multi-Scale Communications},
  volume={4},
  number={1},
  pages={14--26},
  year={2018},
  publisher={IEEE}
}

@article{murin2018optimal,
  title={Optimal detection for one-shot transmission over diffusion-based molecular timing channels},
  author={Murin, Yonathan and Farsad, Nariman and Chowdhury, Mainak and Goldsmith, Andrea},
  journal={IEEE Transactions on Molecular, Biological and Multi-Scale Communications},
  volume={4},
  number={2},
  pages={43--60},
  year={2018},
  publisher={IEEE}
}

@article{dean2020rethinking,
  title={Rethinking modulation and detection for high Doppler channels},
  author={Dean, Thomas R and Chowdhury, Mainak and Grimwood, Nicole and Goldsmith, Andrea J},
  journal={IEEE Transactions on Wireless Communications},
  volume={19},
  number={6},
  pages={3629--3642},
  year={2020},
  publisher={IEEE}
}

@article{gomez2019capacity,
  title={Capacity scaling in a non-coherent wideband massive SIMO block fading channel},
  author={Gomez-Cuba, Felipe and Chowdhury, Mainak and Manolakos, Alexandros and Erkip, Elza and Goldsmith, Andrea J},
  journal={IEEE Transactions on Wireless Communications},
  volume={18},
  number={12},
  pages={5691--5704},
  year={2019},
  publisher={IEEE}
}

@inproceedings{chowdhury2015coherent,
  title={Coherent and noncoherent schemes for massive SIMO systems},
  author={Chowdhury, M and Manolakos, A and Goldsmith, AJ},
  booktitle={Proc. IEEE International Conference on Communications (ICC)},
  year={2015}
}

@article{monajemi2013deterministic,
  title={Deterministic matrices matching the compressed sensing phase transitions of Gaussian random matrices},
  author={Monajemi, Hatef and Jafarpour, Sina and Gavish, Matan and Stat 330/CME 362 Collaboration and Donoho, David L and Ambikasaran, Sivaram and Bacallado, Sergio and Bharadia, Dinesh and Chen, Yuxin and Choi, Young and others},
  journal={Proceedings of the National Academy of Sciences},
  volume={110},
  number={4},
  pages={1181--1186},
  year={2013},
  publisher={National Academy of Sciences}
}

@article{ochoa2013qualcomp,
  title={QualComp: a new lossy compressor for quality scores based on rate distortion theory},
  author={Ochoa, Idoia and Asnani, Himanshu and Bharadia, Dinesh and Chowdhury, Mainak and Weissman, Tsachy and Yona, Golan},
  journal={BMC bioinformatics},
  volume={14},
  number={1},
  pages={1--16},
  year={2013},
  publisher={BioMed Central}
}

@inproceedings{chowdhury2013reliable,
  title={Reliable uncoded communication in the SIMO MAC via low-complexity decoding},
  author={Chowdhury, Mainak and Goldsmith, Andrea and Weissman, Tsachy},
  booktitle={2013 IEEE International Symposium on Information Theory},
  pages={1645--1649},
  year={2013},
  organization={IEEE}
}

@inproceedings{chowdhury2012family,
  title={A family of power allocation schemes achieving high secondary user rates in spectrum sharing OFDM cognitive radio},
  author={Chowdhury, Mainak and Singla, Anubhav and Chaturvedi, Ajit K},
  booktitle={2012 IEEE Global Communications Conference (GLOBECOM)},
  pages={1144--1149},
  year={2012},
  organization={IEEE}
}

@inproceedings{chowdhury2013reliable,
  title={Reliable uncoded communication in the underdetermined SIMO MAC with low-complexity decoding},
  author={Chowdhury, Mainak and Goldsmith, Andrea and Weissman, Tsachy},
  booktitle={2013 51st Annual Allerton Conference on Communication, Control, and Computing (Allerton)},
  pages={1075--1081},
  year={2013},
  organization={IEEE}
}

@inproceedings{chowdhury2012uncoded,
  title={Uncoded transmission in MAC channels achieves arbitrarily small error probability},
  author={Chowdhury, Mainak and Goldsmith, Andrea and Weissman, Tsachy},
  booktitle={2012 50th Annual Allerton Conference on Communication, Control, and Computing (Allerton)},
  pages={1983--1990},
  year={2012},
  organization={IEEE}
}

@inproceedings{chowdhury2011robustness,
  title={Robustness Analysis of a List Decoding Algorithm for Compressed Sensing},
  author={Chowdhury, Mainak and Oymak, Samet and Khajehnejad, M Amin and Hassibi, Babak},
  booktitle={International Conference on Acoustics, Speech, and Signal Processing (ICASSP)},
  year={2011}
}


text:
package task

import (
	"github.com/splitio/go-toolkit/v5/asynctask"
	"github.com/splitio/go-toolkit/v5/logging"
	"github.com/splitio/split-synchronizer/v5/splitio/producer/worker"
)

// NewTelemetrySyncTask constructs a task used to periodically record sdk configs and stats into the Split servers
func NewTelemetrySyncTask(wrk worker.TelemetryMultiWorker, logger logging.LoggerInterface, period int) *asynctask.AsyncTask {
	doWork := func(l logging.LoggerInterface) error {
		wrk.SynchronizeStats()
		wrk.SyncrhonizeConfigs()
		return nil
	}
	return asynctask.NewAsyncTask("sdk-telemetry", doWork, period, nil, nil, logger)
}

repository: splitio/split-synchronizer

repo_name: splitio/split-synchronizer

gha_language: Go


text:
DESCRIPTION = "QCOM Firmware for Google Pixel 3a / 3a XL"

FW_QCOM_NAME = "sargo"
EXTRA_DEVICE_NAME = "bonito"
AOSP_BUILD = "sp2a.220405.003"
CHECKSUM_vendor = "85defed7"

SRC_URI[vendor.sha256sum] = "427d9a6f1d0196c0301d37353230359237df43bbee8920f987477867c6163d56"

require recipes-bsp/firmware-nexus/firmware-qcom-pixel.inc

repository: vchong/meta-qcom

repo_name: vchong/meta-qcom

gha_language: BitBake


text:
/*
Copyright © 2019 mutl3y

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package cmd

import (
	"fmt"
	"github.com/spf13/cobra"
	"os"
	"time"
)

// rootCmd represents the base command when called without any subcommands
var rootCmd = &cobra.Command{
	Use:   "prtg_client_util",
	Short: "simple prtg tests for remote nodes",
	Long: `
A collection of PRTG tests to show a clients view of the world
`,
}

// Execute adds all child commands to the root command and sets flags appropriately.
// This is called by main.main(). It only needs to happen once to the rootCmd.
func Execute() {
	if err := rootCmd.Execute(); err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
}

func init() {
	rootCmd.PersistentFlags().DurationP("timeout", "t", 500*time.Millisecond, "timeout string eg 500ms")
	rootCmd.PersistentFlags().BoolP("debug", "d", false, "command line output")
	rootCmd.DisableAutoGenTag = true

}


text:
@unpublished{Simpson,
        author = "H. Simpson",
        title = "Proof of the {R}iemann {H}ypothesis",
        note = "preprint (2003), available at
        \texttt{http://www.math.drofnats.edu/riemann.ps}",
        year = "2003"
}

repository: planejarfinancas/resumos

repo_name: planejarfinancas/resumos