code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public void releaseMailAccountForThread(final String accountReservationKey) {
lock.lock();
try {
MailAccount mailAccount = lookupUsedMailAccountForCurrentThread(accountReservationKey);
releaseMailAccountForThread(mailAccount);
} finally {
lock.unlock();
}
} | java |
public static MozuUrl addProductSortDefinitionUrl(String responseFields, Boolean useProvidedId)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/admin/productsortdefinitions/?useProvidedId={useProvidedId}&responseFields={responseFields}");
formatter.formatUrl("responseFields", responseFields);
formatter.formatUrl("useProvidedId", useProvidedId);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl updateProductSortDefinitionUrl(Integer productSortDefinitionId, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/admin/productsortdefinitions/{productSortDefinitionId}?responseFields={responseFields}");
formatter.formatUrl("productSortDefinitionId", productSortDefinitionId);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl deleteProductSortDefinitionUrl(Integer productSortDefinitionId)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/admin/productsortdefinitions/{productSortDefinitionId}");
formatter.formatUrl("productSortDefinitionId", productSortDefinitionId);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
@Override
public boolean hasNextCase() {
for (ConstraintWrap wrap : summands) {
if (wrap.constraint.hasNextCase()) {
return true;
}
}
return false;
} | java |
public synchronized void registerHandler(Object handler) {
boolean validClass = false;
if (handler==null) {
throw new IllegalArgumentException("Null handler class");
}
// Get the implemented interfaces. This gets only the
// directly implemented interfaces
Class<?> clazz = handler.getClass();
Class<?> interfaces[] = clazz.getInterfaces();
for (int i=0; i<interfaces.length; i++) {
String iName = interfaces[i].getSimpleName();
// verify the interface is for an event interface
if (iName.contains(EVENT_INTERFACE_SUFFIX)) {
validClass = true;
String eventCategory = iName.substring(0, iName.indexOf(EVENT_INTERFACE_SUFFIX)).toLowerCase();
// see if a handler has been registered for the interface type
if (eventHandlers.get(eventCategory)==null) {
eventHandlers.put(eventCategory, handler);
} else {
throw new ApiException("Handler already registered for event type " + iName);
}
}
}
if (!validClass) {
throw new ApiException("Class is invalid, it does not implement any event interfaces: " + clazz.getName());
}
} | java |
public void merge(OrderedIntDoubleMapping updates, DoubleDoubleFunction func) {
int[] updateIndices = updates.getIndices();
double[] updateValues = updates.getValues();
int newNumMappings = numMappings + updates.getNumMappings();
int newCapacity = Math
.max((int) (1.2 * newNumMappings), newNumMappings + 1);
int[] newIndices = new int[newCapacity];
double[] newValues = new double[newCapacity];
int k = 0;
int i = 0, j = 0;
for (; i < numMappings && j < updates.getNumMappings(); ++k) {
if (indices[i] < updateIndices[j]) {
newIndices[k] = indices[i];
newValues[k] = func.apply(values[i], 0);
++i;
} else if (indices[i] > updateIndices[j]) {
newIndices[k] = updateIndices[j];
newValues[k] = func.apply(0, updateValues[j]);
++j;
} else {
newIndices[k] = updateIndices[j];
newValues[k] = func.apply(values[i], updateValues[j]);
++i;
++j;
}
}
if (i < numMappings) {
int delta = numMappings - i;
System.arraycopy(indices, i, newIndices, k, delta);
System.arraycopy(values, i, newValues, k, delta);
k += delta;
}
if (j < updates.getNumMappings()) {
int delta = updates.getNumMappings() - j;
System.arraycopy(updateIndices, j, newIndices, k, delta);
System.arraycopy(updateValues, j, newValues, k, delta);
k += delta;
}
indices = newIndices;
values = newValues;
numMappings = k;
} | java |
public Field createField(final MathRandom random, final Element element, final String characterSetId) {
Field field = null;
Element fieldElement = null;
Element fieldRefElement = element.getChild(XMLTags.FIELD_REF);
if (fieldRefElement != null) {
fieldElement = getElementFinder(element).findElementById(fieldRefElement);
} else {
fieldElement = element.getChild(XMLTags.FIELD);
}
checkState(fieldElement != null, "Could not find a Field tag or FieldRef tag");
Class<? extends Field> classObject = null;
try {
classObject = getClassObject(fieldElement);
Constructor<? extends Field> constructor = classObject.getConstructor(new Class[] { MathRandom.class, Element.class, String.class });
field = constructor.newInstance(new Object[] { random, fieldElement, characterSetId });
} catch (Exception e) {
throw new IllegalStateException("Could not initialise object of class " + classObject, e);
}
return field;
} | java |
private Class<? extends Field> getClassObject(final Element element) {
String className = element.getAttributeValue(XMLTags.CLASS);
Class<? extends Field> classObject = null;
try {
className = className.indexOf('.') > 0 ? className : getClass().getPackage().getName() + '.' + className;
classObject = Class.forName(className).asSubclass(Field.class);
} catch (ClassNotFoundException e) {
throw new IllegalStateException("could not get class " + className, e);
}
return classObject;
} | java |
public static PointLocation parsePointLocation(final String representation)
throws ParserException
{
if (StringUtils.isBlank(representation))
{
throw new ParserException("No point location value provided");
}
if (!StringUtils.endsWith(representation, "/"))
{
throw new ParserException("Point location value must be terminated with /");
}
final PointLocationParser parser = new PointLocationParser();
final CoordinateParser coordinateParser = new CoordinateParser();
// Split by group
final List<String> tokens = parser.split(representation);
if (tokens.size() != 4)
{
throw new ParserException("Cannot parse " + representation);
}
final Latitude latitude = coordinateParser.parseLatitude(tokens.get(0));
final Longitude longitude = coordinateParser.parseLongitude(tokens.get(1));
final double altitude = NumberUtils.toDouble(tokens.get(2));
final String coordinateReferenceSystemIdentifier = StringUtils
.trimToEmpty(tokens.get(3));
final PointLocation pointLocation = new PointLocation(latitude,
longitude,
altitude,
coordinateReferenceSystemIdentifier);
return pointLocation;
} | java |
public static MozuUrl getPropertyValueLocalizedContentsUrl(String attributeFQN, String productCode, String value)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/admin/products/{productCode}/Properties/{attributeFQN}/values/{value}/LocalizedContent");
formatter.formatUrl("attributeFQN", attributeFQN);
formatter.formatUrl("productCode", productCode);
formatter.formatUrl("value", value);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl deletePropertyUrl(String attributeFQN, String productCode)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/admin/products/{productCode}/Properties/{attributeFQN}");
formatter.formatUrl("attributeFQN", attributeFQN);
formatter.formatUrl("productCode", productCode);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getProductsUrl(String cursorMark, String defaultSort, String filter, Integer pageSize, String responseFields, String responseOptions, String sortBy, Integer startIndex)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/storefront/products/?filter={filter}&startIndex={startIndex}&pageSize={pageSize}&sortBy={sortBy}&responseOptions={responseOptions}&cursorMark={cursorMark}&defaultSort={defaultSort}&responseFields={responseFields}");
formatter.formatUrl("cursorMark", cursorMark);
formatter.formatUrl("defaultSort", defaultSort);
formatter.formatUrl("filter", filter);
formatter.formatUrl("pageSize", pageSize);
formatter.formatUrl("responseFields", responseFields);
formatter.formatUrl("responseOptions", responseOptions);
formatter.formatUrl("sortBy", sortBy);
formatter.formatUrl("startIndex", startIndex);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getProductInventoryUrl(String locationCodes, String productCode, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/storefront/products/{productCode}/locationinventory?locationCodes={locationCodes}&responseFields={responseFields}");
formatter.formatUrl("locationCodes", locationCodes);
formatter.formatUrl("productCode", productCode);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getProductUrl(Boolean acceptVariantProductCode, Boolean allowInactive, String productCode, String purchaseLocation, Integer quantity, String responseFields, Boolean skipInventoryCheck, Boolean supressOutOfStock404, String variationProductCode, String variationProductCodeFilter)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/storefront/products/{productCode}?variationProductCode={variationProductCode}&allowInactive={allowInactive}&skipInventoryCheck={skipInventoryCheck}&supressOutOfStock404={supressOutOfStock404}&quantity={quantity}&acceptVariantProductCode={acceptVariantProductCode}&purchaseLocation={purchaseLocation}&variationProductCodeFilter={variationProductCodeFilter}&responseFields={responseFields}");
formatter.formatUrl("acceptVariantProductCode", acceptVariantProductCode);
formatter.formatUrl("allowInactive", allowInactive);
formatter.formatUrl("productCode", productCode);
formatter.formatUrl("purchaseLocation", purchaseLocation);
formatter.formatUrl("quantity", quantity);
formatter.formatUrl("responseFields", responseFields);
formatter.formatUrl("skipInventoryCheck", skipInventoryCheck);
formatter.formatUrl("supressOutOfStock404", supressOutOfStock404);
formatter.formatUrl("variationProductCode", variationProductCode);
formatter.formatUrl("variationProductCodeFilter", variationProductCodeFilter);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getProductForIndexingUrl(DateTime lastModifiedDate, String productCode, Long productVersion, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/storefront/products/indexing/{productCode}?productVersion={productVersion}&lastModifiedDate={lastModifiedDate}&responseFields={responseFields}");
formatter.formatUrl("lastModifiedDate", lastModifiedDate);
formatter.formatUrl("productCode", productCode);
formatter.formatUrl("productVersion", productVersion);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl configuredProductUrl(Boolean includeOptionDetails, String productCode, String purchaseLocation, Integer quantity, String responseFields, Boolean skipInventoryCheck, String variationProductCodeFilter)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/storefront/products/{productCode}/configure?includeOptionDetails={includeOptionDetails}&skipInventoryCheck={skipInventoryCheck}&quantity={quantity}&purchaseLocation={purchaseLocation}&variationProductCodeFilter={variationProductCodeFilter}&responseFields={responseFields}");
formatter.formatUrl("includeOptionDetails", includeOptionDetails);
formatter.formatUrl("productCode", productCode);
formatter.formatUrl("purchaseLocation", purchaseLocation);
formatter.formatUrl("quantity", quantity);
formatter.formatUrl("responseFields", responseFields);
formatter.formatUrl("skipInventoryCheck", skipInventoryCheck);
formatter.formatUrl("variationProductCodeFilter", variationProductCodeFilter);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl validateProductUrl(String productCode, String purchaseLocation, Integer quantity, String responseFields, Boolean skipDefaults, Boolean skipInventoryCheck)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/storefront/products/{productCode}/validate?skipInventoryCheck={skipInventoryCheck}&quantity={quantity}&skipDefaults={skipDefaults}&purchaseLocation={purchaseLocation}&responseFields={responseFields}");
formatter.formatUrl("productCode", productCode);
formatter.formatUrl("purchaseLocation", purchaseLocation);
formatter.formatUrl("quantity", quantity);
formatter.formatUrl("responseFields", responseFields);
formatter.formatUrl("skipDefaults", skipDefaults);
formatter.formatUrl("skipInventoryCheck", skipInventoryCheck);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl validateDiscountsUrl(Boolean allowInactive, Integer customerAccountId, String productCode, String responseFields, Boolean skipInventoryCheck, String variationProductCode)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/storefront/products/{productCode}/validateDiscounts?variationProductCode={variationProductCode}&customerAccountId={customerAccountId}&allowInactive={allowInactive}&skipInventoryCheck={skipInventoryCheck}&responseFields={responseFields}");
formatter.formatUrl("allowInactive", allowInactive);
formatter.formatUrl("customerAccountId", customerAccountId);
formatter.formatUrl("productCode", productCode);
formatter.formatUrl("responseFields", responseFields);
formatter.formatUrl("skipInventoryCheck", skipInventoryCheck);
formatter.formatUrl("variationProductCode", variationProductCode);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getLocationInventoryUrl(String locationCode, String productCode, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/admin/locationinventory/{locationCode}/{productCode}?responseFields={responseFields}");
formatter.formatUrl("locationCode", locationCode);
formatter.formatUrl("productCode", productCode);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl addLocationInventoryUrl(String locationCode, Boolean performUpserts)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/admin/locationinventory/{locationCode}?performUpserts={performUpserts}");
formatter.formatUrl("locationCode", locationCode);
formatter.formatUrl("performUpserts", performUpserts);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl deleteLocationInventoryUrl(String locationCode, String productCode)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/admin/locationinventory/{locationCode}/{productCode}");
formatter.formatUrl("locationCode", locationCode);
formatter.formatUrl("productCode", productCode);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getOrderNotesUrl(String orderId)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/orders/{orderId}/notes");
formatter.formatUrl("orderId", orderId);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getOrderNoteUrl(String noteId, String orderId, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/orders/{orderId}/notes/{noteId}?responseFields={responseFields}");
formatter.formatUrl("noteId", noteId);
formatter.formatUrl("orderId", orderId);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl deleteOrderNoteUrl(String noteId, String orderId)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/orders/{orderId}/notes/{noteId}");
formatter.formatUrl("noteId", noteId);
formatter.formatUrl("orderId", orderId);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
@Override
public Set<String> getContainedIds() {
Set<String> s = super.getContainedIds();
s.addAll(constraint.getContainedIds());
return s;
} | java |
private void purgeSmsOlderThan(final Date date) {
logger.debug("Starting purge of SMS table with parameter : \n" + " - date : " + date);
final int nbSmsDeleted = daoService.deleteSmsOlderThan(date);
logger.debug("End purge of SMS table, result : \n" +
" - number of sms deleted : " + nbSmsDeleted);
} | java |
public static MozuUrl updateExtendedPropertyUrl(String key, String responseFields, Boolean upsert)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/carts/current/extendedproperties/{key}?upsert={upsert}&responseFields={responseFields}");
formatter.formatUrl("key", key);
formatter.formatUrl("responseFields", responseFields);
formatter.formatUrl("upsert", upsert);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl updateExtendedPropertiesUrl(Boolean upsert)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/carts/current/extendedproperties?upsert={upsert}");
formatter.formatUrl("upsert", upsert);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl deleteExtendedPropertiesUrl()
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/carts/current/extendedproperties");
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
@Override
protected String initValuesImpl(final FieldCase ca) {
if (ca == FieldCase.NULL || ca == FieldCase.BLANK) {
return null;
}
String s = super.initValuesImpl(ca);
int counter = 10000;
while (set.contains(s) && counter > 0) {
s = super.initValuesImpl(ca);
counter--;
}
if (counter == 0) {
throw new IllegalStateException("Could not generate unique value");
}
set.add(s);
return s;
} | java |
@Override
public int getMaxLength() {
int max = -1;
for (Constraint c : constraints) {
int cM = c.getMaxLength();
if (max < cM) {
max = cM;
}
}
return max;
} | java |
@Override
public String initValues(final FieldCase ca) {
if (ca != null) {
/*
* If a FieldCase is given all fields will be generated anew, independent of the case
* combination.
*/
for (Constraint c : constraints) {
c.resetValues();
}
}
for (Constraint c : constraints) {
c.initValues(ca);
}
return null;
} | java |
@Override
public void resetValues() {
int length = constraints.size();
for (int i = length - 1; i >= 0; i--) {
Constraint c = constraints.get(i);
c.resetValues();
if (dependent && c.hasNextCase()) {
// reset all constraints below
// only if the constraint above still has a case to be processed
for (int j = i + 1; j < length; j++) {
constraints.get(j).resetCase();
}
break;
}
}
} | java |
public char[] getCharacters(final int size, final int bad) {
if (size == 0) {
return new char[0];
}
char[] chars = new char[size];
for (int i = 0; i < chars.length; i++) {
chars[i] = field.getAllowedCharacter();
}
// remove leading blanks
for (int i = 0; i < 10 && Character.isSpaceChar(chars[0]); i++) {
chars[0] = field.getAllowedCharacter();
}
// remove trailing blanks
for (int i = 0; i < 10 && Character.isSpaceChar(chars[chars.length - 1]); i++) {
chars[chars.length - 1] = field.getAllowedCharacter();
}
int toBeReplaced = bad;
if (-2 == bad) {
if (!canBad()) {
if (log.isDebugEnabled()) {
log.debug("This node does not allow negative characters, " + "but as all characters shall be negative no character is returned");
}
return new char[0];
}
toBeReplaced = chars.length;
} else if (-1 == bad) {
// 1 - (all -1) characters are replaced
toBeReplaced = 1 + rnd.getInt(chars.length - 2);
}
if (toBeReplaced > 0) {
// create a random index list
List<Integer> l = new ArrayList<Integer>(chars.length);
for (int i = 0; i < chars.length; i++) {
l.add(i);
}
Collections.shuffle(l);
for (int i = 0; i < toBeReplaced; i++) {
int index = l.remove(0);
Character currentBad = field.getForbiddenCharacter();
if (currentBad == null) {
log.warn("This node does not allow negative characters");
break;
}
// The first and the last character as a forbidden character is not a space!
// this would usually shorten the length
if (index == 0 || index == chars.length - 1) {
int counter = 0;
while (counter < 100 && Character.isSpaceChar(currentBad)) {
currentBad = field.getForbiddenCharacter();
counter++;
}
if (counter == 100) {
log.warn("Space is the only possible forbidden character for this node, no replacement!");
break;
}
}
if (log.isDebugEnabled()) {
log.debug("Replace Character " + Character.toString(chars[index]) + " with " + Character.toString(currentBad));
}
chars[index] = currentBad;
}
}
return chars;
} | java |
public static MozuUrl getThirdPartyPaymentWorkflowWithValuesUrl(String fullyQualifiedName, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/settings/checkout/paymentsettings/thirdpartyworkflow/{fullyQualifiedName}?responseFields={responseFields}");
formatter.formatUrl("fullyQualifiedName", fullyQualifiedName);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getThirdPartyPaymentWorkflowsUrl()
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/settings/checkout/paymentsettings/thirdpartyworkflows");
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl addThirdPartyPaymentWorkflowUrl()
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/settings/checkout/paymentsettings/thirdpartyworkflows");
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl deleteThirdPartyPaymentWorkflowUrl(String fullyQualifiedName)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/settings/checkout/paymentsettings/thirdpartyworkflows/{fullyQualifiedName}");
formatter.formatUrl("fullyQualifiedName", fullyQualifiedName);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getAvailableDigitalPackageFulfillmentActionsUrl(String digitalPackageId, String orderId)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/orders/{orderId}/digitalpackages/{digitalPackageId}/actions");
formatter.formatUrl("digitalPackageId", digitalPackageId);
formatter.formatUrl("orderId", orderId);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getDigitalPackageUrl(String digitalPackageId, String orderId, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/orders/{orderId}/digitalpackages/{digitalPackageId}?responseFields={responseFields}");
formatter.formatUrl("digitalPackageId", digitalPackageId);
formatter.formatUrl("orderId", orderId);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
@Cmd
public Reporter registerReporter(final Reporter reporter) {
injector.injectMembers(reporter);
reporters.add(reporter);
return reporter;
} | java |
@Cmd
public File chooseFile(final String fileKey) {
log.debug("Opening file chooser dialog");
JFileChooser fileChooser = new JFileChooser(System.getProperty(JFunkConstants.USER_DIR));
fileChooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
fileChooser.setPreferredSize(new Dimension(600, 326));
int fileChooserResult = fileChooser.showOpenDialog(null);
if (fileChooserResult == JFileChooser.APPROVE_OPTION) {
File file = fileChooser.getSelectedFile();
String filename = file.toString();
log.info("Assigning file path '{}' to property '{}'", filename, fileKey);
config.put(fileKey, filename);
return file;
}
log.error("No file or directory was chosen, execution will abort");
throw new IllegalArgumentException("No file or directory was chosen");
} | java |
@Cmd
public String chooseRandom(final String propertyKey, final List<String> randomValues) {
Randomizable<String> choice = new RandomCollection<>(random, randomValues);
String currentValue = choice.get();
if (log.isDebugEnabled()) {
log.debug("Chosen value: " + currentValue);
}
currentValue = resolveProperty(currentValue);
config.put(propertyKey, currentValue);
if (log.isDebugEnabled()) {
log.debug("... value for '{}' was set to {}", propertyKey, currentValue);
}
return currentValue;
} | java |
@Cmd
public void module(final String moduleName, final Map<?, ?> attributes, final Closure<Void> closure) {
moduleBuilderProvider.get().invokeMethod("module", newArrayList(moduleName, attributes, closure));
} | java |
@Cmd
public void onError(final Closure<Void> closure) {
int errorCount = errors.size();
if (errorCount > 0) {
log.info(errorCount + " error" + (errorCount == 1 ? "" : "s") + " in list --> executing block");
closure.call();
log.info("Finished OnError block");
} else {
log.info("No errors in list --> skipping block");
}
} | java |
@Cmd
public void optional(final Closure<Void> closure) {
log.info("Executing optional block ...");
try {
closure.call();
} catch (final Exception ex) {
log.error("Exception executing optional block: " + ex.getMessage(), ex);
errors.add(ex);
} catch (AssertionError err) {
log.error("Assertion failed executing optional block: " + err.getMessage(), err);
errors.add(err);
}
log.info("... finished execution of optional block");
} | java |
@Cmd
public void processCsvFile(final String csvFile, final String delimiter, final char quoteChar, final Charset charset,
final Closure<Void> closure) {
File f = new File(csvFile);
try {
config.extractFromArchive(f, true);
checkState(f.exists(), "CSV file not found: " + f);
Reader reader = Files.newReader(f, charset == null ? defaultCharset : charset);
csvDataProcessor.processFile(reader, delimiter, quoteChar, closure);
} catch (IOException ex) {
throw new IllegalStateException("Error reading CSV file: " + f, ex);
}
} | java |
@Cmd
public String prompt(final String configKey, final String message) {
System.out.print(resolveProperty(message) + " "); //NOSONAR
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
try {
String value = StringUtils.trim(in.readLine());
config.put(configKey, value);
return value;
// Stream nicht schliessen
} catch (IOException ex) {
throw new IllegalStateException(ex);
}
} | java |
public Rectangle intersection(Rectangle other) {
int left = Math.max(this.left, other.left);
int top = Math.max(this.top, other.top);
int right = Math.min(this.right, other.right);
int bottom = Math.min(this.bottom, other.bottom);
if (right >= left && bottom >= top) {
int height = bottom - top;
int width = right - left;
return new Rectangle(top, left, bottom, right, width, height);
} else {
return null;
}
} | java |
public static MozuUrl deleteChannelUrl(String code)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/channels/{code}");
formatter.formatUrl("code", code);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static String getMemoryInfo(final Unit unit) {
final long[] memory = getMemoryInfo();
for (final Type type : Type.values()) {
memory[type.ordinal()] /= unit.getDenominator();
}
final StringBuilder sb = new StringBuilder(100);
sb.append("Memory (free/total/max): ");
sb.append(memory[Type.FREE.ordinal()]);
sb.append(unit.getUnitString());
sb.append("/");
sb.append(memory[Type.TOTAL.ordinal()]);
sb.append(unit.getUnitString());
sb.append("/");
sb.append(memory[Type.MAX.ordinal()]);
sb.append(unit.getUnitString());
return sb.toString();
} | java |
public static MozuUrl transformDocumentContentUrl(String crop, String documentId, String documentListName, Integer height, Integer max, Integer maxHeight, Integer maxWidth, Integer quality, Integer width)
{
UrlFormatter formatter = new UrlFormatter("/api/content/documentlists/{documentListName}/documents/{documentId}/transform?width={width}&height={height}&maxWidth={maxWidth}&maxHeight={maxHeight}&crop={crop}&quality={quality}");
formatter.formatUrl("crop", crop);
formatter.formatUrl("documentId", documentId);
formatter.formatUrl("documentListName", documentListName);
formatter.formatUrl("height", height);
formatter.formatUrl("max", max);
formatter.formatUrl("maxHeight", maxHeight);
formatter.formatUrl("maxWidth", maxWidth);
formatter.formatUrl("quality", quality);
formatter.formatUrl("width", width);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getDocumentUrl(String documentId, String documentListName, Boolean includeInactive, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/content/documentlists/{documentListName}/documents/{documentId}?includeInactive={includeInactive}&responseFields={responseFields}");
formatter.formatUrl("documentId", documentId);
formatter.formatUrl("documentListName", documentListName);
formatter.formatUrl("includeInactive", includeInactive);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl updateDocumentUrl(String documentId, String documentListName, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/content/documentlists/{documentListName}/documents/{documentId}?responseFields={responseFields}");
formatter.formatUrl("documentId", documentId);
formatter.formatUrl("documentListName", documentListName);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl deleteDocumentUrl(String documentId, String documentListName)
{
UrlFormatter formatter = new UrlFormatter("/api/content/documentlists/{documentListName}/documents/{documentId}");
formatter.formatUrl("documentId", documentId);
formatter.formatUrl("documentListName", documentListName);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl deleteCouponUrl(String couponCode, String couponSetCode)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/admin/couponsets/{couponSetCode}/couponcodes/{couponCode}");
formatter.formatUrl("couponCode", couponCode);
formatter.formatUrl("couponSetCode", couponSetCode);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static String about()
{
final StringBuffer about = new StringBuffer();
about.append(getProductName()).append(" ").append(getVersion())
.append("\n").append("\u00A9 2007-2014 Sualeh Fatehi"); //$NON-NLS-2$
return new String(about);
} | java |
public static HighScoringPair valueOf(final String value) {
checkNotNull(value);
List<String> tokens = Splitter.on("\t").trimResults().splitToList(value);
if (tokens.size() != 12) {
throw new IllegalArgumentException("value must have twelve fields");
}
String source = tokens.get(0).trim();
String target = tokens.get(1).trim();
double percentIdentity = Double.parseDouble(tokens.get(2).trim());
long alignmentLength = Long.parseLong(tokens.get(3).trim());
int mismatches = Integer.parseInt(tokens.get(4).trim());
int gapOpens = Integer.parseInt(tokens.get(5).trim());
long sourceStart = Long.parseLong(tokens.get(6).trim());
long sourceEnd = Long.parseLong(tokens.get(7).trim());
long targetStart = Long.parseLong(tokens.get(8).trim());
long targetEnd = Long.parseLong(tokens.get(9).trim());
double evalue = Double.parseDouble(tokens.get(10).trim());
double bitScore = Double.parseDouble(tokens.get(11).trim());
return new HighScoringPair(source, target, percentIdentity, alignmentLength, mismatches, gapOpens, sourceStart, sourceEnd, targetStart, targetEnd, evalue, bitScore);
} | java |
@Override
public void exitScope() {
Map<Key<?>, Object> scopeMap = scopeStackCache.get().peek();
performDisposal(scopeMap);
scopeStackCache.get().pop();
log.debug("Exited scope.");
} | java |
public static MozuUrl removeAllMessagesUrl()
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/carts/current/messages");
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl removeMessageUrl(String messageId)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/carts/current/messages/{messageId}");
formatter.formatUrl("messageId", messageId);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
@Override
public E get() {
if (originalElements.isEmpty()) {
return null;
}
if (!priorityElements.isEmpty()) {
return priorityElements.remove(0);
}
if (currentElements.size() <= originalElements.size()) {
currentElements.addAll(originalElements);
}
int index = random.getInt(currentElements.size() - 1);
return currentElements.remove(index);
} | java |
@Override
public void reset() {
this.priorityElements = Lists.newArrayList(originalElements);
Collections.shuffle(priorityElements);
this.currentElements = Lists.newArrayListWithExpectedSize(2 * originalElements.size());
this.currentElements.addAll(originalElements);
} | java |
public static MozuUrl getWishlistByNameUrl(Integer customerAccountId, String responseFields, String wishlistName)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/wishlists/customers/{customerAccountId}/{wishlistName}?responseFields={responseFields}");
formatter.formatUrl("customerAccountId", customerAccountId);
formatter.formatUrl("responseFields", responseFields);
formatter.formatUrl("wishlistName", wishlistName);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl updateWishlistUrl(String responseFields, String wishlistId)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/wishlists/{wishlistId}?responseFields={responseFields}");
formatter.formatUrl("responseFields", responseFields);
formatter.formatUrl("wishlistId", wishlistId);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getApplicationUrl(String appId, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/platform/applications/{appId}?responseFields={responseFields}");
formatter.formatUrl("appId", appId);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public double[] getColumn(int col) {
double[] column = new double[numRows];
int offset = translate(0, col, numRows);
for (int i = 0; i < column.length; i++) {
column[i] = matrix[offset + i];
}
return column;
} | java |
public double[] getRow(int row) {
double[] rowArray = new double[getColumnCount()];
for (int i = 0; i < getColumnCount(); i++) {
rowArray[i] = get(row, i);
}
return rowArray;
} | java |
public void setRow(int row, double[] value) {
for (int i = 0; i < value.length; i++) {
this.matrix[translate(row, i, numRows)] = value[i];
}
} | java |
public void setColumn(int col, double[] values) {
int offset = translate(0, col, numRows);
System.arraycopy(values, 0, matrix, offset, values.length);
} | java |
public static MozuUrl getCartUrl(String cartId, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/carts/{cartId}?responseFields={responseFields}");
formatter.formatUrl("cartId", cartId);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getUserCartSummaryUrl(String responseFields, String userId)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/carts/user/{userId}/summary?responseFields={responseFields}");
formatter.formatUrl("responseFields", responseFields);
formatter.formatUrl("userId", userId);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl rejectSuggestedDiscountUrl(String cartId, Integer discountId, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/carts/{cartId}/rejectautodiscount/{discountId}?responseFields={responseFields}");
formatter.formatUrl("cartId", cartId);
formatter.formatUrl("discountId", discountId);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl deleteCurrentCartUrl()
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/carts/current");
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl getViewDocumentsUrl(String documentListName, String filter, Boolean includeInactive, Integer pageSize, String responseFields, String sortBy, Integer startIndex, String viewName)
{
UrlFormatter formatter = new UrlFormatter("/api/content/documentlists/{documentListName}/views/{viewName}/documents?filter={filter}&sortBy={sortBy}&pageSize={pageSize}&startIndex={startIndex}&includeInactive={includeInactive}&responseFields={responseFields}");
formatter.formatUrl("documentListName", documentListName);
formatter.formatUrl("filter", filter);
formatter.formatUrl("includeInactive", includeInactive);
formatter.formatUrl("pageSize", pageSize);
formatter.formatUrl("responseFields", responseFields);
formatter.formatUrl("sortBy", sortBy);
formatter.formatUrl("startIndex", startIndex);
formatter.formatUrl("viewName", viewName);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
static void checkClosedOpen(final Range<Long> range) {
checkNotNull(range);
checkArgument(BoundType.CLOSED == range.lowerBoundType(), "range must be [closed, open), lower bound type was open");
checkArgument(BoundType.OPEN == range.upperBoundType(), "range must be [closed, open), upper bound type was closed");
} | java |
public static long length(final Range<Long> range) {
checkClosedOpen(range);
return Math.max(0L, range.upperEndpoint() - range.lowerEndpoint());
} | java |
public static List<Long> lengths(final Iterable<Range<Long>> ranges) {
checkNotNull(ranges);
List<Long> lengths = new ArrayList<Long>();
for (Range<Long> range : ranges) {
lengths.add(length(range));
}
return lengths;
} | java |
public static long length(final Iterable<Range<Long>> ranges) {
checkNotNull(ranges);
RangeSet<Long> rangeSet = TreeRangeSet.create();
for (Range<Long> range : ranges) {
rangeSet.add(range);
}
long length = 0L;
for (Range<Long> range : rangeSet.asRanges()) {
length += length(range);
}
return length;
} | java |
public static int count(final Iterable<Range<Long>> ranges) {
int count = 0;
for (Range<Long> range : ranges) {
checkClosedOpen(range);
count++;
}
return count;
} | java |
static boolean isGapSymbol(final Symbol symbol) {
return AlphabetManager.getGapSymbol().equals(symbol)
|| DNATools.getDNA().getGapSymbol().equals(symbol);
} | java |
static boolean isMatchSymbol(final Symbol symbol) {
if (!(symbol instanceof BasisSymbol)) {
return false;
}
BasisSymbol basisSymbol = (BasisSymbol) symbol;
Set<Symbol> uniqueSymbols = new HashSet<Symbol>();
for (Object o : basisSymbol.getSymbols()) {
Symbol s = (Symbol) o;
if (isGapSymbol(s)) {
return false;
}
uniqueSymbols.add((Symbol) o);
}
return (uniqueSymbols.size() == 1);
} | java |
public static List<Range<Long>> gaps(final GappedSymbolList gappedSymbols) {
checkNotNull(gappedSymbols);
List<Range<Long>> gaps = new ArrayList<Range<Long>>();
int gapStart = -1;
for (int i = 1, length = gappedSymbols.length() + 1; i < length; i++) {
if (isGapSymbol(gappedSymbols.symbolAt(i))) {
if (gapStart < 0) {
gapStart = i;
}
}
else {
if (gapStart > 0) {
// biojava coordinates are 1-based
gaps.add(Range.closedOpen(Long.valueOf(gapStart - 1L), Long.valueOf(i - 1L)));
gapStart = -1;
}
}
}
if (gapStart > 0) {
gaps.add(Range.closedOpen(Long.valueOf(gapStart - 1L), Long.valueOf(gappedSymbols.length())));
}
return gaps;
} | java |
public static List<Range<Long>> matches(final AlignmentPair alignmentPair) {
checkNotNull(alignmentPair);
List<Range<Long>> matches = new ArrayList<Range<Long>>();
int matchStart = -1;
for (int i = 1, length = alignmentPair.length() + 1; i < length; i++) {
if (isMatchSymbol(alignmentPair.symbolAt(i))) {
if (matchStart < 0) {
matchStart = i;
}
}
else {
if (matchStart > 0) {
// biojava coordinates are 1-based
matches.add(Range.closedOpen(Long.valueOf(matchStart - 1L), Long.valueOf(i - 1L)));
matchStart = -1;
}
}
}
if (matchStart > 0) {
matches.add(Range.closedOpen(Long.valueOf(matchStart - 1L), Long.valueOf(alignmentPair.length())));
}
return matches;
} | java |
public static List<Range<Long>> mismatches(final AlignmentPair alignmentPair) {
checkNotNull(alignmentPair);
List<Range<Long>> mismatches = new ArrayList<Range<Long>>();
int mismatchStart = -1;
for (int i = 1, length = alignmentPair.length() + 1; i < length; i++) {
if (isMismatchSymbol(alignmentPair.symbolAt(i))) {
if (mismatchStart < 0) {
mismatchStart = i;
}
}
else {
if (mismatchStart > 0) {
// biojava coordinates are 1-based
mismatches.add(Range.closedOpen(Long.valueOf(mismatchStart - 1L), Long.valueOf(i - 1L)));
mismatchStart = -1;
}
}
}
if (mismatchStart > 0) {
mismatches.add(Range.closedOpen(Long.valueOf(mismatchStart - 1L), Long.valueOf(alignmentPair.length())));
}
return mismatches;
} | java |
public static <C extends Comparable> C center(final Range<C> range) {
checkNotNull(range);
if (!range.hasLowerBound() && !range.hasUpperBound()) {
throw new IllegalStateException("cannot find the center of a range without bounds");
}
if (!range.hasLowerBound()) {
return range.upperEndpoint();
}
if (!range.hasUpperBound()) {
return range.lowerEndpoint();
}
C lowerEndpoint = range.lowerEndpoint();
C upperEndpoint = range.upperEndpoint();
if (upperEndpoint instanceof Integer) {
Integer upper = (Integer) upperEndpoint;
Integer lower = (Integer) lowerEndpoint;
return (C) Integer.valueOf((upper.intValue() + lower.intValue()) / 2);
}
if (upperEndpoint instanceof Long) {
Long upper = (Long) upperEndpoint;
Long lower = (Long) lowerEndpoint;
return (C) Long.valueOf((upper.longValue() + lower.longValue()) / 2L);
}
if (upperEndpoint instanceof BigInteger) {
BigInteger upper = (BigInteger) upperEndpoint;
BigInteger lower = (BigInteger) lowerEndpoint;
BigInteger two = BigInteger.valueOf(2L);
return (C) upper.subtract(lower).divide(two);
}
// todo: could potentially calculate the center of any range with a discrete domain
throw new IllegalStateException("cannot find the center of a range whose endpoint type is not Integer, Long, or BigInteger");
} | java |
public static <C extends Comparable> boolean intersect(final Range<C> range0, final Range<C> range1) {
checkNotNull(range0);
checkNotNull(range1);
return range0.isConnected(range1) && !range0.intersection(range1).isEmpty();
} | java |
public static <C extends Comparable> boolean isLessThan(final Range<C> range, final C value) {
checkNotNull(range);
checkNotNull(value);
if (!range.hasUpperBound()) {
return false;
}
if (range.upperBoundType() == BoundType.OPEN && range.upperEndpoint().equals(value)) {
return true;
}
return range.upperEndpoint().compareTo(value) < 0;
} | java |
public static <C extends Comparable> boolean isGreaterThan(final Range<C> range, final C value) {
checkNotNull(range);
checkNotNull(value);
if (!range.hasLowerBound()) {
return false;
}
if (range.lowerBoundType() == BoundType.OPEN && range.lowerEndpoint().equals(value)) {
return true;
}
return range.lowerEndpoint().compareTo(value) > 0;
} | java |
public static <C extends Comparable> Ordering<Range<C>> orderingByLowerEndpoint() {
return new Ordering<Range<C>>() {
@Override
public int compare(final Range<C> left, final Range<C> right) {
return ComparisonChain.start()
.compare(left.hasLowerBound(), right.hasLowerBound())
.compare(left.lowerEndpoint(), right.lowerEndpoint())
.result();
}
};
} | java |
public static <C extends Comparable> Ordering<Range<C>> reverseOrderingByLowerEndpoint() {
Ordering<Range<C>> orderingByLowerEndpoint = orderingByLowerEndpoint();
return orderingByLowerEndpoint.reverse();
} | java |
public static <C extends Comparable> Ordering<Range<C>> orderingByUpperEndpoint() {
return new Ordering<Range<C>>() {
@Override
public int compare(final Range<C> left, final Range<C> right) {
return ComparisonChain.start()
.compare(left.hasUpperBound(), right.hasUpperBound())
.compare(left.upperEndpoint(), right.upperEndpoint())
.result();
}
};
} | java |
public static <C extends Comparable> Ordering<Range<C>> reverseOrderingByUpperEndpoint() {
Ordering<Range<C>> orderingByUpperEndpoint = orderingByUpperEndpoint();
return orderingByUpperEndpoint.reverse();
} | java |
public static MozuUrl getCurrencyExchangeRatesUrl()
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/catalog/storefront/currencies/exchangerates");
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public void extractFromArchive(final File targetFile, final boolean forceOverwrite) throws IOException {
if (zipArchive != null) {
ZipEntry entry = zipArchive.getEntry(targetFile.getName());
if (entry != null) {
if (!targetFile.exists()) {
try {
targetFile.createNewFile();
} catch (IOException ex) {
throw new JFunkException("Error creating file: " + targetFile, ex);
}
} else if (!forceOverwrite) {
return;
}
logger.info("Loading file '{}' from zip archive...", targetFile);
OutputStream out = null;
InputStream in = null;
try {
out = new FileOutputStream(targetFile);
in = zipArchive.getInputStream(entry);
IOUtils.copy(in, out);
} finally {
IOUtils.closeQuietly(in);
IOUtils.closeQuietly(out);
}
} else {
logger.error("Could not find file '{}' in zip archive", targetFile);
}
}
} | java |
public static MozuUrl getDestinationUrl(String checkoutId, String destinationId, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/checkouts/{checkoutId}/destinations/{destinationId}?responseFields={responseFields}");
formatter.formatUrl("checkoutId", checkoutId);
formatter.formatUrl("destinationId", destinationId);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl addDestinationUrl(String checkoutId, String responseFields)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/checkouts/{checkoutId}/destinations?responseFields={responseFields}");
formatter.formatUrl("checkoutId", checkoutId);
formatter.formatUrl("responseFields", responseFields);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static MozuUrl removeDestinationUrl(String checkoutId, String destinationId)
{
UrlFormatter formatter = new UrlFormatter("/api/commerce/checkouts/{checkoutId}/destinations/{destinationId}");
formatter.formatUrl("checkoutId", checkoutId);
formatter.formatUrl("destinationId", destinationId);
return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
} | java |
public static Iterable<VcfSample> samples(final Readable readable) throws IOException {
checkNotNull(readable);
ParseListener parseListener = new ParseListener();
VcfParser.parse(readable, parseListener);
return parseListener.getSamples().values();
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.