Gets all known types, sorted alphabetically.
195165
public Iterable<String> getAllSortedTypeNames() {
    synchronized (lock) {
      if (lazyAllSortedTypeNames == null) {
        lazyAllSortedTypeNames =
            Stream.concat(BUILTIN_TYPES.keySet().stream(), descriptors.keySet().stream())
                .sorted()
                .collect(toImmutableList());
      }
      return lazyAllSortedTypeNames;
    }
  }
990013
public String[] getTypes() {
        String[] types = new String[columns.getColumns().size()];
        for (int i = 0; i < columns.getColumns().size(); i++) {
            types[i] = columns.getColumns().get(i).getType();
        }
        return types;
    }
109251
def types(self):
        """"""
        res = []
        for column in self.column_definitions:
            tmp = column.get('type', None)
            res.append(ModelCompiler.get_column_type(tmp)) if tmp else False
        res = list(set(res))
        return res
664099
public static function getTypes() {
        return array(
            self::TYPE_CHARACTER,
            self::TYPE_LOGICAL,
            self::TYPE_DATE ,
            self::TYPE_NUMERIC,
            self::TYPE_MEMO,
        );
    }
1129130
def get_generic_type(type_tag):
    """"""
    return {
        # Alarm
        DEVICE_ALARM: TYPE_ALARM,

        # Binary Sensors - Connectivity
        DEVICE_GLASS_BREAK: TYPE_CONNECTIVITY,
        DEVICE_KEYPAD: TYPE_CONNECTIVITY,
        DEVICE_REMOTE_CONTROLLER: TYPE_CONNECTIVITY,
        DEVICE_SIREN: TYPE_CONNECTIVITY,
        DEVICE_STATUS_DISPLAY: TYPE_CONNECTIVITY,

        # Binary Sensors - Opening
        DEVICE_DOOR_CONTACT: TYPE_OPENING,

        # Cameras
        DEVICE_MOTION_CAMERA: TYPE_CAMERA,
        DEVICE_MOTION_VIDEO_CAMERA: TYPE_CAMERA,
        DEVICE_IP_CAM: TYPE_CAMERA,
        DEVICE_OUTDOOR_MOTION_CAMERA: TYPE_CAMERA,

        # Covers
        DEVICE_SECURE_BARRIER: TYPE_COVER,

        # Lights (Dimmers)
        DEVICE_DIMMER: TYPE_LIGHT,
        DEVICE_DIMMER_METER: TYPE_LIGHT,
        DEVICE_HUE: TYPE_LIGHT,

        # Locks
        DEVICE_DOOR_LOCK: TYPE_LOCK,

        # Moisture
        DEVICE_WATER_SENSOR: TYPE_CONNECTIVITY,

        # Switches
        DEVICE_SWITCH: TYPE_SWITCH,
        DEVICE_NIGHT_SWITCH: TYPE_SWITCH,
        DEVICE_POWER_SWITCH_SENSOR: TYPE_SWITCH,
        DEVICE_POWER_SWITCH_METER: TYPE_SWITCH,

        # Water Valve
        DEVICE_VALVE: TYPE_VALVE,

        # Unknown Sensors
        # More data needed to determine type
        DEVICE_ROOM_SENSOR: TYPE_UNKNOWN_SENSOR,
        DEVICE_TEMPERATURE_SENSOR: TYPE_UNKNOWN_SENSOR,
        DEVICE_MULTI_SENSOR: TYPE_UNKNOWN_SENSOR,
        DEVICE_PIR: TYPE_UNKNOWN_SENSOR,
        DEVICE_POVS: TYPE_UNKNOWN_SENSOR,
    }.get(type_tag.lower(), None)
786267
def types(self) -> GraphQLTypeList:
        """"""
        try:
            types = resolve_thunk(self._types)
        except GraphQLError:
            raise
        except Exception as error:
            raise TypeError(f"{self.name} types cannot be resolved: {error}")
        if types is None:
            types = []
        if not isinstance(types, (list, tuple)):
            raise TypeError(
                f"{self.name} types must be a list/tuple"
                " or a function which returns a list/tuple."
            )
        if not all(isinstance(value, GraphQLObjectType) for value in types):
            raise TypeError(f"{self.name} types must be GraphQLObjectType objects.")
        return types[:]
345533
def get_reference_types(self):
        
        item_types = self._zotero_lib.item_types()
        return sorted([x["itemType"] for x in item_types])
304677
private function resolveTypes($type)
    {
        $sortTypes = [];

        do {
            $sortTypes[] = $sortType = $this->sortRegistry[$type];
        } while (($type = $sortType->getParent()) !== null);

        return $sortTypes;
    }
991122
def _typelist(x):
    """"""
    if isinstance(x, collections.Sequence):
        return list(map(_to_instance, x))
    elif isinstance(x, collections.Iterable):
        return x
    return None if x is None else [_to_instance(x)]
829801
public static Class[] getTypes(Object... args) {
      if (args.length == 0) {
         return new Class[0];
      }
      Class[] types = new Class[args.length];
      for (int i = 0; i < args.length; i++) {
         types[i] = args[i] == null ? Object.class : args[i].getClass();
      }
      return types;
   }
733157
private static List<Type> fetchAllNestedTypes(MessageType type, boolean all) {
        List<Type> ret = new ArrayList<Type>();

        List<Type> nestedTypes = type.getNestedTypes();
        ret.addAll(nestedTypes);
        if (all) {
            for (Type t : nestedTypes) {
                if (t instanceof MessageType) {
                    List<Type> subNestedTypes = fetchAllNestedTypes((MessageType) t, true);
                    ret.addAll(subNestedTypes);
                }
            }
        }

        return ret;
    }
1262286
def get_doctypes(self, default_doctypes=None):
        """"""
        doctypes = self.type.get_mapping_type_name()
        if isinstance(doctypes, six.string_types):
            doctypes = [doctypes]
        return super(S, self).get_doctypes(default_doctypes=doctypes)
147837
protected function getTypesSorted()
    {
        $types = $this->getTypes();
        usort($types, function ($first, $second) {
            /* @var Type $first */
            /* @var Type $second */
            return $first->name == 'mixed' ? 1 : 0;
        });

        return $types;
    }
315794
def mediatypes(self):
        """"""
        return [h for h, q in sorted(request.accept_mimetypes,
                                     key=operator.itemgetter(1), reverse=True)]
621362
protected function getTypesLibrary()
    {
        $types = array();

        foreach (array_keys($this->library->getTypes()) as $id) {
            $types[$id] = $this->text(ucfirst($id));
        }

        return $types;
    }
778216
def get_archive_types():
    '''
    
    '''
    ret = copy.deepcopy(_bundle_types)
    for k, v in ret.items():
        v.pop('handler')
    return ret
1097347
List<Type> readTypeParams(int i) {
        int index = poolIdx[i];
        return sigToTypeParams(buf, index + 3, getChar(index + 1));
    }