text:
<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string name="team">Lag</string>
  <string name="teams">Lag</string>
  <plurals name="nbMembers">
    <item quantity="one">%s medlem</item>
    <item quantity="other">%s medlemmar</item>
  </plurals>
  <string name="allTeams">Alla lag</string>
  <string name="newTeam">Nytt lag</string>
  <string name="myTeams">Mina lag</string>
  <string name="noTeamFound">Inget lag hittat</string>
  <string name="joinTeam">Gå med i lag</string>
  <string name="quitTeam">Lämna lag</string>
  <string name="manuallyReviewAdmissionRequests">Granska antagningsförfrågningar manuellt</string>
  <string name="manuallyReviewAdmissionRequestsHelp">Om markerad behöver spelare skriva en förfrågning för att gå med i laget, som du kan avslå eller godkänna.</string>
  <plurals name="teamLeaders">
    <item quantity="one">Lagledare</item>
    <item quantity="other">Lagledare</item>
  </plurals>
  <string name="teamRecentMembers">Nya medlemmar</string>
  <string name="kickSomeone">Uteslut någon ur laget</string>
  <string name="whoToKick">Vem vill du utesluta ur laget?</string>
  <plurals name="xJoinRequests">
    <item quantity="one">%s förfrågan att gå med</item>
    <item quantity="other">%s förfrågan att gå med</item>
  </plurals>
  <string name="willBeReviewed">Din förfrågan om medlemskap kommer att granskas av lagledaren.</string>
  <string name="beingReviewed">Din förfrågan om medlemskap granskas av lagledaren.</string>
  <string name="subToTeamMessages">Prenumerera på lagmeddelanden</string>
  <string name="teamBattle">Lagmatch</string>
  <string name="teamBattleOverview">En kamp mellan flera lag, varje spelare plockar poäng för sitt lag</string>
  <string name="teamTournament">Turnering inom laget</string>
  <string name="teamTournamentOverview">En arena-turnering som endast medlemmar i ditt lag kan delta i</string>
  <string name="swissTournamentOverview">En schweizerturnering som endast medlemmar i ditt lag kan gå med</string>
  <string name="messageAllMembers">Meddela alla medlemmar</string>
  <string name="messageAllMembersOverview">Skicka ett privat meddelande till varje medlem i laget</string>
  <string name="messageAllMembersLongDescription">Skicka ett privat meddelande till ALLA medlemmar i laget.
Du kan använda detta för att tillkalla spelare att delta i en turnering eller en lagmatch.
Spelare som inte gillar att ta emot dina meddelanden kan komma att lämna laget.</string>
  <string name="teamsIlead">Lag jag leder</string>
  <string name="youWayWantToLinkOneOfTheseTournaments">Du kanske vill länka en av dessa kommande turneringar?</string>
  <string name="usersWhoCanManageThisTeam">Användare som kan managera detta lag</string>
  <string name="leadersChat">Lagledarchatt</string>
  <string name="closeTeam">Avsluta lag</string>
  <string name="closeTeamDescription">Stänger laget för evigt.</string>
  <string name="teamAlreadyExists">Det här lagnamnet finns redan.</string>
  <string name="upcomingTourns">Kommande turneringar</string>
  <string name="completedTourns">Avslutade turneringar</string>
</resources>


text:
namespace piLibs {

class piRenderFont3D
{
public:
    piRenderFont3D();
    ~piRenderFont3D();

    bool Init(piRenderer *renderer, const int fontTytpe, const wchar_t *path);
    void Deinit(piRenderer *renderer);

    void Prints( piRenderer *renderer, float x, float y, float z, float sizex, float sizey, bool doItalic,
				 bool drawCursor, int cursorPos, float cursorTime,
				 const wchar_t *tmp, const float *color, int offsetUniformPos, bool stereoInstances);

private:
    typedef struct
    {
        float        mWidth;
        piRenderMesh mRenderMesh;
        bool         mLoaded;
    }CharInfo;

    piTArray<CharInfo>   mChars;
    int       mFontType;
    bound3    mBBox;
};

} // namespace piLibs

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Collections.Generic;

namespace Thriot.Plugins.Core
{
    public class TelemetryData
    {
        public TelemetryData(string deviceId, string payload, DateTime time)
        {
            DeviceId = deviceId;
            Payload = payload;
            Time = time;
        }

        public string DeviceId { get; private set; }

        public string Payload { get; private set; }

        public DateTime Time { get; private set; }
    }
}


text:
def execute(timePerBlock, head, calloutsFile, dataProcessTime):
    totalCourse = 0
    totalTime = 0
    calloutListPositive = []
    calloutListNegative = []
    calloutsFile.seek(0)

    for line in calloutsFile:
        totalTime += dataProcessTime
        value = int(line) - int(head)
        if value >= 0:
            calloutListPositive.append(value)
        else:
            calloutListNegative.append(value)

    calloutListPositive.sort()
    calloutListNegative.sort()

    while calloutListPositive and calloutListNegative:
        if calloutListPositive[0] <= abs(calloutListNegative[-1]) :
            value = calloutListPositive[0]
            totalCourse += value
            totalTime += timePerBlock * value
            head += calloutListPositive[0]
            calloutListPositive.pop(0)
            calloutListPositive = [x - value for x in calloutListPositive]
            calloutListNegative = [x - value for x in calloutListNegative]
            calloutListPositive.sort()
            calloutListNegative.sort()
        else:
            value = abs(calloutListNegative[-1])
            totalCourse += value
            totalTime += timePerBlock * (value)
            head += calloutListNegative[-1]
            calloutListNegative.pop(-1)
            calloutListPositive = [x + value for x in calloutListPositive]
            calloutListNegative =[x + value for x in calloutListNegative]
            calloutListPositive.sort()
            calloutListNegative.sort()

    while calloutListPositive and not calloutListNegative:
        value = calloutListPositive[0]
        totalCourse += value
        totalTime += timePerBlock * value
        head += calloutListPositive[0]
        calloutListPositive.pop(0)
        calloutListPositive = [x - value for x in calloutListPositive]

    while not calloutListPositive and calloutListNegative:
        value = abs(calloutListNegative[-1])
        totalCourse += value
        totalTime += timePerBlock * value
        head += calloutListNegative[-1]
        calloutListNegative.pop(-1)
        calloutListNegative = [x + value for x in calloutListNegative]

    print("==== SSTF - Results ====")
    print("Total course: ",totalCourse)
    print("Total time:   ",round(totalTime, 2))
    print("\n")


text:
package oauth.Constants;

/**
 * Created by gokhan on 4/8/15.
 */
public class ApiConstants {

    public static String BASE_URL = "https://staj-io-goldenilkay92-1.c9.io/api/v1";
    public static String TOKEN = "oauth/token";
    public static String SIGN_UP = "signup";
    public static String GET_COMPANY_LIST = "";
}


text:
<?php

namespace Google\Service\Document;

class GoogleCloudDocumentaiV1HumanReviewValidationMetadata extends \Google\Model
{
  /**
   * @var float
   */
  public $confidenceThreshold;
  /**
   * @var bool
   */
  public $enableValidation;

  /**
   * @param float
   */
  public function setConfidenceThreshold($confidenceThreshold)
  {
    $this->confidenceThreshold = $confidenceThreshold;
  }
  /**
   * @return float
   */
  public function getConfidenceThreshold()
  {
    return $this->confidenceThreshold;
  }
  /**
   * @param bool
   */
  public function setEnableValidation($enableValidation)
  {
    $this->enableValidation = $enableValidation;
  }
  /**
   * @return bool
   */
  public function getEnableValidation()
  {
    return $this->enableValidation;
  }
}

// Adding a class alias for backwards compatibility with the previous class name.
class_alias(GoogleCloudDocumentaiV1HumanReviewValidationMetadata::class, 'Google_Service_Document_GoogleCloudDocumentaiV1HumanReviewValidationMetadata');


text:
package org.optaplanner.examples.nurserostering.domain.solver;

import org.optaplanner.core.impl.heuristic.selector.common.decorator.SelectionFilter;
import org.optaplanner.core.impl.score.director.ScoreDirector;
import org.optaplanner.examples.nurserostering.domain.NurseRoster;
import org.optaplanner.examples.nurserostering.domain.ShiftAssignment;
import org.optaplanner.examples.nurserostering.domain.ShiftDate;

public class MovableShiftAssignmentSelectionFilter implements SelectionFilter<ShiftAssignment> {

    public boolean accept(ScoreDirector scoreDirector, ShiftAssignment shiftAssignment) {
        NurseRoster nurseRoster = (NurseRoster) scoreDirector.getWorkingSolution();
        return accept(nurseRoster, shiftAssignment);
    }

    public boolean accept(NurseRoster nurseRoster, ShiftAssignment shiftAssignment) {
        ShiftDate shiftDate = shiftAssignment.getShift().getShiftDate();
        return nurseRoster.getNurseRosterInfo().isInPlanningWindow(shiftDate);
    }

}


text:
import mongoose = require('mongoose');

export class CarDatabase {
    private static Schemes = {
        engine_data: new mongoose.Schema({
            rev: Number,
            is_fuel_cut: Number,
            is_af_rich: Number,
            th: Number,
            oil_temp: Number,
            current_total_injected_time: Number,
            current_inject_started_count: Number,
            current_inject_ended_count: Number,
            timestamp: Date,
        }),
        car_data: new mongoose.Schema({
            vattery_voltage: Number,
            wheel_count: Number,
            wheel_rotation_period: Number,
        }),
        basic_inject_time_map: new mongoose.Schema({
            value: Buffer,
        })
    };

