Instructions to be performed in 'classBody' state.
515656
protected function inClassBodyState()
    {
        $char = $this->getCurrentChar();

        if ($char === self::CHAR_DOUBLEQUOTE) {
            $this->setState(self::IN_CLASSSTRING);
        } elseif ($char === self::CHAR_CLOSINGBRACE) {
            $this->setState(self::RUNNING);
        } elseif ($char === self::CHAR_STAR && $this->getPreviousChar() === self::CHAR_SLASH) {
            $this->setState(self::IN_CLASSCOMMENT);
        }

        $this->output($char);
    }
536774
def do_class(self, element, decl, pseudo):
        """"""
        step = self.state[self.state['current_step']]
        actions = step['actions']
        strval = self.eval_string_value(element, decl.value)
        actions.append(('attrib', ('class', strval)))
844135
function CharacterClass(class_id, class_name, is_always_invoke, is_grouping, max_length) {
    this.class_id = class_id;
    this.class_name = class_name;
    this.is_always_invoke = is_always_invoke;
    this.is_grouping = is_grouping;
    this.max_length = max_length;
}
933846
@Override
    public <T> T body(Class<T> classOfT) {
        return body(classOfT, null);
    }
205608
public function set_state() {
		if ( ! empty( $this->struct['state'] ) ) {
			$this->classes[] = 'notice-' . $this->struct['state'];
		} else {
			$this->classes[] = 'notice-warning';
		}
	}
954757
@Override
  public <X> void body(Class<X> type, Result<X> result)
  {
    delegate().body(type, result);
  }
25576
function code_body() {
    // Get the class code from the class docblock onwards first, so it can be
    // then processed for qualified class names.
    $class_doc_block = $this->getClassDocBlockLines();
    $class_doc_block = $this->docBlock($class_doc_block);

    $class_code = array_merge(
      $class_doc_block,
      $this->class_declaration(),
      $this->classCodeBody()
    );

    // Replace any fully-qualified classes with short class names, and keep a
    // list of the replacements to make import statements with.
    $imported_classes = [];
    $this->extractFullyQualifiedClasses($class_code, $imported_classes, $this->component_data['namespace']);

    $return = array_merge(
      $this->code_namespace(),
      $this->imports($imported_classes),
      $class_code,
      [
        '}',
      ]);
    return $return;
  }
871612
protected function inClassCommentState()
    {
        $char = $this->getCurrentChar();

        if ($char === self::CHAR_SLASH && $this->getPreviousChar() === self::CHAR_STAR) {
            $this->setState(self::IN_CLASSBODY);
        }

        $this->output($char);
    }
846166
private synchronized static void activating(String classname, int fn)
	{
		m.put(classname, StaticOperationsCounters.act[fn]++);
		m.put(classname, StaticOperationsCounters.active[fn]++);
		stateChanged();
	}
175645
def Parse(self, how):
        '''
        '''
        if type(how) == types.ClassType: how = how.typecode
        return how.parse(self.body_root, self)
309826
protected function classCodeBody() {
    $code_body = array();

    // Class body always has at least one blank line.
    $code_body[] = '';

    // Let the class collect its section blocks.
    $this->collectSectionBlocks();

    $section_types = [
      // These are the names of class properties.
      // TODO: change these to being roles in the child components.
      'traits',
      'constants',
      'properties',
      'constructor',
      'functions',
    ];
    foreach ($section_types as $section_type) {
      $section_blocks = $this->getSectionBlocks($section_type);
      $code_body = array_merge($code_body, $this->mergeSectionCode($section_blocks));
    }

    // Indent all the class code.
    // TODO: is there a nice way of doing indents?
    $code_body = array_map(function ($line) {
      return empty($line) ? $line : '  ' . $line;
    }, $code_body);

    return $code_body;
  }
930827
function( cls ) {
				var classes = this.getCustomData( 'classes' );
				if ( !this.hasClass( cls ) ) {
					!classes && ( classes = [] ), classes.push( cls );
					this.setCustomData( 'classes', classes );
					this.addClass( cls );
				}
			}
1152146
def do_execute(self):
        
        if isinstance(self.input.payload, Instances):
            inst = None
            data = self.input.payload
        else:
            inst = self.input.payload
            data = inst.dataset

        retrain = False
        if (self._header is None) or (self._header.equal_headers(data) is not None) or (inst is None):
            retrain = True
            self._header = Instances.template_instances(data, 0)

        if retrain or (self._model is None):
            cls = self.resolve_option("setup")
            if isinstance(cls, Classifier):
                self._model = Classifier.make_copy(cls)
            elif isinstance(cls, Clusterer):
                self._model = Clusterer.make_copy(cls)
            elif isinstance(cls, Associator):
                self._model = Associator.make_copy(cls)
            else:
                return "Unhandled class: " + classes.get_classname(cls)

        if retrain:
            if inst is not None:
                data = Instances.template_instances(data, 1)
                data.add_instance(inst)
            if isinstance(self._model, Classifier):
                self._model.build_classifier(data)
            elif isinstance(self._model, Clusterer):
                self._model.build_clusterer(data)
            elif isinstance(self._model, Associator):
                self._model.build_associations(data)
        else:
            if isinstance(self._model, Classifier):
                self._model.update_classifier(inst)
            elif isinstance(self._model, Clusterer):
                self._model.update_clusterer(inst)
            else:
                return "Cannot train incrementally: " + classes.get_classname(self._model)

        cont = ModelContainer(model=self._model, header=self._header)
        self._output.append(Token(cont))
        return None
131421
def composite_state(class_name, state)
      if @compositor
        list = @compositor.css_classes_for("#{class_name}::#{state}")
        return list if !list.empty?
      end

      [ dasherize(state) ]
    end
391666
def class_register(cls):
    """"""
    cls.handler_registry = {}
    cls.sender_registry = {}
    for method_name in dir(cls):
        method = getattr(cls, method_name)
        if hasattr(method, '_handle'):
            cls.handler_registry.update({method._handle: method_name})
        if hasattr(method, '_sends'):
            cls.sender_registry.update({method._sends: method_name})
    return cls
62547
function Output() {
  var body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';

  _classCallCheck(this, Output);

  this.body = body;
  this.temp = null;
}
1164696
def inspect
      str = Inspect.dashed_line(self.class)
      headers.each do |header|
        str << header.inspect
      end
      str << Inspect.inspect_body(body)
    end