Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   package com.robrua.orianna.api.core;
   
   import java.util.Collection;
   import java.util.List;
   import java.util.Map;
   
Accesses the LoL REST API asynchronously and provides results in easy-to-use Java objects.

Author(s):
Rob Rua (FatalElement - NA) (robrua@alumni.cmu.edu)
  
  public abstract class AsyncRiotAPI {
    

Parameters:
action what to do with the challenger league
queueType the ranked queue type to get the challenger league of
  
      public static void getChallenger(final Action<Leagueactionfinal QueueType queueType) {
          new Thread(new Runnable() {
              @Override
              public void run() {
                  try {
                      action.perform(LeagueAPI.getChallenger(queueType));
                  }
                  catch(final APIException e) {
                      action.handle(e);
                  }
              }
          }).start();
      }

    

Parameters:
action what to do with the champion
ID the ID of the champion to get
  
      public static void getChampion(final Action<Championactionfinal long ID) {
          new Thread(new Runnable() {
              @Override
              public void run() {
                  try {
                      action.perform(StaticDataAPI.getChampion(ID));
                  }
                  catch(final APIException e) {
                      action.handle(e);
                  }
              }
          }).start();
      }

    

Parameters:
action what to do with the champion
name the name of the champion to get
  
      public static void getChampion(final Action<Championactionfinal String name) {
          new Thread(new Runnable() {
              @Override
              public void run() {
                  try {
                      action.perform(StaticDataAPI.getChampion(name));
                  }
                  catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with all the champions
 
     public static void getChampions(final Action<List<Champion>> action) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(StaticDataAPI.getChampions());
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the champions
IDs the IDs of the champions to get
 
     public static void getChampions(final Action<List<Champion>> actionfinal List<LongIDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(StaticDataAPI.getChampions(IDs));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the champions
IDs the IDs of the champions to get
 
     public static void getChampions(final Action<List<Champion>> actionfinal long... IDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(StaticDataAPI.getChampions(IDs));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the champion's status
champion the champion to get status for
 
     public static void getChampionStatus(final Action<ChampionStatusactionfinal Champion champion) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(ChampionAPI.getChampionStatus(champion));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the champion's status
ID the ID of the champion to get status for
 
     public static void getChampionStatus(final Action<ChampionStatusactionfinal long ID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(ChampionAPI.getChampionStatus(ID));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the champions' statuses
IDs the IDs of the champions to get statuses for
 
     public static void getChampionStatuses(final Action<List<ChampionStatus>> actionfinal List<LongIDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(ChampionAPI.getChampionStatuses(IDs));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the champions' statuses
IDs the IDs of the champions to get statuses for
 
     public static void getChampionStatuses(final Action<List<ChampionStatus>> actionfinal long... IDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(ChampionAPI.getChampionStatuses(IDs));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with all champion's statuses
 
     public static void getChampionStatuses(final Action<Map<ChampionChampionStatus>> action) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(ChampionAPI.getChampionStatuses());
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with all (possibly only free to play) champion's statuses
freeToPlay whether to only get free to play champions
 
     public static void getChampionStatuses(final Action<Map<ChampionChampionStatus>> actionfinal boolean freeToPlay) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(ChampionAPI.getChampionStatuses(freeToPlay));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoner's current game or null if they aren't in one
summonerID the ID of the summoner to get current game for
 
     public static void getCurrentGame(final Action<CurrentGameactionfinal long summonerID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(CurrentGameAPI.getCurrentGame(summonerID));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoner's current game or null if they aren't in one
summonerName the name of the summoner to get current game for
 
     public static void getCurrentGame(final Action<CurrentGameactionfinal String summonerName) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(CurrentGameAPI.getCurrentGame(summonerName));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoner's current game or null if they aren't in one
summoner the summoner to get current game for
 
     public static void getCurrentGame(final Action<CurrentGameactionfinal Summoner summoner) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(CurrentGameAPI.getCurrentGame(summoner));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the current featured games
 
     public static void getFeaturedGames(final Action<List<CurrentGame>> action) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(FeaturedGamesAPI.getFeaturedGames());
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the item
ID the ID of the item to get
 
     public static void getItem(final Action<Itemactionfinal long ID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(StaticDataAPI.getItem(ID));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with all the items
 
     public static void getItems(final Action<List<Item>> action) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(StaticDataAPI.getItems());
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the items
IDs the IDs of the items to get
 
     public static void getItems(final Action<List<Item>> actionfinal List<LongIDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(StaticDataAPI.getItems(IDs));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the items
IDs the IDs of the items to get
 
     public static void getItems(final Action<List<Item>> actionfinal long... IDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(StaticDataAPI.getItems(IDs));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the languages
 
     public static void getLanguages(final Action<List<String>> action) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(StaticDataAPI.getLanguages());
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the language strings
 
     public static void getLanguageStrings(final Action<Map<StringString>> action) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(StaticDataAPI.getLanguageStrings());
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoner's league entries
summoner the summoner to get league entries for
 
     public static void getLeagueEntriesBySummoner(final Action<List<League>> actionfinal Summoner summoner) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesBySummoner(summoner));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoners' league entries
summoners the summoners to get league entries for
 
     public static void getLeagueEntriesBySummoner(final Action<List<List<League>>> actionfinal List<Summonersummoners) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesBySummoner(summoners));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoners' league entries
summoners the summoners to get league entries for
 
     public static void getLeagueEntriesBySummoner(final Action<List<List<League>>> actionfinal Summoner... summoners) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesBySummoner(summoners));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoner's league entries
summonerID the ID of the summoner to get league entries for
 
     public static void getLeagueEntriesBySummonerID(final Action<List<League>> actionfinal long summonerID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesBySummonerID(summonerID));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoners' league entries
summonerIDs the IDs of the summoners to get league entries for
 
     public static void getLeagueEntriesBySummonerID(final Action<List<List<League>>> actionfinal List<LongsummonerIDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesBySummonerID(summonerIDs));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoners' league entries
summonerIDs the IDs of the summoners to get league entries for
 
     public static void getLeagueEntriesBySummonerID(final Action<List<List<League>>> actionfinal long... summonerIDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesBySummonerID(summonerIDs));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoner's league entries
summonerName the name of the summoner to get league entries for
 
     public static void getLeagueEntriesBySummonerName(final Action<List<League>> actionfinal String summonerName) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesBySummonerName(summonerName));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoners' league entries
summonerNames the names of the summoners to get league entries for
 
     public static void getLeagueEntriesBySummonerName(final Action<List<List<League>>> actionfinal List<StringsummonerNames) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesBySummonerName(summonerNames));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoners' league entries
summonerNames the names of the summoners to get league entries for
 
     public static void getLeagueEntriesBySummonerName(final Action<List<List<League>>> actionfinal String... summonerNames) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesBySummonerName(summonerNames));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the team's league entries
team the team to get league entries for
 
     public static void getLeagueEntriesByTeam(final Action<List<League>> actionfinal Team team) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesByTeam(team));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the teams' league entries
teams the teams to get league entries for
 
     public static void getLeagueEntriesByTeam(final Action<List<List<League>>> actionfinal List<Teamteams) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesByTeam(teams));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the teams' league entries
teams the teams to get league entries for
 
     public static void getLeagueEntriesByTeam(final Action<List<List<League>>> actionfinal Team... teams) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesByTeam(teams));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the team's league entries
teamID the ID of the team to get league entries for
 
     public static void getLeagueEntriesByTeamID(final Action<List<League>> actionfinal String teamID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesByTeamID(teamID));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the teams' league entries
teamIDs the IDs of the teams to get league entries for
 
     public static void getLeagueEntriesByTeamID(final Action<List<List<League>>> actionfinal List<StringteamIDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesByTeamID(teamIDs));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the teams' league entries
teamIDs the IDs of the teams to get league entries for
 
     public static void getLeagueEntriesByTeamID(final Action<List<List<League>>> actionfinal String... teamIDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeagueEntriesByTeamID(teamIDs));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoner's leagues
summoner the summoner to get leagues for
 
     public static void getLeaguesBySummoner(final Action<List<League>> actionfinal Summoner summoner) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeaguesBySummoner(summoner));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoners' leagues
summoners the summoners to get leagues for
 
     public static void getLeaguesBySummoner(final Action<List<List<League>>> actionfinal List<Summonersummoners) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeaguesBySummoner(summoners));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoners' leagues
summoners the summoners to get leagues for
 
     public static void getLeaguesBySummoner(final Action<List<List<League>>> actionfinal Summoner... summoners) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeaguesBySummoner(summoners));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoner's leagues
summonerID the ID of the summoner to get leagues for
 
     public static void getLeaguesBySummonerID(final Action<List<League>> actionfinal long summonerID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeaguesBySummonerID(summonerID));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoners' leagues
summonerIDs the IDs of the summoners to get leagues for
 
     public static void getLeaguesBySummonerID(final Action<List<List<League>>> actionfinal List<LongsummonerIDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeaguesBySummonerID(summonerIDs));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoners' leagues
summonerIDs the IDs of the summoners to get leagues for
 
     public static void getLeaguesBySummonerID(final Action<List<List<League>>> actionfinal long... summonerIDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeaguesBySummonerID(summonerIDs));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoner's leagues
summonerName the name of the summoner to get leagues for
 
     public static void getLeaguesBySummonerName(final Action<List<League>> actionfinal String summonerName) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeaguesBySummonerName(summonerName));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoners' leagues
summonerNames the names of the summoners to get leagues for
 
     public static void getLeaguesBySummonerName(final Action<List<List<League>>> actionfinal List<StringsummonerNames) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeaguesBySummonerName(summonerNames));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoners' leagues
