text:
// Copyright (c) Microsoft Corporation. All Rights Reserved.
// Licensed under the MIT License.

using Microsoft.Datasync.Client.Authentication;
using Microsoft.Datasync.Client.Http;
using Microsoft.Datasync.Client.Offline;
using Microsoft.Datasync.Client.Serialization;
using Microsoft.Datasync.Client.Table;
using Microsoft.Datasync.Client.Utils;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace Microsoft.Datasync.Client
{
    /// <summary>
    /// Provides basic access to a Microsoft Datasync service.
    /// </summary>
    public class DatasyncClient : IDisposable
    {
        /// <summary>
        ///  This is for unit testing only
        /// </summary>
        [ExcludeFromCodeCoverage]
        protected DatasyncClient()
        {
        }

        /// <summary>
        /// Creates a new <see cref="DatasyncClient"/> that connects to the specified endpoint for information transfer.
        /// </summary>
        /// <param name="endpoint">The endpoint of the datasync service.</param>
        /// <exception cref="UriFormatException">if the endpoint is not a valid Uri.</exception>
        public DatasyncClient(string endpoint)
            : this(new Uri(endpoint, UriKind.Absolute), null, null)
        {
        }

        /// <summary>
        /// Creates a new <see cref="DatasyncClient"/> that connects to the specified endpoint for information transfer.
        /// </summary>
        /// <param name="endpoint">The endpoint of the datasync service.</param>
        /// <param name="clientOptions">The client options used to modify any request/response that is sent.</param>
        /// <exception cref="UriFormatException">if the endpoint is not a valid Uri.</exception>
        public DatasyncClient(string endpoint, DatasyncClientOptions clientOptions)
            : this(new Uri(endpoint, UriKind.Absolute), null, clientOptions)
        {
        }

        /// <summary>
        /// Creates a new <see cref="DatasyncClient"/> that connects to the specified endpoint for information transfer.
        /// </summary>
        /// <param name="endpoint">The endpoint of the datasync service.</param>
        /// <param name="authenticationProvider">The authentication provider to use for authenticating the request</param>
        /// <exception cref="UriFormatException">if the endpoint is malformed</exception>
        public DatasyncClient(string endpoint, AuthenticationProvider authenticationProvider)
            : this(new Uri(endpoint, UriKind.Absolute), authenticationProvider, null)
        {
        }

        /// <summary>
        /// Creates a new <see cref="DatasyncClient"/> that connects to the specified endpoint for information transfer.
        /// </summary>
        /// <param name="endpoint">The endpoint of the datasync service.</param>
        /// <param name="authenticationProvider">The authentication provider to use for authenticating the request</param>
        /// <param name="clientOptions">The client options used to modify any request/response that is sent.</param>
        /// <exception cref="UriFormatException">if the endpoint is malformed</exception>
        public DatasyncClient(string endpoint, AuthenticationProvider authenticationProvider, DatasyncClientOptions clientOptions)
            : this(new Uri(endpoint, UriKind.Absolute), authenticationProvider, clientOptions)
        {
        }

        /// <summary>
        /// Creates a new <see cref="DatasyncClient"/> that connects to the specified endpoint for information transfer.
        /// </summary>
        /// <param name="endpoint">The endpoint of the datasync service.</param>
        /// <exception cref="ArgumentNullException">if the endpoint is null</exception>
        /// <exception cref="UriFormatException">if the endpoint is malformed</exception>
        public DatasyncClient(Uri endpoint)
            : this(endpoint, null, null)
        {
        }

        /// <summary>
        /// Creates a new <see cref="DatasyncClient"/> that connects to the specified endpoint for information transfer.
        /// </summary>
        /// <param name="endpoint">The endpoint of the datasync service.</param>
        /// <param name="clientOptions">The client options used to modify any request/response that is sent.</param>
        /// <exception cref="ArgumentNullException">if the endpoint is null</exception>
        /// <exception cref="UriFormatException">if the endpoint is malformed</exception>
        public DatasyncClient(Uri endpoint, DatasyncClientOptions clientOptions)
            : this(endpoint, null, clientOptions)
        {
        }

        /// <summary>
        /// Creates a new <see cref="DatasyncClient"/> that connects to the specified endpoint for information transfer.
        /// </summary>
        /// <param name="endpoint">The endpoint of the datasync service.</param>
        /// <param name="authenticationProvider">The authentication provider to use for authenticating the request</param>
        /// <exception cref="ArgumentNullException">if the endpoint is null</exception>
        /// <exception cref="UriFormatException">if the endpoint is malformed</exception>
        public DatasyncClient(Uri endpoint, AuthenticationProvider authenticationProvider)
            : this(endpoint, authenticationProvider, null)
        {
        }

        /// <summary>
        /// Creates a new <see cref="DatasyncClient"/> that connects to the specified endpoint for information transfer.
        /// </summary>
        /// <param name="endpoint">The endpoint of the datasync service.</param>
        /// <param name="authenticationProvider">The authentication provider to use for authenticating the request</param>
        /// <param name="clientOptions">The client options used to modify any request/response that is sent.</param>
        /// <exception cref="ArgumentNullException">if the endpoint is null</exception>
        /// <exception cref="UriFormatException">if the endpoint is malformed</exception>
        public DatasyncClient(Uri endpoint, AuthenticationProvider authenticationProvider, DatasyncClientOptions clientOptions)
        {
            Arguments.IsValidEndpoint(endpoint, nameof(endpoint));

            Endpoint = endpoint.NormalizeEndpoint();
            ClientOptions = clientOptions ?? new DatasyncClientOptions();
            HttpClient = new ServiceHttpClient(Endpoint, authenticationProvider, ClientOptions);
            if (ClientOptions.SerializerSettings != null)
            {
                Serializer.SerializerSettings = ClientOptions.SerializerSettings;
            }
            if (ClientOptions.OfflineStore != null)
            {
                SyncContext = new SyncContext(this, ClientOptions.OfflineStore);
            }
        }

        /// <summary>
        /// The client options for the service.
        /// </summary>
        public DatasyncClientOptions ClientOptions { get; }

        /// <summary>
        /// Absolute URI of the Microsoft Azure Mobile App.
        /// </summary>
        public Uri Endpoint { get; }

        /// <summary>
        /// Gets the <see cref="ServiceHttpClient"/> associated with the Azure Mobile App.
        /// </summary>
        internal ServiceHttpClient HttpClient { get; }

        /// <summary>
        /// The id used to identify this installation of the application to
        /// provide telemetry data.
        /// </summary>
        public string InstallationId { get => HttpClient.InstallationId; }

        /// <summary>
        /// The number of pending operations, or null if the offline store has not been defined.
        /// </summary>
        public long? PendingOperations { get => SyncContext?.PendingOperations; }

        /// <summary>
        /// The serializer to use for serializing and deserializing content.
        /// </summary>
        public ServiceSerializer Serializer { get; } = new();

        /// <summary>
        /// The synchronization context.
        /// </summary>
        internal SyncContext SyncContext { get; }

        /// <summary>
        /// An event delegate that allows the app to monitor synchronization events.
        /// </summary>
        public event EventHandler<SynchronizationEventArgs> SynchronizationProgress;

        /// <summary>
        /// Returns a reference to an offline table, providing untyped (JSON) data
        /// operations for that table.
        /// </summary>
        /// <param name="tableName">The name of the table.</param>
        /// <returns>A reference to the table.</returns>
        public virtual IOfflineTable GetOfflineTable(string tableName)
        {
            Arguments.IsValidTableName(tableName, nameof(tableName));
            if (SyncContext == null)
            {
                throw new InvalidOperationException("An offline store must be specified before using offline tables.");
            }
            return new OfflineTable(tableName, this);
        }

        /// <summary>
        /// Returns a reference to an offline table, providing typed data
        /// operations for that table.
        /// </summary>
        /// <remarks>
        /// If <paramref name="tableName"/> is not specified, the name of the
        /// type is used as the table name.
        /// </remarks>
        /// <typeparam name="T">The type of the data transfer object (model) being used.</typeparam>
        /// <param name="tableName">The (optional) name of the table.</param>
        /// <returns>A reference to the table.</returns>
        public virtual IOfflineTable<T> GetOfflineTable<T>(string tableName = null)
        {
            tableName ??= Serializer.ResolveTableName<T>();
            Arguments.IsValidTableName(tableName, nameof(tableName));
            if (SyncContext == null)
            {
                throw new InvalidOperationException("An offline store must be specified before using offline tables.");
            }
            if (SyncContext.OfflineStore is AbstractOfflineStore store && !store.TableIsDefined(tableName))
            {
                store.DefineTable<T>(tableName);
            }
            return new OfflineTable<T>(tableName, this);
        }

        /// <summary>
        /// Returns a reference to a remote table, providing untyped (JSON) data
        /// operations for that table.
        /// </summary>
        /// <param name="tableName">The name of the table.</param>
        /// <returns>A reference to the table.</returns>
        public virtual IRemoteTable GetRemoteTable(string tableName)
            => new RemoteTable(tableName, this);

        /// <summary>
        /// Returns a reference to a remote table, providing typed data
        /// operations for that table.
        /// </summary>
        /// <remarks>
        /// If <paramref name="tableName"/> is not specified, the name of the type is used as
        /// the table name.
        /// </remarks>
        /// <typeparam name="T">The type of the data transfer object (model) being used.</typeparam>
        /// <param name="tableName">The (optional) name of the table.</param>
        /// <returns>A reference to the table.</returns>
        public virtual IRemoteTable<T> GetRemoteTable<T>(string tableName = null)
            => new RemoteTable<T>(tableName ?? Serializer.ResolveTableName<T>(), this);

        /// <summary>
        /// Initializes the offline store.
        /// </summary>
        /// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
        /// <returns>A task that completes when the offline store is initialized.</returns>
        /// <exception cref="InvalidOperationException">if the offline store was not provided.</exception>
        public virtual async Task InitializeOfflineStoreAsync(CancellationToken cancellationToken = default)
        {
            if (SyncContext == null)
            {
                throw new InvalidOperationException("An offline store must be specified before initialization.");
            }
            await SyncContext.InitializeAsync(cancellationToken).ConfigureAwait(false);
        }

        /// <summary>
        /// Pushes the pending operations for all tables to the remote service.
        /// </summary>
        /// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
        /// <returns>A task that completes when the pending operations have been pushed.</returns>
        /// <exception cref="InvalidOperationException">if the offline store is not available.</exception>
        public virtual Task PushTablesAsync(CancellationToken cancellationToken = default)
            => PushTablesAsync(Array.Empty<string>(), null, cancellationToken);

        /// <summary>
        /// Pushes the pending operations for all tables to the remote service.
        /// </summary>
        /// <param name="tables">The list of tables to be pushed.</param>
        /// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
        /// <returns>A task that completes when the pending operations have been pushed.</returns>
        /// <exception cref="InvalidOperationException">if the offline store is not available.</exception>
        public virtual Task PushTablesAsync(IEnumerable<string> tables, CancellationToken cancellationToken = default)
            => PushTablesAsync(tables, null, cancellationToken);

        /// <summary>
        /// Pushes the pending operations for all tables to the remote service.
        /// </summary>
        /// <param name="options">The push operation options.</param>
        /// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
        /// <returns>A task that completes when the pending operations have been pushed.</returns>
        /// <exception cref="InvalidOperationException">if the offline store is not available.</exception>
        public virtual Task PushTablesAsync(PushOptions options, CancellationToken cancellationToken = default)
            => PushTablesAsync(Array.Empty<string>(), options, cancellationToken);

        /// <summary>
        /// Pushes the pending operations for a list of tables to the remote service.  You must name the tables
        /// to be pushed.
        /// </summary>
        /// <param name="tables">The list of tables to be pushed.</param>
        /// <param name="options">The push operation options.</param>
        /// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
        /// <returns>A task that completes when the pending operations have been pushed.</returns>
        /// <exception cref="InvalidOperationException">if the offline store is not available.</exception>
        public virtual async Task PushTablesAsync(IEnumerable<string> tables, PushOptions options, CancellationToken cancellationToken = default)
        {
            if (SyncContext == null)
            {
                throw new InvalidOperationException("An offline store must be specified before doing offline operations.");
            }
            await SyncContext.PushItemsAsync(tables.ToArray(), options, cancellationToken).ConfigureAwait(false);
        }

        /// <summary>
        /// Sends a synchronization event to the consumers.
        /// </summary>
        /// <param name="eventArgs">The event arguments.</param>
        internal void SendSynchronizationEvent(SynchronizationEventArgs eventArgs)
        {
            SynchronizationProgress?.Invoke(this, eventArgs);
        }

        #region IDisposable
        /// <summary>
        /// Implemenation of <see cref="IDisposable"/>
        /// </summary>
        [ExcludeFromCodeCoverage]
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Implemenation of <see cref="IDisposable"/> for
        /// derived classes to use.
        /// </summary>
        /// <param name="disposing">
        /// Indicates if being called from the Dispose() method
        /// or the finalizer.
        /// </param>
        [ExcludeFromCodeCoverage]
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                SyncContext.Dispose();
                HttpClient.Dispose();
            }
        }
        #endregion
    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>

