Check the container for the SARL skills.

@param skill the skill.
481894
@Check
	public void checkContainerType(SarlSkill skill) {
		final XtendTypeDeclaration declaringType = skill.getDeclaringType();
		if (declaringType != null) {
			final String name = canonicalName(declaringType);
			assert name != null;
			error(MessageFormat.format(Messages.SARLValidator_31, name),
					skill,
					null,
					INVALID_NESTED_DEFINITION);
		}
	}
867425
def list_all_defaults(self):  # type: () -> Dict[str, List[SkillEntry]]
        """"""
        skills = self.list()
        name_to_skill = {skill.name: skill for skill in skills}
        defaults = {group: [] for group in self.SKILL_GROUPS}

        for section_name, skill_names in self.repo.get_default_skill_names():
            section_skills = []
            for skill_name in skill_names:
                if skill_name in name_to_skill:
                    section_skills.append(name_to_skill[skill_name])
                else:
                    LOG.warning('No such default skill: ' + skill_name)
                defaults[section_name] = section_skills

        return defaults
195160
def player_skill(self, player_handle, game_mode='solo'):
        """"""
        if game_mode not in constants.GAME_MODES:
            raise APIException("game_mode must be one of: solo, duo, squad, all")
        try:
            data = self._get_player_profile(player_handle)
            player_stats = {}
            return_data = []
            for stat in data['Stats']:
                if stat['Match'] == game_mode:
                    for datas in stat['Stats']:
                        if datas['label'] == 'Rating':
                            player_stats[stat['Region']] = datas['value']
            return player_stats
        except BaseException as error:
            print('Unhandled exception: ' + str(error))
            raise
226517
public void setProxy(Proxy proxy) {
        if (verifiers.removeIf(verifier -> verifier instanceof SkillRequestSignatureVerifier)) {
            verifiers.add(new SkillRequestSignatureVerifier(proxy));
        }
    }
198233
public boolean containsInstruction(InstructionHandle handle) {
        Iterator<InstructionHandle> i = instructionIterator();
        while (i.hasNext()) {
            if (i.next() == handle) {
                return true;
            }
        }
        return false;
    }
1304025
@Check
	public void checkContainerType(SarlAgent agent) {
		final XtendTypeDeclaration declaringType = agent.getDeclaringType();
		if (declaringType != null) {
			final String name = canonicalName(declaringType);
			assert name != null;
			error(MessageFormat.format(Messages.SARLValidator_28, name),
					agent,
					null,
					INVALID_NESTED_DEFINITION);
		}
	}
815732
@Check
	public void checkSpaceUse(SarlSpace space) {
		error(MessageFormat.format(
				Messages.SARLValidator_0,
				this.grammarAccess.getSpaceKeyword()),
				space,
				null);
	}
578339
@Override
  public boolean check (final int nLevel)
  {
    if (nLevel == FATAL || nLevel == ERROR)
      return m_aLogger.isErrorEnabled ();
    if (nLevel == WARN)
      return m_aLogger.isWarnEnabled ();
    if (nLevel == INFO)
      return m_aLogger.isInfoEnabled ();
    if (nLevel == DEBUG)
      return m_aLogger.isDebugEnabled ();
    return m_aLogger.isTraceEnabled ();
  }
1181243
def skill_show(self, skill_id, **kwargs):
        ""
        api_path = "/api/v2/skills/{skill_id}"
        api_path = api_path.format(skill_id=skill_id)
        return self.call(api_path, **kwargs)
1317004
def by_skills(queryset, skill_string=None):
  
  if skill_string:
    operator, items = get_operator_and_items(skill_string)
    q_obj = SQ()
    for s in items:
      if len(s) > 0:
        q_obj.add(SQ(skills=s), operator)
    queryset = queryset.filter(q_obj)
  return queryset
761060
def skill_delete(self, skill_id, **kwargs):
        ""
        api_path = "/api/v2/skills/{skill_id}"
        api_path = api_path.format(skill_id=skill_id)
        return self.call(api_path, method="DELETE", **kwargs)
856492
protected void _format(SarlSkill skill, IFormattableDocument document) {
		formatAnnotations(skill, document, XbaseFormatterPreferenceKeys.newLineAfterClassAnnotations);
		formatModifiers(skill, document);

		final ISemanticRegionsFinder regionFor = this.textRegionExtensions.regionFor(skill);
		document.append(regionFor.keyword(this.keywords.getSkillKeyword()), ONE_SPACE);

		document.surround(regionFor.keyword(this.keywords.getExtendsKeyword()), ONE_SPACE);
		document.format(skill.getExtends());

		document.surround(regionFor.keyword(this.keywords.getImplementsKeyword()), ONE_SPACE);
		formatCommaSeparatedList(skill.getImplements(), document);

		formatBody(skill, document);
	}