    private static Models: { [key: string]: mongoose.Model<mongoose.Document>; } = {}

    static connect() {
        mongoose.connect('mongodb://localhost/cardb');
        for (var name in CarDatabase.Schemes) {
            CarDatabase.Models[name] = mongoose.model(name + '_coll', CarDatabase.Schemes[name]);
        }

    }

    static saveData(id: string, data: Object): void {
        if (!CarDatabase.Models.hasOwnProperty(id)) {
            throw new Error(id + " can't serialize");
        }
        var model = new CarDatabase.Models[id](data);
        model.save();
    }

    static disconnect() {
        mongoose.disconnect();
    }
}


text:
<?php

namespace Shrew\Mazzy\Security;

/**
 * @author  Thomas Girard <thomas@shrewstudio.com>
 * @license http://opensource.org/licenses/MIT
 */
class SecurityException extends \DomainException
{
    public function __construct($message, $code = 403, $previous = null)
    {
        parent::__construct($message, $code, $previous);
    }
}


text:
namespace Cofoundry.Domain.Internal;

/// <summary>
/// Simple mapper for mapping to CustomEntityDefinitionSummary objects.
/// </summary>
public class CustomEntityDefinitionSummaryMapper : ICustomEntityDefinitionSummaryMapper
{
    /// <summary>
    /// Maps a code base custom entity definition into a CustomEntityDefinitionSummary object.
    /// </summary>
    /// <param name="codeDefinition">Code based definition to map.</param>
    public CustomEntityDefinitionSummary Map(ICustomEntityDefinition codeDefinition)
    {
        ArgumentNullException.ThrowIfNull(codeDefinition);

        var result = new CustomEntityDefinitionSummary()
        {
            CustomEntityDefinitionCode = codeDefinition.CustomEntityDefinitionCode,
            Description = codeDefinition.Description,
            ForceUrlSlugUniqueness = codeDefinition.ForceUrlSlugUniqueness,
            Name = codeDefinition.Name,
            NamePlural = codeDefinition.NamePlural,
            AutoGenerateUrlSlug = codeDefinition.AutoGenerateUrlSlug,
            AutoPublish = codeDefinition.AutoPublish,
            HasLocale = codeDefinition.HasLocale,
            Ordering = CustomEntityOrdering.None
        };

        result.DataModelType = codeDefinition.GetDataModelType();
        result.Terms = codeDefinition.GetTerms();

        if (codeDefinition is IOrderableCustomEntityDefinition orderableDefinition)
        {
            result.Ordering = orderableDefinition.Ordering;
        }

        return result;
    }
}


text:
from __future__ import absolute_import

import os
import pytest

from collections import OrderedDict
from datetime import datetime

from sentry.search.base import ANY
from sentry.testutils import TestCase
from sentry.tagstore import TagKeyStatus
from sentry.tagstore.v2 import models
from sentry.tagstore.v2.backend import V2TagStorage, transformers
from sentry.tagstore.exceptions import TagKeyNotFound, TagValueNotFound, GroupTagKeyNotFound, GroupTagValueNotFound

def xfail_if_mysql(function):
    return pytest.mark.xfail(
        os.environ.get('TEST_SUITE') == 'mysql',
        reason='mysql microsecond truncation breaks comparison',
    )(function)

