text:
#ifndef GRPC_CORE_LIB_BACKOFF_BACKOFF_H
#define GRPC_CORE_LIB_BACKOFF_BACKOFF_H

#include "src/core/lib/iomgr/exec_ctx.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
  /// const:  how long to wait after the first failure before retrying
  grpc_millis initial_backoff;

  /// const: factor with which to multiply backoff after a failed retry
  double multiplier;

  /// const: amount to randomize backoffs
  double jitter;

  /// const: minimum time between retries
  grpc_millis min_connect_timeout;

  /// const: maximum time between retries
  grpc_millis max_backoff;

  /// current delay before retries
  grpc_millis current_backoff;

  /// random number generator
  uint32_t rng_state;
} grpc_backoff;

typedef struct {
  /// Deadline to be used for the current attempt.
  grpc_millis current_deadline;

  /// Deadline to be used for the next attempt, following the backoff strategy.
  grpc_millis next_attempt_start_time;
} grpc_backoff_result;

/// Initialize backoff machinery - does not need to be destroyed
void grpc_backoff_init(grpc_backoff* backoff, grpc_millis initial_backoff,
                       double multiplier, double jitter,
                       grpc_millis min_connect_timeout,
                       grpc_millis max_backoff);

/// Begin retry loop: returns the deadlines to be used for the current attempt
/// and the subsequent retry, if any.
grpc_backoff_result grpc_backoff_begin(grpc_exec_ctx* exec_ctx,
                                       grpc_backoff* backoff);

/// Step a retry loop: returns the deadlines to be used for the current attempt
/// and the subsequent retry, if any.
grpc_backoff_result grpc_backoff_step(grpc_exec_ctx* exec_ctx,
                                      grpc_backoff* backoff);

/// Reset the backoff, so the next grpc_backoff_step will be a
/// grpc_backoff_begin.
void grpc_backoff_reset(grpc_backoff* backoff);

#ifdef __cplusplus
}
#endif

#endif /* GRPC_CORE_LIB_BACKOFF_BACKOFF_H */


text:
import type { ErrorObject } from "../../types";
export declare enum DiscrError {
    Tag = "tag",
    Mapping = "mapping"
}
export declare type DiscrErrorObj<E extends DiscrError> = ErrorObject<"discriminator", {
    error: E;
    tag: string;
    tagValue: unknown;
}, string>;

redpajama_set_name: RedPajamaGithub


text:
using projeto_integrado_2_sem.Models;
using projeto_integrado_2_sem.Repositories;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace projeto_integrado_2_sem
{
    [Serializable]
    public class SaleStorableAdapter : IStorableAdapter<Sale>
    {
        private int autoIncrementValue = 1;

        [NonSerialized]
        public ProductRepository prodRepo;

        [NonSerialized]
        public CustomerRepository custRepo;

        public string Identifier(Sale storable)
        {
            return storable.Id;
        }

        public virtual string DefineIdentifier(Sale storable)
        {
            storable.id = autoIncrementValue.ToString().PadLeft(6, '0');
            autoIncrementValue++;
            return Identifier(storable);
        }

        public Sale FromSerializedToPublic(Sale stored)
        {
            var cloned = (Sale)stored.Clone();
            cloned.Product = prodRepo.FindById(cloned.ProductId);

            var customer = custRepo.FindById(cloned.CustomerId);

            if (customer == null)
                customer = custRepo.DeadRecordsRepo().FindById(cloned.CustomerId);

            cloned.Customer = customer;

            return cloned;
        }
    }
}


text:
package japgolly.scalajs.react.extra

import japgolly.scalajs.react._
import japgolly.scalajs.react.extra.components.TriStateCheckbox
import japgolly.scalajs.react.test.ReactTestUtils._
import japgolly.scalajs.react.test.TestUtil._
import japgolly.scalajs.react.test._
import japgolly.scalajs.react.vdom.html_<^._
import utest._

object TriStateCheckboxTest extends TestSuite {

  private object OnKeyDown {

    final class Backend($: BackendScope[Unit, Int]) {
      val onKey: ReactEvent => Callback =
        e => $.modState(_ + 1).unless_(e.defaultPrevented)
      def render(s: Int): VdomNode =
        <.div(
          s"s=$s",
          ^.onKeyDown ==> onKey,
          TriStateCheckbox.Props(TriStateCheckbox.Checked, Callback.empty).render
        )
    }

    val Component = ScalaComponent.builder[Unit]
      .initialState(0)
      .renderBackend[Backend]
      .build

    def test() = {
      withRenderedIntoBody(Component()).withParent { p =>
        assertEq(p.textContent, "s=0")
        val i = p.querySelector("input")

        SimEvent.Keyboard.Space.simulateKeyDown(i)
        assertEq(p.textContent, "s=0")

        SimEvent.Keyboard.A.simulateKeyDown(i)
        assertEq(p.textContent, "s=1")
      }
    }
  }

  override def tests = Tests {
    "onKeyDown" - OnKeyDown.test()
  }
}


text:
import pandas as pd
import numpy as np

import pyaf.ForecastEngine as autof
import pyaf.Bench.TS_datasets as tsds

import pyaf.CodeGen.TS_CodeGenerator as tscodegen

import warnings

with warnings.catch_warnings():
    warnings.simplefilter("error")

    b1 = tsds.generate_random_TS(N = 600 , FREQ = 'D', seed = 0, trendtype = "constant", cycle_length = 12, transform = "", sigma = 0.0, exog_count = 20);
    df = b1.mPastData

    # this script works on mysql with N = 600, exog_count = 20 when thread_stack = 1920K in
    # /etc/mysql/mysql.conf.d/mysqld.cnf

    #df.to_csv("outputs/rand_exogenous.csv")

    H = b1.mHorizon;

    N = df.shape[0];
    for n in range(H,  N , 10):
        df1 = df.head(n).copy();
        lEngine = autof.cForecastEngine()
        # lEngine.mOptions.mEnableSeasonals = False;
        # lEngine.mOptions.mDebugCycles = False;
        lEngine
        lExogenousData = (b1.mExogenousDataFrame , b1.mExogenousVariables)
        lEngine.train(df1 , b1.mTimeVar , b1.mSignalVar, H, lExogenousData);
        lEngine.getModelInfo();
        lEngine.standardPlots(name = "outputs/my_rand_exog_" + str(n));
        lEngine.mSignalDecomposition.mBestModel.mTimeInfo.mResolution
        lCodeGenerator = tscodegen.cTimeSeriesCodeGenerator();
        lSQL = lCodeGenerator.testGeneration(lEngine);


text:
package proton;

/**
 * DeliveryState
 *
 */

public interface DeliveryState
{

}


text: R CMD REMOVE --library=$PREFIX/lib/R/library/ mogene20stprobeset.db


text:
<!DOCTYPE html>

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

    <title>Author</title>
    <meta name="description" content="Website under construction - Check back later!" />

    <meta name="HandheldFriendly" content="True" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />

    <link rel="shortcut icon" href="/assets/images/favicon.ico" >

    <link rel="stylesheet" type="text/css" href="/assets/css/screen.css" />
    <link rel="stylesheet" type="text/css"
          href="//fonts.googleapis.com/css?family=Merriweather:300,700,700italic,300italic|Open+Sans:700,400" />
    <link rel="stylesheet" type="text/css" href="/assets/css/syntax.css" />

        <link rel="canonical" href="/" />
    <meta name="referrer" content="origin" />
    <link rel="next" href="/page2/" />

    <meta property="og:site_name" content="Website under construction" />
    <meta property="og:type" content="website" />
    <meta property="og:title" content="Website under construction" />
    <meta property="og:description" content="Check back later!" />
    <meta property="og:url" content="/" />
    <meta property="og:image" content="/assets/images/cover1.jpg" />

    <meta name="twitter:card" content="summary_large_image" />
    <meta name="twitter:title" content="Website under construction" />
    <meta name="twitter:description" content="Check back later!" />
    <meta name="twitter:url" content="/" />
    <meta name="twitter:image:src" content="/assets/images/cover1.jpg" />

    <meta name="generator" content="Jekyll 3.0.0" />
    <link rel="alternate" type="application/rss+xml" title="Website under construction" href="/rss.xml" />

Menu

        Close

Home

About

Research

Presentations

Publications

Pictures

                Menu

Andrea Nerozzi's Picture

Andrea Nerozzi

...

            Lisbon, Portugal
            anerozzi.github.io/

            1 post

     Page 1 of 1

New website

Website under construction.

Started working on the new website.

Stay tuned!
 »

            Andrea Nerozzi

            <time class="post-date" datetime="2016-01-12">12 Jan 2016</time>

     Page 1 of 1

Website under construction © 2016

Proudly published with Jekyll using Jasper


text:
import { o, OBatch } from "./o";
import { OdataConfig } from "./OdataConfig";

describe("initialize a new oHandler", () => {
  test("url with string", () => {
    // given
    const url = "http://odata.org/";

    // when
    const when = o(url);

    // expect
    expect((when.config.rootUrl as URL).href).toEqual(url);
  });

  test("url with string and root config", () => {
    // given
    const url = "http://odata.org/";
    const config = { rootUrl: "http://a/" };

    // when
    const when = o(url, config);

    // expect
    expect((when.config.rootUrl as URL).href).toEqual(url);
  });

  test("only with rootUrl config", () => {
    // given
    const url = "";
    const config = { rootUrl: "http://a/" };

    // when
    const when = o(url, config);

    // expect
    expect((when.config.rootUrl as URL).href).toEqual(config.rootUrl);
  });

  test("only with rootUrl and a given url", () => {
    // given
    const url = "foo";
    const config = { rootUrl: "http://bar/" };

    // when
    const when = o(url, config);

    // expect
    expect((when.config.rootUrl as URL).href).toEqual(`${config.rootUrl}foo`);
  });

  test("no rootUrl given and url given not a valid url (should switch to window.location.href)", () => {
    // given
    const url = "foo";

    // when
    const when = o(url);

    // expect
    expect((when.config.rootUrl as URL).href).toEqual(`http://localhost/foo`);
  });

  test("config should be default if not given", () => {
    // given
    const url = "foo";

    // when
    const when = o(url);

    // expect
    expect(when.config).toBeDefined();
    expect(when.config).toMatchSnapshot();
  });

  test("config should be extended if something given.", () => {
    // given
    const url = "foo";
    const config: Partial<OdataConfig> = {
      mode: "no-cors",
      rootUrl: "http://bar.de/foo",
    };

    // when
    const when = o(url, config);

    // expect
    expect(when.config).toBeDefined();
    expect(when.config.mode).toBe("no-cors");
    expect(when.config.referrer).toBe("client");
    expect((when.config.rootUrl as URL).href).toBe("http://bar.de/foo/foo");
  });
});

describe("Instant request", () => {
  test("Request any thing that is put in the init request", async () => {
    // when
    const data = await o(
      "https://services.odata.org/V4/TripPinServiceRW/People?$top=2"
    )
      .get()
      .query();
    // expect
    expect(data.length).toBe(2);
  });

  test("Still allow chaining and multiple requests", async () => {
    // given
    const [resource1, resource2] = ["People", "Airlines"];
    // when
    const data = await o("https://services.odata.org/V4/TripPinServiceRW/")
      .get(resource1)
      .get(resource2)
      .query({ $top: 2 });
    // expect
    expect(data.length).toBe(2);
    expect(data[0].length).toBe(2);
    expect(data[1].length).toBe(2);
  });

  test("Attach the correct queries to the request", async () => {
    // when
    const data = await o(
      "https://services.odata.org/V4/TripPinServiceRW/People?$top=2",
      {
        query: { $top: 1, $filter: `FirstName eq 'john'` },
      }
    )
      .get()
      .fetch();

    // expect
    expect(decodeURIComponent((data as Response).url)).toContain(
      "People?$top=1&$filter=FirstName+eq+'john'"
    );
  });

  test("Check right URL Params override. query-parameter in fetch()/query() wins over query-config", async () => {
    // when
    const data = await o(
      "https://services.odata.org/V4/TripPinServiceRW/People",
      {
        query: { $top: 1 },
      }
    )
      .get()
      .fetch({ $top: 2 });

    // expect
    expect(decodeURIComponent((data as Response).url)).toContain(
      "People?$top=2"
    );
  });

  test("Check right URL Params override. query-parameter in fetch()/query() wins over baseUrl", async () => {
    // when
    const data = await o(
      "https://services.odata.org/V4/TripPinServiceRW/People?$top=1"
    )
      .get()
      .fetch({ $top: 2 });

    // expect
    expect(decodeURIComponent((data as Response).url)).toContain(
      "People?$top=2"
    );
  });

  test("Check right URL Params override. query-config wins over baseUrl", async () => {
    // when
    const data = await o(
      "https://services.odata.org/V4/TripPinServiceRW/People?$top=1",
      {
        query: { $top: 2 },
      }
    )
      .get()
      .fetch();

    // expect
    expect(decodeURIComponent((data as Response).url)).toContain(
      "People?$top=2"
    );
  });
});

