Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.robrua.orianna.api.core;
  
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
 import java.util.Set;
 
 
 public abstract class StaticDataAPI {
     private static Set<LongIGNORE_ITEMS = new HashSet<>(Arrays.asList(new Long[] {0L, 1080L, 2037L, 2039L, 2040L, 3005L, 3039L, 3123L, 3128L, 3131L, 3160L,
             3166L, 3167L, 3168L, 3169L, 3175L, 3176L, 3171L, 3186L, 3188L, 3205L, 3206L, 3207L, 3209L, 3210L, 3405L, 3406L, 3407L, 3408L, 3409L, 3410L, 3411L,
             3412L, 3413L, 3414L, 3415L, 3416L, 3417L, 3419L, 3420L}));
     private static Set<LongIGNORE_RUNES = new HashSet<>(Arrays.asList(new Long[] {8028L}));
     private static Set<LongIGNORE_SPELLS = new HashSet<>(Arrays.asList(new Long[] {10L}));

    

Parameters:
ID the ID of the champion to get
Returns:
the champion
 
     public synchronized static Champion getChampionByID(final long ID) {
         Champion champion = ..get(Champion.class, (int)ID);
         if(champion != null) {
             return champion;
         }
 
         final com.robrua.orianna.type.dto.staticdata.Champion champ = BaseRiotAPI.getChampion(ID);
         if(champ == null) {
             return null;
         }
         champion = new Champion(champ);
 
         if(. == .) {
             RiotAPI.getItems(new ArrayList<>(champ.getItemIDs()));
         }
 
         ..store(champion, (int)ID);
 
         return champion;
     }

    

Parameters:
name the name of the champion to get
Returns:
the champion
 
     public static Champion getChampionByName(final String name) {
         final List<Championchampions = getChampions();
         for(final Champion champion : champions) {
             if(champion.getName().equals(name)) {
                 return champion;
             }
         }
 
         return null;
     }

    

Returns:
all the champions
 
     public synchronized static List<ChampiongetChampions() {
         if(..hasAll(Champion.class)) {
             return ..getAll(Champion.class);
         }
 
         final ChampionList champs = BaseRiotAPI.getChampions();
 
         final List<Championchampions = new ArrayList<>(champs.getData().size());
         final List<LongIDs = new ArrayList<>(champions.size());
         for(final com.robrua.orianna.type.dto.staticdata.Champion champ : champs.getData().values()) {
             champions.add(new Champion(champ));
             IDs.add(champ.getId().longValue());
         }
 
         if(. == .) {
             RiotAPI.getItems(new ArrayList<>(champs.getItemIDs()));
         }
 
         ..store(champions, Utils.toIntegers(IDs), true);
        return Collections.unmodifiableList(champions);
    }

    

Parameters:
IDs the IDs of the champions to get
Returns:
the champions
    public synchronized static List<ChampiongetChampionsByID(final List<LongIDs) {
        if(IDs.isEmpty()) {
            return Collections.emptyList();
        }
        final List<Championchampions = ..get(Champion.class, Utils.toIntegers(IDs));
        final List<LongtoGet = new ArrayList<>();
        final List<Integerindex = new ArrayList<>();
        for(int i = 0; i < IDs.size(); i++) {
            if(champions.get(i) == null) {
                toGet.add(IDs.get(i));
                index.add(i);
            }
        }
        if(toGet.isEmpty()) {
            return champions;
        }
        if(toGet.size() == 1) {
            champions.set(index.get(0), getChampionByID(toGet.get(0)));
            return champions;
        }
        getChampions();
        final List<Championgotten = ..get(Champion.class, Utils.toIntegers(toGet));
        int count = 0;
        for(final Integer id : index) {
            champions.set(idgotten.get(count++));
        }
        return Collections.unmodifiableList(champions);
    }

    

Parameters:
IDs the IDs of the champions to get
Returns:
the champions
    public static List<ChampiongetChampionsByID(final long... IDs) {
        return getChampionsByID(Utils.convert(IDs));
    }

    

Parameters:
names the names of the champions to get
Returns:
the champions
    public static List<ChampiongetChampionsByName(final List<Stringnames) {
        final Map<StringIntegerindices = new HashMap<>();
        final List<Championresult = new ArrayList<>(names.size());
        int i = 0;
        for(final String name : names) {
            indices.put(namei++);
            result.add(null);
        }
        final List<Championchampions = getChampions();
        for(final Champion champ : champions) {
            final Integer index = indices.get(champ.getName());
            if(index != null) {
                result.set(indexchamp);
            }
        }
        return result;
    }

    

Parameters:
names the names of the champions to get
Returns:
the champions
    public static List<ChampiongetChampionsByName(final String... names) {
        return getChampionsByName(Arrays.asList(names));
    }

    

Parameters:
ID the ID of the item to get
Returns:
the item
    public synchronized static Item getItem(final long ID) {
        if(.contains(ID)) {
            return null;
        }
        Item item = ..get(Item.class, (int)ID);
        if(item != null) {
            return item;
        }
        final com.robrua.orianna.type.dto.staticdata.Item it = BaseRiotAPI.getItem(ID);
        item = new Item(it);
        ..store(item, (int)ID);
        return item;
    }

    

Returns:
all the items
    public synchronized static List<ItemgetItems() {
        if(..hasAll(Item.class)) {
            return ..getAll(Item.class);
        }
        final ItemList its = BaseRiotAPI.getItems();
        final List<Itemitems = new ArrayList<>(its.getData().size());
        final List<LongIDs = new ArrayList<>(items.size());
        for(final com.robrua.orianna.type.dto.staticdata.Item item : its.getData().values()) {
            items.add(new Item(item));
            IDs.add(item.getId().longValue());
        }
        ..store(items, Utils.toIntegers(IDs), true);
        return Collections.unmodifiableList(items);
    }

    

Parameters:
IDs the IDs of the items to get
Returns:
the items
    public synchronized static List<ItemgetItems(final List<LongIDs) {
        if(IDs.isEmpty()) {
            return Collections.emptyList();
        }
        final List<Itemitems = ..get(Item.class, Utils.toIntegers(IDs));
        final List<LongtoGet = new ArrayList<>();
        final List<Integerindex = new ArrayList<>();
        for(int i = 0; i < IDs.size(); i++) {
            if(items.get(i) == null && !.contains(IDs.get(i))) {
                toGet.add(IDs.get(i));
                index.add(i);
            }
        }
        if(toGet.isEmpty()) {
            return items;
        }
        if(toGet.size() == 1) {
            items.set(index.get(0), getItem(toGet.get(0)));
            return items;
        }
        getItems();
        final List<Itemgotten = ..get(Item.class, Utils.toIntegers(toGet));
        int count = 0;
        for(final Integer id : index) {
            items.add(idgotten.get(count++));
        }
        return Collections.unmodifiableList(items);
    }

    

Parameters:
IDs the IDs of the items to get
Returns:
the items
    public static List<ItemgetItems(final long... IDs) {
        return getItems(Utils.convert(IDs));
    }

    

Returns:
the languages
    public static List<StringgetLanguages() {
        return BaseRiotAPI.getLanguages();
    }

    

Returns:
the language strings
    public static Map<StringStringgetLanguageStrings() {
        final com.robrua.orianna.type.dto.staticdata.LanguageStrings str = BaseRiotAPI.getLanguageStrings();
        return str.getData();
    }

    

Returns:
information for the maps
    public synchronized static List<MapDetailsgetMapInformation() {
        if(..hasAll(MapDetails.class)) {
            return ..getAll(MapDetails.class);
        }
        final MapData inf = BaseRiotAPI.getMapInformation();
        final List<MapDetailsinfo = new ArrayList<>(inf.getData().size());
        final List<LongIDs = new ArrayList<>(info.size());
        for(final com.robrua.orianna.type.dto.staticdata.MapDetails map : inf.getData().values()) {
            info.add(new MapDetails(map));
            IDs.add(map.getMapId().longValue());
        }
        ..store(info, Utils.toIntegers(IDs), true);
        return Collections.unmodifiableList(info);
    }

    

Returns:
all the masteries
    public synchronized static List<MasterygetMasteries() {
        if(..hasAll(Mastery.class)) {
            return ..getAll(Mastery.class);
        }
        final MasteryList its = BaseRiotAPI.getMasteries();
        final List<Masterymasteries = new ArrayList<>(its.getData().size());
        final List<LongIDs = new ArrayList<>(masteries.size());
        for(final com.robrua.orianna.type.dto.staticdata.Mastery mastery : its.getData().values()) {
            masteries.add(new Mastery(mastery));
            IDs.add(mastery.getId().longValue());
        }
        ..store(masteries, Utils.toIntegers(IDs), true);
        return Collections.unmodifiableList(masteries);
    }

    

Parameters:
IDs the IDs of the masteries to get
Returns:
the masteries
    public synchronized static List<MasterygetMasteries(final List<LongIDs) {
        if(IDs.isEmpty()) {
            return Collections.emptyList();
        }
        final List<Masterymasteries = ..get(Mastery.class, Utils.toIntegers(IDs));
        final List<LongtoGet = new ArrayList<>();
        final List<Integerindex = new ArrayList<>();
        for(int i = 0; i < IDs.size(); i++) {
            if(masteries.get(i) == null) {
                toGet.add(IDs.get(i));
                index.add(i);
            }
        }
        if(toGet.isEmpty()) {
            return masteries;
        }
        if(toGet.size() == 1) {
            masteries.set(index.get(0), getMastery(toGet.get(0)));
            return masteries;
        }
        getMasteries();
        final List<Masterygotten = ..get(Mastery.class, Utils.toIntegers(toGet));
        int count = 0;
        for(final Integer id : index) {
            masteries.set(idgotten.get(count++));
        }
        return Collections.unmodifiableList(masteries);
    }

    

Parameters:
IDs the IDs of the masteries to get
Returns:
the masteries
    public static List<MasterygetMasteries(final long... IDs) {
        return getMasteries(Utils.convert(IDs));
    }

    

Parameters:
ID the ID of the mastery to get
Returns:
the mastery
    public synchronized static Mastery getMastery(final long ID) {
        Mastery mastery = ..get(Mastery.class, (int)ID);
        if(mastery != null) {
            return mastery;
        }
        final com.robrua.orianna.type.dto.staticdata.Mastery mast = BaseRiotAPI.getMastery(ID);
        mastery = new Mastery(mast);
        ..store(mastery, (int)ID);
        return mastery;
    }

    

Returns:
the realm
    public synchronized static Realm getRealm() {
        Realm realm = ..get(Realm.class, 0L);
        if(realm != null) {
            return realm;
        }
        realm = new Realm(BaseRiotAPI.getRealm());
        ..store(realm, 0);
        return realm;
    }

    

Parameters:
ID the ID of the rune to get
Returns:
the rune
    public synchronized static Rune getRune(final long ID) {
        if(.contains(ID)) {
            return null;
        }
        Rune rune = ..get(Rune.class, (int)ID);
        if(rune != null) {
            return rune;
        }
        final com.robrua.orianna.type.dto.staticdata.Rune run = BaseRiotAPI.getRune(ID);
        rune = new Rune(run);
        ..store(rune, (int)ID);
        return rune;
    }

    

Returns:
all the runes
    public synchronized static List<RunegetRunes() {
        if(..hasAll(Rune.class)) {
            return ..getAll(Rune.class);
        }
        final RuneList its = BaseRiotAPI.getRunes();
        final List<Runerunes = new ArrayList<>(its.getData().size());
        final List<LongIDs = new ArrayList<>(runes.size());
        for(final com.robrua.orianna.type.dto.staticdata.Rune rune : its.getData().values()) {
            runes.add(new Rune(rune));
            IDs.add(rune.getId().longValue());
        }
        ..store(runes, Utils.toIntegers(IDs), true);
        return Collections.unmodifiableList(runes);
    }

    

Parameters:
IDs the IDs of the runes to get
Returns:
the runes
    public synchronized static List<RunegetRunes(final List<LongIDs) {
        if(IDs.isEmpty()) {
            return Collections.emptyList();
        }
        final List<Runerunes = ..get(Rune.class, Utils.toIntegers(IDs));
        final List<LongtoGet = new ArrayList<>();
        final List<Integerindex = new ArrayList<>();
        for(int i = 0; i < IDs.size(); i++) {
            if(runes.get(i) == null && !.contains(IDs.get(i))) {
                toGet.add(IDs.get(i));
                index.add(i);
            }
        }
        if(toGet.isEmpty()) {
            return runes;
        }
        if(toGet.size() == 1) {
            runes.set(index.get(0), getRune(toGet.get(0)));
            return runes;
        }
        getRunes();
        final List<Runegotten = ..get(Rune.class, Utils.toIntegers(toGet));
        int count = 0;
        for(final Integer id : index) {
            runes.set(idgotten.get(count++));
        }
        return Collections.unmodifiableList(runes);
    }

    

Parameters:
IDs the IDs of the runes to get
Returns:
the runes
    public static List<RunegetRunes(final long... IDs) {
        return getRunes(Utils.convert(IDs));
    }

    

Parameters:
ID the ID of the summoner spell to get
Returns:
the summoner spell
    public synchronized static SummonerSpell getSummonerSpell(final long ID) {
        if(.contains(ID)) {
            return null;
        }
        SummonerSpell spell = ..get(SummonerSpell.class, (int)ID);
        if(spell != null) {
            return spell;
        }
        final com.robrua.orianna.type.dto.staticdata.SummonerSpell spl = BaseRiotAPI.getSummonerSpell(ID);
        spell = new SummonerSpell(spl);
        ..store(spell, (int)ID);
        return spell;
    }

    

Returns:
all the summoner spells
    public synchronized static List<SummonerSpellgetSummonerSpells() {
        if(..hasAll(SummonerSpell.class)) {
            return ..getAll(SummonerSpell.class);
        }
        final SummonerSpellList its = BaseRiotAPI.getSummonerSpells();
        final List<SummonerSpellspells = new ArrayList<>(its.getData().size());
        final List<LongIDs = new ArrayList<>(spells.size());
        for(final com.robrua.orianna.type.dto.staticdata.SummonerSpell spell : its.getData().values()) {
            spells.add(new SummonerSpell(spell));
            IDs.add(spell.getId().longValue());
        }
        ..store(spells, Utils.toIntegers(IDs), true);
        return Collections.unmodifiableList(spells);
    }

    

Parameters:
IDs the IDs of the summoner spells to get
Returns:
the summoner spells
    public synchronized static List<SummonerSpellgetSummonerSpells(final List<LongIDs) {
        if(IDs.isEmpty()) {
            return Collections.emptyList();
        }
        final List<SummonerSpellspells = ..get(SummonerSpell.class, Utils.toIntegers(IDs));
        final List<LongtoGet = new ArrayList<>();
        final List<Integerindex = new ArrayList<>();
        for(int i = 0; i < IDs.size(); i++) {
            if(spells.get(i) == null && !.contains(IDs.get(i))) {
                toGet.add(IDs.get(i));
                index.add(i);
            }
        }
        if(toGet.isEmpty()) {
            return spells;
        }
        if(toGet.size() == 1) {
            spells.set(index.get(0), getSummonerSpell(toGet.get(0)));
            return spells;
        }
        getSummonerSpells();
        final List<SummonerSpellgotten = ..get(SummonerSpell.class, Utils.toIntegers(toGet));
        int count = 0;
        for(final Integer id : index) {
            spells.set(idgotten.get(count++));
        }
        return Collections.unmodifiableList(spells);
    }

    

Parameters:
IDs the IDs of the summoner spells to get
Returns:
the summoner spells
    public static List<SummonerSpellgetSummonerSpells(final long... IDs) {
        return getSummonerSpells(Utils.convert(IDs));
    }

    

Returns:
the versions
    public static List<StringgetVersions() {
        return BaseRiotAPI.getVersions();
    }
New to GrepCode? Check out our FAQ X