text:
package de.tudarmstadt.ukp.clarin.webanno.api.annotation.util;

import static org.apache.uima.fit.factory.TypeSystemDescriptionFactory.createTypeSystemDescription;

import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import org.apache.uima.cas.CAS;
import org.apache.uima.resource.metadata.TypeSystemDescription;
import org.assertj.core.api.SoftAssertions;
import org.junit.Before;
import org.junit.Test;

import de.tudarmstadt.ukp.clarin.webanno.api.WebAnnoConst;
import de.tudarmstadt.ukp.clarin.webanno.model.AnchoringMode;
import de.tudarmstadt.ukp.clarin.webanno.model.AnnotationFeature;
import de.tudarmstadt.ukp.clarin.webanno.model.AnnotationLayer;
import de.tudarmstadt.ukp.clarin.webanno.model.OverlapMode;

public class TypeSystemAnalysisTest
{
    @Before
    public void setup()
    {
        ToStringBuilder.setDefaultStyle(ToStringStyle.SHORT_PREFIX_STYLE);
    }

    @Test
    public void testSpanWithPrimitiveFeatures() throws Exception
    {
        TypeSystemDescription tsd = createTypeSystemDescription("tsd/spanWithPrimitiveFeatures");
        TypeSystemAnalysis analysis = TypeSystemAnalysis.of(tsd);

        AnnotationLayer spanLayer = new AnnotationLayer();
        spanLayer.setName("webanno.custom.Span");
        spanLayer.setUiName("Span");
        spanLayer.setType(WebAnnoConst.SPAN_TYPE);
        spanLayer.setAnchoringMode(AnchoringMode.CHARACTERS);
        spanLayer.setOverlapMode(OverlapMode.ANY_OVERLAP);
        spanLayer.setCrossSentence(true);

        AnnotationFeature stringFeature = new AnnotationFeature("stringFeature",
                CAS.TYPE_NAME_STRING);
        AnnotationFeature intFeature = new AnnotationFeature("intFeature", CAS.TYPE_NAME_INTEGER);
        AnnotationFeature booleanFeature = new AnnotationFeature("booleanFeature",
                CAS.TYPE_NAME_BOOLEAN);
        AnnotationFeature floatFeature = new AnnotationFeature("floatFeature", CAS.TYPE_NAME_FLOAT);

        SoftAssertions softly = new SoftAssertions();
        softly.assertThat(analysis.getLayers()).containsExactly(spanLayer)
                .usingFieldByFieldElementComparator();
        softly.assertThat(analysis.getFeatures(spanLayer.getName()))
                .containsExactlyInAnyOrder(stringFeature, intFeature, booleanFeature, floatFeature)
                .usingFieldByFieldElementComparator();
        softly.assertAll();
    }

    @Test
    public void testSpanWithSlotFeatures() throws Exception
    {
        TypeSystemDescription tsd = createTypeSystemDescription("tsd/spanWithSlotFeatures");
        TypeSystemAnalysis analysis = TypeSystemAnalysis.of(tsd);

        AnnotationLayer slotSpanLayer = new AnnotationLayer();
        slotSpanLayer.setName("webanno.custom.SlotSpan");
        slotSpanLayer.setUiName("SlotSpan");
        slotSpanLayer.setType(WebAnnoConst.SPAN_TYPE);
        slotSpanLayer.setAnchoringMode(AnchoringMode.CHARACTERS);
        slotSpanLayer.setOverlapMode(OverlapMode.ANY_OVERLAP);
        slotSpanLayer.setCrossSentence(true);

        AnnotationFeature freeSlot = new AnnotationFeature("freeSlot", CAS.TYPE_NAME_ANNOTATION);

        AnnotationFeature boundSlot = new AnnotationFeature("boundSlot", "webanno.custom.SlotSpan");

        SoftAssertions softly = new SoftAssertions();
        softly.assertThat(analysis.getLayers()).containsExactly(slotSpanLayer)
                .usingFieldByFieldElementComparator();
        softly.assertThat(analysis.getFeatures(slotSpanLayer.getName()))
                .containsExactlyInAnyOrder(freeSlot, boundSlot)
                .usingFieldByFieldElementComparator();
        softly.assertAll();
    }

