text:
data localizedData
{
    # culture="en-US"
    ConvertFrom-StringData @'
InvalidWebUriError=Specified URI is not valid: "{0}". Only http and https paths are accepted.
InvalidDestinationPathSchemeError=Specified DestinationPath is not valid: "{0}". DestinationPath should be absolute path.
DestinationPathIsUncError=Specified DestinationPath is not valid: "{0}". DestinationPath should be local path instead of UNC path.
DestinationPathHasInvalidCharactersError=Specified DestinationPath is not valid: "{0}". DestinationPath should be contains following characters: * ? " < > |
DestinationPathEndsWithInvalidCharacterError=Specified DestinationPath is not valid: "{0}". DestinationPath should not end with / or \\
'@
}

# Path where cache will be stored. It's cleared whenever LCM gets new configuration.
$script:cacheLocation = "$env:ProgramData\Microsoft\Windows\PowerShell\Configuration\BuiltinProvCache\MSFT_xRemoteFile"

# The Get-TargetResource function is used to fetch the status of file specified in DestinationPath on the target machine.
function Get-TargetResource
{
    [CmdletBinding()]
    [OutputType([System.Collections.Hashtable])]
    param
    (
        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [System.String]
        $DestinationPath,

        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [System.String]
        $Uri
    )

    # Check whether DestinationPath is existing file
    $fileExists = $false
    $pathItemType = Get-PathItemType -path $DestinationPath
    switch($pathItemType)
    {
        "File" {
            Write-Verbose "DestinationPath: '$DestinationPath' is existing file on the machine"
            $fileExists = $true
        }

        "Directory" {
            Write-Verbose "DestinationPath: '$DestinationPath' is existing directory on the machine"

            # If it's existing directory, let's check whether expectedDestinationPath exists
            $uriFileName = Split-Path $Uri -Leaf
            $expectedDestinationPath = Join-Path $DestinationPath $uriFileName
            if (Test-Path $expectedDestinationPath) {
                Write-Verbose "File $uriFileName exists in DestinationPath"
                $fileExists = $true
            }
        }

        "Other" {
            Write-Verbose "DestinationPath: '$DestinationPath' has unknown type: '$pathItemType'"
        }

        "NotExists" {
            Write-Verbose "DestinationPath: '$DestinationPath' doesn't exist on the machine"
        }
    }

    $ensure = "Absent"
    if ($fileExists)
    {
        $ensure = "Present"
    }

    $returnValue = @{
        DestinationPath = $DestinationPath
        Ensure = $ensure
    }

    $returnValue
}

