text:
package compute

import original "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2018-04-01/compute"

type AvailabilitySetsClient = original.AvailabilitySetsClient

const (
	DefaultBaseURI = original.DefaultBaseURI
)

type BaseClient = original.BaseClient
type DisksClient = original.DisksClient
type ImagesClient = original.ImagesClient
type LogAnalyticsClient = original.LogAnalyticsClient
type AccessLevel = original.AccessLevel

const (
	None AccessLevel = original.None
	Read AccessLevel = original.Read
)

type CachingTypes = original.CachingTypes

const (
	CachingTypesNone      CachingTypes = original.CachingTypesNone
	CachingTypesReadOnly  CachingTypes = original.CachingTypesReadOnly
	CachingTypesReadWrite CachingTypes = original.CachingTypesReadWrite
)

type ComponentNames = original.ComponentNames

const (
	MicrosoftWindowsShellSetup ComponentNames = original.MicrosoftWindowsShellSetup
)

type DiskCreateOption = original.DiskCreateOption

const (
	Attach    DiskCreateOption = original.Attach
	Copy      DiskCreateOption = original.Copy
	Empty     DiskCreateOption = original.Empty
	FromImage DiskCreateOption = original.FromImage
	Import    DiskCreateOption = original.Import
	Restore   DiskCreateOption = original.Restore
)

type DiskCreateOptionTypes = original.DiskCreateOptionTypes

const (
	DiskCreateOptionTypesAttach    DiskCreateOptionTypes = original.DiskCreateOptionTypesAttach
	DiskCreateOptionTypesEmpty     DiskCreateOptionTypes = original.DiskCreateOptionTypesEmpty
	DiskCreateOptionTypesFromImage DiskCreateOptionTypes = original.DiskCreateOptionTypesFromImage
)

type InstanceViewTypes = original.InstanceViewTypes

const (
	InstanceView InstanceViewTypes = original.InstanceView
)

type IntervalInMins = original.IntervalInMins

const (
	FiveMins   IntervalInMins = original.FiveMins
	SixtyMins  IntervalInMins = original.SixtyMins
	ThirtyMins IntervalInMins = original.ThirtyMins
	ThreeMins  IntervalInMins = original.ThreeMins
)

type IPVersion = original.IPVersion

const (
	IPv4 IPVersion = original.IPv4
	IPv6 IPVersion = original.IPv6
)

type MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypes

const (
	MaintenanceOperationResultCodeTypesMaintenanceAborted   MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypesMaintenanceAborted
	MaintenanceOperationResultCodeTypesMaintenanceCompleted MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypesMaintenanceCompleted
	MaintenanceOperationResultCodeTypesNone                 MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypesNone
	MaintenanceOperationResultCodeTypesRetryLater           MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypesRetryLater
)

type OperatingSystemStateTypes = original.OperatingSystemStateTypes

const (
	Generalized OperatingSystemStateTypes = original.Generalized
	Specialized OperatingSystemStateTypes = original.Specialized
)

type OperatingSystemTypes = original.OperatingSystemTypes

const (
	Linux   OperatingSystemTypes = original.Linux
	Windows OperatingSystemTypes = original.Windows
)

type PassNames = original.PassNames

const (
	OobeSystem PassNames = original.OobeSystem
)

type ProtocolTypes = original.ProtocolTypes

const (
	HTTP  ProtocolTypes = original.HTTP
	HTTPS ProtocolTypes = original.HTTPS
)

type ResourceIdentityType = original.ResourceIdentityType

const (
	ResourceIdentityTypeNone                       ResourceIdentityType = original.ResourceIdentityTypeNone
	ResourceIdentityTypeSystemAssigned             ResourceIdentityType = original.ResourceIdentityTypeSystemAssigned
	ResourceIdentityTypeSystemAssignedUserAssigned ResourceIdentityType = original.ResourceIdentityTypeSystemAssignedUserAssigned
	ResourceIdentityTypeUserAssigned               ResourceIdentityType = original.ResourceIdentityTypeUserAssigned
)

type RollingUpgradeActionType = original.RollingUpgradeActionType

const (
	Cancel RollingUpgradeActionType = original.Cancel
	Start  RollingUpgradeActionType = original.Start
)

type RollingUpgradeStatusCode = original.RollingUpgradeStatusCode

const (
	Cancelled      RollingUpgradeStatusCode = original.Cancelled
	Completed      RollingUpgradeStatusCode = original.Completed
	Faulted        RollingUpgradeStatusCode = original.Faulted
	RollingForward RollingUpgradeStatusCode = original.RollingForward
)

type SettingNames = original.SettingNames

const (
	AutoLogon          SettingNames = original.AutoLogon
	FirstLogonCommands SettingNames = original.FirstLogonCommands
)

type SnapshotStorageAccountTypes = original.SnapshotStorageAccountTypes

const (
	PremiumLRS  SnapshotStorageAccountTypes = original.PremiumLRS
	StandardLRS SnapshotStorageAccountTypes = original.StandardLRS
	StandardZRS SnapshotStorageAccountTypes = original.StandardZRS
)

type StatusLevelTypes = original.StatusLevelTypes

const (
	Error   StatusLevelTypes = original.Error
	Info    StatusLevelTypes = original.Info
	Warning StatusLevelTypes = original.Warning
)

type StorageAccountTypes = original.StorageAccountTypes

const (
	StorageAccountTypesPremiumLRS     StorageAccountTypes = original.StorageAccountTypesPremiumLRS
	StorageAccountTypesStandardLRS    StorageAccountTypes = original.StorageAccountTypesStandardLRS
	StorageAccountTypesStandardSSDLRS StorageAccountTypes = original.StorageAccountTypesStandardSSDLRS
)

type UpgradeMode = original.UpgradeMode

const (
	Automatic UpgradeMode = original.Automatic
	Manual    UpgradeMode = original.Manual
	Rolling   UpgradeMode = original.Rolling
)

type UpgradeOperationInvoker = original.UpgradeOperationInvoker

const (
	Platform UpgradeOperationInvoker = original.Platform
	Unknown  UpgradeOperationInvoker = original.Unknown
	User     UpgradeOperationInvoker = original.User
)

type UpgradeState = original.UpgradeState

const (
	UpgradeStateCancelled      UpgradeState = original.UpgradeStateCancelled
	UpgradeStateCompleted      UpgradeState = original.UpgradeStateCompleted
	UpgradeStateFaulted        UpgradeState = original.UpgradeStateFaulted
	UpgradeStateRollingForward UpgradeState = original.UpgradeStateRollingForward
)

type VirtualMachineEvictionPolicyTypes = original.VirtualMachineEvictionPolicyTypes

const (
	Deallocate VirtualMachineEvictionPolicyTypes = original.Deallocate
	Delete     VirtualMachineEvictionPolicyTypes = original.Delete
)

type VirtualMachinePriorityTypes = original.VirtualMachinePriorityTypes

const (
	Low     VirtualMachinePriorityTypes = original.Low
	Regular VirtualMachinePriorityTypes = original.Regular
)

type VirtualMachineScaleSetSkuScaleType = original.VirtualMachineScaleSetSkuScaleType

const (
	VirtualMachineScaleSetSkuScaleTypeAutomatic VirtualMachineScaleSetSkuScaleType = original.VirtualMachineScaleSetSkuScaleTypeAutomatic
	VirtualMachineScaleSetSkuScaleTypeNone      VirtualMachineScaleSetSkuScaleType = original.VirtualMachineScaleSetSkuScaleTypeNone
)

type VirtualMachineSizeTypes = original.VirtualMachineSizeTypes

