/// <summary>
/// Inserts a song from a specified index to a other index in the playlist and moves all songs in between these indexes
/// one index back.
/// </summary>
/// <param name="fromIndex">The index of the song to move.</param>
/// <param name="toIndex">To index to insert the song.</param>
internal void InsertMove(int fromIndex, int toIndex)
{
if (fromIndex < 0)
{
Throw.ArgumentOutOfRangeException(() => fromIndex, 0);
}
if (toIndex < 0)
{
Throw.ArgumentOutOfRangeException(() => toIndex, 0);
}
if (toIndex >= fromIndex)
{
Throw.ArgumentException(
String.Format("{0} has to be smaller than {1}",
Reflector.GetMemberName(() => toIndex), Reflector.GetMemberName(() => fromIndex)),
() => toIndex);
}
PlaylistEntry from = this[fromIndex];
for (int i = fromIndex; i > toIndex; i--)
{
_playlist[i].Index = i - 1;
_playlist[i] = this[i - 1];
}
from.Index = toIndex;
_playlist[toIndex] = from;
}
/// <summary>
/// Inserts a song from a specified index to a other index in the playlist and moves all songs in between these indexes one index back.
/// </summary>
/// <param name="fromIndex">The index of the song to move.</param>
/// <param name="toIndex">To index to insert the song.</param>
public void InsertMove(int fromIndex, int toIndex)
{
if (fromIndex < 0)
{
Throw.ArgumentOutOfRangeException(() => fromIndex, 0);
}
if (toIndex < 0)
{
Throw.ArgumentOutOfRangeException(() => 0);
}
if (toIndex >= fromIndex)
{
Throw.ArgumentException(
String.Format("{0} has to be small than {1}",
Reflector.GetMemberName(() => toIndex), Reflector.GetMemberName(() => fromIndex)),
() => toIndex);
}
Song from = this[fromIndex];
for (int i = fromIndex; i > toIndex; i--)
{
this.playlist[i] = this[i - 1];
}
this.playlist[toIndex] = from;
}
public static unsafe string Repeat(this string s, int count)
{
if (s == null)
{
Throw.ArgumentNullException(Argument.s);
}
if (count < 0)
{
Throw.ArgumentOutOfRangeException(Argument.count);
}
if (s.Length == 0 || count == 1)
{
return(s);
}
if (count == 0)
{
return(String.Empty);
}
string result = new String('\0', count * s.Length);
fixed(char *pResult = result)
{
var sb = new MutableStringBuilder(pResult, result.Length);
for (int i = 0; i < count; i++)
{
sb.Append(s);
}
}
return(result);
}
public void CopyTo(T[] array, int arrayIndex)
{
if (array == null)
{
Throw.ArgumentNullException(nameof(array));
}
if (arrayIndex < 0)
{
Throw.ArgumentOutOfRangeException(nameof(arrayIndex), Message.Common.NonNegativeArrayIndex);
}
if (arrayIndex > array.Length)
{
Throw.ArgumentOutOfRangeException(nameof(arrayIndex), Message.Common.ArrayIndexCannotGreaterThanArraySize);
}
if (Count > array.Length - arrayIndex)
{
Throw.ArgumentException(Message.Common.ArraySizeLess);
}
if (IsEmpty)
{
return;
}
var current = Head;
while (current != null)
{
array[arrayIndex++] = current.Item;
current = current.Next;
}
}
/// <summary>
/// Copies the elements of the <see cref="T:System.Collections.ICollection" /> to an <see cref="T:System.Array" />, starting at a particular <see cref="T:System.Array" /> index.
/// </summary>
/// <param name="array">The one-dimensional <see cref="T:System.Array" /> that is the destination of the elements copied from <see cref="T:System.Collections.ICollection" />. The <see cref="T:System.Array" /> must have zero-based indexing.</param>
/// <param name="index">The zero-based index in <paramref name="array" /> at which copying begins.</param>
public void CopyTo(Array array, int index)
{
if (array == null)
{
Throw.ArgumentNullException(nameof(array));
}
if (index < 0)
{
Throw.ArgumentOutOfRangeException(nameof(index), index, Message.Common.NonNegativeArrayIndex);
}
if (index > array.Length)
{
Throw.ArgumentOutOfRangeException(nameof(index), index, Message.Common.ArrayIndexCannotGreaterThanArraySize);
}
if (Count > array.Length - index)
{
Throw.ArgumentException(Message.Common.ArraySizeLess);
}
if (_head < _tail)
{
Array.Copy(_array, 0, array, index, Count);
return;
}
Array.Copy(_array, _head, array, 0, _array.Length - _head);
Array.Copy(_array, 0, array, _array.Length - _head, _tail);
}
/// <summary>
/// Copies the <paramref name="source"/> <see cref="Stream"/> into the <paramref name="destination"/> one.
/// Copy begins on the current position of source stream. None of the streams are closed or sought after
/// the end of the copy progress.
/// </summary>
/// <param name="source">Source stream.</param>
/// <param name="destination">Destination stream.</param>
/// <param name="bufferSize">Size of the buffer used for copying.</param>
public static void CopyTo(this Stream source, Stream destination, int bufferSize)
{
if (source == null)
{
Throw.ArgumentNullException(Argument.source);
}
if (destination == null)
{
Throw.ArgumentNullException(Argument.destination);
}
if (bufferSize <= 0)
{
Throw.ArgumentOutOfRangeException(Argument.bufferSize);
}
if (!source.CanRead)
{
Throw.ArgumentException(Argument.source, Res.StreamExtensionsStreamCannotRead);
}
if (!destination.CanWrite)
{
Throw.ArgumentException(Argument.destination, Res.StreamExtensionsStreamCannotWrite);
}
byte[] buffer = new byte[bufferSize];
int read;
while ((read = source.Read(buffer, 0, buffer.Length)) > 0)
{
destination.Write(buffer, 0, read);
}
}
public ArraySection(int length, bool assureClean = true)
{
if (length < 0)
{
Throw.ArgumentOutOfRangeException(Argument.length);
}
offset = 0;
this.length = length;
#if !(NETFRAMEWORK || NETSTANDARD2_0)
poolArray = length >= poolingThreshold;
if (poolArray)
{
array = ArrayPool <T> .Shared.Rent(length);
if (assureClean)
{
Clear();
}
return;
}
#endif
array = length == 0 ? Reflector.EmptyArray <T>() : new T[length];
}
internal void MoveSong(int fromIndex, int toIndex)
{
if (fromIndex >= this.playlist.Count)
{
Throw.ArgumentOutOfRangeException(() => fromIndex);
}
if (fromIndex < 0)
{
Throw.ArgumentOutOfRangeException(() => fromIndex);
}
if (toIndex >= this.playlist.Count)
{
Throw.ArgumentOutOfRangeException(() => fromIndex);
}
if (toIndex < 0)
{
Throw.ArgumentOutOfRangeException(() => fromIndex);
}
using (this.WithIndexRebuild())
{
this.playlist.Move(fromIndex, toIndex);
}
}
/// <summary>
/// Repeats a <see cref="string"/> <paramref name="count"/> times.
/// </summary>
/// <param name="s">The string to repeat <paramref name="count"/> times.</param>
/// <param name="count">The count of repeating <paramref name="s"/>. If 0, an empty string is returned. If 1 the original <paramref name="s"/> is returned.</param>
/// <returns><paramref name="s"/> repeated <paramref name="count"/> times.</returns>
/// <exception cref="ArgumentNullException"><paramref name="s"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is less than 0.</exception>
public static string Repeat(this string s, int count)
{
if (s == null)
{
Throw.ArgumentNullException(Argument.s);
}
if (count < 0)
{
Throw.ArgumentOutOfRangeException(Argument.count);
}
if (s.Length == 0 || count == 1)
{
return(s);
}
if (count == 0)
{
return(String.Empty);
}
StringBuilder result = new StringBuilder(s);
for (int i = 0; i < count; i++)
{
result.Append(s);
}
return(result.ToString());
}
public RequireAuthorChannelPermissionsAttribute(Permission permissions)
{
Permissions = ChannelPermissions.Mask(permissions, out var remainingPermissions);
if (remainingPermissions != Permission.None)
{
Throw.ArgumentOutOfRangeException(nameof(permissions), $"The permissions specified for {GetType()} contain non-channel permissions: {remainingPermissions}.");
}
}
internal int ThrowByHelper(int value)
{
if (value < 0)
{
Throw.ArgumentOutOfRangeException(Argument.value);
}
return(value + 1);
}
public static IEnumerable GetEnumerator(JsonElement document)
{
return(document.ValueKind switch
{
JsonValueKind.Object => EnumerateObject(),
JsonValueKind.Array => ArrayProperties,
_ => Throw.ArgumentOutOfRangeException <IEnumerable>()
});
/// <summary>
/// Initializes a new instance of the <see cref="CircularBuffer<T>"/> class.
/// </summary>
/// <param name="capacity">The initial capacity of the <see cref="CircularBuffer{T}"/>.</param>
public CircularBuffer(int capacity)
{
if (capacity < 1)
{
Throw.ArgumentOutOfRangeException(() => capacity, 1);
}
this.buffer = new List <T>(capacity);
}
public Stack(int capacity)
{
if (capacity < 0)
{
Throw.ArgumentOutOfRangeException(nameof(capacity), capacity, Message.Stack.NonNegativeCapacity);
}
_array = new T[capacity];
}
/// <summary>
/// Plays the song with the specified index in the playlist.
/// </summary>
/// <param name="playlistIndex">The index of the song in the playlist.</param>
public void PlaySong(int playlistIndex)
{
if (playlistIndex < 0)
{
Throw.ArgumentOutOfRangeException(() => playlistIndex, 0);
}
InternPlaySong(playlistIndex);
}
/// <summary>
/// Rotates an array passed.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="array">Array to be rotated.</param>
/// <param name="index">Index of the element from where the rotation must start.</param>
/// <param name="numberOfElements">Number of elements to be rotated.</param>
public void ToRotateIt <T>(T[] array, int index, int numberOfElements)
{
if (index < 0)
{
Throw.ArgumentOutOfRangeException(nameof(index));
}
//var currentIndexOfNewFirstElement = index > 0 ? index - 1 : ;
var newIndexOfCurrentFirstElement = array.Length - numberOfElements + index;
//var tempElement =
}
public ref T GetElementReference(int index)
{
// For better performance we throw an ArgumentOutOfRangeException only when a NullReferenceException
// would come otherwise, and let the ArgumentOutOfRangeException come from array, even if a not localized one.
if (array == null)
{
Throw.ArgumentOutOfRangeException(Argument.index);
}
return(ref GetElementReferenceInternal(index));
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueUsingArray{T}"/> class.
/// </summary>
/// <param name="capacity">The capacity.</param>
public QueueUsingArray(int capacity)
{
if (capacity < 0)
{
Throw.ArgumentOutOfRangeException(nameof(capacity), capacity, Message.Common.NonNegativeCapacity);
}
_array = new T[capacity];
Count = _head = _tail = 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="StreamCopyOperation"/> class.
/// </summary>
/// <param name="sourceStream">The source stream.</param>
/// <param name="targetStream">The target stream.</param>
/// <param name="bufferSize">Size of the buffer.</param>
/// <param name="updateInterval">The interval, after how much copied bytes the <see cref="CopyProgressChanged"/> should be raised.</param>
public StreamCopyOperation(Stream sourceStream, Stream targetStream, int bufferSize, int updateInterval)
: this(sourceStream, targetStream, bufferSize)
{
if (updateInterval < 1)
{
Throw.ArgumentOutOfRangeException(() => updateInterval, 1);
}
this.UpdateInterval = updateInterval;
}
private void InternPlaySong(int playlistIndex)
{
if (playlistIndex < 0)
{
Throw.ArgumentOutOfRangeException(() => playlistIndex, 0);
}
if (_currentPlayingPlaylist != null)
{
_currentPlayingPlaylist.CurrentSongIndex = null;
}
_currentPlayingPlaylist = CurrentPlaylist;
CurrentPlaylist.CurrentSongIndex = playlistIndex;
Song song = CurrentPlaylist[playlistIndex].Song;
RenewCurrentPlayer(song);
Task.Factory.StartNew(() =>
{
try
{
_currentPlayer.Load();
}
catch (SongLoadException)
{
//song.IsCorrupted = true;
SongCorrupted.RaiseSafe(this, EventArgs.Empty);
HandleSongCorruption();
return;
}
try
{
_currentPlayer.Play();
}
catch (PlaybackException)
{
//song.IsCorrupted = true;
SongCorrupted.RaiseSafe(this, EventArgs.Empty);
HandleSongCorruption();
return;
}
SongStarted.RaiseSafe(this, EventArgs.Empty);
});
}
/// <summary>
/// Plays the song with the specified index in the playlist.
/// </summary>
/// <param name="playlistIndex">The index of the song in the playlist.</param>
public async Task PlaySongAsync(int playlistIndex, Guid accessToken)
{
if (playlistIndex < 0)
{
Throw.ArgumentOutOfRangeException(() => playlistIndex, 0);
}
this.accessControl.VerifyAccess(accessToken, this.settings.LockPlayPause);
await this.InternPlaySongAsync(playlistIndex);
}
/// <summary>
/// Computes the CRC-32 hash value for the specified byte array.
/// </summary>
/// <param name="buffer">The input to compute the hash code for.</param>
/// <param name="offset">The offset into the byte array from which to begin using data.</param>
/// <param name="count">The number of bytes in the array to use as data.</param>
/// <param name="initialCrc">The initial CRC value to use. If the final CRC is calculated in more sessions the result of the last calculation can be specified here. This parameter is optional.
/// <br/>Default value: <c>0</c>.</param>
/// <param name="polynomial">The polynomial to use to calculate the CRC value. This parameter is optional.
/// <br/>Default value: <see cref="StandardPolynomial"/>.</param>
/// <returns>The CRC-32 hash value of the specified <paramref name="buffer"/>; or, if <paramref name="initialCrc"/> was specified, an
/// accumulated hash value appended by the current <paramref name="buffer"/>.</returns>
public static uint CalculateHash(byte[] buffer, int offset, int count, uint initialCrc = 0U, uint polynomial = StandardPolynomial)
{
if (buffer == null)
{
Throw.ArgumentNullException(Argument.buffer);
}
if (offset < 0 || count < 0 || offset + count > buffer.Length)
{
Throw.ArgumentOutOfRangeException(Argument.count);
}
return(CalculateHash(tablesCache[polynomial], initialCrc, buffer, offset, count));
}
/// <summary>
/// Gets a <see cref="StringSegment"/> instance, which represents a segment of the specified <see cref="string">string</see>.
/// No new string allocation occurs when using this method.
/// </summary>
/// <param name="s">The string to create the <see cref="StringSegment"/> from.</param>
/// <param name="offset">The offset that points to the first character of the returned segment.</param>
/// <returns>A <see cref="StringSegment"/> instance, which represents a segment of the specified <see cref="string">string</see>.</returns>
public static StringSegment AsSegment(this string s, int offset)
{
if (s == null)
{
Throw.ArgumentNullException(Argument.s);
}
if ((uint)offset > (uint)s.Length)
{
Throw.ArgumentOutOfRangeException(Argument.offset);
}
return(new StringSegment(s, offset, s.Length - offset));
}
/// <summary>
/// Plays the song with the specified index in the playlist.
/// </summary>
/// <param name="playlistIndex">The index of the song in the playlist.</param>
public void PlaySong(int playlistIndex)
{
if (playlistIndex < 0)
{
Throw.ArgumentOutOfRangeException(() => playlistIndex, 0);
}
if (this.LockPlayPause && this.AccessMode == AccessMode.Party)
{
throw new InvalidOperationException("Not allowed to play when in party mode.");
}
this.InternPlaySong(playlistIndex);
}
/// <summary>
/// Gets the character at the specified position in this <see cref="StringSegment"/>.
/// </summary>
/// <param name="index">The index of the character to obtain.</param>
/// <returns>The character at the specified position in this <see cref="StringSegment"/>.</returns>
public char this[int index]
{
[MethodImpl(MethodImpl.AggressiveInlining)]
get
{
// For better performance we throw an ArgumentOutOfRangeException only when a NullReferenceException
// would come otherwise, and let the ArgumentOutOfRangeException come from string, even if a not localized one.
if (str == null)
{
Throw.ArgumentOutOfRangeException(Argument.index);
}
return(GetCharInternal(index));
}
}
/// <summary>
/// Returns the logarithm of a specified <paramref name="value"/> in a specified <paramref name="base"/>.
/// </summary>
/// <param name="value">The value whose logarithm is to be found. Must be greater than zero.</param>
/// <param name="base">The base of the logarithm.</param>
/// <returns>The logarithm of the specified <paramref name="value"/> in the specified <paramref name="base"/>.</returns>
/// <remarks>
/// <para>This member is similar to <see cref="Math.Log(double,double)">Math.Log(double, double)</see> but uses <see cref="decimal"/> type instead of <see cref="double"/>.</para>
/// </remarks>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="value"/> is less than or equal to 0.
/// <br/>-or-
/// <br/><paramref name="base"/> equals to 1 or is less or equal to 0.</exception>
public static decimal Log(this decimal value, decimal @base)
{
if (@base == 1m)
{
Throw.ArgumentOutOfRangeException(Argument.value);
}
if (value == 1m && @base == 0m)
{
return(0m);
}
var result = Log(value) / Log(@base);
return(RoundInternal(result));
}
private void InternPlaySong(int playlistIndex)
{
if (playlistIndex < 0)
{
Throw.ArgumentOutOfRangeException(() => playlistIndex, 0);
}
if (this.isWaitingOnCache)
{
this.overrideCurrentCaching = true;
// Let the song that is selected to be played wait here, if there is currently another song caching
cacheResetHandle.WaitOne();
}
this.playlist.CurrentSongIndex = playlistIndex;
Song song = this.playlist[playlistIndex];
if (this.currentPlayer != null)
{
this.currentPlayer.Dispose();
}
this.currentPlayer = song.CreateAudioPlayer();
this.currentPlayer.SongFinished += (sender, e) => this.HandleSongFinish();
this.currentPlayer.Volume = this.volume;
Task.Factory.StartNew(() =>
{
if (song.HasToCache && !song.IsCached)
{
bool cached = this.AwaitCaching(song);
if (!cached)
{
return;
}
}
this.overrideCurrentCaching = false;
this.currentPlayer.Load(song);
this.currentPlayer.Play();
this.SongStarted.RaiseSafe(this, EventArgs.Empty);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="DataTransferEventArgs"/> class.
/// </summary>
/// <param name="totalBytes">The total number of bytes.</param>
/// <param name="transferredBytes">The transferred bytes.</param>
public DataTransferEventArgs(long totalBytes, long transferredBytes)
{
if (totalBytes < 1)
{
Throw.ArgumentOutOfRangeException(() => totalBytes, 1);
}
if (transferredBytes < 1)
{
Throw.ArgumentOutOfRangeException(() => transferredBytes, 1);
}
this.TotalBytes = totalBytes;
this.TransferredBytes = transferredBytes;
}
internal PlaylistEntry(int index, Song song)
{
if (index < 0)
{
Throw.ArgumentOutOfRangeException(() => index, 0);
}
if (song == null)
{
Throw.ArgumentNullException(() => song);
}
Index = index;
Song = song;
}
private static void InternalValidationForListAndIndex <T>(Singly <T> list, int nTh)
{
if (list == null)
{
Throw.ArgumentNullException(nameof(list));
}
if (nTh < 1)
{
Throw.ArgumentOutOfRangeException(nameof(nTh), Message.OnSinglyLinkedList.NthMustBePositiveNonZero);
}
if (nTh > list.Count)
{
Throw.ArgumentOutOfRangeException(nameof(nTh), Message.OnSinglyLinkedList.NthCannotBeGreaterThanListCount);
}
}
