text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>namespace WinSW
{
public struct ProcessCommand
{
public string? Executable;
public string? Arguments;
publi<|fim_suffix|>doutPath;
public string? StderrPath;
public LogHandler CreateLogHandler() => new TempLogHandler(this.StdoutPath, this.StderrPath);
... | fim | winsw/winsw | csharp |
<|fim_suffix|>gDirectory => Path.GetDirectoryName(this.FullPath)!;
public virtual string LogMode => "append";
public virtual bool OutFileDisabled => false;
public virtual bool ErrFileDisabled => false;
public virtual string OutFilePattern => ".out.log";
public virtual string... | fim | winsw/winsw | csharp |
<|fim_prefix|>namespace WinSW.Configuration
{
<|fim_suffix|>nternal static class SettingNames
{
internal const string Arguments = "arguments";
internal const string Executable = "executable";
internal const string Poststart = "poststart";
internal const string Poststop = "poststop";... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.ServiceProcess;
using System.Text;
using System.Xml;
using WinSW.Configuration;
using WinSW.Native;
using WinSW.Util;
using Names = WinSW.Configuration.SettingNames;
namesp... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
using System.IO;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using log4net;
using WinSW.Logging;
using WinSW.Util;
namespace WinSW
{
/// <summary>
/// Specify the download activities prior to the launch.
/// This enables self-updating se... | fim | winsw/winsw | csharp |
using System.Xml;
namespace WinSW.Extensions
{
public abstract class AbstractWinSWExtension : IWinSWExtension
{
public abstract string DisplayName { get; }
#pragma warning disable CS8618 // Non-nullable field is uninitialized. Consider declaring as nullable.
public WinSWExtensionDescriptor De... | fim | winsw/winsw | csharp |
<|fim_suffix|> }
public override string Message => this.ExtensionId + ": " + base.Message;
}
}
<|fim_prefix|>using System;
namespace WinSW.Extensions
{
public class ExtensionException : WinSWException
{
public string ExtensionId { get; }
public ExtensionException(string exten... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System.Xml;
namespace WinSW.Extensions
{
/// <summary>
/// Interface for Win Service Wrapper Extension
/// </summary>
/// <remarks>
/// All implementations should provide the default empty constructor.
/// The initialization will be performed by Init methods.
/// Binary... | fim | winsw/winsw | csharp |
<|fim_suffix|>FromXml(XmlElement node)
{
bool enabled = XmlHelper.SingleAttribute(node, "enabled", true);
string className = XmlHelper.SingleAttribute<string>(node, "className");
string id = XmlHelper.SingleAttribute<string>(node, "id");
return new WinSWExtensionD... | fim | winsw/winsw | csharp |
<|fim_suffix|> throw;
}
this.Extensions.Add(id, extension);
Log.Info("Extension loaded: " + id);
}
else
{
Log.Warn("Extension is disabled: " + id);
}
}
#endregion
}
}
<|fim_... | fim | winsw/winsw | csharp |
<|fim_suffix|>onfig.Name;
string displayName = config.DisplayName;
return $"{(string.IsNullOrEmpty(displayName) ? name : displayName)} ({name})";
}
internal static string Format(this ServiceController controller)
{
return $"{controller.DisplayName} ({controll... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Threading.Tasks;
using WinSW.Util;
namespace WinSW
{
public interface IEventLogger
{
void WriteEntry(string message);
void WriteEntry(string message, EventLogEnt... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System.Diagnostics;
namespace WinSW.Logging
{
internal interface IServiceEven<|fim_suffix|>og
{
void WriteEntry(string message, EventLogEntryType type);
}
}
<|fim_middle|>tL<|endoftext|> | fim | winsw/winsw | csharp |
<|fim_suffix|> = "service";
}
}
<|fim_prefix|>namespace WinSW.Logging
{
internal static class LoggerNames
{
inte<|fim_middle|>rnal const string Console = "console";
internal const string Service<|endoftext|> | fim | winsw/winsw | csharp |
<|fim_prefix|>namespace WinSW.Logging
{
/// <summary>
/// Implements caching of the WindowsService reference in WinSW.
/// </summary>
internal sealed class WrapperSer<|fim_suffix|>ice? Service { get; set; }
public IServiceEventLog? Locate() => this.Service;
}
}
<|fim_middle|>viceEventLogPr... | fim | winsw/winsw | csharp |
<|fim_suffix|>l32, SetLastError = true)]
internal static extern bool SetConsoleMode(IntPtr consoleHandle, uint mode);
[DllImport(Kernel32)]
internal static extern bool SetConsoleOutputCP(uint codePageID);
[DllImport(Kernel32, SetLastError = true, CharSet = CharSet.Unicode)]
int... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
using System.IO;
using System.Text;
using static WinSW.Native.ConsoleApis;
namespace WinSW.Native
{
internal static class ConsoleEx
{
internal static Handle OpenConsoleInput()
{
return FileApis.CreateFileW(
"CONIN$",
FileA... | fim | winsw/winsw | csharp |
<|fim_suffix|>
IntPtr inAuthBuffer,
int inAuthBufferSize,
out IntPtr outAuthBuffer,
out uint outAuthBufferSize,
ref bool save,
uint flags);
[DllImport(Libraries.CredUI, SetLastError = true, CharSet = CharSet.Unicode, EntryPoint = "CredUnPa... | fim | winsw/winsw | csharp |
<|fim_suffix|>Size = Marshal.SizeOf<CREDUI_INFO>(),
CaptionText = caption,
MessageText = message,
};
uint authPackage = 0;
int error = CredUIPromptForWindowsCredentials(
info,
0,
... | fim | winsw/winsw | csharp |
#pragma warning disable SA1310 // Field names should not contain underscore
namespace WinSW.Native
{
internal static class Errors
{
internal const int ERROR_SUCCESS = 0;
internal const int ERROR_ACCESS_DENIED = 5;
internal const int ERROR_INVALID_HANDLE = 6;
internal const int ... | fim | winsw/winsw | csharp |
<|fim_suffix|>ntPtr templateFile);
internal enum GenericAccess : uint
{
Read = 0x80000000,
Write = 0x40000000,
Execute = 0x20000000,
All = 0x10000000,
}
}
}
<|fim_prefix|>using System;
using System.IO;
using System.Runtime.InteropServices;
n... | fim | winsw/winsw | csharp |
<|fim_suffix|>(long)this.HighDateTime << 32) + this.LowDateTime);
}
}
<|fim_prefix|>using Sys<|fim_middle|>tem;
namespace WinSW.Native
{
internal struct FileTime
{
internal int LowDateTime;
internal int HighDateTime;
public DateTime ToDateTime() => DateTime.FromFileTime((<|endofte... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
using<|fim_suffix|>blic static implicit operator IntPtr(Handle value) => value.handle;
}
}
<|fim_middle|> System.Runtime.InteropServices;
using static WinSW.Native.HandleApis;
namespace WinSW.Native
{
[StructLayout(LayoutKind.Sequential)]
internal readonly struct Handle : IDisp... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
using System.Runtime.InteropServices;
namespace WinSW.Native
{
internal static class HandleApis
{
[DllImport(Libraries.Kerne<|fim_suffix|>32)]
internal static extern bool CloseHandle(IntPtr objectHandle);
}
}
<|fim_middle|>l<|endoftext|> | fim | winsw/winsw | csharp |
<|fim_suffix|>ingSetSize;
public IntPtr MaximumWorkingSetSize;
public uint ActiveProcessLimit;
public UIntPtr Affinity;
public uint PriorityClass;
public uint SchedulingClass;
}
[StructLayout(LayoutKind.Sequential)]
internal struct IO_... | fim | winsw/winsw | csharp |
<|fim_prefix|>namesp<|fim_suffix|> internal const string CredUI = "credui.dll";
internal const string Kernel32 = "kernel32.dll";
internal const string Mpr = "mpr.dll";
internal const string NtDll = "ntdll.dll";
}
}
<|fim_middle|>ace WinSW.Native
{
internal static class Libraries
... | fim | winsw/winsw | csharp |
<|fim_suffix|>tError = true, CharSet = CharSet.Unicode)]
internal static extern int WNetAddConnection2W(in NETRESOURCEW netResource, string? password = null, string? userName = null, uint flags = 0);
[DllImport(Mpr, SetLastError = true, CharSet = CharSet.Unicode)]
internal static extern int WNe... | fim | winsw/winsw | csharp |
<|fim_prefix|>#pragma warning disable SA1310 // Field names should not contain underscore
using System;
using System.Runtime.InteropServices;
using System.Security.Principal;
namespace WinSW.Native
{
internal static class ProcessApis
{
internal const uint CREATE_NEW_PROCESS_GROUP = 0x00000200;
... | fim | winsw/winsw | csharp |
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
namespace WinSW.Native
{
internal static class RegistryApis
{
[DllImport(Libraries.Advapi32, CharSet = CharSet.Unicode)]
internal static extern unsafe int RegQueryInfoKeyW(
SafeRegistryHandle keyHandle,
... | fim | winsw/winsw | csharp |
<|fim_prefix|>#pragma warning disable SA1310 // Field names should not contain underscore
using System;
using System.Runtime.InteropServices;
namespace WinSW.Native
{
internal static class ResourceApis
{
internal static readonly IntPtr VS_VERSION_INFO = new(1);
internal static readonly IntPt... | fim | winsw/winsw | csharp |
<|fim_suffix|> File.Copy(path, outputPath, true);
var update = BeginUpdateResourceW(outputPath, false);
if (update == IntPtr.Zero)
{
Exit();
}
try
... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using static WinSW.Native.SecurityApis;
names<|fim_suffix|>tName)
{
uint status = LsaOpenPolicy(IntPtr.Zero, default, PolicyAccess.ALL_ACCESS, out var policyHandle);
if (status != 0)
... | fim | winsw/winsw | csharp |
<|fim_prefix|>#pragma warning disable SA1310 // Field names should not contain underscore
using System;
using System.Runtime.InteropServices;
namespace WinSW.Native
{
internal static class SecurityApis
{
[DllImport(Libraries.Advapi32, SetLastError = true)]
internal static extern bool GetToken... | fim | winsw/winsw | csharp |
<|fim_suffix|> this.handle,
IntPtr.Zero,
0,
out int bytesNeeded);
var config = Marshal.AllocHGlobal(bytesNeeded);
try
{
if (!QueryServiceConfig(
this.handle,
... | fim | winsw/winsw | csharp |
<|fim_suffix|>
internal struct SERVICE_STATUS_PROCESS
{
public ServiceType ServiceType;
public ServiceControllerStatus CurrentState;
public int ControlsAccepted;
public int Win32ExitCode;
public int ServiceSpecificExitCode;
public ... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
namespace WinSW.Native
{
internal static class Throw
{
internal static class Command
{
/// <exception cref="CommandExcept... | fim | winsw/winsw | csharp |
<|fim_prefix|>// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#if !NET
namespace System.Di<|fim_suffix|>ternal sealed class DoesNotReturnAttribute : Attribute
{
}
}
#endif
<|fim_middle|>agnostics.CodeAnalysis
{
/// <s... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
namespace WinSW
{
// This is largely borrowed from the logback Rolling Calendar.
public class PeriodicRollingCalendar
{
private readonly string format;
private readonly long period;
private DateTime currentRoll;
private DateTime nextRoll;
... | fim | winsw/winsw | csharp |
<|fim_suffix|>essfully.";
internal const string StoppedSuccessfully = "Service stopped successfully.";
}
}
<|fim_prefix|>namespace WinSW
{
internal static class ServiceMessages
{
internal const string StartedSuccessfully = "Ser<|fim_middle|>vice started succ<|endoftext|> | fim | winsw/winsw | csharp |
<|fim_prefix|>using System.Collections.Generic;
using WinSW.Native;
using static WinSW.Native.NetworkApis;
namespace WinSW
{
public seale<|fim_suffix|> string label = config.Label;
int error = WNetCancelConnection2W(label);
if (error != 0)
{
... | fim | winsw/winsw | csharp |
<|fim_suffix|>string driveLabel, string directoryUncPath)
{
this.Label = driveLabel;
this.UncPath = directoryUncPath;
}
}
}
<|fim_prefix|>namespace WinSW
{
public sealed class SharedDirectoryMapperConfig
{
public string Label { get; }
public string U... | fim | winsw/winsw | csharp |
<|fim_suffix|>CCESS_DENIED
_ => new IOException()
};
private static class NativeMethods
{
internal const uint MOVEFILE_REPLACE_EXISTING = 0x01;
internal const uint MOVEFILE_COPY_ALLOWED = 0x02;
[DllImport("kernel32.dll", SetLastError = true, Char... | fim | winsw/winsw | csharp |
<|fim_suffix|>fault:
Log.Warn("Failed to attach to console. " + new Win32Exception(error).Message);
return false;
}
}
// Don't call GenerateConsoleCtrlEvent immediately after SetConsoleCtrlHandler.
// A delay was observ... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
using Microsoft.Win32;
using WinSW.Native;
using static WinSW.Native.RegistryApis;
namespace WinSW.Util
{
internal static class RegistryKeyExtensions
{
/// <exception <|fim_suffix|>, null, null, null, null, out var lastWriteTime);
if (error != Errors.ERROR_SUCCE... | fim | winsw/winsw | csharp |
<|fim_suffix|>utedValue = Environment.ExpandEnvironmentVariables(rawValue);
try
{
return (TAttributeType)Enum.Parse(typeof(TAttributeType), substitutedValue, true);
}
catch (ArgumentException ex)
{
throw new InvalidDataException... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
namespace WinSW
{
public class WinSWException : Exception
{
public WinSWException(string message)
: base(message)
{
}
<|fim_suffix|>xception)
{
}
}
}
<|fim_middle|> public WinSWException(string message, Exception inner... | fim | winsw/winsw | csharp |
<|fim_suffix|><summary>
/// Variable, which specifies path to the executable being launched by WinSW.
/// </summary>
public static string EnvVarNameExecutablePath => SystemEnvVarPrefix + "EXECUTABLE";
}
}
<|fim_prefix|>namespace WinSW
{
/// <summary>
/// Class, which contains generi... | fim | winsw/winsw | csharp |
using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.ServiceProcess;
using System.Text;
using System.Threading.Tasks;
using log4net;
using WinSW.Extensions;
using WinSW.Logging;
using WinSW.Native;
using WinSW.Util;
using Messages = WinSW.ServiceMessages;
namespace WinSW
{
... | fim | winsw/winsw | csharp |
<|fim_suffix|> if (!this.usedTypes.Add(typeDef))
{
return;
}
if (typeDef.DeclaringType != null)
{
this.WalkType(typeDef.DeclaringType);
}
if (typeDef.BaseType != null)
... | fim | winsw/winsw | csharp |
<|fim_suffix|>())
{
this.Skip = "Access is denied";
}
}
}
}
<|fim_prefix|>using System;
using Xunit;
namespace WinSW.Tests
{
[AttributeUsage(At<|fim_middle|>tributeTargets.Method, AllowMultiple = false)]
public sealed class ElevatedFactAttribute : FactAttrib... | fim | winsw/winsw | csharp |
<|fim_suffix|> Assert.EndsWith(
ServiceMessages.StartedSuccessfully + Environment.NewLine,
File.ReadAllText(Path.ChangeExtension(config.FullPath, ".wrapper.log")));
if (Environment.GetEnvironmentVariable("System.DefinitionId") != null... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System.IO;
using System.Xml;
using WinSW.Tests.Util;
using Xunit;
namespace WinSW.Tests.Configuration
{
/// <summary>
/// Tests example configuration files.
/// The test uses a relative path to example files, which is based on the current project structure.
/// </summary>
publi... | fim | winsw/winsw | csharp |
<|fim_suffix|>
this.AssertInitializationFails(d, "Warning: you're sending your credentials in clear text to the server");
}
[Fact]
public void RejectBasicAuth_Without_Username()
{
var d = new Download(From, To, auth: Download.AuthType.Basic, username: null, passw... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using WinSW.Tests.Util;
using Xunit;
namespace WinSW.Tests
{
public class DownloadTests : IDisposable
{
private readonly HttpListener globalList... | fim | winsw/winsw | csharp |
<|fim_suffix|>ytes(Path.Combine(data.path, baseName + errFileExt)));
}
[Fact]
public void TimeBasedRollingLogAppender_PurgeOldFiles_RemovesExcessFiles()
{
using var data = TestData.Create();
string outFileExt = ".out.log";
const int keepFiles = 3;
... | fim | winsw/winsw | csharp |
<|fim_suffix|>ndle);
if (metadataReader.GetString(assembly.Name) != "System.IO.Compression")
{
Assert.Equal(version, assembly.Version);
}
}
}
}
}
#endif
<|fim_prefix|>#if NETFRAMEWORK
using System;
using System.IO;
using System... | fim | winsw/winsw | csharp |
<|fim_suffix|> };
string seedXml =
$@"<service>
<prestart>
<executable>{prestart.Executable}</executable>
<arguments>{prestart.Arguments}</arguments>
<stdoutPath>{prestart.StdoutPath}</stdoutPath>
<stderrPath>{prestart.StderrPath}</stderrPath>
</prestart>
<poststart>
<executable>... | fim | winsw/winsw | csharp |
<|fim_suffix|> internal static extern uint NetShareDel(string servername, string netname, uint reserved = 0);
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
internal struct SHARE_INFO_2
{
public string netname;
public uint ty... | fim | winsw/winsw | csharp |
<|fim_prefix|>using Xunit;
nam<|fim_suffix|>static void Succeeded(int hr) => Assert.InRange(hr, 0, int.MaxValue);
}
}
<|fim_middle|>espace WinSW.Tests.Util
{
internal static class AssertEx
{
internal <|endoftext|> | fim | winsw/winsw | csharp |
<|fim_suffix|> if (idNode is null)
{
idNode = document.CreateElement("id");
_ = serviceNode.PrependChild(idNode);
}
idNode.InnerText = serviceId;
var displayNameNode = serviceNode.SelectSingleNode("name");
... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System.Collections.Generic;
using System.Text;
using Xunit.Abstractions;
namespace WinSW.Tests.Util
{
/// <summary>
/// Configuration XML builder, which simplifies testing of WinSW Configuration file.
/// </summary>
internal class ConfigXmlBuilder
{
public string Name {... | fim | winsw/winsw | csharp |
<|fim_suffix|> dateTime.AddTicks(-(dateTime.Ticks % TimeSpan.TicksPerSecond));
}
}
<|fim_prefix|>using System;
namespace WinSW.Tests.Util
{
internal static class DateTimeExtensio<|fim_middle|>ns
{
internal static DateTime TrimToSeconds(this DateTime dateTime) =>
<|endoftext|> | fim | winsw/winsw | csharp |
<|fim_suffix|>));
_ = Directory.CreateDirectory(tempDirectory);
return tempDirectory;
}
}
}
<|fim_prefix|>using System.IO;
namespace WinSW.Tests.Util
{
internal class FilesystemTestHelper
{
/// <summary>
/// Creates a temporary directory for testing.
... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
using System.Col<|fim_suffix|>mentedException();
}
int IDebugEventCallbacks.ExitThread(uint ExitCode)
{
throw new NotImplementedException();
}
int IDebugEventCallbacks.CreateProcess(ulong ImageFileHandle, ulong Handle, ulong BaseOffset, ... | fim | winsw/winsw | csharp |
<|fim_prefix|>using System;
using System.IO;
using Xunit;
namespace WinSW.Tests.Util
{
internal static class Layout
{
private static string repositoryRoot;
private static string artifactsDirectory;
internal static string RepositoryRoot
{
get
{
... | fim | winsw/winsw | csharp |
<|fim_prefix|>using WinSW.Configuration;
using Xunit;
namespace WinSW.Tests.Util
{
public static class ServiceConfigAssert
{
public static void AssertAllOptionalPropertiesAreDefault(XmlServiceConfig config)
{
var testConfig = new TestServiceConfig(config);
foreach (var ... | fim | winsw/winsw | csharp |
<|fim_prefix|>var fun1 = function(name) {
print('Hi th<|fim_suffix|>.toString.call(object));
};<|fim_middle|>ere from Javascript, ' + name);
return "greetings from javascript";
};
var fun2 = function (object) {
print("JS Class Definition: " + Object.prototype<|endoftext|> | fim | winterbe/java8-tutorial | javascript |
var results = [];
var Context = function () {
this.foo = 'bar';
};
Context.prototype.testArgs = function () {
if (arguments[0]) {
results.push(true);
}
if (arguments[1]) {
results.push(true);
}
if (arguments[2]) {
results.push(true);
}
if (arguments[3]) {
... | fim | winterbe/java8-tutorial | javascript |
<|fim_suffix|>Nashorn2.fun2(String("bam"))
Nashorn2.fun2(new Number(23));
Nashorn2.fun2(new Date());
Nashorn2.fun2(new RegExp());
Nashorn2.fun2({foo: 'bar'});
print('passing object hash:');
Nashorn2.fun3({
foo: 'bar',
bar: 'foo'
});
print('passing custom person object:');
function Person(firstName, lastNam... | fim | winterbe/java8-tutorial | javascript |
<|fim_suffix|>
}
});
var Thread = Java.type('java.lang.Thread');
new Thread(new Printer()).start();
new Thread(function() {
print('this was printed from another thread');
}).start();
print('------------------');
print('Parameter Overload:');
var System = Java.type('java.lang.System');
System.out.println(1... | fim | winterbe/java8-tutorial | javascript |
<|fim_prefix|>// function literal with no braces
function sqr(x) x * x;
print(sqr(3));
// for each
var array = [1, 2, 3, 4];
for each (var num in array) print(num);
// object literals in constructors
var runnable = new java.lang.Runnable() {
run: function() {
print('on the run');
}
};
runnable.... | fim | winterbe/java8-tutorial | javascript |
<|fim_prefix|>function Product(name) {
this.name = name;
}
Product.prototype.stock = 0;
Product.prototype.price = 0;
Product.prototype.getValueOfGoods = function() {
return this.stock * this.price;
};
var product = new Product('Pencil');
<|fim_suffix|>.stock = 78;
print('Value of Goods: ' + product.getValueO... | fim | winterbe/java8-tutorial | javascript |
<|fim_suffix|> return model.attributes;
};<|fim_prefix|>load('http://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.6.0/underscore-min.js');
load('http://cdnjs.cloudflare.com/ajax/libs/backbone.js/1.1.2/backbone-min.js');
// simple backbone model:
// valueOfGoods will automatically be calculated when stock or price ... | fim | winterbe/java8-tutorial | javascript |
<|fim_prefix|>function sqrt(x) x * x
print(sqrt(3));
var array = [1, 2, 3, 4];
for each (var num in ar<|fim_suffix|>e() {
run: function () {
print('on the run');
}
};
runnable.run();
var System = Java.type('java.lang.System');
System.out["println(double)"](12);
var Arrays = Java.type("java.util.Arr... | fim | winterbe/java8-tutorial | javascript |
<|fim_prefix|>var evaluate1 = function () {
(function () {
print(eval("this"));
<|fim_suffix|>rint(eval("this"));
}).call(context);
};<|fim_middle|> }).call(this);
};
var evaluate2 = function () {
var context = {};
(function () {
print(eval("this"));
}).call(context);
};
var eva... | fim | winterbe/java8-tutorial | javascript |
<|fim_prefix|>var size = 100000;
var testPerf = function () {
var result = Math.floor(Math.random() * size) + 1;
for (var i = 0; i<|fim_suffix|> return result;
};<|fim_middle|> < size; i++) {
result += i;
}
<|endoftext|> | fim | winterbe/java8-tutorial | javascript |
package com.winterbe.java11;
import java.io.IOException;
import java.net.Authenticator;
import java.net.PasswordAuthentication;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
public class HttpClientExamples {
p... | fim | winterbe/java8-tutorial | java |
<|fim_suffix|>
Predicate<String> predicate1 = (@Deprecated var a) -> false;
}
void someMethod() {}
}
<|fim_prefix|>package com.winterbe.java11;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;
public class LocalVariableSyntax {
publ... | fim | winterbe/java8-tutorial | java |
<|fim_suffix|>s() throws IOException {
var classLoader = ClassLoader.getSystemClassLoader();
var inputStream = classLoader.getResourceAsStream("com/winterbe/java11/dummy.txt");
var tempFile = File.createTempFile("dummy-copy", "txt");
try (var outputStream = new FileOutputStream(tempFile)... | fim | winterbe/java8-tutorial | java |
<|fim_suffix|>Service executor = Executors.newFixedThreadPool(2);
IntStream.range(0, NUM_INCREMENTS)
.forEach(i -> executor.submit(atomicInt::incrementAndGet));
ConcurrentUtils.stop(executor);
System.out.format("Increment: Expected=%d; Is=%d\n", NUM_INCREMENTS, atomicInt.get()... | fim | winterbe/java8-tutorial | java |
<|fim_prefix|>package com.winterbe.java8.samples.concurrent;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
/<|fim_suffix|>
}
<|fim_middle|>**
* @author Benjamin Winterberg
*/
public class CompletableFuture1 {
public static void main(String[] args) throws Execut... | fim | winterbe/java8-tutorial | java |
<|fim_suffix|>tHashMap<>();
map.putIfAbsent("foo", "bar");
map.putIfAbsent("han", "solo");
map.putIfAbsent("r2", "d2");
map.putIfAbsent("c3", "p0");
map.forEach(1, (key, value) -> System.out.printf("key: %s; value: %s; thread: %s\n", key, value, Thread.currentThread().getName())... | fim | winterbe/java8-tutorial | java |
<|fim_prefix|>package com.winterbe.java8.samples.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
<|fim_suffix|> }
}
}
<|fim_middle|>
/**
* @author Benjamin Winterberg
*/
public class ConcurrentUtils {
public static void stop(ExecutorService executor) {
... | fim | winterbe/java8-tutorial | java |
package com.winterbe.java8.samples.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* @author Benjamin Winterberg
*/
public class Executors1 {
public static void main(String[] args) {
test1(3);
// test1(7);
... | fim | winterbe/java8-tutorial | java |
<|fim_prefix|>package com.winterbe.java8.samples.concurrent;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concu<|fim_suffix|> }
catch (InterruptedException e) ... | fim | winterbe/java8-tutorial | java |
<|fim_prefix|>package com.winterbe.java8.samples.concurrent;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExe... | fim | winterbe/java8-tutorial | java |
package com.winterbe.java8.samples.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.IntStream;
/**
* @author Benjamin Winterberg
*/
public class Lock1 {
private static final int NUM_INCREMENT... | fim | winterbe/java8-tutorial | java |
<|fim_prefix|>package com.winterbe.java8.samples.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author Benjamin Winterberg
*/
public class Lock2 {
public static void main(String[] args) {
ExecutorSe... | fim | winterbe/java8-tutorial | java |
<|fim_suffix|> map.put("foo", "bar");
} finally {
lock.writeLock().unlock();
}
});
Runnable readTask = () -> {
lock.readLock().lock();
try {
System.out.println(map.get("foo"));
ConcurrentUtils.sleep... | fim | winterbe/java8-tutorial | java |
package com.winterbe.java8.samples.concurrent;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.StampedLock;
/**
* @author Benjamin Winterberg
*/
public class Lock4 {
public static void main(Str... | fim | winterbe/java8-tutorial | java |
<|fim_suffix|>s.stop(executor);
}
}
<|fim_prefix|>package com.winterbe.java8.samples.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.StampedLock;
/**
* @author Benjamin Winterberg
*/
public class Lock5 {
public static void m... | fim | winterbe/java8-tutorial | java |
<|fim_suffix|>ncurrent.locks.StampedLock;
/**
* @author Benjamin Winterberg
*/
public class Lock6 {
private static int count = 0;
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(2);
StampedLock lock = new StampedLock();
executor.sub... | fim | winterbe/java8-tutorial | java |
<|fim_prefix|>package com.winterbe.java8.samples.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
impor<|fim_suffix|>tream.range(0, 10)
.forEach(i -> executor.submit(() -> accumulator.accumulate(i)));
ConcurrentUtils.stop(executor);
Syste... | fim | winterbe/java8-tutorial | java |
<|fim_prefix|>package com.winterbe.java8.samples.conc<|fim_suffix|>;
ConcurrentUtils.stop(executor);
System.out.format("Add: %d\n", adder.sumThenReset());
}
private static void testIncrement() {
ExecutorService executor = Executors.newFixedThreadPool(2);
IntStream.range(0, NU... | fim | winterbe/java8-tutorial | java |
<|fim_suffix|>
}
}
}
}
<|fim_prefix|>package com.winterbe.java8.samples.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;
/**
* @autho... | fim | winterbe/java8-tutorial | java |
<|fim_suffix|> }
}
}
}
<|fim_prefix|>package com.winterbe.java8.samples.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.uti<|fim_middle|>l.stream.IntStream;
/**
*... | fim | winterbe/java8-tutorial | java |
<|fim_suffix|>tic synchronized void incrementSync() {
count = count + 1;
}
private static void increment() {
count = count + 1;
}
}
<|fim_prefix|>package com.winterbe.java8.samples.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.... | fim | winterbe/java8-tutorial | java |
<|fim_suffix|> }
}
}
<|fim_prefix|>package com.winterbe.java8.samples.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.IntStream;
/**
* @author Benjamin Winterberg
*/
public class Synchronized2 {
private static final int NUM_INCR... | fim | winterbe/java8-tutorial | java |
<|fim_prefix|>package com.win<|fim_suffix|> TimeUnit.SECONDS.sleep(1);
System.out.println("Bar " + Thread.currentThread().getName());
}
catch (InterruptedException e) {
e.printStackTrace();
}
};
Thread thread = new Thread(runnable... | fim | winterbe/java8-tutorial | java |
<|fim_suffix|>
}
static int positive(int a) {
return a > 0 ? a : 0;
}
}
public static void main(String[] args) {
Formula formula1 = new Formula() {
@Override
public double calculate(int a) {
return sqrt(a * 100);
}... | fim | winterbe/java8-tutorial | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.