const (
	BasicA0          VirtualMachineSizeTypes = original.BasicA0
	BasicA1          VirtualMachineSizeTypes = original.BasicA1
	BasicA2          VirtualMachineSizeTypes = original.BasicA2
	BasicA3          VirtualMachineSizeTypes = original.BasicA3
	BasicA4          VirtualMachineSizeTypes = original.BasicA4
	StandardA0       VirtualMachineSizeTypes = original.StandardA0
	StandardA1       VirtualMachineSizeTypes = original.StandardA1
	StandardA10      VirtualMachineSizeTypes = original.StandardA10
	StandardA11      VirtualMachineSizeTypes = original.StandardA11
	StandardA1V2     VirtualMachineSizeTypes = original.StandardA1V2
	StandardA2       VirtualMachineSizeTypes = original.StandardA2
	StandardA2mV2    VirtualMachineSizeTypes = original.StandardA2mV2
	StandardA2V2     VirtualMachineSizeTypes = original.StandardA2V2
	StandardA3       VirtualMachineSizeTypes = original.StandardA3
	StandardA4       VirtualMachineSizeTypes = original.StandardA4
	StandardA4mV2    VirtualMachineSizeTypes = original.StandardA4mV2
	StandardA4V2     VirtualMachineSizeTypes = original.StandardA4V2
	StandardA5       VirtualMachineSizeTypes = original.StandardA5
	StandardA6       VirtualMachineSizeTypes = original.StandardA6
	StandardA7       VirtualMachineSizeTypes = original.StandardA7
	StandardA8       VirtualMachineSizeTypes = original.StandardA8
	StandardA8mV2    VirtualMachineSizeTypes = original.StandardA8mV2
	StandardA8V2     VirtualMachineSizeTypes = original.StandardA8V2
	StandardA9       VirtualMachineSizeTypes = original.StandardA9
	StandardB1ms     VirtualMachineSizeTypes = original.StandardB1ms
	StandardB1s      VirtualMachineSizeTypes = original.StandardB1s
	StandardB2ms     VirtualMachineSizeTypes = original.StandardB2ms
	StandardB2s      VirtualMachineSizeTypes = original.StandardB2s
	StandardB4ms     VirtualMachineSizeTypes = original.StandardB4ms
	StandardB8ms     VirtualMachineSizeTypes = original.StandardB8ms
	StandardD1       VirtualMachineSizeTypes = original.StandardD1
	StandardD11      VirtualMachineSizeTypes = original.StandardD11
	StandardD11V2    VirtualMachineSizeTypes = original.StandardD11V2
	StandardD12      VirtualMachineSizeTypes = original.StandardD12
	StandardD12V2    VirtualMachineSizeTypes = original.StandardD12V2
	StandardD13      VirtualMachineSizeTypes = original.StandardD13
	StandardD13V2    VirtualMachineSizeTypes = original.StandardD13V2
	StandardD14      VirtualMachineSizeTypes = original.StandardD14
	StandardD14V2    VirtualMachineSizeTypes = original.StandardD14V2
	StandardD15V2    VirtualMachineSizeTypes = original.StandardD15V2
	StandardD16sV3   VirtualMachineSizeTypes = original.StandardD16sV3
	StandardD16V3    VirtualMachineSizeTypes = original.StandardD16V3
	StandardD1V2     VirtualMachineSizeTypes = original.StandardD1V2
	StandardD2       VirtualMachineSizeTypes = original.StandardD2
	StandardD2sV3    VirtualMachineSizeTypes = original.StandardD2sV3
	StandardD2V2     VirtualMachineSizeTypes = original.StandardD2V2
	StandardD2V3     VirtualMachineSizeTypes = original.StandardD2V3
	StandardD3       VirtualMachineSizeTypes = original.StandardD3
	StandardD32sV3   VirtualMachineSizeTypes = original.StandardD32sV3
	StandardD32V3    VirtualMachineSizeTypes = original.StandardD32V3
	StandardD3V2     VirtualMachineSizeTypes = original.StandardD3V2
	StandardD4       VirtualMachineSizeTypes = original.StandardD4
	StandardD4sV3    VirtualMachineSizeTypes = original.StandardD4sV3
	StandardD4V2     VirtualMachineSizeTypes = original.StandardD4V2
	StandardD4V3     VirtualMachineSizeTypes = original.StandardD4V3
	StandardD5V2     VirtualMachineSizeTypes = original.StandardD5V2
	StandardD64sV3   VirtualMachineSizeTypes = original.StandardD64sV3
	StandardD64V3    VirtualMachineSizeTypes = original.StandardD64V3
	StandardD8sV3    VirtualMachineSizeTypes = original.StandardD8sV3
	StandardD8V3     VirtualMachineSizeTypes = original.StandardD8V3
	StandardDS1      VirtualMachineSizeTypes = original.StandardDS1
	StandardDS11     VirtualMachineSizeTypes = original.StandardDS11
	StandardDS11V2   VirtualMachineSizeTypes = original.StandardDS11V2
	StandardDS12     VirtualMachineSizeTypes = original.StandardDS12
	StandardDS12V2   VirtualMachineSizeTypes = original.StandardDS12V2
	StandardDS13     VirtualMachineSizeTypes = original.StandardDS13
	StandardDS132V2  VirtualMachineSizeTypes = original.StandardDS132V2
	StandardDS134V2  VirtualMachineSizeTypes = original.StandardDS134V2
	StandardDS13V2   VirtualMachineSizeTypes = original.StandardDS13V2
	StandardDS14     VirtualMachineSizeTypes = original.StandardDS14
	StandardDS144V2  VirtualMachineSizeTypes = original.StandardDS144V2
	StandardDS148V2  VirtualMachineSizeTypes = original.StandardDS148V2
	StandardDS14V2   VirtualMachineSizeTypes = original.StandardDS14V2
	StandardDS15V2   VirtualMachineSizeTypes = original.StandardDS15V2
	StandardDS1V2    VirtualMachineSizeTypes = original.StandardDS1V2
	StandardDS2      VirtualMachineSizeTypes = original.StandardDS2
	StandardDS2V2    VirtualMachineSizeTypes = original.StandardDS2V2
	StandardDS3      VirtualMachineSizeTypes = original.StandardDS3
	StandardDS3V2    VirtualMachineSizeTypes = original.StandardDS3V2
	StandardDS4      VirtualMachineSizeTypes = original.StandardDS4
	StandardDS4V2    VirtualMachineSizeTypes = original.StandardDS4V2
	StandardDS5V2    VirtualMachineSizeTypes = original.StandardDS5V2
	StandardE16sV3   VirtualMachineSizeTypes = original.StandardE16sV3
	StandardE16V3    VirtualMachineSizeTypes = original.StandardE16V3
	StandardE2sV3    VirtualMachineSizeTypes = original.StandardE2sV3
	StandardE2V3     VirtualMachineSizeTypes = original.StandardE2V3
	StandardE3216V3  VirtualMachineSizeTypes = original.StandardE3216V3
	StandardE328sV3  VirtualMachineSizeTypes = original.StandardE328sV3
	StandardE32sV3   VirtualMachineSizeTypes = original.StandardE32sV3
	StandardE32V3    VirtualMachineSizeTypes = original.StandardE32V3
	StandardE4sV3    VirtualMachineSizeTypes = original.StandardE4sV3
	StandardE4V3     VirtualMachineSizeTypes = original.StandardE4V3
	StandardE6416sV3 VirtualMachineSizeTypes = original.StandardE6416sV3
	StandardE6432sV3 VirtualMachineSizeTypes = original.StandardE6432sV3
	StandardE64sV3   VirtualMachineSizeTypes = original.StandardE64sV3
	StandardE64V3    VirtualMachineSizeTypes = original.StandardE64V3
	StandardE8sV3    VirtualMachineSizeTypes = original.StandardE8sV3
	StandardE8V3     VirtualMachineSizeTypes = original.StandardE8V3
	StandardF1       VirtualMachineSizeTypes = original.StandardF1
	StandardF16      VirtualMachineSizeTypes = original.StandardF16
	StandardF16s     VirtualMachineSizeTypes = original.StandardF16s
	StandardF16sV2   VirtualMachineSizeTypes = original.StandardF16sV2
	StandardF1s      VirtualMachineSizeTypes = original.StandardF1s
	StandardF2       VirtualMachineSizeTypes = original.StandardF2
	StandardF2s      VirtualMachineSizeTypes = original.StandardF2s
	StandardF2sV2    VirtualMachineSizeTypes = original.StandardF2sV2
	StandardF32sV2   VirtualMachineSizeTypes = original.StandardF32sV2
	StandardF4       VirtualMachineSizeTypes = original.StandardF4
	StandardF4s      VirtualMachineSizeTypes = original.StandardF4s
	StandardF4sV2    VirtualMachineSizeTypes = original.StandardF4sV2
	StandardF64sV2   VirtualMachineSizeTypes = original.StandardF64sV2
	StandardF72sV2   VirtualMachineSizeTypes = original.StandardF72sV2
	StandardF8       VirtualMachineSizeTypes = original.StandardF8
	StandardF8s      VirtualMachineSizeTypes = original.StandardF8s
	StandardF8sV2    VirtualMachineSizeTypes = original.StandardF8sV2
	StandardG1       VirtualMachineSizeTypes = original.StandardG1
	StandardG2       VirtualMachineSizeTypes = original.StandardG2
	StandardG3       VirtualMachineSizeTypes = original.StandardG3
	StandardG4       VirtualMachineSizeTypes = original.StandardG4
	StandardG5       VirtualMachineSizeTypes = original.StandardG5
	StandardGS1      VirtualMachineSizeTypes = original.StandardGS1
	StandardGS2      VirtualMachineSizeTypes = original.StandardGS2
	StandardGS3      VirtualMachineSizeTypes = original.StandardGS3
	StandardGS4      VirtualMachineSizeTypes = original.StandardGS4
	StandardGS44     VirtualMachineSizeTypes = original.StandardGS44
	StandardGS48     VirtualMachineSizeTypes = original.StandardGS48
	StandardGS5      VirtualMachineSizeTypes = original.StandardGS5
	StandardGS516    VirtualMachineSizeTypes = original.StandardGS516
	StandardGS58     VirtualMachineSizeTypes = original.StandardGS58
	StandardH16      VirtualMachineSizeTypes = original.StandardH16
	StandardH16m     VirtualMachineSizeTypes = original.StandardH16m
	StandardH16mr    VirtualMachineSizeTypes = original.StandardH16mr
	StandardH16r     VirtualMachineSizeTypes = original.StandardH16r
	StandardH8       VirtualMachineSizeTypes = original.StandardH8
	StandardH8m      VirtualMachineSizeTypes = original.StandardH8m
	StandardL16s     VirtualMachineSizeTypes = original.StandardL16s
	StandardL32s     VirtualMachineSizeTypes = original.StandardL32s
	StandardL4s      VirtualMachineSizeTypes = original.StandardL4s
	StandardL8s      VirtualMachineSizeTypes = original.StandardL8s
	StandardM12832ms VirtualMachineSizeTypes = original.StandardM12832ms
	StandardM12864ms VirtualMachineSizeTypes = original.StandardM12864ms
	StandardM128ms   VirtualMachineSizeTypes = original.StandardM128ms
	StandardM128s    VirtualMachineSizeTypes = original.StandardM128s
	StandardM6416ms  VirtualMachineSizeTypes = original.StandardM6416ms
	StandardM6432ms  VirtualMachineSizeTypes = original.StandardM6432ms
	StandardM64ms    VirtualMachineSizeTypes = original.StandardM64ms
	StandardM64s     VirtualMachineSizeTypes = original.StandardM64s
	StandardNC12     VirtualMachineSizeTypes = original.StandardNC12
	StandardNC12sV2  VirtualMachineSizeTypes = original.StandardNC12sV2
	StandardNC12sV3  VirtualMachineSizeTypes = original.StandardNC12sV3
	StandardNC24     VirtualMachineSizeTypes = original.StandardNC24
	StandardNC24r    VirtualMachineSizeTypes = original.StandardNC24r
	StandardNC24rsV2 VirtualMachineSizeTypes = original.StandardNC24rsV2
	StandardNC24rsV3 VirtualMachineSizeTypes = original.StandardNC24rsV3
	StandardNC24sV2  VirtualMachineSizeTypes = original.StandardNC24sV2
	StandardNC24sV3  VirtualMachineSizeTypes = original.StandardNC24sV3
	StandardNC6      VirtualMachineSizeTypes = original.StandardNC6
	StandardNC6sV2   VirtualMachineSizeTypes = original.StandardNC6sV2
	StandardNC6sV3   VirtualMachineSizeTypes = original.StandardNC6sV3
	StandardND12s    VirtualMachineSizeTypes = original.StandardND12s
	StandardND24rs   VirtualMachineSizeTypes = original.StandardND24rs
	StandardND24s    VirtualMachineSizeTypes = original.StandardND24s
	StandardND6s     VirtualMachineSizeTypes = original.StandardND6s
	StandardNV12     VirtualMachineSizeTypes = original.StandardNV12
	StandardNV24     VirtualMachineSizeTypes = original.StandardNV24
	StandardNV6      VirtualMachineSizeTypes = original.StandardNV6
)