describe("Request handling", () => {
  let oHandler;

  beforeEach(() => {
    oHandler = o("https://services.odata.org/V4/TripPinServiceRW/");
  });

  test("Queue requests", () => {
    // given
    const resource = "People";
    // when
    oHandler.get(resource);
    // expect
    expect(oHandler.pending).toBe(1);
    // when
    oHandler.get(resource).get(resource);
    // expect
    expect(oHandler.pending).toBe(3);
  });

  test("Clean queued request after query", async () => {
    // given
    const resource = "People";
    // when
    await oHandler.get(resource).get(resource).query();
    // expect
    expect(oHandler.pending).toBe(0);
  });

  test("Clean queued request after fetch", async () => {
    // given
    const resource = "People";
    // when
    await oHandler.get(resource).get(resource).fetch();
    // expect
    expect(oHandler.pending).toBe(0);
  });

  test("Clean queued request after batch", async () => {
    // given
    const resource = "People";
    // when
    try {
      await oHandler.get(resource).get(resource).batch();
    } catch (ex) {
      // intended empty
    }
    // expect
    expect(oHandler.pending).toBe(0);
  });

  test("Attach the correct queries to the request", async () => {
    // given
    const resource = "People";
    // when
    const requests = oHandler
      .get(resource)
      .get(resource)
      .fetch({ $top: 1, $filter: `FirstName eq 'john'` });

    const req = await requests;

    // expect
    expect(decodeURIComponent(req[0].url)).toContain(
      "People?$top=1&$filter=FirstName+eq+'john'"
    );
  });

  test("On request to one resource only, don't return an array", async () => {
    // given
    const resource = "People";
    // when
    const requests = oHandler.get(resource).fetch();

    const req = await requests;

    // expect
    expect(Array.isArray(req)).toBe(false);
  });
});

describe("GET request", () => {
  let oHandler;

  beforeAll(() => {
    oHandler = o("https://services.odata.org/V4/TripPinServiceRW/");
  });

  test("Request to a resource should return an array", async () => {
    // given
    const resource = "People";
    // when
    const data = await oHandler.get(resource).query({
      $top: 4,
    });

    // expect
    expect(Array.isArray(data)).toBe(true);
    expect(data.length).toBe(4);
  });

  test("Request to one entity should return a object", async () => {
    // given
    const resource = "People('russellwhyte')";
    // when
    const data = await oHandler.get(resource).query();

    // expect
    expect(Array.isArray(data)).toBe(false);
    expect(typeof data).toBe("object");
  });

  test("Request to $top=1 should return a array", async () => {
    // given
    const resource = "People";
    // when
    const data = await oHandler.get(resource).query({ $top: 1 });

    // expect
    expect(Array.isArray(data)).toBe(true);
    expect(data.length).toBe(1);
  });

  test("Request multiple resources or entities", async () => {
    // given
    const resource1 = "People('russellwhyte')";
    const resource2 = "People";
    // when
    const data = await oHandler.get(resource1).get(resource2).query();

    // expect
    expect(Array.isArray(data)).toBe(true);
    expect(data.length).toBe(2);
    expect(Array.isArray(data[0])).toBe(false);
    expect(Array.isArray(data)).toBe(true);
  });

  test("Request a entity that cannot be found", async () => {
    // given
    const resource = "People('foo')";
    // when
    try {
      await oHandler.get(resource).query();
    } catch (res) {
      // expect
      expect(res.status).toBe(404);
    }
  });

  test("If one request fails in a query sequent, throw all", async () => {
    // given
    const resource1 = "People('russellwhyte')";
    const resource2 = "People('unknown')";
    // when
    try {
      await oHandler.get(resource1).get(resource2).query();
    } catch (res) {
      // expect
      expect(res.status).toBe(404);
    }
  });
});

describe("Create, Update and Delete request", () => {
  let oHandler;

  beforeAll(async () => {
    oHandler = o('https://services.odata.org/V4/TripPinServiceRW/(S(ojstest))/', {
      headers: { "If-match": "*", "Content-Type": "application/json" },
    });
  });

  test("POST a person and request it afterwards", async () => {
    // given
    const resource = "People";
    const data = {
      FirstName: "Foo",
      LastName: "Bar",
      UserName: "barfoo" + Math.random(),
    };

    // when
    const response = await oHandler
      .post(resource, data)
      .get(`${resource}('${data.UserName}')`)
      .query();

    // expect
    expect(Array.isArray(response)).toBe(true);
    expect(Array.isArray(response[0])).toBe(false);
    expect(Array.isArray(response[1])).toBe(false);
    expect(response[0].FirstName).toBe(data.FirstName);
    expect(response[1].LastName).toBe(data.LastName);
    expect(response[1].UserName).toBe(data.UserName);
  });

  test("POST a person and DELETE it afterwards", async () => {
    // given
    const resource = "People";
    const data = {
      FirstName: "Bar",
      LastName: "Foo",
      UserName: "foobar" + Math.random(),
    };

    // when
    const response = await oHandler
      .post(resource, data)
      .delete(`${resource}('${data.UserName}')`)
      .query();

    // expect
    expect(Array.isArray(response)).toBe(true);
    expect(Array.isArray(response[0])).toBe(false);
    expect(Array.isArray(response[1])).toBe(false);
    expect(response[0].FirstName).toBe(data.FirstName);
    expect(response[0].LastName).toBe(data.LastName);
    expect(response[0].UserName).toBe(data.UserName);
    expect(response[1].status).toBe(204);
  });

  test("POST a person and PATCH it afterwards", async () => {
    // given
    const resource = "People";
    const data = {
      FirstName: "Bar",
      LastName: "Foo",
      UserName: "foobar" + Math.random(),
    };

    // when
    const response = await oHandler
      .post(resource, data)
      .patch(`${resource}('${data.UserName}')`, { FirstName: data.LastName })
      .get(`${resource}('${data.UserName}')`)
      .query();

    // expect
    expect(Array.isArray(response)).toBe(true);
    expect(Array.isArray(response[0])).toBe(false);
    expect(Array.isArray(response[1])).toBe(false);
    expect(response[0].FirstName).toBe(data.FirstName);
    expect(response[0].LastName).toBe(data.LastName);
    expect(response[1].status).toBe(204);
    expect(response[2].FirstName).toBe(data.LastName);
  });
});

describe("Batching", () => {
  let oHandler;

  beforeAll(async () => {
    // Use the non restier service as it has CORS enabled
    const response: Response = (await o(
      "https://services.odata.org/V4/TripPinServiceRW/"
    )
      .get()
      .fetch()) as Response;

    oHandler = o(response.url, {
      headers: { "If-match": "*", "Content-Type": "application/json" },
    });
  });

  test("Batch multiple GET requests", async () => {
    // given
    const [resource1, resource2] = ["People", "Airlines"];
    // when
    const data = await oHandler.get(resource1).get(resource2).batch();
    // expect
    expect(data.length).toBe(2);
    expect(data[0].body.length).toBeDefined();
  });

  test("Batch multiple GET requests and allow to add a query", async () => {
    // given
    const [resource1, resource2] = ["People", "Airlines"];
    // when
    const data = await oHandler
      .get(resource1)
      .get(resource2)
      .batch({ $top: 2 });
    // expect
    expect(data[0].body.length).toBe(2);
  });

  test("Batch multiple GET requests and patch something", async () => {
    // given
    const [resource1, resource2] = ["People", "Airlines('AA')"];
    // when
    const data = await oHandler
      .get(resource1)
      .patch(resource2, { Name: "New" })
      .get(resource2)
      .batch();
    // expect
    expect(data.length).toBe(3);
    expect(data[1].status).toBe(204);
    expect(data[2].body.Name).toBe("New");
  });

  test("Batch POST and PATCH with useChangeset=true", async () => {
    oHandler.config.batch.useChangset = true;

    // given
    const [resource1, resource2] = ["People", "Airlines('AA')"];
    const resouce1data = {
      FirstName: "Bar",
      LastName: "Foo is cool",
      UserName: "foobar" + Math.random(),
    };
    // when
    const request = oHandler
      .post(resource1, resouce1data)
      .patch(resource2, { Name: "New" });
    const batch = new OBatch(request.requests, request.config, null);
    const data = await request.batch();
    // expect
    expect(data.length).toBe(2);
    expect(data[0].body.LastName).toBe(resouce1data.LastName);
    expect(data[1].status).toBe(204);
  });

  // Content ID seems to have a problem in the test implementation (or I don't get the right implementation)
  // tested with postman and I always get Resource not found for the segment '$1'
  xtest("add something and directly patch it with Content-Id", async () => {
    // given
    oHandler.config.batch.useChangeset = true;
    const resource = "People";
    const data = {
      FirstName: "Bar",
      LastName: "Foo",
      UserName: "foobar" + Math.random(),
    };
    // when
    const result = await oHandler
      .post(resource, data)
      .patch("$1", { LastName: "Bar" })
      .get(`${resource}('${data.UserName}')`)
      .batch();
    // expect
    expect(result.length).toBe(3);
    expect(result[1].status).toBe(204);
    expect(result[2].body.LastName).toBe("Bar");
  });
});


text:
package org.ryt.dao.api.travel;

import org.ryt.common.config.datasource.TargetDataSource;
import org.ryt.entity.api.travel.DomesticAirport;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 ** 国内航线
 ** @ClassName: IDomesticAirportDao
 ** @Description: TODO
 ** @author CC
 ** @date 2017年7月13日 - 下午1:41:28
 */
@TargetDataSource("travel")
public interface IDomesticAirportDao extends JpaRepository<DomesticAirport, Long> {

}


text:
/*
 *   This file is part of SGEA - Sistema de Gestão de Eventos Acadêmicos - TADS IFNMG Campus Januária.
 *
 *   SGEA 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 of the License, or
 *   (at your option) any later version.
 *
 *   SGEA 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.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with SGEA.  If not, see <http://www.gnu.org/licenses/>.
 */

package br.edu.ifnmg.RetornoPagSeguro.DataAccess;

import br.edu.ifnmg.GerenciamentoEventos.DomainModel.PagSeguroPerfil;
import br.edu.ifnmg.GerenciamentoEventos.DomainModel.Servicos.PagSeguroPerfilRepositorio;
import java.util.List;

/**
 *
 * @author petronio
 */
public class PagSeguroPerfilDAO
    extends DAO<PagSeguroPerfil>
    implements PagSeguroPerfilRepositorio {

    public PagSeguroPerfilDAO(){
        super(PagSeguroPerfil.class);
    }

    @Override
    public List<PagSeguroPerfil> Buscar(PagSeguroPerfil filtro) {
       return Buscar();

    }

}


text:
package org.gradle.internal.deprecation;

import org.gradle.api.logging.configuration.WarningMode;
import org.gradle.internal.Factory;
import org.gradle.internal.featurelifecycle.LoggingDeprecatedFeatureHandler;
import org.gradle.internal.featurelifecycle.UsageLocationReporter;
import org.gradle.internal.operations.BuildOperationProgressEventEmitter;

