Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.robrua.orianna.type.core.game;
  
  import java.util.List;
  
 
 public class RawStats extends OriannaObject<com.robrua.orianna.type.dto.game.RawStats> {
     private static final long serialVersionUID = -8317184539839181991L;
     private Item item0item1item2item3item4item5item6;

    

Parameters:
data the underlying dto
 
     public RawStats(final com.robrua.orianna.type.dto.game.RawStats data) {
         super(datacom.robrua.orianna.type.dto.game.RawStats.class);
     }

    
Assists

Returns:
assists
 
     public int getAssists() {
         return super.getInteger(.getAssists());
     }

    
Number of enemy inhibitors killed

Returns:
number of enemy inhibitors killed
 
     public int getBarracksKilled() {
         return super.getInteger(.getBarracksKilled());
     }

    
Combat player score

Returns:
combat player score
 
     public int getCombatPlayerScore() {
         return super.getInteger(.getCombatPlayerScore());
     }

    
Consumables purchased

Returns:
consumables purchased
 
     public int getConsumablesPurchased() {
         return super.getInteger(.getConsumablesPurchased());
     }

    
Damage dealt player

Returns:
damage dealt player
 
     public int getDamageDealtPlayer() {
         return super.getInteger(.getDamageDealtPlayer());
     }

    
Deaths

Returns:
deaths
 
     public int getDeaths() {
         return super.getInteger(.getNumDeaths());
     }

    
Double kills

Returns:
double kills
 
     public int getDoubleKills() {
         return super.getInteger(.getDoubleKills());
     }

    
First blood

Returns:
first blood
 
     public boolean getFirstBlood() {
         return super.getInteger(.getFirstBlood()) == 1;
     }

    
Gold at end of game

Returns:
gold at end of game
    public int getGold() {
        return super.getInteger(.getGold());
    }

    
Gold earned

Returns:
gold earned
    public int getGoldEarned() {
        return super.getInteger(.getGoldEarned());
    }

    
Gold spent

Returns:
gold spent
    public int getGoldSpent() {
        return super.getInteger(.getGoldSpent());
    }

    
Item 0

Returns:
item 0
    public Item getItem0() {
        if( != null) {
            return ;
        }
        final Integer i = .getItem0();
        if(i == null) {
            throw new MissingDataException("Item #0 ID is null.");
        }
         = RiotAPI.getItem(i.longValue());
        return ;
    }

    
Item 0 ID

Returns:
item 0
    public long getItem0ID() {
        return super.getInteger(.getItem0());
    }

    
Item 1

Returns:
item 1
    public Item getItem1() {
        if( != null) {
            return ;
        }
        final Integer i = .getItem1();
        if(i == null) {
            throw new MissingDataException("Item #1 ID is null.");
        }
         = RiotAPI.getItem(i.longValue());
        return ;
    }

    
Item 1 ID

Returns:
item 1 ID
    public long getItem1ID() {
        return super.getInteger(.getItem1());
    }

    
Item 2

Returns:
item 2
    public Item getItem2() {
        if( != null) {
            return ;
        }
        final Integer i = .getItem2();
        if(i == null) {
            throw new MissingDataException("Item #2 ID is null.");
        }
         = RiotAPI.getItem(i.longValue());
        return ;
    }

    
Item 2 ID

Returns:
item 2 ID
    public long getItem2ID() {
        return super.getInteger(.getItem2());
    }

    
Item 3

Returns:
item 3
    public Item getItem3() {
        if( != null) {
            return ;
        }
        final Integer i = .getItem3();
        if(i == null) {
            throw new MissingDataException("Item #3 ID is null.");
        }
         = RiotAPI.getItem(i.longValue());
        return ;
    }

    
Item 3 ID

Returns:
item 3 ID
    public long getItem3ID() {
        return super.getInteger(.getItem3());
    }

    
Item 4

Returns:
item 4
    public Item getItem4() {
        if( != null) {
            return ;
        }
        final Integer i = .getItem4();
        if(i == null) {
            throw new MissingDataException("Item #4 ID is null.");
        }
         = RiotAPI.getItem(i.longValue());
        return ;
    }

    
Item 4 ID

Returns:
item 4 ID
    public long getItem4ID() {
        return super.getInteger(.getItem4());
    }

    
Item 5

Returns:
item 5
    public Item getItem5() {
        if( != null) {
            return ;
        }
        final Integer i = .getItem5();
        if(i == null) {
            throw new MissingDataException("Item #5 ID is null.");
        }
         = RiotAPI.getItem(i.longValue());
        return ;
    }

    
Item 5 ID

Returns:
item 5 ID
    public long getItem5ID() {
        return super.getInteger(.getItem5());
    }

    
Item 6

Returns:
item 6
    public Item getItem6() {
        if( != null) {
            return ;
        }
        final Integer i = .getItem6();
        if(i == null) {
            throw new MissingDataException("Item #6 ID is null.");
        }
         = RiotAPI.getItem(i.longValue());
        return ;
    }

    
Item 6 ID

Returns:
item 6 ID
    public long getItem6ID() {
        return super.getInteger(.getItem6());
    }

    
All items

Returns:
all items
    public List<ItemgetItems() {
        final List<Itemitems = new ArrayList<>(7);
        final List<LongtoLoad = new ArrayList<>(7);
        if( != null) {
            items.add(0, );
        }
        else {
            final Integer i = .getItem0();
            if(i == null) {
                throw new MissingDataException("Item #0 ID is null.");
            }
            toLoad.add(i.longValue());
        }
        if( != null) {
            items.add(1, );
        }
        else {
            final Integer i = .getItem1();
            if(i == null) {
                throw new MissingDataException("Item #1 ID is null.");
            }
            toLoad.add(i.longValue());
        }
        if( != null) {
            items.add(2, );
        }
        else {
            final Integer i = .getItem2();
            if(i == null) {
                throw new MissingDataException("Item #2 ID is null.");
            }
            toLoad.add(i.longValue());
        }
        if( != null) {
            items.add(3, );
        }
        else {
            final Integer i = .getItem3();
            if(i == null) {
                throw new MissingDataException("Item #3 ID is null.");
            }
            toLoad.add(i.longValue());
        }
        if( != null) {
            items.add(4, );
        }
        else {
            final Integer i = .getItem4();
            if(i == null) {
                throw new MissingDataException("Item #4 ID is null.");
            }
            toLoad.add(i.longValue());
        }
        if( != null) {
            items.add(5, );
        }
        else {
            final Integer i = .getItem5();
            if(i == null) {
                throw new MissingDataException("Item #5 ID is null.");
            }
            toLoad.add(i.longValue());
        }
        if( != null) {
            items.add(6, );
        }
        else {
            final Integer i = .getItem6();
            if(i == null) {
                throw new MissingDataException("Item #6 ID is null.");
            }
            toLoad.add(i.longValue());
        }
        if(toLoad.isEmpty()) {
            return Collections.unmodifiableList(items);
        }
        final List<ItemnewItems = RiotAPI.getItems(toLoad);
        for(final Item item : newItems) {
            final int index = items.indexOf(null);
            items.add(indexitem);
        }
        return Collections.unmodifiableList(items);
    }

    
Items bought

Returns:
items bought
    public int getItemsBought() {
        return super.getInteger(.getNumItemsBought());
    }

    
Items purchased

Returns:
items purchased
    public int getItemsPurchased() {
        return super.getInteger(.getItemsPurchased());
    }

    
Killing sprees

Returns:
killing sprees
    public int getKillingSprees() {
        return super.getInteger(.getKillingSprees());
    }

    
Champions killed

Returns:
champions killed
    public int getKills() {
        return super.getInteger(.getChampionsKilled());
    }

    
Largest critical strike

Returns:
largest critial strike
    public int getLargestCriticalStrike() {
        return super.getInteger(.getLargestCriticalStrike());
    }

    
Largest killing spree

Returns:
largest killing spree
    public int getLargestKillingSpree() {
        return super.getInteger(.getLargestKillingSpree());
    }

    
Largest multi kill

Returns:
largest multi kill
    public int getLargestMultiKill() {
        return super.getInteger(.getLargestMultiKill());
    }

    
Number of tier 3 items built

Returns:
number of tier 3 items built
    public int getLegendaryItemsCreated() {
        return super.getInteger(.getLegendaryItemsCreated());
    }

    
Level

Returns:
level
    public int getLevel() {
        return super.getInteger(.getLevel());
    }

    
Magic damage dealt player

Returns:
magic damage dealt player
    public int getMagicDamageDealtPlayer() {
        return super.getInteger(.getMagicDamageDealtPlayer());
    }

    
Magic damage dealt to champions

Returns:
magic damage dealt to champions
    public int getMagicDamageDealtToChampions() {
        return super.getInteger(.getMagicDamageDealtToChampions());
    }

    
Magic damage taken

Returns:
magic damage taken
    public int getMagicDamageTaken() {
        return super.getInteger(.getMagicDamageTaken());
    }

    
Minions denied

Returns:
minions denied
    public int getMinionsDenied() {
        return super.getInteger(.getMinionsDenied());
    }

    
Minions killed

Returns:
minions killed
    public int getMinionsKilled() {
        return super.getInteger(.getMinionsKilled());
    }

    
Neutral minions killed

Returns:
neutral minions killed
    public int getNeutralMinionsKilled() {
        return super.getInteger(.getNeutralMinionsKilled());
    }

    
Neutral minions killed inside enemy jungle

Returns:
neutral minions killed inside enemy jungle
    public int getNeutralMinionsKilledEnemyJungle() {
        return super.getInteger(.getNeutralMinionsKilledEnemyJungle());
    }

    
Neutral minions killed inside friendly jungle

Returns:
neutral minions killed inside friendly jungle
    public int getNeutralMinionsKilledYourJungle() {
        return super.getInteger(.getNeutralMinionsKilledYourJungle());
    }

    
Flag specifying if the summoner got the killing blow on the nexus

Returns:
whether the summoner got the killing blow on the nexus
    public boolean getNexusKilled() {
        return super.getBoolean(.getNexusKilled());
    }

    
Node captures assisted

Returns:
node captures assisted
    public int getNodeCaptureAssists() {
        return super.getInteger(.getNodeCaptureAssist());
    }

    
Nodes captured

Returns:
nodes captured
    public int getNodeCaptures() {
        return super.getInteger(.getNodeCapture());
    }

    
Nodes neutralized

Returns:
nodes neutralized
    public int getNodeNeutralizations() {
        return super.getInteger(.getNodeNeutralize());
    }

    
Node neutralizations assisted

Returns:
node neutralizations assisted
    public int getNodeNeutralizeAssists() {
        return super.getInteger(.getNodeNeutralizeAssist());
    }

    
Objective player score

Returns:
objective player score
    public int getObjectivePlayerScore() {
        return super.getInteger(.getObjectivePlayerScore());
    }

    
Penta kills

Returns:
penta kills
    public int getPentaKills() {
        return super.getInteger(.getPentaKills());
    }

    
Physical damage dealt player

Returns:
Physical damage dealt player
    public int getPhysicalDamageDealtPlayer() {
        return super.getInteger(.getPhysicalDamageDealtPlayer());
    }

    
Physical damage dealt to champions

Returns:
physical damage dealt to champions
    public int getPhysicalDamageDealtToChampions() {
        return super.getInteger(.getPhysicalDamageDealtToChampions());
    }

    
Physical damage taken

Returns:
physical damage taken
    public int getPhysicalDamageTaken() {
        return super.getInteger(.getPhysicalDamageTaken());
    }

    
Quadra kills

Returns:
quadra kills
    public int getQuadraKills() {
        return super.getInteger(.getQuadraKills());
    }

    
Sight wards bought

Returns:
sight wards bought
    public int getSightWardsBought() {
        return super.getInteger(.getSightWardsBought());
    }

    
Number of times first champion spell (Q) was cast

Returns:
number of times first champion spell (Q) was cast
    public int getSpell1Casts() {
        return super.getInteger(.getSpell1Cast());
    }

    
Number of times second champion spell (W) was cast

Returns:
number of times second champion spell (W) was cast
    public int getSpell2Casts() {
        return super.getInteger(.getSpell2Cast());
    }

    
Number of times third champion spell (E) was cast

Returns:
number of times third champion spell (E) was cast
    public int getSpell3Casts() {
        return super.getInteger(.getSpell3Cast());
    }

    
Number of times fourth champion spell (R) was cast

Returns:
number of times fourth champion spell (R) was cast
    public int getSpell4Casts() {
        return super.getInteger(.getSpell4Cast());
    }

    
Number of times first summoner spell was cast

Returns:
number of times first summoner spell was cast
    public int getSummonSpell1Casts() {
        return super.getInteger(.getSummonSpell1Cast());
    }

    
Number of times second summoner spell was cast

Returns:
number of times second summoner spell was cast
    public int getSummonSpell2Casts() {
        return super.getInteger(.getSummonSpell2Cast());
    }

    
Super monsters killed

Returns:
super monsters killed
    public int getSuperMonsterKilled() {
        return super.getInteger(.getSuperMonsterKilled());
    }

    
Team

Returns:
team
    public Side getTeam() {
        return Side.forID(super.getInteger(.getTeam()));
    }

    
Team objectives

Returns:
team objectives
    public int getTeamObjectives() {
        return super.getInteger(.getTeamObjective());
    }

    
Time played (in seconds)

Returns:
time played (in seconds)
    public long getTimePlayed() {
        return super.getInteger(.getTimePlayed());
    }

    
Total damage dealt

Returns:
total damage dealt
    public int getTotalDamageDealt() {
        return super.getInteger(.getTotalDamageDealt());
    }

    
Damage dealt to champions

Returns:
damage dealt to champions
    public int getTotalDamageDealtToChampions() {
        return super.getInteger(.getTotalDamageDealtToChampions());
    }

    
Total damage taken

Returns:
total damage taken
    public int getTotalDamageTaken() {
        return super.getInteger(.getTotalDamageTaken());
    }

    
Total healing done

Returns:
total healing done
    public int getTotalHealing() {
        return super.getInteger(.getTotalHeal());
    }

    
Total player score

Returns:
total player score
    public int getTotalPlayerScore() {
        return super.getInteger(.getTotalPlayerScore());
    }

    
Total score rank

Returns:
total score rank
    public int getTotalScoreRank() {
        return super.getInteger(.getTotalScoreRank());
    }

    
Total time of crowd controls dealt (in milliseconds)

Returns:
total time of crowd controls dealt (in milliseconds)
    public long getTotalTimeCrowdControlDealt() {
        return super.getInteger(.getTotalTimeCrowdControlDealt());
    }

    
Total units healed

Returns:
total units healed
    public int getTotalUnitsHealed() {
        return super.getInteger(.getTotalUnitsHealed());
    }

    
Triple kills

Returns:
triple kills
    public int getTripleKills() {
        return super.getInteger(.getTripleKills());
    }

    
True damage dealt player

Returns:
true damage dealt player
    public int getTrueDamageDealtPlayer() {
        return super.getInteger(.getTrueDamageDealtPlayer());
    }

    
True damage dealt to champions

Returns:
true damage dealt to champions
    public int getTrueDamageDealtToChampions() {
        return super.getInteger(.getTrueDamageDealtToChampions());
    }

    
True damage taken

Returns:
true damage taken
    public int getTrueDamageTaken() {
        return super.getInteger(.getTrueDamageTaken());
    }

    
Turrets killed

Returns:
turrets killed
    public int getTurretsKilled() {
        return super.getInteger(.getTurretsKilled());
    }

    
Unreal kills

Returns:
unreal kills
    public int getUnrealKills() {
        return super.getInteger(.getUnrealKills());
    }

    
Victory point total

Returns:
victory point total
    public int getVictoryPointTotal() {
        return super.getInteger(.getVictoryPointTotal());
    }

    
Vision wards bought

Returns:
vision wards bought
    public int getVisionWardsBought() {
        return super.getInteger(.getVisionWardsBought());
    }

    
Wards killed

Returns:
wards killed
    public int getWardsKilled() {
        return super.getInteger(.getWardKilled());
    }

    
Wards placed

Returns:
wards placed
    public int getWardsPlaced() {
        return super.getInteger(.getWardPlaced());
    }

    
Flag specifying whether or not this game was won

Returns:
whether or not this game was won
    public boolean getWin() {
        return super.getBoolean(.getWin());
    }
    /*
     * (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "RawStats";
    }
New to GrepCode? Check out our FAQ X