type AccessURI = original.AccessURI
type AccessURIOutput = original.AccessURIOutput
type AccessURIRaw = original.AccessURIRaw
type AdditionalUnattendContent = original.AdditionalUnattendContent
type APIEntityReference = original.APIEntityReference
type APIError = original.APIError
type APIErrorBase = original.APIErrorBase
type AutoOSUpgradePolicy = original.AutoOSUpgradePolicy
type AvailabilitySet = original.AvailabilitySet
type AvailabilitySetListResult = original.AvailabilitySetListResult
type AvailabilitySetListResultIterator = original.AvailabilitySetListResultIterator
type AvailabilitySetListResultPage = original.AvailabilitySetListResultPage
type AvailabilitySetProperties = original.AvailabilitySetProperties
type AvailabilitySetUpdate = original.AvailabilitySetUpdate
type BootDiagnostics = original.BootDiagnostics
type BootDiagnosticsInstanceView = original.BootDiagnosticsInstanceView
type CreationData = original.CreationData
type DataDisk = original.DataDisk
type DataDiskImage = original.DataDiskImage
type DiagnosticsProfile = original.DiagnosticsProfile
type Disk = original.Disk
type DiskEncryptionSettings = original.DiskEncryptionSettings
type DiskInstanceView = original.DiskInstanceView
type DiskList = original.DiskList
type DiskListIterator = original.DiskListIterator
type DiskListPage = original.DiskListPage
type DiskProperties = original.DiskProperties
type DisksCreateOrUpdateFuture = original.DisksCreateOrUpdateFuture
type DisksDeleteFuture = original.DisksDeleteFuture
type DisksGrantAccessFuture = original.DisksGrantAccessFuture
type DiskSku = original.DiskSku
type DisksRevokeAccessFuture = original.DisksRevokeAccessFuture
type DisksUpdateFuture = original.DisksUpdateFuture
type DiskUpdate = original.DiskUpdate
type DiskUpdateProperties = original.DiskUpdateProperties
type EncryptionSettings = original.EncryptionSettings
type GrantAccessData = original.GrantAccessData
type HardwareProfile = original.HardwareProfile
type Image = original.Image
type ImageDataDisk = original.ImageDataDisk
type ImageDiskReference = original.ImageDiskReference
type ImageListResult = original.ImageListResult
type ImageListResultIterator = original.ImageListResultIterator
type ImageListResultPage = original.ImageListResultPage
type ImageOSDisk = original.ImageOSDisk
type ImageProperties = original.ImageProperties
type ImageReference = original.ImageReference
type ImagesCreateOrUpdateFuture = original.ImagesCreateOrUpdateFuture
type ImagesDeleteFuture = original.ImagesDeleteFuture
type ImageStorageProfile = original.ImageStorageProfile
type ImagesUpdateFuture = original.ImagesUpdateFuture
type ImageUpdate = original.ImageUpdate
type InnerError = original.InnerError
type InstanceViewStatus = original.InstanceViewStatus
type KeyVaultAndKeyReference = original.KeyVaultAndKeyReference
type KeyVaultAndSecretReference = original.KeyVaultAndSecretReference
type KeyVaultKeyReference = original.KeyVaultKeyReference
type KeyVaultSecretReference = original.KeyVaultSecretReference
type LinuxConfiguration = original.LinuxConfiguration
type ListUsagesResult = original.ListUsagesResult
type ListUsagesResultIterator = original.ListUsagesResultIterator
type ListUsagesResultPage = original.ListUsagesResultPage
type ListVirtualMachineExtensionImage = original.ListVirtualMachineExtensionImage
type ListVirtualMachineImageResource = original.ListVirtualMachineImageResource
type LogAnalyticsExportRequestRateByIntervalFuture = original.LogAnalyticsExportRequestRateByIntervalFuture
type LogAnalyticsExportThrottledRequestsFuture = original.LogAnalyticsExportThrottledRequestsFuture
type LogAnalyticsInputBase = original.LogAnalyticsInputBase
type LogAnalyticsOperationResult = original.LogAnalyticsOperationResult
type LogAnalyticsOutput = original.LogAnalyticsOutput
type MaintenanceRedeployStatus = original.MaintenanceRedeployStatus
type ManagedDiskParameters = original.ManagedDiskParameters
type NetworkInterfaceReference = original.NetworkInterfaceReference
type NetworkInterfaceReferenceProperties = original.NetworkInterfaceReferenceProperties
type NetworkProfile = original.NetworkProfile
type OperationListResult = original.OperationListResult
type OperationValue = original.OperationValue
type OperationValueDisplay = original.OperationValueDisplay
type OSDisk = original.OSDisk
type OSDiskImage = original.OSDiskImage
type OSProfile = original.OSProfile
type Plan = original.Plan
type PurchasePlan = original.PurchasePlan
type RecoveryWalkResponse = original.RecoveryWalkResponse
type RequestRateByIntervalInput = original.RequestRateByIntervalInput
type Resource = original.Resource
type RollbackStatusInfo = original.RollbackStatusInfo
type RollingUpgradePolicy = original.RollingUpgradePolicy
type RollingUpgradeProgressInfo = original.RollingUpgradeProgressInfo
type RollingUpgradeRunningStatus = original.RollingUpgradeRunningStatus
type RollingUpgradeStatusInfo = original.RollingUpgradeStatusInfo
type RollingUpgradeStatusInfoProperties = original.RollingUpgradeStatusInfoProperties
type RunCommandDocument = original.RunCommandDocument
type RunCommandDocumentBase = original.RunCommandDocumentBase
type RunCommandInput = original.RunCommandInput
type RunCommandInputParameter = original.RunCommandInputParameter
type RunCommandListResult = original.RunCommandListResult
type RunCommandListResultIterator = original.RunCommandListResultIterator
type RunCommandListResultPage = original.RunCommandListResultPage
type RunCommandParameterDefinition = original.RunCommandParameterDefinition
type RunCommandResult = original.RunCommandResult
type Sku = original.Sku
type Snapshot = original.Snapshot
type SnapshotList = original.SnapshotList
type SnapshotListIterator = original.SnapshotListIterator
type SnapshotListPage = original.SnapshotListPage
type SnapshotsCreateOrUpdateFuture = original.SnapshotsCreateOrUpdateFuture
type SnapshotsDeleteFuture = original.SnapshotsDeleteFuture
type SnapshotsGrantAccessFuture = original.SnapshotsGrantAccessFuture
type SnapshotSku = original.SnapshotSku
type SnapshotsRevokeAccessFuture = original.SnapshotsRevokeAccessFuture
type SnapshotsUpdateFuture = original.SnapshotsUpdateFuture
type SnapshotUpdate = original.SnapshotUpdate
type SourceVault = original.SourceVault
type SSHConfiguration = original.SSHConfiguration
type SSHPublicKey = original.SSHPublicKey
type StorageProfile = original.StorageProfile
type SubResource = original.SubResource
type SubResourceReadOnly = original.SubResourceReadOnly
type ThrottledRequestsInput = original.ThrottledRequestsInput
type UpdateResource = original.UpdateResource
type UpgradeOperationHistoricalStatusInfo = original.UpgradeOperationHistoricalStatusInfo
type UpgradeOperationHistoricalStatusInfoProperties = original.UpgradeOperationHistoricalStatusInfoProperties
type UpgradeOperationHistoryStatus = original.UpgradeOperationHistoryStatus
type UpgradePolicy = original.UpgradePolicy
type Usage = original.Usage
type UsageName = original.UsageName
type VaultCertificate = original.VaultCertificate
type VaultSecretGroup = original.VaultSecretGroup
type VirtualHardDisk = original.VirtualHardDisk
type VirtualMachine = original.VirtualMachine
type VirtualMachineAgentInstanceView = original.VirtualMachineAgentInstanceView
type VirtualMachineCaptureParameters = original.VirtualMachineCaptureParameters
type VirtualMachineCaptureResult = original.VirtualMachineCaptureResult
type VirtualMachineExtension = original.VirtualMachineExtension
type VirtualMachineExtensionHandlerInstanceView = original.VirtualMachineExtensionHandlerInstanceView
type VirtualMachineExtensionImage = original.VirtualMachineExtensionImage
type VirtualMachineExtensionImageProperties = original.VirtualMachineExtensionImageProperties
type VirtualMachineExtensionInstanceView = original.VirtualMachineExtensionInstanceView
type VirtualMachineExtensionProperties = original.VirtualMachineExtensionProperties
type VirtualMachineExtensionsCreateOrUpdateFuture = original.VirtualMachineExtensionsCreateOrUpdateFuture
type VirtualMachineExtensionsDeleteFuture = original.VirtualMachineExtensionsDeleteFuture
type VirtualMachineExtensionsListResult = original.VirtualMachineExtensionsListResult
type VirtualMachineExtensionsUpdateFuture = original.VirtualMachineExtensionsUpdateFuture
type VirtualMachineExtensionUpdate = original.VirtualMachineExtensionUpdate
type VirtualMachineExtensionUpdateProperties = original.VirtualMachineExtensionUpdateProperties
type VirtualMachineHealthStatus = original.VirtualMachineHealthStatus
type VirtualMachineIdentity = original.VirtualMachineIdentity
type VirtualMachineImage = original.VirtualMachineImage
type VirtualMachineImageProperties = original.VirtualMachineImageProperties
type VirtualMachineImageResource = original.VirtualMachineImageResource
type VirtualMachineInstanceView = original.VirtualMachineInstanceView
type VirtualMachineListResult = original.VirtualMachineListResult
type VirtualMachineListResultIterator = original.VirtualMachineListResultIterator
type VirtualMachineListResultPage = original.VirtualMachineListResultPage
type VirtualMachineProperties = original.VirtualMachineProperties
type VirtualMachineScaleSet = original.VirtualMachineScaleSet
type VirtualMachineScaleSetDataDisk = original.VirtualMachineScaleSetDataDisk
type VirtualMachineScaleSetExtension = original.VirtualMachineScaleSetExtension
type VirtualMachineScaleSetExtensionListResult = original.VirtualMachineScaleSetExtensionListResult
type VirtualMachineScaleSetExtensionListResultIterator = original.VirtualMachineScaleSetExtensionListResultIterator
type VirtualMachineScaleSetExtensionListResultPage = original.VirtualMachineScaleSetExtensionListResultPage
type VirtualMachineScaleSetExtensionProfile = original.VirtualMachineScaleSetExtensionProfile
type VirtualMachineScaleSetExtensionProperties = original.VirtualMachineScaleSetExtensionProperties
type VirtualMachineScaleSetExtensionsCreateOrUpdateFuture = original.VirtualMachineScaleSetExtensionsCreateOrUpdateFuture
type VirtualMachineScaleSetExtensionsDeleteFuture = original.VirtualMachineScaleSetExtensionsDeleteFuture
type VirtualMachineScaleSetIdentity = original.VirtualMachineScaleSetIdentity
type VirtualMachineScaleSetInstanceView = original.VirtualMachineScaleSetInstanceView
type VirtualMachineScaleSetInstanceViewStatusesSummary = original.VirtualMachineScaleSetInstanceViewStatusesSummary
type VirtualMachineScaleSetIPConfiguration = original.VirtualMachineScaleSetIPConfiguration
type VirtualMachineScaleSetIPConfigurationProperties = original.VirtualMachineScaleSetIPConfigurationProperties
type VirtualMachineScaleSetIPTag = original.VirtualMachineScaleSetIPTag
type VirtualMachineScaleSetListOSUpgradeHistory = original.VirtualMachineScaleSetListOSUpgradeHistory
type VirtualMachineScaleSetListOSUpgradeHistoryIterator = original.VirtualMachineScaleSetListOSUpgradeHistoryIterator
type VirtualMachineScaleSetListOSUpgradeHistoryPage = original.VirtualMachineScaleSetListOSUpgradeHistoryPage
type VirtualMachineScaleSetListResult = original.VirtualMachineScaleSetListResult
type VirtualMachineScaleSetListResultIterator = original.VirtualMachineScaleSetListResultIterator
type VirtualMachineScaleSetListResultPage = original.VirtualMachineScaleSetListResultPage
type VirtualMachineScaleSetListSkusResult = original.VirtualMachineScaleSetListSkusResult
type VirtualMachineScaleSetListSkusResultIterator = original.VirtualMachineScaleSetListSkusResultIterator
type VirtualMachineScaleSetListSkusResultPage = original.VirtualMachineScaleSetListSkusResultPage
type VirtualMachineScaleSetListWithLinkResult = original.VirtualMachineScaleSetListWithLinkResult
type VirtualMachineScaleSetListWithLinkResultIterator = original.VirtualMachineScaleSetListWithLinkResultIterator
type VirtualMachineScaleSetListWithLinkResultPage = original.VirtualMachineScaleSetListWithLinkResultPage
type VirtualMachineScaleSetManagedDiskParameters = original.VirtualMachineScaleSetManagedDiskParameters
type VirtualMachineScaleSetNetworkConfiguration = original.VirtualMachineScaleSetNetworkConfiguration
type VirtualMachineScaleSetNetworkConfigurationDNSSettings = original.VirtualMachineScaleSetNetworkConfigurationDNSSettings
type VirtualMachineScaleSetNetworkConfigurationProperties = original.VirtualMachineScaleSetNetworkConfigurationProperties
type VirtualMachineScaleSetNetworkProfile = original.VirtualMachineScaleSetNetworkProfile
type VirtualMachineScaleSetOSDisk = original.VirtualMachineScaleSetOSDisk
type VirtualMachineScaleSetOSProfile = original.VirtualMachineScaleSetOSProfile
type VirtualMachineScaleSetProperties = original.VirtualMachineScaleSetProperties
type VirtualMachineScaleSetPublicIPAddressConfiguration = original.VirtualMachineScaleSetPublicIPAddressConfiguration
type VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings = original.VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings
type VirtualMachineScaleSetPublicIPAddressConfigurationProperties = original.VirtualMachineScaleSetPublicIPAddressConfigurationProperties
type VirtualMachineScaleSetRollingUpgradesCancelFuture = original.VirtualMachineScaleSetRollingUpgradesCancelFuture
type VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture = original.VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture
type VirtualMachineScaleSetsCreateOrUpdateFuture = original.VirtualMachineScaleSetsCreateOrUpdateFuture
type VirtualMachineScaleSetsDeallocateFuture = original.VirtualMachineScaleSetsDeallocateFuture
type VirtualMachineScaleSetsDeleteFuture = original.VirtualMachineScaleSetsDeleteFuture
type VirtualMachineScaleSetsDeleteInstancesFuture = original.VirtualMachineScaleSetsDeleteInstancesFuture
type VirtualMachineScaleSetSku = original.VirtualMachineScaleSetSku
type VirtualMachineScaleSetSkuCapacity = original.VirtualMachineScaleSetSkuCapacity
type VirtualMachineScaleSetsPerformMaintenanceFuture = original.VirtualMachineScaleSetsPerformMaintenanceFuture
type VirtualMachineScaleSetsPowerOffFuture = original.VirtualMachineScaleSetsPowerOffFuture
type VirtualMachineScaleSetsRedeployFuture = original.VirtualMachineScaleSetsRedeployFuture
type VirtualMachineScaleSetsReimageAllFuture = original.VirtualMachineScaleSetsReimageAllFuture
type VirtualMachineScaleSetsReimageFuture = original.VirtualMachineScaleSetsReimageFuture
type VirtualMachineScaleSetsRestartFuture = original.VirtualMachineScaleSetsRestartFuture
type VirtualMachineScaleSetsStartFuture = original.VirtualMachineScaleSetsStartFuture
type VirtualMachineScaleSetStorageProfile = original.VirtualMachineScaleSetStorageProfile
type VirtualMachineScaleSetsUpdateFuture = original.VirtualMachineScaleSetsUpdateFuture
type VirtualMachineScaleSetsUpdateInstancesFuture = original.VirtualMachineScaleSetsUpdateInstancesFuture
type VirtualMachineScaleSetUpdate = original.VirtualMachineScaleSetUpdate
type VirtualMachineScaleSetUpdateIPConfiguration = original.VirtualMachineScaleSetUpdateIPConfiguration
type VirtualMachineScaleSetUpdateIPConfigurationProperties = original.VirtualMachineScaleSetUpdateIPConfigurationProperties
type VirtualMachineScaleSetUpdateNetworkConfiguration = original.VirtualMachineScaleSetUpdateNetworkConfiguration
type VirtualMachineScaleSetUpdateNetworkConfigurationProperties = original.VirtualMachineScaleSetUpdateNetworkConfigurationProperties
type VirtualMachineScaleSetUpdateNetworkProfile = original.VirtualMachineScaleSetUpdateNetworkProfile
type VirtualMachineScaleSetUpdateOSDisk = original.VirtualMachineScaleSetUpdateOSDisk
type VirtualMachineScaleSetUpdateOSProfile = original.VirtualMachineScaleSetUpdateOSProfile
type VirtualMachineScaleSetUpdateProperties = original.VirtualMachineScaleSetUpdateProperties
type VirtualMachineScaleSetUpdatePublicIPAddressConfiguration = original.VirtualMachineScaleSetUpdatePublicIPAddressConfiguration
type VirtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties = original.VirtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties
type VirtualMachineScaleSetUpdateStorageProfile = original.VirtualMachineScaleSetUpdateStorageProfile
type VirtualMachineScaleSetUpdateVMProfile = original.VirtualMachineScaleSetUpdateVMProfile
type VirtualMachineScaleSetVM = original.VirtualMachineScaleSetVM
type VirtualMachineScaleSetVMExtensionsSummary = original.VirtualMachineScaleSetVMExtensionsSummary
type VirtualMachineScaleSetVMInstanceIDs = original.VirtualMachineScaleSetVMInstanceIDs
type VirtualMachineScaleSetVMInstanceRequiredIDs = original.VirtualMachineScaleSetVMInstanceRequiredIDs
type VirtualMachineScaleSetVMInstanceView = original.VirtualMachineScaleSetVMInstanceView
type VirtualMachineScaleSetVMListResult = original.VirtualMachineScaleSetVMListResult
type VirtualMachineScaleSetVMListResultIterator = original.VirtualMachineScaleSetVMListResultIterator
type VirtualMachineScaleSetVMListResultPage = original.VirtualMachineScaleSetVMListResultPage
type VirtualMachineScaleSetVMProfile = original.VirtualMachineScaleSetVMProfile
type VirtualMachineScaleSetVMProperties = original.VirtualMachineScaleSetVMProperties
type VirtualMachineScaleSetVMsDeallocateFuture = original.VirtualMachineScaleSetVMsDeallocateFuture
type VirtualMachineScaleSetVMsDeleteFuture = original.VirtualMachineScaleSetVMsDeleteFuture
type VirtualMachineScaleSetVMsPerformMaintenanceFuture = original.VirtualMachineScaleSetVMsPerformMaintenanceFuture
type VirtualMachineScaleSetVMsPowerOffFuture = original.VirtualMachineScaleSetVMsPowerOffFuture
type VirtualMachineScaleSetVMsRedeployFuture = original.VirtualMachineScaleSetVMsRedeployFuture
type VirtualMachineScaleSetVMsReimageAllFuture = original.VirtualMachineScaleSetVMsReimageAllFuture
type VirtualMachineScaleSetVMsReimageFuture = original.VirtualMachineScaleSetVMsReimageFuture
type VirtualMachineScaleSetVMsRestartFuture = original.VirtualMachineScaleSetVMsRestartFuture
type VirtualMachineScaleSetVMsRunCommandFuture = original.VirtualMachineScaleSetVMsRunCommandFuture
type VirtualMachineScaleSetVMsStartFuture = original.VirtualMachineScaleSetVMsStartFuture
type VirtualMachineScaleSetVMsUpdateFuture = original.VirtualMachineScaleSetVMsUpdateFuture
type VirtualMachinesCaptureFuture = original.VirtualMachinesCaptureFuture
type VirtualMachinesConvertToManagedDisksFuture = original.VirtualMachinesConvertToManagedDisksFuture
type VirtualMachinesCreateOrUpdateFuture = original.VirtualMachinesCreateOrUpdateFuture
type VirtualMachinesDeallocateFuture = original.VirtualMachinesDeallocateFuture
type VirtualMachinesDeleteFuture = original.VirtualMachinesDeleteFuture
type VirtualMachineSize = original.VirtualMachineSize
type VirtualMachineSizeListResult = original.VirtualMachineSizeListResult
type VirtualMachinesPerformMaintenanceFuture = original.VirtualMachinesPerformMaintenanceFuture
type VirtualMachinesPowerOffFuture = original.VirtualMachinesPowerOffFuture
type VirtualMachinesRedeployFuture = original.VirtualMachinesRedeployFuture
type VirtualMachinesRestartFuture = original.VirtualMachinesRestartFuture
type VirtualMachinesRunCommandFuture = original.VirtualMachinesRunCommandFuture
type VirtualMachinesStartFuture = original.VirtualMachinesStartFuture
type VirtualMachineStatusCodeCount = original.VirtualMachineStatusCodeCount
type VirtualMachinesUpdateFuture = original.VirtualMachinesUpdateFuture
type VirtualMachineUpdate = original.VirtualMachineUpdate
type WindowsConfiguration = original.WindowsConfiguration
type WinRMConfiguration = original.WinRMConfiguration
type WinRMListener = original.WinRMListener
type OperationsClient = original.OperationsClient
type SnapshotsClient = original.SnapshotsClient
type UsageClient = original.UsageClient
type VirtualMachineExtensionImagesClient = original.VirtualMachineExtensionImagesClient
type VirtualMachineExtensionsClient = original.VirtualMachineExtensionsClient
type VirtualMachineImagesClient = original.VirtualMachineImagesClient
type VirtualMachineRunCommandsClient = original.VirtualMachineRunCommandsClient
type VirtualMachinesClient = original.VirtualMachinesClient
type VirtualMachineScaleSetExtensionsClient = original.VirtualMachineScaleSetExtensionsClient
type VirtualMachineScaleSetRollingUpgradesClient = original.VirtualMachineScaleSetRollingUpgradesClient
type VirtualMachineScaleSetsClient = original.VirtualMachineScaleSetsClient
type VirtualMachineScaleSetVMsClient = original.VirtualMachineScaleSetVMsClient
type VirtualMachineSizesClient = original.VirtualMachineSizesClient

