Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.robrua.orianna.type.core.match;
  
  import java.util.List;
  
 
     private static final long serialVersionUID = -6687839465360280189L;
     private Item item0item1item2item3item4item5item6;

    

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

    
Number of assists

Returns:
number of assists
 
     public long getAssists() {
         return super.getLong(.getAssists());
     }

    
If game was a dominion game, player's combat score, otherwise 0

Returns:
if game was a dominion game, player's combat score, otherwise 0
 
     public long getCombatPlayerScore() {
         return super.getLong(.getCombatPlayerScore());
     }

    
Number of deaths

Returns:
number of deaths
 
     public long getDeaths() {
         return super.getLong(.getDeaths());
     }

    
Number of double kills

Returns:
number of double kills
 
     public long getDoubleKills() {
         return super.getLong(.getDoubleKills());
     }

    
Flag indicating if participant got an assist on first blood

Returns:
flag indicating if participant got an assist on first blood
 
     public boolean getFirstBloodAssist() {
         return super.getBoolean(.getFirstBloodAssist());
     }

    
Flag indicating if participant got first blood

Returns:
flag indicating if participant got first blood
 
     public boolean getFirstBloodKill() {
         return super.getBoolean(.getFirstBloodKill());
     }

    
Flag indicating if participant got an assist on the first inhibitor

Returns:
flag indicating if participant got an assist on the first inhibitor
 
     public boolean getFirstInhibitorAssist() {
         return super.getBoolean(.getFirstInhibitorAssist());
     }

    
Flag indicating if participant destroyed the first inhibitor

Returns:
flag indicating if participant destroyed the first inhibitor
 
     public boolean getFirstInhibitorKill() {
         return super.getBoolean(.getFirstInhibitorKill());
     }

    
Flag indicating if participant got an assist on the first tower

Returns:
flag indicating if participant got an assist on the first tower
    public boolean getFirstTowerAssist() {
        return super.getBoolean(.getFirstTowerAssist());
    }

    
Flag indicating if participant destroyed the first tower

Returns:
flag indicating if participant destroyed the first tower
    public boolean getFirstTowerKill() {
        return super.getBoolean(.getFirstTowerKill());
    }

    
Gold earned

Returns:
gold earned
    public long getGoldEarned() {
        return super.getLong(.getGoldEarned());
    }

    
Gold spent

Returns:
gold spent
    public long getGoldSpent() {
        return super.getLong(.getGoldSpent());
    }

    
Number of inhibitor kills

Returns:
number of inhibitor kills
    public long getInhibitorKills() {
        return super.getLong(.getInhibitorKills());
    }

    
Item 0

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

    
Item 0 ID

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

    
Item 1

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

    
Item 1 ID

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

    
Item 2

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

    
Item 2 ID

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

    
Item 3

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

    
Item 3 ID

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

    
Item 4

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

    
Item 4 ID

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

    
Item 5

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

    
Item 5 ID

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

    
Item 6

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

    
Item 6 ID