class TagStorage(TestCase):
    def setUp(self):
        self.ts = V2TagStorage()

        self.proj1 = self.create_project()
        self.proj1group1 = self.create_group(self.proj1)
        self.proj1group2 = self.create_group(self.proj1)
        self.proj1env1 = self.create_environment(project=self.proj1)
        self.proj1env2 = self.create_environment(project=self.proj1)
        self.proj1group1event1 = self.create_event(project=self.proj1, group=self.proj1group1)
        self.proj1group1event2 = self.create_event(project=self.proj1, group=self.proj1group1)
        self.proj1group1event3 = self.create_event(project=self.proj1, group=self.proj1group1)

        self.proj2 = self.create_project()
        self.proj2group1 = self.create_group(self.proj2)
        self.proj2env1 = self.create_environment(project=self.proj2)

        self.key1 = 'key1'
        self.value1 = 'value1'

    def test_create_tag_key(self):
        with pytest.raises(TagKeyNotFound):
            self.ts.get_tag_key(
                project_id=self.proj1.id,
                environment_id=self.proj1env1.id,
                key=self.key1,
            )

        assert self.ts.get_tag_keys(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
        ) == set()

        tk = self.ts.create_tag_key(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        )

        assert self.ts.get_tag_key(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        ) == transformers[models.TagKey](tk)

        assert self.ts.get_tag_keys(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
        ) == set([transformers[models.TagKey](tk)])

        assert models.TagKey.objects.all().count() == 1

    def test_get_or_create_tag_key(self):
        tk1, _ = self.ts.get_or_create_tag_key(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        )

        tk2, _ = self.ts.get_or_create_tag_key(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        )

        assert tk1.id == tk2.id
        assert models.TagKey.objects.filter(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        ).count() == 1
        assert models.TagKey.objects.all().count() == 1

    @xfail_if_mysql
    def test_create_tag_value(self):
        with pytest.raises(TagValueNotFound):
            self.ts.get_tag_value(
                project_id=self.proj1.id,
                environment_id=self.proj1env1.id,
                key=self.key1,
                value=self.value1,
            )

        assert self.ts.get_tag_values(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        ) == set()

        tv = self.ts.create_tag_value(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
            value=self.value1,
        )

        assert self.ts.get_tag_value(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
            value=self.value1,
        ) == transformers[models.TagValue](tv)

        assert self.ts.get_tag_values(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        ) == set([transformers[models.TagValue](tv)])

        assert models.TagKey.objects.all().count() == 1
        assert models.TagValue.objects.all().count() == 1

    def test_get_or_create_tag_value(self):
        tv1, _ = self.ts.get_or_create_tag_value(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
            value=self.value1,
        )

        tv2, _ = self.ts.get_or_create_tag_value(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
            value=self.value1,
        )

        assert tv1.id == tv2.id

        tk = models.TagKey.objects.get(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        )

        assert models.TagKey.objects.all().count() == 1

        assert models.TagValue.objects.filter(
            project_id=self.proj1.id,
            _key__environment_id=self.proj1env1.id,
            _key_id=tk.id,
            value=self.value1,
        ).count() == 1
        assert models.TagValue.objects.all().count() == 1

    def test_create_group_tag_key(self):
        with pytest.raises(GroupTagKeyNotFound):
            self.ts.get_group_tag_key(
                project_id=self.proj1.id,
                group_id=self.proj1group1.id,
                environment_id=self.proj1env1.id,
                key=self.key1,
            )

        assert self.ts.get_group_tag_keys(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
        ) == set()

        gtk = self.ts.create_group_tag_key(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        )

        self.ts.get_group_tag_keys(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
        ) == [transformers[models.GroupTagKey](gtk)]

        models.TagKey.objects.get(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        )
        assert models.TagKey.objects.all().count() == 1

        assert self.ts.get_group_tag_key(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        ) == transformers[models.GroupTagKey](gtk)

        assert models.GroupTagKey.objects.all().count() == 1

    def test_get_or_create_group_tag_key(self):
        gtk1, _ = self.ts.get_or_create_group_tag_key(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        )

        gtk2, _ = self.ts.get_or_create_group_tag_key(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        )

        assert gtk1.id == gtk2.id

        tk = models.TagKey.objects.get(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        )
        assert models.TagKey.objects.all().count() == 1

        assert models.GroupTagKey.objects.filter(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            _key__environment_id=self.proj1env1.id,
            _key_id=tk.id,
        ).count() == 1
        assert models.GroupTagKey.objects.all().count() == 1

    @xfail_if_mysql
    def test_create_group_tag_value(self):
        with pytest.raises(GroupTagValueNotFound):
            self.ts.get_group_tag_value(
                project_id=self.proj1.id,
                group_id=self.proj1group1.id,
                environment_id=self.proj1env1.id,
                key=self.key1,
                value=self.value1,
            )

        assert self.ts.get_group_tag_values(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        ) == []

        gtv = self.ts.create_group_tag_value(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
            value=self.value1,
        )

        assert self.ts.get_group_tag_value(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
            value=self.value1,
        ) == transformers[models.GroupTagValue](gtv)

        assert self.ts.get_group_tag_values(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        ) == [transformers[models.GroupTagValue](gtv)]

        assert models.TagKey.objects.all().count() == 1
        assert models.TagValue.objects.all().count() == 1
        assert models.GroupTagValue.objects.all().count() == 1

    def test_get_or_create_group_tag_value(self):
        gtv1, _ = self.ts.get_or_create_group_tag_value(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
            value=self.value1,
        )

        gtv2, _ = self.ts.get_or_create_group_tag_value(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
            value=self.value1,
        )

        assert gtv1.id == gtv2.id

        tk = models.TagKey.objects.get(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        )
        assert models.TagKey.objects.all().count() == 1

        tv = models.TagValue.objects.get(
            project_id=self.proj1.id,
            _key__environment_id=self.proj1env1.id,
            _key_id=tk.id,
            value=self.value1,
        )
        assert models.TagValue.objects.all().count() == 1

        assert models.GroupTagValue.objects.filter(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            _key__environment_id=self.proj1env1.id,
            _key_id=tk.id,
            _value_id=tv.id,
        ).count() == 1
        assert models.GroupTagValue.objects.all().count() == 1

    def test_create_event_tags(self):
        v1, _ = self.ts.get_or_create_tag_value(self.proj1.id, self.proj1env1.id, 'k1', 'v1')
        v2, _ = self.ts.get_or_create_tag_value(self.proj1.id, self.proj1env1.id, 'k2', 'v2')
        v3, _ = self.ts.get_or_create_tag_value(self.proj1.id, self.proj1env1.id, 'k3', 'v3')

        tags = [(v1._key, v1), (v2._key, v2), (v3._key, v3)]
        self.ts.create_event_tags(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            event_id=self.proj1group1event1.id,
            tags=[(k.key, v.value) for k, v in tags]
        )

        assert models.EventTag.objects.count() == 3
        for (k, v) in tags:
            assert models.EventTag.objects.get(
                project_id=self.proj1.id,
                group_id=self.proj1group1.id,
                key__environment_id=self.proj1env1.id,
                event_id=self.proj1group1event1.id,
                key_id=k.id,
                value_id=v.id,
            ) is not None
            assert set(
                self.ts.get_event_tag_qs(
                    self.proj1.id,
                    self.proj1env1.id,
                    k.key,
                    v.value,
                ).values_list('group_id', flat=True)
            ) == set([self.proj1group1.id])

    def test_delete_tag_key(self):
        tk1 = self.ts.create_tag_key(
            project_id=self.proj1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        )

        tk2 = self.ts.create_tag_key(
            project_id=self.proj1.id,
            environment_id=self.proj1env2.id,
            key=self.key1,
        )

        assert models.TagKey.objects.filter(
            project_id=self.proj1.id,
            status=TagKeyStatus.VISIBLE,
        ).count() == 2

        deleted = self.ts.delete_tag_key(self.proj1.id, self.key1)
        assert tk1 in deleted
        assert tk2 in deleted

        assert models.TagKey.objects.filter(
            project_id=self.proj1.id,
            status=TagKeyStatus.VISIBLE,
        ).count() == 0

    def test_delete_all_group_tag_keys(self):
        assert models.GroupTagKey.objects.count() == 0

        self.ts.create_group_tag_key(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
        )

        assert models.GroupTagKey.objects.count() == 1

        self.ts.delete_all_group_tag_keys(self.proj1.id, self.proj1group1.id)

        assert models.GroupTagKey.objects.count() == 0

    def test_delete_all_group_tag_values(self):
        assert models.GroupTagValue.objects.count() == 0

        self.ts.create_group_tag_value(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            key=self.key1,
            value=self.value1,
        )

        assert models.GroupTagValue.objects.count() == 1

        self.ts.delete_all_group_tag_values(self.proj1.id, self.proj1group1.id)

        assert models.GroupTagValue.objects.count() == 0

    def test_get_group_event_filter(self):
        tags = {
            'abc': 'xyz',
            'foo': 'bar',
            'baz': 'quux',
        }

        # 2 events with the same tags
        for event in (self.proj1group1event1, self.proj1group1event2):
            self.ts.create_event_tags(
                project_id=self.proj1.id,
                group_id=self.proj1group1.id,
                environment_id=self.proj1env1.id,
                event_id=event.id,
                tags=tags.items(),
            )

        different_tags = {
            'abc': 'DIFFERENT',
            'foo': 'bar',
            'baz': 'quux',
        }

        # 1 event with different tags
        self.ts.create_event_tags(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            event_id=self.proj1group1event3.id,
            tags=different_tags.items(),
        )

        assert self.ts.get_group_event_filter(
            self.proj1.id,
            self.proj1group1.id,
            self.proj1env1.id,
            tags
        ) == {'id__in': set([self.proj1group1event1.id, self.proj1group1event2.id])}

    def test_get_groups_user_counts(self):
        k1, _ = self.ts.get_or_create_group_tag_key(
            self.proj1.id,
            self.proj1group1.id,
            self.proj1env1.id,
            'sentry:user')
        k1.values_seen = 7
        k1.save()

        k2, _ = self.ts.get_or_create_group_tag_key(
            self.proj1.id,
            self.proj1group2.id,
            self.proj1env1.id,
            'sentry:user')
        k2.values_seen = 11
        k2.save()

        assert dict(
            self.ts.get_groups_user_counts(
                self.proj1.id,
                [self.proj1group1.id, self.proj1group2.id],
                self.proj1env1.id).items()) == {self.proj1group1.id: 7, self.proj1group2.id: 11}

    def test_get_group_tag_value_count(self):
        v1, _ = self.ts.get_or_create_group_tag_value(
            self.proj1.id,
            self.proj1group1.id,
            self.proj1env1.id,
            self.key1,
            'value1')
        v1.times_seen = 7
        v1.save()

        v2, _ = self.ts.get_or_create_group_tag_value(
            self.proj1.id,
            self.proj1group1.id,
            self.proj1env1.id,
            self.key1,
            'value2')
        v2.times_seen = 11
        v2.save()

        assert self.ts.get_group_tag_value_count(
            self.proj1.id,
            self.proj1group1.id,
            self.proj1env1.id,
            self.key1,
        ) == 18

    def test_get_top_group_tag_values(self):
        v1, _ = self.ts.get_or_create_group_tag_value(
            self.proj1.id,
            self.proj1group1.id,
            self.proj1env1.id,
            self.key1,
            'value1')
        v1.times_seen = 7
        v1.save()

        v2, _ = self.ts.get_or_create_group_tag_value(
            self.proj1.id,
            self.proj1group1.id,
            self.proj1env1.id,
            self.key1,
            'value2')
        v2.times_seen = 11
        v2.save()

        resp = self.ts.get_top_group_tag_values(
            self.proj1.id,
            self.proj1group1.id,
            self.proj1env1.id,
            self.key1,
        )

        assert resp[0].times_seen == 11
        assert resp[0].key == self.key1
        assert resp[0].group_id == self.proj1group1.id

        assert resp[1].times_seen == 7
        assert resp[1].key == self.key1
        assert resp[1].group_id == self.proj1group1.id

    def test_get_first_release(self):
        v1, _ = self.ts.get_or_create_group_tag_value(
            self.proj1.id,
            self.proj1group1.id,
            self.proj1env1.id,
            'sentry:release',
            '1.0')
        v1.first_seen = datetime(2000, 1, 1)
        v1.save()

        v2, _ = self.ts.get_or_create_group_tag_value(
            self.proj1.id,
            self.proj1group1.id,
            self.proj1env1.id,
            'sentry:release',
            '2.0')
        v2.first_seen = datetime(2000, 1, 2)
        v2.save()

        assert self.ts.get_first_release(
            self.proj1.id,
            self.proj1group1.id,
        ) == '1.0'

    def test_get_last_release(self):
        v1, _ = self.ts.get_or_create_group_tag_value(
            self.proj1.id,
            self.proj1group1.id,
            self.proj1env1.id,
            'sentry:release',
            '1.0')
        v1.last_seen = datetime(2000, 1, 1)
        v1.save()

        v2, _ = self.ts.get_or_create_group_tag_value(
            self.proj1.id,
            self.proj1group1.id,
            self.proj1env1.id,
            'sentry:release',
            '2.0')
        v2.last_seen = datetime(2000, 1, 2)
        v2.save()

        assert self.ts.get_last_release(
            self.proj1.id,
            self.proj1group1.id,
        ) == '2.0'

    @xfail_if_mysql
    def test_get_release_tags(self):
        tv, _ = self.ts.get_or_create_tag_value(
            self.proj1.id,
            self.proj1env1.id,
            'sentry:release',
            '1.0'
        )

        assert self.ts.get_release_tags(
            [self.proj1.id],
            self.proj1env1.id,
            ['1.0'],
        ) == set([transformers[models.TagValue](tv)])

    def test_get_group_ids_for_users(self):
        from sentry.models import EventUser

        v1, _ = self.ts.get_or_create_group_tag_value(
            self.proj1.id,
            self.proj1group1.id,
            0,
            'sentry:user',
            'email:user@sentry.io')

        eu = EventUser(project_id=self.proj1.id, email='user@sentry.io')

        assert self.ts.get_group_ids_for_users(
            [self.proj1.id],
            [eu]) == set([self.proj1group1.id])

    @xfail_if_mysql
    def test_get_group_tag_values_for_users(self):
        from sentry.models import EventUser

        v1, _ = self.ts.get_or_create_group_tag_value(
            self.proj1.id,
            self.proj1group1.id,
            0,
            'sentry:user',
            'email:user@sentry.io')

        eu = EventUser(project_id=self.proj1.id, email='user@sentry.io')

        assert self.ts.get_group_tag_values_for_users([eu]) == [
            transformers[models.GroupTagValue](v1)
        ]

    def test_get_group_ids_for_search_filter(self):
        tags = {
            'foo': 'bar',
            'baz': 'quux',
        }

        for k, v in tags.items():
            v1, _ = self.ts.get_or_create_group_tag_value(
                self.proj1.id,
                self.proj1group1.id,
                self.proj1env1.id,
                k,
                v)

        assert self.ts.get_group_ids_for_search_filter(
            self.proj1.id, self.proj1env1.id, tags) == [self.proj1group1.id]

    def test_get_group_ids_for_search_filter_predicate_order(self):
        """
            Since each tag-matching filter returns limited results, and each
            filter returns a subset of the previous filter's matches, we
            attempt to match more selective predicates first.

            This tests that we filter by a more selective "divides == even"
            predicate before filtering by an ANY predicate and therefore return
            all matching groups instead of the partial set that would be returned
            if we had filtered and limited using the ANY predicate first.
        """
        for i in range(3):
            self.ts.get_or_create_group_tag_value(
                self.proj1.id, i, self.proj1env1.id,
                'foo', 'bar'
            )

            self.ts.get_or_create_group_tag_value(
                self.proj1.id, i, self.proj1env1.id,
                'divides', 'even' if i % 2 == 0 else 'odd'
            )

        assert len(self.ts.get_group_ids_for_search_filter(
            self.proj1.id,
            self.proj1env1.id,
            OrderedDict([('foo', ANY), ('divides', 'even')]),
            limit=2
        )) == 2

    def test_update_group_for_events(self):
        v1, _ = self.ts.get_or_create_tag_value(self.proj1.id, self.proj1env1.id, 'k1', 'v1')
        v2, _ = self.ts.get_or_create_tag_value(self.proj1.id, self.proj1env1.id, 'k2', 'v2')
        v3, _ = self.ts.get_or_create_tag_value(self.proj1.id, self.proj1env1.id, 'k3', 'v3')

        tags = [(v1.key, v1.value), (v2.key, v2.value), (v3.key, v3.value)]
        self.ts.create_event_tags(
            project_id=self.proj1.id,
            group_id=self.proj1group1.id,
            environment_id=self.proj1env1.id,
            event_id=self.proj1group1event1.id,
            tags=tags
        )

        assert models.EventTag.objects.filter(group_id=self.proj1group2.id).count() == 0

        self.ts.update_group_for_events(
            self.proj1.id, [
                self.proj1group1event1.id], self.proj1group2.id)

        assert models.EventTag.objects.filter(group_id=self.proj1group2.id).count() == 3