import javax.annotation.CheckReturnValue;
import javax.annotation.Nullable;
import javax.annotation.concurrent.ThreadSafe;

/**
 * Provides entry points for constructing and emitting deprecation messages.
 * The basic deprecation message structure is "Summary. DeprecationTimeline. Context. Advice. Documentation."
 *
 * The deprecateX methods in this class return a builder that guides creation of the deprecation message.
 * Summary is populated by the deprecateX methods in this class.
 * Context can be added in free text using {@link DeprecationMessageBuilder#withContext(String)}.
 * Advice is constructed contextually using {@link DeprecationMessageBuilder.WithReplacement#replaceWith(Object)} methods based on the thing being deprecated. Alternatively, it can be populated using {@link DeprecationMessageBuilder#withAdvice(String)}.
 * DeprecationTimeline is mandatory and is added using one of:
 * - ${@link DeprecationMessageBuilder#willBeRemovedInGradle8()}
 * - ${@link DeprecationMessageBuilder#willBecomeAnErrorInGradle8()}
 * After DeprecationTimeline is set, Documentation reference must be added using one of:
 * - {@link DeprecationMessageBuilder.WithDeprecationTimeline#withUpgradeGuideSection(int, String)}
 * - {@link DeprecationMessageBuilder.WithDeprecationTimeline#withDslReference(Class, String)}
 * - {@link DeprecationMessageBuilder.WithDeprecationTimeline#withUserManual(String, String)}
 *
 * In order for the deprecation message to be emitted, terminal operation {@link DeprecationMessageBuilder.WithDocumentation#nagUser()} has to be called after one of the documentation providing methods.
 */
@ThreadSafe
public class DeprecationLogger {

    private static final ThreadLocal<Boolean> ENABLED = new ThreadLocal<Boolean>() {
        @Override
        protected Boolean initialValue() {
            return true;
        }
    };

    private static final LoggingDeprecatedFeatureHandler DEPRECATED_FEATURE_HANDLER = new LoggingDeprecatedFeatureHandler();

    public synchronized static void init(UsageLocationReporter reporter, WarningMode warningMode, BuildOperationProgressEventEmitter buildOperationProgressEventEmitter) {
        DEPRECATED_FEATURE_HANDLER.init(reporter, warningMode, buildOperationProgressEventEmitter);
    }

    public synchronized static void reset() {
        DEPRECATED_FEATURE_HANDLER.reset();
    }

    public synchronized static void reportSuppressedDeprecations() {
        DEPRECATED_FEATURE_HANDLER.reportSuppressedDeprecations();
    }

    @Nullable
    public static Throwable getDeprecationFailure() {
        return DEPRECATED_FEATURE_HANDLER.getDeprecationFailure();
    }

    /**
     * This is a rather generic deprecation entry point - consider using a more specific deprecation method and only resort to this one if there is no fit.
     *
     * Output: ${feature} has been deprecated.
     */
    @CheckReturnValue
    @SuppressWarnings("rawtypes")
    public static DeprecationMessageBuilder<?> deprecate(final String feature) {
        return new DeprecationMessageBuilder() {
            @Override
            DeprecationMessage build() {
                setSummary(xHasBeenDeprecated(feature));
                return super.build();
            }
        };
    }

    /**
     * Indirect usage means that stack trace at the time the deprecation is logged does not indicate the call site.
     * This directs GE to not display unhelpful stacktraces with the deprecation.
     *
     * Output: ${feature} has been deprecated.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder<?> deprecateIndirectUsage(String feature) {
        DeprecationMessageBuilder<?> builder = deprecate(feature);
        builder.setIndirectUsage();
        return builder;
    }

    /**
     * Output: ${feature} has been deprecated.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder<?> deprecateBuildInvocationFeature(String feature) {
        DeprecationMessageBuilder<?> builder = deprecate(feature);
        builder.setBuildInvocationUsage();
        return builder;
    }

    /**
     * Output: ${behaviour}.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder.DeprecateBehaviour deprecateBehaviour(String behaviour) {
        return new DeprecationMessageBuilder.DeprecateBehaviour(behaviour);
    }

    /**
     * Output: ${behaviour} ${advice}
     */
    @CheckReturnValue
    @SuppressWarnings("rawtypes")
    public static DeprecationMessageBuilder.WithDeprecationTimeline warnOfChangedBehaviour(final String behaviour, final String advice) {
        return new DeprecationMessageBuilder.WithDeprecationTimeline(new DeprecationMessageBuilder() {
            @Override
            DeprecationMessage build() {
                return new DeprecationMessage(behaviour, "", advice, null, Documentation.NO_DOCUMENTATION, DeprecatedFeatureUsage.Type.USER_CODE_INDIRECT);
            }
        });
    }

    /**
     * Output: ${action} has been deprecated.
     */
    @CheckReturnValue
    @SuppressWarnings("rawtypes")
    public static DeprecationMessageBuilder<?> deprecateAction(final String action) {
        return new DeprecationMessageBuilder() {
            @Override
            DeprecationMessage build() {
                setSummary(xHasBeenDeprecated(action));
                return super.build();
            }
        };
    }

    /**
     * Output: The ${property} property has been deprecated.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder.DeprecateProperty deprecateProperty(Class<?> propertyClass, String property) {
        return new DeprecationMessageBuilder.DeprecateProperty(propertyClass, property);
    }

    /**
     * Output: The ${property} system property has been deprecated.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder.DeprecateSystemProperty deprecateSystemProperty(String systemProperty) {
        return new DeprecationMessageBuilder.DeprecateSystemProperty(systemProperty);
    }

    /**
     * Output: The ${parameter} named parameter has been deprecated.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder.DeprecateNamedParameter deprecateNamedParameter(String parameter) {
        return new DeprecationMessageBuilder.DeprecateNamedParameter(parameter);
    }

    /**
     * Output: The ${method} method has been deprecated.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder.DeprecateMethod deprecateMethod(Class<?> methodClass, String methodWithParams) {
        return new DeprecationMessageBuilder.DeprecateMethod(methodClass, methodWithParams);
    }

    /**
     * Output: Using method ${invocation} has been deprecated.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder.DeprecateInvocation deprecateInvocation(String methodWithParams) {
        return new DeprecationMessageBuilder.DeprecateInvocation(methodWithParams);
    }

    /**
     * Output: The ${task} task has been deprecated.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder.DeprecateTask deprecateTask(String task) {
        return new DeprecationMessageBuilder.DeprecateTask(task);
    }

    /**
     * Output: The task type ${task.getCanonicalName()} (used by the ${task.getPath()} task) has been deprecated.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder.DeprecateTaskType deprecateTaskType(Class<?> task, String path) {
        return new DeprecationMessageBuilder.DeprecateTaskType(task.getCanonicalName(), path);
    }

    /**
     * Output: The ${plugin} plugin has been deprecated.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder.DeprecatePlugin deprecatePlugin(String plugin) {
        return new DeprecationMessageBuilder.DeprecatePlugin(plugin);
    }

    /**
     * Output: Internal API ${api} has been deprecated.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder.DeprecateInternalApi deprecateInternalApi(String api) {
        return new DeprecationMessageBuilder.DeprecateInternalApi(api);
    }

    /**
     * Output: The ${configurationType} configuration has been deprecated for ${declarationType}.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder.ConfigurationDeprecationTypeSelector deprecateConfiguration(String configurationType) {
        return new DeprecationMessageBuilder.ConfigurationDeprecationTypeSelector(configurationType);
    }

    static void nagUserWith(DeprecationMessageBuilder<?> deprecationMessageBuilder, Class<?> calledFrom) {
        if (isEnabled()) {
            DeprecationMessage deprecationMessage = deprecationMessageBuilder.build();
            nagUserWith(deprecationMessage.toDeprecatedFeatureUsage(calledFrom));
        }
    }

    @Nullable
    public static <T> T whileDisabled(Factory<T> factory) {
        ENABLED.set(false);
        try {
            return factory.create();
        } finally {
            ENABLED.set(true);
        }
    }

    public static void whileDisabled(Runnable action) {
        ENABLED.set(false);
        try {
            action.run();
        } finally {
            ENABLED.set(true);
        }
    }

    private static boolean isEnabled() {
        return ENABLED.get();
    }

    private synchronized static void nagUserWith(DeprecatedFeatureUsage usage) {
        DEPRECATED_FEATURE_HANDLER.featureUsed(usage);
    }

    private static String xHasBeenDeprecated(String x) {
        return String.format("%s has been deprecated.", x);
    }

}


text:
import grp
import os
import pwd
import subprocess
import sys

import githubutil as U

downloadbeta = 'N'
if len(sys.argv) == 2:
	downloadbeta = sys.argv[1]
# Set up directories

if os.getegid() != 0:
	# Not running as root
	print("Must run as root")
	exit(999)

print("*** Setupconsole ***")
piuid = pwd.getpwnam('pi')[2]
pigrp = grp.getgrnam('pi')[2]
for pdir in ('Console', 'consolestable', 'consolebeta', 'consolerem', 'consoledev', 'Console/cfglib'):
	# noinspection PyBroadException
	try:
		os.mkdir(pdir)
		print("Created: " + str(pdir))
	except:
		print("Already present: " + str(pdir))
	os.chown(pdir, piuid, pigrp)

if os.path.exists('homesystem'):
	# personal system
	U.StageVersion('consolestable', 'homerelease', 'Initial Install')
	print("Stage homerelease as stable")
else:
	U.StageVersion('consolestable', 'currentrelease', 'Initial Install')
	print("Stage standard stable release")
U.InstallStagedVersion('consolestable')
print("Installed staged stable")

if downloadbeta == 'Y':
	U.StageVersion('consolebeta', 'currentbeta', 'Initial Install')
	print('Stage beta also')
	U.InstallStagedVersion('consolebeta')
	print('Intalled staged beta')

if os.path.exists('homesystem'):
	os.mkdir('consolecur')
	os.chown('consolecur', piuid, pigrp)

subprocess.call("cp -r /home/pi/consolestable/'example configs'/* /home/pi/Console", shell=True)


text:
require_relative 'extensions/aggregate_target_extensions'
require_relative 'extensions/analyzer_extensions'


text:
using UnityEngine;

public class ActionController : MonoBehaviour
{
    private Animator animator;

    private void Start()
    {
        animator = GetComponent<Animator>();
    }

    private void Update()
    {
        FireState(Input.GetKey(KeyCode.J));
        StabState(Input.GetKey(KeyCode.L));
    }

    public void FireState(bool state)
    {
        animator.SetBool("fire", state);
    }

    public void StabState(bool state)
    {
        animator.SetBool("stab", state);
    }

    #region Animation Events

    public void Fire(string bulletPath)
    {
        GameObject origin = transform.Find(bulletPath).gameObject;
        GameObject bullet = GameObject.Instantiate(origin) as GameObject;
        bullet.SetActive(true);
        float dir = Mathf.Sign(transform.localScale.x);
        bullet.transform.position = origin.transform.position;
        bullet.rigidbody2D.AddForce(new Vector2(dir * 10, 0), ForceMode2D.Impulse);
        rigidbody2D.AddForce(new Vector2(-transform.localScale.x * 3, 0), ForceMode2D.Impulse);
    }

    #endregion
}


text:
#pragma once
#include <aws/greengrassv2/GreengrassV2_EXPORTS.h>
#include <aws/greengrassv2/GreengrassV2Request.h>
#include <aws/core/utils/Array.h>
#include <aws/greengrassv2/model/LambdaFunctionRecipeSource.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>
#include <aws/core/utils/UUID.h>

namespace Aws
{
namespace GreengrassV2
{
namespace Model
{

  /**
   */
  class AWS_GREENGRASSV2_API CreateComponentVersionRequest : public GreengrassV2Request
  {
  public:
    CreateComponentVersionRequest();