<!--L
  Copyright Oracle Inc

  Distributed under the OSI-approved BSD 3-Clause License.
  See http://ncip.github.com/cadsr-cgmdr-nci-uk/LICENSE.txt for details.
L-->

<cgMDR:Property xmlns:cgMDR="http://www.cancergrid.org/schema/cgMDR" item_registration_authority_identifier="GB-CANCERGRID" data_identifier="014A4967A" version="0.11">
    <cgMDR:administered_item_administration_record>
        <cgMDR:administrative_note>Curation of Neat annual followup form</cgMDR:administrative_note>
        <cgMDR:administrative_status>scheduledForReview</cgMDR:administrative_status>
        <cgMDR:change_description>curation to recorded status</cgMDR:change_description>
        <cgMDR:creation_date>2007-01-08</cgMDR:creation_date>
        <cgMDR:effective_date>2007-01-08</cgMDR:effective_date>
        <cgMDR:explanatory_comment>(none)</cgMDR:explanatory_comment>
        <cgMDR:last_change_date>2007-01-08</cgMDR:last_change_date>
        <cgMDR:origin>CRUK Cancer Clinical Trials Unit, University of Birmingham</cgMDR:origin>
        <cgMDR:registration_status>Recorded</cgMDR:registration_status>
        <cgMDR:unresolved_issue>(none)</cgMDR:unresolved_issue>
    </cgMDR:administered_item_administration_record>
    <cgMDR:administered_by>GB-CANCERGRID-000007-1</cgMDR:administered_by>
    <cgMDR:registered_by>GB-CANCERGRID-000009-1</cgMDR:registered_by>
    <cgMDR:submitted_by>GB-CANCERGRID-200002-1</cgMDR:submitted_by>
    <cgMDR:described_by/>
    <cgMDR:classified_by>http://www.cancergrid.org/ontologies/data-element-classification#</cgMDR:classified_by>
    <cgMDR:having>
        <cgMDR:context_identifier>GB-CANCERGRID-000001-1</cgMDR:context_identifier>
        <cgMDR:containing>
            <cgMDR:language_section_language_identifier>
                <cgMDR:country_identifier>GB</cgMDR:country_identifier>
                <cgMDR:language_identifier>eng</cgMDR:language_identifier>
            </cgMDR:language_section_language_identifier>
            <cgMDR:name>Date</cgMDR:name>
            <cgMDR:definition_text>Simple date property</cgMDR:definition_text>
            <cgMDR:preferred_designation>true</cgMDR:preferred_designation>
            <cgMDR:definition_source_reference/>
        </cgMDR:containing>
    </cgMDR:having>
    <cgMDR:reference_uri>urn:lsid:ncicb.nci.nih.gov:nci-thesaurus:C25164</cgMDR:reference_uri>
</cgMDR:Property>

redpajama_set_name: RedPajamaGithub


text:
#ifndef MediaControlElementTypes_h
#define MediaControlElementTypes_h

#include "core/html/HTMLDivElement.h"
#include "core/html/HTMLInputElement.h"
#include "core/rendering/RenderBlock.h"

namespace blink {

class HTMLMediaElement;
class MediaControls;

enum MediaControlElementType {
    MediaEnterFullscreenButton = 0,
    MediaMuteButton,
    MediaPlayButton,
    MediaSlider,
    MediaSliderThumb,
    MediaShowClosedCaptionsButton,
    MediaHideClosedCaptionsButton,
    MediaUnMuteButton,
    MediaPauseButton,
    MediaTimelineContainer,
    MediaCurrentTimeDisplay,
    MediaTimeRemainingDisplay,
    MediaStatusDisplay,
    MediaControlsPanel,
    MediaVolumeSliderContainer,
    MediaVolumeSlider,
    MediaVolumeSliderThumb,
    MediaFullScreenVolumeSlider,
    MediaFullScreenVolumeSliderThumb,
    MediaTextTrackDisplayContainer,
    MediaTextTrackDisplay,
    MediaExitFullscreenButton,
    MediaOverlayPlayButton,
    MediaCastOffButton,
    MediaCastOnButton,
    MediaOverlayCastOffButton,
    MediaOverlayCastOnButton,
};

HTMLMediaElement* toParentMediaElement(Node*);
inline HTMLMediaElement* toParentMediaElement(RenderObject* renderer) { return toParentMediaElement(renderer->node()); }

MediaControlElementType mediaControlElementType(Node*);

// ----------------------------

class MediaControlElement : public WillBeGarbageCollectedMixin {
public:
    void hide();
    void show();

    MediaControlElementType displayType() { return m_displayType; }

    virtual void trace(Visitor*);

protected:
    MediaControlElement(MediaControls&, MediaControlElementType, HTMLElement*);

    MediaControls& mediaControls() const { return m_mediaControls; }
    HTMLMediaElement& mediaElement() const;

    void setDisplayType(MediaControlElementType);

private:
    MediaControls& m_mediaControls;
    MediaControlElementType m_displayType;
    RawPtrWillBeMember<HTMLElement> m_element;
};

// ----------------------------

class MediaControlDivElement : public HTMLDivElement, public MediaControlElement {
    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(MediaControlDivElement);
public:
    virtual void trace(Visitor*) override;

protected:
    virtual bool isMediaControlElement() const override final { return true; }
    MediaControlDivElement(MediaControls&, MediaControlElementType);
};

// ----------------------------

class MediaControlInputElement : public HTMLInputElement, public MediaControlElement {
    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(MediaControlInputElement);
public:
    virtual void trace(Visitor*) override;

protected:
    virtual bool isMediaControlElement() const override final { return true; }
    MediaControlInputElement(MediaControls&, MediaControlElementType);

private:
    virtual void updateDisplayType() { }
    virtual bool isMouseFocusable() const override;
};

// ----------------------------

class MediaControlTimeDisplayElement : public MediaControlDivElement {
public:
    void setCurrentValue(double);
    double currentValue() const { return m_currentValue; }

protected:
    MediaControlTimeDisplayElement(MediaControls&, MediaControlElementType);

private:
    double m_currentValue;
};

} // namespace blink

#endif // MediaControlElementTypes_h


text:
local mod	= DBM:NewMod(1195, "DBM-Highmaul", nil, 477)
local L		= mod:GetLocalizedStrings()

mod:SetRevision(("$Revision: 14994 $"):sub(12, -3))
mod:SetCreatureID(78948, 80557, 80551, 99999)--78948 Tectus, 80557 Mote of Tectus, 80551 Shard of Tectus
mod:SetEncounterID(1722)--Hopefully win will work fine off this because otherwise tracking shard deaths is crappy
mod:SetZone()
mod:SetMinSyncRevision(13109)
mod:SetUsedIcons(8, 7, 6, 5, 4, 3, 2, 1)
mod:SetModelSound("sound\\creature\\tectus\\VO_60_HMR_TECTUS_AGGRO_01.ogg", "sound\\creature\\tectus\\vo_60_hmr_tectus_spell_05.ogg")
mod:SetHotfixNoticeRev(13109)

mod:RegisterCombat("combat")
mod.syncThreshold = 4--Rise Mountain can occur pretty often.
mod:SetWipeTime(30)