text:
alias ll='ls -la'
alias la='ls -a'
alias lr='ls -R'
alias llr='ls -alR'
alias ...='cd ../..'
alias ....='cd ../../..'
alias goodbye='exit'
alias goodnight='sudo shutdown -p now'
alias reboot='sudo shutdown -r now'


text:
import { Laya3D } from "Laya3D";
import { Laya } from "Laya";
import { CameraMoveScript } from "../common/CameraMoveScript"
	import { Camera } from "laya/d3/core/Camera"
	import { MeshSprite3D } from "laya/d3/core/MeshSprite3D"
	import { Sprite3D } from "laya/d3/core/Sprite3D"
	import { BlinnPhongMaterial } from "laya/d3/core/material/BlinnPhongMaterial"
	import { Scene3D } from "laya/d3/core/scene/Scene3D"
	import { Stage } from "laya/display/Stage"
	import { Handler } from "laya/utils/Handler"
	import { Stat } from "laya/utils/Stat"
	import { Browser } from "laya/utils/Browser"

	export class AnimationTest {
		constructor(){
			Laya3D.init(0, 0);
			Stat.show();
			Laya.stage.scaleMode = Stage.SCALE_FULL;
			Laya.stage.screenMode = Stage.SCREEN_NONE;

			if(Browser.onAndroid){
				Scene3D.load("../../../../res/threeDimen/scene/LayaScene_DUDEcompress/Android/layaScene.ls", Handler.create(null, function(scene:Scene3D):void {
				(<Scene3D>Laya.stage.addChild(scene) );
				var camera:Camera = (<Camera>scene.getChildByName("Main Camera") );
				camera.addComponent(CameraMoveScript);
				}));
			}
			else if(Browser.onIOS){
				Scene3D.load("../../../../res/threeDimen/scene/LayaScene_DUDEcompress/IOS/layaScene.ls", Handler.create(null, function(scene:Scene3D):void {
				(<Scene3D>Laya.stage.addChild(scene) );
				var camera:Camera = (<Camera>scene.getChildByName("Main Camera") );
				camera.addComponent(CameraMoveScript);
				}));
			}
			else{
				Scene3D.load("../../../../res/threeDimen/scene/LayaScene_DUDEcompress/Conventional/layaScene.ls", Handler.create(null, function(scene:Scene3D):void {
				(<Scene3D>Laya.stage.addChild(scene) );
				var camera:Camera = (<Camera>scene.getChildByName("Main Camera") );
				camera.addComponent(CameraMoveScript);
				}));
			}

		}

	}


text:
	<md-button class="md-raised md-primary" aria-label="Agregar Nueva {{$root.user.pequenogrupo}}" ng-click="showAgregarPatrulla($event)">
		  Agregar Nueva {{$root.user.pequenogrupo}}
	</md-button>

NO TIENES {{$root.user.pequenogrupo.toUpperCase()}}S REGISTRADOS AÚN

		<md-card md-theme="default">
			<md-card-title>
				<md-card-title-text>
					{{patrulla.nombre}}
				</md-card-title-text>
				<md-card-title-media>

				</md-card-title-media>
			</md-card-title>
			<md-card-actions layout="row" layout-align="start center">

					<md-button ng-click="borrar(patrulla)" class="btn-lg btn-lg-text" aria-label="Borrar {{$root.user.pequenogrupo}}" aria-label="BORRAR">
						<md-tooltip>Borrar {{$root.user.pequenogrupo}}</md-tooltip>

					</md-button>

					<md-button class="btn-lg btn-lg-text" aria-label="Informacion Personal">
						<md-tooltip>Editar {{$root.user.pequenogrupo}}</md-tooltip>

					</md-button>

			</md-card-actions>
		</md-card>


text:
package edu.monash.infotech.marvl.cola.geom;

import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.List;

@AllArgsConstructor
@NoArgsConstructor
public class VisibilityGraph {

    public List<VisibilityVertex> V = new ArrayList<>();
    public List<VisibilityEdge>   E = new ArrayList<>();

}


text:
<?xml version="1.0" encoding="UTF-8"?>
<!-- Persistence deployment descriptor for dev profile -->
<persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
	version="1.0">

	<persistence-unit name="matrix">
		<provider>org.hibernate.ejb.HibernatePersistence</provider>
		<jta-data-source>java:/matrixDatasource</jta-data-source>
		<!-- The <jar-file> element is necessary if you put the persistence.xml in the WAR and the classes
			in the JAR -->
		<!-- <jar-file>../../vehicles.jar</jar-file> -->
		<properties>
			<property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" />
			<property name="hibernate.hbm2ddl.auto" value="none" />
			<property name="hibernate.show_sql" value="false" />
			<property name="hibernate.format_sql" value="true" />
			<property name="jboss.entity.manager.factory.jndi.name" value="java:/matrixEntityManagerFactory" />
		</properties>
	</persistence-unit>

</persistence>


text:
namespace freeflow {

/// A Path is a sequence of characters that designates a file object.
///
/// @todo This should be an actual class with a legitimate interface.
/// Or, we could rely on the C++ File System TS whenever it's implemented
/// standardized.
using Path = std::string;

} // namespace freeflow


text:
package org.testng.internal;

import java.util.List;
import org.testng.collections.Lists;

/** Stores the information regarding the configuration of a pluggable report listener. */
public class ReporterConfig {

  /** The class name of the reporter listener */
  // TODO make it private/final once org.testng.ReporterConfig will be removed
  protected String className;

  /** The properties of the reporter listener */
  // TODO make it private once org.testng.ReporterConfig will be removed
  protected final List<Property> properties;

  public ReporterConfig(String className, List<Property> properties) {
    this.className = className;
    this.properties = properties;
  }

  public String getClassName() {
    return className;
  }

  public List<Property> getProperties() {
    return properties;
  }

  public String serialize() {
    StringBuilder sb = new StringBuilder(className);
    if (!properties.isEmpty()) {
      sb.append(":");

      for (int i = 0; i < properties.size(); i++) {
        Property property = properties.get(i);
        sb.append(property);
        if (i < properties.size() - 1) {
          sb.append(",");
        }
      }
    }
    return sb.toString();
  }

  public static ReporterConfig deserialize(String inputString) {

    if (Utils.isStringEmpty(inputString)) {
      return null;
    }

    String className;
    List<Property> properties = Lists.newArrayList();
    int clsNameEndIndex = inputString.indexOf(':');
    if (clsNameEndIndex == -1) {
      className = inputString;
    } else {
      className = inputString.substring(0, clsNameEndIndex);
      String propString = inputString.substring(clsNameEndIndex + 1);
      for (String prop : propString.split(",")) {
        String[] propNameAndVal = prop.split("=");
        if (propNameAndVal.length == 2) {
          properties.add(new Property(propNameAndVal[0], propNameAndVal[1]));
        }
      }
    }

    return new ReporterConfig(className, properties);
  }

  public static class Property {
    private final String name;
    private final String value;

    public Property(String name, String value) {
      this.name = name;
      this.value = value;
    }

    public String getName() {
      return name;
    }

    public String getValue() {
      return value;
    }

    @Override
    public String toString() {
      return name + "=" + value;
    }
  }

  @Override
  public String toString() {
    StringBuilder buf = new StringBuilder();
    buf.append("\nClass = ").append(className);
    for (Property prop : properties) {
      buf.append("\n\t ").append(prop);
    }
    return buf.toString();
  }
}


text:
package org.jetbrains.plugins.scala.lang.resolve2

class ElementTest extends ResolveTestBase {
  override def folderPath: String = {
    super.folderPath + "element/"
  }

