text:
AliAnalysisTaskCaloTrackCorrelation *AddTaskPi0IMGammaCorrQA(const TString  calorimeter   = "EMCAL",
                                                             const Bool_t   simulation    = kFALSE,
                                                             const TString  collision     = "pp",
                                                             const TString  suffix        = "default",
                                                             const Bool_t   qaan          = kTRUE,
                                                             const Bool_t   hadronan      = kTRUE,
                                                             const Bool_t   calibrate     = kFALSE,
                                                             const Int_t    minTime       = -1000,
                                                             const Int_t    maxTime       =  1000,
                                                             const Int_t    minCen        = -1,
                                                             const Int_t    maxCen        = -1,
                                                             const Int_t    debugLevel    = -1,
                                                             const Int_t    year          = 2015
                                                          )
{
  if(simulation && !suffix.Contains("default"))
  {
    printf("AddTaskPi0IMGammaCorrQA - CAREFUL : Triggered events not checked in simulation!! \n");
    return 0x0;
  }

  // Get the pointer to the existing analysis manager via the static access method.

  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr)
  {
    ::Error("AddTaskPi0IMGammaCorrQA", "No analysis manager to connect to.");
    return NULL;
  }

  // Check the analysis type using the event handlers connected to the analysis manager.

  if (!mgr->GetInputEventHandler())
  {
    ::Error("AddTaskPi0IMGammaCorrQA", "This task requires an input event handler");
    return NULL;
  }

  // Make sure the B field is enabled for track selection, some cuts need it
  ((AliInputEventHandler*)mgr->GetInputEventHandler())->SetNeedField(kTRUE);

  TString inputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"

  // Name for containers

  TString containerName = Form("%s_Trig%s",calorimeter.Data(), suffix.Data());

  if(collision!="pp" && maxCen>=0) containerName+=Form("Cen%d_%d",minCen,maxCen);

  printf("AddTaskPi0IMGammaCorrQA - Container NAME: %s \n",containerName.Data());

  // #### Configure analysis ####

  AliAnaCaloTrackCorrMaker * maker = new AliAnaCaloTrackCorrMaker();

  // General frame setting and configuration
  maker->SetReader   ( ConfigureReader   (inputDataType,collision,calibrate,minTime,maxTime,minCen,maxCen,simulation,year,debugLevel) );
  maker->SetCaloUtils( ConfigureCaloUtils(calorimeter,simulation,calibrate,year,debugLevel) );

  // Analysis tasks setting and configuration
  Int_t n = 0;//Analysis number, order is important
  Bool_t fillQACellTimeHisto = kTRUE;

  // Analysis with EMCal trigger or MB
  if ( !suffix.Contains("DCAL") )
  {
    maker->AddAnalysis(ConfigurePhotonAnalysis(calorimeter,0,collision,containerName,simulation,year     ,debugLevel), n++); // Photon cluster selection
    maker->AddAnalysis(ConfigurePi0Analysis   (calorimeter,0,collision,containerName,simulation,year,qaan,debugLevel,minCen) ,n++); // Previous photon invariant mass
    if(qaan) maker->AddAnalysis(ConfigureQAAnalysis(calorimeter,0,collision,simulation,fillQACellTimeHisto,year,debugLevel),n++);

    if(hadronan)
    {
      maker->AddAnalysis(ConfigureIsolationAnalysis("Photon",calorimeter,0,collision,containerName,simulation,year,debugLevel), n++); // isolation
      maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Photon",calorimeter,0,collision,containerName,simulation,year,debugLevel,minCen), n++); // Gamma hadron correlation
    }
  }

  // Analysis with DCal trigger or MB
  if(year > 2014 && calorimeter=="EMCAL" && !suffix.Contains("EMCAL"))
  {
    maker->AddAnalysis(ConfigurePhotonAnalysis(calorimeter,1,collision,containerName,simulation,year     ,debugLevel), n++); // Photon cluster selection
    maker->AddAnalysis(ConfigurePi0Analysis   (calorimeter,1,collision,containerName,simulation,year,qaan,debugLevel,minCen) ,n++); // Previous photon invariant mass

    if(suffix.Contains("INT") || suffix.Contains("MB") || suffix.Contains("default")) fillQACellTimeHisto = kFALSE;

    if(qaan) maker->AddAnalysis(ConfigureQAAnalysis(calorimeter,1,collision, simulation, fillQACellTimeHisto,year,debugLevel),n++);

    if(hadronan)
    {
      maker->AddAnalysis(ConfigureIsolationAnalysis("Photon",calorimeter,1,collision,containerName,simulation,year,debugLevel), n++); // isolation
      maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Photon",calorimeter,1,collision,containerName,simulation,year,debugLevel,minCen), n++); // Gamma hadron correlation
    }
  }

  if(hadronan)
  {
    maker->GetReader()->SwitchOnCTS();
    maker->AddAnalysis(ConfigureChargedAnalysis(collision,containerName,simulation,year,debugLevel), n++); // charged tracks plots
  }

  maker->SetAnaDebug(debugLevel)  ;
  maker->SwitchOnHistogramsMaker()  ;
  maker->SwitchOnAODsMaker() ;
//  maker->SwitchOffDataControlHistograms();
//  if(suffix.Contains("EMC"))
//    maker->SwitchOnDataControlHistograms();

  if(simulation)
  {
    // Calculate the cross section weights, apply them to all histograms
    // and fill xsec and trial histo. Sumw2 must be activated.
    //maker->GetReader()->GetWeightUtils()->SwitchOnMCCrossSectionCalculation();
    //maker->SwitchOnSumw2Histograms();

    // For recent productions where the cross sections and trials are not stored in separate file
    //maker->GetReader()->GetWeightUtils()->SwitchOnMCCrossSectionFromEventHeader() ;

    // Just fill cross section and trials histograms.
    maker->GetReader()->GetWeightUtils()->SwitchOnMCCrossSectionHistoFill();

    // Add control histogram with pT hard to control aplication of weights
    maker->SwitchOnPtHardHistogram();
  }

  if(debugLevel > 0) maker->Print("");

  // Create task

  TString taskName =Form("Pi0IM_GammaTrackCorr_%s",containerName.Data());

  AliAnalysisTaskCaloTrackCorrelation * task = new AliAnalysisTaskCaloTrackCorrelation (taskName);
  task->SetConfigFileName(""); //Don't configure the analysis via configuration file.
  task->SetDebugLevel(debugLevel);
  //task->SetBranches("ESD:AliESDRun.,AliESDHeader");
  //task->SetBranches("AOD:header,tracks,vertices,emcalCells,caloClusters");
  task->SetAnalysisMaker(maker);

  //
  // Select events trigger depending on suffix
  //
  if(!simulation)
  {
    if( suffix.Contains("INT") || suffix.Contains("MB") || suffix.Contains("default") )
    {
      task->SelectCollisionCandidates( AliVEvent::kINT7 | AliVEvent::kMB );
    }
    else if(suffix.Contains("EMCAL_L0"))
    {
      task ->SelectCollisionCandidates( AliVEvent::kEMC7 | AliVEvent::kEMC8 | AliVEvent::kEMC1 );
      maker->GetReader()->SetFiredTriggerClassName("EMC");
    }
    else if(suffix.Contains("DCAL_L0"))
    {
      task ->SelectCollisionCandidates( AliVEvent::kEMC7 | AliVEvent::kEMC8 | AliVEvent::kEMC1 );
      maker->GetReader()->SetFiredTriggerClassName("DMC");
    }
    else if(suffix.Contains("EMCAL_L1"))
    {
      task ->SelectCollisionCandidates( AliVEvent::kEMCEGA );
      maker->GetReader()->SetFiredTriggerClassName("EG1");
    }
    else if(suffix.Contains("DCAL_L1"))
    {
      task ->SelectCollisionCandidates( AliVEvent::kEMCEGA );
      maker->GetReader()->SetFiredTriggerClassName("DG1");
    }
    else if(suffix.Contains("EMCAL_L1_Run1"))
    {
      task ->SelectCollisionCandidates( AliVEvent::kEMCEGA );
      //maker->GetReader()->SetFiredTriggerClassName("EGA");
    }
    else if(suffix.Contains("EMCAL_L2"))
    {
      task ->SelectCollisionCandidates( AliVEvent::kEMCEGA );
      maker->GetReader()->SetFiredTriggerClassName("EG2");
    }
    else if(suffix.Contains("DCAL_L2"))
    {
      task ->SelectCollisionCandidates( AliVEvent::kEMCEGA );
      maker->GetReader()->SetFiredTriggerClassName("DG2");
    }
  }

  mgr->AddTask(task);

  //Create containers

  TString outputfile = AliAnalysisManager::GetCommonFileName();

  AliAnalysisDataContainer *cout_pc   = mgr->CreateContainer(taskName, TList::Class(),
                                                             AliAnalysisManager::kOutputContainer,
                                                             Form("%s:%s",outputfile.Data(),taskName.Data()));

  AliAnalysisDataContainer *cout_cuts = mgr->CreateContainer(Form("Param_%s",taskName.Data()), TList::Class(),
                                                             AliAnalysisManager::kParamContainer,
                                                             Form("%s_Parameters.root",taskName.Data()));

  // Create ONLY the output containers for the data produced by the task.
  // Get and connect other common input/output containers via the manager as below
  //==============================================================================
  mgr->ConnectInput  (task, 0, mgr->GetCommonInputContainer());
  mgr->ConnectOutput (task, 1, cout_pc);
  mgr->ConnectOutput (task, 2, cout_cuts);

  return task;
}

///
/// Configure the class handling the events and cluster/tracks filtering.
///
AliCaloTrackReader * ConfigureReader(TString inputDataType, TString collision, Bool_t calibrate,
                                     Int_t   minTime,       Int_t maxTime,
                                     Int_t   minCen,        Int_t maxCen,
                                     Bool_t  simulation,    Int_t year,        Int_t debugLevel)
{
  AliCaloTrackReader * reader = 0;
  if     (inputDataType=="AOD")
    reader = new AliCaloTrackAODReader();
  else if(inputDataType=="ESD")
    reader = new AliCaloTrackESDReader();
  else
    printf("AliCaloTrackReader::ConfigureReader() - Data combination not known input Data=%s\n",
           inputDataType.Data());

  reader->SetDebug(debugLevel);//10 for lots of messages

  // MC settings
  if(simulation)
  {
    if(inputDataType == "ESD")
    {
      reader->SwitchOnStack();
      reader->SwitchOffAODMCParticles();
    }
    else if(inputDataType == "AOD")
    {
      reader->SwitchOffStack();
      reader->SwitchOnAODMCParticles();
    }
  }

  //------------------------
  // Detector input filling
  //------------------------

  //Min cluster/track E
  reader->SetEMCALEMin(0.3);
  reader->SetEMCALEMax(1000);
  reader->SetPHOSEMin(0.3);
  reader->SetPHOSEMax(1000);
  reader->SetCTSPtMin(0.2);
  reader->SetCTSPtMax(1000);

  // Time cut
  reader->SwitchOffUseParametrizedTimeCut();

  if(calibrate)
  {
    reader->SwitchOnUseEMCALTimeCut() ;
    reader->SetEMCALTimeCut(minTime,maxTime);
  }

  reader->SwitchOffUseTrackTimeCut();
  reader->SetTrackTimeCut(-1e10,1e10);

  reader->SwitchOffFiducialCut();

  // Tracks
  reader->SwitchOffCTS();
  reader->SwitchOffRejectNoTrackEvents();
  reader->SwitchOffRecalculateVertexBC();
  reader->SwitchOffVertexBCEventSelection();
  reader->SwitchOffUseTrackDCACut();
  //reader->SetTrackDCACut(0,0.0105);
  //reader->SetTrackDCACut(1,0.035);
  //reader->SetTrackDCACut(2,1.1);

  if(inputDataType=="ESD")
  {
    gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/macros/CreateTrackCutsPWGJE.C");
    if(year > 2010)
    {
      //Hybrids 2011
      AliESDtrackCuts * esdTrackCuts  = CreateTrackCutsPWGJE(10001008);
      reader->SetTrackCuts(esdTrackCuts);
      AliESDtrackCuts * esdTrackCuts2 = CreateTrackCutsPWGJE(10011008);
      reader->SetTrackComplementaryCuts(esdTrackCuts2);
    }
    else
    {
      //Hybrids 2010
      AliESDtrackCuts * esdTrackCuts  = CreateTrackCutsPWGJE(10001006);
      reader->SetTrackCuts(esdTrackCuts);
      AliESDtrackCuts * esdTrackCuts2 = CreateTrackCutsPWGJE(10041006);
      reader->SetTrackComplementaryCuts(esdTrackCuts2);
    }
  }
  else if(inputDataType=="AOD")
  {
    reader->SwitchOnAODHybridTrackSelection(); // Check that the AODs have Hybrids!!!!
    reader->SetTrackStatus(AliVTrack::kITSrefit);
  }

  // Calorimeter

  reader->SetEMCALClusterListName("");

  if(calibrate && !simulation) reader->SwitchOnClusterRecalculation();
  else                         reader->SwitchOffClusterRecalculation();

  reader->SwitchOnEMCALCells();
  reader->SwitchOnEMCAL();

  reader->SwitchOnPHOSCells();
  reader->SwitchOnPHOS();

  //-----------------
  // Event selection
  //-----------------

  reader->SwitchOnEventTriggerAtSE();

  reader->SetZvertexCut(10.);
  reader->SwitchOnPrimaryVertexSelection();  // and besides primary vertex
  reader->SwitchOffPileUpEventRejection();   // remove pileup
  reader->SwitchOffV0ANDSelection() ;        // and besides v0 AND

  if(collision=="PbPb")
  {
    if(year < 2014) reader->SwitchOnAliCentrality();
    reader->SetCentralityBin(minCen,maxCen); // Accept all events, if not select range
    reader->SetCentralityOpt(100);  // 10 (c= 0-10, 10-20 ...), 20  (c= 0-5, 5-10 ...) or 100 (c= 1, 2, 3 ..)
  }

  if(debugLevel > 0) reader->Print("");

  return reader;
}