    // Service request name is the Operation name which will send this request out,
    // each operation should has unique request name, so that we can get operation's name from this request.
    // Note: this is not true for response, multiple operations may have the same response name,
    // so we can not get operation's name from response.
    inline virtual const char* GetServiceRequestName() const override { return "CreateComponentVersion"; }

    Aws::String SerializePayload() const override;

    /**
     *
The recipe to use to create the component. The recipe defines the component's
     * metadata, parameters, dependencies, lifecycle, artifacts, and platform
     * compatibility.

You must specify either inlineRecipe or
     * lambdaFunction.

     */
    inline const Aws::Utils::ByteBuffer& GetInlineRecipe() const{ return m_inlineRecipe; }

    /**
     *
The recipe to use to create the component. The recipe defines the component's
     * metadata, parameters, dependencies, lifecycle, artifacts, and platform
     * compatibility.

You must specify either inlineRecipe or
     * lambdaFunction.

     */
    inline bool InlineRecipeHasBeenSet() const { return m_inlineRecipeHasBeenSet; }

    /**
     *
The recipe to use to create the component. The recipe defines the component's
     * metadata, parameters, dependencies, lifecycle, artifacts, and platform
     * compatibility.

You must specify either inlineRecipe or
     * lambdaFunction.

     */
    inline void SetInlineRecipe(const Aws::Utils::ByteBuffer& value) { m_inlineRecipeHasBeenSet = true; m_inlineRecipe = value; }

    /**
     *
The recipe to use to create the component. The recipe defines the component's
     * metadata, parameters, dependencies, lifecycle, artifacts, and platform
     * compatibility.

You must specify either inlineRecipe or
     * lambdaFunction.

     */
    inline void SetInlineRecipe(Aws::Utils::ByteBuffer&& value) { m_inlineRecipeHasBeenSet = true; m_inlineRecipe = std::move(value); }

    /**
     *
The recipe to use to create the component. The recipe defines the component's
     * metadata, parameters, dependencies, lifecycle, artifacts, and platform
     * compatibility.

You must specify either inlineRecipe or
     * lambdaFunction.

     */
    inline CreateComponentVersionRequest& WithInlineRecipe(const Aws::Utils::ByteBuffer& value) { SetInlineRecipe(value); return *this;}

    /**
     *
The recipe to use to create the component. The recipe defines the component's
     * metadata, parameters, dependencies, lifecycle, artifacts, and platform
     * compatibility.

You must specify either inlineRecipe or
     * lambdaFunction.

     */
    inline CreateComponentVersionRequest& WithInlineRecipe(Aws::Utils::ByteBuffer&& value) { SetInlineRecipe(std::move(value)); return *this;}

    /**
     *
The parameters to create a component from a Lambda function.

You must
     * specify either inlineRecipe or lambdaFunction.

     */
    inline const LambdaFunctionRecipeSource& GetLambdaFunction() const{ return m_lambdaFunction; }

    /**
     *
The parameters to create a component from a Lambda function.

You must
     * specify either inlineRecipe or lambdaFunction.

     */
    inline bool LambdaFunctionHasBeenSet() const { return m_lambdaFunctionHasBeenSet; }

    /**
     *
The parameters to create a component from a Lambda function.

You must
     * specify either inlineRecipe or lambdaFunction.

     */
    inline void SetLambdaFunction(const LambdaFunctionRecipeSource& value) { m_lambdaFunctionHasBeenSet = true; m_lambdaFunction = value; }

    /**
     *
The parameters to create a component from a Lambda function.

You must
     * specify either inlineRecipe or lambdaFunction.

     */
    inline void SetLambdaFunction(LambdaFunctionRecipeSource&& value) { m_lambdaFunctionHasBeenSet = true; m_lambdaFunction = std::move(value); }

    /**
     *
The parameters to create a component from a Lambda function.

You must
     * specify either inlineRecipe or lambdaFunction.

     */
    inline CreateComponentVersionRequest& WithLambdaFunction(const LambdaFunctionRecipeSource& value) { SetLambdaFunction(value); return *this;}

    /**
     *
The parameters to create a component from a Lambda function.

You must
     * specify either inlineRecipe or lambdaFunction.

     */
    inline CreateComponentVersionRequest& WithLambdaFunction(LambdaFunctionRecipeSource&& value) { SetLambdaFunction(std::move(value)); return *this;}

    /**
     *
A list of key-value pairs that contain metadata for the resource. For more
     * information, see Tag
     * your resources in the IoT Greengrass V2 Developer Guide.

     */
    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }

    /**
     *
A list of key-value pairs that contain metadata for the resource. For more
     * information, see Tag
     * your resources in the IoT Greengrass V2 Developer Guide.

     */
    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }

    /**
     *
A list of key-value pairs that contain metadata for the resource. For more
     * information, see Tag
     * your resources in the IoT Greengrass V2 Developer Guide.

     */
    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }

    /**
     *
A list of key-value pairs that contain metadata for the resource. For more
     * information, see Tag
     * your resources in the IoT Greengrass V2 Developer Guide.

     */
    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }

    /**
     *
A list of key-value pairs that contain metadata for the resource. For more
     * information, see Tag
     * your resources in the IoT Greengrass V2 Developer Guide.

     */
    inline CreateComponentVersionRequest& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}

    /**
     *
A list of key-value pairs that contain metadata for the resource. For more
     * information, see Tag
     * your resources in the IoT Greengrass V2 Developer Guide.

     */
    inline CreateComponentVersionRequest& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}

    /**
     *
A list of key-value pairs that contain metadata for the resource. For more
     * information, see Tag
     * your resources in the IoT Greengrass V2 Developer Guide.

     */
    inline CreateComponentVersionRequest& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }

    /**
     *
A list of key-value pairs that contain metadata for the resource. For more
     * information, see Tag
     * your resources in the IoT Greengrass V2 Developer Guide.

     */
    inline CreateComponentVersionRequest& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }

    /**
     *
A list of key-value pairs that contain metadata for the resource. For more
     * information, see Tag
     * your resources in the IoT Greengrass V2 Developer Guide.

     */
    inline CreateComponentVersionRequest& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }

    /**
     *
A list of key-value pairs that contain metadata for the resource. For more
     * information, see Tag
     * your resources in the IoT Greengrass V2 Developer Guide.

     */
    inline CreateComponentVersionRequest& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }

    /**
     *
A list of key-value pairs that contain metadata for the resource. For more
     * information, see Tag
     * your resources in the IoT Greengrass V2 Developer Guide.

     */
    inline CreateComponentVersionRequest& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }

    /**
     *
A list of key-value pairs that contain metadata for the resource. For more
     * information, see Tag
     * your resources in the IoT Greengrass V2 Developer Guide.

     */
    inline CreateComponentVersionRequest& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }

    /**
     *
A list of key-value pairs that contain metadata for the resource. For more
     * information, see Tag
     * your resources in the IoT Greengrass V2 Developer Guide.

     */
    inline CreateComponentVersionRequest& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }

    /**
     *
A unique, case-sensitive identifier that you can provide to ensure that the
     * request is idempotent. Idempotency means that the request is successfully
     * processed only once, even if you send the request multiple times. When a request
     * succeeds, and you specify the same client token for subsequent successful
     * requests, the IoT Greengrass V2 service returns the successful response that it
     * caches from the previous request. IoT Greengrass V2 caches successful responses
     * for idempotent requests for up to 8 hours.

     */
    inline const Aws::String& GetClientToken() const{ return m_clientToken; }

    /**
     *
A unique, case-sensitive identifier that you can provide to ensure that the
     * request is idempotent. Idempotency means that the request is successfully
     * processed only once, even if you send the request multiple times. When a request
     * succeeds, and you specify the same client token for subsequent successful
     * requests, the IoT Greengrass V2 service returns the successful response that it
     * caches from the previous request. IoT Greengrass V2 caches successful responses
     * for idempotent requests for up to 8 hours.

     */
    inline bool ClientTokenHasBeenSet() const { return m_clientTokenHasBeenSet; }

    /**
     *
A unique, case-sensitive identifier that you can provide to ensure that the
     * request is idempotent. Idempotency means that the request is successfully
     * processed only once, even if you send the request multiple times. When a request
     * succeeds, and you specify the same client token for subsequent successful
     * requests, the IoT Greengrass V2 service returns the successful response that it
     * caches from the previous request. IoT Greengrass V2 caches successful responses
     * for idempotent requests for up to 8 hours.

     */
    inline void SetClientToken(const Aws::String& value) { m_clientTokenHasBeenSet = true; m_clientToken = value; }

    /**
     *
A unique, case-sensitive identifier that you can provide to ensure that the
     * request is idempotent. Idempotency means that the request is successfully
     * processed only once, even if you send the request multiple times. When a request
     * succeeds, and you specify the same client token for subsequent successful
     * requests, the IoT Greengrass V2 service returns the successful response that it
     * caches from the previous request. IoT Greengrass V2 caches successful responses
     * for idempotent requests for up to 8 hours.

     */
    inline void SetClientToken(Aws::String&& value) { m_clientTokenHasBeenSet = true; m_clientToken = std::move(value); }

    /**
     *
A unique, case-sensitive identifier that you can provide to ensure that the
     * request is idempotent. Idempotency means that the request is successfully
     * processed only once, even if you send the request multiple times. When a request
     * succeeds, and you specify the same client token for subsequent successful
     * requests, the IoT Greengrass V2 service returns the successful response that it
     * caches from the previous request. IoT Greengrass V2 caches successful responses
     * for idempotent requests for up to 8 hours.

     */
    inline void SetClientToken(const char* value) { m_clientTokenHasBeenSet = true; m_clientToken.assign(value); }

    /**
     *
A unique, case-sensitive identifier that you can provide to ensure that the
     * request is idempotent. Idempotency means that the request is successfully
     * processed only once, even if you send the request multiple times. When a request
     * succeeds, and you specify the same client token for subsequent successful
     * requests, the IoT Greengrass V2 service returns the successful response that it
     * caches from the previous request. IoT Greengrass V2 caches successful responses
     * for idempotent requests for up to 8 hours.

     */
    inline CreateComponentVersionRequest& WithClientToken(const Aws::String& value) { SetClientToken(value); return *this;}

    /**
     *
A unique, case-sensitive identifier that you can provide to ensure that the
     * request is idempotent. Idempotency means that the request is successfully
     * processed only once, even if you send the request multiple times. When a request
     * succeeds, and you specify the same client token for subsequent successful
     * requests, the IoT Greengrass V2 service returns the successful response that it
     * caches from the previous request. IoT Greengrass V2 caches successful responses
     * for idempotent requests for up to 8 hours.

     */
    inline CreateComponentVersionRequest& WithClientToken(Aws::String&& value) { SetClientToken(std::move(value)); return *this;}

    /**
     *
A unique, case-sensitive identifier that you can provide to ensure that the
     * request is idempotent. Idempotency means that the request is successfully
     * processed only once, even if you send the request multiple times. When a request
     * succeeds, and you specify the same client token for subsequent successful
     * requests, the IoT Greengrass V2 service returns the successful response that it
     * caches from the previous request. IoT Greengrass V2 caches successful responses
     * for idempotent requests for up to 8 hours.

     */
    inline CreateComponentVersionRequest& WithClientToken(const char* value) { SetClientToken(value); return *this;}

  private:

    Aws::Utils::ByteBuffer m_inlineRecipe;
    bool m_inlineRecipeHasBeenSet;

    LambdaFunctionRecipeSource m_lambdaFunction;
    bool m_lambdaFunctionHasBeenSet;

    Aws::Map<Aws::String, Aws::String> m_tags;
    bool m_tagsHasBeenSet;

    Aws::String m_clientToken;
    bool m_clientTokenHasBeenSet;
  };

} // namespace Model
} // namespace GreengrassV2
} // namespace Aws


text:
package com.youzu.clan.base.json.checkpost;

import com.youzu.clan.base.json.model.Variables;

public class CheckPostVariables extends Variables {
	 private Allowperm allowperm;

	public Allowperm getAllowperm() {
		return allowperm;
	}

	public void setAllowperm(Allowperm allowperm) {
		this.allowperm = allowperm;
	}
}