# The Set-TargetResource function is used to download file found under Uri location to DestinationPath
# Additional parameters can be specified to configure web request
function Set-TargetResource
{
    [CmdletBinding()]
    param
    (
        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [System.String]
        $DestinationPath,

        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [System.String]
        $Uri,

        [System.String]
        $UserAgent,

        [Microsoft.Management.Infrastructure.CimInstance[]]
        $Headers,

        [System.Management.Automation.PSCredential]
        $Credential
    )

    # Validate Uri
    if (!(Check-UriScheme -uri $Uri -scheme "http") -and !(Check-UriScheme -uri $Uri -scheme "https"))
    {
        $errorId = "UriValidationFailure";
        $errorMessage = $($LocalizedData.InvalidWebUriError) -f ${Uri}
        Throw-InvalidDataException -errorId $errorId -errorMessage $errorMessage
    }

    # Validate DestinationPath scheme
    if (!(Check-UriScheme -uri $DestinationPath -scheme "file"))
    {
        $errorMessage = $($LocalizedData.InvalidDestinationPathSchemeError) -f ${DestinationPath}
        Throw-InvalidDataException -errorId "DestinationPathSchemeValidationFailure" -errorMessage $errorMessage
    }

    # Validate DestinationPath is not UNC path
    if ($DestinationPath.StartsWith("\\"))
    {
        $errorMessage = $($LocalizedData.DestinationPathIsUncError) -f ${DestinationPath}
        Throw-InvalidDataException -errorId "DestinationPathIsUncFailure" -errorMessage $errorMessage
    }

    # Validate DestinationPath does not contain invalid characters
    $invalidCharacters = '*','?','"','<','>','|'
    $invalidCharacters | % {
        if ($DestinationPath.Contains($_) ){
            $errorMessage = $($LocalizedData.DestinationPathHasInvalidCharactersError) -f ${DestinationPath}
            Throw-InvalidDataException -errorId "DestinationPathHasInvalidCharactersError" -errorMessage $errorMessage
        }
    }

    # Validate DestinationPath does not end with / or \ (Invoke-WebRequest requirement)
    if ($DestinationPath.EndsWith('/') -or $DestinationPath.EndsWith('\')){
        $errorMessage = $($LocalizedData.DestinationPathEndsWithInvalidCharacterError) -f ${DestinationPath}
        Throw-InvalidDataException -errorId "DestinationPathEndsWithInvalidCharacterError" -errorMessage $errorMessage
    }

    # Check whether DestinationPath's parent directory exists. Create if it doesn't.
    $destinationPathParent = Split-Path $DestinationPath -Parent
    if (!(Test-Path $destinationPathParent))
    {
        New-Item -Type Directory -Path $destinationPathParent -Force
    }

    # Check whether DestinationPath's leaf is an existing folder
    $uriFileName = Split-Path $Uri -Leaf
    if (Test-Path $DestinationPath -PathType Container)
    {
        $DestinationPath = Join-Path $DestinationPath $uriFileName
    }

    # Remove DestinationPath from parameters as it is not parameter of Invoke-WebRequest
    $PSBoundParameters.Remove("DestinationPath") | Out-Null;

    # Convert headers to hashtable
    $PSBoundParameters.Remove("Headers") | Out-Null;
    $headersHashtable = $null

    if ($Headers -ne $null)
    {
        $headersHashtable = Convert-KeyValuePairArrayToHashtable -array $Headers
    }

    # Invoke web request
    try
    {
        Write-Verbose "Downloading $Uri to $DestinationPath"
        Invoke-WebRequest @PSBoundParameters -Headers $headersHashtable -outFile $DestinationPath
    }
    catch [System.OutOfMemoryException]
    {
        throw "Received OutOfMemoryException. Possible cause is the requested file being too big. $_"
    }
    catch [System.Exception]
    {
        throw "Invoking web request failed with error $($_.Exception.Response.StatusCode.Value__): $($_.Exception.Response.StatusDescription)"
    }

    # Update cache
    if (Test-Path $DestinationPath)
    {
        $downloadedFile = Get-Item $DestinationPath
        $lastWriteTime = $downloadedFile.LastWriteTimeUtc
        $inputObject = @{}
        $inputObject["LastWriteTime"] = $lastWriteTime
        Update-Cache -DestinationPath $DestinationPath -Uri $Uri -InputObject $inputObject
    }
}

# The Test-TargetResource function is used to validate if the DestinationPath exists on the machine.
function Test-TargetResource
{
    [CmdletBinding()]
    [OutputType([System.Boolean])]
    param
    (
        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [System.String]
        $DestinationPath,

        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [System.String]
        $Uri,

        [System.String]
        $UserAgent,

        [Microsoft.Management.Infrastructure.CimInstance[]]
        $Headers,

        [System.Management.Automation.PSCredential]
        $Credential
    )

    # Check whether DestinationPath points to existing file or directory
    $fileExists = $false
    $uriFileName = Split-Path $Uri -Leaf
    $pathItemType = Get-PathItemType -path $DestinationPath
    switch($pathItemType)
    {
        "File" {
            Write-Debug "DestinationPath: '$DestinationPath' is existing file on the machine"

            $file = Get-Item $DestinationPath
            # Getting cache. It's cleared every time user runs Start-DscConfiguration
            $cache = Get-Cache -DestinationPath $DestinationPath -Uri $Uri

            if ($cache -ne $null -and ($cache.LastWriteTime -eq $file.LastWriteTimeUtc))
            {
                Write-Debug "Cache reflects current state. No need for downloading file."
                $fileExists = $true
            }
            else
            {
                Write-Debug "Cache is empty or it doesn't reflect current state. File will be downloaded."
            }
        }

        "Directory" {
            Write-Debug "DestinationPath: '$DestinationPath' is existing directory on the machine"
            $expectedDestinationPath = Join-Path $DestinationPath $uriFileName

            if (Test-Path $expectedDestinationPath) {
                $file = Get-Item $expectedDestinationPath
                $cache = Get-Cache -DestinationPath $expectedDestinationPath -Uri $Uri
                if ($cache -ne $null -and ($cache.LastWriteTime -eq $file.LastWriteTimeUtc))
                {
                    Write-Debug "Cache reflects current state. No need for downloading file."
                    $fileExists = $true
                }
                else
                {
                    Write-Debug "Cache is empty or it doesn't reflect current state. File will be downloaded."
                }
            }
        }

        "Other" {
            Write-Debug "DestinationPath: '$DestinationPath' has unknown type: '$pathItemType'"
        }

        "NotExists" {
            Write-Debug "DestinationPath: '$DestinationPath' doesn't exist on the machine"
        }
    }

    $result = $fileExists

    $result
}

# Throws terminating error of category InvalidData with specified errorId and errorMessage
function Throw-InvalidDataException
{
    param(
        [parameter(Mandatory = $true)]
        [System.String]
        $errorId,
        [parameter(Mandatory = $true)]
        [System.String]
        $errorMessage
    )

    $errorCategory = [System.Management.Automation.ErrorCategory]::InvalidData
    $exception = New-Object System.InvalidOperationException $errorMessage
    $errorRecord = New-Object System.Management.Automation.ErrorRecord $exception, $errorId, $errorCategory, $null
    throw $errorRecord
}

# Checks whether given URI represents specific scheme
# Most common schemes: file, http, https, ftp
# We can also specify logical expressions like: [http|https]
function Check-UriScheme
{
    param (
        [parameter(Mandatory = $true)]
        [System.String]
        $uri,
        [parameter(Mandatory = $true)]
        [System.String]
        $scheme
    )
    $newUri = $uri -as [System.URI]
    $newUri.AbsoluteURI -ne $null -and $newUri.Scheme -match $scheme
}

# Gets type of the item which path points to.
# Returns: File, Directory, Other or NotExists
function Get-PathItemType
{
    param (
        [parameter(Mandatory = $true)]
        [System.String]
        $path
    )

    $type = $null

    # Check whether path exists
    if (Test-Path $path)
    {
        # Check type of the path
        $pathItem = Get-Item $path
        $pathItemType = $pathItem.GetType().Name
        if ($pathItemType -eq "FileInfo")
        {
            $type = "File"
        }
        elseif ($pathItemType -eq "DirectoryInfo")
        {
            $type = "Directory"
        }
        else
        {
            $type = "Other"
        }
    }
    else
    {
        $type = "NotExists"
    }

    return $type
}

# Converts CimInstance array of type KeyValuePair to hashtable
function Convert-KeyValuePairArrayToHashtable
{
    param (
        [parameter(Mandatory = $true)]
        [Microsoft.Management.Infrastructure.CimInstance[]]
        $array
    )

    $hashtable = @{}
    foreach($item in $array)
    {
        $hashtable += @{$item.Key = $item.Value}
    }

    return $hashtable
}

# Gets cache for specific DestinationPath and Uri
function Get-Cache
{
    param (
        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [System.String]
        $DestinationPath,

        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [System.String]
        $Uri
    )

    $cacheContent = $null
    $key = Get-CacheKey -DestinationPath $DestinationPath -Uri $Uri
    $path = Join-Path $script:cacheLocation $key

    Write-Debug "Looking for path $path"
    if(!(Test-Path $path))
    {
        Write-Debug "No cache found for DestinationPath = $DestinationPath and Uri = $Uri. CacheKey = $key"
        $cacheContent = $null
    }
    else
    {
        $cacheContent = Import-CliXml $path
        Write-Debug "Found cache for DestinationPath = $DestinationPath and Uri = $Uri. CacheKey = $key"
    }

    return $cacheContent
}

# Creates or updates cache for specific DestinationPath and Uri
function Update-Cache
{
    param (
        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [System.String]
        $DestinationPath,

        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [System.String]
        $Uri,

        [parameter(Mandatory = $true)]
        [Object]
        $InputObject
    )

    $key = Get-CacheKey -DestinationPath $DestinationPath -Uri $Uri
    $path = Join-Path $script:cacheLocation $key

    if(-not (Test-Path $script:cacheLocation))
    {
        mkdir $script:cacheLocation | Out-Null
    }

    Write-Debug "Updating cache for DestinationPath = $DestinationPath and Uri = $Uri. CacheKey = $key"
    Export-CliXml -Path $path -InputObject $InputObject -Force
}

# Returns cache key for given parameters
function Get-CacheKey
{
    param (
        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [System.String]
        $DestinationPath,

        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [System.String]
        $Uri
    )
    $key = [string]::Join("", @($DestinationPath, $Uri)).GetHashCode().ToString()
    return $key
}

Export-ModuleMember -Function *-TargetResource


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Revis. gen. pl. (Leipzig) 3: 448 (1898)

#### Original name
Helotium pullatum W.R. Gerard

### Remarks
null

redpajama_set_name: RedPajamaGithub


text:
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <!-- From: file:/D:/workooad/Move2/Move-and-Move-Alarm/MAMTv1/app/build/intermediates/exploded-aar/com.android.support/appcompat-v7/23.0.1/res/values-w500dp/values-w500dp.xml -->
    <eat-comment/>
    <integer name="abc_max_action_buttons">4</integer>
</resources>


text:
module ApplicationHelper

  def current_user
    @current_user ||= User.find_by_id(session[:user_id]) if session[:user_id]
  end

  def authorize
    unless current_user
      flash[:notice] = "Please log in."
      redirect_to login_path
    end
  end

   def logged_in?
     current_user != nil
   end

end


text:
namespace ps.dmv.infrastructure
{
    using System;
    using System.Collections.Generic;

    public partial class DmvCalculation
    {
        public DmvCalculation()
        {
            this.MobileDeCarList = new HashSet<MobileDeCar>();
        }

        public int Id { get; set; }
        public System.DateTime DateOfCalculation { get; set; }
        public int VehicleTypeId { get; set; }
        public int FuelTypeId { get; set; }
        public short Co2EmissionsValue { get; set; }
        public int EuroExhaustTypeId { get; set; }
        public bool AtLeastEightSeatsVehicle { get; set; }
        public bool DieselParticlesAbove005Limit { get; set; }
        public int EnginePowerKw { get; set; }
        public int EngineDisplacementCcm { get; set; }
        public int EngineTypeId { get; set; }
        public double VehicleValue { get; set; }
        public double BaseTaxRate { get; set; }
        public double BaseTaxRateValue { get; set; }
        public double AdditionalTaxRate { get; set; }
        public double AdditionalTaxRateValue { get; set; }
        public double TaxTotalValue { get; set; }
        public bool IsDeleted { get; set; }
        public string UserId { get; set; }
        public System.DateTime CreatedOn { get; set; }
        public Nullable<int> MobileDeCarId { get; set; }

        public virtual AspNetUsers AspNetUsers { get; set; }
        public virtual EngineType EngineType { get; set; }
        public virtual EuroExhaustType EuroExhaustType { get; set; }
        public virtual FuelType FuelType { get; set; }
        public virtual VehicleType VehicleType { get; set; }
        public virtual ICollection<MobileDeCar> MobileDeCarList { get; set; }
        public virtual MobileDeCar MobileDeCar { get; set; }
    }
}


text:
package androidx.media.filterpacks.performance;

import android.util.Log;
import android.os.SystemClock;

import androidx.media.filterfw.*;

public class ThroughputFilter extends Filter {

    private int mPeriod = 3;
    private long mLastTime = 0;
    private int mTotalFrameCount = 0;
    private int mPeriodFrameCount = 0;

    public ThroughputFilter(MffContext context, String name) {
        super(context, name);
    }

    @Override
    public Signature getSignature() {
        FrameType throughputType = FrameType.single(Throughput.class);
        return new Signature()
            .addInputPort("frame", Signature.PORT_REQUIRED, FrameType.any())
            .addOutputPort("throughput", Signature.PORT_REQUIRED, throughputType)
            .addOutputPort("frame", Signature.PORT_REQUIRED, FrameType.any())
            .addInputPort("period", Signature.PORT_OPTIONAL, FrameType.single(int.class))
            .disallowOtherPorts();
    }

    @Override
    public void onInputPortOpen(InputPort port) {
        if (port.getName().equals("period")) {
            port.bindToFieldNamed("mPeriod");
        } else {
            port.attachToOutputPort(getConnectedOutputPort("frame"));
        }
    }

    @Override
    protected void onOpen() {
        mTotalFrameCount = 0;
        mPeriodFrameCount = 0;
        mLastTime = 0;
    }

    @Override
    protected synchronized void onProcess() {
        Frame inputFrame = getConnectedInputPort("frame").pullFrame();

        // Update stats
        ++mTotalFrameCount;
        ++mPeriodFrameCount;

        // Check clock
        if (mLastTime == 0) {
            mLastTime = SystemClock.elapsedRealtime();
        }
        long curTime = SystemClock.elapsedRealtime();

        // Output throughput info if time period is up
        if ((curTime - mLastTime) >= (mPeriod * 1000)) {
            Log.i("Thru", "It is time!");
            OutputPort tpPort = getConnectedOutputPort("throughput");
            Throughput throughput = new Throughput(mTotalFrameCount,
                                                   mPeriodFrameCount,
                                                   curTime - mLastTime,
                                                   inputFrame.getElementCount());
            FrameValue throughputFrame = tpPort.fetchAvailableFrame(null).asFrameValue();
            throughputFrame.setValue(throughput);
            tpPort.pushFrame(throughputFrame);
            mLastTime = curTime;
            mPeriodFrameCount = 0;
        }

        getConnectedOutputPort("frame").pushFrame(inputFrame);
    }
}


text:
import { StyleSheet } from 'react-native'
import Colors from '../constants/Colors'
import Layout from '../constants/Layout'

const width = Layout.window.width

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: Colors.white,
  },
  imageContainer: {
    justifyContent: 'center',
    alignItems: 'center',
    flex: 1,
    backgroundColor: Colors.white,
    paddingTop: 15,
  },
  pagination: {
    color: Colors.tabIconSelected,
    fontSize: 38,
  },
  fitImageWithSize: {
    height: 200,
    width,
  },
  swiper: {
    position: 'relative',
  },
  mapContainer: {
    borderColor: Colors.grey6,
  },
  map: {
    height: 260,
  },
  titleName: {
    padding: 15,
    color: Colors.darkGrey,
    fontSize: 16,
    textAlign: 'center',
    backgroundColor: Colors.white,
    fontWeight: '500',
    lineHeight: 23,
  },
  toasterContainer: {
    backgroundColor: Colors.gray,
    height: 30,
    margin: 0,
    padding: 0,
    justifyContent: 'center',
    alignItems: 'center',
  },
  toasterText: {
    color: Colors.darkGray,
  },
})