///
/// Configure the class handling the calorimeter clusters specific methods
///
AliCalorimeterUtils* ConfigureCaloUtils(TString calorimeter, Bool_t simulation, Bool_t calibrate,
                                        Int_t year, Int_t debugLevel)
{
  AliCalorimeterUtils *cu = new AliCalorimeterUtils;
  cu->SetDebug(debugLevel);

  // Remove clusters close to borders, at least max energy cell is 1 cell away
  cu->SetNumberOfCellsFromEMCALBorder(1);
  cu->SetNumberOfCellsFromPHOSBorder(2);

  // Search of local maxima in cluster
  cu->SetLocalMaximaCutE(0.1);
  cu->SetLocalMaximaCutEDiff(0.03);

  //cu->SwitchOffClusterPlot();
  cu->SwitchOffRecalculateClusterTrackMatching();

  cu->SwitchOnBadChannelsRemoval() ;

  //EMCAL settings

  if(!simulation)
    cu->SwitchOnLoadOwnEMCALGeometryMatrices();

  AliEMCALRecoUtils * recou = cu->GetEMCALRecoUtils();
  cu->SwitchOffRecalibration(); // Check the reader if it is taken into account during filtering
  cu->SwitchOffRunDepCorrection();

  cu->SwitchOffCorrectClusterLinearity();

  Bool_t bExotic  = kTRUE;
  Bool_t bNonLin  = kFALSE;
  Bool_t bBadMap  = kTRUE;

  Bool_t bEnCalib = kFALSE;
  Bool_t bTiCalib = kFALSE;

  if(calibrate && !simulation)
  {
    cu->SwitchOnRecalibration(); // Check the reader if it is taken into account during filtering
    cu->SwitchOffRunDepCorrection();
    cu->SwitchOnRecalculateClusterPosition() ;

    bEnCalib = kTRUE;
    bTiCalib = kTRUE;
  }

  gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/EMCAL/macros/ConfigureEMCALRecoUtils.C");
  ConfigureEMCALRecoUtils(recou,
                          simulation,
                          bExotic,
                          bNonLin,
                          bEnCalib,
                          bBadMap,
                          bTiCalib,
                          debugLevel
                          );
  //recou->SetExoticCellDiffTimeCut(50.);

  if(calorimeter=="PHOS")
  {
    cu->SetNumberOfSuperModulesUsed(3);
  }
  else
  {
    if      (year == 2010) cu->SetNumberOfSuperModulesUsed(4); // EMCAL first year
    else if (year <  2014) cu->SetNumberOfSuperModulesUsed(10);
    else                   cu->SetNumberOfSuperModulesUsed(20);
  }

  // PHOS
  cu->SwitchOffLoadOwnPHOSGeometryMatrices();

  if(debugLevel > 0) cu->Print("");

  return cu;
}

///
/// Configure the task doing the first photon cluster selections
/// Basically the track matching, minor shower shape cut, NLM selection ...
///
AliAnaPhoton* ConfigurePhotonAnalysis(TString calorimeter,   Bool_t caloType, TString collision,
                                      TString containerName, Bool_t simulation,
                                      Int_t year,            Int_t debugLevel)
{
  AliAnaPhoton *ana = new AliAnaPhoton();
  ana->SetDebug(debugLevel); //10 for lots of messages

  // cluster selection cuts

  ana->SwitchOnFiducialCut();
  if(caloType==0)ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.7,  80, 187) ; // EMC
  else           ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.7, 260, 327) ; // DMC
  ana->GetFiducialCut()->DoEMCALFiducialCut(kTRUE);

  ana->SetCalorimeter(calorimeter);

  if(calorimeter == "PHOS")
  {
    ana->SetNCellCut(2);// At least 3 cells
    ana->SetMinPt(0.5);
    ana->SetMinDistanceToBadChannel(2, 4, 5);
    ana->SetTimeCut(-1e10,1e10); // open cut
  }
  else
  {//EMCAL
    ana->SetNCellCut(1);// At least 2 cells
    ana->SetMinEnergy(0.3); // avoid mip peak at E = 260 MeV
    ana->SetMaxEnergy(1000);
    ana->SetTimeCut(-1e10,1e10); // open cut, usual time window of [425-825] ns if time recalibration is off
    // restrict to less than 100 ns when time calibration is on
    ana->SetMinDistanceToBadChannel(2, 4, 6);
    // Not useful if M02 cut is already strong
    ana->SetNLMCut(1, 2) ;
  }

  ana->SwitchOnTrackMatchRejection() ;
  ana->SwitchOffTMHistoFill() ;

  //PID cuts (shower shape)
  ana->SwitchOnCaloPID(); // do PID selection, unless specified in GetCaloPID, selection not based on bayesian
  AliCaloPID* caloPID = ana->GetCaloPID();
  //Not used in bayesian

  //EMCAL
  caloPID->SetEMCALLambda0CutMax(0.4); // Rather open
  caloPID->SetEMCALLambda0CutMin(0.10);

  caloPID->SetEMCALDEtaCut(0.025);
  caloPID->SetEMCALDPhiCut(0.030);

  //PHOS
  caloPID->SetPHOSDispersionCut(2.5);
  caloPID->SetPHOSRCut(2.);

  ana->SwitchOnFillShowerShapeHistograms();  // Filled before photon shower shape selection
  //if(!simulation)ana->SwitchOnFillPileUpHistograms();

  if(collision.Contains("Pb"))   ana->SwitchOnFillHighMultiplicityHistograms();

  // Input / output delta AOD settings
  ana->SetOutputAODName(Form("Photon%s_Calo%d",containerName.Data(),caloType));
  ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
  ana->SetInputAODName (Form("Photon%s_Calo%d",containerName.Data(),caloType));

  // Set Histograms name tag, bins and ranges
  ana->AddToHistogramsName(Form("AnaPhoton_Calo%d_",caloType));
  SetHistoRangeAndNBins(ana->GetHistogramRanges(),calorimeter,caloType,collision,year); // see method below

  // Number of particle type MC histograms
  ana->FillNOriginHistograms(7);
  ana->FillNPrimaryHistograms(4);

  if(simulation) ana->SwitchOnDataMC();

  if(debugLevel > 0 ) ana->Print("");

  return ana;
}

///
/// Configure the task doing the 2 cluster invariant mass analysis
///
AliAnaPi0* ConfigurePi0Analysis(TString calorimeter, Bool_t caloType, TString collision,
                                TString containerName, Bool_t simulation, Int_t year,
                                Bool_t qaan, Int_t debugLevel, Int_t minCen)
{
  AliAnaPi0 *ana = new AliAnaPi0();

  ana->SetDebug(debugLevel);//10 for lots of messages

  // Input delta AOD settings
  ana->SetInputAODName(Form("Photon%s_Calo%d",containerName.Data(),caloType));

  // Calorimeter settings
  ana->SetCalorimeter(calorimeter);

  ana->SwitchOnFiducialCut();
  if(caloType==0)ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.7,  80, 187) ; // EMC
  else           ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.7, 260, 327) ; // DMC
  ana->GetFiducialCut()->DoEMCALFiducialCut(kTRUE);

  ana->SwitchOnRealCaloAcceptance();

  // Settings for pp collision mixing
  ana->SwitchOnOwnMix(); //Off when mixing done with general mixing frame

  // Cuts
  if(calorimeter=="EMCAL") ana->SetPairTimeCut(100);

  ana->SetNPIDBits(1);
  ana->SetNAsymCuts(1); // no asymmetry cut, previous studies showed small effect.
  // In EMCAL assymetry cut prevents combination of assymetric decays which is the main source of pi0 at high E.

  if     (collision == "pp"  )
  {
    ana->SetNCentrBin(1);
    ana->SetNZvertBin(10);
    ana->SetNRPBin(1);
    ana->SetNMaxEvMix(100);
    ana->SetMinPt(0.5);
  }
  else if(collision =="PbPb")
  {
    ana->SetNCentrBin(10);
    ana->SetNZvertBin(10);
    ana->SetNRPBin(4);
    ana->SetNMaxEvMix(10);
    if(minCen >= 10) ana->SetNMaxEvMix(50);
    if(minCen >= 50) ana->SetNMaxEvMix(100);
    ana->SetMinPt(1.5);
    ana->SwitchOnFillHighMultiplicityHistograms();
  }
  else if(collision =="pPb")
  {
    ana->SetNCentrBin(1);
    ana->SetNZvertBin(10);
    ana->SetNRPBin(4);
    ana->SetNMaxEvMix(100);
    ana->SetMinPt(0.5);
    ana->SwitchOnFillHighMultiplicityHistograms();
  }

  ana->SwitchOffMultipleCutAnalysis();
  ana->SwitchOnSMCombinations();
  ana->SwitchOffFillAngleHisto();
  ana->SwitchOffFillOriginHisto();

  //Set Histograms name tag, bins and ranges

  ana->AddToHistogramsName(Form("AnaPi0_Calo%d_",caloType));
  SetHistoRangeAndNBins(ana->GetHistogramRanges(),calorimeter,caloType,collision,year); // see method below

  if(simulation) ana->SwitchOnDataMC();

  if(debugLevel > 0) ana->Print("");

  return ana;
}

///
/// Configure the task doing charged track selection
///
AliAnaChargedParticles* ConfigureChargedAnalysis(TString collision,TString containerName,
                                                 Bool_t simulation, Int_t year, Int_t debugLevel)
{
  AliAnaChargedParticles *ana = new AliAnaChargedParticles();
  ana->SetDebug(debugLevel); //10 for lots of messages

  // selection cuts

  ana->SetMinPt(0.5);
  ana->SwitchOnFiducialCut();
  ana->GetFiducialCut()->SetSimpleCTSFiducialCut(0.8, 0, 360) ; //more restrictive cut in reader and after in isolation

  ana->SwitchOffFillVertexBC0Histograms() ;
  //if(!simulation) ana->SwitchOnFillPileUpHistograms();

  // Input / output delta AOD settings

  ana->SetOutputAODName(Form("Hadron%s",containerName.Data()));
  ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
  ana->SetInputAODName(Form("Hadron%s",containerName.Data()));

  //Set Histograms name tag, bins and ranges

  ana->AddToHistogramsName("AnaHadrons_");
  SetHistoRangeAndNBins(ana->GetHistogramRanges(),"",kFALSE,collision,year); // see method below

  ana->GetHistogramRanges()->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 200) ;
  ana->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-1.5, 1.5, 300) ;

  if(debugLevel > 0) ana->Print("");

  return ana;
}