text:
package de.otto.edison.jobs.repository.cleanup;

import de.otto.edison.jobs.service.JobService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;

public class StopDeadJobs implements JobCleanupStrategy {

    private static final Logger LOG = LoggerFactory.getLogger(StopDeadJobs.class);
    private static final long STOP_DEAD_JOBS_CLEANUP_INTERVAL = 1L * 60L * 1000L;

    private final int stopJobAfterSeconds;
    private final JobService jobService;

    public StopDeadJobs(final JobService jobService, final int stopJobAfterSeconds) {
        this.jobService = jobService;
        this.stopJobAfterSeconds = stopJobAfterSeconds;
        LOG.info("Mark old as stopped after '{}' seconds of inactivity", stopJobAfterSeconds);
    }

    @Override
    @Scheduled(fixedRate = STOP_DEAD_JOBS_CLEANUP_INTERVAL)
    public void doCleanUp() {
        jobService.killJobsDeadSince(stopJobAfterSeconds);
    }
}


text:
An app to boost the scope of your music by Gautier Delorme

/!\ this is a TEST project to discover the Multipeer Connectivity on iOS.


text:
import {dataJoin, isTransition} from '@d3fc/d3fc-data-join';
import {line as lineShape} from 'd3-shape';
import {select} from 'd3-selection';
import {rebind, exclude, rebindAll} from '@d3fc/d3fc-rebind';
import xyBase from '../xyBase';
import colors from '../colors';

export default () => {
    const base = xyBase();

    const lineData = lineShape()
        .x((d, i) => base.values(d, i).transposedX)
        .y((d, i) => base.values(d, i).transposedY);

    const join = dataJoin('path', 'line');

    const line = (selection) => {

        if (isTransition(selection)) {
            join.transition(selection);
        }

        lineData.defined(base.defined());

        selection.each((data, index, group) => {
            const path = join(select(group[index]), [data]);

            path.enter()
              .attr('fill', 'none')
              .attr('stroke', colors.black);

            path.attr('d', lineData);

            base.decorate()(path, data, index);
        });
    };

    rebindAll(line, base, exclude('baseValue', 'bandwidth', 'align'));
    rebind(line, join, 'key');
    rebind(line, lineData, 'curve');

    return line;
};


text:
package xyz.kandrac.kappka.utils;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

/**
 * Created by jan on 9.2.2017.
 */

public final class DateUtils {

    public static final long DAY_SPAN_MILIS = 24 * 60 * 60 * 1000;

    private DateUtils() {

    }

    public static final DateFormat TIME_FORMAT = SimpleDateFormat.getTimeInstance(DateFormat.SHORT, Locale.getDefault());
    public static final DateFormat DATE_FORMAT = SimpleDateFormat.getDateInstance(DateFormat.DEFAULT, Locale.getDefault());
    public static final DateFormat DATE_FORMAT_2 = new SimpleDateFormat("dd.MM.", Locale.getDefault());

    public static String getDateFormatted(long dateMilis) {
        return DATE_FORMAT.format(new Date(dateMilis));
    }

    public static String getCurrentDateFormatted() {
        return DATE_FORMAT.format(getCurrentDateMilis());
    }

    public static String getDateTimeFormatted(long time) {
        return DATE_FORMAT_2.format(time) + " " + getTimeFormatted(time);
    }

    private static String getTimeFormatted(long time) {
        return TIME_FORMAT.format(time);
    }

    public static long getCurrentDateMilis() {
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(System.currentTimeMillis());
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTimeInMillis();
    }

    public static long decrementDate(long time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(time);
        calendar.add(Calendar.DAY_OF_YEAR, -1);
        return calendar.getTimeInMillis();
    }

    public static long incrementDate(long time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(time);
        calendar.add(Calendar.DAY_OF_YEAR, 1);
        return calendar.getTimeInMillis();
    }
}


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

namespace XamarinMarathon.model
{
    public class Auth
    {
        public String UserName { get; set; }

        public int UserID { get; set; }

        public String UserFirstName { get; set; }

        public String UserLastName { get; set; }

        public String UserWorkPhone { get; set; }

        public String UserMobile { get; set; }

        public String UserDhiaID { get; set; }

        public String UserOwnerID { get; set; }

        public String UserSalesRepID { get; set; }

        public String UserSalesmanID { get; set; }

        public int UserSexcessID { get; set; }

        public String UserModule { get; set; }

        public String UserPercAllocation { get; set; }

        public String UserLanguage { get; set; }

        public int UserSexcessLocationId { get; set; }

        public String UserIndustryType { get; set; }

        public String UserRole { get; set; }

        public String SilosYour { get; set; }

        public String SilosOther { get; set; }

        public String HomeRead { get; set; }

        public int HomeLevel { get; set; }

        public String userPassword { get; set; }
    }
}


text:
Rails.application.routes.draw do
  root 'sessions#home'

  get '/account/new', to: 'users#new', as: 'new_account'
  post '/account/new', to: 'users#create'
  get '/account/settings', to: 'users#show', as: 'account_settings'
  get '/account/edit', to: 'users#edit', as: 'edit_account'
  patch '/account/edit', to: 'users#update'
  delete '/account', to: 'users#delete', as: 'delete_account'

  # get '/browse', to: 'profiles#index', as: 'sitters'
  # post '/profiles', to: 'profiles#create'
  # get '/profiles/:id/edit', to: 'profiles'
  resources :profiles#, except: ['index']

  get '/login', to: 'sessions#new', as: 'login'
  post '/login', to: 'sessions#create'
  delete '/logout', to: 'sessions#destroy', as: 'logout'
  # The priority is based upon order of creation: first created -> highest priority.
  # See how all your routes lay out with "rake routes".

  # You can have the root of your site routed with "root"
  # root 'welcome#index'

  # Example of regular route:
  #   get 'products/:id' => 'catalog#view'

  # Example of named route that can be invoked with purchase_url(id: product.id)
  #   get 'products/:id/purchase' => 'catalog#purchase', as: :purchase

  # Example resource route (maps HTTP verbs to controller actions automatically):
  #   resources :products

  # Example resource route with options:
  #   resources :products do
  #     member do
  #       get 'short'
  #       post 'toggle'
  #     end
  #
  #     collection do
  #       get 'sold'
  #     end
  #   end

  # Example resource route with sub-resources:
  #   resources :products do
  #     resources :comments, :sales
  #     resource :seller
  #   end

  # Example resource route with more complex sub-resources:
  #   resources :products do
  #     resources :comments
  #     resources :sales do
  #       get 'recent', on: :collection
  #     end
  #   end

  # Example resource route with concerns:
  #   concern :toggleable do
  #     post 'toggle'
  #   end
  #   resources :posts, concerns: :toggleable
  #   resources :photos, concerns: :toggleable

  # Example resource route within a namespace:
  #   namespace :admin do
  #     # Directs /admin/products/* to Admin::ProductsController
  #     # (app/controllers/admin/products_controller.rb)
  #     resources :products
  #   end
end


text:
package com.liferay.docs.guestbook.service.http;

import com.liferay.docs.guestbook.service.GuestbookServiceUtil;

import com.liferay.portal.kernel.log.Log;
import com.liferay.portal.kernel.log.LogFactoryUtil;

import java.rmi.RemoteException;

/**
 * Provides the SOAP utility for the
 * {@link com.liferay.docs.guestbook.service.GuestbookServiceUtil} service utility. The
 * static methods of this class calls the same methods of the service utility.
 * However, the signatures are different because it is difficult for SOAP to
 * support certain types.
 *
 *

 * ServiceBuilder follows certain rules in translating the methods. For example,
 * if the method in the service utility returns a {@link java.util.List}, that
 * is translated to an array of {@link com.liferay.docs.guestbook.model.GuestbookSoap}.
 * If the method in the service utility returns a
 * {@link com.liferay.docs.guestbook.model.Guestbook}, that is translated to a
 * {@link com.liferay.docs.guestbook.model.GuestbookSoap}. Methods that SOAP cannot
 * safely wire are skipped.
 *

 *
 *

 * The benefits of using the SOAP utility is that it is cross platform
 * compatible. SOAP allows different languages like Java, .NET, C++, PHP, and
 * even Perl, to call the generated services. One drawback of SOAP is that it is
 * slow because it needs to serialize all calls into a text format (XML).
 *

 *
 *

 * You can see a list of services at http://localhost:8080/api/axis. Set the
 * property axis.servlet.hosts.allowed in portal.properties to configure
 * security.
 *

 *
 *

 * The SOAP utility is only generated for remote services.
 *

 *
 * @author Rich Sezov
 * @see GuestbookServiceHttp
 * @see com.liferay.docs.guestbook.model.GuestbookSoap
 * @see com.liferay.docs.guestbook.service.GuestbookServiceUtil
 * @generated
 */
public class GuestbookServiceSoap {
	public static com.liferay.docs.guestbook.model.GuestbookSoap addGuestbook(
		long userId, java.lang.String name,
		com.liferay.portal.service.ServiceContext serviceContext)
		throws RemoteException {
		try {
			com.liferay.docs.guestbook.model.Guestbook returnValue = GuestbookServiceUtil.addGuestbook(userId,
					name, serviceContext);

			return com.liferay.docs.guestbook.model.GuestbookSoap.toSoapModel(returnValue);
		}
		catch (Exception e) {
			_log.error(e, e);

			throw new RemoteException(e.getMessage());
		}
	}

	public static com.liferay.docs.guestbook.model.GuestbookSoap deleteGuestbook(
		long guestbookId,
		com.liferay.portal.service.ServiceContext serviceContext)
		throws RemoteException {
		try {
			com.liferay.docs.guestbook.model.Guestbook returnValue = GuestbookServiceUtil.deleteGuestbook(guestbookId,
					serviceContext);

			return com.liferay.docs.guestbook.model.GuestbookSoap.toSoapModel(returnValue);
		}
		catch (Exception e) {
			_log.error(e, e);

			throw new RemoteException(e.getMessage());
		}
	}

	public static com.liferay.docs.guestbook.model.GuestbookSoap[] getGuestbooks(
		long groupId) throws RemoteException {
		try {
			java.util.List<com.liferay.docs.guestbook.model.Guestbook> returnValue =
				GuestbookServiceUtil.getGuestbooks(groupId);

			return com.liferay.docs.guestbook.model.GuestbookSoap.toSoapModels(returnValue);
		}
		catch (Exception e) {
			_log.error(e, e);

			throw new RemoteException(e.getMessage());
		}
	}

	public static com.liferay.docs.guestbook.model.GuestbookSoap[] getGuestbooks(
		long groupId, int start, int end) throws RemoteException {
		try {
			java.util.List<com.liferay.docs.guestbook.model.Guestbook> returnValue =
				GuestbookServiceUtil.getGuestbooks(groupId, start, end);

			return com.liferay.docs.guestbook.model.GuestbookSoap.toSoapModels(returnValue);
		}
		catch (Exception e) {
			_log.error(e, e);

			throw new RemoteException(e.getMessage());
		}
	}