func NewAvailabilitySetsClient(subscriptionID string) AvailabilitySetsClient {
	return original.NewAvailabilitySetsClient(subscriptionID)
}
func NewAvailabilitySetsClientWithBaseURI(baseURI string, subscriptionID string) AvailabilitySetsClient {
	return original.NewAvailabilitySetsClientWithBaseURI(baseURI, subscriptionID)
}
func New(subscriptionID string) BaseClient {
	return original.New(subscriptionID)
}
func NewWithBaseURI(baseURI string, subscriptionID string) BaseClient {
	return original.NewWithBaseURI(baseURI, subscriptionID)
}
func NewDisksClient(subscriptionID string) DisksClient {
	return original.NewDisksClient(subscriptionID)
}
func NewDisksClientWithBaseURI(baseURI string, subscriptionID string) DisksClient {
	return original.NewDisksClientWithBaseURI(baseURI, subscriptionID)
}
func NewImagesClient(subscriptionID string) ImagesClient {
	return original.NewImagesClient(subscriptionID)
}
func NewImagesClientWithBaseURI(baseURI string, subscriptionID string) ImagesClient {
	return original.NewImagesClientWithBaseURI(baseURI, subscriptionID)
}
func NewLogAnalyticsClient(subscriptionID string) LogAnalyticsClient {
	return original.NewLogAnalyticsClient(subscriptionID)
}
func NewLogAnalyticsClientWithBaseURI(baseURI string, subscriptionID string) LogAnalyticsClient {
	return original.NewLogAnalyticsClientWithBaseURI(baseURI, subscriptionID)
}
func PossibleAccessLevelValues() []AccessLevel {
	return original.PossibleAccessLevelValues()
}
func PossibleCachingTypesValues() []CachingTypes {
	return original.PossibleCachingTypesValues()
}
func PossibleComponentNamesValues() []ComponentNames {
	return original.PossibleComponentNamesValues()
}
func PossibleDiskCreateOptionValues() []DiskCreateOption {
	return original.PossibleDiskCreateOptionValues()
}
func PossibleDiskCreateOptionTypesValues() []DiskCreateOptionTypes {
	return original.PossibleDiskCreateOptionTypesValues()
}
func PossibleInstanceViewTypesValues() []InstanceViewTypes {
	return original.PossibleInstanceViewTypesValues()
}
func PossibleIntervalInMinsValues() []IntervalInMins {
	return original.PossibleIntervalInMinsValues()
}
func PossibleIPVersionValues() []IPVersion {
	return original.PossibleIPVersionValues()
}
func PossibleMaintenanceOperationResultCodeTypesValues() []MaintenanceOperationResultCodeTypes {
	return original.PossibleMaintenanceOperationResultCodeTypesValues()
}
func PossibleOperatingSystemStateTypesValues() []OperatingSystemStateTypes {
	return original.PossibleOperatingSystemStateTypesValues()
}
func PossibleOperatingSystemTypesValues() []OperatingSystemTypes {
	return original.PossibleOperatingSystemTypesValues()
}
func PossiblePassNamesValues() []PassNames {
	return original.PossiblePassNamesValues()
}
func PossibleProtocolTypesValues() []ProtocolTypes {
	return original.PossibleProtocolTypesValues()
}
func PossibleResourceIdentityTypeValues() []ResourceIdentityType {
	return original.PossibleResourceIdentityTypeValues()
}
func PossibleRollingUpgradeActionTypeValues() []RollingUpgradeActionType {
	return original.PossibleRollingUpgradeActionTypeValues()
}
func PossibleRollingUpgradeStatusCodeValues() []RollingUpgradeStatusCode {
	return original.PossibleRollingUpgradeStatusCodeValues()
}
func PossibleSettingNamesValues() []SettingNames {
	return original.PossibleSettingNamesValues()
}
func PossibleSnapshotStorageAccountTypesValues() []SnapshotStorageAccountTypes {
	return original.PossibleSnapshotStorageAccountTypesValues()
}
func PossibleStatusLevelTypesValues() []StatusLevelTypes {
	return original.PossibleStatusLevelTypesValues()
}
func PossibleStorageAccountTypesValues() []StorageAccountTypes {
	return original.PossibleStorageAccountTypesValues()
}
func PossibleUpgradeModeValues() []UpgradeMode {
	return original.PossibleUpgradeModeValues()
}
func PossibleUpgradeOperationInvokerValues() []UpgradeOperationInvoker {
	return original.PossibleUpgradeOperationInvokerValues()
}
func PossibleUpgradeStateValues() []UpgradeState {
	return original.PossibleUpgradeStateValues()
}
func PossibleVirtualMachineEvictionPolicyTypesValues() []VirtualMachineEvictionPolicyTypes {
	return original.PossibleVirtualMachineEvictionPolicyTypesValues()
}
func PossibleVirtualMachinePriorityTypesValues() []VirtualMachinePriorityTypes {
	return original.PossibleVirtualMachinePriorityTypesValues()
}
func PossibleVirtualMachineScaleSetSkuScaleTypeValues() []VirtualMachineScaleSetSkuScaleType {
	return original.PossibleVirtualMachineScaleSetSkuScaleTypeValues()
}
func PossibleVirtualMachineSizeTypesValues() []VirtualMachineSizeTypes {
	return original.PossibleVirtualMachineSizeTypesValues()
}
func NewOperationsClient(subscriptionID string) OperationsClient {
	return original.NewOperationsClient(subscriptionID)
}
func NewOperationsClientWithBaseURI(baseURI string, subscriptionID string) OperationsClient {
	return original.NewOperationsClientWithBaseURI(baseURI, subscriptionID)
}
func NewSnapshotsClient(subscriptionID string) SnapshotsClient {
	return original.NewSnapshotsClient(subscriptionID)
}
func NewSnapshotsClientWithBaseURI(baseURI string, subscriptionID string) SnapshotsClient {
	return original.NewSnapshotsClientWithBaseURI(baseURI, subscriptionID)
}
func NewUsageClient(subscriptionID string) UsageClient {
	return original.NewUsageClient(subscriptionID)
}
func NewUsageClientWithBaseURI(baseURI string, subscriptionID string) UsageClient {
	return original.NewUsageClientWithBaseURI(baseURI, subscriptionID)
}
func UserAgent() string {
	return original.UserAgent() + " profiles/latest"
}
func Version() string {
	return original.Version()
}
func NewVirtualMachineExtensionImagesClient(subscriptionID string) VirtualMachineExtensionImagesClient {
	return original.NewVirtualMachineExtensionImagesClient(subscriptionID)
}
func NewVirtualMachineExtensionImagesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineExtensionImagesClient {
	return original.NewVirtualMachineExtensionImagesClientWithBaseURI(baseURI, subscriptionID)
}
func NewVirtualMachineExtensionsClient(subscriptionID string) VirtualMachineExtensionsClient {
	return original.NewVirtualMachineExtensionsClient(subscriptionID)
}
func NewVirtualMachineExtensionsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineExtensionsClient {
	return original.NewVirtualMachineExtensionsClientWithBaseURI(baseURI, subscriptionID)
}
func NewVirtualMachineImagesClient(subscriptionID string) VirtualMachineImagesClient {
	return original.NewVirtualMachineImagesClient(subscriptionID)
}
func NewVirtualMachineImagesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineImagesClient {
	return original.NewVirtualMachineImagesClientWithBaseURI(baseURI, subscriptionID)
}
func NewVirtualMachineRunCommandsClient(subscriptionID string) VirtualMachineRunCommandsClient {
	return original.NewVirtualMachineRunCommandsClient(subscriptionID)
}
func NewVirtualMachineRunCommandsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineRunCommandsClient {
	return original.NewVirtualMachineRunCommandsClientWithBaseURI(baseURI, subscriptionID)
}
func NewVirtualMachinesClient(subscriptionID string) VirtualMachinesClient {
	return original.NewVirtualMachinesClient(subscriptionID)
}
func NewVirtualMachinesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachinesClient {
	return original.NewVirtualMachinesClientWithBaseURI(baseURI, subscriptionID)
}
func NewVirtualMachineScaleSetExtensionsClient(subscriptionID string) VirtualMachineScaleSetExtensionsClient {
	return original.NewVirtualMachineScaleSetExtensionsClient(subscriptionID)
}
func NewVirtualMachineScaleSetExtensionsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetExtensionsClient {
	return original.NewVirtualMachineScaleSetExtensionsClientWithBaseURI(baseURI, subscriptionID)
}
func NewVirtualMachineScaleSetRollingUpgradesClient(subscriptionID string) VirtualMachineScaleSetRollingUpgradesClient {
	return original.NewVirtualMachineScaleSetRollingUpgradesClient(subscriptionID)
}
func NewVirtualMachineScaleSetRollingUpgradesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetRollingUpgradesClient {
	return original.NewVirtualMachineScaleSetRollingUpgradesClientWithBaseURI(baseURI, subscriptionID)
}
func NewVirtualMachineScaleSetsClient(subscriptionID string) VirtualMachineScaleSetsClient {
	return original.NewVirtualMachineScaleSetsClient(subscriptionID)
}
func NewVirtualMachineScaleSetsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetsClient {
	return original.NewVirtualMachineScaleSetsClientWithBaseURI(baseURI, subscriptionID)
}
func NewVirtualMachineScaleSetVMsClient(subscriptionID string) VirtualMachineScaleSetVMsClient {
	return original.NewVirtualMachineScaleSetVMsClient(subscriptionID)
}
func NewVirtualMachineScaleSetVMsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetVMsClient {
	return original.NewVirtualMachineScaleSetVMsClientWithBaseURI(baseURI, subscriptionID)
}
func NewVirtualMachineSizesClient(subscriptionID string) VirtualMachineSizesClient {
	return original.NewVirtualMachineSizesClient(subscriptionID)
}
func NewVirtualMachineSizesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineSizesClient {
	return original.NewVirtualMachineSizesClientWithBaseURI(baseURI, subscriptionID)
}