  def testCaseClass(): Unit = doTest()
  def testCaseObject(): Unit = doTest()
  def testClass(): Unit = doTest()
  def testClassParameter(): Unit = doTest()
  def testClassParameterValue(): Unit = doTest()
  def testClassParameterVariable(): Unit = doTest()
  def testObject(): Unit = doTest()
  def testTrait(): Unit = doTest()
  def testFunctionDefinition(): Unit = doTest()
  def testFunctionParameter(): Unit = doTest()
  def testFunctionParameterClause(): Unit = doTest()
  def testMacroDefinition(): Unit = doTest()
  def testNamedParameter(): Unit = doTest()
  def testConstructorParameter(): Unit = doTest()
  def testTypeAlias(): Unit = doTest()
  def testValue(): Unit = doTest()
  def testVariable(): Unit = doTest()
  //TODO answer? classof, it's internal compiler error, should be resolved, but another error in annotator
//  def testTypeParameterClass = doTest
  //TODO answer? classof, it's internal compiler error, should be resolved, but another error in annotator
//  def testTypeParameterFunction = doTest
  //TODO answer? classof, it's internal compiler error, should be resolved, but another error in annotator
//  def testTypeParameterTrait = doTest
  def testBinding(): Unit = doTest()
  def testValues(): Unit = doTest()
  def testStatementForValue(): Unit = doTest()
  def testStatementForValues(): Unit = doTest()
  def testStatementForBinding(): Unit = doTest()
  def testStatementForAssignment(): Unit = doTest()
  def testFunctionExpressionParameter(): Unit = doTest()
  def testCaseClauseParameter(): Unit = doTest()
  def testCaseClauseNamed(): Unit = doTest()
  def testCaseClauseBinding(): Unit = doTest()

  //TODO answer? classof, it's internal compiler error, should be resolved, but another error in annotator
//  def testPackage = doTest
  //TODO answer? classof, it's internal compiler error, should be resolved, but another error in annotator
//  def testPackageObject = doTest
}


text:
hiqdev/hidev-config changelog
-----------------------------

## Under development

## 0.1.2 2015-11-09

- Fixed (improved) package description

## 0.1.1 2015-11-06

- Fixed (improved) package description
- Changed structure of authors config and added nick and github

## 0.1.0 2015-10-24

- Fixed badges

## 0.0.4 2015-10-23

- Changed package title to: HiQDev vendor hidev config

## 0.0.3 2015-10-23

- Changed package title
- Changed urls to https <- https

## 0.0.2 2015-07-11

- Changed configuration: redone parent to plugins
- Added different templates
- Added codeception

## 0.0.1 June 19, 2015

- Added php-cs-fixer
- Inited

## Development started May 29, 2015


text:
package com.hazelcast.durableexecutor.impl;

import com.hazelcast.config.DurableExecutorConfig;
import com.hazelcast.core.DistributedObject;
import com.hazelcast.internal.services.ManagedService;
import com.hazelcast.internal.services.RemoteService;
import com.hazelcast.internal.services.SplitBrainProtectionAwareService;
import com.hazelcast.spi.impl.NodeEngine;
import com.hazelcast.spi.impl.NodeEngineImpl;
import com.hazelcast.spi.impl.operationservice.Operation;
import com.hazelcast.internal.partition.MigrationAwareService;
import com.hazelcast.internal.partition.MigrationEndpoint;
import com.hazelcast.internal.partition.PartitionMigrationEvent;
import com.hazelcast.internal.partition.PartitionReplicationEvent;
import com.hazelcast.internal.util.ConstructorFunction;
import com.hazelcast.internal.util.ContextMutexFactory;

import java.util.Collections;
import java.util.Properties;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import static com.hazelcast.internal.util.ConcurrencyUtil.getOrPutSynchronized;

public class DistributedDurableExecutorService implements ManagedService, RemoteService, MigrationAwareService,
        SplitBrainProtectionAwareService {

    public static final String SERVICE_NAME = "hz:impl:durableExecutorService";

    private static final Object NULL_OBJECT = new Object();

    private final NodeEngineImpl nodeEngine;
    private final DurableExecutorPartitionContainer[] partitionContainers;

    private final Set<String> shutdownExecutors
            = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>());

    private final ConcurrentMap<String, Object> splitBrainProtectionConfigCache = new ConcurrentHashMap<String, Object>();
    private final ContextMutexFactory splitBrainProtectionConfigCacheMutexFactory = new ContextMutexFactory();
    private final ConstructorFunction<String, Object> splitBrainProtectionConfigConstructor =
            new ConstructorFunction<String, Object>() {
        @Override
        public Object createNew(String name) {
            DurableExecutorConfig executorConfig = nodeEngine.getConfig().findDurableExecutorConfig(name);
            String splitBrainProtectionName = executorConfig.getSplitBrainProtectionName();
            return splitBrainProtectionName == null ? NULL_OBJECT : splitBrainProtectionName;
        }
    };

    public DistributedDurableExecutorService(NodeEngineImpl nodeEngine) {
        this.nodeEngine = nodeEngine;
        int partitionCount = nodeEngine.getPartitionService().getPartitionCount();
        partitionContainers = new DurableExecutorPartitionContainer[partitionCount];
        for (int partitionId = 0; partitionId < partitionCount; partitionId++) {
            partitionContainers[partitionId] = new DurableExecutorPartitionContainer(nodeEngine, partitionId);
        }
    }

    @Override
    public void init(NodeEngine nodeEngine, Properties properties) {
    }

    public DurableExecutorPartitionContainer getPartitionContainer(int partitionId) {
        return partitionContainers[partitionId];
    }

    public NodeEngine getNodeEngine() {
        return nodeEngine;
    }

    @Override
    public void reset() {
        shutdownExecutors.clear();
        for (int partitionId = 0; partitionId < partitionContainers.length; partitionId++) {
            partitionContainers[partitionId] = new DurableExecutorPartitionContainer(nodeEngine, partitionId);
        }
    }

    @Override
    public void shutdown(boolean terminate) {
        reset();
    }

    @Override
    public DistributedObject createDistributedObject(String name, UUID source, boolean local) {
        return new DurableExecutorServiceProxy(nodeEngine, this, name);
    }

    @Override
    public void destroyDistributedObject(String name, boolean local) {
        shutdownExecutors.remove(name);
        nodeEngine.getExecutionService().shutdownDurableExecutor(name);
        removeAllContainers(name);
        splitBrainProtectionConfigCache.remove(name);
    }

    public void shutdownExecutor(String name) {
        nodeEngine.getExecutionService().shutdownDurableExecutor(name);
        shutdownExecutors.add(name);
    }

    public boolean isShutdown(String name) {
        return shutdownExecutors.contains(name);
    }

    @Override
    public Operation prepareReplicationOperation(PartitionReplicationEvent event) {
        int partitionId = event.getPartitionId();
        DurableExecutorPartitionContainer partitionContainer = partitionContainers[partitionId];
        return partitionContainer.prepareReplicationOperation(event.getReplicaIndex());
    }

    @Override
    public void beforeMigration(PartitionMigrationEvent event) {
    }

    @Override
    public void commitMigration(PartitionMigrationEvent event) {
        int partitionId = event.getPartitionId();
        if (event.getMigrationEndpoint() == MigrationEndpoint.SOURCE) {
            clearRingBuffersHavingLesserBackupCountThan(partitionId, event.getNewReplicaIndex());
        } else if (event.getNewReplicaIndex() == 0) {
            DurableExecutorPartitionContainer partitionContainer = partitionContainers[partitionId];
            partitionContainer.executeAll();
        }
    }

    @Override
    public void rollbackMigration(PartitionMigrationEvent event) {
        if (event.getMigrationEndpoint() == MigrationEndpoint.DESTINATION) {
            clearRingBuffersHavingLesserBackupCountThan(event.getPartitionId(), event.getCurrentReplicaIndex());
        }
    }

    private void clearRingBuffersHavingLesserBackupCountThan(int partitionId, int thresholdReplicaIndex) {
        DurableExecutorPartitionContainer partitionContainer = partitionContainers[partitionId];
        partitionContainer.clearRingBuffersHavingLesserBackupCountThan(thresholdReplicaIndex);
    }

    @Override
    public String getSplitBrainProtectionName(final String name) {
        Object splitBrainProtectionName = getOrPutSynchronized(splitBrainProtectionConfigCache, name,
                splitBrainProtectionConfigCacheMutexFactory, splitBrainProtectionConfigConstructor);
        return splitBrainProtectionName == NULL_OBJECT ? null : (String) splitBrainProtectionName;
    }

    private void removeAllContainers(String name) {
        for (int i = 0; i < partitionContainers.length; i++) {
            getPartitionContainer(i).removeContainer(name);
        }
    }
}


text:
'use strict';

exports.init = function(req, res){
  res.render('test');
};


text:
import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
import { enableProdMode } from '@angular/core';
import { environment } from './environments/environment';
import { ChatModule } from './chat/modules/chat.module';

if (environment.production) {
  enableProdMode();
}

platformBrowserDynamic().bootstrapModule(ChatModule);


text:
'use strict';

(function (scope) {
    /**
     * WebSocket start text recognition message
     *
     * @class TextStartRequestWSMessage
     * @extends AbstractStartRequestWSMessage
     * @param {Object} [obj] Recognition WebSocket message
     * @constructor
     */
    function TextStartRequestWSMessage(obj) {
        scope.AbstractStartRequestWSMessage.call(this, obj);
    }

    /**
     * Inheritance property
     */
    TextStartRequestWSMessage.prototype = new scope.AbstractStartRequestWSMessage();

    /**
     * Constructor property
     */
    TextStartRequestWSMessage.prototype.constructor = TextStartRequestWSMessage;

    /**
     * Get parameters
     *
     * @method getParameters
     * @returns {TextParameter}
     */
    TextStartRequestWSMessage.prototype.getParameters = function () {
        return this.textParameter;
    };

    /**
     * Set parameters
     *
     * @method setParameters
     * @param {TextParameter} parameters
     */
    TextStartRequestWSMessage.prototype.setParameters = function (parameters) {
        this.textParameter = parameters;
    };

    /**
     * Get input units
     *
     * @method getInputUnits
     * @returns {TextInputUnit[]}
     */
    TextStartRequestWSMessage.prototype.getInputUnits = function () {
        return this.inputUnits;
    };

    /**
     * Set input units
     *
     * @method setInputUnits
     * @param {TextInputUnit[]} inputUnits
     */
    TextStartRequestWSMessage.prototype.setInputUnits = function (inputUnits) {
        this.inputUnits = inputUnits;
    };

    // Export
    scope.TextStartRequestWSMessage = TextStartRequestWSMessage;
})(MyScript);