    @Test
    public void testRelationWithPrimitiveFeatures() throws Exception
    {
        TypeSystemDescription tsd = createTypeSystemDescription(
                "tsd/relationWithPrimitiveFeatures");
        TypeSystemAnalysis analysis = TypeSystemAnalysis.of(tsd);

        AnnotationLayer relationLayer = new AnnotationLayer();
        relationLayer.setName("webanno.custom.Relation");
        relationLayer.setUiName("Relation");
        relationLayer.setType(WebAnnoConst.RELATION_TYPE);
        relationLayer.setAnchoringMode(AnchoringMode.CHARACTERS);
        relationLayer.setOverlapMode(OverlapMode.ANY_OVERLAP);
        relationLayer.setCrossSentence(true);

        AnnotationLayer relationTargetLayer = new AnnotationLayer();
        relationTargetLayer.setName("webanno.custom.RelationTarget");
        relationTargetLayer.setUiName("RelationTarget");
        relationTargetLayer.setType(WebAnnoConst.SPAN_TYPE);
        relationTargetLayer.setAnchoringMode(AnchoringMode.CHARACTERS);
        relationTargetLayer.setOverlapMode(OverlapMode.ANY_OVERLAP);
        relationTargetLayer.setCrossSentence(true);

        AnnotationFeature stringFeature = new AnnotationFeature("stringFeature",
                CAS.TYPE_NAME_STRING);
        AnnotationFeature intFeature = new AnnotationFeature("intFeature", CAS.TYPE_NAME_INTEGER);
        AnnotationFeature booleanFeature = new AnnotationFeature("booleanFeature",
                CAS.TYPE_NAME_BOOLEAN);
        AnnotationFeature floatFeature = new AnnotationFeature("floatFeature", CAS.TYPE_NAME_FLOAT);

        SoftAssertions softly = new SoftAssertions();
        softly.assertThat(analysis.getLayers())
                .containsExactlyInAnyOrder(relationLayer, relationTargetLayer)
                .usingFieldByFieldElementComparator();
        softly.assertThat(analysis.getFeatures(relationLayer.getName()))
                .containsExactlyInAnyOrder(stringFeature, intFeature, booleanFeature, floatFeature)
                .usingFieldByFieldElementComparator();
        softly.assertAll();
    }

    @Test
    public void testChain() throws Exception
    {
        TypeSystemDescription tsd = createTypeSystemDescription("tsd/chain");
        TypeSystemAnalysis analysis = TypeSystemAnalysis.of(tsd);

        AnnotationLayer chainLayer = new AnnotationLayer();
        chainLayer.setName("webanno.custom.Chain");
        chainLayer.setUiName("Chain");
        chainLayer.setType(WebAnnoConst.CHAIN_TYPE);
        chainLayer.setAnchoringMode(AnchoringMode.CHARACTERS);
        chainLayer.setOverlapMode(OverlapMode.ANY_OVERLAP);
        chainLayer.setCrossSentence(true);

        AnnotationFeature referenceRelationFeature = new AnnotationFeature("referenceRelation",
                CAS.TYPE_NAME_STRING);
        AnnotationFeature referenceTypeFeature = new AnnotationFeature("referenceType",
                CAS.TYPE_NAME_STRING);

        SoftAssertions softly = new SoftAssertions();
        softly.assertThat(analysis.getLayers()).containsExactlyInAnyOrder(chainLayer)
                .usingFieldByFieldElementComparator();
        softly.assertThat(analysis.getFeatures(chainLayer.getName()))
                .containsExactlyInAnyOrder(referenceRelationFeature, referenceTypeFeature)
                .usingFieldByFieldElementComparator();
        softly.assertAll();
    }