mod:RegisterEventsInCombat(
	"SPELL_CAST_START 162475 162968 162894 163312",
	"SPELL_AURA_APPLIED 162346 162658",
	"SPELL_AURA_REMOVED 162346",
	"SPELL_CAST_SUCCESS 181089 181113",
	"SPELL_PERIODIC_DAMAGE 162370",
	"SPELL_ABSORBED 162370",
	"CHAT_MSG_MONSTER_YELL",
	"UNIT_DIED"
)

--TODO, find better icons for adds, these are filler icons for spells they use.
--TODO, figure out what's wrong with DBM-Core stripping most of EJ spellname in specWarnEarthwarper (it's saying "Night - Switch" instead of "Night-Twisted Earthshaper - Switch")
--Tectus
local warnCrystallineBarrage		= mod:NewTargetAnnounce(162346, 3)
local warnBerserker					= mod:NewSpellAnnounce("ej10062", 3, 163312)

local specWarnEarthwarper			= mod:NewSpecialWarningSwitch("ej10061", "-Healer", nil, 2, nil, 2)
local specWarnTectonicUpheaval		= mod:NewSpecialWarningSpell(162475, nil, nil, nil, 2, 2)
local specWarnEarthenPillar			= mod:NewSpecialWarningDodge(162518, nil, nil, nil, 3, 2)
local specWarnCrystallineBarrageYou	= mod:NewSpecialWarningYou(162346, nil, nil, nil, nil, 2)
local yellCrystalineBarrage			= mod:NewYell(162346)
local specWarnCrystallineBarrage	= mod:NewSpecialWarningMove(162370, nil, nil, nil, nil, 2)
--Night-Twisted NPCs
local specWarnRavingAssault			= mod:NewSpecialWarningDodge(163312, "Melee", nil, nil, nil, 2)
local specWarnEarthenFlechettes		= mod:NewSpecialWarningDodge(162968, "Melee", nil, nil, nil, 2)
local specWarnGiftOfEarth			= mod:NewSpecialWarningCount(162894, "Melee", nil, nil, nil, 2)

local timerEarthwarperCD			= mod:NewNextTimer(40, "ej10061", nil, nil, nil, 1, 162894)--Both of these get delayed by upheavel
local timerBerserkerCD				= mod:NewNextTimer(40, "ej10062", nil, "Tank", nil, 1, 163312)--Both of these get delayed by upheavel
local timerGiftOfEarthCD			= mod:NewCDTimer(10.5, 162894, nil, "Melee", nil, 4, nil, DBM_CORE_INTERRUPT_ICON)--10.5 but obviously delayed if stuns were used.
local timerEarthenFlechettesCD		= mod:NewCDTimer(14, 162968, nil, "Melee", nil, 5)--14 but obviously delayed if stuns were used. Also tends to be recast immediately if stun interrupted
local timerCrystalBarrageCD			= mod:NewNextSourceTimer(30, 162346, nil, false, nil, 3)--Very accurate but spammy mess with 4+ adds up.
local timerCrystalBarrage			= mod:NewBuffFadesTimer(15, 162346)

local berserkTimer					= mod:NewBerserkTimer(600)

local countdownEarthwarper			= mod:NewCountdown(41, "ej10061", "Melee")

local voiceCrystallineBarrage		= mod:NewVoice(162346)
local voiceEarthenFlechettes		= mod:NewVoice(162968, "Melee")
local voiceTectonicUpheaval			= mod:NewVoice(162475)
local voiceGiftOfEarth				= mod:NewVoice(162894, "Melee")
local voiceRavingAssault			= mod:NewVoice(163312)
local voiceEarthwarper				= mod:NewVoice("ej10061", "Dps")
local voiceEarthenPillar			= mod:NewVoice(162518, nil )

mod:AddSetIconOption("SetIconOnEarthwarper", "ej10061", true, true)
mod:AddSetIconOption("SetIconOnMote", "ej10064", false, true)--Working with both shard and mote. ej10083 description is bad / This more or less assumes the 4 at a time strat. if you unleash 8 it will fail. Although any guild unleashing 8 is probably doing it wrong (minus LFR)
mod:AddSetIconOption("SetIconOnCrystal", 162370, false)--icons 1 and 2, no conflict with icon on earthwarper

local UnitGUID, UnitExists = UnitGUID, UnitExists
mod.vb.EarthwarperAlive = 0
mod.vb.shardDeath = 0
mod.vb.moteDeath = 0
mod.vb.healthPhase = 0
local earthDuders = {}

local tectusN = EJ_GetEncounterInfo(1195)
local shardN = EJ_GetSectionInfo(10063)
local moteN = EJ_GetSectionInfo(10064)
local moteH = {}
local tectusGUID
local shardGUID = {}
local ltectusH, lshardC, lshardT, lmoteC, lmoteT = 1, 1, 1, 1, 1 -- not need to sync.

function mod:CustomHealthUpdate()
	local tectusH, shardC, shardT, moteC, moteT = 0, 0, 0, 0, 0
	local moteGUID = {}
	for i = 1, 5 do
		local unitID = "boss"..i
		local guid = UnitGUID(unitID)
		if UnitExists(unitID) then
			local cid = self:GetCIDFromGUID(guid)
			if cid == 78948 then
				tectusH = UnitHealth(unitID) / UnitHealthMax(unitID) * 100
				tectusGUID = guid
				ltectusH = tectusH
			elseif cid == 80551 then
				shardC = shardC + 1
				shardT = shardT + (UnitHealth(unitID) / UnitHealthMax(unitID) * 100)
				shardGUID[guid] = true
				lshardC = shardC
				lshardT = shardT
			elseif cid == 80557 then
				local health = UnitHealth(unitID) / UnitHealthMax(unitID) * 100
				moteC = moteC + 1
				moteT = moteT + health
				moteGUID[guid] = true
				lmoteC = moteC
				lmoteT = moteT
				moteH[guid] = health
			end
		end
	end
	for guid, health in pairs(moteH) do
		if not moteGUID[guid] then
			local newhealth = self:GetBossHPByGUID(guid) or health
			if newhealth >= 1 then
				self.vb.healthPhase = 3
				moteC = moteC + 1
				moteT = moteT + newhealth
				moteGUID[guid] = true
				lmoteC = moteC
				lmoteT = moteT
				moteH[guid] = newhealth
			end
		end
	end
	if DBM.BossHealth:IsShown() then
		if DBM.BossHealth:HasBoss(78948) then
			DBM.BossHealth:RemoveBoss(78948)
		end
		if tectusGUID then
			if tectusH > 0 then
				if not DBM.BossHealth:HasBoss(tectusGUID) then
					DBM.BossHealth:AddBoss(tectusGUID, tectusN)
				end
			else
				if DBM.BossHealth:HasBoss(tectusGUID) then
					DBM.BossHealth:RemoveBoss(tectusGUID)
				end
			end
		end
		for guid, value in pairs(shardGUID) do
			if shardT > 0 then
				if not DBM.BossHealth:HasBoss(guid) then
					DBM.BossHealth:AddBoss(guid, shardN)
				end
			else
				if DBM.BossHealth:HasBoss(guid) then
					DBM.BossHealth:RemoveBoss(guid)
				end
			end
		end
		for guid, health in pairs(moteH) do
			if not DBM.BossHealth:HasBoss(guid) then
				DBM.BossHealth:AddBoss(guid, moteN)
			end
		end
	end
	if self.vb.healthPhase == 1 then
		return ("(%d%%, %s)"):format(tectusH > 0 and tectusH or ltectusH, tectusN)
	elseif self.vb.healthPhase == 2 then
		return ("(%d%%, %s)"):format((shardT > 0 and shardT or lshardT) / (shardC > 0 and shardC or lshardC), shardN)
	elseif self.vb.healthPhase == 3 then
		return ("(%d%%, %s)"):format((moteT > 0 and moteT or lmoteT) / (moteC > 0 and moteC or lmoteC), moteN)
	end
	return DBM_CORE_UNKNOWN
end

function mod:OnCombatStart(delay)
	table.wipe(earthDuders)
	self.vb.EarthwarperAlive = 0
	self.vb.moteDeath = 0
	self.vb.shardDeath = 0
	self.vb.healthPhase = 1
	table.wipe(moteH)
	timerEarthwarperCD:Start(8-delay)
	countdownEarthwarper:Start(8-delay)
	timerBerserkerCD:Start(18-delay)
	if self:IsMythic() then
		--Figure out berserk
	elseif self:IsDifficulty("normal", "heroic") then
		berserkTimer:Start(-delay)--Confirmed 10 min in both.
	else
		--Find LFR berserk for LFR
	end
	if DBM.BossHealth:IsShown() then
		DBM.BossHealth:Clear()
	end
end

function mod:OnCombatEnd()
end

function mod:SPELL_CAST_START(args)
	local spellId = args.spellId
	if spellId == 162475 and self:AntiSpam(5, 1) then--Antispam for later fight.
		specWarnTectonicUpheaval:Show()
		voiceTectonicUpheaval:Play("aesoon")
	elseif spellId == 162968 then
		local guid = args.souceGUID
		specWarnEarthenFlechettes:Show()
		timerEarthenFlechettesCD:Start(guid)
		if guid == UnitGUID("target") or guid == UnitGUID("focus") then
			voiceEarthenFlechettes:Play("shockwave")
		end
	elseif spellId == 162894 then
		local GUID = args.sourceGUID
		--Support for counts for each earth guy up.
		if not earthDuders[GUID] then
			earthDuders[GUID] = 0
		end
		earthDuders[GUID] = earthDuders[GUID] + 1
		specWarnGiftOfEarth:Show(earthDuders[GUID])
		timerGiftOfEarthCD:Start(GUID)
		voiceGiftOfEarth:Play("162894")
	elseif spellId == 163312 then
		specWarnRavingAssault:Show()
		voiceRavingAssault:Play("chargemove")
	end
end

