text:
'use strict'
const test = require('tape')
const request = require('req-then')
const localWebServer = require('../')
const http = require('http')

function launchServer (app, options) {
  options = options || {}
  const path = `http://localhost:8100${options.path || '/'}`
  const server = http.createServer(app.callback())
  return server.listen(options.port || 8100, () => {
    const req = request(path, options.reqOptions)
    if (options.onSuccess) req.then(options.onSuccess)
    if (!options.leaveOpen) req.then(() => server.close())
    req.catch(err => console.error('LAUNCH ERROR', err.stack))
  })
}

test('static', function (t) {
  t.plan(1)
  const app = localWebServer({
    log: { format: 'none' },
    static: {
      root: __dirname + '/fixture',
      options: {
        index: 'file.txt'
      }
    }
  })
  launchServer(app, { onSuccess: response => {
    t.ok(/test/.test(response.data))
  }})
})

redpajama_set_name: RedPajamaGithub


text:
// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.

package experimental

import (
	time "time"

	api "k8s.io/kubernetes/pkg/api"
	resource "k8s.io/kubernetes/pkg/api/resource"
	unversioned "k8s.io/kubernetes/pkg/api/unversioned"
	conversion "k8s.io/kubernetes/pkg/conversion"
	util "k8s.io/kubernetes/pkg/util"
	inf "speter.net/go/exp/math/dec/inf"
)

func deepCopy_api_AWSElasticBlockStoreVolumeSource(in api.AWSElasticBlockStoreVolumeSource, out *api.AWSElasticBlockStoreVolumeSource, c *conversion.Cloner) error {
	out.VolumeID = in.VolumeID
	out.FSType = in.FSType
	out.Partition = in.Partition
	out.ReadOnly = in.ReadOnly
	return nil
}

func deepCopy_api_Capabilities(in api.Capabilities, out *api.Capabilities, c *conversion.Cloner) error {
	if in.Add != nil {
		out.Add = make([]api.Capability, len(in.Add))
		for i := range in.Add {
			out.Add[i] = in.Add[i]
		}
	} else {
		out.Add = nil
	}
	if in.Drop != nil {
		out.Drop = make([]api.Capability, len(in.Drop))
		for i := range in.Drop {
			out.Drop[i] = in.Drop[i]
		}
	} else {
		out.Drop = nil
	}
	return nil
}

func deepCopy_api_CephFSVolumeSource(in api.CephFSVolumeSource, out *api.CephFSVolumeSource, c *conversion.Cloner) error {
	if in.Monitors != nil {
		out.Monitors = make([]string, len(in.Monitors))
		for i := range in.Monitors {
			out.Monitors[i] = in.Monitors[i]
		}
	} else {
		out.Monitors = nil
	}
	out.User = in.User
	out.SecretFile = in.SecretFile
	if in.SecretRef != nil {
		out.SecretRef = new(api.LocalObjectReference)
		if err := deepCopy_api_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil {
			return err
		}
	} else {
		out.SecretRef = nil
	}
	out.ReadOnly = in.ReadOnly
	return nil
}

func deepCopy_api_CinderVolumeSource(in api.CinderVolumeSource, out *api.CinderVolumeSource, c *conversion.Cloner) error {
	out.VolumeID = in.VolumeID
	out.FSType = in.FSType
	out.ReadOnly = in.ReadOnly
	return nil
}

func deepCopy_api_Container(in api.Container, out *api.Container, c *conversion.Cloner) error {
	out.Name = in.Name
	out.Image = in.Image
	if in.Command != nil {
		out.Command = make([]string, len(in.Command))
		for i := range in.Command {
			out.Command[i] = in.Command[i]
		}
	} else {
		out.Command = nil
	}
	if in.Args != nil {
		out.Args = make([]string, len(in.Args))
		for i := range in.Args {
			out.Args[i] = in.Args[i]
		}
	} else {
		out.Args = nil
	}
	out.WorkingDir = in.WorkingDir
	if in.Ports != nil {
		out.Ports = make([]api.ContainerPort, len(in.Ports))
		for i := range in.Ports {
			if err := deepCopy_api_ContainerPort(in.Ports[i], &out.Ports[i], c); err != nil {
				return err
			}
		}
	} else {
		out.Ports = nil
	}
	if in.Env != nil {
		out.Env = make([]api.EnvVar, len(in.Env))
		for i := range in.Env {
			if err := deepCopy_api_EnvVar(in.Env[i], &out.Env[i], c); err != nil {
				return err
			}
		}
	} else {
		out.Env = nil
	}
	if err := deepCopy_api_ResourceRequirements(in.Resources, &out.Resources, c); err != nil {
		return err
	}
	if in.VolumeMounts != nil {
		out.VolumeMounts = make([]api.VolumeMount, len(in.VolumeMounts))
		for i := range in.VolumeMounts {
			if err := deepCopy_api_VolumeMount(in.VolumeMounts[i], &out.VolumeMounts[i], c); err != nil {
				return err
			}
		}
	} else {
		out.VolumeMounts = nil
	}
	if in.LivenessProbe != nil {
		out.LivenessProbe = new(api.Probe)
		if err := deepCopy_api_Probe(*in.LivenessProbe, out.LivenessProbe, c); err != nil {
			return err
		}
	} else {
		out.LivenessProbe = nil
	}
	if in.ReadinessProbe != nil {
		out.ReadinessProbe = new(api.Probe)
		if err := deepCopy_api_Probe(*in.ReadinessProbe, out.ReadinessProbe, c); err != nil {
			return err
		}
	} else {
		out.ReadinessProbe = nil
	}
	if in.Lifecycle != nil {
		out.Lifecycle = new(api.Lifecycle)
		if err := deepCopy_api_Lifecycle(*in.Lifecycle, out.Lifecycle, c); err != nil {
			return err
		}
	} else {
		out.Lifecycle = nil
	}
	out.TerminationMessagePath = in.TerminationMessagePath
	out.ImagePullPolicy = in.ImagePullPolicy
	if in.SecurityContext != nil {
		out.SecurityContext = new(api.SecurityContext)
		if err := deepCopy_api_SecurityContext(*in.SecurityContext, out.SecurityContext, c); err != nil {
			return err
		}
	} else {
		out.SecurityContext = nil
	}
	out.Stdin = in.Stdin
	out.TTY = in.TTY
	return nil
}

func deepCopy_api_ContainerPort(in api.ContainerPort, out *api.ContainerPort, c *conversion.Cloner) error {
	out.Name = in.Name
	out.HostPort = in.HostPort
	out.ContainerPort = in.ContainerPort
	out.Protocol = in.Protocol
	out.HostIP = in.HostIP
	return nil
}

func deepCopy_api_DownwardAPIVolumeFile(in api.DownwardAPIVolumeFile, out *api.DownwardAPIVolumeFile, c *conversion.Cloner) error {
	out.Path = in.Path
	if err := deepCopy_api_ObjectFieldSelector(in.FieldRef, &out.FieldRef, c); err != nil {
		return err
	}
	return nil
}

