Return the reference types.

        Zotero.item_types() caches data after the first API call.
345533
def get_reference_types(self):
        
        item_types = self._zotero_lib.item_types()
        return sorted([x["itemType"] for x in item_types])
1286130
def array_item_type(type_):
    """"""
    if is_array(type_):
        type_ = remove_alias(type_)
        type_ = remove_cv(type_)
        return type_.base
    elif is_pointer(type_):
        return remove_pointer(type_)
    else:
        raise RuntimeError(
            "array_item_type functions takes as argument array or pointer " +
            "types")
1222300
def types(*args, **kwargs):
    

    rtype = first(args)

    return Types(rtype=rtype, ptypes=kwargs)
1154416
def types(self):
        
        r = requests.get(self.evaluator_url + 'types')
        r.raise_for_status()
        return r.json()
599150
def get_type(data):
    
    if data["analysis"].lower().startswith("var") or dd.get_variantcaller(data):
        return tz.get_in(("config", "algorithm", "effects"), data, "snpeff")
1141088
def itemtypes(cls, mapped_types, coll_type, visitor):
        
        rv = list(v for k, v in mapped_types)
        return rv[0] if len(rv) == 1 else rv
357101
function type()
    {
        $type = false;

        // get first product
        $productCollectionItemList = eZProductCollectionItem::fetchList( array( 'productcollection_id' => $this->attribute( 'productcollection_id' ) ),
                                                                         true,
                                                                         0,
                                                                         1 );

        if ( is_array( $productCollectionItemList ) && count( $productCollectionItemList ) === 1 )
        {
            $product = $productCollectionItemList[0]->attribute( 'contentobject' );
            if ( is_object( $product ) )
            {
                $type = eZShopFunctions::productTypeByObject( $product );
            }
        }

        return $type;
    }
498933
def get_datatypes(self):
        
        datatypes = set()
        for element in self.elements:
            if isinstance(element, PolygonSet):
                datatypes.update(element.datatypes)
            elif isinstance(element, CellReference) or isinstance(
                    element, CellArray):
                datatypes.update(element.ref_cell.get_datatypes())
        return datatypes
125420
def _check_type(self, check_type, properties):
        """"""
        if 'PrimitiveType' in properties:
            return properties['PrimitiveType'] == check_type
        if properties['Type'] == 'List':
            if 'ItemType' in properties:
                return properties['ItemType'] == check_type
            else:
                return properties['PrimitiveItemType'] == check_type
        return False
1000855
protected function processReferencesChanged()
    {
        $cache = $this->_cache;
        $attrs = $this->getAttrs();
        foreach ($cache as $key => $item) {
            if(!isset($attrs[$key])) continue;
            $attr = $attrs[$key];
            if ($attr['type'] == self::DATA_TYPE_REFERENCES) {
                if ($item instanceof Collection && (!isset($this->cleanData[$key]) || $this->cleanData[$key] !== $item->makeRef())) {
                    $this->__setter($key, $item);
                }
            }
        }
    }
1267914
def load_cache(self):
        """"""
        with open(self.cache_path, "rb") as f:
            print("Loading cached Zotero data...")
            cache = pickle.load(f)
            self._references = cache[self.CACHE_REFERENCE_LIST]
            self.reference_types = cache[self.CACHE_REFERENCE_TYPES]
            self.reference_templates = cache[self.CACHE_REFERENCE_TEMPLATES]
            print("Cached Zotero data loaded.")
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
1157363
private static Map<String, String> getTypeItems() {

        Map<String, String> types = new LinkedHashMap<String, String>();
        types.put("roadmap", Messages.get().key(Messages.GUI_LOCATION_ROADMAP_0));
        types.put("hybrid", Messages.get().key(Messages.GUI_LOCATION_HYBRID_0));
        types.put("satellite", Messages.get().key(Messages.GUI_LOCATION_SATELLITE_0));
        types.put("terrain", Messages.get().key(Messages.GUI_LOCATION_TERRAIN_0));
        return types;
    }
699228
def get_type(self, name, api=None):
        
        k = (name, api)
        if k in self.types:
            return self.types[k]
        else:
            return self.types[(name, None)]
793986
def get_reference_template(self, ref_type):
        
        template = self._zotero_lib.item_template(ref_type)
        return OrderedDict(sorted(template.items(), key=lambda x: x[0]))
1259779
@Override
  public List<ApiType> list() {
    lock.lock();
    try {
      List<ApiType> itemList = new ArrayList<>(this.items.size());
      for (Map.Entry<String, ApiType> entry : this.items.entrySet()) {
        itemList.add(entry.getValue());
      }
      return itemList;
    } finally {
      lock.unlock();
    }
  }
520644
public Set<Type> getTypes()
        throws CacheReloadException
    {
        final Set<Type> ret = new HashSet<>();
        for (final Long id : this.types) {
            ret.add(Type.get(id));
        }
        return Collections.unmodifiableSet(ret);
    }