text:
__author__ = 'Zachary Yocum'
__email__ = 'zyocum@brandeis.edu'

"""Functions for computing Cohen's kappa (𝜅), a measure of inter-annotator
agreement between exactly two annotators."""

import numpy as np

def kappa(data):
    """Computes Cohen's 𝜅 coefficient given a confusion matrix.

        Pr(a) - Pr(e)
    𝜅 = -------------
          1 - Pr(e)

    Where Pr(a) is the percentage of observed agreement and Pr(e) is percentage
    of expected agreement."""
    if len(data.shape) != 2:
        raise ValueError, 'input must be 2-dimensional array'
    if len(set(data.shape)) > 1:
        message = 'array dimensions must be N x N (they are {} x {})'
        raise ValueError, message.format(*data.shape)
    if not issubclass(data.dtype.type, np.integer):
        raise TypeError, 'expected integer type'
    if not np.isfinite(data).all():
        raise ValueError, 'all data must be finite'
    if (data < 0).any():
        raise ValueError, 'all data must be non-negative'
    if np.sum(data) <= 0:
        raise ValueError, 'total data must sum to positive value'
    observation = observed(data)
    expectation = expected(data)
    perfection = 1.0
    k = np.divide(
        observation - expectation,
        perfection - expectation
    )
    return k

def observed(data):
    """Computes the observed agreement, Pr(a), between annotators."""
    total = float(np.sum(data))
    agreed = np.sum(data.diagonal())
    percent_agreement = agreed / total
    return percent_agreement

def expected(data):
    """Computes the expected agreement, Pr(e), between annotators."""
    total = float(np.sum(data))
    annotators = range(len(data.shape))
    percentages = ((data.sum(axis=i) / total) for i in annotators)
    percent_expected = np.dot(*percentages)
    return percent_expected

if __name__ == '__main__':
    # Example data from Pustejovsky and Stubbs
    # Natural Language Annotation for Machine Learning, (p. 127-128)
    #    B   B   B
    #    +   /   -
    data = np.array([
        [54, 28, 3 ], # + A
        [31, 18, 23], # / A
        [0,  21, 72]  # - A
    ])
    labels = ('Matrix', 'Pr(a)', 'Pr(e)', 'kappa')
    separator = ' : '
    width = max(map(len, labels))
    indent = ' ' * (width + len(separator))
    matrix = ('\n' + indent).join(map(str, data))
    values = (matrix, observed(data), expected(data), kappa(data))
    output = ''.join(('{:>', str(width), '}', separator, '{}'))
    print '\n'.join(output.format(*record) for record in zip(labels, values))

redpajama_set_name: RedPajamaGithub


text:
#ifndef CDSUNIT_SET_TEST_MICHAEL_LAZY_RCU_H
#define CDSUNIT_SET_TEST_MICHAEL_LAZY_RCU_H

#include "test_set_rcu.h"
#include <cds/container/lazy_list_rcu.h>
#include <cds/container/michael_set_rcu.h>

namespace cc = cds::container;

template <class RCU>
class MichaelLazySet: public cds_test::container_set_rcu
{
    typedef cds_test::container_set_rcu base_class;
public:
    typedef cds::urcu::gc<RCU> rcu_type;

protected:
    void SetUp()
    {
        RCU::Construct();
        cds::threading::Manager::attachThread();
    }

    void TearDown()
    {
        cds::threading::Manager::detachThread();
        RCU::Destruct();
    }
};

TYPED_TEST_CASE_P( MichaelLazySet );

TYPED_TEST_P( MichaelLazySet, compare )
{
    typedef typename TestFixture::rcu_type rcu_type;
    typedef typename TestFixture::int_item int_item;

    typedef cc::LazyList< rcu_type, int_item,
        typename cc::lazy_list::make_traits<
            cds::opt::compare< typename TestFixture::cmp >
        >::type
    > list_type;

    typedef cc::MichaelHashSet< rcu_type, list_type,
        typename cc::michael_set::make_traits<
            cds::opt::hash< typename TestFixture::hash_int >
        >::type
    > set_type;

    set_type s( TestFixture::kSize, 2 );
    this->test( s );
}

TYPED_TEST_P( MichaelLazySet, less )
{
    typedef typename TestFixture::rcu_type rcu_type;
    typedef typename TestFixture::int_item int_item;

    typedef cc::LazyList< rcu_type, int_item,
        typename cc::lazy_list::make_traits<
            cds::opt::less< typename TestFixture::less >
        >::type
    > list_type;

    typedef cc::MichaelHashSet< rcu_type, list_type,
        typename cc::michael_set::make_traits<
            cds::opt::hash< typename TestFixture::hash_int >
        >::type
    > set_type;

    set_type s( TestFixture::kSize, 2 );
    this->test( s );
}

TYPED_TEST_P( MichaelLazySet, cmpmix )
{
    typedef typename TestFixture::rcu_type rcu_type;
    typedef typename TestFixture::int_item int_item;

    struct list_traits : public cc::lazy_list::traits
    {
        typedef typename TestFixture::less less;
        typedef typename TestFixture::cmp compare;
    };
    typedef cc::LazyList< rcu_type, int_item, list_traits > list_type;

    typedef cc::MichaelHashSet< rcu_type, list_type,
        typename cc::michael_set::make_traits<
            cds::opt::hash< typename TestFixture::hash_int >
        >::type
    > set_type;

    set_type s( TestFixture::kSize, 2 );
    this->test( s );
}

TYPED_TEST_P( MichaelLazySet, item_counting )
{
    typedef typename TestFixture::rcu_type rcu_type;
    typedef typename TestFixture::int_item int_item;

    struct list_traits : public cc::lazy_list::traits
    {
        typedef typename TestFixture::cmp compare;
    };
    typedef cc::LazyList< rcu_type, int_item, list_traits > list_type;

    struct set_traits: public cc::michael_set::traits
    {
        typedef typename TestFixture::hash_int hash;
        typedef typename TestFixture::simple_item_counter item_counter;
    };
    typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type;

    set_type s( TestFixture::kSize, 3 );
    this->test( s );
}

TYPED_TEST_P( MichaelLazySet, backoff )
{
    typedef typename TestFixture::rcu_type rcu_type;
    typedef typename TestFixture::int_item int_item;

    struct list_traits : public cc::lazy_list::traits
    {
        typedef typename TestFixture::cmp compare;
        typedef cds::backoff::exponential<cds::backoff::pause, cds::backoff::yield> back_off;
    };
    typedef cc::LazyList< rcu_type, int_item, list_traits > list_type;

    struct set_traits : public cc::michael_set::traits
    {
        typedef typename TestFixture::hash_int hash;
        typedef cds::atomicity::item_counter item_counter;
    };
    typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type;

    set_type s( TestFixture::kSize, 4 );
    this->test( s );
}

TYPED_TEST_P( MichaelLazySet, seq_cst )
{
    typedef typename TestFixture::rcu_type rcu_type;
    typedef typename TestFixture::int_item int_item;

    struct list_traits : public cc::lazy_list::traits
    {
        typedef typename TestFixture::less less;
        typedef cds::backoff::pause back_off;
        typedef cds::opt::v::sequential_consistent memory_model;
    };
    typedef cc::LazyList< rcu_type, int_item, list_traits > list_type;

    struct set_traits : public cc::michael_set::traits
    {
        typedef typename TestFixture::hash_int hash;
        typedef cds::atomicity::item_counter item_counter;
    };
    typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type;

    set_type s( TestFixture::kSize, 4 );
    this->test( s );
}

TYPED_TEST_P( MichaelLazySet, mutex )
{
    typedef typename TestFixture::rcu_type rcu_type;
    typedef typename TestFixture::int_item int_item;

    struct list_traits : public cc::lazy_list::traits
    {
        typedef typename TestFixture::less less;
        typedef cds::backoff::pause back_off;
        typedef std::mutex lock_type;
    };
    typedef cc::LazyList< rcu_type, int_item, list_traits > list_type;

    struct set_traits : public cc::michael_set::traits
    {
        typedef typename TestFixture::hash_int hash;
        typedef cds::atomicity::item_counter item_counter;
    };
    typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type;

    set_type s( TestFixture::kSize, 4 );
    this->test( s );
}

TYPED_TEST_P( MichaelLazySet, stat )
{
    typedef typename TestFixture::rcu_type rcu_type;
    typedef typename TestFixture::int_item int_item;

    struct list_traits: public cc::lazy_list::traits
    {
        typedef typename TestFixture::less less;
        typedef cds::backoff::pause back_off;
        typedef cc::lazy_list::stat<> stat;
    };
    typedef cc::LazyList< rcu_type, int_item, list_traits > list_type;

    struct set_traits: public cc::michael_set::traits
    {
        typedef typename TestFixture::hash_int hash;
        typedef cds::atomicity::item_counter item_counter;
    };
    typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type;

    set_type s( TestFixture::kSize, 4 );
    this->test( s );
    EXPECT_GE( s.statistics().m_nInsertSuccess, 0u );
}

TYPED_TEST_P( MichaelLazySet, wrapped_stat )
{
    typedef typename TestFixture::rcu_type rcu_type;
    typedef typename TestFixture::int_item int_item;

    struct list_traits: public cc::lazy_list::traits
    {
        typedef typename TestFixture::less less;
        typedef cds::backoff::pause back_off;
        typedef cc::lazy_list::wrapped_stat<> stat;
    };
    typedef cc::LazyList< rcu_type, int_item, list_traits > list_type;

    struct set_traits: public cc::michael_set::traits
    {
        typedef typename TestFixture::hash_int hash;
        typedef cds::atomicity::item_counter item_counter;
    };
    typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type;

    set_type s( TestFixture::kSize, 4 );
    this->test( s );
    EXPECT_GE( s.statistics().m_nInsertSuccess, 0u );
}

// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as
// "No test named <test_name> can be found in this test case"
REGISTER_TYPED_TEST_CASE_P( MichaelLazySet,
    compare, less, cmpmix, item_counting, backoff, seq_cst, mutex, stat, wrapped_stat
);

#endif // CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_LAZY_RCU_H


text:
using std::ifstream;

#include <string>
using std::string;

#include <vector>
using std::vector;

#include "City.hpp"
#include "Population.hpp"

class ImportData {
public:
    ImportData(string);
    vector<City> getCitiesCoord();
    string gettspName();
    string getType();
    string getedge_type();
    string getnode_comment();
    string getcomment();
    void printInfos();
    string getInfos();

    void setEdge_Type(string);

    Population importFirstPopulation(string, unsigned);

private:
    string tspName = "N/A";
    string type = "N/A";
    string comment = "";
    string edge_type = "N/A";
    string node_comment = "N/A";
    string flag;
    string flagaux;
    ifstream myfile;
    vector<City> citiescoord;
    int dimension;
    void regexManager(string);
    bool findIgnoredWords(string);
    void reader(string, string);
    vector<string> explode(string const & s, char delim);
};

#endif


text:
if [[ -z $1 ]]; then
        echo "No argument provided.."
        echo "Usage: $0 tag-source-class-name [<more-arguments>]"
        exit -1;
fi
action=$1
className=
realScriptPath=`readlink -f $0`
realScriptDir=`dirname $realScriptPath`
cd $realScriptDir
cdir=`pwd`

if [ "${action}" == "file" ]; then
	action=file
	className=org.apache.ranger.tagsync.source.file.FileTagSource

elif [ "${action}" == "atlasrest" ]; then
	action=atlasrest
	className=org.apache.ranger.tagsync.source.atlasrest.AtlasRESTTagSource
else
	className=${action}
fi

shift

if [ -f ${cdir}/conf/java_home.sh ]; then
	. ${cdir}/conf/java_home.sh
fi

for custom_env_script in `find ${cdir}/conf.dist/ -name "ranger-tagsync-env*"`; do
       	if [ -f $custom_env_script ]; then
               	. $custom_env_script
        fi
done

if [ "$JAVA_HOME" != "" ]; then
       	export PATH=$JAVA_HOME/bin:$PATH
fi

logdir=/var/log/ranger/tagsync-$action

if [ ! -d $logdir ]; then
	mkdir -p $logdir
	chmod 777 $logdir
fi

cp="${cdir}/conf:${cdir}/dist/*:${cdir}/lib/*"