function mod:SPELL_AURA_APPLIED(args)
	local spellId = args.spellId
	if spellId == 162346 then
		warnCrystallineBarrage:CombinedShow(1, args.destName)
		timerCrystalBarrageCD:Start(30, args.sourceName, args.sourceGUID)
		if args:IsPlayer() then
			specWarnCrystallineBarrageYou:Show()
			timerCrystalBarrage:Start()
			if not self:IsLFR() then
				yellCrystalineBarrage:Yell()
				voiceCrystallineBarrage:Play("runout")
			end
		end
		if self.Options.SetIconOnCrystal and self.vb.healthPhase ~= 3 then
			self:SetSortedIcon(1, args.destName, 1, 2)--Wait 3 seconds or until we have 2 targets, mobs sometimes stagger casts.
		end
	elseif spellId == 162658 then
		local guid = args.destGUID
		local cid = self:GetCIDFromGUID(guid)
		if cid == 80557 then
			if not moteH[guid] then
				moteH[guid] = 0
			end
			if self.Options.SetIconOnMote and not self:IsLFR() then--Don't mark kill/pickup marks in LFR, it'll be an aoe fest.
				if self:AntiSpam(5, 3) then
					self:ClearIcons()--Clear any barrage icons
					self:CustomHealthUpdate()--Force update to health phase 3
				end
				self:ScanForMobs(guid, 0, 8, 8, 0.1, 20, "SetIconOnMote")
			end
		end
	end
end

function mod:SPELL_AURA_REMOVED(args)
	local spellId = args.spellId
	if spellId == 162346 then
		if args:IsPlayer() then
			timerCrystalBarrage:Stop()
		end
		if self.Options.SetIconOnCrystal then
			self:SetIcon(args.destName, 0)
		end
	end
end

function mod:SPELL_CAST_SUCCESS(args)
	local spellId = args.spellId
	if spellId == 181113 then--Encounter Spawn
		local cid = self:GetCIDFromGUID(args.sourceGUID)
		if cid == 80599 then--Earth Warper
			self.vb.EarthwarperAlive = self.vb.EarthwarperAlive + 1
			specWarnEarthwarper:Show()
			voiceEarthwarper:Play("killmob")
			timerGiftOfEarthCD:Start(10)--TODO, verify timing on new event
			timerEarthenFlechettesCD:Start(15)--TODO, verify timing on new event
			timerEarthwarperCD:Start()--TODO, verify timing on new event
			countdownEarthwarper:Start()--TODO, verify timing on new event
			if self.Options.SetIconOnEarthwarper and self.vb.EarthwarperAlive < 9 and not (self:IsMythic() and self.Options.SetIconOnMote) then--Support for marking up to 8 mobs (you're group is terrible)
				self:ScanForMobs(80599, 2, 9-self.vb.EarthwarperAlive, 1, 0.2, 13, "SetIconOnEarthwarper")
			end
		elseif cid == 80822 then
			warnBerserker:Show()
			timerBerserkerCD:Start()
		end
	elseif spellId == 181089 then--Encounter Event
		local cid = self:GetCIDFromGUID(args.sourceGUID)
		if cid == 78948 then
			self.vb.healthPhase = 2
			if not self:IsMythic() then
				timerEarthwarperCD:Stop()
				countdownEarthwarper:Cancel()
				timerBerserkerCD:Stop()
			end
		elseif cid == 80551 then
			self.vb.shardDeath = self.vb.shardDeath + 1
			if self.vb.shardDeath == 2 then
				self.vb.healthPhase = 3
			end
		elseif cid == 80557 then--Mote of Tectus
			self.vb.moteDeath = self.vb.moteDeath + 1
			if self.vb.moteDeath == 8 then
				DBM:EndCombat(self)
			end
		end
	end
end

function mod:SPELL_PERIODIC_DAMAGE(sourceGUID, sourceName, _, _, destGUID, destName, _, _, spellId)
	if spellId == 162370 then
		if (self.vb.healthPhase == 0 or self.vb.healthPhase == 3) and not moteH[sourceGUID] and sourceName == moteN then -- try to recover moteH table if timer recovery worked.
			moteH[sourceGUID] = 0
		end
		if destGUID == UnitGUID("player") and self:AntiSpam(2, 2) then
			specWarnCrystallineBarrage:Show()
			voiceCrystallineBarrage:Play("runaway")
		end
	end
end
mod.SPELL_ABSORBED = mod.SPELL_PERIODIC_DAMAGE

function mod:UNIT_DIED(args)
	local cid = self:GetCIDFromGUID(args.destGUID)
	if cid == 80599 then
		local GUID = args.destGUID
		self.vb.EarthwarperAlive = self.vb.EarthwarperAlive - 1
		timerGiftOfEarthCD:Cancel(GUID)--Only issue is that this won't cancel the FIRST timer which lacks a GUID, if you manage to kill it before first cast
		timerEarthenFlechettesCD:Cancel(GUID)
		earthDuders[GUID] = nil
	end
end

function mod:CHAT_MSG_MONSTER_YELL(msg, npc)
	if msg == L.pillarSpawn or msg:find(L.pillarSpawn) then
		self:SendSync("TectusPillar")
	end
end

function mod:OnSync(msg)
	if msg == "TectusPillar" and self:IsInCombat() then
		specWarnEarthenPillar:Show()
		voiceEarthenPillar:Play("watchstep")
	end
end


text:
CKEDITOR.plugins.setLang( 'sourcearea', 'fr', {
	toolbar: 'Source'
});


text:
package com.yueny.blog.console.vo.article;

import com.yueny.superclub.util.common.pojo.BaseBo;

import lombok.Getter;
import lombok.Setter;

/**
 * 全站文章分类

 * @author yueny09 <deep_blue_yang@163.com>
 *
 * @DATE 2018年1月10日 上午12:03:02
 *
 */
@Getter
@Setter
public class ArticleBlogForCategoryTagModel extends BaseBo {
	/** */
	private static final long serialVersionUID = 6938452333399672864L;

	/** 全站文章分类编号 */
	private String categoryTagCode;
	/** 全站文章分类名称 */
	private String categoryTagName;
}


text:
package org.geometerplus.zlibrary.text.view;

interface PaintStateEnum {
	int NOTHING_TO_PAINT = 0;
	int READY = 1;
	int START_IS_KNOWN = 2;
	int END_IS_KNOWN = 3;
	int TO_SCROLL_FORWARD = 4;
	int TO_SCROLL_BACKWARD = 5;
};


text:
<!DOCTYPE html>
<?php
	include('redirect-search.php');
?>

	<link rel="icon" href="img/favicon2.ico">
	<title>Search | Twitter</title>

	<meta charset="utf-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">

	<link href="src/bootstrap/css/bootstrap.min.css" rel="stylesheet">

	<link rel="stylesheet" href="src/bootstrap/css/bootstrap-theme.min.css">

<?php
$res_string="";
$keyword_valid = $type_valid = $cat1_valid = $cat2_valid = $cat3_valid = $cat4_valid = false;

if (empty($_GET["keyword"])){
	$keyword= "";
} else {
	$keyword = $_GET["keyword"];
	$keyword_valid = true;
}

if (empty($_GET["type"])){
	$type= "";
} else {
	$type = $_GET["type"];
	$type_valid = true;
}

if (empty($_GET["cat1"])){
	$cat1= "";
} else {
	$cat1 = unserialize(urldecode($_GET['cat1']));
	$cat1_valid = true;
}
if($cat1_valid){
	$cat1length = count($cat1);
	$sport_keywords='';
	for($x=0;$x<$cat1length;$x++){
		if($x != 0){ $sport_keywords .= '--'; }
		$sport_keywords .= trim($cat1[$x]);
	}
}

if (empty($_GET["cat2"])){
	$cat2= "";
} else {
	$cat2 = unserialize(urldecode($_GET['cat2']));
	$cat2_valid = true;
}
if($cat2_valid){
	$cat2length = count($cat2);
	$hiburan_keywords='';
	for($x=0;$x<$cat2length;$x++){
		if($x != 0){ $hiburan_keywords .= '--'; }
		$hiburan_keywords .= trim($cat2[$x]);
	}
}

if (empty($_GET["cat3"])){
	$cat3= "";
} else {
	$cat3 = unserialize(urldecode($_GET['cat3']));
	$cat3_valid = true;
}
if($cat3_valid){
	$cat3length = count($cat3);
	$teknologi_keywords='';
	for($x=0;$x<$cat3length;$x++){
		if($x != 0){ $teknologi_keywords .= '--'; }
		$teknologi_keywords .= trim($cat3[$x]);
	}
}
if (empty($_GET["cat4"])){
	$cat4= "";
} else {
	$cat4 = unserialize(urldecode($_GET['cat4']));
	$cat4_valid = true;
}
if($cat4_valid){
	$cat4length = count($cat4);
	$health_beauty_keywords='';
	for($x=0;$x<$cat4length;$x++){
		if($x != 0){ $health_beauty_keywords .= '--'; }
		$health_beauty_keywords .= trim($cat4[$x]);
	}
}
?>

	<?php include('navbar.php');?>

Search on Twitter

								<form role="form" method="post" action="<?php echo htmlspecialchars($_SERVER["PHP_SELF"]);?>" enctype="multipart/form-data">

											Hashtag

											<input required type="text" name="keyword" class="form-control input-sm" placeholder="Keyword">

											Sport

											<input required type="text" name="category1" class="form-control input-sm" placeholder="Sport-related keywords">

											Hiburan

											<input required type="text" name="category2" class="form-control input-sm" placeholder="Hiburan-related keywords">

											Teknologi

											<input required type="text" name="category3" class="form-control input-sm" placeholder="Teknologi-related keywords">

											Health &  Beauty

											<input required type="text" name="category4" class="form-control input-sm" placeholder="Health & Beauty-related keywords">

										Type

											<input type="radio" name="type" value="KMP" required>KMP

											<input type="radio" name="type" value="BM">BM

								<input type="submit" value="Get Tweets" class="btn btn-info btn-block">

								</form>

Perform another search

				Cancel search

Sport

Hiburan

Teknologi

Health & Beauty

Unknown

Hasil Sport

Hasil Hiburan

Hasil Teknologi

Hasil Health & Beauty

Hasil Unknown

<?php
ini_set('max_execution_time', 300);

if(($keyword_valid) && ($type_valid) && ($cat1_valid) && ($cat2_valid) && ($cat3_valid) && ($cat4_valid)){
		//session_start();
		ob_end_flush();
		ob_start();
		$descriptorspec = array(
			0 => array("pipe", "r"),   // stdin is a pipe that the child will read from
			1 => array("pipe", "w")   // stdout is a pipe that the child will write to
			//2 => array("pipe", "w")    // stderr is a pipe that the child will write to
		);
		$count = 0;
		$count_found = 1;
		$count_sport = 0;
		$count_hiburan = 0;
		$count_teknologi = 0;
		$count_healthbeauty = 0;
		$count_unknown = 0;
		$process = proc_open("java -cp .;twitter4j/lib/twitter4j-core-4.0.3.jar Main ".escapeshellarg($keyword)." ".escapeshellarg($type)." ".escapeshellarg($sport_keywords)." ".escapeshellarg($hiburan_keywords)." ".escapeshellarg($teknologi_keywords)." ".escapeshellarg($health_beauty_keywords), $descriptorspec, $pipes);
		//$process = proc_open("java main2", $descriptorspec, $pipes);
		$percent = 0;
		$finish = false;
		if (is_resource($process)) {
			echo '';
					if(strcmp ($tag,"sport") == 0){
						$count_sport++;
						echo '';
						echo '';
						echo '';
					} else if(strcmp ($tag,"hiburan") == 0){
						$count_hiburan++;
						echo '';
						echo '';
						echo '';
					} else if (strcmp ($tag,"teknologi") == 0){
						$count_teknologi++;
						echo '';
						echo '';
						echo '';
					} else if (strcmp ($tag,"healthbeauty") == 0){
						$count_healthbeauty++;
						echo '';
						echo '';
						echo '';
					} else if (strcmp ($tag,"unknown") == 0){
						$count_unknown++;
						echo '';
						echo '';
						echo '';
					}
					$count_found++;
					$str = stream_get_line($pipes[1],1024,"[/catend]");
				} else if (strcmp($tag,"notmatch") == 0){
					$str = stream_get_line($pipes[1],1024,"[/notmatch]");
				}
			$count++;
			echo str_repeat(' ',1024 * 64);
			flush();
			}
			$count_found--;
		}
		proc_close($process);
} else {
	echo '';
}