export default styles


text:
var Accessor = (function () {
    function Accessor() {
    }
    return Accessor;
})();

function attr(nameOrMap, value) {
    if (nameOrMap && typeof nameOrMap === "object") {
        // handle map case
        return new Accessor();
    } else {
        // handle string case
        return "s";
    }
}

function attr2(nameOrMap, value) {
    if (nameOrMap && typeof nameOrMap === "object") {
        // handle map case
        return "t";
    } else {
        // handle string case
        return "s";
    }
}

function foo() {
    return "a";
}
;


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <artifactId>com.amazonaws.eclipse.bundles</artifactId>
  <packaging>pom</packaging>

  <parent>
    <groupId>com.amazonaws.eclipse</groupId>
    <artifactId>com.amazonaws.eclipse.root</artifactId>
    <version>1.0.0-SNAPSHOT</version>
  </parent>

  <modules>
    <module>com.amazonaws.eclipse.core</module>
    <module>com.amazonaws.eclipse.sdk.ui</module>
    <module>com.amazonaws.eclipse.ec2</module>
    <module>com.amazonaws.eclipse.dynamodb</module>
    <module>com.amazonaws.eclipse.identitymanagement</module>
    <module>com.amazonaws.eclipse.cloudformation</module>
    <module>com.amazonaws.eclipse.codecommit</module>
    <module>com.amazonaws.eclipse.codedeploy</module>
    <module>com.amazonaws.eclipse.codestar</module>
    <module>com.amazonaws.eclipse.elasticbeanstalk</module>
    <module>com.amazonaws.eclipse.lambda</module>
    <module>com.amazonaws.eclipse.opsworks</module>
    <module>com.amazonaws.eclipse.rds</module>
    <module>com.amazonaws.eclipse.simpledb</module>
  </modules>