func deepCopy_api_DownwardAPIVolumeSource(in api.DownwardAPIVolumeSource, out *api.DownwardAPIVolumeSource, c *conversion.Cloner) error {
	if in.Items != nil {
		out.Items = make([]api.DownwardAPIVolumeFile, len(in.Items))
		for i := range in.Items {
			if err := deepCopy_api_DownwardAPIVolumeFile(in.Items[i], &out.Items[i], c); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

func deepCopy_api_EmptyDirVolumeSource(in api.EmptyDirVolumeSource, out *api.EmptyDirVolumeSource, c *conversion.Cloner) error {
	out.Medium = in.Medium
	return nil
}

func deepCopy_api_EnvVar(in api.EnvVar, out *api.EnvVar, c *conversion.Cloner) error {
	out.Name = in.Name
	out.Value = in.Value
	if in.ValueFrom != nil {
		out.ValueFrom = new(api.EnvVarSource)
		if err := deepCopy_api_EnvVarSource(*in.ValueFrom, out.ValueFrom, c); err != nil {
			return err
		}
	} else {
		out.ValueFrom = nil
	}
	return nil
}

func deepCopy_api_EnvVarSource(in api.EnvVarSource, out *api.EnvVarSource, c *conversion.Cloner) error {
	if in.FieldRef != nil {
		out.FieldRef = new(api.ObjectFieldSelector)
		if err := deepCopy_api_ObjectFieldSelector(*in.FieldRef, out.FieldRef, c); err != nil {
			return err
		}
	} else {
		out.FieldRef = nil
	}
	return nil
}

func deepCopy_api_ExecAction(in api.ExecAction, out *api.ExecAction, c *conversion.Cloner) error {
	if in.Command != nil {
		out.Command = make([]string, len(in.Command))
		for i := range in.Command {
			out.Command[i] = in.Command[i]
		}
	} else {
		out.Command = nil
	}
	return nil
}

func deepCopy_api_GCEPersistentDiskVolumeSource(in api.GCEPersistentDiskVolumeSource, out *api.GCEPersistentDiskVolumeSource, c *conversion.Cloner) error {
	out.PDName = in.PDName
	out.FSType = in.FSType
	out.Partition = in.Partition
	out.ReadOnly = in.ReadOnly
	return nil
}

func deepCopy_api_GitRepoVolumeSource(in api.GitRepoVolumeSource, out *api.GitRepoVolumeSource, c *conversion.Cloner) error {
	out.Repository = in.Repository
	out.Revision = in.Revision
	return nil
}

func deepCopy_api_GlusterfsVolumeSource(in api.GlusterfsVolumeSource, out *api.GlusterfsVolumeSource, c *conversion.Cloner) error {
	out.EndpointsName = in.EndpointsName
	out.Path = in.Path
	out.ReadOnly = in.ReadOnly
	return nil
}

func deepCopy_api_HTTPGetAction(in api.HTTPGetAction, out *api.HTTPGetAction, c *conversion.Cloner) error {
	out.Path = in.Path
	if err := deepCopy_util_IntOrString(in.Port, &out.Port, c); err != nil {
		return err
	}
	out.Host = in.Host
	out.Scheme = in.Scheme
	return nil
}

func deepCopy_api_Handler(in api.Handler, out *api.Handler, c *conversion.Cloner) error {
	if in.Exec != nil {
		out.Exec = new(api.ExecAction)
		if err := deepCopy_api_ExecAction(*in.Exec, out.Exec, c); err != nil {
			return err
		}
	} else {
		out.Exec = nil
	}
	if in.HTTPGet != nil {
		out.HTTPGet = new(api.HTTPGetAction)
		if err := deepCopy_api_HTTPGetAction(*in.HTTPGet, out.HTTPGet, c); err != nil {
			return err
		}
	} else {
		out.HTTPGet = nil
	}
	if in.TCPSocket != nil {
		out.TCPSocket = new(api.TCPSocketAction)
		if err := deepCopy_api_TCPSocketAction(*in.TCPSocket, out.TCPSocket, c); err != nil {
			return err
		}
	} else {
		out.TCPSocket = nil
	}
	return nil
}

func deepCopy_api_HostPathVolumeSource(in api.HostPathVolumeSource, out *api.HostPathVolumeSource, c *conversion.Cloner) error {
	out.Path = in.Path
	return nil
}

func deepCopy_api_ISCSIVolumeSource(in api.ISCSIVolumeSource, out *api.ISCSIVolumeSource, c *conversion.Cloner) error {
	out.TargetPortal = in.TargetPortal
	out.IQN = in.IQN
	out.Lun = in.Lun
	out.FSType = in.FSType
	out.ReadOnly = in.ReadOnly
	return nil
}

func deepCopy_api_Lifecycle(in api.Lifecycle, out *api.Lifecycle, c *conversion.Cloner) error {
	if in.PostStart != nil {
		out.PostStart = new(api.Handler)
		if err := deepCopy_api_Handler(*in.PostStart, out.PostStart, c); err != nil {
			return err
		}
	} else {
		out.PostStart = nil
	}
	if in.PreStop != nil {
		out.PreStop = new(api.Handler)
		if err := deepCopy_api_Handler(*in.PreStop, out.PreStop, c); err != nil {
			return err
		}
	} else {
		out.PreStop = nil
	}
	return nil
}

func deepCopy_api_LocalObjectReference(in api.LocalObjectReference, out *api.LocalObjectReference, c *conversion.Cloner) error {
	out.Name = in.Name
	return nil
}

func deepCopy_api_NFSVolumeSource(in api.NFSVolumeSource, out *api.NFSVolumeSource, c *conversion.Cloner) error {
	out.Server = in.Server
	out.Path = in.Path
	out.ReadOnly = in.ReadOnly
	return nil
}

func deepCopy_api_ObjectFieldSelector(in api.ObjectFieldSelector, out *api.ObjectFieldSelector, c *conversion.Cloner) error {
	out.APIVersion = in.APIVersion
	out.FieldPath = in.FieldPath
	return nil
}

func deepCopy_api_ObjectMeta(in api.ObjectMeta, out *api.ObjectMeta, c *conversion.Cloner) error {
	out.Name = in.Name
	out.GenerateName = in.GenerateName
	out.Namespace = in.Namespace
	out.SelfLink = in.SelfLink
	out.UID = in.UID
	out.ResourceVersion = in.ResourceVersion
	out.Generation = in.Generation
	if err := deepCopy_util_Time(in.CreationTimestamp, &out.CreationTimestamp, c); err != nil {
		return err
	}
	if in.DeletionTimestamp != nil {
		out.DeletionTimestamp = new(util.Time)
		if err := deepCopy_util_Time(*in.DeletionTimestamp, out.DeletionTimestamp, c); err != nil {
			return err
		}
	} else {
		out.DeletionTimestamp = nil
	}
	if in.DeletionGracePeriodSeconds != nil {
		out.DeletionGracePeriodSeconds = new(int64)
		*out.DeletionGracePeriodSeconds = *in.DeletionGracePeriodSeconds
	} else {
		out.DeletionGracePeriodSeconds = nil
	}
	if in.Labels != nil {
		out.Labels = make(map[string]string)
		for key, val := range in.Labels {
			out.Labels[key] = val
		}
	} else {
		out.Labels = nil
	}
	if in.Annotations != nil {
		out.Annotations = make(map[string]string)
		for key, val := range in.Annotations {
			out.Annotations[key] = val
		}
	} else {
		out.Annotations = nil
	}
	return nil
}

func deepCopy_api_PersistentVolumeClaimVolumeSource(in api.PersistentVolumeClaimVolumeSource, out *api.PersistentVolumeClaimVolumeSource, c *conversion.Cloner) error {
	out.ClaimName = in.ClaimName
	out.ReadOnly = in.ReadOnly
	return nil
}

func deepCopy_api_PodSpec(in api.PodSpec, out *api.PodSpec, c *conversion.Cloner) error {
	if in.Volumes != nil {
		out.Volumes = make([]api.Volume, len(in.Volumes))
		for i := range in.Volumes {
			if err := deepCopy_api_Volume(in.Volumes[i], &out.Volumes[i], c); err != nil {
				return err
			}
		}
	} else {
		out.Volumes = nil
	}
	if in.Containers != nil {
		out.Containers = make([]api.Container, len(in.Containers))
		for i := range in.Containers {
			if err := deepCopy_api_Container(in.Containers[i], &out.Containers[i], c); err != nil {
				return err
			}
		}
	} else {
		out.Containers = nil
	}
	out.RestartPolicy = in.RestartPolicy
	if in.TerminationGracePeriodSeconds != nil {
		out.TerminationGracePeriodSeconds = new(int64)
		*out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds
	} else {
		out.TerminationGracePeriodSeconds = nil
	}
	if in.ActiveDeadlineSeconds != nil {
		out.ActiveDeadlineSeconds = new(int64)
		*out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
	} else {
		out.ActiveDeadlineSeconds = nil
	}
	out.DNSPolicy = in.DNSPolicy
	if in.NodeSelector != nil {
		out.NodeSelector = make(map[string]string)
		for key, val := range in.NodeSelector {
			out.NodeSelector[key] = val
		}
	} else {
		out.NodeSelector = nil
	}
	out.ServiceAccountName = in.ServiceAccountName
	out.NodeName = in.NodeName
	out.HostNetwork = in.HostNetwork
	out.HostPID = in.HostPID
	if in.ImagePullSecrets != nil {
		out.ImagePullSecrets = make([]api.LocalObjectReference, len(in.ImagePullSecrets))
		for i := range in.ImagePullSecrets {
			if err := deepCopy_api_LocalObjectReference(in.ImagePullSecrets[i], &out.ImagePullSecrets[i], c); err != nil {
				return err
			}
		}
	} else {
		out.ImagePullSecrets = nil
	}
	return nil
}

func deepCopy_api_PodTemplateSpec(in api.PodTemplateSpec, out *api.PodTemplateSpec, c *conversion.Cloner) error {
	if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
		return err
	}
	if err := deepCopy_api_PodSpec(in.Spec, &out.Spec, c); err != nil {
		return err
	}
	return nil
}

func deepCopy_api_Probe(in api.Probe, out *api.Probe, c *conversion.Cloner) error {
	if err := deepCopy_api_Handler(in.Handler, &out.Handler, c); err != nil {
		return err
	}
	out.InitialDelaySeconds = in.InitialDelaySeconds
	out.TimeoutSeconds = in.TimeoutSeconds
	return nil
}

func deepCopy_api_RBDVolumeSource(in api.RBDVolumeSource, out *api.RBDVolumeSource, c *conversion.Cloner) error {
	if in.CephMonitors != nil {
		out.CephMonitors = make([]string, len(in.CephMonitors))
		for i := range in.CephMonitors {
			out.CephMonitors[i] = in.CephMonitors[i]
		}
	} else {
		out.CephMonitors = nil
	}
	out.RBDImage = in.RBDImage
	out.FSType = in.FSType
	out.RBDPool = in.RBDPool
	out.RadosUser = in.RadosUser
	out.Keyring = in.Keyring
	if in.SecretRef != nil {
		out.SecretRef = new(api.LocalObjectReference)
		if err := deepCopy_api_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil {
			return err
		}
	} else {
		out.SecretRef = nil
	}
	out.ReadOnly = in.ReadOnly
	return nil
}

func deepCopy_api_ResourceRequirements(in api.ResourceRequirements, out *api.ResourceRequirements, c *conversion.Cloner) error {
	if in.Limits != nil {
		out.Limits = make(api.ResourceList)
		for key, val := range in.Limits {
			newVal := new(resource.Quantity)
			if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
				return err
			}
			out.Limits[key] = *newVal
		}
	} else {
		out.Limits = nil
	}
	if in.Requests != nil {
		out.Requests = make(api.ResourceList)
		for key, val := range in.Requests {
			newVal := new(resource.Quantity)
			if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
				return err
			}
			out.Requests[key] = *newVal
		}
	} else {
		out.Requests = nil
	}
	return nil
}

func deepCopy_api_SELinuxOptions(in api.SELinuxOptions, out *api.SELinuxOptions, c *conversion.Cloner) error {
	out.User = in.User
	out.Role = in.Role
	out.Type = in.Type
	out.Level = in.Level
	return nil
}

func deepCopy_api_SecretVolumeSource(in api.SecretVolumeSource, out *api.SecretVolumeSource, c *conversion.Cloner) error {
	out.SecretName = in.SecretName
	return nil
}

func deepCopy_api_SecurityContext(in api.SecurityContext, out *api.SecurityContext, c *conversion.Cloner) error {
	if in.Capabilities != nil {
		out.Capabilities = new(api.Capabilities)
		if err := deepCopy_api_Capabilities(*in.Capabilities, out.Capabilities, c); err != nil {
			return err
		}
	} else {
		out.Capabilities = nil
	}
	if in.Privileged != nil {
		out.Privileged = new(bool)
		*out.Privileged = *in.Privileged
	} else {
		out.Privileged = nil
	}
	if in.SELinuxOptions != nil {
		out.SELinuxOptions = new(api.SELinuxOptions)
		if err := deepCopy_api_SELinuxOptions(*in.SELinuxOptions, out.SELinuxOptions, c); err != nil {
			return err
		}
	} else {
		out.SELinuxOptions = nil
	}
	if in.RunAsUser != nil {
		out.RunAsUser = new(int64)
		*out.RunAsUser = *in.RunAsUser
	} else {
		out.RunAsUser = nil
	}
	out.RunAsNonRoot = in.RunAsNonRoot
	return nil
}

func deepCopy_api_TCPSocketAction(in api.TCPSocketAction, out *api.TCPSocketAction, c *conversion.Cloner) error {
	if err := deepCopy_util_IntOrString(in.Port, &out.Port, c); err != nil {
		return err
	}
	return nil
}

func deepCopy_api_Volume(in api.Volume, out *api.Volume, c *conversion.Cloner) error {
	out.Name = in.Name
	if err := deepCopy_api_VolumeSource(in.VolumeSource, &out.VolumeSource, c); err != nil {
		return err
	}
	return nil
}

func deepCopy_api_VolumeMount(in api.VolumeMount, out *api.VolumeMount, c *conversion.Cloner) error {
	out.Name = in.Name
	out.ReadOnly = in.ReadOnly
	out.MountPath = in.MountPath
	return nil
}