?>

		(C) 2015 Tweet Hunt


text:
voteserver
==========

A simple node+sockjs server for voting on things.

# How

Nothing magical here; `npm install voteserver` to get started.

`require('voteserver')` will return `{Client: ctor(), makeServer: initFunc()`.
The documentation for `Client` is [here](https://github.com/bengreenier/voteserver/tree/master/js-client)
(note, where it says `require('voter')` you'll use `require('voteserver').Client`).
The documentation for `makeServer` is here!

## makeServer(opts)

> Note that using makeServer in v0.1.0 will flood the console with log messages. Will fix soon!

This will create a voteserver. Opts may contain any of the following:

```
{
	server: http.Server, // an existing http server to mount on

	// how long the user is considered "still active" without connection
	userTTL: 30 * 60, // in seconds

	// where the sockjs service is mounted
	mountPoint: "/ws"
}
```

For example:

```
var voteserver = require('voteserver');

var server = voteserver.makeServer({
		userTTL: 15, // in seconds
		mountPoint: "/ws"
	});

server.listen(1337);
```

## Running example

You can simply `npm start` in this directory to run [server.js](https://github.com/bengreenier/voteserver/blob/master/server.js) which is a working example server.

# License

MIT LICENSE


text:
'use strict';

exports.type = 'perItem';
exports.active = true;

var
  convertPathDataPlugin = require('./utils/convertPathDataPlugin'),
  svgoDefinitions = require('./utils/svgoDefinitions'),
  pathElems = svgoDefinitions.pathElems;

exports.params = convertPathDataPlugin.params;

/**
 * Force transform path elements with stroke.
 *
 * @param {Object} item current iteration item
 * @return {Boolean} if false, item will be filtered out
 *
 */
exports.fn = function(item, params) {
  var
    stroke;

  if (item.isElem(pathElems) && item.hasAttr('d') && item.hasAttr('stroke') && item.hasAttr('transform')) {
    stroke = item.attr('stroke');
    item.removeAttr(stroke.name);
    convertPathDataPlugin.fn.call(this, item, params);
    item.addAttr(stroke);
  }

};


text:
class Pyramid
{
public:
    Pyramid();
    ~Pyramid();
    int* GetIndexData();
    VERTEX *GetVertexData();
    int GetNumOfVertices();
    int GetNumOfIndecies();
    std::vector<std::tuple<float, float, float>> vertices;
    std::vector<std::tuple<int, int, int>> faces;

    int NumOFIndecies;
    int NumOfVertecies;
};


text:
package org.motechproject.scheduletracking.domain;

/**
 * The WindowName Enum contains the possible names for
 * a milestone window.
 */
public enum WindowName {

    /**
     * The first window of the milestone.
     */
    earliest,

    /**
     * The second window of the milestone.
     */
    due,

    /**
     * The third window of the milestone.
     */
    late,

    /**
     * The last window of the milestone.
     */
    max;
}


text:
function springDampers = springDampersModify(springDampers, springDamperVals, startPoints, ...
                                         staticPoints, widths, springConst, ...
                                         damperConst)

% SPRINGDAMPERSMODIFY Helper code for visualisation of springDamper data.
% FORMAT
% DESC is a helper function for visualising spring dampers using latent
% variable models.
% ARG springDampers : array of spring damper drawing objects.
% ARG springDamperValues : the values to set the springDamper data to.
% ARG startPoints : the fixed points of the spring damers.
% ARG widths : the widths of the spring dampers.
% ARG springConst : the spring constants of the spring dampers.
% ARG damperConst : the damper constants of the spring dampers.
% RETURN springDampers : contains array of spring damper objects.
%
% COPYRIGHT : Neil D. Lawrence, 2003, 2004, 2006
%
% SEEALSO : springDamperVisualise, fgplvmResultsDynamic

% GPMAT

for i = 1:length(springDampers)
  vec = (staticPoints(i, :) - springDampers(i).start);
  vecNorm = vec./(sum(sqrt(vec.^2)));
  springDampers(i).end = springDamperVals(i)*vecNorm + staticPoints(i, :);
end
springDampers = springDamperDraw(springDampers);


text:
using Newtonsoft.Json;
using System;
using System.Linq;
using System.Web;

namespace Bot.Builder.ChannelConnector.Facebook.Schema
{
    // This is the message, facebook sends to us
    public class FacebookRequestMessage
    {
        [JsonProperty("object")]
        public string Object { get; set; }
        [JsonProperty("entry")]
        public FacebookEntry[] Entries { get; set; }
    }
}


text:
<!DOCTYPE html>

		<title>StorageJS Tests: cookie</title>

StorageJS Tests: cookie

		<button onclick="runTests();">Run Tests</button>


text:
import Ember from 'ember';
import layout from '../templates/components/ui-checkbox';
import SemanticSettings from '../mixins/semantic-settings';

export default Ember.Component.extend(SemanticSettings, {
  classNames: ['ui', 'checkbox'],
  moduleName: 'checkbox',
  init: function () {
    this.set('inputId', Ember.generateGuid());
    this._super();
  },
  layout: layout,
  actions: {
    check() {
      this.toggleProperty('isChecked');
    }
  }
});


text:
package com.salesmanager.shop.store.controller.manufacturer.facade;

import java.util.List;
import com.salesmanager.core.model.catalog.product.manufacturer.Manufacturer;
import com.salesmanager.core.model.merchant.MerchantStore;
import com.salesmanager.core.model.reference.language.Language;
import com.salesmanager.shop.model.catalog.manufacturer.PersistableManufacturer;
import com.salesmanager.shop.model.catalog.manufacturer.ReadableManufacturer;
import com.salesmanager.shop.model.catalog.manufacturer.ReadableManufacturerList;
import com.salesmanager.shop.model.entity.ListCriteria;

/**
 * Manufacturer / brand / collection product grouping
 * @author carlsamson
 *
 */
public interface ManufacturerFacade {

  List<ReadableManufacturer> getByProductInCategory(MerchantStore store, Language language, Long categoryId);

  /**
   * Creates or saves a manufacturer
   *
   * @param manufacturer
   * @param store
   * @param language
   * @throws Exception
   */
  void saveOrUpdateManufacturer(PersistableManufacturer manufacturer, MerchantStore store,
      Language language) throws Exception;

  /**
   * Deletes a manufacturer
   *
   * @param manufacturer
   * @param store
   * @param language
   * @throws Exception
   */
  void deleteManufacturer(Manufacturer manufacturer, MerchantStore store, Language language)
      throws Exception;

  /**
   * Get a Manufacturer by id
   *
   * @param id
   * @param store
   * @param language
   * @return
   * @throws Exception
   */
  ReadableManufacturer getManufacturer(Long id, MerchantStore store, Language language)
      throws Exception;

  /**
   * Get all Manufacturer
   *
   * @param store
   * @param language
   * @return
   * @throws Exception
   */
  ReadableManufacturerList getAllManufacturers(MerchantStore store, Language language, ListCriteria criteria, int page, int count) ;

  /**
   * List manufacturers by a specific store
   * @param store
   * @param language
   * @param criteria
   * @param page
   * @param count
   * @return
   */
  ReadableManufacturerList listByStore(MerchantStore store, Language language, ListCriteria criteria, int page, int count) ;

  /**
   * Determines if manufacturer code already exists
   * @param store
   * @param manufacturerCode
   * @return
   */
  boolean manufacturerExist(MerchantStore store, String manufacturerCode);

}


text:
'''program causing an error with an undefined variable'''

def main():
    x = 3
    f()

def f():
    print(x)  # error: f does not know about the x defined in main

main()


text:
<!doctype html>

<meta charset="utf-8">
<title>unique-number</title>

<link rel="stylesheet" href="../node_modules/mocha/mocha.css"/>


text:
'use strict';

var mongoose = require('mongoose'),
    Plan = mongoose.model('Plan'),
    Activity = mongoose.model('Activity'),
    NutritionProfile = mongoose.model('NutritionProfile'),
    BodyStats = mongoose.model('BodyStats'),
    _ = require('lodash');

/**
 * Module dependencies.
 */
exports.index = function(req, res) {
	res.render('index', {
		user: req.user || null
	});
};

exports.getDailyDashboardData = function(req, res){
    if(req.user) {
        var dashboardData = {};

        var planDate = req.param("planDate");

        var split = planDate.split('_');
        var month = parseInt(split[0]);
        var day = parseInt(split[1]);
        var year = parseInt(split[2]);

        Plan.findOne({'planDateYear': year, 'planDateMonth': month, 'planDateDay': day, 'user': req.user.id}).exec(function (err, plan) {
            if (err) return next(err);

            dashboardData.nutritionPlan = plan;

            Activity.findOne({'planDateYear': year, 'planDateMonth': month, 'planDateDay': day, 'user': req.user.id}).exec(function (err, activity) {
                if (err) return next(err);
                //if (!activity) return next(new Error('Failed to load activity with date: ' + activityDate));
                dashboardData.activityPlan = activity;

                BodyStats.findOne({'planDateYear': year, 'planDateMonth': month, 'planDateDay': day, 'user': req.user.id}).exec(function (err, bodyStat) {
                    if (err) return next(err);
                    dashboardData.dailyBodyStats = bodyStat;

                    //if (!activity) return next(new Error('Failed to load activity with date: ' + activityDate));
                    res.jsonp(dashboardData);
                });
            });

        });

    }
};

/**
 * Get the error message from error object
 */
var getErrorMessage = function(err) {
    var message = '';

    if (err.code) {
        switch (err.code) {
            case 11000:
            case 11001:
                message = 'activity already exists';
                break;
            default:
                message = 'Something went wrong';
        }
    } else {
        for (var errName in err.errors) {
            if (err.errors[errName].message) message = err.errors[errName].message;
        }
    }

    return message;
};


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Revue mycol. , Toulouse 17: 168 (1895)

#### Original name
Leptosphaeria chelidonii Fautrey

### Remarks
null


text:
require 'spec_helper'

describe Members::AuthorizedDestroyService, services: true do
  let(:member_user) { create(:user) }
  let(:project) { create(:empty_project, :public) }
  let(:group) { create(:group, :public) }
  let(:group_project) { create(:empty_project, :public, group: group) }

  def number_of_assigned_issuables(user)
    Issue.assigned_to(user).count + MergeRequest.assigned_to(user).count
  end

  context 'Group member' do
    it "unassigns issues and merge requests" do
      group.add_developer(member_user)

      issue = create :issue, project: group_project, assignee: member_user
      create :issue, assignee: member_user
      merge_request = create :merge_request, target_project: group_project, source_project: group_project, assignee: member_user
      create :merge_request, target_project: project, source_project: project, assignee: member_user

      member = group.members.find_by(user_id: member_user.id)

      expect { described_class.new(member, member_user).execute }
        .to change { number_of_assigned_issuables(member_user) }.from(4).to(2)

      expect(issue.reload.assignee_id).to be_nil
      expect(merge_request.reload.assignee_id).to be_nil
    end
  end

  context 'Project member' do
    it "unassigns issues and merge requests" do
      project.team << [member_user, :developer]

      create :issue, project: project, assignee: member_user
      create :merge_request, target_project: project, source_project: project, assignee: member_user

      member = project.members.find_by(user_id: member_user.id)

      expect { described_class.new(member, member_user).execute }
        .to change { number_of_assigned_issuables(member_user) }.from(2).to(0)
    end
  end
end


text:
{% verbatim %}

    <form class="form-horizontal visible formReset">

                Title:

                    <input id="inputTitle" type="text" class="form-control" ng-model="newCompostable.title" placeholder="Title">

                    Carbon:

                        <input id="inputCarbon" type="number" class="form-control" ng-model="newCompostable.carbon">

                    Nitrogen:

                        <input id="inputNitro" type="number" class="form-control" ng-model="newCompostable.nitrogen">

                    Description:

                        <input id="inputDesc" type="text" class="form-control" ng-model="newCompostable.description">

                    <button id="compSaveBtn" class="btn btn-default" ng-click="saveCompostable()">Save Compostable</button>

    </form>

{% endverbatim %}


text:
package vbox

import (
	"testing"

	apitests "github.com/rexray/rexray/libstorage/api/tests"

	// load the driver packages
	"github.com/rexray/rexray/libstorage/drivers/storage/vbox"
	_ "github.com/rexray/rexray/libstorage/drivers/storage/vbox/storage"
)

func TestSuite(t *testing.T) {
	apitests.RunSuite(t, vbox.Name)
}


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

#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_INTERNAL_COMPILER_INFO_H
#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_INTERNAL_COMPILER_INFO_H

#include "google/cloud/version.h"
#include <string>

namespace google {
namespace cloud {
GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
namespace internal {
/**
 * Returns the compiler ID.
 *
 * The Compiler ID is a string like "GNU" or "Clang", as described by
 * https://cmake.org/cmake/help/v3.5/variable/CMAKE_LANG_COMPILER_ID.html
 */
std::string CompilerId();

/**
 * Returns the compiler version.
 *
 * This string will be something like "9.1.1".
 */
std::string CompilerVersion();

/**
 * Returns certain interesting compiler features.
 *
 * Currently this returns one of "ex" or "noex" to indicate whether or not
 * C++ exceptions are enabled.
 */
std::string CompilerFeatures();

/**
 * Returns the 4-digit year of the C++ language standard.
 */
std::string LanguageVersion();

}  // namespace internal
GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
}  // namespace cloud
}  // namespace google

#endif  // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_INTERNAL_COMPILER_INFO_H


text:
'use strict';

module.exports = function(grunt) {

  var bower = require('bower');
  var DepTree = require('deptree');
  var fs = require('fs');

  var getList = function(cb) {
    bower.commands.list({ json: true }, { offline: true })
      .on('end', function(data) {
        cb(null, data);
      })
      .on('error', cb);
  };
  var getPaths = function(cb) {
    bower.commands.list({ paths: true }, { offline: true })
      .on('end', function(data) {
        cb(null, data);
      })
      .on('error', cb);
  };

  var getDeps = function(name, deps, deptree) {
    if (name) {
      deptree.add(name, Object.keys(deps));
    }
    for (var depname in deps) {
      getDeps(depname, deps[depname].dependencies, deptree);
    }
  };

  var getFile = function(main, type) {
    var files = main.split(',');
    var filter = files.filter(function(item) {
      return (item.indexOf(type) !== -1);
    });

    return (filter.length !== 0) ? filter : null;
  };

  grunt.registerMultiTask('bower', 'A grunt plugin to concat bower dependencies', function() {
    var type = this.data.type || '.js';
    var exclude = this.data.exclude || [];
    var overridePaths = this.data.paths || {};
    var additionalDeps = this.data.additionalDeps || {};
    var dest = this.data.dest;
    var async = grunt.util.async;

    var done = this.async();

    var process = function(err, results) {
      if (err){
        grunt.fatal(err);
      }
      else {
        var paths = results[0];
        var sources = results[1].dependencies;
        var devDeps = results[1].pkgMeta.devDependencies;

        //remove dev deps
        for (var key in devDeps) {
          delete sources[key];
        }

        var deptree = new DepTree();

        getDeps(false, sources, deptree);
        if (additionalDeps) {
          for (var key in additionalDeps) {
            deptree.add(key, additionalDeps[key]);
          }
        }
        var deps = deptree.resolve();

        var out = '';

        deps.forEach(function(dep){
          var file = overridePaths[dep] || paths[dep];
          file = getFile(file, type);

          if (typeof file === 'string') {
            file = [file];
          }
          if (!file || file.length === 0) {
            grunt.log.writeln('Not including ' + dep + ' because doesn\'t match file type');
          } else {
            file.forEach(function(f) {
              if (!fs.existsSync(f) || fs.lstatSync(f).isDirectory()) {
                grunt.log.error('Not including '+ dep + ' because main is not set');
              } else if (exclude.indexOf(dep) !== -1) {
                grunt.log.writeln('Skipping '+ dep +' ('+f+')');
              } else {
                grunt.log.writeln('Including '+ dep + ' ('+f+')');
                out += grunt.file.read(f);
              }
            });
          }
        });

        grunt.file.write(dest, out);
        grunt.log.writeln(dest + ' written');
        done();
      }
    };
    async.parallel([getPaths, getList], process);
  });
};


text:
var AskQuestion = require('../restapi/questions/ask.question.js');
var DetailQuestion = require('../restapi/questions/detail.question.js');
var TabTopQ = require('../restapi/tabquestions/tab.top.questions.js');
var TabInterestQ = require('../restapi/tabquestions/tab.interesting.questions.js');
var TabFeaturedQ = require('../restapi/tabquestions/tab.featured.questions.js');
var TabHotQ = require('../restapi/tabquestions/tab.hot.questions.js');
var TabWeekQ = require('../restapi/tabquestions/tab.week.questions.js');
var TabMonthQ = require('../restapi/tabquestions/tab.month.questions.js');

var AllQuestions = require('../restapi/questions/all.questions.js');
var NewestQuestions = require('../restapi/questions/newest.questions.js');
var FeaturedQuestions = require('../restapi/questions/featured.questions.js');
var FrequentQuestions = require('../restapi/questions/frequent.questions.js');
var ActiveQuestions = require('../restapi/questions/active.questions.js');
var VotesQuestions = require('../restapi/questions/votes.questions.js');
var ViewsQuestions = require('../restapi/questions/views.questions.js');
var AnswersQuestions = require('../restapi/questions/answers.questions.js');
var UnanswersQuestions = require('../restapi/questions/unanswers.questions.js');

//answer
var NewAnswer = require('../restapi/answers/new.answer.js');

module.exports = {
    //answers
    newAnswer: function(esclient, redis, req, res) {
        NewAnswer.newAnswer(esclient, redis, req, res);
    },

    //questions
    askQuestion: function(esclient, redis, req, res) {
        AskQuestion.askQuestion(esclient, redis, req, res);
    },
    detailQuestion: function(esclient, redis, req, res) {
        DetailQuestion.detailQuestion(esclient, redis, req, res);
    },
    //questions tab== list get frome redis sorted set quene very fast.
    tabTopQuestions: function(esclient, redis, req, res) {
        TabTopQ.tabTopQuestions(esclient, redis, req, res);
    },
    tabInterestingQuestions: function(esclient, redis, req, res) {
        TabInterestQ.tabInterestingQuestions(esclient, redis, req, res);
    },
    tabFeaturedQ: function(esclient, redis, req, res) {
        TabFeaturedQ.tabFeaturedQuestions(esclient, redis, req, res);
    },
    tabHotQuestion: function(esclient, redis, req, res) {
        TabHotQ.tabHotQuestion(esclient, redis, req, res);
    },
    tabWeekQuestions: function(esclient, redis, req, res) {
        TabWeekQ.tabWeekQuestions(esclient, redis, req, res);
    },
    tabMonthQuestion: function(esclient, redis, req, res) {
        TabMonthQ.tabMonthQuestion(esclient, redis, req, res);
    },

    //Questions from ES index sorted by ... list
    allQuestions: function(esclient, redis, req, res) {
    	AllQuestions.allQuestions(esclient, redis, req, res);
    },
    newestQuestions: function(esclient, redis, req, res) {
    	NewestQuestions.newestQuestions(esclient, redis, req, res);
    },
    featuredQuestions: function(esclient, redis, req, res) {
    	FeaturedQuestions.featuredQuestions(esclient, redis, req, res);
    },
    frequentQuestions: function(esclient, redis, req, res) {
    	FrequentQuestions.frequentQuestions(esclient, redis, req, res);
    },
    activeQuestions: function(esclient, redis, req, res) {
    	ActiveQuestions.activeQuestions(esclient, redis, req, res);
    },
    votesQuestions: function(esclient, redis, req, res) {
        VotesQuestions.votesQuestions(esclient, redis, req, res);
    },
    viewsQuestions: function(esclient, redis, req, res) {
    	ViewsQuestions.viewsQuestions(esclient, redis, req, res);
    },
    answersQuestions: function(esclient, redis, req, res) {
    	AnswersQuestions.answersQuestions(esclient, redis, req, res);
    },
    unanswersQuestions: function(esclient, redis, req, res) {
    	UnanswersQuestions.unanswersQuestions(esclient, redis, req, res);
    }

};


text:
<?xml version="1.0" encoding="utf-8"?>
<project>
  <builders>
    <org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
      <condition class="org.jenkins_ci.plugins.run_condition.core.CauseCondition">
        <buildCause>TimerTrigger</buildCause>
        <exclusiveCause>true</exclusiveCause>
      </condition>
      <runner class="org.jenkins_ci.plugins.run_condition.BuildStepRunner$Fail"/>
      <buildStep class="hudson.tasks.Shell">
        <command>java -version</command>
      </buildStep>
    </org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
  </builders>
</project>


text:
package j_combined_app_storage

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"github.com/go-openapi/runtime"

	strfmt "github.com/go-openapi/strfmt"
)

// New creates a new j combined app storage API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) *Client {
	return &Client{transport: transport, formats: formats}
}

/*
Client for j combined app storage API
*/
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
}