	public static com.liferay.docs.guestbook.model.GuestbookSoap getGuestbookByG_N(
		long groupId, java.lang.String name,
		com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
		throws RemoteException {
		try {
			com.liferay.docs.guestbook.model.Guestbook returnValue = GuestbookServiceUtil.getGuestbookByG_N(groupId,
					name, orderByComparator);

			return com.liferay.docs.guestbook.model.GuestbookSoap.toSoapModel(returnValue);
		}
		catch (Exception e) {
			_log.error(e, e);

			throw new RemoteException(e.getMessage());
		}
	}

	public static int getGuestbooksCount(long groupId)
		throws RemoteException {
		try {
			int returnValue = GuestbookServiceUtil.getGuestbooksCount(groupId);

			return returnValue;
		}
		catch (Exception e) {
			_log.error(e, e);

			throw new RemoteException(e.getMessage());
		}
	}

	public static com.liferay.docs.guestbook.model.GuestbookSoap updateGuestbook(
		long userId, long guestbookId, java.lang.String name,
		com.liferay.portal.service.ServiceContext serviceContext)
		throws RemoteException {
		try {
			com.liferay.docs.guestbook.model.Guestbook returnValue = GuestbookServiceUtil.updateGuestbook(userId,
					guestbookId, name, serviceContext);

			return com.liferay.docs.guestbook.model.GuestbookSoap.toSoapModel(returnValue);
		}
		catch (Exception e) {
			_log.error(e, e);

			throw new RemoteException(e.getMessage());
		}
	}

	private static Log _log = LogFactoryUtil.getLog(GuestbookServiceSoap.class);
}


text:
package org.apache.ignite.igfs.mapreduce;

import java.util.List;
import org.apache.ignite.compute.ComputeJobResult;

/**
 * Convenient {@link IgfsTask} adapter with empty reduce step. Use this adapter in case you are not interested in
 * results returned by jobs.
 */
public abstract class IgfsTaskNoReduceAdapter<T, R> extends IgfsTask<T, R> {
    /** */
    private static final long serialVersionUID = 0L;

    /**
     * Default implementation which will ignore all results sent from execution nodes.
     *
     * @param results Received results of broadcasted remote executions. Note that if task class has
     *      {@link org.apache.ignite.compute.ComputeTaskNoResultCache} annotation, then this list will be empty.
     * @return Will always return {@code null}.
     */
    @Override public R reduce(List<ComputeJobResult> results) {
        return null;
    }
}


text:
import { Directive, Input, OnInit } from '@angular/core';
import { ThemeVariables, lyl, StyleRenderer, toBoolean } from '@alyle/ui';

const STYLES = (theme: ThemeVariables) => lyl `{
  display: block
  background-color: ${theme.divider}
  height: 1px
}`;

@Directive({
  selector: 'ly-divider',
  providers: [
    StyleRenderer
  ]
})
export class LyDivider implements OnInit {
  static readonly и = 'LyDivider';
  private _inset: boolean;

  /** Add indentation (72px) */
  @Input()
  set inset(val: boolean) {
    const newVal = this._inset = toBoolean(val);
    if (newVal) {
      this[0x1] = this.sRenderer.add(
        `${LyDivider.и}--inset`,
        ({before}) => lyl `{
          margin-${before}: 74px
        }`,
        this[0x1]
      );
    } else {
      this.sRenderer.removeClass(this[0x1]);
    }
  }
  get inset() {
    return this._inset;
  }
  [0x1]: string;

  constructor(
    readonly sRenderer: StyleRenderer
  ) { }

  ngOnInit() {
    this.sRenderer.add(STYLES);
  }
}


text:
#include "neko_elf.h"

static value elf_update_section_header_for_bytecode(value _file, value _interp_size, value _bytecode_size)
{
/* This function is a no-op on non-ELF platforms... */
#ifdef SEPARATE_SECTION_FOR_BYTECODE

	FILE *exe;
        int interp_size, bytecode_size;
	char buf[size_Shdr], *file;
	int bytecode_sec_idx;

	val_check(_file,string);
	val_check(_interp_size,int);
	val_check(_bytecode_size,int);
	file = val_string(_file);
	interp_size = val_int(_interp_size);
	bytecode_size = val_int(_bytecode_size);

	if ( interp_size%4 != 0 ) {
		return val_false;
	}

	/* Open the file to update the elf nekobytecode section
	   header... */
	exe = fopen(file,"r+b");
	if( exe == NULL )
		return val_false;

	/* First read the elf header... */
	if ( val_true != elf_read_header(exe) ) goto failed;

	/* Find the right section header... */
	bytecode_sec_idx = elf_find_bytecode_section(exe);
	if ( -1 == bytecode_sec_idx ) goto failed;

	/* Now that we have the right section header, update it... */
	if ( val_true != elf_read_section(exe,bytecode_sec_idx,buf) ) goto failed;

	elf_set_Shdr(buf,sh_type,SHT_PROGBITS);
	elf_set_Shdr(buf,sh_flags,elf_get_Shdr(buf,sh_flags) & (SHF_MASKOS|SHF_MASKPROC));
	elf_set_Shdr(buf,sh_addr,0);
	elf_set_Shdr(buf,sh_offset,interp_size);
	elf_set_Shdr(buf,sh_size,bytecode_size);
	elf_set_Shdr(buf,sh_addralign,1);
	elf_set_Shdr(buf,sh_entsize,0);

	/* ...and write it back... */
	if ( val_true != elf_write_section(exe,bytecode_sec_idx,buf) ) goto failed;

        elf_free_section_string_table();
	fclose(exe);
	return val_true;

failed:
        elf_free_section_string_table();
	fclose(exe);
	return val_false;
#else
	return val_true;
#endif
}

DEFINE_PRIM(elf_update_section_header_for_bytecode,3);


text:
<?php

namespace NetSuite\Classes;

class WorkOrderItem {
    public $line;
    public $item;
    public $operationSequenceNumber;
    public $componentYield;
    public $bomQuantity;
    public $quantityCommitted;
    public $quantityBackOrdered;
    public $quantityAvailable;
    public $averageCost;
    public $lastPurchasePrice;
    public $quantityOnHand;
    public $quantity;
    public $units;
    public $inventoryDetail;
    public $serialNumbers;
    public $orderPriority;
    public $options;
    public $itemSource;
    public $department;
    public $class;
    public $location;
    public $poVendor;
    public $poRate;
    public $percentComplete;
    public $contribution;
    public $description;
    public $commitInventory;
    public $plannedIssueDate;
    public $customFieldList;
    static $paramtypesmap = array(
        "line" => "integer",
        "item" => "RecordRef",
        "operationSequenceNumber" => "integer",
        "componentYield" => "float",
        "bomQuantity" => "float",
        "quantityCommitted" => "float",
        "quantityBackOrdered" => "float",
        "quantityAvailable" => "float",
        "averageCost" => "float",
        "lastPurchasePrice" => "float",
        "quantityOnHand" => "float",
        "quantity" => "float",
        "units" => "RecordRef",
        "inventoryDetail" => "InventoryDetail",
        "serialNumbers" => "string",
        "orderPriority" => "float",
        "options" => "CustomFieldList",
        "itemSource" => "ItemSource",
        "department" => "RecordRef",
        "class" => "RecordRef",
        "location" => "RecordRef",
        "poVendor" => "RecordRef",
        "poRate" => "float",
        "percentComplete" => "float",
        "contribution" => "float",
        "description" => "string",
        "commitInventory" => "WorkOrderItemItemCommitInventory",
        "plannedIssueDate" => "dateTime",
        "customFieldList" => "CustomFieldList",
    );
}


text:
/* global describe, it, require */
'use strict';

// MODULES //

var // Expectation library:
	chai = require( 'chai' ),

	// Deep close to:
	deepCloseTo = require( './utils/deepcloseto.js' ),

	// Module to be tested:
	variance = require( './../lib/array.js' );

// VARIABLES //

var expect = chai.expect,
	assert = chai.assert;

// TESTS //

describe( 'array variance', function tests() {

	it( 'should export a function', function test() {
		expect( variance ).to.be.a( 'function' );
	});

	it( 'should compute the distribution variance', function test() {
		var v, actual, expected;

		v = [ 2, 4, 8, 16 ];
		actual = new Array( v.length );

		actual = variance( actual, v );
		expected = [ Infinity, 2, 8/6, 16/14 ];

		assert.isTrue( deepCloseTo( actual, expected, 1e-5 ) );
	});

	it( 'should return an empty array if provided an empty array', function test() {
		assert.deepEqual( variance( [], [] ), [] );
	});

	it( 'should handle non-numeric values by setting the element to NaN', function test() {
		var data, actual, expected;

		data = [ true, null, [], {} ];
		actual = new Array( data.length );
		actual = variance( actual, data );

		expected = [ NaN, NaN, NaN, NaN ];

		assert.deepEqual( actual, expected );
	});

});


text:
import re

def filter_handler(x=None):
    if x.__class__.__name__ == "NoneType":
        return None
    else:
        # lowercase bools
        for k, v in x.items():
            if v.__class__ == bool:
                x[k] = str(v).lower()

        # combine
        nn = x.keys()
        if any([i in others for i in nn]):
            out = []
            for i in nn:
                if i in others:
                    out.append(switch_filters(i))
                else:
                    out.append(i)
            nn = out

        newnn = [re.sub("_", "-", z) for z in nn]
        newnnd = dict(zip(x.keys(), newnn))
        x = rename_keys(x, newnnd)

        # split any lists into duplicated key/filter names
        newx = []
        for k, v in x.items():
            if v.__class__ == list:
                for a, b in enumerate(v):
                    newx.append(":".join([k, b]))
            else:
                newx.append(":".join([k, v]))

        newx = ",".join(newx)
        return newx

others = [
    "license_url",
    "license_version",
    "license_delay",
    "full_text_version",
    "full_text_type",
    "full_text_application",
    "award_number",
    "award_funder",
]

dict_filts = {
    "license_url": "license.url",
    "license_version": "license.version",
    "license_delay": "license.delay",
    "full_text_version": "full-text.version",
    "full_text_type": "full-text.type",
    "award_number": "award.number",
    "award_funder": "award.funder",
    "relation_type": "relation.type",
    "relation_object": "relation.object",
    "relation_object_type": "relation.object-type",
}

def switch_filters(x):
    return switch(x, dict_filts)

def switch(x, dict):
    return dict[x]

# https://github.com/healthsites/healthsites/blob/3b10b12f004bfa783ee3121647ff9856836717f3/django_project/api/utils.py
def rename_keys(old_dict, transform):
    new_dict = {}
    for k, v in old_dict.items():
        if k in transform:
            new_dict.update({transform[k]: v})
        else:
            new_dict.update({k: v})
    return new_dict


text:
import cases from './index';

describe('pascalCase()', () => {
  it.each`
    method            | output
    ${'upperCase'}    | ${'QuickBrownFoxFromTown'}
    ${'lowerCase'}    | ${'QuickBrownFoxFromTown'}
    ${'titleCase'}    | ${'QuickBrownFoxFromTown'}
    ${'sentenceCase'} | ${'QuickBrownFoxFromTown'}
    ${'camelCase'}    | ${'QuickBrownFoxFromTown'}
    ${'pascalCase'}   | ${'QuickBrownFoxFromTown'}
    ${'constantCase'} | ${'QuickBrownFoxFromTown'}
    ${'paramCase'}    | ${'QuickBrownFoxFromTown'}
    ${'snakeCase'}    | ${'QuickBrownFoxFromTown'}
    ${'dotCase'}      | ${'QuickBrownFoxFromTown'}
    ${'toggleCase'}   | ${'QuickBrownFoxFromTown'}
    ${'noAccents'}    | ${'QuickBrownFoxFromTown'}
    ${'noCase'}       | ${'QuickBrownFoxFromTown'}
  `('converts from $method —— $output', ({method, output}) => {
    const input = cases[method]('quick brown fox from town');
    expect(cases.pascalCase(input)).toBe(output);
  });
});


text:
package com.udemy.api.dtos;

import java.util.Optional;

import org.hibernate.validator.constraints.Email;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.NotEmpty;

public class FuncionarioDto {

	private Long id;
	private String nome;
	private String email;
	private Optional<String> senha = Optional.empty();
	private Optional<String> valorHora = Optional.empty();
	private Optional<String> qtdHorasTrabalhoDia = Optional.empty();
	private Optional<String> qtdHorasAlmoco = Optional.empty();

	public FuncionarioDto() {
	}

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	@NotEmpty(message = "Nome não pode ser vazio.")
	@Length(min = 3, max = 200, message = "Nome deve conter entre 3 e 200 caracteres.")
	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}

	@NotEmpty(message = "Email não pode ser vazio.")
	@Length(min = 5, max = 200, message = "Email deve conter entre 5 e 200 caracteres.")
	@Email(message="Email inválido.")
	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public Optional<String> getSenha() {
		return senha;
	}