    @Test
    public void testTheFullMonty() throws Exception
    {
        TypeSystemDescription tsd = createTypeSystemDescription("tsd/fullMonty");
        TypeSystemAnalysis analysis = TypeSystemAnalysis.of(tsd);

        SoftAssertions softly = new SoftAssertions();
        softly.assertThat(analysis.getLayers()).extracting(l -> l.getName() + ":" + l.getType())
                .hasSize(27).containsExactlyInAnyOrder(
                        "de.tudarmstadt.ukp.dkpro.core.api.coref.type.Coreference:chain",
                        "de.tudarmstadt.ukp.dkpro.core.api.lexmorph.type.morph.Morpheme:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.lexmorph.type.morph.MorphologicalFeatures:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.lexmorph.type.pos.POS:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.metadata.type.MetaDataStringField:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.ner.type.NamedEntity:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Div:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Lemma:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.LexicalPhrase:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.NGram:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Stem:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.StopWord:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.SurfaceForm:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.TokenForm:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.semantics.type.SemArg:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.semantics.type.SemPred:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.semantics.type.SemanticArgument:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.semantics.type.SemanticField:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.semantics.type.WordSense:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.syntax.type.PennTree:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.syntax.type.Tag:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.syntax.type.chunk.Chunk:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.syntax.type.dependency.Dependency:relation",
                        "de.tudarmstadt.ukp.dkpro.core.api.transform.type.SofaChangeAnnotation:span",
                        "webanno.custom.Chain:chain", "webanno.custom.Relation:relation",
                        "webanno.custom.SlotSpan:span");
        softly.assertAll();
    }

    @Test
    public void testCTakes40() throws Exception
    {
        TypeSystemDescription tsd = createTypeSystemDescription(
                "3rd-party-tsd/ctakes-type-system-4_0");
        TypeSystemAnalysis analysis = TypeSystemAnalysis.of(tsd);

        SoftAssertions softly = new SoftAssertions();
        softly.assertThat(analysis.getLayers()).extracting(l -> l.getName() + ":" + l.getType())
                .hasSize(8).containsExactlyInAnyOrder(
                        "org.apache.ctakes.typesystem.type.textspan.Segment:span",
                        "org.apache.ctakes.typesystem.type.textspan.Sentence:span",
                        "org.apache.ctakes.typesystem.type.syntax.Chunk:span",
                        "org.apache.ctakes.typesystem.type.textspan.LookupWindowAnnotation:span",
                        "org.apache.ctakes.typesystem.type.temporary.assertion.AssertionCuePhraseAnnotation:span",
                        "org.apache.ctakes.typesystem.type.textspan.Paragraph:span",
                        "org.apache.ctakes.typesystem.type.textspan.ListEntry:span",
                        "org.apache.ctakes.typesystem.type.textspan.LookupWindowAnnotation:span");
        softly.assertAll();
    }

    @Test
    public void testCcpTypeSystem() throws Exception
    {
        TypeSystemDescription tsd = createTypeSystemDescription("3rd-party-tsd/CcpTypeSystem");
        TypeSystemAnalysis analysis = TypeSystemAnalysis.of(tsd);

        SoftAssertions softly = new SoftAssertions();
        softly.assertThat(analysis.getLayers()).hasSize(0);
        softly.assertAll();
    }

    @Test
    public void testTtcTermSuite() throws Exception
    {
        TypeSystemDescription tsd = createTypeSystemDescription("3rd-party-tsd/ttc-term-suite");
        TypeSystemAnalysis analysis = TypeSystemAnalysis.of(tsd);

        SoftAssertions softly = new SoftAssertions();
        softly.assertThat(analysis.getLayers()).extracting(l -> l.getName() + ":" + l.getType())
                .hasSize(4).containsExactlyInAnyOrder("eu.project.ttc.types.WordAnnotation:span",
                        "eu.project.ttc.types.TermComponentAnnotation:span",
                        "eu.project.ttc.types.TranslationCandidateAnnotation:span",
                        "eu.project.ttc.types.FormAnnotation:span");
        softly.assertAll();
    }