/*
JCombinedAppStorageUpsert j combined app storage upsert API
*/
func (a *Client) JCombinedAppStorageUpsert(params *JCombinedAppStorageUpsertParams, authInfo runtime.ClientAuthInfoWriter) (*JCombinedAppStorageUpsertOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewJCombinedAppStorageUpsertParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "JCombinedAppStorage.upsert",
		Method:             "POST",
		PathPattern:        "/remote.api/JCombinedAppStorage.upsert/{id}",
		ProducesMediaTypes: []string{""},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &JCombinedAppStorageUpsertReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*JCombinedAppStorageUpsertOK), nil

}

// SetTransport changes the transport on the client
func (a *Client) SetTransport(transport runtime.ClientTransport) {
	a.transport = transport
}


text:
package org.skk.tide;

/**
 * The runtime exception thrown when a registered handler does handle the specified event.
 *
 * When a handler registers for an event, the handle method needs to be annotated with {@link org.skk.tide.HandleEvent}.
 * If it does not, {@link org.skk.tide.HandlerMethodNotFoundException} is thrown at runtime
 */
public class HandlerMethodNotFoundException extends Exception {
    private final Class<? extends EventHandler> handlerClass;
    private final Class<? extends Event> eventClass;

    public HandlerMethodNotFoundException(Class<? extends EventHandler> handlerClass, Class<? extends Event> eventClass) {

        this.handlerClass = handlerClass;
        this.eventClass = eventClass;
    }