</project>


text:
package org.darkstorm.darkbot.minecraftbot.nbt;

import java.io.*;

public class NBTTagFloat extends NBTBase
{
    /** The float value for the tag. */
    public float data;

    public NBTTagFloat(String par1Str)
    {
        super(par1Str);
    }

    public NBTTagFloat(String par1Str, float par2)
    {
        super(par1Str);
        data = par2;
    }

    /**
     * Write the actual data contents of the tag, implemented in NBT extension classes
     */
    void write(DataOutput par1DataOutput) throws IOException
    {
        par1DataOutput.writeFloat(data);
    }

    /**
     * Read the actual data contents of the tag, implemented in NBT extension classes
     */
    void load(DataInput par1DataInput) throws IOException
    {
        data = par1DataInput.readFloat();
    }

    /**
     * Gets the type byte for the tag.
     */
    public byte getId()
    {
        return 5;
    }

    public String toString()
    {
        return (new StringBuilder()).append("").append(data).toString();
    }

    /**
     * Creates a clone of the tag.
     */
    public NBTBase copy()
    {
        return new NBTTagFloat(getName(), data);
    }

    public boolean equals(Object par1Obj)
    {
        if (super.equals(par1Obj))
        {
            NBTTagFloat nbttagfloat = (NBTTagFloat)par1Obj;
            return data == nbttagfloat.data;
        }
        else
        {
            return false;
        }
    }