///
/// Configure the task doing the trigger particle hadron correlation
///
AliAnaParticleIsolation* ConfigureIsolationAnalysis(TString particle,  TString calorimeter, Bool_t caloType,
                                                    TString collision, TString containerName,
                                                    Bool_t simulation, Int_t year, Int_t debugLevel)
{
  AliAnaParticleIsolation *ana = new AliAnaParticleIsolation();
  ana->SetDebug(debugLevel);

  //if(collision.Contains("Pb"))   ana->SwitchOnFillHighMultiplicityHistograms();

  ana->SetMinPt(5);

  ana->SwitchOffStudyTracksInCone() ;
  ana->SwitchOffUEBandSubtractionHistoFill();

  ana->SwitchOffDecayTaggedHistoFill() ;
  ana->SwitchOnSSHistoFill();

  ana->SwitchOffLeadingOnly();
  ana->SwitchOffCheckNeutralClustersForLeading();

  ana->SwitchOffPtTrigBinHistoFill();
  ana->SwitchOffBackgroundBinHistoFill();
  ana->SwitchOffTMHistoFill();

  // MC
  ana->SwitchOffPrimariesInConeSelection();
  ana->SwitchOffPrimariesPi0DecayStudy() ;

  ana->SwitchOnRealCaloAcceptance();
  ana->SwitchOnFiducialCut();

  if(calorimeter == "EMCAL" && caloType == 0)
  {
    // Avoid borders of EMCal
    ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.60, 86, 174) ;
  }
  if(calorimeter == "EMCAL" && caloType == 1)
  {
    // Avoid borders of DCal
    ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.60, 264, 316) ;
  }

  AliCaloPID* caloPID = ana->GetCaloPID();
  caloPID->SetEMCALDEtaCut(0.025);
  caloPID->SetEMCALDPhiCut(0.030);

  ana->SwitchOffSeveralIsolation() ;
  ana->SwitchOffReIsolation();

  //
  // Do settings for main isolation cut class
  //
  AliIsolationCut * ic =  ana->GetIsolationCut();
  ic->SetDebug(debugLevel);
  ic->SetParticleTypeInCone(AliIsolationCut::kNeutralAndCharged);
  ic->SetICMethod(AliIsolationCut::kSumPtIC);
  if ( collision == "pp" || collision == "pPb" )
  {
    ic->SetPtThreshold(0.5);
    ic->SetSumPtThreshold(2.0) ;
    ic->SetConeSize(0.4);
  }
  if ( collision == "PbPb" )
  {
    ic->SetPtThreshold(3.);
    ic->SetSumPtThreshold(3.0) ;
    ic->SetConeSize(0.3);
  }

  // Input / output delta AOD settings

  ana->SetInputAODName(Form("%s%s_Calo%d",particle.Data(),containerName.Data(),caloType));
  ana->SetAODObjArrayName(Form("%sIso_%s_Calo%d",particle.Data(),containerName.Data(),caloType));

  // Set Histograms name tag, bins and ranges

  ana->AddToHistogramsName(Form("AnaIsol%s_Calo%d_",particle.Data(),caloType));
  SetHistoRangeAndNBins(ana->GetHistogramRanges(),calorimeter,caloType,collision,year); // see method below

  if(simulation) ana->SwitchOnDataMC();

  if(debugLevel > 0) ana->Print("");

  return ana;
}

///
/// Configure the task doing the trigger particle hadron correlation
///
AliAnaParticleHadronCorrelation* ConfigureHadronCorrelationAnalysis(TString particle,  TString calorimeter, Bool_t caloType,
                                                                    TString collision, TString containerName,
                                                                    Bool_t simulation, Int_t year, Int_t debugLevel, Int_t minCen)
{
  AliAnaParticleHadronCorrelation *ana = new AliAnaParticleHadronCorrelation();
  ana->SetDebug(debugLevel);

  ana->SetTriggerPtRange(5,100);
  ana->SetAssociatedPtRange(0.2,100);
  //ana->SetDeltaPhiCutRange( TMath::Pi()/2,3*TMath::Pi()/2 ); //[90 deg, 270 deg]
  ana->SetDeltaPhiCutRange  (TMath::DegToRad()*120.,TMath::DegToRad()*240.);
  ana->SetUeDeltaPhiCutRange(TMath::DegToRad()*60. ,TMath::DegToRad()*120.);
  ana->SwitchOffFillEtaGapHistograms();

  ana->SetNAssocPtBins(4);
  ana->SetAssocPtBinLimit(0, 0.5) ;
  ana->SetAssocPtBinLimit(1, 2) ;
  ana->SetAssocPtBinLimit(2, 5) ;
  ana->SetAssocPtBinLimit(3, 10) ;
  ana->SetAssocPtBinLimit(4, 20) ;

  ana->SelectIsolated(kFALSE); // do correlation with isolated photons

  //if(!simulation) ana->SwitchOnFillPileUpHistograms();

  ana->SwitchOffAbsoluteLeading(); // Select trigger leading particle of all the selected tracks
  ana->SwitchOffNearSideLeading(); // Select trigger leading particle of all the particles at +-90 degrees, default

  //ana->SwitchOnLeadHadronSelection();
  //ana->SetLeadHadronPhiCut(TMath::DegToRad()*100., TMath::DegToRad()*260.);
  //ana->SetLeadHadronPtCut(0.5, 100);

  // Mixing with own pool
  ana->SwitchOffOwnMix();

  ana->SetNZvertBin(20);
  ana->SwitchOffCorrelationVzBin() ;

  //if(collision.Contains("Pb"))   ana->SwitchOnFillHighMultiplicityHistograms();

  if(collision=="pp")
  {
    ana->SetNMaxEvMix(100);
    ana->SwitchOnTrackMultBins();
    ana->SetNTrackMultBin(10); // same as SetNCentrBin(10);
    ana->SetNRPBin(1);
  }
  else
  {
    ana->SetNMaxEvMix(10);
    if(minCen >= 10) ana->SetNMaxEvMix(50);
    if(minCen >= 50) ana->SetNMaxEvMix(100);
    ana->SwitchOffTrackMultBins(); // centrality bins
    ana->SetNCentrBin(10);
    ana->SetNRPBin(3);
  }

  // Input / output delta AOD settings

  ana->SetInputAODName(Form("%s%s_Calo%d",particle.Data(),containerName.Data(),caloType));
  ana->SetAODObjArrayName(Form("%sHadronCorr_%s_Calo%d",particle.Data(),containerName.Data(),caloType));

  ana->SwitchOffPi0TriggerDecayCorr();
  ana->SwitchOffDecayTriggerDecayCorr();
  ana->SwitchOffNeutralCorr(); // Do only correlation with TPC
  ana->SwitchOffHMPIDCorrelation();
  ana->SwitchOffFillBradHistograms();

  // Underlying event
  ana->SwitchOffSeveralUECalculation();
  ana->SetUeDeltaPhiCutRange(TMath::Pi()/3, 2*TMath::Pi()/3);

  //Set Histograms name tag, bins and ranges

  ana->AddToHistogramsName(Form("Ana%sHadronCorr_Calo%d_",particle.Data(),caloType));
  SetHistoRangeAndNBins(ana->GetHistogramRanges(),calorimeter,caloType,collision,year); // see method below

  if(simulation) ana->SwitchOnDataMC();

  if(debugLevel > 0) ana->Print("");

  return ana;
}

///
/// Configure the task doing standard calorimeter QA
///
AliAnaCalorimeterQA* ConfigureQAAnalysis(TString calorimeter, Bool_t caloType, TString collision,
                                         Bool_t simulation,   Bool_t fillCellTime,  Int_t year,    Int_t debugLevel)
{
  AliAnaCalorimeterQA *ana = new AliAnaCalorimeterQA();
  ana->SetDebug(debugLevel); //10 for lots of messages
  ana->SetCalorimeter(calorimeter);

  //printf("QA: calorimeter %s, caloType %d, collision %s, simulation %d, fillCellTime %d, year %d, debugLevel  %d\n",
  //       calorimeter.Data(),caloType,collision.Data(),simulation,fillCellTime,year,debugLevel);

  ana->SetTimeCut(-1e10,1e10); // Open time cut
  ana->SwitchOffStudyBadClusters() ;
  ana->SwitchOffFillAllTH3Histogram();
  ana->SwitchOffFillAllPositionHistogram();
  ana->SwitchOffFillAllPositionHistogram2();
  ana->SwitchOffStudyBadClusters();
  ana->SwitchOffStudyClustersAsymmetry();
  ana->SwitchOffStudyWeight();
  ana->SwitchOffFillAllPi0Histogram()  ;

  ana->SwitchOnFillAllTrackMatchingHistogram();

  if(fillCellTime)
  {
    ana->SwitchOnFillAllCellTimeHisto() ;
    ana->SwitchOnCorrelation();
  }
  else
  {
    ana->SwitchOffFillAllCellTimeHisto() ;
    ana->SwitchOffCorrelation();

  }

  ana->AddToHistogramsName(Form("QA_Calo%d_",caloType)); //Begining of histograms name
  SetHistoRangeAndNBins(ana->GetHistogramRanges(),calorimeter, caloType, collision,year); // see method below

  ana->SwitchOnFiducialCut();
  if(caloType==0)ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.7,  80, 187) ; // EMC
  else           ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.7, 260, 327) ; // DMC

  ana->GetFiducialCut()->DoEMCALFiducialCut(kTRUE);

  if(simulation) ana->SwitchOnDataMC();

  if(debugLevel > 0) ana->Print("");

  return ana;
}