    @Test
    public void testCreta() throws Exception
    {
        TypeSystemDescription tsd = createTypeSystemDescription("3rd-party-tsd/creta-typesystem");
        TypeSystemAnalysis analysis = TypeSystemAnalysis.of(tsd);

        SoftAssertions softly = new SoftAssertions();
        softly.assertThat(analysis.getLayers()).extracting(l -> l.getName() + ":" + l.getType())
                .hasSize(58).containsExactlyInAnyOrder(
                        "de.tudarmstadt.ukp.dkpro.core.api.coref.type.Coreference:chain",
                        "de.tudarmstadt.ukp.dkpro.core.api.lexmorph.type.morph.Morpheme:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.lexmorph.type.morph.MorphologicalFeatures:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.lexmorph.type.pos.POS:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.metadata.type.MetaDataStringField:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.ner.type.NamedEntity:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Div:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Lemma:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.NGram:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Stem:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.StopWord:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.semantics.type.SemanticArgument:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.semantics.type.SemanticField:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.semantics.type.WordSense:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.syntax.type.PennTree:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.syntax.type.Tag:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.syntax.type.chunk.Chunk:span",
                        "de.tudarmstadt.ukp.dkpro.core.api.syntax.type.dependency.Dependency:relation",
                        "de.uni_potsdam.acl.type.Chunk:span",
                        "de.uni_potsdam.acl.type.ClusteredEventMention:span",
                        "de.uni_potsdam.acl.type.Mention:span",
                        "de.uni_potsdam.acl.type.Negation:span",
                        "de.uni_potsdam.acl.type.Sentiment:span",
                        "de.unihd.dbs.uima.types.heideltime.Dct:span",
                        "de.unihd.dbs.uima.types.heideltime.Sentence:span",
                        "de.unihd.dbs.uima.types.heideltime.SourceDocInfo:span",
                        "de.unihd.dbs.uima.types.heideltime.Timex3:span",
                        "de.unihd.dbs.uima.types.heideltime.Timex3Interval:span",
                        "de.unihd.dbs.uima.types.heideltime.Token:span",
                        "de.unistuttgart.ims.creta.api.Entity:span",
                        "de.unistuttgart.ims.creta.api.ExampleType:span",
                        "de.unistuttgart.ims.creta.api.Format:span",
                        "de.unistuttgart.ims.creta.api.Line:span",
                        "de.unistuttgart.ims.creta.api.Quotation:span",
                        "de.unistuttgart.ims.creta.api.Stage:span",
                        "de.unistuttgart.ims.creta.api.Utterance:span",
                        "de.unistuttgart.ims.type.Agenda:span",
                        "de.unistuttgart.ims.type.Chunk:span",
                        "de.unistuttgart.ims.type.HumanAnnotation:span",
                        "de.unistuttgart.ims.type.Keyword:span",
                        "de.unistuttgart.ims.type.Link:span",
                        "de.unistuttgart.ims.type.Markable:span",
                        "de.unistuttgart.ims.type.NE:span",
                        "de.unistuttgart.ims.type.Paragraph:span",
                        "de.unistuttgart.ims.type.Quotation:span",
                        "de.unistuttgart.ims.type.Section:span",
                        "de.unistuttgart.ims.type.Sentence:span",
                        "de.unistuttgart.ims.type.Speaker:span",
                        "de.unistuttgart.ims.type.Token:span",
                        "de.unistuttgart.ims.uimautil.WordListDescription:span",
                        "org.cleartk.ne.type.Ace2005Document:span",
                        "org.cleartk.ne.type.Chunk:span",
                        "org.cleartk.score.type.ScoredAnnotation:span",
                        "org.cleartk.srl.type.Chunk:span", "org.cleartk.timeml.type.Anchor:span",
                        "org.cleartk.timeml.type.Event:span",
                        "org.cleartk.token.type.Subtoken:span",
                        "org.cleartk.token.type.Token:span");
        softly.assertAll();
    }
}


text:
<?php

/**
 * SpaceSettingTest
 *
 * @package humhub.modules_core.space.tests.unit.models
 * @since 0.9
 * @group space
 */
class SpaceSettingTest extends CDbTestCase
{

    public $fixtures = array(':space_setting');

    protected function setUp()
    {
        parent::setUp();

        Yii::app()->cache->flush();
        RuntimeCache::$data = array();
    }

