Get every information needed from this class.
767280
private function getPropertiesInfo()
    {
        if (!$this->_automatedBehaviorInitialized) {
            $classInfo = Reader::getClassInformation($this);

            $this->_accessProperties = $classInfo['accessProperties'];
            $this->_collectionsItemNames = $classInfo['collectionsItemNames'];
            $this->_associationsList = $classInfo['associationsList'];
            $this->_initialPropertiesValues = $classInfo['initialPropertiesValues'];
            $this->_initializationNeededArguments = $classInfo['initializationNeededArguments'];

            if ($this->_constraintsValidationEnabled === null) {
                $this->_constraintsValidationEnabled = $classInfo['constraintsValidationEnabled'];
            }

            $this->_automatedBehaviorInitialized = true;
        }
    }
1021197
def info(self):
        

        return (self.start_pc, self.end_pc,
                self.handler_pc, self.get_catch_type())
316528
def _get_all_decendents(self, cls):
        """"""
        decendents = {}
        for sc in cls.__sub_classes__:
            decendents[sc.__name__] = sc
            decendents.update(self._get_all_decendents(sc))
        return decendents
252397
def info(self):
        
        result = dict()
        for name, namespace in self._namespaces.items():
            result[name] = namespace.info_all()
        return result
797830
def _info(self):
        
        name = self.__class__.__module__ + '.' + self.__class__.__name__
        info, created = ModuleInfo.objects.get_or_create(name=name)
        if created:
            # Do not set as changed
            info.commit()
        return info
207627
def _to_dict(self):
        """"""
        _dict = {}
        if hasattr(self, 'text') and self.text is not None:
            _dict['text'] = self.text
        if hasattr(self, 'top_class') and self.top_class is not None:
            _dict['top_class'] = self.top_class
        if hasattr(self, 'classes') and self.classes is not None:
            _dict['classes'] = [x._to_dict() for x in self.classes]
        return _dict
710504
def find_all(self, cls):
        """"""
        final_results = []
        for db_result in read_by_indexes(cls.get_table_name(), []):
            obj = cls.from_data(db_result['value'])
            final_results.append(obj)

        return final_results
478825
private function getAllInfo()
    {
        $data = [
            'username'       => $this->getUsername(),
            'image'          => $this->getImage(),
            'last_online'    => $this->getStatus('Last Online'),
            'gender'         => $this->getStatus('Gender'),
            'birthday'       => $this->getStatus('Birthday'),
            'location'       => $this->getStatus('Location'),
            'joined_date'    => $this->getStatus('Joined'),
            'forum_post'     => $this->getStatus2(0),
            'review'         => $this->getStatus2(1),
            'recommendation' => $this->getStatus2(2),
            'blog_post'      => $this->getStatus2(3),
            'club'           => $this->getStatus2(4),
            'sns'            => $this->getSns(),
            'friend'         => $this->getFriend(),
            'about'          => $this->getAbout(),
            'anime_stat'     => $this->getStat('anime'),
            'manga_stat'     => $this->getStat('manga'),
            'favorite'       => $this->getFavorite(),
        ];

        return $data;
    }
718559
def get_all(self, qry, tpl):
        '''  '''
        self.cur.execute(qry, tpl)
        result = self.cur.fetchall()
        return result
350521
private function getAllInfo()
    {
        $data = [
            'id'        => $this->getId(),
            'cover'     => $this->getCover(),
            'title'     => $this->getTitle(),
            'title2'    => $this->getTitle2(),
            'video'     => $this->getVideo(),
            'synopsis'  => $this->getSynopsis(),
            'score'     => $this->getScore(),
            'voter'     => $this->getVoter(),
            'rank'      => $this->getRank(),
            'popularity'=> $this->getPopularity(),
            'members'   => $this->getMembers(),
            'favorite'  => $this->getFavorite(),
        ];

        $data = array_merge($data, $this->getOtherInfo());

        $data2 = [
            'related'        => $this->getRelated(),
            'character'      => $this->getCharacter(),
            'staff'          => $this->getStaff(),
            'song'           => $this->getSong(),
            'review'         => $this->getReview(),
            'recommendation' => $this->getRecommendation(),
        ];

        $data = array_merge($data, $data2);

        return $data;
    }
867284
def find_class(self):
        """"""
        classes = {1: InstructionGotoTable, 2: InstructionWriteMetadata,
                   3: InstructionWriteAction, 4: InstructionApplyAction,
                   5: InstructionClearAction, 6: InstructionMeter}
        return classes.get(self.value, None)
979601
def classes(self) -> Iterator[str]:
        """"""
        yield from (
            c[:-6]
            for c in self.path_map.keys() if c.endswith('.class')
        )
709215
def _getSuitableClasses(self, data):
        """"""
        classes = None
        if data[EI.CLASS] == ELFCLASS.BITS_32:
            if data[EI.DATA] == ELFDATA.LSB:
                classes = LSB_32
            elif data[EI.DATA] == ELFDATA.MSB:
                classes = MSB_32

        elif data[EI.CLASS] == ELFCLASS.BITS_64:
            if data[EI.DATA] == ELFDATA.LSB:
                classes = LSB_64
            elif data[EI.DATA] == ELFDATA.MSB:
                classes = MSB_64

        return classes
605465
def _load_info(self):
    """"""
    if self._info is None:
      try:
        self._info = self._api.tables_get(self._name_parts)
      except Exception as e:
        raise e
131135
def classes(self):
        """"""
        defclass = lib.EnvGetNextDefclass(self._env, ffi.NULL)

        while defclass != ffi.NULL:
            yield Class(self._env, defclass)

            defclass = lib.EnvGetNextDefclass(self._env, defclass)
43212
private function info()
    {
        $response = [
            'class' => []
        ];
        
        foreach ($this->config["classes"] as $key => $val) {
            
            // addtional config
            $response["class"][$key]["config"] = !empty($val[1]) ? $val[1] : [];
            
            // check class file exists
            if (!file_exists($val[0])) {
                $response["class"][$key]["methods"] = [];
                continue;
            }
            
            //
            require($val[0]);

            $reflection = new \ReflectionClass($key);

            foreach ($reflection->getMethods() as $method) {
                if (!in_array($method->getName(), ["__construct"])) {
                    $param = [];
                    foreach ($method->getParameters() as $parameter) {
                        $param[] = $parameter->getName();
                    }
                    $response["class"][$key]["methods"][$method->getName()] = $param;
                }
            }
        }

        return $response;
    }
695110
def get_all(cls):
        
        issues = db.Issue.find(
            Issue.issue_type_id == IssueType.get(cls.issue_type).issue_type_id
        )

        return {res.issue_id: cls(res) for res in issues}