///
/// Configure the selection of MC events
///
void SetHistoRangeAndNBins (AliHistogramRanges* histoRanges, TString calorimeter, Bool_t caloType,
                            TString collision,               Int_t year)
{
  histoRanges->SetHistoPtRangeAndNBins(0, 100, 200) ; // Energy and pt histograms

  if(calorimeter=="EMCAL")
  {
    if ( year == 2010 )
    {
      histoRanges->SetHistoPhiRangeAndNBins(79*TMath::DegToRad(), 121*TMath::DegToRad(), 42) ;
      histoRanges->SetHistoXRangeAndNBins(-230,90,120); // QA
      histoRanges->SetHistoYRangeAndNBins(370,450,40);  // QA
    }
    else if ( year < 2014 )
    {
      histoRanges->SetHistoPhiRangeAndNBins(78*TMath::DegToRad(), 182*TMath::DegToRad(), 108) ;
      histoRanges->SetHistoXRangeAndNBins(-460,90,200); // QA
      histoRanges->SetHistoYRangeAndNBins(100,450,100); // QA
    }
    else // Run2
    {
      if(caloType == 0) histoRanges->SetHistoPhiRangeAndNBins(78 *TMath::DegToRad(), 189*TMath::DegToRad(), 111) ;
      else              histoRanges->SetHistoPhiRangeAndNBins(258*TMath::DegToRad(), 329*TMath::DegToRad(),  71) ;
      histoRanges->SetHistoXRangeAndNBins(-460,460,230); // QA
      histoRanges->SetHistoYRangeAndNBins(-450,450,225); // QA
    }

    histoRanges->SetHistoEtaRangeAndNBins(-0.72, 0.72, 144) ;
  }
  else
  {
    histoRanges->SetHistoPhiRangeAndNBins(250*TMath::DegToRad(), 320*TMath::DegToRad(), 70) ;
    histoRanges->SetHistoEtaRangeAndNBins(-0.13, 0.13, 130) ;
  }

  histoRanges->SetHistoShowerShapeRangeAndNBins(-0.1, 2.9, 300);

  // Invariant mass histoRangeslysis
  histoRanges->SetHistoMassRangeAndNBins(0., 0.8, 160) ;
  histoRanges->SetHistoAsymmetryRangeAndNBins(0., 1. , 100) ;
  histoRanges->SetHistoOpeningAngleRangeAndNBins(0,0.7,50);

  // check if time calibration is on
  histoRanges->SetHistoTimeRangeAndNBins(-1000.,1000,500);
  //histoRanges->SetHistoTimeRangeAndNBins(-400.,400,400);
  histoRanges->SetHistoDiffTimeRangeAndNBins(-200, 200, 800);

  // track-cluster residuals
  histoRanges->SetHistoTrackResidualEtaRangeAndNBins(-0.10,0.10,200);
  histoRanges->SetHistoTrackResidualPhiRangeAndNBins(-0.10,0.10,200);
  histoRanges->SetHistodRRangeAndNBins(0.,0.10,100);//QA

  // QA, electron, charged
  histoRanges->SetHistoPOverERangeAndNBins(0,  2. ,200);
  histoRanges->SetHistodEdxRangeAndNBins  (0.,200.0,200);

  // QA
  histoRanges->SetHistoFinePtRangeAndNBins(0, 10, 200) ; // bining for fhAmpId
  histoRanges->SetHistoVertexDistRangeAndNBins(0.,500.,250);
  histoRanges->SetHistoZRangeAndNBins(-350,350,175);
  histoRanges->SetHistoRRangeAndNBins(430,460,30);
  histoRanges->SetHistoV0SignalRangeAndNBins(0,5000,250);
  histoRanges->SetHistoV0MultiplicityRangeAndNBins(0,5000,250);

  // QA, correlation
  if(collision=="PbPb")
  {
    histoRanges->SetHistoNClusterCellRangeAndNBins(0,100,100);
    histoRanges->SetHistoNClustersRangeAndNBins(0,500,50);
    histoRanges->SetHistoTrackMultiplicityRangeAndNBins(0,2000,200);
  }
  else
  {
    histoRanges->SetHistoNClusterCellRangeAndNBins(0,50,50);
    histoRanges->SetHistoNClustersRangeAndNBins(0,50,50);
    histoRanges->SetHistoTrackMultiplicityRangeAndNBins(0,200,200);
  }

  // xE, zT
  histoRanges->SetHistoRatioRangeAndNBins(0.,2.,200);
  histoRanges->SetHistoHBPRangeAndNBins  (0.,10.,200);

  // Isolation
  histoRanges->SetHistoPtInConeRangeAndNBins(0, 50 , 250);
  histoRanges->SetHistoPtSumRangeAndNBins   (0, 100, 250);

}


text:
<?php
namespace FSS\Controllers;

use FSS\Models\CountyData;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;
use Monolog\Logger;
use Illuminate\Database\Capsule\Manager;
use FSS\Utilities\Cache;
use \Exception;
use League\OAuth2\Server\AuthorizationServer;

/**
 * The controller for county_data-related actions.
 *
 * Implements the ControllerInterface.
 *
 * Borrows from addressController
 *
 * @author Marshal
 *
 *         @SWG\Resource(
 *         apiVersion="1.0",
 *         resourcePath="/countydata",
 *         description="CountyData operations",
 *         produces="['application/json']"
 *         )
 */