func deepCopy_api_VolumeSource(in api.VolumeSource, out *api.VolumeSource, c *conversion.Cloner) error {
	if in.HostPath != nil {
		out.HostPath = new(api.HostPathVolumeSource)
		if err := deepCopy_api_HostPathVolumeSource(*in.HostPath, out.HostPath, c); err != nil {
			return err
		}
	} else {
		out.HostPath = nil
	}
	if in.EmptyDir != nil {
		out.EmptyDir = new(api.EmptyDirVolumeSource)
		if err := deepCopy_api_EmptyDirVolumeSource(*in.EmptyDir, out.EmptyDir, c); err != nil {
			return err
		}
	} else {
		out.EmptyDir = nil
	}
	if in.GCEPersistentDisk != nil {
		out.GCEPersistentDisk = new(api.GCEPersistentDiskVolumeSource)
		if err := deepCopy_api_GCEPersistentDiskVolumeSource(*in.GCEPersistentDisk, out.GCEPersistentDisk, c); err != nil {
			return err
		}
	} else {
		out.GCEPersistentDisk = nil
	}
	if in.AWSElasticBlockStore != nil {
		out.AWSElasticBlockStore = new(api.AWSElasticBlockStoreVolumeSource)
		if err := deepCopy_api_AWSElasticBlockStoreVolumeSource(*in.AWSElasticBlockStore, out.AWSElasticBlockStore, c); err != nil {
			return err
		}
	} else {
		out.AWSElasticBlockStore = nil
	}
	if in.GitRepo != nil {
		out.GitRepo = new(api.GitRepoVolumeSource)
		if err := deepCopy_api_GitRepoVolumeSource(*in.GitRepo, out.GitRepo, c); err != nil {
			return err
		}
	} else {
		out.GitRepo = nil
	}
	if in.Secret != nil {
		out.Secret = new(api.SecretVolumeSource)
		if err := deepCopy_api_SecretVolumeSource(*in.Secret, out.Secret, c); err != nil {
			return err
		}
	} else {
		out.Secret = nil
	}
	if in.NFS != nil {
		out.NFS = new(api.NFSVolumeSource)
		if err := deepCopy_api_NFSVolumeSource(*in.NFS, out.NFS, c); err != nil {
			return err
		}
	} else {
		out.NFS = nil
	}
	if in.ISCSI != nil {
		out.ISCSI = new(api.ISCSIVolumeSource)
		if err := deepCopy_api_ISCSIVolumeSource(*in.ISCSI, out.ISCSI, c); err != nil {
			return err
		}
	} else {
		out.ISCSI = nil
	}
	if in.Glusterfs != nil {
		out.Glusterfs = new(api.GlusterfsVolumeSource)
		if err := deepCopy_api_GlusterfsVolumeSource(*in.Glusterfs, out.Glusterfs, c); err != nil {
			return err
		}
	} else {
		out.Glusterfs = nil
	}
	if in.PersistentVolumeClaim != nil {
		out.PersistentVolumeClaim = new(api.PersistentVolumeClaimVolumeSource)
		if err := deepCopy_api_PersistentVolumeClaimVolumeSource(*in.PersistentVolumeClaim, out.PersistentVolumeClaim, c); err != nil {
			return err
		}
	} else {
		out.PersistentVolumeClaim = nil
	}
	if in.RBD != nil {
		out.RBD = new(api.RBDVolumeSource)
		if err := deepCopy_api_RBDVolumeSource(*in.RBD, out.RBD, c); err != nil {
			return err
		}
	} else {
		out.RBD = nil
	}
	if in.Cinder != nil {
		out.Cinder = new(api.CinderVolumeSource)
		if err := deepCopy_api_CinderVolumeSource(*in.Cinder, out.Cinder, c); err != nil {
			return err
		}
	} else {
		out.Cinder = nil
	}
	if in.CephFS != nil {
		out.CephFS = new(api.CephFSVolumeSource)
		if err := deepCopy_api_CephFSVolumeSource(*in.CephFS, out.CephFS, c); err != nil {
			return err
		}
	} else {
		out.CephFS = nil
	}
	if in.DownwardAPI != nil {
		out.DownwardAPI = new(api.DownwardAPIVolumeSource)
		if err := deepCopy_api_DownwardAPIVolumeSource(*in.DownwardAPI, out.DownwardAPI, c); err != nil {
			return err
		}
	} else {
		out.DownwardAPI = nil
	}
	return nil
}

func deepCopy_resource_Quantity(in resource.Quantity, out *resource.Quantity, c *conversion.Cloner) error {
	if in.Amount != nil {
		if newVal, err := c.DeepCopy(in.Amount); err != nil {
			return err
		} else if newVal == nil {
			out.Amount = nil
		} else {
			out.Amount = newVal.(*inf.Dec)
		}
	} else {
		out.Amount = nil
	}
	out.Format = in.Format
	return nil
}

func deepCopy_unversioned_ListMeta(in unversioned.ListMeta, out *unversioned.ListMeta, c *conversion.Cloner) error {
	out.SelfLink = in.SelfLink
	out.ResourceVersion = in.ResourceVersion
	return nil
}

func deepCopy_unversioned_TypeMeta(in unversioned.TypeMeta, out *unversioned.TypeMeta, c *conversion.Cloner) error {
	out.Kind = in.Kind
	out.APIVersion = in.APIVersion
	return nil
}

func deepCopy_experimental_APIVersion(in APIVersion, out *APIVersion, c *conversion.Cloner) error {
	out.Name = in.Name
	out.APIGroup = in.APIGroup
	return nil
}

func deepCopy_experimental_DaemonSet(in DaemonSet, out *DaemonSet, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
		return err
	}
	if err := deepCopy_experimental_DaemonSetSpec(in.Spec, &out.Spec, c); err != nil {
		return err
	}
	if err := deepCopy_experimental_DaemonSetStatus(in.Status, &out.Status, c); err != nil {
		return err
	}
	return nil
}

