<b>DEPRECATED:</b> Please use <tt>purchase_item</tt> instead.
14763
def purchase(release_id, track_id, price, token, options={})
      warn "[DEPRECATION] 'purchase' is deprecated.  Please use 'purchase_item' instead."
      purchase_item(release_id, track_id, price, token, options)
    end
343960
def request_refund(options = {})
      response = JSON.parse(@client.patch("items/#{send(:id)}/request_refund", options).body)
      @attributes = response['items']
      true
    end
883637
def use_comparative_item_view(self):
        """"""
        self._object_views['item'] = COMPARATIVE
        # self._get_provider_session('item_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_comparative_item_view()
            except AttributeError:
                pass
120013
@Deprecated
	@Override
	public com.liferay.commerce.model.CommerceOrderItem deleteCommerceOrderItem(
		com.liferay.commerce.model.CommerceOrderItem commerceOrderItem)
		throws com.liferay.portal.kernel.exception.PortalException {
		return _commerceOrderItemLocalService.deleteCommerceOrderItem(commerceOrderItem);
	}
173626
public void setPurchaseRequests(java.util.Collection<PurchaseRequest> purchaseRequests) {
        if (purchaseRequests == null) {
            this.purchaseRequests = null;
            return;
        }

        this.purchaseRequests = new com.amazonaws.internal.SdkInternalList<PurchaseRequest>(purchaseRequests);
    }
720979
def _raise_deprecation_note(deprecated, replacement, soft=False):
    
    error_msg = ("`{deprecated}` is deprecated. Please use `{replacement}`. "
                 "`{deprecated}` will be removed in future versions of "
                 "Ray.".format(deprecated=deprecated, replacement=replacement))
    if soft:
        logger.warning(error_msg)
    else:
        raise DeprecationWarning(error_msg)
304797
private <T> T getItem(String itemName, Map<String, T> items, String typeName) {
		T item = items.get(itemName);
		if (item == null) {
			throw new FuzzerException(name + ": " + typeName + " '" + itemName + "' not found");
		}
		return item;
	}
1084722
def _map_purchase_request_to_func(self, purchase_request_type):
        """"""
        
        if purchase_request_type in self._intent_view_funcs:
            view_func = self._intent_view_funcs[purchase_request_type]
        else:
            raise NotImplementedError('Request type "{}" not found and no default view specified.'.format(purchase_request_type)) 

        argspec = inspect.getargspec(view_func)
        arg_names = argspec.args
        arg_values = self._map_params_to_view_args(purchase_request_type, arg_names)

        print('_map_purchase_request_to_func', arg_names, arg_values, view_func, purchase_request_type)
        return partial(view_func, *arg_values)
481615
public void deselect() {
        SelectExtension<Item> selectExtension = mFastAdapter.getExtension(SelectExtension.class);
        if (selectExtension == null) {
            return;
        }
        for (Item item : AdapterUtil.getAllItems(mFastAdapter)) {
            selectExtension.deselect(item);
        }
        mFastAdapter.notifyDataSetChanged();
    }
584309
@Deprecated
    protected <R> BaseRequest<R> prepareRequest(BaseRequest<R> request, String orgToken, String requesterEmail, String product, String productVersion, String userKey,
                                                boolean aggregateModules, boolean preserveModuleStructure, String aggregateProjectName,
                                                String aggregateProjectToken, String logData, String scanComment, String productToken, Map<String, String> extraProperties) {
        request.setOrgToken(orgToken);
        request.setProduct(product);
        request.setProductVersion(productVersion);
        request.setRequesterEmail(requesterEmail);
        request.setUserKey(userKey);
        request.setAggregateModules(aggregateModules);
        request.setPreserveModuleStructure(preserveModuleStructure);
        request.setAggregateProjectName(aggregateProjectName);
        request.setAggregateProjectToken(aggregateProjectToken);
        request.setScanComment(scanComment);
        request.setLogData(logData);
        request.setProductToken(productToken);
        request.setExtraProperties(extraProperties);
        return prepareRequest(request);
    }
954182
@Indexable(type = IndexableType.DELETE)
	@Override
	public CommerceShipmentItem deleteCommerceShipmentItem(
		CommerceShipmentItem commerceShipmentItem) {
		return commerceShipmentItemPersistence.remove(commerceShipmentItem);
	}
132043
@Deprecated
    <T> long[] insert(String table, T[] records, boolean withTransaction) {
        if (N.isNullOrEmpty(records)) {
            return N.EMPTY_LONG_ARRAY;
        }

        final long[] ret = new long[records.length];

        table = formatName(table);

        if (withTransaction) {
            beginTransaction();
        }

        try {
            for (int i = 0, len = records.length; i < len; i++) {
                ret[i] = insert(table, records[i]);
            }

            if (withTransaction) {
                sqliteDB.setTransactionSuccessful();
            }
        } finally {
            if (withTransaction) {
                endTransaction();
            }
        }

        return ret;
    }
1082869
def getItem(self, itemId):
        
        url = "%s/items/%s" % (self.root, itemId)
        return Item(url=url,
                    securityHandler=self._securityHandler,
                    proxy_url=self._proxy_url,
                    proxy_port=self._proxy_port)
720516
public void consumeAsync(List<Purchase> purchases, OnConsumeMultiFinishedListener listener) {
        checkNotDisposed();
        checkSetupDone("consume");
        consumeAsyncInternal(purchases, null, listener);
    }
1255306
public synchronized void putShort(short item)
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "putShort", Short.valueOf(item));

      checkValid();
      getCurrentByteBuffer(2).putShort(item);

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "putShort");
   }
98496
public int add(T item) {
		if (itemIndex.containsKey(item)) {
			// Items can only be added once
			return itemIndex.get(item);
		}
		int index = items.size();
		itemIndex.put(item, index);
		items.add(item);
		return index;
	}
184853
function(item) {
        if (item && Selectivity.isValidId(item.id) && isString(item.text)) {
            return item;
        } else {
            throw new Error('Item should have id (number or string) and text (string) properties');
        }
    }