text:
#include <pdal/PipelineManager.hpp>

#include <pdal/Filter.hpp>
#include <pdal/MultiFilter.hpp>
#include <pdal/Reader.hpp>
#include <pdal/Writer.hpp>
#include <pdal/Utils.hpp>

#include <boost/property_tree/xml_parser.hpp>
#include <boost/optional.hpp>

namespace pdal
{

PipelineManager::PipelineManager()
    : m_lastStage(NULL)
    , m_lastWriter(NULL)
    , m_isWriterPipeline(false)
{

    return;
}

PipelineManager::~PipelineManager()
{
    while (m_readers.size())
    {
        Reader* reader = m_readers.back();
        m_readers.pop_back();
        delete reader;
    }

    while (m_filters.size())
    {
        Filter* filter = m_filters.back();
        m_filters.pop_back();
        delete filter;
    }

    while (m_multifilters.size())
    {
        MultiFilter* multifilter = m_multifilters.back();
        m_multifilters.pop_back();
        delete multifilter;
    }

    while (m_writers.size())
    {
        Writer* writer = m_writers.back();
        m_writers.pop_back();
        delete writer;
    }

    return;
}

void PipelineManager::removeWriter()
{
    while (m_writers.size())
    {
        Writer* writer = m_writers.back();
        m_writers.pop_back();
        delete writer;
    }

    m_lastWriter = 0;
}

Reader* PipelineManager::addReader(const std::string& type, const Options& options)
{
    registerPluginIfExists(options);

    Reader* stage = m_factory.createReader(type, options);
    m_readers.push_back(stage);
    m_lastStage = stage;
    return stage;
}

Filter* PipelineManager::addFilter(const std::string& type, Stage& prevStage, const Options& options)
{
    registerPluginIfExists(options);

    Filter* stage = m_factory.createFilter(type, prevStage, options);
    m_filters.push_back(stage);
    m_lastStage = stage;
    return stage;
}

MultiFilter* PipelineManager::addMultiFilter(const std::string& type, const std::vector<Stage*>& prevStages, const Options& options)
{
    registerPluginIfExists(options);

    MultiFilter* stage = m_factory.createMultiFilter(type, prevStages, options);
    m_multifilters.push_back(stage);
    m_lastStage = stage;
    return stage;
}

void PipelineManager::registerPluginIfExists(const Options& options)
{
    if (options.hasOption("plugin"))
    {
        m_factory.registerPlugin(options.getValueOrThrow<std::string>("plugin"));
    }
}

Writer* PipelineManager::addWriter(const std::string& type, Stage& prevStage, const Options& options)
{
    m_isWriterPipeline = true;

    registerPluginIfExists(options);

    Writer* writer = m_factory.createWriter(type, prevStage, options);
    m_writers.push_back(writer);
    m_lastWriter = writer;
    return writer;
}

Writer* PipelineManager::getWriter() const
{
    return m_lastWriter;
}

Stage* PipelineManager::getStage() const
{
    return m_lastStage;
}

boost::uint64_t PipelineManager::execute()
{
    if (!isWriterPipeline())
        throw pdal_error("This pipeline does not have a writer, unable to execute");
    getWriter()->initialize();
    return getWriter()->write(0);
}

bool PipelineManager::isWriterPipeline() const
{
    return (m_lastWriter != NULL);
}

} // namespace pdal


text:
'use strict'

const ProductModel = require('../models/product')
    , Repository = require('../repositories/repository')
    , Response = require('../utils/response')

let controller = {
    create: (_request, _response) => {
        return Repository.selectWhere({ name: _request.body.name }, ProductModel).then((_name) => {
            if (_name) {
                return Response.resourceAlreadyExists(_request.body)
            } else {
                let product = new ProductModel({
                    name: _request.body.name,
                    description: _request.body.description,
                    price: _request.body.price
                })
                return Repository.insert(product).then((_error) => {
                    if (_error) {
                        return Response.created(product)
                    } else {
                        return Response.internalServerError(_error)
                    }
                })
            }
        })
    },
    updateById: (_request, _response) => {
        return _response.status(200).json({
            message: 'updated'
        })
    },
    deleteById: (_request, _response) => {
        return _response.status(200).json({
            message: 'deleted'
        })
    },
    getById: (_request, _response) => {
        return _response.status(200).json({
            message: 'success'
        })
    },
    getAll: (_request, _response) => {
        return Repository.selectFrom(ProductModel).then((_result) => {
            if (_result.length > 0) {
                return Response.ok(_result)
            } else {
                return Response.notFound()
            }
        })
    }
}

module.exports = controller