    public function testGet()
    {
        $this->assertEquals(SpaceSetting::Get(1, 'globalSetting', 'core'), 'xyz');
        $this->assertEquals(SpaceSetting::Get(1, 'globalSetting'), 'xyz');

        $this->assertEquals(SpaceSetting::Get(1, 'moduleSetting', 'someModule'), 'zyx');

        $space = Space::model()->findByPk(1);
        $this->assertEquals($space->getSetting('globalSetting', 'core'), 'xyz');
        $this->assertEquals($space->getSetting('globalSetting'), 'xyz');
        $this->assertEquals($space->getSetting('moduleSetting', 'someModule'), 'zyx');
    }

    public function testSet()
    {
        SpaceSetting::Set(1, 'globalSetting', 'xyz2');
        $this->assertEquals(SpaceSetting::Get(1, 'globalSetting', 'core'), 'xyz2');
    }

}

redpajama_set_name: RedPajamaGithub


text:
This repo houses game-theoretic motion planning experiments.

### \#TODO
* Set up file structure
* Import OMPL
* Modify the RRT\* algorithm


text:
package old.datatypes.bindingsite;

import old.datatypes.sequence.Sequence;

/**
 * Abstract class that implements the NBindingSites interface.
 * @author Tristan
 *
 */
public abstract class AbstractNBindingSites implements NBindingSites{

	private BindingSite[] sites;

	protected AbstractNBindingSites(Sequence seq, int[] starts, int[] ends){
		int count = Math.min(starts.length, ends.length);
		sites = new BindingSite[count];
		for(int i=0; i<count; i++){
			sites[i] = new BindingSite(seq, starts[i], ends[i]);
		}
	}

	@Override
	public BindingSite[] getBindingSites() {
		return sites;
	}

	@Override
	public abstract String getName();

}