Returns:
item 6 ID
    public long getItem6ID() {
        return super.getLong(.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 Long l = .getItem0();
            if(l == null) {
                throw new MissingDataException("Item #0 ID is null.");
            }
            toLoad.add(l.longValue());
        }
        if( != null) {
            items.add(1, );
        }
        else {
            final Long l = .getItem1();
            if(l == null) {
                throw new MissingDataException("Item #1 ID is null.");
            }
            toLoad.add(l.longValue());
        }
        if( != null) {
            items.add(2, );
        }
        else {
            final Long l = .getItem2();
            if(l == null) {
                throw new MissingDataException("Item #2 ID is null.");
            }
            toLoad.add(l.longValue());
        }
        if( != null) {
            items.add(3, );
        }
        else {
            final Long l = .getItem3();
            if(l == null) {
                throw new MissingDataException("Item #3 ID is null.");
            }
            toLoad.add(l.longValue());
        }
        if( != null) {
            items.add(4, );
        }
        else {
            final Long l = .getItem4();
            if(l == null) {
                throw new MissingDataException("Item #4 ID is null.");
            }
            toLoad.add(l.longValue());
        }
        if( != null) {
            items.add(5, );
        }
        else {
            final Long l = .getItem5();
            if(l == null) {
                throw new MissingDataException("Item #5 ID is null.");
            }
            toLoad.add(l.longValue());
        }
        if( != null) {
            items.add(6, );
        }
        else {
            final Long l = .getItem6();
            if(l == null) {
                throw new MissingDataException("Item #6 ID is null.");
            }
            toLoad.add(l.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);
    }

    
Number of killing sprees

Returns:
number of killing sprees
    public long getKillingSprees() {
        return super.getLong(.getKillingSprees());
    }

    
Number of kills

Returns:
number of kills
    public long getKills() {
        return super.getLong(.getKills());
    }

    
Largest critical strike

Returns:
largest critical strike
    public long getLargestCriticalStrike() {
        return super.getLong(.getLargestCriticalStrike());
    }

    
Largest killing spree

Returns:
largest killing spree
    public long getLargestKillingSpree() {
        return super.getLong(.getLargestKillingSpree());
    }

    
Largest multi kill

Returns:
largest multi kill
    public long getLargestMultiKill() {
        return super.getLong(.getLargestMultiKill());
    }

    
Champion level achieved

Returns:
champion level achieved
    public long getLevel() {
        return super.getLong(.getChampLevel());
    }

    
Magical damage dealt

Returns:
magical damage dealt
    public long getMagicDamageDealt() {
        return super.getLong(.getMagicDamageDealt());
    }

    
Magical damage dealt to champions

Returns:
magical damage dealt to champions
    public long getMagicDamageDealtToChampions() {
        return super.getLong(.getMagicDamageDealtToChampions());
    }

    
Magic damage taken

Returns:
magic damage taken
    public long getMagicDamageTaken() {
        return super.getLong(.getMagicDamageTaken());
    }

    
Minions killed

Returns:
minions killed
    public long getMinionsKilled() {
        return super.getLong(.getMinionsKilled());
    }

    
Neutral minions killed

Returns:
neutral minions killed
    public long getNeutralMinionsKilled() {
        return super.getLong(.getNeutralMinionsKilled());
    }

    
Neutral jungle minions killed in the enemy team's jungle

Returns:
neutral jungle minions killed in the enemy team's jungle
    public long getNeutralMinionsKilledEnemyJungle() {
        return super.getLong(.getNeutralMinionsKilledEnemyJungle());
    }

    
Neutral jungle minions killed in your team's jungle

Returns:
neutral jungle minions killed in your team's jungle
    public long getNeutralMinionsKilledTeamJungle() {
        return super.getLong(.getNeutralMinionsKilledTeamJungle());
    }

    
If game was a dominion game, number of node capture assists

Returns:
if game was a dominion game, number of node capture assists
    public long getNodeCaptureAssists() {
        return super.getLong(.getNodeCaptureAssist());
    }

    
If game was a dominion game, number of node captures

Returns:
if game was a dominion game, number of node captures
    public long getNodeCaptures() {
        return super.getLong(.getNodeCapture());
    }

    
If game was a dominion game, number of node neutralizations

Returns:
if game was a dominion game, number of node neutralizations
    public long getNodeNeutralizations() {
        return super.getLong(.getNodeNeutralize());
    }

    
If game was a dominion game, number of node neutralization assists

Returns:
if game was a dominion game, number of node neutralization assists
    public long getNodeNeutralizeAssists() {
        return super.getLong(.getNodeNeutralizeAssist());
    }

    
If game was a dominion game, player's objectives score, otherwise 0

Returns:
if game was a dominion game, player's objectives score, otherwise 0
    public long getObjectivePlayerScore() {
        return super.getLong(.getObjectivePlayerScore());
    }

    
Number of penta kills

Returns:
number of penta kills
    public long getPentaKills() {
        return super.getLong(.getPentaKills());
    }

    
Physical damage dealt

Returns:
physical damage dealt
    public long getPhysicalDamageDealt() {
        return super.getLong(.getPhysicalDamageDealt());
    }

    
Physical damage dealt to champions

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

    
Physical damage taken

Returns:
physical damage taken
    public long getPhysicalDamageTaken() {
        return super.getLong(.getPhysicalDamageTaken());
    }

    
Number of quadra kills

Returns:
number of quadra kills
    public long getQuadraKills() {
        return super.getLong(.getQuadraKills());
    }

    
Sight wards purchased

Returns:
sight wards purchased
    public long getSightWardsBought() {
        return super.getLong(.getSightWardsBoughtInGame());
    }

    
If game was a dominion game, number of completed team objectives (i.e., quests)

Returns:
if game was a dominion game, number of completed team objectives (i.e., quests)
    public long getTeamObjectives() {
        return super.getLong(.getTeamObjective());
    }

    
Total damage dealt

Returns:
total damage dealt
    public long getTotalDamageDealt() {
        return super.getLong(.getTotalDamageDealt());
    }

    
Total damage dealt to champions

Returns:
total damage dealt to champions
    public long getTotalDamageDealtToChampions() {
        return super.getLong(.getTotalDamageDealtToChampions());
    }

    
Total damage taken

Returns:
total damage taken
    public long getTotalDamageTaken() {
        return super.getLong(.getTotalDamageTaken());
    }

    
Total heal amount

Returns:
total heal amount
    public long getTotalHealing() {
        return super.getLong(.getTotalHeal());
    }

    
If game was a dominion game, player's total score, otherwise 0

Returns:
if game was a dominion game, player's total score, otherwise 0
    public long getTotalPlayerScore() {
        return super.getLong(.getTotalPlayerScore());
    }

    
If game was a dominion game, team rank of the player's total score (e.g., 1-5)

Returns:
if game was a dominion game, team rank of the player's total score (e.g., 1-5)
    public long getTotalScoreRank() {
        return super.getLong(.getTotalScoreRank());
    }

    
Total dealt crowd control time

Returns:
total dealt crowd control time
    public long getTotalTimeCrowdControlDealt() {
        return super.getLong(.getTotalTimeCrowdControlDealt());
    }

    
Total units healed

Returns:
total units healed
    public long getTotalUnitsHealed() {
        return super.getLong(.getTotalUnitsHealed());
    }

    
Number of tower kills

Returns:
number of tower kills
    public long getTowerKills() {
        return super.getLong(.getTowerKills());
    }

    
Number of triple kills

Returns:
number of triple kills
    public long getTripleKills() {
        return super.getLong(.getTripleKills());
    }

    
True damage dealt

Returns:
true damage dealt
    public long getTrueDamageDealt() {
        return super.getLong(.getTrueDamageDealt());
    }

    
True damage dealt to champions

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

    
True damage taken

Returns:
true damage taken
    public long getTrueDamageTaken() {
        return super.getLong(.getTrueDamageTaken());
    }

    
Number of unreal kills

Returns:
number of unreal kills
    public long getUnrealKills() {
        return super.getLong(.getUnrealKills());
    }

    
Vision wards purchased

Returns:
vision wards purchased
    public long getVisionWardsBought() {
        return super.getLong(.getVisionWardsBoughtInGame());
    }

    
Number of wards killed

Returns:
number of wards killed
    public long getWardsKilled() {
        return super.getLong(.getWardsKilled());
    }

    
Number of wards placed

Returns:
number of wards placed
    public long getWardsPlaced() {
        return super.getLong(.getWardsPlaced());
    }

    
Flag indicating whether or not the participant won

Returns:
flag indicating whether or not the participant won
    public boolean getWinner() {
        return super.getBoolean(.getWinner());
    }
    /*
     * (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "ParticipantStats";
    }
New to GrepCode? Check out our FAQ X