    public int hashCode()
    {
        return super.hashCode() ^ Float.floatToIntBits(data);
    }
}


text:
package mobi.cangol.mobile.uiframe.demo.fragment;

import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.ListView;
import android.widget.TextView;

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

import mobi.cangol.mobile.base.BaseContentFragment;
import mobi.cangol.mobile.uiframe.demo.R;

public class ListFragment extends BaseContentFragment {
    private ListView mListView;
    private DataAdapter mDataAdapter;
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mDataAdapter=new DataAdapter();
    }
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        super.onCreateView(inflater, container, savedInstanceState);
        return inflater.inflate(R.layout.fragment_list, container, false);
    }

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        findViews(view);
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        initViews(savedInstanceState);
        initData(savedInstanceState);
    }

    @Override
    protected void findViews(View view) {
        this.setTitle(this.getClass().getSimpleName());
        mListView=findViewById(R.id.listView);
        mListView.setAdapter(mDataAdapter);
        mListView .setOnItemClickListener(new AdapterView.OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                String name = (String) parent.getItemAtPosition(position);
                Bundle bundle=new Bundle();
                bundle.putString("flag",name);
                setContentFragment(ItemFragment.class,"ItemFragment_"+name,bundle);
            }
        });
    }

    @Override
    protected void initViews(Bundle savedInstanceState) {
    }

    @Override
    protected void initData(Bundle savedInstanceState) {
        getUiHandler().postDelayed(new Runnable() {
            @Override
            public void run() {
                if(!isEnable())return;
                String[] array=getResources().getStringArray(R.array.sts);
                List<String> temp=new ArrayList<>();
                for (int i = 0; i <array.length ; i++) {
                    temp.add(array[i]);
                }
                mDataAdapter.cleanAddAll(temp);
                Log.d(TAG,"cleanAddAll "+temp.size());
            }
        },3000L);
    }

    private static class DataAdapter extends BaseAdapter {
        private List<String> items;

        DataAdapter() {
            super();
            items = new ArrayList<>();
        }

        DataAdapter(List<String> items) {
            super();
            this.items = items;
        }

        void cleanAddAll(List<String> list) {
            items.clear();
            items.addAll(list);
            this.notifyDataSetChanged();
        }

        @Override
        public int getCount() {
            return items.size();
        }

        @Override
        public Object getItem(int position) {
            return items.get(position);
        }

        @Override
        public long getItemId(int position) {
            return position;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            View view=LayoutInflater.from(parent.getContext()).inflate(android.R.layout.simple_list_item_1, parent, false);
            TextView textView=view.findViewById(android.R.id.text1);
            textView.setText(String.valueOf(getItem(position)));
            return textView;
        }
    }
}