summonerNames the names of the summoners to get leagues for
 
     public static void getLeaguesBySummonerName(final Action<List<List<League>>> actionfinal String... summonerNames) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeaguesBySummonerName(summonerNames));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the team's leagues
team the team to get leagues for
 
     public static void getLeaguesByTeam(final Action<List<League>> actionfinal Team team) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeaguesByTeam(team));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the teams' leagues
teams the teams to get leagues for
 
     public static void getLeaguesByTeam(final Action<List<List<League>>> actionfinal List<Teamteams) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     action.perform(LeagueAPI.getLeaguesByTeam(teams));
                 }
                 catch(final APIException e) {
                     action.handle(e);
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the teams' leagues
teams the teams to get leagues for
    public static void getLeaguesByTeam(final Action<List<List<League>>> actionfinal Team... teams) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(LeagueAPI.getLeaguesByTeam(teams));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the team's leagues
teamID the ID of the team to get leagues for
    public static void getLeaguesByTeamID(final Action<List<League>> actionfinal String teamID) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(LeagueAPI.getLeaguesByTeamID(teamID));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the teams' leagues
teamIDs the IDs of the teams to get leagues for
    public static void getLeaguesByTeamID(final Action<List<List<League>>> actionfinal List<StringteamIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(LeagueAPI.getLeaguesByTeamID(teamIDs));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the teams' leagues
teamIDs the IDs of the teams to get leagues for
    public static void getLeaguesByTeamID(final Action<List<List<League>>> actionfinal String... teamIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(LeagueAPI.getLeaguesByTeamID(teamIDs));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with information for the maps
    public static void getMapInformation(final Action<List<MapDetails>> action) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(StaticDataAPI.getMapInformation());
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with all the masteries
    public static void getMasteries(final Action<List<Mastery>> action) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(StaticDataAPI.getMasteries());
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the masteries
IDs the IDs of the masteries to get
    public static void getMasteries(final Action<List<Mastery>> actionfinal List<LongIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(StaticDataAPI.getMasteries(IDs));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the masteries
IDs the IDs of the masteries to get
    public static void getMasteries(final Action<List<Mastery>> actionfinal long... IDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(StaticDataAPI.getMasteries(IDs));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the mastery
ID the ID of the mastery to get
    public static void getMastery(final Action<Masteryactionfinal long ID) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(StaticDataAPI.getMastery(ID));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }
    public static void getMasteryByID(final Action<Masteryactionfinal long ID) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(null);
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' mastery pages
summoners the summoners to get mastery pages for
    public static void getMasteryPages(final Action<List<List<MasteryPage>>> actionfinal List<Summonersummoners) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(SummonerAPI.getMasteryPages(summoners));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' mastery pages
summoners the summoners to get mastery pages for
    public static void getMasteryPages(final Action<List<List<MasteryPage>>> actionfinal Summoner... summoners) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(SummonerAPI.getMasteryPages(summoners));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoner's mastery pages
summoner the summoner to get mastery pages for
    public static void getMasteryPages(final Action<List<MasteryPage>> actionfinal Summoner summoner) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(SummonerAPI.getMasteryPages(summoner));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' mastery pages
summonerIDs the IDs of the summoners to get mastery pages for
    public static void getMasteryPagesByID(final Action<List<List<MasteryPage>>> actionfinal List<LongsummonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(SummonerAPI.getMasteryPagesByID(summonerIDs));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' mastery pages
summonerIDs the IDs of the summoners to get mastery pages for
    public static void getMasteryPagesByID(final Action<List<List<MasteryPage>>> actionfinal long... summonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(SummonerAPI.getMasteryPagesByID(summonerIDs));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoner's mastery pages
summonerID the ID of the summoner to get mastery pages for
    public static void getMasteryPagesByID(final Action<List<MasteryPage>> actionfinal long summonerID) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(SummonerAPI.getMasteryPagesByID(summonerID));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' mastery pages
summonerNames the names of the summoners to get mastery pages for
    public static void getMasteryPagesByName(final Action<List<List<MasteryPage>>> actionfinal List<StringsummonerNames) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(SummonerAPI.getMasteryPagesByName(summonerNames));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' mastery pages
summonerNames the names of the summoners to get mastery pages for
    public static void getMasteryPagesByName(final Action<List<List<MasteryPage>>> actionfinal String... summonerNames) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(SummonerAPI.getMasteryPagesByName(summonerNames));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoner's mastery pages
summonerName the name of the summoner to get mastery pages for
    public static void getMasteryPagesByName(final Action<List<MasteryPage>> actionfinal String summonerName) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(SummonerAPI.getMasteryPagesByName(summonerName));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the match
ID the ID of the match to get
    public static void getMatch(final Action<Matchactionfinal long ID) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(MatchAPI.getMatch(ID));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the 15 most recent matches for the summoner
summonerID the summoner to get match history for
    public static void getMatchHistory(final Action<List<MatchSummary>> actionfinal long summonerID) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(MatchHistoryAPI.getMatchHistory(summonerID));
                }
   &nbs