cd ${cdir}
umask 0077

java -Dproc_rangertagsync-${action} ${JAVA_OPTS} -Dlogdir="${logdir}" -Dlog4j.configuration=file:/etc/ranger/tagsync/conf/log4j.properties -cp "${cp}" ${className} $* > ${logdir}/tagsync.out 2>&1


text:
package org.openspaces.core.space.mode;

/**
 * Enables beans implementing this interface to get notified before a space changes its mode to
 * {@link com.gigaspaces.cluster.activeelection.SpaceMode#PRIMARY}.
 *
 * @author shaiw
 */
public interface SpaceBeforePrimaryListener {

    void onBeforePrimary(BeforeSpaceModeChangeEvent event);
}


text:
ActiveSupport.on_load(:active_record) do
  unless ActiveRecord::Migration.respond_to?(:[])
    ActiveRecord::Migration.define_singleton_method(:[]) do |version|
      self if version.to_s.starts_with?('4')
    end
  end
end


text:
Implicit conversions are applied to transform an expression `e` into
some destination type `T`. This section describes the semantics of
these conversions.

A *conversion sequence* consists of a set of conversions
applied in the following order:

- Zero or one type promotions.
- Zero or one type conversions.
- Zero or one value transformations.

A *type promotion* changes the type of a value without modifying
it's underlying representation. The type promotions are:
enumeration promotion, ...

A *type conversion* allows the widening of a value to a type
that represents a broader set of values, or the reinterpretation
of a value as a different kind (e.g., signed to unsigned integer).

A *value transformation* modifies the representation of as
value, but not its interpretation.

## Boolean promotion

A value of type bool can be converted to a value of type int.

## Enumeration promotion

A value of enumeration type can be converted to value of its
underlying type. Note that this conversion is conceptual;
it does not alter the bit pattern of the source value.

## Integer conversion

A value of integer type can be converted to a value of a
different integer type with the byte order whose precision
is greater than or equal to that of the source integer.

When the precision of the destination type is greater than
that of the source type, the source value is first promoted
to a greater precision.

This allows signed integers to be converted to unsigned
integers, but this does not change the underlying pattern
of bits after promotiohn.

## Tuple conversion

A value of tuple type can be converted to the value of a record
type, where the type of each member matches the type of the
corresponding elements in the tuple value.

TODO: If we have constructors, we need to verify that there
is a suitable constructor that accepts a tuple -- or an
initializer list or some such thing.

TODO: Allow for integer values to initialize bitfields. Note
that truncation may occur!

## Integer transformation

A value of integer type can be converted to a value of a
different integer type with the same signedness and precision
but a different byte ordering.

This allows the following:

    def f(n : intm32);

    f(0); // OK: implicit byte order conversion

## Boolean conversions

In certain contexts, an expression may be converted to `bool`.

The expression is first promoted.

A promoted integer value can be converted to `bool`. If the integer
value is `0`, the converted value is `false`. Otherwise, the converted
value is `true`.

TODO: What else can be converted to bool?

## Conversion to a common type

The *common type* of two expressions E1 and E2 is a type T to
which both E1 and E2 can be converted. Note that T may be the
type of E1, the type of E2, or some other type. The common type of E1
and E2 is found by a sequence of conversions to E1 and E2 that
would coause them to have the same type. That sequence is defined
as follows:

- If E1 and E2 have the same type, then no conversions are applied.

- Promote both E1 and E2. The following rules are applied to the
  promoted expressions. If, after promotion, E1 and E2 have the
  same type, no further conversions are applied.

- If both promoted expressions are integer expressions, see the
  rules below for finding the common type of integer expressions.

- Otherwise, the expressions cannot be converted to a common type.

TODO: Verify that the rules for conversion to common type will
allow implicit conversion from either expression to the common
type.

### Common type of integer expressions.

The following rules are used to convert integer expressions E1 and
E2 to a common type.

- Both E1 and E2 are converted to native byte order. If, after
  conversion, the converted expressions have the same type,
  no further conversions are applied.

- If the converted expressions have the same signedness the expression
  with the least precision is converted to the expression with the greater
  precision.

- Otherwise, both expressions are converted to an unsigned integer
  type whose precision is the greatest precision of either expression.

### Common type of ...


text:
angular.module('Sala', [
	'ngResource',
	]);


text:
<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
    $CI = & get_instance();

    $action_data=array();
    if(isset($CI->permissions['edit'])&&($CI->permissions['edit']==1))
    {
        $action_data["action_edit"]=base_url($CI->controller_url."/index/edit");
    }
    if(isset($CI->permissions['view'])&&($CI->permissions['view']==1))
    {
        $action_data["action_details"]=base_url($CI->controller_url."/index/details");
    }
    if(isset($CI->permissions['print'])&&($CI->permissions['print']==1))
    {
        $action_data["action_print"]='PO LIST';
    }
    if(isset($CI->permissions['download'])&&($CI->permissions['download']==1))
    {
        $action_data["action_csv"]='PO LIST';
    }

    $action_data["action_refresh"]=base_url($CI->controller_url."/index/list");
    $CI->load->view("action_buttons",$action_data);
?>

            <?php echo $title; ?>

    <?php
    if(isset($CI->permissions['column_headers'])&&($CI->permissions['column_headers']==1))
    {

        ?>

            <input type="checkbox" class="system_jqx_column"  checked value="po_no"><?php echo $CI->lang->line('LABEL_PO_NO'); ?>
            <input type="checkbox" class="system_jqx_column"  checked value="name"><?php echo $CI->lang->line('LABEL_NAME'); ?>
            <input type="checkbox" class="system_jqx_column"  checked value="date_po"><?php echo $CI->lang->line('LABEL_DATE_PO'); ?>
            <input type="checkbox" class="system_jqx_column"  checked value="customer_code"><?php echo $CI->lang->line('LABEL_CUSTOMER_CODE'); ?>
            <input type="checkbox" class="system_jqx_column"  checked value="division_name"><?php echo $CI->lang->line('LABEL_DIVISION_NAME'); ?>
            <input type="checkbox" class="system_jqx_column"  checked value="zone_name"><?php echo $CI->lang->line('LABEL_ZONE_NAME'); ?>
            <input type="checkbox" class="system_jqx_column"  checked value="territory_name"><?php echo $CI->lang->line('LABEL_TERRITORY_NAME'); ?>
            <input type="checkbox" class="system_jqx_column"  checked value="district_name"><?php echo $CI->lang->line('LABEL_DISTRICT_NAME'); ?>
            <input type="checkbox" class="system_jqx_column"  checked value="quantity_total"><?php echo $CI->lang->line('LABEL_QUANTITY_PIECES'); ?>
            <input type="checkbox" class="system_jqx_column"  checked value="quantity_weight"><?php echo $CI->lang->line('LABEL_WEIGHT_KG'); ?>
            <input type="checkbox" class="system_jqx_column"  checked value="status_received"><?php echo $CI->lang->line('LABEL_RECEIVED'); ?>

        <?php
    }
    ?>


text:
import re
from .base_linter import BaseLinter

CONFIG = {
    'language': 'Lua',
    'executable': 'luac',
    'lint_args': ['-p', '-'],
}

class Linter(BaseLinter):

    def parse_errors(self, view, errors, lines, errorUnderlines, violationUnderlines, warningUnderlines, errorMessages, violationMessages, warningMessages):
        for line in errors.splitlines():
            match = re.match(r'^.+:(?P<line>\d+):\s+(?P<error>.+)', line)

            if match:
                error, line = match.group('error'), match.group('line')
                self.add_message(int(line), lines, error, errorMessages)


text:
<?php

namespace PHP\Util;

\ClassLoader::import('PHP\Lang\Object');
\ClassLoader::import('PHP\Lang\TypeError');
\ClassLoader::import('PHP\Lang\ValueError');

class Random extends \PHP\Lang\Object {
	const NUMBER_METHOD_AUTO=0;
	const NUMBER_METHOD_RAND=1;
	const NUMBER_METHOD_MTRAND=2;
	const STRING_METHOD_AUTO=0;
	const STRING_METHOD_TIME=1;
	const STRING_METHOD_UNIQID=2;
	const STRING_METHOD_OPENSSL=3;

	/**
	 * Generate a pseudo-random number between $min and $max. If possible,
	 * this function will use mt_rand() for random number generation. Otherwise
	 * it will fall back to rand(), which uses the libc random number generator.
	 * @param  double $min
	 * @param  double $max
	 * @param  int    $method default \PHP\Util\Random::NUMBER_METHOD_AUTO
	 *                        Random generator method to use. If not available,
	 *                        fallback to auto.
	 * @return double
	 */
	static function pseudoNumber($min = 0, $max = 1,
		$method = self::NUMBER_METHOD_AUTO) {
		if (!\is_numeric($min)) {
			throw new \PHP\Lang\TypeError($min, 'number');
		}
		if (!\is_numeric($max)) {
			throw new \PHP\Lang\TypeError($max, 'number');
		}
		switch ($method) {
			case self::NUMBER_METHOD_AUTO:
			case self::NUMBER_METHOD_MTRAND:
				if (\function_exists('\mt_rand')) {
					$value = \mt_rand();
					$maxvalue = \mt_getrandmax();
					break;
				}
			case self::NUMBER_METHOD_RAND:
				$value = \rand();
				$maxvalue = \getrandmax();
				break;
			default:
				throw new \PHP\Lang\ValueError($method, 'One of the NUMBER_METHOD_* constants');
		}
		return (double)($min + $value * (($max - $min) / $maxvalue));
	}

	/**
	 * Generate a pseudo-random string in the given length. This string is NOT
	 * suitable for cryptographic purposes! Use the \PHPx\Crypto library for
	 * that!
	 * @param  integer $length      default 23
	 * @param  integer $method      default \PHP\Util\Random::STRING_METHOD_AUTO
	 *                              The method to use for random string
	 *                              generation. Falls back to default if the
	 *                              method is not available.
	 * @return string
	 * @throws \PHP\Lang\TypeError  if length is not an integer
	 * @throws \PHP\Lang\ValueError if length is smaller than 1
	 */
	static function pseudoString($length = 23, $method = self::STRING_METHOD_AUTO) {
		if (!\is_integer($length)) {
			throw new \PHP\Lang\TypeError($length, 'integer');
		}
		if ($length < 0) {
			throw new \PHP\Lang\ValueError($length, 'number larger than 0');
		}
		$string = '';
		switch ($method) {
			case self::STRING_METHOD_AUTO:
			case self::STRING_METHOD_OPENSSL:
				if (\function_exists('\openssl_random_pseudo_bytes')) {
					$string = \openssl_random_pseudo_bytes($length, $strong);
					break;
				}
			case self::STRING_METHOD_UNIQID:
				while (\strlen($string) < $length) {
					$string .= \uniqid('', true);
				}
				$string = \substr($string, 0, $length);
				break;
			case self::STRING_METHOD_TIME:
				while (\strlen($string) < $length) {
					$string .= \md5(\time());
				}
				$string = \substr($string, 0, $length);
				break;
			default:
				throw new \PHP\Lang\ValueError($method, 'One of the STRING_METHOD_* constants');
		}
		return $string;
	}
}


text:
package com.englishtown.vertx.jersey.examples.guice.resources;

import com.englishtown.vertx.jersey.examples.guice.MyDependency;

import javax.inject.Inject;
import javax.inject.Singleton;
import javax.ws.rs.GET;
import javax.ws.rs.Path;

/**
 * Guice JAX-RS endpoint
 */
@Singleton
@Path("guice")
public class GuiceTestResource {

    private final MyDependency myDependency;

    @Inject
    public GuiceTestResource(MyDependency myDependency) {
        this.myDependency = myDependency;
    }

    @GET
    public String doGet() {
        return "Instance of " + myDependency.getClass().getName() + " injected!";
    }

}


text:
namespace Anycmd.Engine.Edi.Messages
{
    using Engine.Messages;
    using Commands;

    // TODO:在界面上添加创建运行时本体元素的按钮
    public sealed class AddSystemElementCommand : Command, IAnycmdCommand
    {
        public AddSystemElementCommand(IAcSession acSession)
        {
            this.AcSession = acSession;
        }

        public IAcSession AcSession { get; private set; }
    }
}


text:
import math
import time
import xml.dom.minidom as minidom

FUZZY_NOW = 1
FUZZY_MINS = 2
FUZZY_TIME = 3

def fuzzy_departure(dep, mins_cutoff=10, time_format="%H.%M"):
    """Makes a fuzzy representation of the time to wait. Returns a tuple
    containing (result_type, result).

    If the wait time is less than one minute returns (FUZZY_NOW, "Now").
    If the wait time is less than mins_cutoff (in minutes), returns
    (FUZZY_MINS, number_of_minutes_to_wait)
    If the wait time is equal or greater than mins_cutoff returns
    (FUZZY_TIME, time_for_departure). The time will be formated according
    to time_format, which is in the format of time.striftime."""
    wait = int(dep["wait_time"])
    if wait < 60:
        return (FUZZY_NOW, None)
    elif wait < mins_cutoff*60:
        return (FUZZY_MINS, int(math.floor(wait/60)))
    else:
        return (FUZZY_TIME, time.strftime(time_format, dep["time"]))