class CountyDataController extends AbstractController implements
    ControllerInterface
{

    // The dependencies.
    /**
     *
     * @var Logger
     */
    private $logger;

    /**
     *
     * @var Manager
     */
    private $db;

    /**
     *
     * @var Cache
     */
    private $cache;

    /**
     *
     * @var bool
     */
    private $debug;

    /**
     *
     * @var AuthorizationServer
     */
    private $authorizer;

    /**
     * The constructor that sets The dependencies and
     * enable query logging if debug mode is true in settings.php
     *
     * @param Logger $logger
     * @param Manager $db
     * @param Cache $cache
     * @param bool $debug
     * @param AuthorizationServer $authorizer
     */
    public function __construct(Logger $logger, Manager $db, Cache $cache,
        bool $debug, AuthorizationServer $authorizer)
    {
        $this->logger = $logger;
        $this->db = $db;
        $this->cache = $cache;
        $this->debug = $debug;
        $this->authorizer = $authorizer;
        if ($this->debug) {
            $this->logger->debug(
                "Enabling query log for the CountyData Controller.");
            $this->db::enableQueryLog();
        }
    }

    /**
     *
     * {@inheritdoc}
     * @see \FSS\Controllers\ControllerInterface::read() @SWG\Api(
     *      path="/countydata/{id}",
     *      @SWG\Operation(
     *      method="GET",
     *      summary="Displays a CountyData",
     *      type="CountyData",
     *      @SWG\Parameter(
     *      name="id",
     *      description="id of CountyData to fetch",
     *      paramType="path",
     *      required=true,
     *      allowMultiple=false,
     *      type="integer"
     *      ),
     *      @SWG\ResponseMessage(code=404, message="CountyData not found")
     *      )
     *      )
     */
    public function read(ServerRequestInterface $request,
        ResponseInterface $response, array $args): ResponseInterface
    {
        $id = $args['id'];
        $params = [
            'id',
            $id
        ];
        $request = $request->withAttribute('params', implode('/', $params));
        // $this->logger->info("Reading county_data with id of $id");
        $this->logger->debug("Reading county_data with id of $id");

        return $this->readAllWithFilter($request, $response, $args);
    }

    /**
     *
     * {@inheritdoc}
     * @see \FSS\Controllers\ControllerInterface::readAll() @SWG\Api(
     *      path="/countydata",
     *      @SWG\Operation(
     *      method="GET",
     *      summary="Fetch CountyData",
     *      type="CountyData"
     *      )
     *      )
     */
    public function readAll(ServerRequestInterface $request,
        ResponseInterface $response, array $args): ResponseInterface
    {
        $records = CountyData::limit(200)->get();
        $this->logger->debug("All CountyData query: ", $this->db::getQueryLog());
        // $records = County_data::all();
        return $response->withJson(
            [
                "success" => true,
                "message" => "All CountyData returned",
                "data" => $records
            ], 200, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT);
    }

    /**
     *
     * {@inheritdoc}
     * @see \FSS\Controllers\ControllerInterface::readAllWithFilter() @SWG\Api(
     *      path="/countydata/{filter}/{value}",
     *      @SWG\Operation(
     *      method="GET",
     *      summary="Displays CountyData that meet the property=value search criteria",
     *      type="CountyData",
     *      @SWG\Parameter(
     *      name="filter",
     *      description="property to search for in the related model.",
     *      paramType="path",
     *      required=true,
     *      allowMultiple=false,
     *      type="string"
     *      ),
     *      @SWG\Parameter(
     *      name="value",
     *      description="value to search for, given the property.",
     *      paramType="path",
     *      required=true,
     *      allowMultiple=false,
     *      type="object"
     *      ),
     *      @SWG\ResponseMessage(code=404, message="CountyData not found")
     *      )
     *      )
     */
    public function readAllWithFilter(ServerRequestInterface $request,
        ResponseInterface $response, array $args): ResponseInterface
    {
        // $filter = $args['filter'];
        // $value = $args['value'];
        $params = explode('/', $request->getAttribute('params'));
        $filters = [];
        $values = [];

        try {
            $this->getFilters($params, $filters, $values);

            foreach ($filters as $filter) {
                CountyData::validateColumn($filter, $this->logger, $this->cache,
                    $this->db);
            }
            $records = CountyData::whereRaw(
                'LOWER(`' . $filters[0] . '`) like ?',
                [
                    '%' . strtolower($values[0]) . '%'
                ]);
            for ($i = 1; $i < count($filters); $i ++) {
                $records = $records->whereRaw(
                    'LOWER(`' . $filters[$i] . '`) like ?',
                    [
                        '%' . strtolower($values[$i]) . '%'
                    ]);
            }
            $records = $records->limit(200)->get();

            $this->logger->debug("CountyData filter query: ",
                $this->db::getQueryLog());
            if ($records->isEmpty()) {
                return $response->withJson(
                    [
                        "success" => true,
                        "message" => "No CountyData found",
                        "data" => $records
                    ], 404);
            }
            return $response->withJson(
                [
                    "success" => true,
                    "message" => "Filtered CountyData by $filter",
                    "data" => $records
                ], 200, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT);
        } catch (Exception $e) {
            return $response->withJson(
                [
                    "success" => false,
                    "message" => "Error occured: " . $e->getMessage()
                ], 400);
        }
    }

    /**
     *
     * {@inheritdoc}
     * @see \FSS\Controllers\ControllerInterface::create() @SWG\Api(
     *      path="/countydata",
     *      @SWG\Operation(
     *      method="POST",
     *      summary="Creates a CountyData. See CountyData model for details.",
     *      type="CountyData",
     *      @SWG\ResponseMessage(code=400, message="Error occurred")
     *      )
     *      )
     */
    public function create(ServerRequestInterface $request,
        ResponseInterface $response, array $args): ResponseInterface
    {
        // Make sure the frontend only puts the name attribute
        // on form elements that actually contain data
        // for the record.
        $recordData = $request->getParsedBody();
        try {
            foreach ($recordData as $key => $val) {
                CountyData::validateColumn($key, $this->logger, $this->cache,
                    $this->db);
                $this->logger->debug("POST values: ", [
                    $key . " => " . $val
                ]);
            }
            $recordData['updated_by'] = $request->getAttribute('oauth_user_id');
            $recordId = CountyData::insertGetId($recordData);
            $this->logger->debug("CountyData create query: ",
                $this->db::getQueryLog());
            return $response->withJson(
                [
                    "success" => true,
                    "message" => "CountyData $recordId has been created.",
                    "id" => $recordId
                ], 200, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT);
        } catch (Exception $e) {
            return $response->withJson(
                [
                    "success" => false,
                    "message" => "Error occured: " . $e->getMessage()
                ], 400);
        }
    }

    /**
     *
     * {@inheritdoc}
     * @see \FSS\Controllers\ControllerInterface::update() @SWG\Api(
     *      path="/countydata/{id}",
     *      @SWG\Operation(
     *      method="PUT",
     *      summary="Updates a CountyData. See the CountyData model for details.",
     *      type="CountyData",
     *      @SWG\Parameter(
     *      name="id",
     *      description="id of CountyData to update",
     *      paramType="path",
     *      required=true,
     *      allowMultiple=false,
     *      type="integer"
     *      ),
     *      @SWG\ResponseMessage(code=400, message="Error occurred")
     *      )
     *      )
     */
    public function update(ServerRequestInterface $request,
        ResponseInterface $response, array $args): ResponseInterface
    {
        // $id = $args['id'];
        $recordData = $request->getParsedBody();
        try {
            $updateData = [];
            foreach ($recordData as $key => $val) {
                CountyData::validateColumn($key, $this->logger, $this->cache,
                    $this->db);
                $updateData = array_merge($updateData,
                    [
                        $key => $val
                    ]);
            }
            $updateData['updated_by'] = $request->getAttribute('oauth_user_id');
            $recordId = CountyData::update($updateData);
            $this->logger->debug("CountyData update query: ",
                $this->db::getQueryLog());
            return $response->withJson(
                [
                    "success" => true,
                    "message" => "Updated CountyData $recordId"
                ], 200, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT);
        } catch (Exception $e) {
            return $response->withJson(
                [
                    "success" => false,
                    "message" => "Error occured: " . $e->getMessage()
                ], 400);
        }
    }

    /**
     *
     * {@inheritdoc}
     * @see \FSS\Controllers\ControllerInterface::delete() @SWG\Api(
     *      path="/countydata/{id}",
     *      @SWG\Operation(
     *      method="DELETE",
     *      summary="Deletes a CountyData",
     *      type="CountyData",
     *      @SWG\Parameter(
     *      name="id",
     *      description="id of CountyData to delete",
     *      paramType="path",
     *      required=true,
     *      allowMultiple=false,
     *      type="integer"
     *      ),
     *      @SWG\ResponseMessage(code=404, message="CountyData not found")
     *      )
     *      )
     */
    public function delete(ServerRequestInterface $request,
        ResponseInterface $response, array $args): ResponseInterface
    {
        $id = $args['id'];
        try {
            $record = CountyData::findOrFail($id);
            $record->delete();
            $this->logger->debug("CountyData delete query: ",
                $this->db::getQueryLog());
            return $response->withJson(
                [
                    "success" => true,
                    "message" => "Deleted CountyData $id"
                ], 200, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT);
        } catch (Exception $e) {
            return $response->withJson(
                [
                    "success" => false,
                    "message" => "CountyData not found"
                ], 404);
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
import getEncapsulatedImageFrame from './getEncapsulatedImageFrame.js';
import getUncompressedImageFrame from './getUncompressedImageFrame.js';

function getPixelData (dataSet, frameIndex = 0) {
  const pixelDataElement = dataSet.elements.x7fe00010 || dataSet.elements.x7fe00008;

  if (pixelDataElement.encapsulatedPixelData) {
    return getEncapsulatedImageFrame(dataSet, frameIndex);
  }

  return getUncompressedImageFrame(dataSet, frameIndex);
}

export default getPixelData;


text:
import scala.collection.immutable.Set
import scala.collection.immutable.Multiset

object MultisetOperations {
  def preservedUnderToSet(a: Multiset[Int], b: Multiset[Int]) : Boolean = {
    ((a ++ b).toSet.size == (a.toSet ++ b.toSet).size) &&
    ((a ** b).toSet.size == (a.toSet ** b.toSet).size)
  } ensuring(res => res)

  def sumPreservesSizes(a: Multiset[Int], b: Multiset[Int]) : Boolean = {
    ((a +++ b).size == a.size + b.size)
  } ensuring(res => res)
}


text:
import { NgModule } from '@angular/core';

import { ServiceList } from './services';

@NgModule({
  providers: [...ServiceList],
})
export class CoreModule { }


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--
  Licensed to the AOS Community (AOS) under one or more
  contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The AOS licenses this file
  to you under the Apache License, Version 2.0 (the
  "License"); you may not use this file except in compliance
  with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an
  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, either express or implied.  See the License for the
  specific language governing permissions and limitations
  under the License.
-->

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:amq="http://activemq.apache.org/schema/core" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core.xsd">

	<!--  lets create an embedded ActiveMQ Broker -->
	<amq:broker useJmx="false" persistent="false">
		<amq:transportConnectors>
			<amq:transportConnector uri="tcp://localhost:61616" />
		</amq:transportConnectors>
	</amq:broker>

	<!--  ActiveMQ destinations to use  -->
	<amq:queue id="destination"
		physicalName="aos.activemq.launch.spring.Test.spring.embedded" />

	<!--
		JMS ConnectionFactory to use, configuring the embedded broker using
		XML
	-->
	<amq:connectionFactory id="jmsFactory" brokerURL="tcp://localhost:61616?useJmx=true" />

	<!-- Spring JMS Template -->
	<bean id="myJmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		<property name="connectionFactory">
			<!-- lets wrap in a pool to avoid creating a connection per send -->
			<bean class="org.springframework.jms.connection.SingleConnectionFactory">
				<property name="targetConnectionFactory">
					<ref local="jmsFactory" />
				</property>
			</bean>
		</property>
	</bean>

	<bean id="consumerJmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		<property name="connectionFactory" ref="jmsFactory" />
	</bean>

	<!-- a sample POJO which uses a Spring JmsTemplate -->
	<bean id="producer" class="aos.activemq.producer.SpringProducer">
		<property name="template">
			<ref bean="myJmsTemplate"></ref>
		</property>

		<property name="destination">
			<ref bean="destination" />
		</property>

		<property name="messageCount">
			<value>10</value>
		</property>
	</bean>

	<!-- a sample POJO consumer -->
	<bean id="consumer" class="aos.activemq.consumer.SpringConsumer">
		<property name="template" ref="consumerJmsTemplate" />
		<property name="destination" ref="destination" />
	</bean>

</beans>


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.

package com.azure.maps.weather.models;

import com.azure.core.annotation.Fluent;
import com.fasterxml.jackson.annotation.JsonProperty;

/** Summary of temperature fluctuations over the number of past hours. */
@Fluent
public final class PastHoursTemperature {
    /*
     * minimum
     */
    @JsonProperty(value = "minimum")
    private WeatherUnitDetails minimum;

    /*
     * maximum
     */
    @JsonProperty(value = "maximum")
    private WeatherUnitDetails maximum;

    /** Set default PastHoursTemperature constructor to private */
    private PastHoursTemperature() {}

    /**
     * Get the minimum property: minimum.
     *
     * @return the minimum value.
     */
    public WeatherUnitDetails getMinimum() {
        return this.minimum;
    }

    /**
     * Get the maximum property: maximum.
     *
     * @return the maximum value.
     */
    public WeatherUnitDetails getMaximum() {
        return this.maximum;
    }
}


text:
*This repository won't get much updated anymore, it has been superseded by an [Ansible version](https://github.com/marcaurele/laptop-ansible).*

# dotfiles

Fork from holman dotfiles (https://github.com/holman/dotfiles).

Your dotfiles are how you personalize your system. These are mine.

## components

There's a few special files in the hierarchy.

- **bin/**: Anything in `bin/` will get added to your `$PATH` and be made
  available everywhere.
- **Brewfile**: This is a list of applications for [Homebrew Cask](http://caskroom.io) to install: things like Chrome and 1Password and Adium and stuff. Might want to edit this file before running any initial setup.
- **topic/\*.zsh**: Any files ending in `.zsh` get loaded into your
  environment.
- **topic/path.zsh**: Any file named `path.zsh` is loaded first and is
  expected to setup `$PATH` or similar.
- **topic/completion.zsh**: Any file named `completion.zsh` is loaded
  last and is expected to setup autocomplete.
- **topic/\*.symlink**: Any files ending in `*.symlink` get symlinked into
  your `$HOME`. This is so you can keep all of those versioned in your dotfiles
  but still keep those autoloaded files in your home directory. These get
  symlinked in when you run `script/bootstrap`.

## Install

Run this:

```sh
git clone https://github.com/marcaurele/dotfiles.git ~/.dotfiles
cd ~/.dotfiles
script/bootstrap
```

This will symlink the appropriate files in `.dotfiles` to your home directory.
Everything is configured and tweaked within `~/.dotfiles`.

The main file you'll want to change right off the bat is `zsh/zshrc.symlink`,
which sets up a few paths that'll be different on your particular machine.

`dot` is a simple script that installs some dependencies, sets sane OS X
defaults, and so on. Tweak this script, and occasionally run `dot` from
time to time to keep your environment fresh and up-to-date. You can find
this script in `bin/`.

To only install the brew packages inside `Brewfile`, run:

```sh
cd <this-directory>
brew bundle
```

Warning: it won't show which packages have been updated!

## Missing stuff

- KeepassX 0.4.4
- Truecrypt 7.1a/VeraCrypt

## Manual things

### Python

Use `pyenv` to install different py flavour, most likely 2.7.12, 3.4.5, 3.5.2

### Asciidoctor
  - `sudo gem install asciidoctor`
  - `sudo gem install --pre asciidoctor-pdf`
  - `sudo gem install coderay pygments.rb`

## TODO in readme/conf
https://gist.github.com/bmhatfield/cc21ec0a3a2df963bffa3c1f884b676b


text:
#ifndef ALGORITHM_RLE_H_
#define ALGORITHM_RLE_H_ 1

#include <cstdint>
#include <istream>
#include <ostream>

namespace algorithm
{

class RLE
{
public:
    typedef uint8_t         SymbolType;
    typedef uint32_t        SizeType;       /** TODO: uint32_t is too big */
    typedef std::istream    StreamInType;
    typedef std::ostream    StreamOutType;

    void Encode(StreamInType & fin, StreamOutType & fout);
    void Decode(StreamInType & fin, StreamOutType & fout);
};

} /** ns: algorithm */

#endif /** ! ALGORITHM_RLE_H_ */


text:
Function Show-Chart
{
   <#
    .SYNOPSIS
        Show-Chart draws a chart

    .DESCRIPTION
        With Show-Chart you can create a chart on the screen and optionally save it to a file. It uses the Windows Forms control to create the chart, then can be controlled using various parameters. See the examples for details.

    .EXAMPLE
        Show-Chart

        Draw a chart using the default dataset (top 5 running processes sorted based on memory usage), default width, height and column type.

    .EXAMPLE
        Show-Chart -Title "Food calories" -Dataset @{"Muffin" = 377; "Apple" = 52; "Banana" = 89} -Type "Point"

        Draw a point chart with a custom title and dataset.

    .EXAMPLE
        Show-Chart -Width 800 -Height 800 -Output chart.png

        Draw a default chart with the specified resolution, but do not display it, save it directly to a file (format must be PNG).

    .EXAMPLE
        Show-Chart -Type "Pie" -Dataset $set -ShowValues $false

        Draw a pie chart with a custom data set, and do not show individual values on the chart.

    .LINK
        Author: Patrick Lambert - http://dendory.net
    #>
    param([string]$Title = "", [string]$Output = "", $Dataset = @{}, [int32]$Width = 700, [int32]$Height = 500, [string]$Type = "Column", [boolean]$ShowValues = $true)

    Add-Type -AssemblyName System.Windows.Forms
    Add-Type -AssemblyName System.Windows.Forms.DataVisualization
    $chart = New-object System.Windows.Forms.DataVisualization.Charting.Chart
    $chart.Width = $Width
    $chart.Height = $Height
    $chart.Top = 50
    $chart.Left = 50
    $chartarea = New-Object System.Windows.Forms.DataVisualization.Charting.ChartArea
    $chartarea.BackColor = "#FFFFFF"
    $chartarea.BackSecondaryColor = "#FFFFFF"
    $chartarea.BackGradientStyle = "DiagonalRight"
    if($Dataset.Count -eq 0)
    {
        $Title = "Top 5 memory usage processes (MB)"
        Get-Process | Sort -Property WorkingSet | Select ProcessName,@{Name='Memory';Expression={[math]::Round($_.WorkingSet / 1000000,1)}} -Last 5 | Foreach { $Dataset[$_.ProcessName] = [double]$_.Memory }
    }
    $chart.ChartAreas.Add($chartarea)
    $chart.Titles.Add($Title) | Out-Null
    $chart.Titles[0].Font = New-Object System.Drawing.Font("Times New Roman", 16)
    $chart.Series.Add("dataset") | Out-Null
    $chart.Series[0].Points.DataBindXY($Dataset.Keys, $Dataset.Values)
    $chart.Series[0].ChartType = [System.Windows.Forms.DataVisualization.Charting.SeriesChartType]::$Type
    $chart.Series[0].IsValueShownAsLabel = $ShowValues
    $chart.Series[0]["PieLabelStyle"] = "Outside"
    $chart.Series[0]["DrawingStyle"] = "Emboss"
    $chart.Series[0]["PieLineColor"] = "Black"
    $chart.Series[0]["PieDrawingStyle"] = "Concave"
    $chart.Anchor = [System.Windows.Forms.AnchorStyles]::Bottom -bor [System.Windows.Forms.AnchorStyles]::Left -bor [System.Windows.Forms.AnchorStyles]::Right -bor [System.Windows.Forms.AnchorStyles]::Top
    $form = New-Object Windows.Forms.Form
    $form.Width = $Width + 100
    $form.Height = $Height + 120
    $form.Controls.Add($chart)
    $save = New-Object Windows.Forms.Button
    $save.Text = "Save Chart"
    $save.Top = 10
    $save.Left = 10
    $save.Width = 100
    $save.Anchor = [System.Windows.Forms.AnchorStyles]::Top -bor [System.Windows.Forms.AnchorStyles]::Left
    $save.add_click({
        $browse = New-Object System.Windows.Forms.SaveFileDialog
        $browse.initialDirectory = $Env:USERPROFILE + "\Desktop\"
        $browse.filter = "Images (*.png)| *.png"
        $browse.filename = "chart.png"
        $browse.ShowDialog() | Out-Null
        $browse.FilterIndex
        $chart.SaveImage($browse.filename, "PNG")
        $label.Text = "Saved to: " + $browse.filename
    })
    $form.controls.add($save)
    $label = New-Object Windows.Forms.Label
    $label.Top = 15
    $label.Left = 120
    $label.Width = $Width - 150
    $form.controls.add($label)
    if($Output -eq "")
    {
        $form.ShowDialog() | Out-Null
    }
    else
    {
        $chart.SaveImage($Output, "PNG")
    }
}

Export-ModuleMember Show-Chart


text:
SpriteRenderer::SpriteRenderer(int id)
{
	m_ComponentID = id;
	m_ComponentName = "SpriteRenderer";
}

SpriteRenderer::~SpriteRenderer()
{
}

void SpriteRenderer::setSprite(string filename)
{
	if (!this->SpriteTexture.loadFromFile(filename))
	{
		cout << filename << " not found." << endl;
	}

	this->Sprite.setTexture(this->SpriteTexture);
}

void SpriteRenderer::Update()
{
	Sprite.setScale(m_GameObject->ObjectScale());
	Sprite.setPosition(m_GameObject->ObjectPosition());
	Sprite.setRotation(m_GameObject->ObjectRotation());
	Sprite.setOrigin(25.0f, 25.0f);
}


text:
package com.gilt.storeroom

import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global

import org.scalatest.{FunSuite, Matchers}
import org.scalatest.concurrent.ScalaFutures

trait StoreTest[T <: Store[String,Long]] extends  FunSuite with Matchers with ScalaFutures {
  def emptyStore: T
  def cleanupStore(store: T): Unit = {}

  def withStore(f: T => Unit) = {
    val store = emptyStore
    try {
      f(store)
    } finally {
      cleanupStore(store)
    }
  }

  // TODO: should probably use scalacheck properties

  test("get on an empty store returns None") {
    withStore { store =>
      store.get("1").futureValue should be(None)
    }
  }

  test("put than get finds item") {
    withStore { store =>
      store.put("1"->Some(2)).futureValue
      store.get("1").futureValue should be(Some(2))
    }
  }

  test("second put replaces item") {
    withStore { store =>
      store.put("1"->Some(2)).futureValue
      store.put("1"->Some(3)).futureValue
      store.get("1").futureValue should be(Some(3))
    }
  }

  test("can delete with put") {
    withStore { store =>
      store.put("1"->Some(2)).futureValue
      store.put("1"->None).futureValue
      store.get("1").futureValue should be(None)
    }
  }

  test("can close") {
    withStore { store =>
      store.close.futureValue
    }
  }
}

trait IterableStoreTest[T <: IterableStore[String,Long]] extends StoreTest[T] {

  test("getAll works") {
    withStore { store =>
      val items = Map("1"->2,"3"->4,"5"->6)

      sequenceMapOfFutures(store.multiPut(items.mapValues(Some(_)))).futureValue

      enumeratorValue(store.getAll()) should contain theSameElementsAs items.toList
    }
  }
}


text:
Difficulty: Hard

https://leetcode.com/problems/longest-chunked-palindrome-decomposition/

Return the largest possible k such that there exists a_1, a_2, ..., a_k such that:

* Each a_i is a non-empty string;
* Their concatenation a_1 + a_2 + ... + a_k is equal to text;
* For all 1 <= i <= k,  a_i = a_{k+1 - i}.

**Example 1:**
```
Input: text = "ghiabcdefhelloadamhelloabcdefghi"
Output: 7
Explanation: We can split the string on "(ghi)(abcdef)(hello)(adam)(hello)(abcdef)(ghi)".
```

**Example 2:**
```
Input: text = "merchant"
Output: 1
Explanation: We can split the string on "(merchant)".
```

**Example 3:**
```
Input: text = "antaprezatepzapreanta"
Output: 11
Explanation: We can split the string on "(a)(nt)(a)(pre)(za)(tpe)(za)(pre)(a)(nt)(a)".
```

**Example 4:**
```
Input: text = "aaa"
Output: 3
Explanation: We can split the string on "(a)(a)(a)".
```

**Constraints:**

* text consists only of lowercase English characters.
* 1 <= text.length <= 1000


text:
//
//  GTLPlusDomainsAudience.h
//

// ----------------------------------------------------------------------------
// NOTE: This file is generated from Google APIs Discovery Service.
// Service:
//   Google+ Domains API (plusDomains/v1)
// Description:
//   The Google+ API enables developers to build on top of the Google+ platform.
// Documentation:
//   https://developers.google.com/+/domains/
// Classes:
//   GTLPlusDomainsAudience (0 custom class methods, 5 custom properties)

#if GTL_BUILT_AS_FRAMEWORK
  #import "GTL/GTLObject.h"
#else
  #import "GTLObject.h"
#endif

@class GTLPlusDomainsAclentryResource;

// ----------------------------------------------------------------------------
//
//   GTLPlusDomainsAudience
//

@interface GTLPlusDomainsAudience : GTLObject

// ETag of this response for caching purposes.
@property (copy) NSString *ETag;

// The access control list entry.
@property (retain) GTLPlusDomainsAclentryResource *item;

// Identifies this resource as an audience. Value: "plus#audience".
@property (copy) NSString *kind;

// The number of people in this circle. This only applies if entity_type is
// CIRCLE.
@property (retain) NSNumber *memberCount;  // unsignedIntValue

// The circle members' visibility as chosen by the owner of the circle. This
// only applies for items with "item.type" equals "circle". Possible values are:
// - "public" - Members are visible to the public.
// - "limited" - Members are visible to a limited audience.
// - "private" - Members are visible to the owner only.
@property (copy) NSString *visibility;

@end


text:
// Copyright 2007-2018 Chris Patterson, Dru Sellers, Travis Smith, et. al.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
// this file except in compliance with the License. You may obtain a copy of the
// License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
namespace MassTransit.WebJobs.ServiceBusIntegration
{
    using System;
    using System.Threading;
    using System.Threading.Tasks;
    using AzureServiceBusTransport.Contexts;
    using GreenPipes;
    using Logging;
    using Microsoft.Azure.WebJobs;
    using Microsoft.ServiceBus.Messaging;

    public class CollectorSendEndpointContext :
        BasePipeContext,
        SendEndpointContext
    {
        readonly CancellationToken _cancellationToken;
        readonly ILog _log;
        readonly IAsyncCollector<BrokeredMessage> _collector;

        public CollectorSendEndpointContext(string path, ILog log, IAsyncCollector<BrokeredMessage> collector, CancellationToken cancellationToken)
        {
            _collector = collector;
            _log = log;
            _cancellationToken = cancellationToken;
            EntityPath = path;
        }

        public string EntityPath { get; }

        public Task Send(BrokeredMessage message)
        {
            if (_log.IsDebugEnabled)
                _log.DebugFormat("Sending message: {0}", message.MessageId);

            return _collector.AddAsync(message, _cancellationToken);
        }

        public async Task<long> ScheduleSend(BrokeredMessage message, DateTime scheduleEnqueueTimeUtc)
        {
            if (_log.IsDebugEnabled)
                _log.DebugFormat("Scheduling message: {0} for delivery at {1}", message.MessageId, scheduleEnqueueTimeUtc);

            message.ScheduledEnqueueTimeUtc = scheduleEnqueueTimeUtc;

            await _collector.AddAsync(message, _cancellationToken).ConfigureAwait(false);

            return 0;
        }

        public Task CancelScheduledSend(long sequenceNumber)
        {
            throw new NotImplementedException("Cannot cancel a scheduled message when using the collector transport");
        }

        public Task Close()
        {
            return _collector.FlushAsync(_cancellationToken);
        }
    }
}


text:
magichour.lib.StringMatch package
=================================

Submodules
----------

magichour.lib.StringMatch.StringMatch module
--------------------------------------------

.. automodule:: magichour.lib.StringMatch.StringMatch
    :members:
    :undoc-members:
    :show-inheritance:

magichour.lib.StringMatch.cluster module
----------------------------------------

.. automodule:: magichour.lib.StringMatch.cluster
    :members:
    :undoc-members:
    :show-inheritance:

magichour.lib.StringMatch.leaf module
-------------------------------------

.. automodule:: magichour.lib.StringMatch.leaf
    :members:
    :undoc-members:
    :show-inheritance:

magichour.lib.StringMatch.utils module
--------------------------------------

.. automodule:: magichour.lib.StringMatch.utils
    :members:
    :undoc-members:
    :show-inheritance:

Module contents
---------------

.. automodule:: magichour.lib.StringMatch
    :members:
    :undoc-members:
    :show-inheritance:


text:
namespace iresearch {

//////////////////////////////////////////////////////////////////////////////
/// @class memory_allocator
/// @brief a reusable thread-safe allocator for memory files
//////////////////////////////////////////////////////////////////////////////
class IRESEARCH_API memory_allocator : public stored_attribute {
 private:
  struct IRESEARCH_API buffer {
    typedef std::unique_ptr<byte_type[]> ptr;
    DECLARE_FACTORY(size_t size);
  }; // buffer

 public:
  DECLARE_FACTORY(size_t pool_size);

  typedef container_utils::memory::bucket_allocator<
    buffer,
    16 // as in memory_file
  > allocator_type;

  static memory_allocator& global() noexcept;

  explicit memory_allocator(size_t pool_size);

  operator allocator_type&() const noexcept {
    return const_cast<allocator_type&>(allocator_);
  }

 private:
  allocator_type allocator_;
}; // memory_allocator

//////////////////////////////////////////////////////////////////////////////
/// @class fd_pool_size
/// @brief the size of file descriptor pools
///        where applicable, e.g. fs_directory
//////////////////////////////////////////////////////////////////////////////
struct IRESEARCH_API fd_pool_size: public stored_attribute {
  DECLARE_FACTORY();

  fd_pool_size() noexcept;
  void clear() noexcept;

  size_t size;
}; // fd_pool_size

//////////////////////////////////////////////////////////////////////////////
/// @class index_file_refs
/// @brief represents a ref_counter for index related files
//////////////////////////////////////////////////////////////////////////////
class IRESEARCH_API index_file_refs : public stored_attribute {
 public:
  typedef attribute_store::ref<index_file_refs>::type attribute_t;
  typedef ref_counter<std::string> counter_t;
  typedef counter_t::ref_t ref_t;

  DECLARE_FACTORY();
  index_file_refs() = default;
  ref_t add(const std::string& key);
  ref_t add(std::string&& key);
  void clear();
  bool remove(const std::string& key) { return refs_.remove(key); }
  counter_t& refs() noexcept {
    return refs_;
  }

 private:
  IRESEARCH_API_PRIVATE_VARIABLES_BEGIN
  counter_t refs_;
  IRESEARCH_API_PRIVATE_VARIABLES_END
}; // index_file_refs

}

#endif


text:
SYNONYM

#### According to
Index Fungorum

#### Published in
null

#### Original name
Coccocarpia smaragdina Pers.

### Remarks
null


text:
/*
 * James Brundege
 * Date: 2017-04-09
 * MIT license: https://opensource.org/licenses/MIT
 */
package jmb.jcortex.data;

import org.apache.commons.math3.util.FastMath;

public class DataSetSplitter {

    public DataSet[] split(DataSet src, double... setSizes) {
        int numRows = src.numRows();
        DataSet[] subsets = new DataSet[setSizes.length];
        int previousEnd = 0;
        for (int i = 0; i < setSizes.length; i++) {
            // if we've consumed the entire DataSet and still have another subset, there is something very wrong
            if (previousEnd >= numRows) {
                throw new IllegalArgumentException("Error, setSizes sum to > 1.0");
            }
            int numRowsInSubset = (int)FastMath.round(setSizes[i] * numRows);
            int newEnd = previousEnd + numRowsInSubset;
            // if we're over on this subset, just truncate it. This can happen due to rounding issues, so don't fail.
            if (newEnd > numRows) {
                newEnd = numRows;
            }
            subsets[i] = src.sliceRows(previousEnd, newEnd);
            previousEnd = newEnd;
        }
        return subsets;
    }

}


text:
import re
from setuptools import setup

init_py = open('changes_test/__init__.py').read()
metadata = dict(re.findall("__([a-z]+)__ = '([^']+)'", init_py))
metadata['doc'] = re.findall('"""(.+)"""', init_py)[0]

setup(
    name='changes_test',
    version=metadata['version'],
    description=metadata['doc'],
    author=metadata['author'],
    author_email=metadata['email'],
    url=metadata['url'],
    packages=['changes_test'],
    include_package_data=True,
    install_requires=[
        'click < 2.1.0'
    ],
    entry_points={
        'console_scripts': [
            'changes_test = changes_test.cli:main',
        ],
    },
    test_suite='nose.collector',
    license=open('LICENSE').read(),
)


text:
package org.apache.camel.component.aws2.lambda;

import org.apache.camel.Category;
import org.apache.camel.Component;
import org.apache.camel.Consumer;
import org.apache.camel.Processor;
import org.apache.camel.Producer;
import org.apache.camel.component.aws2.lambda.client.Lambda2ClientFactory;
import org.apache.camel.spi.Metadata;
import org.apache.camel.spi.UriEndpoint;
import org.apache.camel.spi.UriParam;
import org.apache.camel.spi.UriPath;
import org.apache.camel.support.DefaultEndpoint;
import org.apache.camel.util.ObjectHelper;
import software.amazon.awssdk.services.lambda.LambdaClient;

/**
 * Manage and invoke AWS Lambda functions using AWS SDK version 2.x.
 */
@UriEndpoint(firstVersion = "3.2.0", scheme = "aws2-lambda", title = "AWS Lambda", syntax = "aws2-lambda:function",
             producerOnly = true, category = { Category.CLOUD, Category.COMPUTING, Category.SERVERLESS })
public class Lambda2Endpoint extends DefaultEndpoint {

    private LambdaClient awsLambdaClient;

    @UriPath
    @Metadata(required = true)
    private String function;
    @UriParam
    private Lambda2Configuration configuration;

    public Lambda2Endpoint(String uri, Component component, Lambda2Configuration configuration) {
        super(uri, component);
        this.configuration = configuration;
    }

    @Override
    public Consumer createConsumer(Processor processor) throws Exception {
        throw new UnsupportedOperationException("You cannot receive messages from this endpoint");
    }

    @Override
    public Producer createProducer() throws Exception {
        return new Lambda2Producer(this);
    }

    public String getFunction() {
        return function;
    }

    /**
     * Name of the Lambda function.
     */
    public void setFunction(String function) {
        this.function = function;
    }

    @Override
    public void doStart() throws Exception {
        super.doStart();
        awsLambdaClient = configuration.getAwsLambdaClient() != null
                ? configuration.getAwsLambdaClient()
                : Lambda2ClientFactory.getLambdaClient(configuration).getLambdaClient();
    }

    @Override
    public void doStop() throws Exception {
        if (ObjectHelper.isEmpty(configuration.getAwsLambdaClient())) {
            if (awsLambdaClient != null) {
                awsLambdaClient.close();
            }
        }
        super.doStop();
    }

    public Lambda2Configuration getConfiguration() {
        return configuration;
    }

    public LambdaClient getAwsLambdaClient() {
        return awsLambdaClient;
    }
}


text:
/**
 */
package de.uni_hildesheim.sse.ivml;

import org.eclipse.emf.ecore.EObject;

/**
 *
 * A representation of the model object 'Opt Block Expression'.
 *
 *
 *

 * The following features are supported:
 *

 *

 *
{@link de.uni_hildesheim.sse.ivml.OptBlockExpression#getExpr Expr}

 *
{@link de.uni_hildesheim.sse.ivml.OptBlockExpression#getBlock Block}

 *

 *
 * @see de.uni_hildesheim.sse.ivml.IvmlPackage#getOptBlockExpression()
 * @model
 * @generated
 */
public interface OptBlockExpression extends EObject
{
  /**
   * Returns the value of the 'Expr' containment reference.
   *
   *
   * @return the value of the 'Expr' containment reference.
   * @see #setExpr(Expression)
   * @see de.uni_hildesheim.sse.ivml.IvmlPackage#getOptBlockExpression_Expr()
   * @model containment="true"
   * @generated
   */
  Expression getExpr();

  /**
   * Sets the value of the '{@link de.uni_hildesheim.sse.ivml.OptBlockExpression#getExpr Expr}' containment reference.
   *
   *
   * @param value the new value of the 'Expr' containment reference.
   * @see #getExpr()
   * @generated
   */
  void setExpr(Expression value);

  /**
   * Returns the value of the 'Block' containment reference.
   *
   *
   * @return the value of the 'Block' containment reference.
   * @see #setBlock(BlockExpression)
   * @see de.uni_hildesheim.sse.ivml.IvmlPackage#getOptBlockExpression_Block()
   * @model containment="true"
   * @generated
   */
  BlockExpression getBlock();

  /**
   * Sets the value of the '{@link de.uni_hildesheim.sse.ivml.OptBlockExpression#getBlock Block}' containment reference.
   *
   *
   * @param value the new value of the 'Block' containment reference.
   * @see #getBlock()
   * @generated
   */
  void setBlock(BlockExpression value);

} // OptBlockExpression


text:
include(ExternalProject)

ExternalProject_Add(
  gli
  DOWNLOAD_DIR "${SEQUOIA_EXTERNAL_DOWNLOAD_DIR}/gli"
  URL ${gli_url}
  URL_MD5 ${gli_md5}
  BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/gli"
  INSTALL_DIR "${SEQUOIA_EXTERNAL_INSTALL_PREFIX}/gli"
  PATCH_COMMAND ""
  CONFIGURE_COMMAND ""
  BUILD_COMMAND ""
  INSTALL_COMMAND ${CMAKE_COMMAND} -E make_directory <INSTALL_DIR>/gli &&
                  ${CMAKE_COMMAND} -E copy_directory <SOURCE_DIR>/gli/ <INSTALL_DIR>/gli/
)

ExternalProject_Get_Property(gli install_dir)
set(GLI_ROOT "${install_dir}" CACHE INTERNAL "")

sequoia_export_package(
  PACKAGE gli
  CMAKE_ARGS
    "-DGLI_ROOT:PATH=${GLI_ROOT}"
)


text:
"""Support for August binary sensors."""
from __future__ import annotations

from collections.abc import Callable
from dataclasses import dataclass
from datetime import datetime, timedelta
import logging
from typing import cast

from yalexs.activity import (
    ACTION_DOORBELL_CALL_MISSED,
    SOURCE_PUBNUB,
    Activity,
    ActivityType,
)
from yalexs.doorbell import DoorbellDetail
from yalexs.lock import LockDoorStatus
from yalexs.util import update_lock_detail_from_activity

from homeassistant.components.binary_sensor import (
    BinarySensorDeviceClass,
    BinarySensorEntity,
    BinarySensorEntityDescription,
)
from homeassistant.core import callback
from homeassistant.helpers.entity import EntityCategory
from homeassistant.helpers.event import async_call_later

from . import AugustData
from .const import ACTIVITY_UPDATE_INTERVAL, DATA_AUGUST, DOMAIN
from .entity import AugustEntityMixin

_LOGGER = logging.getLogger(__name__)

TIME_TO_DECLARE_DETECTION = timedelta(seconds=ACTIVITY_UPDATE_INTERVAL.total_seconds())
TIME_TO_RECHECK_DETECTION = timedelta(
    seconds=ACTIVITY_UPDATE_INTERVAL.total_seconds() * 3
)

def _retrieve_online_state(data: AugustData, detail: DoorbellDetail) -> bool:
    """Get the latest state of the sensor."""
    # The doorbell will go into standby mode when there is no motion
    # for a short while. It will wake by itself when needed so we need
    # to consider is available or we will not report motion or dings

    return detail.is_online or detail.is_standby

def _retrieve_motion_state(data: AugustData, detail: DoorbellDetail) -> bool:
    latest = data.activity_stream.get_latest_device_activity(
        detail.device_id, {ActivityType.DOORBELL_MOTION}
    )

    if latest is None:
        return False

    return _activity_time_based_state(latest)

def _retrieve_image_capture_state(data: AugustData, detail: DoorbellDetail) -> bool:
    latest = data.activity_stream.get_latest_device_activity(
        detail.device_id, {ActivityType.DOORBELL_IMAGE_CAPTURE}
    )

    if latest is None:
        return False

    return _activity_time_based_state(latest)

def _retrieve_ding_state(data: AugustData, detail: DoorbellDetail) -> bool:
    latest = data.activity_stream.get_latest_device_activity(
        detail.device_id, {ActivityType.DOORBELL_DING}
    )

    if latest is None:
        return False

    if (
        data.activity_stream.pubnub.connected
        and latest.action == ACTION_DOORBELL_CALL_MISSED
    ):
        return False

    return _activity_time_based_state(latest)

def _activity_time_based_state(latest: Activity) -> bool:
    """Get the latest state of the sensor."""
    start = latest.activity_start_time
    end = latest.activity_end_time + TIME_TO_DECLARE_DETECTION
    return start <= _native_datetime() <= end

def _native_datetime() -> datetime:
    """Return time in the format august uses without timezone."""
    return datetime.now()

@dataclass
class AugustRequiredKeysMixin:
    """Mixin for required keys."""

    value_fn: Callable[[AugustData, DoorbellDetail], bool]
    is_time_based: bool

@dataclass
class AugustBinarySensorEntityDescription(
    BinarySensorEntityDescription, AugustRequiredKeysMixin
):
    """Describes August binary_sensor entity."""

SENSOR_TYPE_DOOR = BinarySensorEntityDescription(
    key="door_open",
    name="Open",
)

SENSOR_TYPES_DOORBELL: tuple[AugustBinarySensorEntityDescription, ...] = (
    AugustBinarySensorEntityDescription(
        key="doorbell_ding",
        name="Ding",
        device_class=BinarySensorDeviceClass.OCCUPANCY,
        value_fn=_retrieve_ding_state,
        is_time_based=True,
    ),
    AugustBinarySensorEntityDescription(
        key="doorbell_motion",
        name="Motion",
        device_class=BinarySensorDeviceClass.MOTION,
        value_fn=_retrieve_motion_state,
        is_time_based=True,
    ),
    AugustBinarySensorEntityDescription(
        key="doorbell_image_capture",
        name="Image Capture",
        icon="mdi:file-image",
        value_fn=_retrieve_image_capture_state,
        is_time_based=True,
    ),
    AugustBinarySensorEntityDescription(
        key="doorbell_online",
        name="Online",
        device_class=BinarySensorDeviceClass.CONNECTIVITY,
        entity_category=EntityCategory.DIAGNOSTIC,
        value_fn=_retrieve_online_state,
        is_time_based=False,
    ),
)

async def async_setup_entry(hass, config_entry, async_add_entities):
    """Set up the August binary sensors."""
    data = hass.data[DOMAIN][config_entry.entry_id][DATA_AUGUST]
    entities = []

    for door in data.locks:
        detail = data.get_device_detail(door.device_id)
        if not detail.doorsense:
            _LOGGER.debug(
                "Not adding sensor class door for lock %s because it does not have doorsense",
                door.device_name,
            )
            continue

        _LOGGER.debug("Adding sensor class door for %s", door.device_name)
        entities.append(AugustDoorBinarySensor(data, door, SENSOR_TYPE_DOOR))

    for doorbell in data.doorbells:
        for description in SENSOR_TYPES_DOORBELL:
            _LOGGER.debug(
                "Adding doorbell sensor class %s for %s",
                description.device_class,
                doorbell.device_name,
            )
            entities.append(AugustDoorbellBinarySensor(data, doorbell, description))

    async_add_entities(entities)

class AugustDoorBinarySensor(AugustEntityMixin, BinarySensorEntity):
    """Representation of an August Door binary sensor."""

    _attr_device_class = BinarySensorDeviceClass.DOOR

    def __init__(self, data, device, description: BinarySensorEntityDescription):
        """Initialize the sensor."""
        super().__init__(data, device)
        self.entity_description = description
        self._data = data
        self._device = device
        self._attr_name = f"{device.device_name} {description.name}"
        self._attr_unique_id = (
            f"{self._device_id}_{cast(str, description.name).lower()}"
        )
        self._update_from_data()

    @callback
    def _update_from_data(self):
        """Get the latest state of the sensor and update activity."""
        door_activity = self._data.activity_stream.get_latest_device_activity(
            self._device_id, {ActivityType.DOOR_OPERATION}
        )

        if door_activity is not None:
            update_lock_detail_from_activity(self._detail, door_activity)
            # If the source is pubnub the lock must be online since its a live update
            if door_activity.source == SOURCE_PUBNUB:
                self._detail.set_online(True)

        bridge_activity = self._data.activity_stream.get_latest_device_activity(
            self._device_id, {ActivityType.BRIDGE_OPERATION}
        )

        if bridge_activity is not None:
            update_lock_detail_from_activity(self._detail, bridge_activity)
        self._attr_available = self._detail.bridge_is_online
        self._attr_is_on = self._detail.door_state == LockDoorStatus.OPEN

class AugustDoorbellBinarySensor(AugustEntityMixin, BinarySensorEntity):
    """Representation of an August binary sensor."""

    entity_description: AugustBinarySensorEntityDescription

    def __init__(self, data, device, description: AugustBinarySensorEntityDescription):
        """Initialize the sensor."""
        super().__init__(data, device)
        self.entity_description = description
        self._check_for_off_update_listener = None
        self._data = data
        self._attr_name = f"{device.device_name} {description.name}"
        self._attr_unique_id = (
            f"{self._device_id}_{cast(str, description.name).lower()}"
        )
        self._update_from_data()

    @callback
    def _update_from_data(self):
        """Get the latest state of the sensor."""
        self._cancel_any_pending_updates()
        self._attr_is_on = self.entity_description.value_fn(self._data, self._detail)

        if self.entity_description.is_time_based:
            self._attr_available = _retrieve_online_state(self._data, self._detail)
            self._schedule_update_to_recheck_turn_off_sensor()
        else:
            self._attr_available = True

    def _schedule_update_to_recheck_turn_off_sensor(self):
        """Schedule an update to recheck the sensor to see if it is ready to turn off."""

        # If the sensor is already off there is nothing to do
        if not self.is_on:
            return

        # self.hass is only available after setup is completed
        # and we will recheck in async_added_to_hass
        if not self.hass:
            return

        @callback
        def _scheduled_update(now):
            """Timer callback for sensor update."""
            self._check_for_off_update_listener = None
            self._update_from_data()
            if not self.is_on:
                self.async_write_ha_state()

        self._check_for_off_update_listener = async_call_later(
            self.hass, TIME_TO_RECHECK_DETECTION.total_seconds(), _scheduled_update
        )

    def _cancel_any_pending_updates(self):
        """Cancel any updates to recheck a sensor to see if it is ready to turn off."""
        if not self._check_for_off_update_listener:
            return
        _LOGGER.debug("%s: canceled pending update", self.entity_id)
        self._check_for_off_update_listener()
        self._check_for_off_update_listener = None

    async def async_added_to_hass(self):
        """Call the mixin to subscribe and setup an async_track_point_in_utc_time to turn off the sensor if needed."""
        self._schedule_update_to_recheck_turn_off_sensor()
        await super().async_added_to_hass()


text:
package Jesse_model;

/**
 * Created by becogontijo on 4/23/2015.
 */

import java.io.IOException;
import java.util.Objects;

/**
 * A text-based view for the Connect N model.
 */
@FunctionalInterface
public interface View {

  /**
   * Renders the model as text.
   *
   * @throws java.io.IOException if writing the output throws
   */
  void draw() throws IOException;

  /**
   * Constructs a new console view for the given game model. Output will be
   * to standard out.
   *
   * @param model the model to view (non-null)
   * @throws IllegalArgumentException {@code model.getWidth() > MAX_MODEL_WIDTH}
   */
  public static View create(Model model, Board board) {
    return create(model,board, System.out);
  }

  /**
   * Constructs a new console view for the given game model. Output will be
   * to the given {@link Appendable}.
   *
   * @param model the model to view (non-null)
   * @param out where to write the output (non-null)
   * @throws IllegalArgumentException {@code model.getWidth() > MAX_MODEL_WIDTH}
   */
    public static View create(final Model model, Board bd, final Appendable out) {
      Objects.requireNonNull(out);
      Board board = bd;

      return () -> {
      out.append(board.toString());
    };

  }
}


text:
package org.kuali.rice.kim.bo.ui;

import java.sql.Timestamp;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Convert;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.Transient;

import org.eclipse.persistence.annotations.JoinFetch;
import org.eclipse.persistence.annotations.JoinFetchType;
import org.kuali.rice.kim.impl.identity.address.EntityAddressTypeBo;
import org.kuali.rice.krad.data.jpa.converters.BooleanYNConverter;
import org.kuali.rice.krad.data.jpa.PortableSequenceGenerator;

/**
 * This is a description of what this class does - shyu don't forget to fill this in.
 *
 * @author Kuali Rice Team (rice.collab@kuali.org)
 *
 */
@Entity
@Table(name = "KRIM_PND_ADDR_MT")
public class PersonDocumentAddress extends PersonDocumentBoDefaultBase {
    private static final long serialVersionUID = 1L;

    @PortableSequenceGenerator(name = "KRIM_ENTITY_ADDR_ID_S")
    @GeneratedValue(generator = "KRIM_ENTITY_ADDR_ID_S")
    @Id
    @Column(name = "ENTITY_ADDR_ID")
    protected String entityAddressId;

    @Column(name = "ADDR_TYP_CD")
    protected String addressTypeCode;

    //@Column(name = "ENT_TYP_CD")
    @Transient
    protected String entityTypeCode;

    @Column(name = "CITY")
    protected String city;

    @Column(name = "STATE_PVC_CD")
    protected String stateProvinceCode;

    @Column(name = "POSTAL_CD")
    protected String postalCode;

    @Column(name = "POSTAL_CNTRY_CD")
    protected String countryCode;

    @Column(name = "ATTN_LINE")
    protected String attentionLine;

    @Column(name = "ADDR_LINE_1")
    protected String line1;

    @Column(name = "ADDR_LINE_2")
    protected String line2;

    @Column(name = "ADDR_LINE_3")
    protected String line3;

    @Column(name = "ADDR_FMT")
    protected String addressFormat;

    @Column(name = "MOD_DT")
    protected Timestamp modifiedDate;

    @Column(name = "VALID_DT")
    protected Timestamp validatedDate;

    @Column(name = "VALID_IND")
    @Convert(converter = BooleanYNConverter.class)
    protected boolean validated;

    @Column(name = "NOTE_MSG")
    protected String noteMessage;

    @JoinFetch(value= JoinFetchType.OUTER)
    @ManyToOne(targetEntity = EntityAddressTypeBo.class, cascade = { CascadeType.REFRESH })
    @JoinColumn(name = "ADDR_TYP_CD", referencedColumnName = "ADDR_TYP_CD", insertable = false, updatable = false)
    private EntityAddressTypeBo addressType;

    // Waiting until we pull in from KFS
    // protected State state;
    // protected PostalCode postalCode;
    // protected Country country;
    public PersonDocumentAddress() {
        this.active = true;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#getAddressTypeCode()
	 */
    public String getAddressTypeCode() {
        return addressTypeCode;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#getCity()
	 */
    public String getCity() {
        return city;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#getCountryCode()
	 */
    public String getCountryCode() {
        return countryCode;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#getEntityAddressId()
	 */
    public String getEntityAddressId() {
        return entityAddressId;
    }

    /**
	 * @see org.kuali.rice.kim.api.identity.address.EntityAddressContract#getAttentionLine()
	 */
    public String getAttentionLine() {
        return attentionLine;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#getLine1()
	 */
    public String getLine1() {
        return line1;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#getLine2()
	 */
    public String getLine2() {
        return line2;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#getLine3()
	 */
    public String getLine3() {
        return line3;
    }

    /**
	 * @see @see org.kuali.rice.kim.api.identity.address.EntityAddressContract#getAddressFormat
	 */
    public String getAddressFormat() {
        return addressFormat;
    }

    public Timestamp getModifiedDate() {
        return modifiedDate;
    }

    public Timestamp getValidatedDate() {
        return validatedDate;
    }

    public boolean isValidated() {
        return validated;
    }

    public String getNoteMessage() {
        return noteMessage;
    }

    /**
	 * This overridden method ...
	 *
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#getPostalCode()
	 */
    public String getPostalCode() {
        return postalCode;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#getStateCode()
	 */
    public String getStateProvinceCode() {
        return stateProvinceCode;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#setAddressTypeCode(java.lang.String)
	 */
    public void setAddressTypeCode(String addressTypeCode) {
        this.addressTypeCode = addressTypeCode;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#setCity(java.lang.String)
	 */
    public void setCity(String city) {
        this.city = city;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#setCountryCode(java.lang.String)
	 */
    public void setCountryCode(String countryCode) {
        this.countryCode = countryCode;
    }

    /**
	 * @see org.kuali.rice.kim.api.identity.address.EntityAddressContract#getAttentionLine()
	 */
    public void setAttentionLine(String attentionLine) {
        this.attentionLine = attentionLine;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#setLine1(java.lang.String)
	 */
    public void setLine1(String line1) {
        this.line1 = line1;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#setLine2(java.lang.String)
	 */
    public void setLine2(String line2) {
        this.line2 = line2;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#setLine3(java.lang.String)
	 */
    public void setLine3(String line3) {
        this.line3 = line3;
    }

    /**
	 * @see org.kuali.rice.kim.api.identity.address.EntityAddressContract#getAddressFormat()
	 */
    public void setAddressFormat(String addressFormat) {
        this.addressFormat = addressFormat;
    }

    public void setModifiedDate(Timestamp modifiedDate) {
        this.modifiedDate = modifiedDate;
    }

    public void setValidatedDate(Timestamp validatedDate) {
        this.validatedDate = validatedDate;
    }

    public void setValidated(boolean validated) {
        this.validated = validated;
    }

    public void setNoteMessage(String noteMessage) {
        this.noteMessage = noteMessage;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#setPostalCode(java.lang.String)
	 */
    public void setPostalCode(String postalCode) {
        this.postalCode = postalCode;
    }

    /**
	 * @see org.kuali.rice.kim.bo.entity.KimEntityAddress#setStateCode(java.lang.String)
	 */
    public void setStateProvinceCode(String stateProvinceCode) {
        this.stateProvinceCode = stateProvinceCode;
    }

    /**
	 * @see org.kuali.rice.kim.impl.identity.type.EntityTypeContactInfoBo#getEntityTypeCode()
	 */
    public String getEntityTypeCode() {
        return entityTypeCode;
    }

    public void setEntityTypeCode(String entityTypeCode) {
        this.entityTypeCode = entityTypeCode;
    }

    public void setEntityAddressId(String entityAddressId) {
        this.entityAddressId = entityAddressId;
    }

    public EntityAddressTypeBo getAddressType() {
        return this.addressType;
    }

    public void setAddressType(EntityAddressTypeBo addressType) {
        this.addressType = addressType;
    }
}


text:
<application>
  <component name="UpdatesConfigurable">
    <option name="LAST_BUILD_CHECKED" value="DB-192.5728.128" />
    <option name="LAST_TIME_CHECKED" value="1565193514472" />
  </component>
</application>