text:
namespace fyiReporting.RdlDesign
{
    /// <summary>
    /// Summary description for StyleCtl.
    /// </summary>
    partial class DataSetsCtl
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }
            base.Dispose(disposing);
        }

        #region Component Designer generated code
        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(DataSetsCtl));
            System.Windows.Forms.DataGridViewCellStyle dataGridViewCellStyle1 = new System.Windows.Forms.DataGridViewCellStyle();
            this.splitContainer1 = new System.Windows.Forms.SplitContainer();
            this.panel2 = new System.Windows.Forms.Panel();
            this.panel4 = new System.Windows.Forms.Panel();
            this.scintillaSQL = new ScintillaNET.Scintilla();
            this.panel3 = new System.Windows.Forms.Panel();
            this.bRefresh = new System.Windows.Forms.Button();
            this.bEditSQL = new System.Windows.Forms.Button();
            this.panel1 = new System.Windows.Forms.Panel();
            this.lDataSetName = new System.Windows.Forms.Label();
            this.tbDSName = new System.Windows.Forms.TextBox();
            this.tbTimeout = new System.Windows.Forms.NumericUpDown();
            this.label3 = new System.Windows.Forms.Label();
            this.label1 = new System.Windows.Forms.Label();
            this.cbDataSource = new System.Windows.Forms.ComboBox();
            this.lDataSource = new System.Windows.Forms.Label();
            this.bDeleteField = new System.Windows.Forms.Button();
            this.dgFields = new System.Windows.Forms.DataGridView();
            this.dgtbName = new System.Windows.Forms.DataGridViewTextBoxColumn();
            this.dgtbQueryName = new System.Windows.Forms.DataGridViewTextBoxColumn();
            this.dgtbValue = new System.Windows.Forms.DataGridViewTextBoxColumn();
            this.dgtbTypeName = new System.Windows.Forms.DataGridViewComboBoxColumn();
            this.label2 = new System.Windows.Forms.Label();
            this.dataGridTableStyle1 = new System.Windows.Forms.DataGridTableStyle();
            ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
            this.splitContainer1.Panel1.SuspendLayout();
            this.splitContainer1.Panel2.SuspendLayout();
            this.splitContainer1.SuspendLayout();
            this.panel2.SuspendLayout();
            this.panel4.SuspendLayout();
            this.panel3.SuspendLayout();
            this.panel1.SuspendLayout();
            ((System.ComponentModel.ISupportInitialize)(this.tbTimeout)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.dgFields)).BeginInit();
            this.SuspendLayout();
            //
            // splitContainer1
            //
            resources.ApplyResources(this.splitContainer1, "splitContainer1");
            this.splitContainer1.Name = "splitContainer1";
            //
            // splitContainer1.Panel1
            //
            this.splitContainer1.Panel1.Controls.Add(this.panel2);
            this.splitContainer1.Panel1.Controls.Add(this.panel1);
            //
            // splitContainer1.Panel2
            //
            this.splitContainer1.Panel2.Controls.Add(this.bDeleteField);
            this.splitContainer1.Panel2.Controls.Add(this.dgFields);
            this.splitContainer1.Panel2.Controls.Add(this.label2);
            //
            // panel2
            //
            this.panel2.Controls.Add(this.panel4);
            this.panel2.Controls.Add(this.panel3);
            resources.ApplyResources(this.panel2, "panel2");
            this.panel2.Name = "panel2";
            //
            // panel4
            //
            this.panel4.Controls.Add(this.scintillaSQL);
            resources.ApplyResources(this.panel4, "panel4");
            this.panel4.Name = "panel4";
            //
            // scintillaSQL
            //
            resources.ApplyResources(this.scintillaSQL, "scintillaSQL");
            this.scintillaSQL.Lexer = ScintillaNET.Lexer.Sql;
            this.scintillaSQL.Name = "scintillaSQL";
            this.scintillaSQL.UseTabs = false;
            this.scintillaSQL.TextChanged += new System.EventHandler(this.tbSQL_TextChanged);
            //
            // panel3
            //
            this.panel3.Controls.Add(this.bRefresh);
            this.panel3.Controls.Add(this.bEditSQL);
            resources.ApplyResources(this.panel3, "panel3");
            this.panel3.Name = "panel3";
            //
            // bRefresh
            //
            resources.ApplyResources(this.bRefresh, "bRefresh");
            this.bRefresh.Name = "bRefresh";
            this.bRefresh.Click += new System.EventHandler(this.bRefresh_Click);
            //
            // bEditSQL
            //
            resources.ApplyResources(this.bEditSQL, "bEditSQL");
            this.bEditSQL.Name = "bEditSQL";
            this.bEditSQL.Click += new System.EventHandler(this.bEditSQL_Click);
            //
            // panel1
            //
            this.panel1.Controls.Add(this.lDataSetName);
            this.panel1.Controls.Add(this.tbDSName);
            this.panel1.Controls.Add(this.tbTimeout);
            this.panel1.Controls.Add(this.label3);
            this.panel1.Controls.Add(this.label1);
            this.panel1.Controls.Add(this.cbDataSource);
            this.panel1.Controls.Add(this.lDataSource);
            resources.ApplyResources(this.panel1, "panel1");
            this.panel1.Name = "panel1";
            //
            // lDataSetName
            //
            resources.ApplyResources(this.lDataSetName, "lDataSetName");
            this.lDataSetName.Name = "lDataSetName";
            //
            // tbDSName
            //
            resources.ApplyResources(this.tbDSName, "tbDSName");
            this.tbDSName.Name = "tbDSName";
            this.tbDSName.TextChanged += new System.EventHandler(this.tbDSName_TextChanged);
            //
            // tbTimeout
            //
            resources.ApplyResources(this.tbTimeout, "tbTimeout");
            this.tbTimeout.Maximum = new decimal(new int[] {
            2147483647,
            0,
            0,
            0});
            this.tbTimeout.Name = "tbTimeout";
            this.tbTimeout.ValueChanged += new System.EventHandler(this.tbTimeout_ValueChanged);
            //
            // label3
            //
            resources.ApplyResources(this.label3, "label3");
            this.label3.Name = "label3";
            //
            // label1
            //
            resources.ApplyResources(this.label1, "label1");
            this.label1.Name = "label1";
            //
            // cbDataSource
            //
            resources.ApplyResources(this.cbDataSource, "cbDataSource");
            this.cbDataSource.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.cbDataSource.Name = "cbDataSource";
            this.cbDataSource.SelectedIndexChanged += new System.EventHandler(this.cbDataSource_SelectedIndexChanged);
            //
            // lDataSource
            //
            resources.ApplyResources(this.lDataSource, "lDataSource");
            this.lDataSource.Name = "lDataSource";
            //
            // bDeleteField
            //
            resources.ApplyResources(this.bDeleteField, "bDeleteField");
            this.bDeleteField.Name = "bDeleteField";
            this.bDeleteField.Click += new System.EventHandler(this.bDeleteField_Click);
            //
            // dgFields
            //
            resources.ApplyResources(this.dgFields, "dgFields");
            this.dgFields.AutoSizeColumnsMode = System.Windows.Forms.DataGridViewAutoSizeColumnsMode.Fill;
            dataGridViewCellStyle1.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleLeft;
            dataGridViewCellStyle1.BackColor = System.Drawing.SystemColors.ControlText;
            dataGridViewCellStyle1.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
            dataGridViewCellStyle1.ForeColor = System.Drawing.SystemColors.WindowText;
            dataGridViewCellStyle1.SelectionBackColor = System.Drawing.SystemColors.Highlight;
            dataGridViewCellStyle1.SelectionForeColor = System.Drawing.SystemColors.HighlightText;
            dataGridViewCellStyle1.WrapMode = System.Windows.Forms.DataGridViewTriState.True;
            this.dgFields.ColumnHeadersDefaultCellStyle = dataGridViewCellStyle1;
            this.dgFields.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] {
            this.dgtbName,
            this.dgtbQueryName,
            this.dgtbValue,
            this.dgtbTypeName});
            this.dgFields.Name = "dgFields";
            //
            // dgtbName
            //
            this.dgtbName.DataPropertyName = "Name";
            resources.ApplyResources(this.dgtbName, "dgtbName");
            this.dgtbName.Name = "dgtbName";
            //
            // dgtbQueryName
            //
            this.dgtbQueryName.DataPropertyName = "QueryName";
            resources.ApplyResources(this.dgtbQueryName, "dgtbQueryName");
            this.dgtbQueryName.Name = "dgtbQueryName";
            //
            // dgtbValue
            //
            this.dgtbValue.DataPropertyName = "Value";
            resources.ApplyResources(this.dgtbValue, "dgtbValue");
            this.dgtbValue.Name = "dgtbValue";
            //
            // dgtbTypeName
            //
            this.dgtbTypeName.DataPropertyName = "TypeName";
            resources.ApplyResources(this.dgtbTypeName, "dgtbTypeName");
            this.dgtbTypeName.Items.AddRange(new object[] {
            "System.String",
            "System.Int16",
            "System.Int32",
            "System.Int64",
            "System.UInt16",
            "System.UInt32",
            "System.UInt64",
            "System.Single",
            "System.Double",
            "System.Decimal",
            "System.DateTime",
            "System.Char",
            "System.Boolean",
            "System.Byte"});
            this.dgtbTypeName.Name = "dgtbTypeName";
            this.dgtbTypeName.Resizable = System.Windows.Forms.DataGridViewTriState.True;
            this.dgtbTypeName.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.Automatic;
            //
            // label2
            //
            resources.ApplyResources(this.label2, "label2");
            this.label2.Name = "label2";
            //
            // dataGridTableStyle1
            //
            this.dataGridTableStyle1.DataGrid = null;
            this.dataGridTableStyle1.HeaderForeColor = System.Drawing.SystemColors.ControlText;
            //
            // DataSetsCtl
            //
            this.Controls.Add(this.splitContainer1);
            resources.ApplyResources(this, "$this");
            this.Name = "DataSetsCtl";
            this.splitContainer1.Panel1.ResumeLayout(false);
            this.splitContainer1.Panel2.ResumeLayout(false);
            ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit();
            this.splitContainer1.ResumeLayout(false);
            this.panel2.ResumeLayout(false);
            this.panel4.ResumeLayout(false);
            this.panel3.ResumeLayout(false);
            this.panel1.ResumeLayout(false);
            this.panel1.PerformLayout();
            ((System.ComponentModel.ISupportInitialize)(this.tbTimeout)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.dgFields)).EndInit();
            this.ResumeLayout(false);

        }
        #endregion

        private System.Windows.Forms.DataGridTableStyle dataGridTableStyle1;
        private System.Windows.Forms.SplitContainer splitContainer1;
        private System.Windows.Forms.NumericUpDown tbTimeout;
        private System.Windows.Forms.Label label3;
        private System.Windows.Forms.Button bRefresh;
        private System.Windows.Forms.Button bEditSQL;
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.ComboBox cbDataSource;
        private System.Windows.Forms.Label lDataSource;
        private System.Windows.Forms.TextBox tbDSName;
        private System.Windows.Forms.Label lDataSetName;
        private System.Windows.Forms.Button bDeleteField;
        private System.Windows.Forms.DataGridView dgFields;
		private System.Windows.Forms.Label label2;
		private System.Windows.Forms.DataGridViewTextBoxColumn dgtbName;
		private System.Windows.Forms.DataGridViewTextBoxColumn dgtbQueryName;
		private System.Windows.Forms.DataGridViewTextBoxColumn dgtbValue;
		private System.Windows.Forms.DataGridViewComboBoxColumn dgtbTypeName;
        private System.Windows.Forms.Panel panel2;
        private System.Windows.Forms.Panel panel4;
        private ScintillaNET.Scintilla scintillaSQL;
        private System.Windows.Forms.Panel panel3;
        private System.Windows.Forms.Panel panel1;
    }
}


text:
<?php

/**
* <auto-generated>
*     This code was generated by Codezu.
*
*     Changes to this file may cause incorrect behavior and will be lost if
*     the code is regenerated.
* </auto-generated>
*/

namespace Mozu\Api\Resources\Commerce\Orders;

use Mozu\Api\Clients\Commerce\Orders\FulfillmentInfoClient;
use Mozu\Api\ApiContext;

/**
* Use the Fulfillment Information resource to manage shipping or pickup information for orders.
*/
class FulfillmentInfoResource {

		private $apiContext;

	public function __construct(ApiContext $apiContext)
	{
		$this->apiContext = $apiContext;
	}

	/**
	* Retrieves a list of the fulfillment information for the specified order.
	*
	* @param bool $draft If true, retrieve the draft version of the order, which might include uncommitted changes to the order or its components.
	* @param string $orderId Unique identifier of the order.
	* @param string $responseFields Use this field to include those fields which are not included by default.
	* @return FulfillmentInfo
	* @deprecated deprecated since version 1.17
	*/
	public function getFulfillmentInfo($orderId, $draft =  null, $responseFields =  null)
	{
		$mozuClient = FulfillmentInfoClient::getFulfillmentInfoClient($orderId, $draft, $responseFields);
		$mozuClient = $mozuClient->withContext($this->apiContext);
		$mozuClient->execute();
		return $mozuClient->getResult();

	}

/**
	* Retrieves a list of the fulfillment information for the specified order.
	*
	* @param bool $draft If true, retrieve the draft version of the order, which might include uncommitted changes to the order or its components.
	* @param string $orderId Unique identifier of the order.
	* @param string $responseFields Use this field to include those fields which are not included by default.
	* @return Promise - use $promise->then(sucessfn, errorfn). successFn is passed Mozu\Api\MozuResult. errorFn is passed Mozu\Api\ApiException
	*/
	public function getFulfillmentInfoAsync($orderId, $draft =  null, $responseFields =  null)
	{
		$mozuClient = FulfillmentInfoClient::getFulfillmentInfoClient($orderId, $draft, $responseFields);
		$mozuClient = $mozuClient->withContext($this->apiContext);
		return $mozuClient->executeAsync();

	}