def make_human_readable_stations(res):
    """Makes  text representation of a search result that is suitable for
    showing to a user. Returns a string"""
    ret = []
    if not res:
        ret.append( u"""No stations found""")
    else:
        format = u"%%(id)%ds %%(name)s (%%(district)s)" % \
                                max([ len(e["id"]) for e in res ])
        for dep in res:
            ret.append(format % dep)
    return "\n".join(ret)

def make_delimited_stations(res, header=False, separator=";"):
    """Emit station search result delimited by separator. If header is
    true, include field names as the first line, using same delimiter.
    """
    if not res:
        return ""

    separator = unicode(separator)

    format = separator.join(("%(id)s", "%(name)s", "%(district)s",
              "%(xcoord)s", "%(ycoord)s"))

    ret = []
    if header:
        ret.append(
            separator.join(("id", "name", "district", "xcoord", "ycoord")))

    for dep in res:
        ret.append(format % dep)

    return "\n".join(ret)

def make_xml_stations(res):
    """Serialize as search result in res to xml. Returns xml as a string.
    Format of xml is as follows:
    <stations>
        <station>
            <id>123123</id>
            <name>asdf</name
            <disctrict>Oslo</district>

            fixme: more

    """

    impl = minidom.getDOMImplementation()
    document = impl.createDocument(None, "stations", None)
    body = document.documentElement
    for hit in res:
        station = document.createElement("station")
        for key, val in hit.items():
            ele = document.createElement(key)
            ele.appendChild(document.createTextNode(val))
            station.appendChild(ele)
        body.appendChild(station)

    pretty = document.toprettyxml()
    # fixme: minidom docs says this is needed due to bugs with cyclic gc.
    # Is this still the case though?
    document.unlink()

    return pretty

def make_delimited_realtime(res, header=False, separator=";"):
    """Emit realtimeresult delimited by separator. If header is true, include
    field names as the first line, using same delimiter
    """
    if not res:
        return ""

    clean_res = [
        { "id": e["id"],
          "destination": e["destination"],
          "direction": e["direction"],
          "is_realtime": str(int(e["is_realtime"])),
          "wait_time": e["wait_time"],
          "time": time.asctime(e["time"])
        } for e in res
    ]

    format = separator.join(("%(id)s", "%(destination)s", "%(direction)s",
              "%(is_realtime)s", "%(wait_time)s", "%(time)s"))

    ret = []
    if header:
        ret.append(separator.join(("id", "destination", "direction",
                              "is_realtime", "wait_time", "time")))
    for dep in clean_res:
        ret.append(format % dep)

    return "\n".join(ret)

def make_human_readable_realtime(res):
    if not res:
        return """No departures found for station."""
    else:
        format = u"""%%(id)%ds %%(destination)-%ds %%(formatted_wait)-5s""" % \
                 (max([ len(e["id"]) for e in res ]),
                  max([ len(e["destination"]) for e in res ]))
        ret = []
        for dep in res:
            curdep = {"id": dep["id"], "destination": dep["destination"]}
            fuzz, val = fuzzy_departure(dep)

            if fuzz == FUZZY_NOW:
                curdep["formatted_wait"] = u"Now"
            elif fuzz == FUZZY_MINS and val == 1:
                curdep["formatted_wait"] = u"1 min"
            elif fuzz == FUZZY_MINS:
                curdep["formatted_wait"] = u"%d mins" % val
            else:
                curdep["formatted_wait"] = val

            ret.append(format % curdep)

    return "\n".join(ret)

def make_xml_realtime(res):
    """Serialize realtime data in res to xml. Returns xml as a string.
    Format of xml is as follows:
    <realtime>
        <departure>
            <id>123123</id>
            <name>asdf</name
            <time>result from time.asctime</time>
            <is_realtime>yes|no</is_realtime>
            <wait_time>234</wait_time>
            fixme: more

    """
    impl = minidom.getDOMImplementation()

    type_mapper = {
        "time": lambda t: time.asctime(t),
        "wait_time": unicode,
        "is_realtime": lambda b: u"yes" if b else u"no"
    }

    document = impl.createDocument(None, "realtime", None)
    body = document.documentElement
    for hit in res:
        departure = document.createElement("departure")
        for key, val in hit.items():
            ele = document.createElement(key)
            if key in type_mapper:
                ele.appendChild(document.createTextNode(type_mapper[key](val)))
            else:
                ele.appendChild(document.createTextNode(val))
            departure.appendChild(ele)
        body.appendChild(departure)

    pretty = document.toprettyxml()

    # fixme: minidom docs says this is needed due to bugs with cyclic gc.
    # Is this still the case though?
    document.unlink()
    return pretty

def utm_to_lat_lng(easting, northing, zone=32, northernHemisphere=True):
    """Converts from utm to lat_lng. Default zone is the one in which
    Oslo and Akershus falls."""
    if not northernHemisphere:
        northing = 10000000 - northing

    a = 6378137
    e = 0.081819191
    e1sq = 0.006739497
    k0 = 0.9996

    arc = northing / k0
    mu = arc / (a * (1 - math.pow(e, 2) / 4.0 - 3 * math.pow(e, 4) / 64.0 - 5 * math.pow(e, 6) / 256.0))

    ei = (1 - math.pow((1 - e * e), (1 / 2.0))) / (1 + math.pow((1 - e * e), (1 / 2.0)))

    ca = 3 * ei / 2 - 27 * math.pow(ei, 3) / 32.0

    cb = 21 * math.pow(ei, 2) / 16 - 55 * math.pow(ei, 4) / 32
    cc = 151 * math.pow(ei, 3) / 96
    cd = 1097 * math.pow(ei, 4) / 512
    phi1 = mu + ca * math.sin(2 * mu) + cb * math.sin(4 * mu) + cc * math.sin(6 * mu) + cd * math.sin(8 * mu)

    n0 = a / math.pow((1 - math.pow((e * math.sin(phi1)), 2)), (1 / 2.0))

    r0 = a * (1 - e * e) / math.pow((1 - math.pow((e * math.sin(phi1)), 2)), (3 / 2.0))
    fact1 = n0 * math.tan(phi1) / r0

    _a1 = 500000 - easting
    dd0 = _a1 / (n0 * k0)
    fact2 = dd0 * dd0 / 2

    t0 = math.pow(math.tan(phi1), 2)
    Q0 = e1sq * math.pow(math.cos(phi1), 2)
    fact3 = (5 + 3 * t0 + 10 * Q0 - 4 * Q0 * Q0 - 9 * e1sq) * math.pow(dd0, 4) / 24

    fact4 = (61 + 90 * t0 + 298 * Q0 + 45 * t0 * t0 - 252 * e1sq - 3 * Q0 * Q0) * math.pow(dd0, 6) / 720

    lof1 = _a1 / (n0 * k0)
    lof2 = (1 + 2 * t0 + Q0) * math.pow(dd0, 3) / 6.0
    lof3 = (5 - 2 * Q0 + 28 * t0 - 3 * math.pow(Q0, 2) + 8 * e1sq + 24 * math.pow(t0, 2)) * math.pow(dd0, 5) / 120
    _a2 = (lof1 - lof2 + lof3) / math.cos(phi1)
    _a3 = _a2 * 180 / math.pi

    latitude = 180 * (phi1 - fact1 * (fact2 + fact3 + fact4)) / math.pi

    if not northernHemisphere:
        latitude = -latitude

    longitude = ((zone > 0) and (6 * zone - 183.0) or 3.0) - _a3

    return (latitude, longitude)


text:
package mobi.cangol.mobile.soap;

import android.content.Context;
import android.util.Log;

import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
import org.kxml2.kdom.Element;
import org.kxml2.kdom.Node;

import java.lang.ref.WeakReference;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.Future;

import mobi.cangol.mobile.service.PoolManager;

/**
 * SoapClient.java 使用此类需要ksoap2-android-assembly-3.0.0-jar-with-dependencies.jar
 *
 * @author Cangol
 */
public class SoapClient {
    private static final String TAG = "SoapRequest";
    private static final int TIMEOUT = 20 * 1000;
    private final Map<Context, List<WeakReference<Future<?>>>> requestMap;
    private SoapSerializationEnvelope envelope;
    private PoolManager.Pool threadPool;

    public SoapClient() {
        threadPool = PoolManager.buildPool(TAG, 3);
        requestMap = new WeakHashMap<>();
        envelope = new SoapSerializationEnvelope(SoapEnvelope.VER12);
        envelope.dotNet = true;
    }

    /**
     * 添加header
     *
     * @param namespace
     * @param authheader
     * @param headers
     */
    public void addHeader(String namespace, String authheader, Map<String, String> headers) {
        if (authheader != null && headers != null) {
            envelope.headerOut = new Element[1];
            envelope.headerOut[0] = buildAuthHeader(namespace, authheader, headers);
        }
    }

    /**
     * 执行请求
     *
     * @param context
     * @param url
     * @param namespace
     * @param action
     * @param params
     * @param responseHandler
     */
    public void send(Context context, String url, String namespace, String action, Map<String, String> params, SoapResponseHandler responseHandler) {

        if (params != null) {
            final StringBuilder paramsStr = new StringBuilder(url);
            paramsStr.append('/')
                    .append(action);
            if (params.size() > 0) {
                paramsStr.append('?');
            }
            final SoapObject rpc = new SoapObject(namespace, action);
            for (final Map.Entry<String, String> entry : params.entrySet()) {
                rpc.addProperty(entry.getKey(), entry.getValue());
                paramsStr.append(entry.getKey())
                        .append('=')
                        .append(entry.getValue())
                        .append('&');
            }
            Log.d(TAG, "sendRequest " + paramsStr.toString());
            envelope.bodyOut = rpc;
        }
        sendRequest(new HttpTransportSE(url, TIMEOUT), envelope, namespace, responseHandler, context);
    }

    /**
     * 构建auth header
     *
     * @param namespace
     * @param authheader
     * @param params
     * @return
     */
    private Element buildAuthHeader(String namespace, String authheader, Map<String, String> params) {
        final Element header = new Element().createElement(namespace, authheader);
        for (final Map.Entry<String, String> entry : params.entrySet()) {
            final Element element = new Element().createElement(namespace, entry.getKey());
            element.addChild(Node.TEXT, entry.getValue());
            header.addChild(Node.ELEMENT, element);
        }
        return header;
    }

    /**
     * 取消请求
     *
     * @param context
     * @param mayInterruptIfRunning
     */
    public void cancelRequests(Context context, boolean mayInterruptIfRunning) {
        final List<WeakReference<Future<?>>> requestList = requestMap.get(context);
        if (requestList != null) {
            for (final WeakReference<Future<?>> requestRef : requestList) {
                final Future<?> request = requestRef.get();
                if (request != null) {
                    request.cancel(mayInterruptIfRunning);
                }
            }
        }
        requestMap.remove(context);
    }

    /**
     * 发生请求
     *
     * @param ht
     * @param envelope
     * @param namespace
     * @param responseHandler
     * @param context
     */
    protected void sendRequest(HttpTransportSE ht, SoapSerializationEnvelope envelope,
                               String namespace, SoapResponseHandler responseHandler, Context context) {

        final Future<?> request = threadPool.submit(new SoapRequest(ht, envelope, namespace, responseHandler));

        if (context != null) {
            // Add request to request map
            List<WeakReference<Future<?>>> requestList = requestMap.get(context);
            if (requestList == null) {
                requestList = new LinkedList<>();
                requestMap.put(context, requestList);
            }
            requestList.add(new WeakReference<Future<?>>(request));
        }
    }
}


text:
package org.bitsofinfo.s3.control;

import java.net.InetAddress;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import org.apache.log4j.Logger;

import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.policy.Policy;
import com.amazonaws.auth.policy.Principal;
import com.amazonaws.auth.policy.Resource;
import com.amazonaws.auth.policy.Statement;
import com.amazonaws.auth.policy.Statement.Effect;
import com.amazonaws.auth.policy.actions.SQSActions;
import com.amazonaws.auth.policy.conditions.ConditionFactory;
import com.amazonaws.services.sns.AmazonSNSClient;
import com.amazonaws.services.sns.model.CreateTopicResult;
import com.amazonaws.services.sns.model.ListTopicsResult;
import com.amazonaws.services.sns.model.SubscribeResult;
import com.amazonaws.services.sns.model.Topic;
import com.amazonaws.services.sqs.AmazonSQSClient;
import com.amazonaws.services.sqs.model.CreateQueueResult;
import com.amazonaws.services.sqs.model.Message;
import com.amazonaws.services.sqs.model.ReceiveMessageRequest;
import com.amazonaws.services.sqs.model.ReceiveMessageResult;
import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

public class ControlChannel implements Runnable {

	private static final Logger logger = Logger.getLogger(ControlChannel.class);

	private AmazonSNSClient snsClient = null;
	private AmazonSQSClient sqsClient = null;

	private String snsTopicARN = null;
	private String snsSubscriptionARN = null;
	private String sqsQueueUrl = null;
	private String sqsQueueARN = null;