func deepCopy_experimental_DaemonSetList(in DaemonSetList, out *DaemonSetList, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
		return err
	}
	if in.Items != nil {
		out.Items = make([]DaemonSet, len(in.Items))
		for i := range in.Items {
			if err := deepCopy_experimental_DaemonSet(in.Items[i], &out.Items[i], c); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

func deepCopy_experimental_DaemonSetSpec(in DaemonSetSpec, out *DaemonSetSpec, c *conversion.Cloner) error {
	if in.Selector != nil {
		out.Selector = make(map[string]string)
		for key, val := range in.Selector {
			out.Selector[key] = val
		}
	} else {
		out.Selector = nil
	}
	if in.Template != nil {
		out.Template = new(api.PodTemplateSpec)
		if err := deepCopy_api_PodTemplateSpec(*in.Template, out.Template, c); err != nil {
			return err
		}
	} else {
		out.Template = nil
	}
	return nil
}

func deepCopy_experimental_DaemonSetStatus(in DaemonSetStatus, out *DaemonSetStatus, c *conversion.Cloner) error {
	out.CurrentNumberScheduled = in.CurrentNumberScheduled
	out.NumberMisscheduled = in.NumberMisscheduled
	out.DesiredNumberScheduled = in.DesiredNumberScheduled
	return nil
}

func deepCopy_experimental_Deployment(in Deployment, out *Deployment, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
		return err
	}
	if err := deepCopy_experimental_DeploymentSpec(in.Spec, &out.Spec, c); err != nil {
		return err
	}
	if err := deepCopy_experimental_DeploymentStatus(in.Status, &out.Status, c); err != nil {
		return err
	}
	return nil
}

func deepCopy_experimental_DeploymentList(in DeploymentList, out *DeploymentList, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
		return err
	}
	if in.Items != nil {
		out.Items = make([]Deployment, len(in.Items))
		for i := range in.Items {
			if err := deepCopy_experimental_Deployment(in.Items[i], &out.Items[i], c); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

func deepCopy_experimental_DeploymentSpec(in DeploymentSpec, out *DeploymentSpec, c *conversion.Cloner) error {
	out.Replicas = in.Replicas
	if in.Selector != nil {
		out.Selector = make(map[string]string)
		for key, val := range in.Selector {
			out.Selector[key] = val
		}
	} else {
		out.Selector = nil
	}
	if in.Template != nil {
		out.Template = new(api.PodTemplateSpec)
		if err := deepCopy_api_PodTemplateSpec(*in.Template, out.Template, c); err != nil {
			return err
		}
	} else {
		out.Template = nil
	}
	if err := deepCopy_experimental_DeploymentStrategy(in.Strategy, &out.Strategy, c); err != nil {
		return err
	}
	out.UniqueLabelKey = in.UniqueLabelKey
	return nil
}

func deepCopy_experimental_DeploymentStatus(in DeploymentStatus, out *DeploymentStatus, c *conversion.Cloner) error {
	out.Replicas = in.Replicas
	out.UpdatedReplicas = in.UpdatedReplicas
	return nil
}

func deepCopy_experimental_DeploymentStrategy(in DeploymentStrategy, out *DeploymentStrategy, c *conversion.Cloner) error {
	out.Type = in.Type
	if in.RollingUpdate != nil {
		out.RollingUpdate = new(RollingUpdateDeployment)
		if err := deepCopy_experimental_RollingUpdateDeployment(*in.RollingUpdate, out.RollingUpdate, c); err != nil {
			return err
		}
	} else {
		out.RollingUpdate = nil
	}
	return nil
}

func deepCopy_experimental_HorizontalPodAutoscaler(in HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
		return err
	}
	if err := deepCopy_experimental_HorizontalPodAutoscalerSpec(in.Spec, &out.Spec, c); err != nil {
		return err
	}
	if in.Status != nil {
		out.Status = new(HorizontalPodAutoscalerStatus)
		if err := deepCopy_experimental_HorizontalPodAutoscalerStatus(*in.Status, out.Status, c); err != nil {
			return err
		}
	} else {
		out.Status = nil
	}
	return nil
}

func deepCopy_experimental_HorizontalPodAutoscalerList(in HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
		return err
	}
	if in.Items != nil {
		out.Items = make([]HorizontalPodAutoscaler, len(in.Items))
		for i := range in.Items {
			if err := deepCopy_experimental_HorizontalPodAutoscaler(in.Items[i], &out.Items[i], c); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

func deepCopy_experimental_HorizontalPodAutoscalerSpec(in HorizontalPodAutoscalerSpec, out *HorizontalPodAutoscalerSpec, c *conversion.Cloner) error {
	if in.ScaleRef != nil {
		out.ScaleRef = new(SubresourceReference)
		if err := deepCopy_experimental_SubresourceReference(*in.ScaleRef, out.ScaleRef, c); err != nil {
			return err
		}
	} else {
		out.ScaleRef = nil
	}
	out.MinCount = in.MinCount
	out.MaxCount = in.MaxCount
	if err := deepCopy_experimental_ResourceConsumption(in.Target, &out.Target, c); err != nil {
		return err
	}
	return nil
}

func deepCopy_experimental_HorizontalPodAutoscalerStatus(in HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, c *conversion.Cloner) error {
	out.CurrentReplicas = in.CurrentReplicas
	out.DesiredReplicas = in.DesiredReplicas
	if in.CurrentConsumption != nil {
		out.CurrentConsumption = new(ResourceConsumption)
		if err := deepCopy_experimental_ResourceConsumption(*in.CurrentConsumption, out.CurrentConsumption, c); err != nil {
			return err
		}
	} else {
		out.CurrentConsumption = nil
	}
	if in.LastScaleTimestamp != nil {
		out.LastScaleTimestamp = new(util.Time)
		if err := deepCopy_util_Time(*in.LastScaleTimestamp, out.LastScaleTimestamp, c); err != nil {
			return err
		}
	} else {
		out.LastScaleTimestamp = nil
	}
	return nil
}

func deepCopy_experimental_Job(in Job, out *Job, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
		return err
	}
	if err := deepCopy_experimental_JobSpec(in.Spec, &out.Spec, c); err != nil {
		return err
	}
	if err := deepCopy_experimental_JobStatus(in.Status, &out.Status, c); err != nil {
		return err
	}
	return nil
}

func deepCopy_experimental_JobCondition(in JobCondition, out *JobCondition, c *conversion.Cloner) error {
	out.Type = in.Type
	out.Status = in.Status
	if err := deepCopy_util_Time(in.LastProbeTime, &out.LastProbeTime, c); err != nil {
		return err
	}
	if err := deepCopy_util_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
		return err
	}
	out.Reason = in.Reason
	out.Message = in.Message
	return nil
}

func deepCopy_experimental_JobList(in JobList, out *JobList, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
		return err
	}
	if in.Items != nil {
		out.Items = make([]Job, len(in.Items))
		for i := range in.Items {
			if err := deepCopy_experimental_Job(in.Items[i], &out.Items[i], c); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

func deepCopy_experimental_JobSpec(in JobSpec, out *JobSpec, c *conversion.Cloner) error {
	if in.Parallelism != nil {
		out.Parallelism = new(int)
		*out.Parallelism = *in.Parallelism
	} else {
		out.Parallelism = nil
	}
	if in.Completions != nil {
		out.Completions = new(int)
		*out.Completions = *in.Completions
	} else {
		out.Completions = nil
	}
	if in.Selector != nil {
		out.Selector = make(map[string]string)
		for key, val := range in.Selector {
			out.Selector[key] = val
		}
	} else {
		out.Selector = nil
	}
	if in.Template != nil {
		out.Template = new(api.PodTemplateSpec)
		if err := deepCopy_api_PodTemplateSpec(*in.Template, out.Template, c); err != nil {
			return err
		}
	} else {
		out.Template = nil
	}
	return nil
}

func deepCopy_experimental_JobStatus(in JobStatus, out *JobStatus, c *conversion.Cloner) error {
	if in.Conditions != nil {
		out.Conditions = make([]JobCondition, len(in.Conditions))
		for i := range in.Conditions {
			if err := deepCopy_experimental_JobCondition(in.Conditions[i], &out.Conditions[i], c); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	if in.StartTime != nil {
		out.StartTime = new(util.Time)
		if err := deepCopy_util_Time(*in.StartTime, out.StartTime, c); err != nil {
			return err
		}
	} else {
		out.StartTime = nil
	}
	if in.CompletionTime != nil {
		out.CompletionTime = new(util.Time)
		if err := deepCopy_util_Time(*in.CompletionTime, out.CompletionTime, c); err != nil {
			return err
		}
	} else {
		out.CompletionTime = nil
	}
	out.Active = in.Active
	out.Successful = in.Successful
	out.Unsuccessful = in.Unsuccessful
	return nil
}

func deepCopy_experimental_ReplicationControllerDummy(in ReplicationControllerDummy, out *ReplicationControllerDummy, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	return nil
}

func deepCopy_experimental_ResourceConsumption(in ResourceConsumption, out *ResourceConsumption, c *conversion.Cloner) error {
	out.Resource = in.Resource
	if err := deepCopy_resource_Quantity(in.Quantity, &out.Quantity, c); err != nil {
		return err
	}
	return nil
}

func deepCopy_experimental_RollingUpdateDeployment(in RollingUpdateDeployment, out *RollingUpdateDeployment, c *conversion.Cloner) error {
	if err := deepCopy_util_IntOrString(in.MaxUnavailable, &out.MaxUnavailable, c); err != nil {
		return err
	}
	if err := deepCopy_util_IntOrString(in.MaxSurge, &out.MaxSurge, c); err != nil {
		return err
	}
	out.MinReadySeconds = in.MinReadySeconds
	return nil
}

func deepCopy_experimental_Scale(in Scale, out *Scale, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
		return err
	}
	if err := deepCopy_experimental_ScaleSpec(in.Spec, &out.Spec, c); err != nil {
		return err
	}
	if err := deepCopy_experimental_ScaleStatus(in.Status, &out.Status, c); err != nil {
		return err
	}
	return nil
}

func deepCopy_experimental_ScaleSpec(in ScaleSpec, out *ScaleSpec, c *conversion.Cloner) error {
	out.Replicas = in.Replicas
	return nil
}

func deepCopy_experimental_ScaleStatus(in ScaleStatus, out *ScaleStatus, c *conversion.Cloner) error {
	out.Replicas = in.Replicas
	if in.Selector != nil {
		out.Selector = make(map[string]string)
		for key, val := range in.Selector {
			out.Selector[key] = val
		}
	} else {
		out.Selector = nil
	}
	return nil
}

func deepCopy_experimental_SubresourceReference(in SubresourceReference, out *SubresourceReference, c *conversion.Cloner) error {
	out.Kind = in.Kind
	out.Namespace = in.Namespace
	out.Name = in.Name
	out.APIVersion = in.APIVersion
	out.Subresource = in.Subresource
	return nil
}

func deepCopy_experimental_ThirdPartyResource(in ThirdPartyResource, out *ThirdPartyResource, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
		return err
	}
	out.Description = in.Description
	if in.Versions != nil {
		out.Versions = make([]APIVersion, len(in.Versions))
		for i := range in.Versions {
			if err := deepCopy_experimental_APIVersion(in.Versions[i], &out.Versions[i], c); err != nil {
				return err
			}
		}
	} else {
		out.Versions = nil
	}
	return nil
}

func deepCopy_experimental_ThirdPartyResourceData(in ThirdPartyResourceData, out *ThirdPartyResourceData, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
		return err
	}
	if in.Data != nil {
		out.Data = make([]uint8, len(in.Data))
		for i := range in.Data {
			out.Data[i] = in.Data[i]
		}
	} else {
		out.Data = nil
	}
	return nil
}

func deepCopy_experimental_ThirdPartyResourceDataList(in ThirdPartyResourceDataList, out *ThirdPartyResourceDataList, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
		return err
	}
	if in.Items != nil {
		out.Items = make([]ThirdPartyResourceData, len(in.Items))
		for i := range in.Items {
			if err := deepCopy_experimental_ThirdPartyResourceData(in.Items[i], &out.Items[i], c); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

func deepCopy_experimental_ThirdPartyResourceList(in ThirdPartyResourceList, out *ThirdPartyResourceList, c *conversion.Cloner) error {
	if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
		return err
	}
	if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
		return err
	}
	if in.Items != nil {
		out.Items = make([]ThirdPartyResource, len(in.Items))
		for i := range in.Items {
			if err := deepCopy_experimental_ThirdPartyResource(in.Items[i], &out.Items[i], c); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

func deepCopy_util_IntOrString(in util.IntOrString, out *util.IntOrString, c *conversion.Cloner) error {
	out.Kind = in.Kind
	out.IntVal = in.IntVal
	out.StrVal = in.StrVal
	return nil
}

func deepCopy_util_Time(in util.Time, out *util.Time, c *conversion.Cloner) error {
	if newVal, err := c.DeepCopy(in.Time); err != nil {
		return err
	} else {
		out.Time = newVal.(time.Time)
	}
	return nil
}

func init() {
	err := api.Scheme.AddGeneratedDeepCopyFuncs(
		deepCopy_api_AWSElasticBlockStoreVolumeSource,
		deepCopy_api_Capabilities,
		deepCopy_api_CephFSVolumeSource,
		deepCopy_api_CinderVolumeSource,
		deepCopy_api_Container,
		deepCopy_api_ContainerPort,
		deepCopy_api_DownwardAPIVolumeFile,
		deepCopy_api_DownwardAPIVolumeSource,
		deepCopy_api_EmptyDirVolumeSource,
		deepCopy_api_EnvVar,
		deepCopy_api_EnvVarSource,
		deepCopy_api_ExecAction,
		deepCopy_api_GCEPersistentDiskVolumeSource,
		deepCopy_api_GitRepoVolumeSource,
		deepCopy_api_GlusterfsVolumeSource,
		deepCopy_api_HTTPGetAction,
		deepCopy_api_Handler,
		deepCopy_api_HostPathVolumeSource,
		deepCopy_api_ISCSIVolumeSource,
		deepCopy_api_Lifecycle,
		deepCopy_api_LocalObjectReference,
		deepCopy_api_NFSVolumeSource,
		deepCopy_api_ObjectFieldSelector,
		deepCopy_api_ObjectMeta,
		deepCopy_api_PersistentVolumeClaimVolumeSource,
		deepCopy_api_PodSpec,
		deepCopy_api_PodTemplateSpec,
		deepCopy_api_Probe,
		deepCopy_api_RBDVolumeSource,
		deepCopy_api_ResourceRequirements,
		deepCopy_api_SELinuxOptions,
		deepCopy_api_SecretVolumeSource,
		deepCopy_api_SecurityContext,
		deepCopy_api_TCPSocketAction,
		deepCopy_api_Volume,
		deepCopy_api_VolumeMount,
		deepCopy_api_VolumeSource,
		deepCopy_resource_Quantity,
		deepCopy_unversioned_ListMeta,
		deepCopy_unversioned_TypeMeta,
		deepCopy_experimental_APIVersion,
		deepCopy_experimental_DaemonSet,
		deepCopy_experimental_DaemonSetList,
		deepCopy_experimental_DaemonSetSpec,
		deepCopy_experimental_DaemonSetStatus,
		deepCopy_experimental_Deployment,
		deepCopy_experimental_DeploymentList,
		deepCopy_experimental_DeploymentSpec,
		deepCopy_experimental_DeploymentStatus,
		deepCopy_experimental_DeploymentStrategy,
		deepCopy_experimental_HorizontalPodAutoscaler,
		deepCopy_experimental_HorizontalPodAutoscalerList,
		deepCopy_experimental_HorizontalPodAutoscalerSpec,
		deepCopy_experimental_HorizontalPodAutoscalerStatus,
		deepCopy_experimental_Job,
		deepCopy_experimental_JobCondition,
		deepCopy_experimental_JobList,
		deepCopy_experimental_JobSpec,
		deepCopy_experimental_JobStatus,
		deepCopy_experimental_ReplicationControllerDummy,
		deepCopy_experimental_ResourceConsumption,
		deepCopy_experimental_RollingUpdateDeployment,
		deepCopy_experimental_Scale,
		deepCopy_experimental_ScaleSpec,
		deepCopy_experimental_ScaleStatus,
		deepCopy_experimental_SubresourceReference,
		deepCopy_experimental_ThirdPartyResource,
		deepCopy_experimental_ThirdPartyResourceData,
		deepCopy_experimental_ThirdPartyResourceDataList,
		deepCopy_experimental_ThirdPartyResourceList,
		deepCopy_util_IntOrString,
		deepCopy_util_Time,
	)
	if err != nil {
		// if one of the deep copy functions is malformed, detect it immediately.
		panic(err)
	}
}


text:
![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png) 0

To use the Know India skill, try saying...

* *Alexa launch simply india*

This skill will tell you amazing things about India. Few unbelievable facts.

Message for the users: All the amazing things that the skill says are true. If you think they need few word changes will be happy to know about it.

***

### Skill Details

* **Invocation Name:** simply india
* **Category:** null
* **ID:** amzn1.ask.skill.512b80ff-05da-4938-b73d-736c1d2d66fe
* **ASIN:** B01LHWNV8W
* **Author:** Charlie
* **Release Date:** September 11, 2016 @ 02:43:41
* **In-App Purchasing:** No


text:
package com.sun.voip;

import java.io.IOException;

/**
 * Sample rate converter, convert from one sample rate to another.
 */
public class SampleRateConverter {
    private Resampler resampler;

    public SampleRateConverter(String id, int inSampleRate, int inChannels,
	    int outSampleRate, int outChannels) throws IOException {

	if (inSampleRate < outSampleRate) {
	    resampler = new Upsampler(id, inSampleRate, inChannels,
		outSampleRate, outChannels);
	} else {
	    resampler = new Downsampler(id, inSampleRate, inChannels,
		outSampleRate, outChannels);
	}

	if (Logger.logLevel >= Logger.LOG_MOREINFO) {
	    Logger.println("New Sample Rate Converter:  from "
	        + inSampleRate + "/" + inChannels + " to "
	        + outSampleRate + "/" + outChannels);
	}
    }

    public void reset() {
	resampler.reset();
    }

    public byte[] resample(byte[] inSamples, int offset, int length)
	    throws IOException {

	return resampler.resample(inSamples, offset, length);
    }

    public int[] resample(int[] inSamples) throws IOException {
	return resampler.resample(inSamples);
    }

    public void printStatistics() {
	resampler.printStatistics();
    }

}


text:
<?xml version="1.0" encoding="utf-8"?>
<android.support.design.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <WebView
        android:id="@+id/web_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_below="@+id/web_view_progress_bar" />

    <ProgressBar
        android:id="@+id/web_view_progress_bar"
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:indeterminate="false"
        android:visibility="gone" />

</android.support.design.widget.CoordinatorLayout>


text:
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Ann. Bot. Mem. 1: 441 (1950)

#### Original name
Lachnocladium micheneri Berk. & M.A. Curtis, 1873

### Remarks
null


text:
function out = superpixels(image, maxdist)
ratio = 0.5;
kernelsize = 2;
%maxdist = 10;
out = vl_quickseg(image, ratio, kernelsize, maxdist);


text:
@implementation UIFont (Aladin)

+ (instancetype)aladinRegularFontOfSize:(CGFloat)size {
  static dispatch_once_t onceToken;
  [GFIFontLoader loadFontFile:@"Aladin-Regular"
                   fromBundle:@"Aladin"
                    onceToken:&onceToken];
  return [self fontWithName:@"Aladin-Regular" size:size];
}

@end


text:
require 'test_helper'

module SwaggerUiEngine
  class SwaggerDocsControllerTest < ActionDispatch::IntegrationTest
    include Engine.routes.url_helpers

    setup do
      @routes = Engine.routes
    end

    test 'index action should redirect when single doc version' do
      get '/swagger'
      assert_response :redirect
    end

    test 'index action should not display back link when single doc version' do
      get '/swagger'
      refute_match('Back to API versions', @response.body)
    end

    test 'oauth2 redirect url should be set' do
      get '/swagger/swagger_docs/v1'
      assert_response :success
      assert_match('oauth2RedirectUrl: "http://www.example.com/swagger/swagger_docs/oauth2"', @response.body)
    end

    test 'custom config options should work successfully' do
      get '/swagger/swagger_docs/v1'
      assert_response :success
      assert_match('url = "api_docs/v1/swagger.yaml"', @response.body)
      assert_match('docExpansion: "list"', @response.body)
      assert_match('defaultModelRendering: "model"', @response.body)
      assert_match('appName: "Oauth2 Test App Name"', @response.body)
      assert_match('realm: "Oauth2 Test Realm"', @response.body)
    end

    test 'default config options should work successfully' do
      get '/swagger/swagger_docs/v1'
      assert_response :success
      assert_match('showRequestHeaders: "false"', @response.body)
      assert_match('jsonEditor: "false"', @response.body)
      assert_match('validatorUrl: "null"', @response.body)
      assert_match('clientId: "your-client-id"', @response.body)
      assert_match('clientSecret: "your-client-secret-if-required"', @response.body)
      assert_match('scopeSeparator: " "', @response.body)
      assert_match('additionalQueryStringParams: "{}"', @response.body)
    end
  end
end


text:
require 'cogwheels'

module Dockmaster
  # Loads the configuration file and holds utility methods for dealing with the resulting object
  class Configuration
    DOTFILE = '.dockmaster.yml'.freeze
    class << self
      def load_file
        dockmaster_yml = File.join(Dir.pwd, DOTFILE)

        Cogwheels.load(dockmaster_yml).to_symbol_keys if File.exist?(dockmaster_yml)
      end

      def excluded?(file)
        Dockmaster::CONFIG[:exclude].each do |ex|
          return true if file.start_with?(File.join(Dir.pwd, ex))
        end

        false
      end
    end
  end
end


text:
<?php

/**
 * BaseaReusableSlideshowSlot
 *
 * This class has been auto-generated by the Doctrine ORM Framework
 *
 *
 * @package    asandbox
 * @subpackage model
 * @author     Your name here
 * @version    SVN: $Id: Builder.php 7490 2010-03-29 19:53:27Z jwage $
 */
abstract class BaseaReusableSlideshowSlot extends aSlot
{
    public function setUp()
    {
        parent::setUp();

    }
}


text:
/*
 * 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 org.skife.jdbi.v2.sqlobject.stringtemplate;

import org.skife.jdbi.v2.Binding;
import org.skife.jdbi.v2.Cleanable;
import org.skife.jdbi.v2.Foreman;
import org.skife.jdbi.v2.StatementContext;
import org.skife.jdbi.v2.tweak.ResultColumnMapper;

import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.HashMap;
import java.util.Map;

public class TestingStatementContext implements StatementContext
{
    private final Map<String, Object> attributes;

    public TestingStatementContext(final Map<String, Object> globalAttributes)
    {
        attributes = new HashMap<String, Object>(globalAttributes);
    }

    @Override
    public Object setAttribute(final String key, final Object value)
    {
        return attributes.put(key, value);
    }

    @Override
    public Object getAttribute(final String key)
    {
        return attributes.get(key);
    }

    @Override
    public Map<String, Object> getAttributes()
    {
        return attributes;
    }

    @Override
    public ResultColumnMapper columnMapperFor(Class type) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String getRawSql()
    {
        throw new UnsupportedOperationException();
    }

    @Override
    public String getRewrittenSql()
    {
        throw new UnsupportedOperationException();
    }

    @Override
    public String getLocatedSql()
    {
        throw new UnsupportedOperationException();
    }

    @Override
    public PreparedStatement getStatement()
    {
        throw new UnsupportedOperationException();
    }

    @Override
    public Connection getConnection()
    {
        throw new UnsupportedOperationException();
    }

    @Override
    public Binding getBinding()
    {
        throw new UnsupportedOperationException();
    }

    @Override
    public Class<?> getSqlObjectType()
    {
        throw new UnsupportedOperationException();
    }

    @Override
    public Method getSqlObjectMethod()
    {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean isReturningGeneratedKeys()
    {
        throw new UnsupportedOperationException();
    }

    @Override
    public String[] getGeneratedKeysColumnNames() {
        return new String[0];
    }

    @Override
    public void addCleanable(final Cleanable cleanable)
    {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean isConcurrentUpdatable() {
        throw new UnsupportedOperationException();
    }

    @Override
    public Foreman getForeman() {
        throw new UnsupportedOperationException("Not Yet Implemented!");
    }

}


text:
// Copyright (c) 2012 Ecma International.  All rights reserved.
// Ecma International makes this code available under the terms and conditions set
// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the
// "Use Terms").   Any redistribution of this code must retain the above
// copyright and this notice and otherwise comply with the Use Terms.

/*---
es5id: 15.2.3.7-6-a-227
description: >
    Object.defineProperties - 'O' is an Array, 'P' is an array index
    property, TypeError is thrown if the [[Configurable]] attribute
    value of 'P' is false  and the [[Configurable]] field of 'desc' is
    true  (15.4.5.1 step 4.c)
includes: [propertyHelper.js]
---*/

var arr = [];

Object.defineProperty(arr, "1", {
    value: 3,
    configurable: false
});

try {
    Object.defineProperties(arr, {
        "1": {
            value: 13,
            configurable: true
        }
    });
} catch (e) {
    verifyEqualTo(arr, "1", 3);

    verifyNotWritable(arr, "1");

    verifyNotEnumerable(arr, "1");

    verifyNotConfigurable(arr, "1");

    if (!(e instanceof TypeError)) {
        $ERROR("Expected TypeError, got " + e);
    }

}


text:
#ifndef TIGHTDB_COLUMN_STRING_ENUM_HPP
#define TIGHTDB_COLUMN_STRING_ENUM_HPP

#include <tightdb/column_string.hpp>

namespace tightdb {

// Pre-declarations
class StringIndex;

/// From the point of view of the application, an enumerated strings column
/// (ColumnStringEnum) is like a string column (AdaptiveStringColumn), yet it
/// manages its stings in such a way that each unique string is stored only
/// once. In fact, an enumerated strings column is a combination of two
/// subcolumns; a regular string column (AdaptiveStringColumn) that stores the
/// unique strings, and an integer column that stores one unique string index
/// for each entry in the enumerated strings column.
///
/// In terms of the underlying node structure, the subcolumn containing the
/// unique strings is not a true part of the enumerated strings column. Instead
/// it is a part of the spec structure that describes the table of which the
/// enumerated strings column is a part. This way, the unique strings can be
/// shared across enumerated strings columns of multiple subtables. This also
/// means that the root of an enumerated strings column coincides with the root
/// of the integer subcolumn, and in some sense, an enumerated strings column is
/// just the integer subcolumn.
///
/// An enumerated strings column can optionally be equipped with a
/// search index. If it is, then the root ref of the index is stored
/// in Table::m_columns immediately after the root ref of the
/// enumerated strings column.
class ColumnStringEnum: public Column {
public:
    typedef StringData value_type;

    ColumnStringEnum(Allocator&, ref_type ref, ref_type keys_ref);
    ~ColumnStringEnum() TIGHTDB_NOEXCEPT TIGHTDB_OVERRIDE;
    void destroy() TIGHTDB_NOEXCEPT TIGHTDB_OVERRIDE;

    int compare_values(size_t row1, size_t row2) const TIGHTDB_OVERRIDE
    {
        StringData a = get(row1);
        StringData b = get(row2);
        if (a == b)
            return 0;
        return utf8_compare(a, b) ? 1 : -1;
    }

    StringData get(std::size_t ndx) const TIGHTDB_NOEXCEPT;
    void set(std::size_t ndx, StringData value);
    void add(StringData value = StringData());
    void insert(std::size_t ndx, StringData value = StringData());
    void erase(std::size_t row_ndx);
    void move_last_over(std::size_t row_ndx);
    void clear();

    std::size_t count(StringData value) const;
    std::size_t find_first(StringData value, std::size_t begin = 0, std::size_t end = npos) const;
    void find_all(Column& res, StringData value,
                  std::size_t begin = 0, std::size_t end = npos) const;
    FindRes find_all_indexref(StringData value, std::size_t& dst) const;

    std::size_t count(std::size_t key_index) const;
    std::size_t find_first(std::size_t key_index, std::size_t begin=0, std::size_t end=-1) const;
    void find_all(Column& res, std::size_t key_index, std::size_t begin = 0, std::size_t end = -1) const;

    //@{
    /// Find the lower/upper bound for the specified value assuming
    /// that the elements are already sorted in ascending order
    /// according to StringData::operator<().
    std::size_t lower_bound_string(StringData value) const TIGHTDB_NOEXCEPT;
    std::size_t upper_bound_string(StringData value) const TIGHTDB_NOEXCEPT;
    //@}

    void set_string(std::size_t, StringData) TIGHTDB_OVERRIDE;

    void adjust_keys_ndx_in_parent(int diff) TIGHTDB_NOEXCEPT;

    // Search index
    bool has_search_index() const TIGHTDB_NOEXCEPT TIGHTDB_OVERRIDE;
    void set_search_index_ref(ref_type, ArrayParent*, std::size_t, bool) TIGHTDB_OVERRIDE;
    void set_search_index_allow_duplicate_values(bool) TIGHTDB_NOEXCEPT TIGHTDB_OVERRIDE;
    StringIndex& get_search_index() TIGHTDB_NOEXCEPT;
    const StringIndex& get_search_index() const TIGHTDB_NOEXCEPT;
    StringIndex& create_search_index();
    void install_search_index(StringIndex*) TIGHTDB_NOEXCEPT;

    // Compare two string columns for equality
    bool compare_string(const AdaptiveStringColumn&) const;
    bool compare_string(const ColumnStringEnum&) const;

    void insert(std::size_t, std::size_t, bool) TIGHTDB_OVERRIDE;
    void erase(std::size_t, bool) TIGHTDB_OVERRIDE;
    void move_last_over(std::size_t, std::size_t, bool) TIGHTDB_OVERRIDE;
    void clear(std::size_t, bool) TIGHTDB_OVERRIDE;
    void update_from_parent(std::size_t) TIGHTDB_NOEXCEPT TIGHTDB_OVERRIDE;
    void refresh_accessor_tree(std::size_t, const Spec&) TIGHTDB_OVERRIDE;

    std::size_t GetKeyNdx(StringData value) const;
    std::size_t GetKeyNdxOrAdd(StringData value);

    AdaptiveStringColumn& get_keys();
    const AdaptiveStringColumn& get_keys() const;

#ifdef TIGHTDB_DEBUG
    void Verify() const TIGHTDB_OVERRIDE;
    void Verify(const Table&, std::size_t) const TIGHTDB_OVERRIDE;
    void do_dump_node_structure(std::ostream&, int) const TIGHTDB_OVERRIDE;
    void to_dot(std::ostream&, StringData title) const TIGHTDB_OVERRIDE;
#endif

private:
    // Member variables
    AdaptiveStringColumn m_keys;
    StringIndex* m_search_index;

    /// If you are appending and have the size of the column readily available,
    /// call the 4 argument version instead. If you are not appending, either
    /// one is fine.
    ///
    /// \param row_ndx Must be `tightdb::npos` if appending.
    void do_insert(std::size_t row_ndx, StringData value, std::size_t num_rows);

    /// If you are appending and you do not have the size of the column readily
    /// available, call the 3 argument version instead. If you are not
    /// appending, either one is fine.
    ///
    /// \param is_append Must be true if, and only if `row_ndx` is equal to the
    /// size of the column (before insertion).
    void do_insert(std::size_t row_ndx, StringData value, std::size_t num_rows, bool is_append);

    void do_erase(std::size_t row_ndx, bool is_last);
    void do_move_last_over(std::size_t row_ndx, std::size_t last_row_ndx);
    void do_clear();
};

// Implementation:

inline StringData ColumnStringEnum::get(std::size_t ndx) const TIGHTDB_NOEXCEPT
{
    TIGHTDB_ASSERT(ndx < Column::size());
    std::size_t key_ndx = to_size_t(Column::get(ndx));
    return m_keys.get(key_ndx);
}

inline void ColumnStringEnum::add(StringData value)
{
    std::size_t row_ndx = tightdb::npos;
    std::size_t num_rows = 1;
    do_insert(row_ndx, value, num_rows); // Throws
}

inline void ColumnStringEnum::insert(std::size_t row_ndx, StringData value)
{
    std::size_t size = this->size();
    TIGHTDB_ASSERT(row_ndx <= size);
    std::size_t num_rows = 1;
    bool is_append = row_ndx == size;
    do_insert(row_ndx, value, num_rows, is_append); // Throws
}

inline void ColumnStringEnum::erase(std::size_t row_ndx)
{
    std::size_t last_row_ndx = size() - 1; // Note that size() is slow
    bool is_last = row_ndx == last_row_ndx;
    do_erase(row_ndx, is_last); // Throws
}

inline void ColumnStringEnum::move_last_over(std::size_t row_ndx)
{
    std::size_t last_row_ndx = size() - 1; // Note that size() is slow
    do_move_last_over(row_ndx, last_row_ndx); // Throws
}

inline void ColumnStringEnum::clear()
{
    do_clear(); // Throws
}

// Overriding virtual method of Column.
inline void ColumnStringEnum::insert(std::size_t row_ndx, std::size_t num_rows, bool is_append)
{
    StringData value = StringData();
    do_insert(row_ndx, value, num_rows, is_append); // Throws
}

// Overriding virtual method of Column.
inline void ColumnStringEnum::erase(std::size_t row_ndx, bool is_last)
{
    do_erase(row_ndx, is_last); // Throws
}

// Overriding virtual method of Column.
inline void ColumnStringEnum::move_last_over(std::size_t row_ndx, std::size_t last_row_ndx, bool)
{
    do_move_last_over(row_ndx, last_row_ndx); // Throws
}

// Overriding virtual method of Column.
inline void ColumnStringEnum::clear(std::size_t, bool)
{
    do_clear(); // Throws
}

inline std::size_t ColumnStringEnum::lower_bound_string(StringData value) const TIGHTDB_NOEXCEPT
{
    return ColumnBase::lower_bound(*this, value);
}

inline std::size_t ColumnStringEnum::upper_bound_string(StringData value) const TIGHTDB_NOEXCEPT
{
    return ColumnBase::upper_bound(*this, value);
}

inline void ColumnStringEnum::set_string(std::size_t row_ndx, StringData value)
{
    set(row_ndx, value); // Throws
}

inline bool ColumnStringEnum::has_search_index() const TIGHTDB_NOEXCEPT
{
    return m_search_index != 0;
}

inline StringIndex& ColumnStringEnum::get_search_index() TIGHTDB_NOEXCEPT
{
    return *m_search_index;
}

inline const StringIndex& ColumnStringEnum::get_search_index() const TIGHTDB_NOEXCEPT
{
    return *m_search_index;
}

inline AdaptiveStringColumn& ColumnStringEnum::get_keys()
{
    return m_keys;
}

inline const AdaptiveStringColumn& ColumnStringEnum::get_keys() const
{
    return m_keys;
}

} // namespace tightdb

#endif // TIGHTDB_COLUMN_STRING_ENUM_HPP


text:
<!--
   This file is part of the X12Parser library that provides tools to
   manipulate X12 messages using Ruby native syntax.

   http://x12parser.rubyforge.org

   Copyright (C) 2009 APP Design, Inc.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

   $Id: F07.xml 78 2009-05-12 22:27:26Z ikk $
-->

<Segment name="F07" comment="To itemize extent of automotive loss or damage">
  <Field name="AssignedNumber" type="long" min="1" max="6" comment="Number assigned for differentiation within a transaction set"/>
  <Field name="Quantity" type="double" required="y" min="1" max="15" comment="Numeric value of quantity"/>
  <Field name="ProductServiceId" required="y" min="1" max="48" comment="Identifying number for a product or service"/>
  <Field name="PartName" required="y" min="3" max="16" comment="Name of the part(s) replaced"/>
  <Field name="Amount" type="double" required="y" min="1" max="15" comment="Monetary amount"/>
  <Field name="DamageAreaCode1" min="2" max="2" comment="Code representing the location on the vehicle where the damage was repaired"/>
  <Field name="DamageTypeCode1" min="2" max="2" comment="Code indicating the type of damage"/>
  <Field name="DamageSeverityCode1" min="1" max="1" comment="Code indicating the severity of the damage"/>
  <Field name="LaborOperationIdentifier" required="y" min="5" max="6" comment="Identifier representing the labor operation performed in repairing damage"/>
  <Field name="FreeFormDescription" required="y" min="1" max="45" comment="Free-form descriptive text"/>
  <Field name="LaborHours1" type="double" required="y" min="1" max="3" comment="Labor hours"/>
  <Field name="LaborHours2" type="double" required="y" min="1" max="3" comment="Labor hours"/>
  <Field name="TotalLaborCost" type="double" required="y" min="3" max="6" comment="Labor cost utilized in repair of the damage. Equal to the sum of the two labor hour data elements multiplied by the appropriate labor rate"/>
  <Field name="TotalMiscellaneousCosts" type="double" required="y" min="2" max="15" comment="Sum of costs for all miscellaneous items not covered by labor and parts costs"/>
  <Field name="TotalRepairCost" type="double" min="3" max="15" comment="Total cost of repair for the line item of damage, equal to the sum of part cost, total labor and total miscellaneous cost"/>
  <Field name="AuthorizationIdentification" required="y" min="1" max="4" comment="Identifier representing authorization of an unusual repair or some attendant condition"/>
  <Field name="InspectionLocationTypeCode" required="y" min="1" max="2" validation="T831" comment="Code to define the location where a type of inspection is performed"/>
  <Field name="DamageAreaCode2" required="y" min="2" max="2" comment="Code representing the location on the vehicle where the damage was repaired"/>
  <Field name="DamageTypeCode2" required="y" min="2" max="2" comment="Code indicating the type of damage"/>
  <Field name="DamageSeverityCode2" required="y" min="1" max="1" comment="Code indicating the severity of the damage"/>
  <Field name="DeclineAmendReasonCode" required="y" min="3" max="3" validation="T548" comment="Code indicating the reason for declination or amendment"/>
  <Field name="ChargeAllowanceQualifier" required="y" min="2" max="2" validation="T538" comment="Code indicating reason for charge or allowance"/>
</Segment>


text:
Please login

		<?=$this->layout->getMessages();?>

		<form method="post" name="login_form" id="login_form" action="<?=SITEPATH.$this->request_path?>">

				Username:

<input class="required" type="text" name="secure_username" />

				Password:

<input class="required" type="password" name="secure_password" />

				<input type="submit" name="LOGIN" value="LOGIN" />

		</form>


text:
export declare class BaseException extends Error {
    constructor(message?: string);
}
export declare class FileDoesNotExistException extends BaseException {
    constructor(path: string);
}
export declare class FileAlreadyExistException extends BaseException {
    constructor(path: string);
}
export declare class ContentHasMutatedException extends BaseException {
    constructor(path: string);
}
export declare class InvalidUpdateRecordException extends BaseException {
    constructor();
}
export declare class MergeConflictException extends BaseException {
    constructor(path: string);
}
export declare class UnimplementedException extends BaseException {
    constructor();
}


text:
function y = col_combo (A,k)

% column combinations
% y is a cell array of matrices, formed by taking all possible combinations
% of the columns of A, k at a time.

[M,N] = size(A);
combs = combnk(1:N,k); % all column combinations, taken k at a time
AA = A(:,combs.'); % arrange col combinations horizontally
y = mat2cell(AA,M,k*ones(1,size(combs,1))); % partition into cell array


text:
using System.Windows.Controls;

namespace Homophone.OutsideControl.Views
{
    /// <summary>
    /// Interaction logic for InfoBoxView.xaml
    /// </summary>
    public partial class InfoBoxView : UserControl
    {
        public InfoBoxView()
        {
            InitializeComponent();
        }
    }
}


text:
<!doctype html>

    <title>Lithuanian</title>

VISUOTINĖ ŽMOGAUS TEISIŲ DEKLARACIJA

PREAMBULĖ

Atsižvelgdama į tai, kad visiems žmonių giminės nariams būdingo orumo ir lygių bei neatimamų teisių pripažinimas yra laisvės, teisingumo ir taikos pasaulyje pagrindas;

atsižvelgdama į tai, kad žmogaus teisių visiškas nepaisymas ir niekinimas pastūmėjo vykdyti barbariškus aktus, piktinančius žmonijos sąžinę, o sukūrimas pasaulio, kuriame žmonės turės žodžio ir įsitikinimų laisvę ir bus išlaisvinti iš baimės ir skurdo pančių, paskelbtas kaip kilniausias žmogaus siekimas;

atsižvelgdama į tai, jog būtinai reikia, kad žmogaus teises saugotų įstatymo galia, dėl to, kad jis nebūtų priverstas imtis, kaip kraštutinės priemonės, sukilimo prieš tironiją ir priespaudą;

atsižvelgdama į tai, jog būtinai reikia remti draugiškų santykių tarp tautų vystymą;

atsižvelgdama į tai, kad Suvienytųjų Nacijų Organizacijos įstatuose tautos vėl įtvirtino savo tikėjimą pagrindinėmis žmogaus teisėmis, žmogaus, kaip asmenybės, orumu ir vertingumu, lygiomis vyrų ir moterų teisėmis ir pareiškė, jog esančios pasiryžusios skatinti visuomenės pažangą ir sukurti geresnes gyvenimo sąlygas, didesnę laisvę;

atsižvelgdama į tai, kad valstybės narės, bendradarbiaudamos su Suvienytųjų Nacijų Organizacija, įsipareigojo garantuoti visuotinį ir tikrą žmogaus teisių ir pagrindinių laisvių laikymąsi;

atsižvelgdama į tai, jog bendras visiems žmonėms šių teisių ir laisvių supratimas turi didžiausią reikm, kad būtų visiškai įvykdytas šis įsipareigojimas,

Generalinė Asamblėja

skelbia šią Visuotinę žmogaus teisių deklaraciją, kaip visuotinį idealą, kurio turi siekti visos tautos ir visos valstybės dėl to, kad kiekvienas žmogus ir kiekvienas visuomenės organas, nuolat turėdami galvoj šią Deklaraciją, pasitelkę švietimą ir mokslą, stengtųsi prisidėti prie to, kad šios teisės ir laisvės būtų gerbiamos ir kad būtų garantuota, imantis nacionalinių ir tarptautinių pažangių priemonių, kad jos bus visuotinai ir tikrai pripažįstamos ir taikomos tiek valstybių narių gyventojams, tiek gyventojams teritorijų, esančių jų jurisdikcijoje.

1 straipsnis

Visi žmonės gimsta laisvi ir lygūs savo orumu ir teisėmis. Jiems suteiktas protas ir sąžinė ir jie turi elgtis vienas kito atžvilgiu kaip broliai.

2 straipsnis

Kiekvienas žmogus gali naudotis visomis teisėmis ir laisvėmis, paskelbtomis šioje Deklaracijoje, be jokių skirtumų, tokių kaip rasė, odos spalva, lytis, kalba, religija, politiniai ar kitokie įsitikinimai, nacionalinė ar socialinė kilmė, turtinė, jo gimimo ar kokia nors kitokia padėtis.

Be to, neturi būti daroma jokių skirtumų remiantis šalies ar teritorijos, kuriai priklauso žmogus, politiniu, teisiniu ar tarptautiniu statusu, dėl to, kad ši šalis ar teritorija yra nepriklausoma, globojama, nesavavaldi ar kaip nors kitaip apribotas jos suverenitetas.

3 straipsnis

Kiekvienas žmogus turi teisę į gyvybę, laisvę ir asmens neliečiamybę.

4 straipsnis

Niekas negali būti laikomas vergijoje ar nelaisvas: visų formų vergija ir prekyba vergais draudžiama.

5 straipsnis

Niekas negali būti kankinamas arba žiauriai, nežmoniškai žeminant jo orumą su juo elgiamasi ir jis baudžiamas.

6 straipsnis

Kiekvienas žmogus, kad ir kur jis būtų turi teisę būti pripažintas teisinių santykių subjektu.

7 straipsnis

Visi lygūs prieš įstatymą ir turi teisę, be jokio skirtumo, į lygią įstatymo apsaugą. Visi turi teisę į lygią apsaugą nuo visokios diskriminacijos, pažeidžiančios šią Deklaraciją ir nuo visokio kurstymo tokiai diskriminacijai.

8 straipsnis

Kiekvienas žmogus turi teisė pasinaudoti kompetentingais nacionaliniais teismais savo teisėms atgauti, kai jo pagrindinės teisės, pripažįstamos jam konstitucijos ar įstatymo, buvo pažeistos.

9 straipsnis

Niekas negali būti savavališkai areštuotas, suimtas ar ištremtas.

10 straipsnis

Kiekvienas žmogus, remdamasis visika lygybe, turi teisę į tai, kad jo bylą viešai ir teisingai išnagrinėtų nepriklausomas ir bešališkas teismas, kuris nustatytų jo teises ir pareigas ar jam pareikšto baudžiamojo kaltinimo pagrįstuma.

11 straipsnis

Kiekvienas žmogus, kaltinamas nusikaltimo padarymu, laikomas nekaltu tol, kol jo kaltumas bus nustatytas įstatymo tvarka viešo teisminio nagrinėjimo metu, kur jam bus sudaromos visos būtinos gynybos garantijos.

Niekas negali būti nuteistas už veiksmus ar neveikimą, kurie jų įvykdymo metu nebuvo laikomi nusikaltimais pagal valstybės vidaus įstatymus arba tarptautinę teisę. Taip pat negali būti skiriama sunkesnė bausmė už tą, kuri buvo taikoma nusikaltimo padarymo momentu.

12 straipsnis

Niekas neturi patirti savavališko kišimosi į jo asmeninį ir šeimyninį gyvenimą, jo buto neliečiamybę, susirašinėjimo slaptumą, kėsinimosi į jo garbę ir orumą. Kiekvienas žmogus turi teisę į įstatymo apsaugą nuo tokio kišimosi arba tokių pasikėsinimų.

13 straipsnis

Kiekvienas žmogus turi teisę laisvai kilnotis ir laisvai pasirinkti gyvenamąją vietą kiekvienoje valstybėje.

Kiekvienas žmogus turi teisę išvažiuoti iš kiekvienos šalies, įskaitant savąją, ir grįžti į savo šalį.

14 straipsnis

Persekiojamas kiekvienas žmogus turi teisę ieškoti prieglobsčio kitose šalyse ir juo naudotis.

Šia teise negali būti pasinaudota, kai persekiojimas tikrai pagrįstas padarymu kriminalinio nusikaltimo ar veiksmų, prieštaraujančių Suvienytųjų Nacijų Organizacijos tikslams ir principams.

15 straipsnis

Kiekvienas žmogus turi teisę į pilietybę.

Niekam negali būti savavališkai atimta jo pilietybė ar teisė ją pakeisti.

16 straipsnis

Vyrai ir moterys, pasiekę brandos amžių, turi teisę be jokių apribojimų dėl rasės, tautybės ar religijos sudaryti santuoką ir sukurti šeimą. Jie turi lygias teises tiek santuokos sudarymo bei jos trukmės, tiek santuokos nutraukimo metu.

Santuoka gali būti sudaryta tik tasa, kai susituokiantieji duoda laisva ir visišką sutikimą.

eima yra natūrali ir pagrindinė visuomenės ląstelė ir ji turi teisę į visuomenės ir valstybės apsaugą.

17 straipsnis

Kiekvienas žmogus turi teisę turėti nuosavybę tiek vienas, tiek kartu su kitais.

Iš nieko negali būti savavališkai atimta jo nuosavybė.

18 straipsnis

Kiekvienas žmogus turi teisę į minties, sąžinės ir religijos laisvę. Ši teisė apima laisvę pakeisti religiją ar tikėjimą, taip pat laisvę skelbti savo religiją ar tikėjimą tiek vienam, tiek kartu su kitais, viešai ar privačiai, mokant, praktikuojant tikėjimą, laikant pamaldas bei atliekant apeigas.

19 straipsnis

Kiekvienas žmogus turi teisę į įsitikinimų ir jų reiškimo laisvę, kuri apima teisę nekliudomai laikytis savo įsitikinimų ir teisę ieškoti, gauti ir skleisti informaciją ir idėjas nepriklausomai nuo valstybių sienų, ir nesvarbu, kokiomis priemonėmis jos būtų išreikštos.

20 straipsnis

Kiekvienas žmogus turi teisę į taikių susirinkimų ir asociacijų laisvę.

Niekas negali būti verčiamas priklausyti kokiai nors asociacijai.

21 straipsnis

Kiekvienas žmogus turi teisę dalyvauti valdant savo šalį tiek tiesiogiai, tiek per laisvai išrinktus atstovus.

Kiekvienas žmogus turi teisę lygybęs sąlygomis stoti į savo šalies valstybinę tarnybą.

Liaudies valia yra valstybinės valdžios pagrindas; ši valis turi būti išreiškiama teisinguose rinkimouse, kurie turi vykti periodiškai, kai yra visuotinė ir lygi rinkimų teisę ir slaptas balsavimas arba kitos lygiavertės procedūros, garantuojančios balsavimo laisvę.

22 straipsnis

Kiekvienas žmogus, kaip visuomenės narys, turi teisę į socialinį aprūpinimą, kuris skirtas būtinoms jo orumui ir laisvam asmenybės vystymuisi ekonominėms, socialinėms ir kultūrinėms teisėms igyvendinti nacionalinemis pastangomis ir per tarptautinį bendradarbiavimą ir pagal kiekvienos šalies vidinę struktūrą bei išteklius.

23 straipsnis

Kiekvienas žmogus turi teisę į darbą, į laisvą darbo pasirinkimą, į teisingas ir tinkamas darbo sąlygas ir į apsaugą nuo nedarbo.

Visi žmonės, be jokios diskriminacijos, turi teisę į lygų apmokėjimą už lygiavertį darbą.

Kiekvienas darbo žmogus turi teisę į teisingą ir patenkinamą atlyginimą, garantuojantį žmogaus orumo vertą egzistavimą jam pačiam ir jo šeimai, ir papildomą, kai reikia, visomis kitomis socialinės apsaugos lėšomis.

Kiekvienas žmogus turi teisę kartu su kitais steigti profesines sąjungas ar stoti į jas savo interesams ginti.

24 straipsnis

Kiekvienas žmogus turi teisę į poilsį ir laisvalaikį ir ypač teisę į pagrįstą darbo laiko apribojimą ir periodines apmokamas atostogas.

25 straipsnis

Kiekvienas žmogus turi teisę į pakankamą gyvenimo lygį, kuris garantuotų jo ir jo šeimos sveikatą ir gerovę, ir ypač į maistą, drabužius, būstą, medicininę priežiūrą ir būtiną socialinį aptarnavimą: jis turi teisę į aprūpinimą nedarbo, ligos, invalidumo, našlystės, senatvės ar kitokio pragyvenimo šaltinių netekimo atveju dėl nepriklausančių nuo jo aplinkybių.

Motinystė ir kūdikystė turi būti itin globojamos ir remiamos. Visi vaikai, tiek gimę santuokoje, tiek nesantuokiniai, naudojasi vienoda socialine apsauga.

26 straipsnis

Kiekvienas žmogus turi teisę į mokslą. Mokslas turi būti nemokamas - bent jau pradinis ir bendrasis lavinimas. Pradinis lavinimas yra privalomas. Profesinis techninis mokymas turi būti visuotinai prieinamas; aukštasis mokslas turi būti vienodai prieinamas visiems pagal kiekvieno žmogus sugebėjimus.

Mokslas turi būti skirtas tam, kad visi škai suklestėtų žmogaus asmenybė ir kad būtų vis labiau gerbiamos žmogaus teisės ir pagrindinės laisvės. Jis turi padėti ugdyti savitarpio supratimą, pakantumą ir draugystę tarp visų tautų, rasinių, ir religinių grupių, taip pat turi skatinti Suvienytųjų Nacijų Organizacijos vykdomą taikos išsaugojimo veiklą.

Tėvai turi pirmenybės teisę parenkant savo vaikų mokymą.

27 straipsnis

Kiekvienas žmogus turi teisę laisvai dalyvauti visuomenės kultūriniame gyvenime, gėrėtis menu, dalyvauti mokslinėje pažangoje ir naudotis jos gėrybėmis.

Kiekvienas žmogus turi teisę į apsaugą jo dvasinių ir materialinių interesų, atsirandančių ryšium su mokslo, literatūros ar meno kūrinių, kurių jis yra autorius, sukūrimu.

28 straipsnis

Kiekvienas žmogus turi teisę į tai, kad visuomenėje ir tarp tautų įsiviešpatautų tokia tvarka, kurioje galėtų būti visiškai įgyvendintos teisės ir laisvės, išdėstytos šioje Deklaracijoje.

29 straipsnis

Kiekvienas žmogus turi pareigas visuomenei, kurioje tik ir gali laisvai ir visiškai vystytis jo asmenybė.

Įgyvendindamas savo teises ir naudodamasis savo laisvėmis, kiekvienas žmogus negali patirti kitokių apribojimų kaip įstatymo numatyti vien tik tam, kad garantuotų kitų žmonių teisių ir laisvių deramą pripažinimą ir gerbimą siekiant patenkinti teisingus moralės, viešosios tvarkos ir visuotinės gerovės reikalavimus demokratinėje visuomenėje.

Šios teisės ir laisvės jokiu būdu negali būti įgyvendinamos, jeigu tai prieštarauja Suvienytųjų Nacijų Organizacijos tikslams ir principams.

30 straipsnis

Jokia šios Deklaracijos nuostata negali būti aiškinama kaip suteikianti kuriai nors valstybei, grupei ar asmeniui teisę vykdyti kokią nors veiklą ar atlikti veiksmus, skirtus joje išdėstytoms teisėms ir laisvėms panaikinti.


text:
<?php

namespace WellCommerce\Bundle\ShipmentBundle\Processor;

use WellCommerce\Bundle\ShipmentBundle\Adapter\ShipmentAdapterInterface;
use WellCommerce\Component\Collections\ArrayCollection;

/**
 * Class ShipmentAdapterCollection
 *
 * @author  Adam Piotrowski <adam@wellcommerce.org>
 */
class ShipmentAdapterCollection extends ArrayCollection
{
    public function add(ShipmentAdapterInterface $adapter)
    {
        $this->items[$adapter->getAlias()] = $adapter;
    }

    public function get($key): ShipmentAdapterInterface
    {
        return $this->items[$key];
    }
}


text:
import React, { Component } from 'react';
import { connect } from 'react-redux';

class App extends Component {

  static willTransitionTo() {
    console.log('willTransitionTo in App component');
  }

  render() {
    let { fname, lname } = this.props;

    return (

Hello {fname} {lname}!

    );
  }

}

function select(state) {
  return state;
}

export default connect(select)(App)


text:
<!--
Copyright (c) 2016, the Flutter project authors.  Please see the AUTHORS file
for details. All rights reserved. Use of this source code is governed by a
BSD-style license that can be found in the LICENSE file.
-->

Flutter: A Walk Up A Mahogony Staircase
=======================================

Prologue
--------

This talk is intended to explain Flutter's design. As such, it starts
from first principles and slowly walks up to the full design. This
means that, especially early in the talk, the code presented will not
be very ergonomic. If you're looking for a tutorial on how to use
Flutter, this is not it. Nor is it a comprehensive API description.

   This is a tutorial: https://flutter.io/tutorial/

   These are our API docs: http://docs.flutter.io/

   This is our Web site with more information: https://flutter.io/

Chapter 1: Let's create an app!
-------------------------------

Let's write a trivial app. It'll just show a table with my wishlist of
items I want from the Märklin 2016 model train catalogue.

```
$ flutter create trains
```

Type type type.

<https://github.com/Hixie/mahogony-staircase/blob/master/apps/chapter1/trains/lib/main.dart>

```
$ flutter analyze
$ flutter run
```

Success!

Chapter 2: Adding more to the app
---------------------------------

Ok. Let's add a checkbox to the first cell of each row so that we can
track which one's I've preordered.

<https://github.com/Hixie/mahogony-staircase/blob/master/apps/chapter2/trains/lib/main.dart>

Pros of this approach:
- There's only one code path.
- There's no question what's going on.

Cons of this approach:
- You do a ton of work every frame.
- Holy cow the mathematics.

Trees:
- There's a layer tree buried near the end of the paint calls. We could be really
  fancy and split the scene into more parts, if the application was animated and
  we wanted to improve performance.

Chapter 3: Rendering library
----------------------------

Having to do all these calculations is ridiculous.

Let's use a library that provides render objects.

<https://github.com/Hixie/mahogony-staircase/blob/master/apps/chapter3/trains/lib/main.dart>

Side bar: Let's explain what's going on here.

Chapter 4: Adding more to the app
---------------------------------

Let's add the "checkbox" again.

<https://github.com/Hixie/mahogony-staircase/blob/master/apps/chapter4/trains/lib/main.dart>

Chapter 5: Widgets
------------------

Having to first build the app and then poke at it is error-prone.
Let's use a library that provides an abstraction over the render
objects so that you just build the app each time and it efficiently
redoes the layout only as needed.

![This is the third time I've written this app, and I'm getting exceedingly efficient at it.](https://i.ytimg.com/vi/ZKpFFD7aX3c/maxresdefault.jpg)

<https://github.com/Hixie/mahogony-staircase/blob/master/apps/chapter5/trains/lib/main.dart>

Side bar: Let's explain what's going on here.

Chapter 6: Adding more to the app
---------------------------------

Let's add the "checkbox" again.

<https://github.com/Hixie/mahogony-staircase/blob/master/apps/chapter6/trains/lib/main.dart>

Chapter 7: Stateful builder
---------------------------

We can move the state back into the tree using a StatefulBuilder.

<https://github.com/Hixie/mahogony-staircase/blob/master/apps/chapter7/trains/lib/main.dart>

Chapter 8: Stateful widgets
---------------------------

Code reuse demands that we be able to extract these little bits out.

We want to have a State that lives longer than the Widgets, so we have
the Widget create a State the first time the tree is built, and then
we reuse it later.

Thus, NetworkImage!

<https://github.com/Hixie/mahogony-staircase/blob/master/apps/chapter8/trains/lib/main.dart>

Turns out that is one of our built-in components, so we can just
remove all this code.

Chapter 9: Stateless stateful widgets
-------------------------------------

One pattern we use a lot here is this padding + text pattern. Since we
now know how to create reusable components, let's make one for this
pattern.

We can even use this for the title, if we take out half the bottom
padding and put it after the title.

<https://github.com/Hixie/mahogony-staircase/blob/master/apps/chapter9/trains/lib/main.dart>

Chapter A: Stateless stateful widgets
-------------------------------------

We don't really need two classes here. We could put our build()
function on the Widget, and make a subclass of State that just always
calls it. That way, when the object has no state, we'd just use that
State and not need to create one ourselves.

<https://github.com/Hixie/mahogony-staircase/blob/master/apps/chapterA/trains/lib/main.dart>

Chapter B: Stateless stateful widgets
-------------------------------------

That's what StatelessWidget is.

<https://github.com/Hixie/mahogony-staircase/blob/master/apps/chapterB/trains/lib/main.dart>

Chapter C: Pre-built widgets
----------------------------

There are lots of pre-built widgets along the lines of NetworkImage and TextCell.

- DecoratedBox, Padding, and ConstrainedBox can all be expressed using
  Container. This helps keep the code a tiny bit more concise.

- Viewport and BlockBody are actually the building blocks of Block,
  which also has built-in support for scrolling.

- Instead of a child-less padding, we can use a Container with a
  height. This actually internally turns into a ConstrainedBox, which
  we've seen before, and which is much the same as Padding really, but
  it looks cleaner in the source.

- Instead of a Listener we can use a GestureDetector. This lets you
  recognise actual gestures like taps, instead of only driving things
  on tap-down.

- Instead of just making the green dot appear or disappear, we can use
  an AnimatedOpacity to make it transition smoothly.

- Instead of just Align we can use Center to better express the intent.

Chapter D: Material widgets
---------------------------

If we move up yet one more layer, we get to the material library. This
library is similar to the widgets library, but it introduces user
interface widgets from material design, like buttons, checkboxes, and
so forth.

- We can introduce a MaterialApp, and set our material theme. This
  also reminds us to set the application title, which is used e.g. in
  the Android app switcher. We could have done this before, but we had
  forgotten to do so.

- By convention, we create a widget for our main page. This lets us
  put much of the app state into a class rather than having it be in
  global statics.

- We can trivially use a real checkbox instead of a green ball.

- We can get real Ink Wells!