	public void setSenha(Optional<String> senha) {
		this.senha = senha;
	}

	public Optional<String> getValorHora() {
		return valorHora;
	}

	public void setValorHora(Optional<String> valorHora) {
		this.valorHora = valorHora;
	}

	public Optional<String> getQtdHorasTrabalhoDia() {
		return qtdHorasTrabalhoDia;
	}

	public void setQtdHorasTrabalhoDia(Optional<String> qtdHorasTrabalhoDia) {
		this.qtdHorasTrabalhoDia = qtdHorasTrabalhoDia;
	}

	public Optional<String> getQtdHorasAlmoco() {
		return qtdHorasAlmoco;
	}

	public void setQtdHorasAlmoco(Optional<String> qtdHorasAlmoco) {
		this.qtdHorasAlmoco = qtdHorasAlmoco;
	}

	@Override
	public String toString() {
		return "FuncionarioDto [id=" + id + ", nome=" + nome + ", email=" + email + ", senha=" + senha + ", valorHora="
				+ valorHora + ", qtdHorasTrabalhoDia=" + qtdHorasTrabalhoDia + ", qtdHorasAlmoco=" + qtdHorasAlmoco
				+ "]";
	}

}


text:
from testtools import matchers

from keystoneclient.auth import token_endpoint
from keystoneclient import session
from keystoneclient.tests.unit import utils

class TokenEndpointTest(utils.TestCase):

    TEST_TOKEN = 'aToken'
    TEST_URL = 'http://server/prefix'

    def test_basic_case(self):
        self.requests_mock.get(self.TEST_URL, text='body')

        a = token_endpoint.Token(self.TEST_URL, self.TEST_TOKEN)
        s = session.Session(auth=a)

        data = s.get(self.TEST_URL, authenticated=True)

        self.assertEqual(data.text, 'body')
        self.assertRequestHeaderEqual('X-Auth-Token', self.TEST_TOKEN)

    def test_basic_endpoint_case(self):
        self.stub_url('GET', ['p'], text='body')
        a = token_endpoint.Token(self.TEST_URL, self.TEST_TOKEN)
        s = session.Session(auth=a)

        data = s.get('/p',
                     authenticated=True,
                     endpoint_filter={'service': 'identity'})

        self.assertEqual(self.TEST_URL, a.get_endpoint(s))
        self.assertEqual('body', data.text)
        self.assertRequestHeaderEqual('X-Auth-Token', self.TEST_TOKEN)

    def test_token_endpoint_options(self):
        opt_names = [opt.name for opt in token_endpoint.Token.get_options()]

        self.assertThat(opt_names, matchers.HasLength(2))

        self.assertIn('token', opt_names)
        self.assertIn('endpoint', opt_names)

    def test_token_endpoint_user_id(self):
        a = token_endpoint.Token(self.TEST_URL, self.TEST_TOKEN)
        s = session.Session()

        # we can't know this information about this sort of plugin
        self.assertIsNone(a.get_user_id(s))
        self.assertIsNone(a.get_project_id(s))


text:
package cn.hemw.miniui;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SuppressWarnings({"rawtypes", "unchecked"})
public class TreeUtil {

    public static ArrayList ToTree(List table, String childrenField, String idField, String parentIdField)
    {
    	ArrayList tree = new ArrayList();

        Map hash = new HashMap();
        for (int i = 0, l = table.size(); i < l; i++)
        {
            Map t = (Map)table.get(i);
            hash.put(t.get(idField), t);
        }

        for (int i = 0, l = table.size(); i < l; i++)
        {
            Map t = (Map)table.get(i);
            Object parentID = t.get(parentIdField);
            if (parentID == null || parentID.toString().equals("-1"))
            {
                tree.add(t);
                continue;
            }
            Map parent = (Map)hash.get(parentID);
            if (parent == null)
            {
                tree.add(t);
                continue;
            }
            List children = (List)parent.get(childrenField);
            if (children == null)
            {
                children = new ArrayList();
                parent.put(childrenField, children);
            }
            children.add(t);
        }

        SyncTreeNodes(tree, 1, "", childrenField);

        return tree;
    }
    private static void SyncTreeNodes(ArrayList nodes, int outlineLevel, String outlineNumber, String childrenField)
    {
        for (int i = 0, l = nodes.size(); i < l; i++)
        {
            HashMap node = (HashMap)nodes.get(i);

            node.put("OutlineLevel", outlineLevel);
            node.put("OutlineNumber", outlineNumber + (i + 1));

            ArrayList childNodes = (ArrayList)node.get(childrenField);

            if (childNodes != null && childNodes.size() > 0)
            {
                SyncTreeNodes(childNodes, outlineLevel + 1, node.get("OutlineNumber").toString() + ".",  childrenField);
            }
        }
    }

    public static ArrayList ToList(List tree, String parentId, String childrenField, String idField, String parentIdField)
    {
    	ArrayList list = new ArrayList();
        for (int i = 0, len = tree.size(); i < len; i++)
        {
            Map task = (Map)tree.get(i);

            task.put(parentIdField, parentId);
            list.add(task);

            List children = (List)task.get(childrenField);

            if (children != null && children.size() > 0)
            {
            	String id = task.get(idField) == null ?"" : task.get(idField).toString();
                List list2 = ToList(children, id, childrenField, idField, parentIdField);
                list.addAll(list2);
            }
            //task.remove(childrenField);
        }
        return list;
    }
}


text:
using System;
using System.Drawing;

namespace RayTracer
{
    class RenderEventArgs : EventArgs
    {
        private Image image;

        public Image Image
        {
            get { return image; }
        }

        private double renderTime;

        public double RenderTime
        {
            get { return renderTime; }
        }

        public RenderEventArgs(Image image, double renderTime)
        {
            this.image = image;
            this.renderTime = renderTime;
        }
    }
}


text:
function __processArg(obj, key) {
    var arg = null;
    if (obj) {
        arg = obj[key] || null;
        delete obj[key];
    }
    return arg;
}

function Controller() {
    require("alloy/controllers/BaseController").apply(this, Array.prototype.slice.call(arguments));
    this.__controllerPath = "item_gallery";
    if (arguments[0]) {
        __processArg(arguments[0], "__parentSymbol");
        __processArg(arguments[0], "$model");
        __processArg(arguments[0], "__itemTemplate");
    }
    var $ = this;
    var exports = {};
    $.__views.mainView = Ti.UI.createView({
        id: "mainView"
    });
    $.__views.mainView && $.addTopLevelView($.__views.mainView);
    $.__views.itemContainer = Ti.UI.createView({
        backgroundImage: "/images/fondo4.jpg",
        borderRadius: "5",
        opacity: "1",
        font: {
            fontSize: "20",
            fontFamily: "Arial"
        },
        id: "itemContainer"
    });
    $.__views.mainView.add($.__views.itemContainer);
    $.__views.titulo = Ti.UI.createLabel({
        id: "titulo",
        color: "#FFFFFF",
        shadowColor: "#aaa",
        text: "",
        textAlign: Ti.UI.TEXT_ALIGNMENT_CENTER
    });
    $.__views.itemContainer.add($.__views.titulo);
    exports.destroy = function() {};
    _.extend($, $.__views);
    MeteorDdp = require("meteor-ddp"), Anuncios = require("models/anuncios"), ddp = void 0;
    var args = arguments[0] || {};
    var titulo = args.titulo || "";
    $.titulo.setText(titulo);
    exports.titulo = $.titulo;
    ddp = new MeteorDdp("ws://encartelera.meteor.com/websocket");
    ddp.connect().done(function() {
        Ti.API.info("Connected!");
    });
    _.extend($, exports);
}

var Alloy = require("alloy"), Backbone = Alloy.Backbone, _ = Alloy._;

module.exports = Controller;


text:
describe("Docbase", function() {
  it("Docbase should exists globally", function() {
    expect(Docbase).not.toBeUndefined();
  });

  it("Should use config file when the parameter is a string", function() {
    Docbase.run('spec/json/docbase-sample.json');
    expect(Docbase.options['name']).toBe("testeFile");
  });

  it("Should use github as drive", function() {
    Docbase.run('spec/json/docbase-sample-github.json');
    expect(Docbase.options['name']).toBe("github");
  });

  it("Should use github as drive", function() {
    Docbase.run('spec/json/docbase-sample-generic.json');
    expect(Docbase.options['name']).toBe("generic");
  });

  it("Should throw an exception when drive is github and github.user is missing", function() {
    expect(function(){
      Docbase.run('spec/json/docbase-sample-github-without-user.json');
    }).toThrowError(/user/);
  });

  it("Should throw an exception when drive is github and github.repo is missing", function() {
    expect(function(){
      Docbase.run('spec/json/docbase-sample-github-without-repo.json');
    }).toThrowError(/repo/);
  });

  it("Should throw an exception when config file doesn't exists", function() {
    expect(function(){
      Docbase.run('spec/json/docbase-sample-nonexistent.json');
    }).toThrowError(/exists/);
  });

  it("Should throw an exception when config file is invalid", function() {
    expect(function(){
      Docbase.run('spec/json/docbase-sample-invalid-json.json');
    }).toThrowError(/invalid/);
  });

  it("Should use default config file when the parameter is empty", function() {
    Docbase.run();
    expect(Docbase.options['name']).toBe("defaultConfig");
  });

  it("Should the object as a configurations when an object is passed", function() {
    Docbase.run({
      name : 'objConfig',
      method: 'file',
      map: {
        file: 'map.json',
        path: '/'
      },
      "file" : {
        'path': 'src'
      },
      github: {
        user: 'appbaseio',
        repo: 'Docs',
        path: 'src',
        branch: 'master'
      },
      indexType: 'html',
      indexHtml: 'html/main.html',
      editGithubBtn: true,
      html5mode: false,
      flatdocHtml: 'html/flatdoc.html',
      angularAppName: 'docbaseApp'

    });
    expect(Docbase.options['name']).toBe("objConfig");
    expect(Docbase.options['github']['user']).toBe("appbaseio");
  });

});


text:
package api

import (
	"net/http"

	"github.com/gin-gonic/gin"

	"github.com/drone/drone/cache"
	"github.com/drone/drone/model"
	"github.com/drone/drone/router/middleware/session"
	"github.com/drone/drone/shared/crypto"
	"github.com/drone/drone/shared/token"
	"github.com/drone/drone/store"
)

// swagger:route GET /user user getUser
//
// Get the currently authenticated user.
//
//     Responses:
//       200: user
//
func GetSelf(c *gin.Context) {
	c.JSON(200, session.User(c))
}

// swagger:route GET /user/feed user getUserFeed
//
// Get the currently authenticated user's build feed.
//
//     Responses:
//       200: feed
//
func GetFeed(c *gin.Context) {
	repos, err := cache.GetRepos(c, session.User(c))
	if err != nil {
		c.String(500, "Error fetching repository list. %s", err)
		return
	}

	feed, err := store.GetUserFeed(c, repos)
	if err != nil {
		c.String(500, "Error fetching feed. %s", err)
		return
	}
	c.JSON(200, feed)
}

// swagger:route GET /user/repos user getUserRepos
//
// Get the currently authenticated user's active repository list.
//
//     Responses:
//       200: repos
//
func GetRepos(c *gin.Context) {
	repos, err := cache.GetRepos(c, session.User(c))
	if err != nil {
		c.String(500, "Error fetching repository list. %s", err)
		return
	}

	repos_, err := store.GetRepoListOf(c, repos)
	if err != nil {
		c.String(500, "Error fetching repository list. %s", err)
		return
	}
	c.JSON(http.StatusOK, repos_)
}

func GetRemoteRepos(c *gin.Context) {
	repos, err := cache.GetRepos(c, session.User(c))
	if err != nil {
		c.String(500, "Error fetching repository list. %s", err)
		return
	}
	c.JSON(http.StatusOK, repos)
}

func PostToken(c *gin.Context) {
	user := session.User(c)

	token := token.New(token.UserToken, user.Login)
	tokenstr, err := token.Sign(user.Hash)
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}
	c.String(http.StatusOK, tokenstr)
}