	private Gson gson = new Gson();

	private CCPayloadHandler ccPayloadHandler = null;
	private String mySourceIdentifier = null;
	private String mySourceIp = null;
	private Thread consumerThread = null;

	private boolean canDestroyTopic = false;

	private boolean running = true;
	private String snsControlTopicName = null;

	private String uuid = UUID.randomUUID().toString().replace("-", "").substring(0,4);;

	public ControlChannel(boolean callerIsMaster,
						  String awsAccessKey, String awsSecretKey, String snsControlTopicName,
						  String userAccountPrincipalId,
						  String userARN,
						  CCPayloadHandler ccPayloadHandler) throws Exception {
		super();

		try {
			this.mySourceIp = InetAddress.getLocalHost().getHostAddress();
		} catch(Exception e) {
			logger.error("Error getting local inet address: " + e.getMessage());
		}

		mySourceIdentifier = determineHostName() + "-" +uuid;
		this.snsControlTopicName = snsControlTopicName;

		if (callerIsMaster) {
			canDestroyTopic = true;
			this.snsControlTopicName += "-" + mySourceIdentifier;
		}

		this.ccPayloadHandler = ccPayloadHandler;

		sqsClient = new AmazonSQSClient(new BasicAWSCredentials(awsAccessKey, awsSecretKey));
		snsClient = new AmazonSNSClient(new BasicAWSCredentials(awsAccessKey, awsSecretKey));

		this.connectToTopic(callerIsMaster, 1000, userAccountPrincipalId, userARN);

	}

	public void connectToTopic(boolean callerIsMaster, int maxAttempts, String userAccountPrincipalId, String userARN) throws Exception {

		// try up to max attempts to connect to pre-existing topic
		for (int i=0; i<maxAttempts; i++) {

			logger.debug("connectToTopic() attempt: " + (i+1));

			ListTopicsResult listResult = snsClient.listTopics();
			List<Topic> topics = listResult.getTopics();

			while(topics != null) {

				for (Topic topic : topics) {

					// note we do index of match....
					if (topic.getTopicArn().indexOf(snsControlTopicName) != -1) {
						snsTopicARN = topic.getTopicArn();
						logger.info("Found existing SNS topic by name: "+snsControlTopicName + " @ " + snsTopicARN);
						break;
					}
				}

				String nextToken = listResult.getNextToken();

				if (nextToken != null && snsTopicARN == null) {
					listResult = snsClient.listTopics(nextToken);
					topics = listResult.getTopics();

				} else {
					break;
				}
			}

			// if consumer, retry, otherwise is master, so just exit quick to create...
			if (snsTopicARN == null && !callerIsMaster) {
				Thread.currentThread().sleep(1000);
				continue;
			} else {
				break; // exit;
			}
		}

		// if master only he can create...
		if (snsTopicARN == null && callerIsMaster) {
			this.snsControlTopicName = this.snsControlTopicName.substring(0,(snsControlTopicName.length() > 80 ? 80 : this.snsControlTopicName.length()));

			logger.info("Attempting to create new SNS control channel topic by name: "+this.snsControlTopicName);

			CreateTopicResult createTopicResult = snsClient.createTopic(this.snsControlTopicName);
			snsTopicARN = createTopicResult.getTopicArn();
			snsClient.addPermission(snsTopicARN, "Permit_SNSAdd",
									Arrays.asList(new String[]{userARN}),
									Arrays.asList(new String[]{"Publish","Subscribe","Receive"}));
			logger.info("Created new SNS control channel topic by name: "+this.snsControlTopicName + " @ " + snsTopicARN);

		} else if (snsTopicARN == null) {
			throw new Exception("Worker() cannot start, snsControlTopicName has yet to be created by master?: " + this.snsControlTopicName);
		}

		// http://www.jorgjanke.com/2013/01/aws-sns-topic-subscriptions-with-sqs.html

		// create SQS queue to get SNS notifications (max 80 len)
		String prefix =  ("s3bktLoaderCC_" + mySourceIdentifier);
		String sqsQueueName = prefix.substring(0,(prefix.length() > 80 ? 80 : prefix.length()));

		CreateQueueResult createQueueResult = sqsClient.createQueue(sqsQueueName);
		this.sqsQueueUrl = createQueueResult.getQueueUrl();
		this.sqsQueueARN = sqsClient.getQueueAttributes(sqsQueueUrl, Arrays.asList(new String[]{"QueueArn"})).getAttributes().get("QueueArn");

		Statement statement = new Statement(Effect.Allow)
								.withActions(SQSActions.SendMessage)
								 .withPrincipals(new Principal("*"))
								 .withConditions(ConditionFactory.newSourceArnCondition(snsTopicARN))
								 .withResources(new Resource(sqsQueueARN));
		Policy policy = new Policy("SubscriptionPermission").withStatements(statement);

		HashMap<String, String> attributes = new HashMap<String, String>();
		attributes.put("Policy", policy.toJson());
		SetQueueAttributesRequest request = new SetQueueAttributesRequest(sqsQueueUrl, attributes);
		sqsClient.setQueueAttributes(request);

		logger.info("Created SQS queue: " + sqsQueueARN + " @ " + sqsQueueUrl);

		// subscribe our SQS queue to the SNS:s3MountTest topic
		SubscribeResult subscribeResult = snsClient.subscribe(snsTopicARN,"sqs",sqsQueueARN);
		snsSubscriptionARN = subscribeResult.getSubscriptionArn();
		logger.info("Subscribed for messages from SNS control channel:" + snsTopicARN + " ----> SQS: "+sqsQueueARN);
		logger.info("Subscription ARN: " + snsSubscriptionARN);

		this.consumerThread = new Thread(this,"ControlChannel msg consumer thread");
		this.consumerThread.start();

		logger.info("\n-------------------------------------------\n" +
					"CONTROL CHANNEL: ALL SNS/SQS resources hooked up OK\n" +
					"-------------------------------------------\n");
	}

	public void send(boolean fromMaster, CCPayloadType type, Object value) throws Exception {
		this.send(fromMaster,type,null,value);
	}

	public void send(boolean fromMaster, CCPayloadType type, String onlyForHostOrIp, Object value) throws Exception {
		CCPayload payload = new CCPayload();
		payload.fromMaster = fromMaster;
		payload.type = type;
		payload.value = value;
		payload.onlyForHostIdOrIP = onlyForHostOrIp;
		payload.sourceHostId = this.mySourceIdentifier.trim();
		payload.sourceHostIP = this.mySourceIp;

		logger.debug("Sending: " + type + "="+value);

		// send!
		this.snsClient.publish(this.snsTopicARN, gson.toJson(payload));
	}

	public void run() {

		while(running) {

			try {

				ReceiveMessageRequest req = new ReceiveMessageRequest();
				req.setWaitTimeSeconds(10);
				req.setMaxNumberOfMessages(10);
				req.setVisibilityTimeout(300);
				req.setQueueUrl(sqsQueueUrl);

				ReceiveMessageResult msgResult = sqsClient.receiveMessage(req);
				List<Message> messages = msgResult.getMessages();

				for (Message msg : messages) {

					CCPayload payload = null;

					try {
						Map<String,String> body = gson.fromJson(msg.getBody(), new TypeToken<Map<String, String>>(){}.getType());
						payload = gson.fromJson(body.get("Message"), CCPayload.class);

					} catch(Exception e) {
						logger.error("ERROR: unexpected error converting SQS Message " +
								"body (json -> CCPayload) body= " + msg.getBody() + " error="+e.getMessage());

						// delete the message we just analyzed
						sqsClient.deleteMessage(sqsQueueUrl, msg.getReceiptHandle());

						continue;
					}

					// if NOT equal to THIS MACHINE... defer tp payload handler
					if (!payload.sourceHostId.equalsIgnoreCase(mySourceIdentifier))  {
						this.ccPayloadHandler.handlePayload(payload);
					}

					// delete the message we just analyzed
					sqsClient.deleteMessage(sqsQueueUrl, msg.getReceiptHandle());
				}

			} catch(Exception e) {
				logger.error("run() " + e.getMessage(),e);
			}

			try {
				Thread.currentThread().sleep(500);
			} catch(Exception ignore) {}

		}
	}

	public void destroy() throws Exception {

		this.running = false;

		Thread.currentThread().sleep(30000);

		if (snsClient != null) {
			try {
				logger.debug("destroy() unsubscribe " + this.snsSubscriptionARN);
				snsClient.unsubscribe(snsSubscriptionARN);
			} catch(Exception e) {
				logger.debug("destroy() error: " + e.getMessage());
			}
		}

		if (sqsClient != null) {
			try {
				logger.debug("destroy() " + this.sqsQueueUrl);
				sqsClient.deleteQueue(sqsQueueUrl);
			} catch(Exception e) {
				logger.debug("destroy() error: " + e.getMessage());
			}
		}

		if (canDestroyTopic && snsClient != null) {
			try {
				logger.debug("destroy() " + this.snsTopicARN);
				snsClient.deleteTopic(this.snsTopicARN);
			} catch(Exception e) {
				logger.debug("destroy() error: " + e.getMessage());
			}
		}

	}

	public AmazonSNSClient getSnsClient() {
		return snsClient;
	}

	public void setSnsClient(AmazonSNSClient snsClient) {
		this.snsClient = snsClient;
	}

	private static String determineHostName() throws Exception {

		InetAddress addr = InetAddress.getLocalHost();

		// Get IP Address
		byte[] ipAddr = addr.getAddress();
		// Get sourceHost
		String tmpHost = addr.getHostName();

		// we only care about the HOST portion, strip everything else
		// as some boxes report a fully qualified sourceHost such as
		// host.domainname.com

		int firstDot = tmpHost.indexOf('.');
		if (firstDot != -1) {
			tmpHost = tmpHost.substring(0,firstDot);
		}
		return tmpHost;

	}

	public static Logger getLogger() {
		return logger;
	}

	public AmazonSQSClient getSqsClient() {
		return sqsClient;
	}

	public String getSnsTopicARN() {
		return snsTopicARN;
	}

	public String getSnsSubscriptionARN() {
		return snsSubscriptionARN;
	}

	public String getSqsQueueUrl() {
		return sqsQueueUrl;
	}

	public String getSqsQueueARN() {
		return sqsQueueARN;
	}

	public Gson getGson() {
		return gson;
	}

	public CCPayloadHandler getCcPayloadHandler() {
		return ccPayloadHandler;
	}

	public String getMySourceIdentifier() {
		return mySourceIdentifier;
	}

	public Thread getConsumerThread() {
		return consumerThread;
	}

	public String getMySourceIp() {
		return mySourceIp;
	}

}


text:
package org.jboss.weld.lite.extension.translator;

import java.lang.annotation.Annotation;
import java.util.Set;
import java.util.function.Consumer;

class ExtensionPhaseEnhancementAction {
    private final Set<Class<?>> types;
    private final boolean withSubtypes;
    private final Set<Class<? extends Annotation>> withAnnotations;
    private final Consumer<jakarta.enterprise.inject.spi.ProcessAnnotatedType<?>> acceptor;

    ExtensionPhaseEnhancementAction(Set<Class<?>> types, boolean withSubtypes, Set<Class<? extends Annotation>> withAnnotations,
                                    Consumer<jakarta.enterprise.inject.spi.ProcessAnnotatedType<?>> acceptor) {
        this.types = types;
        this.withSubtypes = withSubtypes;
        this.withAnnotations = withAnnotations;
        this.acceptor = acceptor;
    }

    void run(jakarta.enterprise.inject.spi.ProcessAnnotatedType<?> pat) {
        if (satisfies(pat.getAnnotatedType())) {
            acceptor.accept(pat);
        }
    }

    private boolean satisfies(jakarta.enterprise.inject.spi.AnnotatedType<?> inspectedAnnotatedType) {
        Class<?> inspectedClass = inspectedAnnotatedType.getJavaClass();
        if (types.contains(inspectedClass)) {
            return satisfiesAnnotationConstraints(inspectedAnnotatedType);
        } else if (withSubtypes) {
            boolean typeMatches = false;
            for (Class<?> type : types) {
                if (type.isAssignableFrom(inspectedClass)) {
                    typeMatches = true;
                    break;
                }
            }
            return typeMatches && satisfiesAnnotationConstraints(inspectedAnnotatedType);
        } else {
            return false;
        }
    }

    private boolean satisfiesAnnotationConstraints(jakarta.enterprise.inject.spi.AnnotatedType<?> annotatedType) {
        if (withAnnotations.isEmpty()) {
            return true;
        }

        return AnnotationPresence.allAnnotations(annotatedType)
                .anyMatch(it -> {
                    if (withAnnotations.contains(Annotation.class)) {
                        return true;
                    }
                    if (withAnnotations.contains(it.annotationType())) {
                        return true;
                    }
                    return false;
                });
    }
}


Wordpress

contentType: Profile

mediaType: Html

schema: Atom

contentType: Lifestream

mediaType: Atom


text:
php -f generate-docs.php > html\index.html
php -f generate-json.php > json\console-info.json