326862
function(container) {
      var index = WireIt.indexOf(container, this.containers);
      if( index != -1 ) {
	  
	container.remove();
	    
        this.containers[index] = null;
        this.containers = WireIt.compact(this.containers);
      
	this.eventRemoveContainer.fire(container);

	this.eventChanged.fire(this);
      }
   }
1017123
public static function initializeSkills()
    {
        if (self::$skills) {
            return;
        }

        self::$skills = [
            self::SKILL_TOTAL => new Skill(self::SKILL_TOTAL, "Total"),
            self::SKILL_ATTACK => new Skill(self::SKILL_ATTACK, "Attack"),
            self::SKILL_DEFENCE => new Skill(self::SKILL_DEFENCE, "Defence"),
            self::SKILL_STRENGTH => new Skill(self::SKILL_STRENGTH, "Strength"),
            self::SKILL_CONSTITUTION => new Skill(self::SKILL_CONSTITUTION, "Constitution", false, false, 10),
            self::SKILL_RANGED => new Skill(self::SKILL_RANGED, "Ranged"),
            self::SKILL_PRAYER => new Skill(self::SKILL_PRAYER, "Prayer"),
            self::SKILL_MAGIC => new Skill(self::SKILL_MAGIC, "Magic"),
            self::SKILL_COOKING => new Skill(self::SKILL_COOKING, "Cooking"),
            self::SKILL_WOODCUTTING => new Skill(self::SKILL_WOODCUTTING, "Woodcutting"),
            self::SKILL_FLETCHING => new Skill(self::SKILL_FLETCHING, "Fletching"),
            self::SKILL_FISHING => new Skill(self::SKILL_FISHING, "Fishing"),
            self::SKILL_FIREMAKING => new Skill(self::SKILL_FIREMAKING, "Firemaking"),
            self::SKILL_CRAFTING => new Skill(self::SKILL_CRAFTING, "Crafting"),
            self::SKILL_SMITHING => new Skill(self::SKILL_SMITHING, "Smithing"),
            self::SKILL_MINING => new Skill(self::SKILL_MINING, "Mining"),
            self::SKILL_HERBLORE => new Skill(self::SKILL_HERBLORE, "Herblore"),
            self::SKILL_AGILITY => new Skill(self::SKILL_AGILITY, "Agility"),
            self::SKILL_THIEVING => new Skill(self::SKILL_THIEVING, "Thieving"),
            self::SKILL_SLAYER => new Skill(self::SKILL_SLAYER, "Slayer", true),
            self::SKILL_FARMING => new Skill(self::SKILL_FARMING, "Farming"),
            self::SKILL_RUNECRAFTING => new Skill(self::SKILL_RUNECRAFTING, "Runecrafting"),
            self::SKILL_HUNTER => new Skill(self::SKILL_HUNTER, "Hunter"),
            self::SKILL_CONSTRUCTION => new Skill(self::SKILL_CONSTRUCTION, "Construction"),
            self::SKILL_SUMMONING => new Skill(self::SKILL_SUMMONING, "Summoning"),
            self::SKILL_DUNGEONEERING => new Skill(self::SKILL_DUNGEONEERING, "Dungeoneering", true),
            self::SKILL_DIVINATION => new Skill(self::SKILL_DIVINATION, "Divination"),
            self::SKILL_INVENTION => new Skill(self::SKILL_INVENTION, "Invention", true, true)
        ];
    }
705979
def get_skill_entry(name, skills_data) -> dict:
    
    for e in skills_data.get('skills', []):
        if e.get('name') == name:
            return e
    return {}
686135
public void setSkillSummaries(java.util.Collection<SkillSummary> skillSummaries) {
        if (skillSummaries == null) {
            this.skillSummaries = null;
            return;
        }

        this.skillSummaries = new java.util.ArrayList<SkillSummary>(skillSummaries);
    }
1064624
static public boolean isContainer(ReferenceType target) throws ClassNotFoundException {
        Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2();
        return subtypes2.isSubtype(target, COLLECTION_TYPE)
                || subtypes2.isSubtype(target, MAP_TYPE);
    }