    @Override
    public String getMessage() {
        return "No handler method found for event " + eventClass + " on handler " + handlerClass + ". Make sure the method is annotated with @HandleEvent passing the event class and it takes only one or no arguments";
    }
}


text:
<!DOCTYPE html>

  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <title>User|Print</title>

  <meta content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no" name="viewport">

  <link rel="stylesheet" href="<?php echo base_url();?>assets/bootstrap/css/bootstrap.min.css">

  <link rel="stylesheet" href="<?php echo base_url();?>assets/dist/fonts/font-awesome/css/font-awesome.min.css">

  <link rel="stylesheet" href="<?php echo base_url();?>assets/plugins/daterangepicker/daterangepicker-bs3.css">

  <link rel="stylesheet" href="<?php echo base_url();?>assets/plugins/datepicker/datepicker3.css">

  <link rel="stylesheet" href="<?php echo base_url();?>assets/plugins/iCheck/all.css">

  <link rel="stylesheet" href="<?php echo base_url();?>assets/plugins/colorpicker/bootstrap-colorpicker.min.css">

  <link rel="stylesheet" href="<?php echo base_url();?>assets/plugins/timepicker/bootstrap-timepicker.min.css">

  <link rel="stylesheet" href="<?php echo base_url();?>assets/plugins/select2/select2.min.css">

  <link rel="stylesheet" href="<?php echo base_url();?>assets/dist/css/AdminLTE.min.css">

  <link rel="stylesheet" href="<?php echo base_url();?>assets/dist/css/skins/_all-skins.min.css">
  <![endif]-->

                            SIV NO:
                            <?php echo $siv_details['siv_no']; ?>

                            SIV Grade:
                            <?php echo $siv_details['siv_grade']; ?>

                            Date Of Issue:
                            <?php echo $siv_details['date_of_issue']; ?>

                            No Of Components:
                            <?php echo $siv_details['no_of_components']; ?>

                            SIV Status:
                            <?php echo $siv_details['siv_status']; ?>

                            Entered By:
                            <?php echo $siv_details['entered_by']; ?>

              Component Type
              Component Name
              Date Of Expiry
               Quantity

            <?php
            foreach($component_details as $row) {
                echo "
";
                echo "".$row['component_type']."	";
                echo "".$row['component_name']."	";
                echo "".$row['date_of_expiry']."	";
                echo "".$row['component_quantity']."	";
                echo "
";
            }
            ?>


text:
package org.darkphoenixs.kafka.pool;

import org.darkphoenixs.kafka.core.KafkaMessageNewSender;
import org.darkphoenixs.kafka.core.KafkaMessageSender;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PropertiesLoaderUtils;

import java.io.IOException;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 *
Title: KafkaMessageNewSenderPool

 *
Description: 新Kafka消息发送连接池

 *

 *
连接采用线程安全单例模式

 *
 * @param <K> the type of kafka message key
 * @param <V> the type of kafka message value
 * @author Victor.Zxy
 * @version 1.4.0
 * @see MessageSenderPool
 * @since 2016 /7/26
 */
public class KafkaMessageNewSenderPool<K, V> implements MessageSenderPool<K, V> {

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

    /**
     * The Running.
     */
    protected AtomicBoolean running = new AtomicBoolean(false);

    /**
     * The Props.
     */
    protected Properties props = new Properties();

    /**
     * The Config.
     */
    protected Resource config;

    /**
     * The Sender.
     */
    protected KafkaMessageSender<K, V> sender;

    /**
     * The Pool size (unused).
     *
     * @deprecated
     */
    protected int poolSize;

    /**
     * Gets pool size.
     *
     * @return the pool size
     * @deprecated
     */
    public int getPoolSize() {
        return poolSize;
    }

    /**
     * Sets pool size.
     *
     * @param poolSize the pool size
     * @deprecated
     */
    public void setPoolSize(int poolSize) {
        this.poolSize = poolSize;
    }

    /**
     * Gets props.
     *
     * @return the props
     */
    public Properties getProps() {
        return props;
    }

    /**
     * Sets props.
     *
     * @param props the props
     */
    public void setProps(Properties props) {
        this.props = props;
    }

    /**
     * Gets config.
     *
     * @return the config
     */
    public Resource getConfig() {
        return config;
    }

    /**
     * Sets config.
     *
     * @param config the config
     */
    public void setConfig(Resource config) {
        this.config = config;
        try {
            PropertiesLoaderUtils.fillProperties(props, this.config);
        } catch (IOException e) {
            logger.error("Fill properties failed.", e);
        }
    }

    @Override
    public synchronized void init() {

        sender = new KafkaMessageNewSender<K, V>(props);

        running.set(true);

        logger.info("Message Sender Pool initialized.");
    }

    @Override
    public synchronized void destroy() {

        sender.shutDown();

        running.set(false);

        logger.info("Message Sender pool closed.");
    }

    @Override
    public synchronized boolean isRunning() {

        return running.get();
    }

    @Override
    public KafkaMessageSender<K, V> getSender() {

        if (sender == null)

            sender = new KafkaMessageNewSender<K, V>(props);

        return sender;
    }

    @Override
    public void returnSender(KafkaMessageSender<K, V> sender) {

        // nothing to do.
    }
}