	/**
	* Updates one or more properties of fulfillment information for the specified order.
	*
	* @param string $orderId Unique identifier of the order.
	* @param string $responseFields Use this field to include those fields which are not included by default.
	* @param string $updateMode Specifies whether to update the original order, update the order in draft mode, or update the order in draft mode and then commit the changes to the original. Draft mode enables users to make incremental order changes before committing the changes to the original order. Valid values are "ApplyToOriginal," "ApplyToDraft," or "ApplyAndCommit."
	* @param string $version System-supplied integer that represents the current version of the order, which prevents users from unintentionally overriding changes to the order. When a user performs an operation for a defined order, the system validates that the version of the updated order matches the version of the order on the server. After the operation completes successfully, the system increments the version number by one.
	* @param FulfillmentInfo $fulfillmentInfo Properties of the information needed to fulfill an order, whether via in-store pickup or direct shipping.
	* @return FulfillmentInfo
	* @deprecated deprecated since version 1.17
	*/
	public function setFulFillmentInfo($fulfillmentInfo, $orderId, $updateMode =  null, $version =  null, $responseFields =  null)
	{
		$mozuClient = FulfillmentInfoClient::setFulFillmentInfoClient($fulfillmentInfo, $orderId, $updateMode, $version, $responseFields);
		$mozuClient = $mozuClient->withContext($this->apiContext);
		$mozuClient->execute();
		return $mozuClient->getResult();

	}

/**
	* Updates one or more properties of fulfillment information for the specified order.
	*
	* @param string $orderId Unique identifier of the order.
	* @param string $responseFields Use this field to include those fields which are not included by default.
	* @param string $updateMode Specifies whether to update the original order, update the order in draft mode, or update the order in draft mode and then commit the changes to the original. Draft mode enables users to make incremental order changes before committing the changes to the original order. Valid values are "ApplyToOriginal," "ApplyToDraft," or "ApplyAndCommit."
	* @param string $version System-supplied integer that represents the current version of the order, which prevents users from unintentionally overriding changes to the order. When a user performs an operation for a defined order, the system validates that the version of the updated order matches the version of the order on the server. After the operation completes successfully, the system increments the version number by one.
	* @return Promise - use $promise->then(sucessfn, errorfn). successFn is passed Mozu\Api\MozuResult. errorFn is passed Mozu\Api\ApiException
	*/
	public function setFulFillmentInfoAsync($fulfillmentInfo, $orderId, $updateMode =  null, $version =  null, $responseFields =  null)
	{
		$mozuClient = FulfillmentInfoClient::setFulFillmentInfoClient($fulfillmentInfo, $orderId, $updateMode, $version, $responseFields);
		$mozuClient = $mozuClient->withContext($this->apiContext);
		return $mozuClient->executeAsync();

	}

}

?>


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TwitterAutherino.Model.Exceptions
{
    public class OAuthMissingAccessTokenException : Exception
    {
        public OAuthMissingAccessTokenException()
        {

        }

        public OAuthMissingAccessTokenException(string message) : base(message)
        {

        }
    }
}


text:
<?php

namespace OpgTest\Lpa\Pdf;

use Opg\Lpa\DataModel\Lpa\Lpa;
use Opg\Lpa\Pdf\AbstractIndividualPdf;

class TestableAbstractIndividualPdf extends AbstractIndividualPdf
{
    /**
     * PDF template file name (without path) for this PDF object
     *
     * @var
     */
    protected $templateFileName = 'LP1F.pdf';

    public function __construct(?Lpa $lpa = null, array $options = [])
    {

        parent::__construct($lpa, $options);
    }

    /**
     * Empty create method so that the class can be instantiated
     *
     * @param Lpa $lpa
     */
    protected function create(Lpa $lpa) { }

    /**
     * @throws \setasign\Fpdi\PdfParser\CrossReference\CrossReferenceException
     * @throws \setasign\Fpdi\PdfParser\Filter\FilterException
     * @throws \setasign\Fpdi\PdfParser\PdfParserException
     * @throws \setasign\Fpdi\PdfParser\Type\PdfTypeException
     * @throws \setasign\Fpdi\PdfReader\PdfReaderException
     */
    public function drawStrikeThroughsAndBlanks() : void
    {
        parent::drawStrikeThroughsAndBlanks();
    }

    public function addStrikeThrough($areaReference, $pageNumber = 1) : void
    {
        parent::addStrikeThrough($areaReference, $pageNumber);
    }

    public function addBlank($areaReference, $pageNumber = 1)
    {
        return parent::addBlank($areaReference, $pageNumber);
    }

    public function setPdfFile(string $path) : void
    {
        $this->pdfFile = $path;
    }
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace LogManager.Services.ServiceModels
{
    public class LogGrouping
    {
        public string LastErrorID { get; set; }
        public string ErrorType { get; set; }
        public string ErrorMessage { get; set; }
        public string ErrorDetail { get; set; }
        public string Url { get; set; }

        public int ErrorCount { get; set; }
        public String LastReport { get; set; }

        public List<LogEntry> LogEntries { get; set; }

        public Dictionary<string, string> ServerVariables { get; set; }
        public Dictionary<string, string> QueryStrings { get; set; }
        public Dictionary<string, string> Cookies { get; set; }
    }
}


text:
This example shows how to do server side rendering with next.js and React InstantSearch. There's a live example here: https://codesandbox.io/s/github/algolia/react-instantsearch/tree/master/examples/next.

## Clone the example

```
curl https://codeload.github.com/algolia/react-instantsearch/tar.gz/master | tar -xz --strip=2 react-instantsearch-master/examples/next
```

## Start the example

```sh
yarn install --no-lockfile
yarn run dev
```

Read more about `react-instantsearch` [in our documentation](https://www.algolia.com/doc/guides/building-search-ui/what-is-instantsearch/react/).


text:
// -*- C++ -*-

// Copyright (C) 2005-2014 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the terms
// of the GNU General Public License as published by the Free Software
// Foundation; either version 3, or (at your option) any later
// version.

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

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.

// Permission to use, copy, modify, sell, and distribute this software
// is hereby granted without fee, provided that the above copyright
// notice appears in all copies, and that both that copyright notice
// and this permission notice appear in supporting documentation. None
// of the above authors, nor IBM Haifa Research Laboratories, make any
// representation about the suitability of this software for any
// purpose. It is provided "as is" without express or implied
// warranty.

/**
 * @file left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp
 * Contains an implementation class for left_child_next_sibling_heap_.
 */

PB_DS_CLASS_T_DEC
typename PB_DS_CLASS_C_DEC::node_allocator
PB_DS_CLASS_C_DEC::s_node_allocator;

PB_DS_CLASS_T_DEC
typename PB_DS_CLASS_C_DEC::no_throw_copies_t
PB_DS_CLASS_C_DEC::s_no_throw_copies_ind;

PB_DS_CLASS_T_DEC
PB_DS_CLASS_C_DEC::
left_child_next_sibling_heap() :
  m_p_root(0),
  m_size(0)
{
  PB_DS_ASSERT_VALID((*this))
}

PB_DS_CLASS_T_DEC
PB_DS_CLASS_C_DEC::
left_child_next_sibling_heap(const Cmp_Fn& r_cmp_fn) :
  Cmp_Fn(r_cmp_fn),
  m_p_root(0),
  m_size(0)
{
  PB_DS_ASSERT_VALID((*this))
}

PB_DS_CLASS_T_DEC
PB_DS_CLASS_C_DEC::
left_child_next_sibling_heap(const PB_DS_CLASS_C_DEC& other)
: Cmp_Fn(other), m_p_root(0), m_size(0)
{
  m_size = other.m_size;
  PB_DS_ASSERT_VALID(other)
  m_p_root = recursive_copy_node(other.m_p_root);
  m_size = other.m_size;
  PB_DS_ASSERT_VALID((*this))
}

PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
swap(PB_DS_CLASS_C_DEC& other)
{
  PB_DS_ASSERT_VALID((*this))
  PB_DS_ASSERT_VALID(other)
  value_swap(other);
  std::swap((Cmp_Fn& )(*this), (Cmp_Fn& )other);
  PB_DS_ASSERT_VALID((*this))
  PB_DS_ASSERT_VALID(other)
}

PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
value_swap(PB_DS_CLASS_C_DEC& other)
{
  std::swap(m_p_root, other.m_p_root);
  std::swap(m_size, other.m_size);
}

PB_DS_CLASS_T_DEC
PB_DS_CLASS_C_DEC::
~left_child_next_sibling_heap()
{
  clear();
}

PB_DS_CLASS_T_DEC
typename PB_DS_CLASS_C_DEC::node_pointer
PB_DS_CLASS_C_DEC::
recursive_copy_node(node_const_pointer p_nd)
{
  if (p_nd == 0)
    return (0);

  node_pointer p_ret = s_node_allocator.allocate(1);

  __try
    {
      new (p_ret) node(*p_nd);
    }
  __catch(...)
    {
      s_node_allocator.deallocate(p_ret, 1);
      __throw_exception_again;
    }

  p_ret->m_p_l_child = p_ret->m_p_next_sibling =
    p_ret->m_p_prev_or_parent = 0;

  __try
    {
      p_ret->m_p_l_child = recursive_copy_node(p_nd->m_p_l_child);
      p_ret->m_p_next_sibling = recursive_copy_node(p_nd->m_p_next_sibling);
    }
  __catch(...)
    {
      clear_imp(p_ret);
      __throw_exception_again;
    }

  if (p_ret->m_p_l_child != 0)
    p_ret->m_p_l_child->m_p_prev_or_parent = p_ret;

  if (p_ret->m_p_next_sibling != 0)
    p_ret->m_p_next_sibling->m_p_prev_or_parent =
      p_nd->m_p_next_sibling->m_p_prev_or_parent == p_nd ? p_ret : 0;

  return p_ret;
}