func DeleteToken(c *gin.Context) {
	user := session.User(c)
	user.Hash = crypto.Rand()
	if err := store.UpdateUser(c, user); err != nil {
		c.String(500, "Error revoking tokens. %s", err)
		return
	}

	token := token.New(token.UserToken, user.Login)
	tokenstr, err := token.Sign(user.Hash)
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}
	c.String(http.StatusOK, tokenstr)
}

// swagger:response user
type userResp struct {
	// in: body
	Body model.User
}

// swagger:response users
type usersResp struct {
	// in: body
	Body []model.User
}

// swagger:response feed
type feedResp struct {
	// in: body
	Body []model.Feed
}

// swagger:response repos
type reposResp struct {
	// in: body
	Body []model.Repo
}


text:
/*
 * ParameterValue.h
 *
 *  Created on: 17.07.2016
 *      Author: Frank
 */

#ifndef TESTPROT_PARAMETERVALUE_H_
#define TESTPROT_PARAMETERVALUE_H_

#include "Parameter.h"

#include <pugixml.hpp>
#include <string>

namespace testprot {

class ParameterValue : public Parameter {
public:
	ParameterValue();
	ParameterValue(std::string name, std::string value);
	virtual ~ParameterValue();
	std::string value{""};
	void load( pugi::xml_node node );
	virtual std::string toString();
	virtual bool isParameterValue() { return true; }
	virtual ParameterValue& asParameterValue() { return *this; }
	virtual void encodeInto( pugi::xml_node node );
};

} /* namespace testprot */

#endif /* TESTPROT_PARAMETERVALUE_H_ */


text:
class Text: public QParallelAnimationGroup{
	Q_OBJECT
private:
	QLabel *text;
	QPropertyAnimation *movement;
	QSize range;
	QPoint v;
	bool bounce;

private slots:
	void LoopChanged(){
	  movement->setStartValue(movement->endValue());
	  QPoint currLoc = movement->startValue().toPoint();
	  bounce = !(currLoc.y() < 100 or currLoc.y() > range.height()-100 or currLoc.x() > range.width()-100 or currLoc.x() < 100);
	  if((currLoc.y() < 10 or currLoc.y() > range.height()-40) and !bounce) {
	    v.setY((v.y() * -1) + (qrand() % 20 - 10));
	  }else if((currLoc.x() > range.width()-10 or currLoc.x() < 10) and !bounce) {
	    v.setX((v.x() * -1) + (qrand() % 20 - 10));
	  }
	  currLoc.setX(currLoc.x() + v.x());
	  currLoc.setY(currLoc.y() + v.y());
	  movement->setEndValue(currLoc);
	}
	void stopped(){ qDebug() << "Text Stopped"; text->hide();}

public:
	Text(QWidget *parent, QString display) : QParallelAnimationGroup(parent){
	  text = new QLabel(parent);
	  range = parent->size();
	  QPoint center = QRect( QPoint(0,0), parent->size()).center();

	  QString color = "rgba(" + QString::number(qrand() % 206 + 50) + ", " + QString::number(qrand() % 206 + 50) + ", " + QString::number(qrand() % 206 + 50);
	  text->setStyleSheet("QLabel {background-color: transparent; color: " + color + "); }");
	  text->setFont(QFont("Courier", 24, QFont::Bold));
	  text->setText(display);
          QFontMetrics metrics(text->font());
	  text->setMinimumSize(QSize( metrics.width(text->text())+10, metrics.height()*text->text().count("\n") +10));

	  movement = new QPropertyAnimation(text);
	  movement->setPropertyName("pos");
	  movement->setTargetObject(text);

	  this->addAnimation(movement);
	  text->show();
	  v.setX((qrand() % 100 + 50) * qPow(-1, qrand() % 2));
	  v.setY((qrand() % 100 + 50) * qPow(-1, qrand() % 2));
	  movement->setStartValue(center);
	  //Ensures the screensaver will not stop until the user wishes to login or it times out
	  this->setLoopCount(200); //number of wall bounces
	  movement->setDuration(200);
	  movement->setEndValue(QPoint(qrand() % (int)range.height(), qrand() % range.width()));
	  LoopChanged();  //load initial values

	  connect(this, SIGNAL(currentLoopChanged(int)), this, SLOT(LoopChanged()) );
	  connect(this, SIGNAL(finished()), this, SLOT(stopped()) );
	}
	~Text(){}

};

class TextAnimation : public BaseAnimGroup{
	Q_OBJECT
public:
	TextAnimation(QWidget *parent) : BaseAnimGroup(parent){}
	~TextAnimation(){
	  this->stop();
	}

	void LoadAnimations(){
	  canvas->setStyleSheet("background: black;");
	  //Read off the text that needs to be displayed
	  QString textToShow = readSetting("text", "").toString();
	  if(textToShow.isEmpty()){
 	    char hname[300];
            gethostname(hname, 300);
            textToShow = QString::fromLocal8Bit(hname);
	  }
	  // Now create the animation
	  Text *tmp = new Text(canvas, textToShow);
	  this->addAnimation(tmp);
	}

};
#endif


text:
require 'colorize'
require 'byebug'

require_relative "./chess/tile.rb"
require_relative "./chess/piece.rb"
require_relative "./chess/board.rb"
require_relative "./chess/pieces/bishop.rb"
require_relative "./chess/pieces/king.rb"
require_relative "./chess/pieces/knight.rb"
require_relative "./chess/pieces/pawn.rb"
require_relative "./chess/pieces/queen.rb"
require_relative "./chess/pieces/rook.rb"
require_relative "./chess/pieces/sliding_piece.rb"
require_relative "./chess/pieces/stepping_piece.rb"
require_relative "./chess/game.rb"
require_relative "./chess/player.rb"

module Chess

  WHITE_UNICODE_PIECES = {
    :K => "\u265A".encode("UTF-8"),
    :Q => "\u265B".encode("UTF-8"),
    :B => "\u265D".encode("UTF-8"),
    :R => "\u265C".encode("UTF-8"),
    :N => "\u265E".encode("UTF-8"),
    :P => "\u265F".encode("UTF-8")
  }

  BLACK_UNICODE_PIECES = {
    :K => "\u2654".encode("UTF-8"),
    :Q => "\u2655".encode("UTF-8"),
    :B => "\u2657".encode("UTF-8"),
    :R => "\u2656".encode("UTF-8"),
    :N => "\u2658".encode("UTF-8"),
    :P => "\u2659".encode("UTF-8")
  }

  class InvalidMoveError < ArgumentError
  end

end

b = Chess::Game.new
b.start(b.prompt_player)


text:
package catp

import (
	"encoding/xml"

	"github.com/fgrid/iso20022"
)

type Document00800101 struct {
	XMLName xml.Name                `xml:"urn:iso:std:iso:20022:tech:xsd:catp.008.001.01 Document"`
	Message *ATMCompletionAdviceV01 `xml:"ATMCmpltnAdvc"`
}

func (d *Document00800101) AddMessage() *ATMCompletionAdviceV01 {
	d.Message = new(ATMCompletionAdviceV01)
	return d.Message
}

// The ATMCompletionAdvice message is sent by an ATM to an acquirer or its agent to inform of the result of a transaction performed on the ATM.
type ATMCompletionAdviceV01 struct {

	// Information related to the protocol management on a segment of the path from the ATM to the acquirer.
	Header *iso20022.Header21 `xml:"Hdr"`

	// Encrypted body of the message.
	ProtectedATMCompletionAdvice *iso20022.ContentInformationType10 `xml:"PrtctdATMCmpltnAdvc,omitempty"`

	// Information related to the completion of an operation on the ATM.
	ATMCompletionAdvice *iso20022.ATMCompletionAdvice1 `xml:"ATMCmpltnAdvc,omitempty"`

	// Trailer of the message containing a MAC.
	SecurityTrailer *iso20022.ContentInformationType15 `xml:"SctyTrlr,omitempty"`
}

func (a *ATMCompletionAdviceV01) AddHeader() *iso20022.Header21 {
	a.Header = new(iso20022.Header21)
	return a.Header
}

func (a *ATMCompletionAdviceV01) AddProtectedATMCompletionAdvice() *iso20022.ContentInformationType10 {
	a.ProtectedATMCompletionAdvice = new(iso20022.ContentInformationType10)
	return a.ProtectedATMCompletionAdvice
}

func (a *ATMCompletionAdviceV01) AddATMCompletionAdvice() *iso20022.ATMCompletionAdvice1 {
	a.ATMCompletionAdvice = new(iso20022.ATMCompletionAdvice1)
	return a.ATMCompletionAdvice
}

func (a *ATMCompletionAdviceV01) AddSecurityTrailer() *iso20022.ContentInformationType15 {
	a.SecurityTrailer = new(iso20022.ContentInformationType15)
	return a.SecurityTrailer
}


text:
Version 2.0.69 by Volodymyr Volynets

	<time class="change_log_date_commit" datetime="2019-12-20">2019-12-20</time>

U/M, D/T

	Enhancement #1317 (Added credential types.)

Repository / Git:
	Name: Numbers\Users
	Title: Users Repository
	Version: 2.0.68
	Last Tag: 2.0.68
	User Name: Volodymyr Volynets
	User Email: volodymyr.volynets@gmail.com
Statistics:
	Addition: 540
	Deletion: 5
Modules:
	D/T Document Management (Numbers\Users\Documents\Base, 1.0.10)                            |    42    0
		   34    0	 | Documents/Base/Helper/Preview.php
		    8    0	 | Documents/Base/Override/ACL/Resources.php
	U/M User Management (Numbers\Users\Users, 1.0.39)                                         |   498    5
		   24    0	 | Users/Controller/Credential/Types.php
		  139    4	 | Users/Data/System.php
		   32    0	 | Users/Form/Credential/Passwords.php
		  109    0	 | Users/Form/Credential/Types.php
		   70    0	 | Users/Form/List2/Credential/Types.php
		    1    1	 | Users/Model/Credential/Password/Values.php
		    7    0	 | Users/Model/Credential/Passwords.php
		   54    0	 | Users/Model/Credential/Type/Values.php
		   60    0	 | Users/Model/Credential/Types.php
		    2    0	 | Users/module.ini


text:
#import "EventReporter_report.h"

@interface EventReporter_report()
FREObject ANE4MBG_analytics_EventReporter_report(FREContext cxt,
                                                 void* functionData,
                                                 uint32_t argc,
                                                 FREObject argv[]);
@end

@implementation EventReporter_report
+ (void)ContextInitializer:(FunctionSets *)funcSets {
    LOG_METHOD;
    [funcSets addFuncSet:@"ANE4MBG_analytics_EventReporter_report"
                 pointer:&ANE4MBG_analytics_EventReporter_report];

}

FREObject ANE4MBG_analytics_EventReporter_report(FREContext cxt,
                                                 void* functionData,
                                                 uint32_t argc,
                                                 FREObject argv[]) {
    LOG_METHOD;
    ArgsParser *parser = [ArgsParser sharedParser];
    [parser setArgc:argc argv:argv];
    NSString *eventName = [parser nextString];
    NSDictionary *payload = [parser nextDictionary];
    NSDictionary *playerState  = [parser nextDictionary];

    if (payload.count == 0) {
        payload = nil;
    }

    if (playerState.count == 0) {
        playerState = nil;
    }

    MBGGameEvent *gameEvent = [[[MBGGameEvent alloc] initWithId:eventName
                                                        payload:payload
                                                    playerState:playerState] autorelease];
    [MBGEventReporter report:gameEvent];

    return NULL;
}
@end


text:
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

using System.Collections.Immutable;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeActions;

namespace Microsoft.CodeAnalysis.Wrapping
{
    internal interface ICodeActionComputer
    {
        /// <summary>
        /// Produces the actual top-level code wrapping actions for the original node provided.
        /// </summary>
        Task<ImmutableArray<CodeAction>> GetTopLevelCodeActionsAsync();
    }
}