text:
int main(int argc, char* argv[]) {
	// check for file
	if(argc<3)
	{
		printf("Missing files to concatenate... usage: MergeResults <MergedFile.txt> <file1.txt> <file2.txt>...\n");
		return -1;
	}
	int numberOfFiles = argc-2;
	printf("Number of files combining: %d\n",numberOfFiles);
	std::ofstream mergedFile(argv[1], std::ios_base::binary);
	for(int i= 0; i<numberOfFiles;i++)
	{
		printf("Appending [%s] to [%s] ...\n",argv[i+2],argv[1]);
		std::ifstream fileToAppend(argv[i+2], std::ios_base::binary);
		mergedFile << fileToAppend.rdbuf();
		fileToAppend.close();
	}
	printf("Concatenation Finished\n");
	mergedFile.close();
	return 0;
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<urlset
      xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9
            http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd">

  <url>
    <loc>http://borderlands2goldenkeys.laedit.net/</loc>
    <changefreq>daily</changefreq>
  </url>
  <url>
    <loc>http://borderlands2goldenkeys.laedit.net/showall</loc>
    <changefreq>daily</changefreq>
  </url>
  <url>
    <loc>http://borderlands2goldenkeys.laedit.net/rss</loc>
    <changefreq>daily</changefreq>
  </url>
</urlset>


text:
'use strict';
(function(){

    var module = angular.module('editAdoc.service.storage', []);

    module.service('LocalStorage', function LocalStorage($localStorage, $q) {
        var storageKey = 'EditAdocCache';
        var changeListeners =  Object.create(null);
        var that = this;

        $localStorage[storageKey] = $localStorage[storageKey] || Object.create(null);

        this.save = function (key, value) {
            if (value === null) {
                return;
            }

            if (Array.isArray(changeListeners[key])) {
                changeListeners[key].forEach(function (fn) {
                    fn(value);
                });
            }

            //_.debounce(function () {
               // window.requestAnimationFrame(function () {
                    $localStorage[storageKey][key] = value;
                //});
          //  }, 100)();
        };

        this.reset = function () {
            Object.keys($localStorage[storageKey]).forEach(function (key) {
                that.save(key, '');
            });
        };

        this.load = function (key) {
            var deferred = $q.defer();
            if (!key) {
                deferred.resolve($localStorage[storageKey]);
            } else {
                deferred.resolve($localStorage[storageKey][key]);
            }

            return deferred.promise;
        };

        this.addChangeListener = function (key, fn) {
            if (angular.isFunction(fn)) {
                if (!changeListeners[key]) {
                    changeListeners[key] = [];
                }
                changeListeners[key].push(fn);
            }
        };
    });

    /*
     * Determines if LocalStorage should be used for storage or a Backend
    */
    module.service('Storage', function Storage(LocalStorage,
      defaults) {
      if (defaults.useBackendForStorage) {
          //TODO : handle backend storage or Firebird Storage ?
        return LocalStorage;
      }

      return LocalStorage;
    });

})();


text:
FROM ubuntu:18.04

ENV PROTOC_VERSION 3.8.0

RUN export DEBIAN_FRONTEND=noninteractive DEBCONF_NONINTERACTIVE_SEEN=true && \
    apt-get -q update && \
    apt-get install -qy --no-install-recommends \
      autoconf \
      automake \
      ca-certificates \
      libtool \
      curl \
      make \
      g++ \
      unzip \
      zlib1g-dev && \
    rm -r /var/lib/apt/lists/*

WORKDIR /tmp

RUN curl -O -L https://github.com/protocolbuffers/protobuf/archive/v${PROTOC_VERSION}.zip
RUN unzip v${PROTOC_VERSION}.zip
RUN cd protobuf-${PROTOC_VERSION} && \
    ./autogen.sh && \
    ./configure --disable-debug --disable-dependency-tracking --prefix=/usr/local --with-zlib && \
    make && \
    make install && \
    ldconfig && \
    cd .. && \
    rm -rf v${PROTOC_VERSION}.zip protobuf-${PROTOC_VERSION}


text:
package com.amazonaws.services.iotfleetwise.model;

import javax.annotation.Generated;

/**
 *

 * The request couldn't be completed due to throttling.
 *

 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class ThrottlingException extends com.amazonaws.services.iotfleetwise.model.AWSIoTFleetWiseException {
    private static final long serialVersionUID = 1L;

    /**
     *

     * The quota identifier of the applied throttling rules for this request.
     *

     */
    private String quotaCode;
    /**
     *

     * The code for the service that couldn't be completed due to throttling.
     *

     */
    private String serviceCode;
    /**
     *

     * The number of seconds to wait before retrying the command.
     *

     */
    private Integer retryAfterSeconds;

    /**
     * Constructs a new ThrottlingException with the specified error message.
     *
     * @param message
     *        Describes the error encountered.
     */
    public ThrottlingException(String message) {
        super(message);
    }

    /**
     *

     * The quota identifier of the applied throttling rules for this request.
     *

     *
     * @param quotaCode
     *        The quota identifier of the applied throttling rules for this request.
     */

    @com.fasterxml.jackson.annotation.JsonProperty("quotaCode")
    public void setQuotaCode(String quotaCode) {
        this.quotaCode = quotaCode;
    }

    /**
     *

     * The quota identifier of the applied throttling rules for this request.
     *

     *
     * @return The quota identifier of the applied throttling rules for this request.
     */

    @com.fasterxml.jackson.annotation.JsonProperty("quotaCode")
    public String getQuotaCode() {
        return this.quotaCode;
    }

    /**
     *

     * The quota identifier of the applied throttling rules for this request.
     *

     *
     * @param quotaCode
     *        The quota identifier of the applied throttling rules for this request.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public ThrottlingException withQuotaCode(String quotaCode) {
        setQuotaCode(quotaCode);
        return this;
    }

    /**
     *

     * The code for the service that couldn't be completed due to throttling.
     *

     *
     * @param serviceCode
     *        The code for the service that couldn't be completed due to throttling.
     */

    @com.fasterxml.jackson.annotation.JsonProperty("serviceCode")
    public void setServiceCode(String serviceCode) {
        this.serviceCode = serviceCode;
    }

    /**
     *

     * The code for the service that couldn't be completed due to throttling.
     *

     *
     * @return The code for the service that couldn't be completed due to throttling.
     */

    @com.fasterxml.jackson.annotation.JsonProperty("serviceCode")
    public String getServiceCode() {
        return this.serviceCode;
    }

    /**
     *

     * The code for the service that couldn't be completed due to throttling.
     *

     *
     * @param serviceCode
     *        The code for the service that couldn't be completed due to throttling.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public ThrottlingException withServiceCode(String serviceCode) {
        setServiceCode(serviceCode);
        return this;
    }

    /**
     *

     * The number of seconds to wait before retrying the command.
     *

     *
     * @param retryAfterSeconds
     *        The number of seconds to wait before retrying the command.
     */

    @com.fasterxml.jackson.annotation.JsonProperty("retryAfterSeconds")
    public void setRetryAfterSeconds(Integer retryAfterSeconds) {
        this.retryAfterSeconds = retryAfterSeconds;
    }

    /**
     *

     * The number of seconds to wait before retrying the command.
     *

     *
     * @return The number of seconds to wait before retrying the command.
     */

    @com.fasterxml.jackson.annotation.JsonProperty("retryAfterSeconds")
    public Integer getRetryAfterSeconds() {
        return this.retryAfterSeconds;
    }

    /**
     *

     * The number of seconds to wait before retrying the command.
     *

     *
     * @param retryAfterSeconds
     *        The number of seconds to wait before retrying the command.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public ThrottlingException withRetryAfterSeconds(Integer retryAfterSeconds) {
        setRetryAfterSeconds(retryAfterSeconds);
        return this;
    }

}


text:
import Ember from 'ember';

export default Ember.Component.extend({
  i18n: Ember.inject.service(),
  errorMessage: '',
  rememberMe: false,
  isPending: false,

  // change the store's cookie expiration time depending on whether 'remember me' is checked or not
  rememberMeChanged: Ember.observer('rememberMe', function () {
    const fourteenDays = 1209600;
    const expiration = this.get('rememberMe') ? fourteenDays : null;

    this.set('session.store.cookieExpirationTime', expiration);
  }),

  actions: {
    login() {
      this.set('isPending', true);
      this.set('errorMessage', '');
      let errorMessage;

      this.get('session').authenticate('authenticator:devise', this.get('identification'), this.get('password')).then(
        () => {
          this.set('isPending', false);
        },
        () => {
          this.set('isPending', false);
          errorMessage = this.get('i18n').t('validation.auth.invalidCredentials');
          this.set('errorMessage', errorMessage);
        }
      );
    },
  },
});


text:
{% load staticfiles %}
{% load adv_cache %}

<!DOCTYPE html>

    <title>{% block title %}{% endblock %} - {{SITE_META.site_name}}</title>

    {% include 'partials/seo.html' %}
    {% include 'partials/icons.html' %}

    <link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css" rel="stylesheet">
    <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,700,300italic' rel='stylesheet' type='text/css'>
    <link rel="stylesheet" type="text/css" href="{% static 'css/bootstrap.journal.min.css' %}" />
    <link rel="stylesheet" type="text/css" href="{% static 'css/dataTables.bootstrap.css' %}" />

    {% block extra_css %}{% endblock %}

    <link rel="stylesheet" type="text/css" href="{% static 'css/custom.css' %}" />
    <link rel="stylesheet" type="text/css" href="{% static 'css/city_custom.css' %}" />

    {% cache 600 nav_wrapper 'nav' %}

              <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
                Toggle navigation

              </button>

                Metro Board

                        About

                            Board of Directors

                            Committees

                            Contact Us

                            About Us

                        Search

                            Board Reports

                            Archive Search

                        Meetings

                            {{ CITY_VOCAB.EVENTS }} & Agendas

                            Minutes

                    {% nocache %}

                        {% if user.is_authenticated %}
                             Logout
                        {% else %}

                        {% endif %}

                    {% endnocache %}

    {% endcache %}

    {% block full_content %}
    {% endblock %}

    {% block extra_js %}{% endblock %}

    {% comment %}
        This block is included for reference by our template overrides, e.g.,
        search/search.html. Extending the extra_js block and calling super()
        duplicates the extended content. I'm not quite sure why the duplication
        occurs, but this seems to fix the problem.
    {% endcomment %}

    {% block uninherited_js %}{% endblock %}