text: Get Basic File Information


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

    Cookie Consent by
      TermsFeed Generator

    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta charset="UTF-8" />
    <link rel="apple-touch-icon" sizes="57x57" href="img/favicon/apple-icon-57x57.png" />
    <link rel="apple-touch-icon" sizes="60x60" href="img/favicon/apple-icon-60x60.png" />
    <link rel="apple-touch-icon" sizes="72x72" href="img/favicon/apple-icon-72x72.png" />
    <link rel="apple-touch-icon" sizes="76x76" href="img/favicon/apple-icon-76x76.png" />
    <link rel="apple-touch-icon" sizes="114x114" href="img/favicon/apple-icon-114x114.png" />
    <link rel="apple-touch-icon" sizes="120x120" href="img/favicon/apple-icon-120x120.png" />
    <link rel="apple-touch-icon" sizes="144x144" href="img/favicon/apple-icon-144x144.png" />
    <link rel="apple-touch-icon" sizes="152x152" href="img/favicon/apple-icon-152x152.png" />
    <link rel="apple-touch-icon" sizes="180x180" href="img/favicon/apple-icon-180x180.png" />
    <link rel="icon" type="image/png" sizes="192x192" href="img/favicon/android-icon-192x192.png" />
    <link rel="icon" type="image/png" sizes="32x32" href="img/favicon/favicon-32x32.png" />
    <link rel="icon" type="image/png" sizes="96x96" href="img/favicon/favicon-96x96.png" />
    <link rel="icon" type="image/png" sizes="16x16" href="img/favicon/favicon-16x16.png" />
    <link rel="manifest" href="img/favicon/manifest.json" />
    <meta name="msapplication-TileColor" content="#ffffff" />
    <meta name="msapplication-TileImage" content="img/favicon/ms-icon-144x144.png" />
    <meta name="theme-color" content="#ffffff" />

    <meta property="og:title" content="scRNA-tools" />
    <meta property="og:url" content="https://www.scrna-tools.org/" />
    <meta property="og:type" content="website" />
    <meta
      property="og:description"
      content="A catalogue of single-cell RNA-sequencing analysis tools"
    />
    <meta property="og:image" content="https://www.scrna-tools.org/img/square.png" />

    <meta name="twitter:card" content="summary" />
    <meta name="twitter:site" content="@scRNAtools" />
    <meta name="twitter:title" content="scRNA-tools table page" />
    <meta name="twitter:description" content="Filter and sort scRNA-seq analysis tools" />
    <meta name="twitter:image" content="https://www.scrna-tools.org/img/square.png" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />

    <meta name="description" content="A catalogue of single-cell RNA-sequencing analysis tools" />
    <title>scRNA-tools</title>

    <link
      rel="stylesheet"
      href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css"
      integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u"
      crossorigin="anonymous"
    />
    <link
      rel="stylesheet"
      href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap-theme.min.css"
      integrity="sha384-rHyoN1iRsVXV4nD0JutlnGaslCJuC7uwjduW9SVrLvRYooPp2bWYgmgJQIXwl/Sp"
      crossorigin="anonymous"
    />
    <link
      rel="stylesheet"
      href="https://unpkg.com/bootstrap-table@1.16.0/dist/bootstrap-table.min.css"
    />
    <link
      rel="stylesheet"
      href="https://unpkg.com/bootstrap-table@1.16.0/dist/extensions/filter-control/bootstrap-table-filter-control.css"
    />
    <link
      href="https://unpkg.com/bootstrap-table@1.16.0/dist/extensions/page-jump-to/bootstrap-table-page-jump-to.min.css"
      rel="stylesheet"
    />
    <link
      rel="stylesheet"
      href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"
    />
    <link rel="stylesheet" type="text/css" href="css/layout.css" />
    <link rel="stylesheet" type="text/css" href="css/index.css" />

Table

Tools

Analysis

Updates

Submit

FAQs

Tools Table

Sort, filter and download the database

      <table
        class="table-dark table-striped"
        id="table"
        data-url="data/tools-table.json"
        data-pagination="true"
        data-page-size="30"
        data-show-pagination-switch="true"
        data-show-extended-pagination="true"
        data-show-jump-to="true"
        data-toggle="table"
        data-show-toggle="true"
        data-show-columns="true"
        data-show-export="true"
        data-export-data-type="all"
        data-filter-control="true"
        data-total-not-filtered-field="totalNotFiltered"
        data-search="true"
        data-advanced-search="true"
      >

              Name

              Platform

              DOIs

              Pub Dates

            Citations

              Code

            Description

              License

              Categories

              Assembly

              Alignment

              UMIs

              Quantification

              Quality Control

              Normalisation

              Imputation

              Integration

              Gene Filtering

              Clustering

              Classification

              Ordering

              Differential Expression

              Marker Genes

              Expression Patterns

              Variable Genes

              Gene Sets

              Gene Networks

              Cell Cycle

              Dimensionality Reduction

              Transformation

              Modality

              Alternative Splicing

              Rare Cells

              Stem Cells

              Immune

              Variants

              Haplotypes

              Allele Specific

              Perturbations

              Visualisation

              Interactive

              Simulation

            Added
            Updated

Cite us

            Zappia L, Phipson B, Oshlack A. "Exploring the single-cell RNA-seq analysis landscape
            with the scRNA-tools database", PLOS Computational Biology (2018), DOI:
            10.1371/journal.pcbi.1006245

About scRNA-tools

            The scRNA-tools database is a catalogue of software packages for analysing single-cell
            RNA sequencing data. It was created by the
            Oshlack Lab, a bioinformatics research group based
            in Melbourne, Australia and is now maintained at the
            Institute of Computational Biology
            in Munich, Germany and by a team of volunteers around the world.
            Contact us here.

Table

Tools

Analysis

Updates

Submit

FAQs

Contact


text:
#include <common.h>
#include <lcd.h>
#include <asm/io.h>
#include <asm/arch/clock.h>
#include <asm/arch/funcmux.h>
#include <asm/arch/pinmux.h>
#include <asm/arch/tegra.h>
#include <asm/gpio.h>

#ifdef CONFIG_MMC_SDHCI_TEGRA
/*
 * Routine: pin_mux_mmc
 * Description: setup the pin muxes/tristate values for the SDMMC(s)
 */
void pin_mux_mmc(void)
{
	funcmux_select(PERIPH_ID_SDMMC4, FUNCMUX_SDMMC4_ATB_GMA_GME_8_BIT);
	funcmux_select(PERIPH_ID_SDMMC2, FUNCMUX_SDMMC2_DTA_DTD_8BIT);

	/* For power GPIO PI6 */
	pinmux_tristate_disable(PMUX_PINGRP_ATA);
	/* For CD GPIO PH2 */
	pinmux_tristate_disable(PMUX_PINGRP_ATD);

	/* For power GPIO PT3 */
	pinmux_tristate_disable(PMUX_PINGRP_DTB);
	/* For CD GPIO PI5 */
	pinmux_tristate_disable(PMUX_PINGRP_ATC);
}
#endif

void pin_mux_usb(void)
{
	funcmux_select(PERIPH_ID_USB2, FUNCMUX_USB2_ULPI);
	pinmux_set_func(PMUX_PINGRP_CDEV2, PMUX_FUNC_PLLP_OUT4);
	pinmux_tristate_disable(PMUX_PINGRP_CDEV2);
	/* USB2 PHY reset GPIO */
	pinmux_tristate_disable(PMUX_PINGRP_UAC);
}

void pin_mux_display(void)
{
	pinmux_set_func(PMUX_PINGRP_SDC, PMUX_FUNC_PWM);
	pinmux_tristate_disable(PMUX_PINGRP_SDC);
}


text:
class AddDonorIdToExternalAccounts < ActiveRecord::Migration
  def change
    add_column :external_accounts, :donor_id, :integer
    add_index :external_accounts, :donor_id
  end
end


text:
class WeaponItemName < ItemName
  def to_s
    @name ||= [possessive, quality, type, suffix].compact.join(' ')
  end
end


text:
require 'rails_helper'
require 'cancan/matchers'

describe Admin::CollectionPresenter do
  let(:id) {  "abcd12345" }
  let(:name) { "Sample Collection" }
  let(:unit) { "Default Unit" }
  let(:description) { "The long form description of this collection." }
  let(:managers) { [manager.to_s] }
  let(:editors) { [editor.to_s] }
  let(:depositors) { [depositor.to_s] }
  let(:manager) { FactoryBot.create(:manager) }
  let(:editor) { FactoryBot.create(:user) }
  let(:depositor) { FactoryBot.create(:user) }
  let(:solr_doc) do
    SolrDocument.new(
      id: id,
      "name_ssi": name,
      "unit_ssi": unit,
      "description_tesim": [description],
      "edit_access_person_ssim": managers + editors,
      "read_access_person_ssim": depositors
    )
  end
  subject(:presenter) { described_class.new(solr_doc) }

  it 'provides getters for descriptive fields' do
    expect(presenter.id).to eq id
    expect(presenter.name).to eq name
    expect(presenter.unit).to eq unit
    expect(presenter.description).to eq description
  end

  it 'provides access control information' do
    expect(presenter.managers).to eq managers
    expect(presenter.editors).to eq editors
    expect(presenter.depositors).to eq depositors
  end

  describe '#as_json' do
    subject(:presenter_json) { presenter.as_json({}) }
    it 'returns json' do
      expect(presenter_json[:id]).to eq id
      expect(presenter_json[:name]).to eq name
      expect(presenter_json[:unit]).to eq unit
      expect(presenter_json[:description]).to eq description
      expect(presenter_json[:object_count]).to be_present
      expect(presenter_json[:roles][:managers]).to eq managers
      expect(presenter_json[:roles][:editors]).to eq editors
      expect(presenter_json[:roles][:depositors]).to eq depositors
    end
  end

  describe 'abilities' do
    subject(:ability) { Ability.new(user, {}) }

    context 'when manager' do
      let(:user) { manager }

      it { is_expected.to be_able_to(:destroy, presenter) }
    end

    context 'when editor' do
      let(:user) { editor }

      it { is_expected.not_to be_able_to(:destroy, presenter) }
    end

    context 'when depositor' do
      let(:user) { depositor }

      it { is_expected.not_to be_able_to(:destroy, presenter) }
    end
  end
end


text:
<?php

namespace Cubiche\Core\Validator\Rules\Numeric;

use Cubiche\Core\Validator\Rules\Rule;

/**
 * Scalar class.
 *
 * @author Ivannis Suárez Jerez <ivannis.suarez@gmail.com>
 */
class Scalar extends Rule
{
}


text:
namespace Jal.Validator.Interface
{
    public interface IValidatorFactory
    {
        IValidator<T>[] Create<T>(T instance, string validationgroup);
    }
}


text:
namespace Facade.Interfaces
{
	internal interface IBank
	{
		/// <summary>
		/// Pays for home.
		/// </summary>
		/// <param name="creditCard">The credit card.</param>
		/// <param name="homeTaxes">The home taxes.</param>
		void PayForHome(ICreditCard creditCard, decimal homeTaxes);

		/// <summary>
		/// Pays for credit.
		/// </summary>
		/// <param name="creditCard">The credit card.</param>
		/// <param name="creditTaxes">The credit taxes.</param>
		void PayForCredit(ICreditCard creditCard, decimal creditTaxes);

		/// <summary>
		/// Pays for university.
		/// </summary>
		/// <param name="creditCard">The credit card.</param>
		/// <param name="universityTaxes">The university taxes.</param>
		void PayForUniversity(ICreditCard creditCard, decimal universityTaxes);
	}
}