@Override public String setOutputProperty(String name, String value) { Validate.notEmpty(name, "name cannot be null"); Validate.notEmpty(value, "value cannot be null"); return this.outputProperties.put(name, value); }
@Override public String setStylesheetParameter(String name, String value) { Validate.notEmpty(name, "name cannot be null"); Validate.notEmpty(value, "value cannot be null"); return this.parameters.put(name, value); }
/** * main method to interact with {@link AvailableApplicationTool}. * * @param args * @throws SchedulingException * @throws NotAVisitorException * @throws CalendarAccountNotFoundException */ public static void main(String[] args) throws CalendarAccountNotFoundException, NotAVisitorException, SchedulingException { // scan the arguments if (args.length == 0) { System.err.println( "Usage: AppointmentTool create [-owner username] [-visitor username] [-start YYYYmmdd-hhmm] [-duration minutes]"); System.exit(1); } if (CREATE.equals(args[0])) { String visitorUsername = null; String ownerUsername = null; Date startTime = null; int duration = 30; for (int i = 1; i < args.length; i++) { if (OWNER_ARG.equalsIgnoreCase(args[i])) { ownerUsername = args[++i]; } else if (VISITOR_ARG.equalsIgnoreCase(args[i])) { visitorUsername = args[++i]; } else if (START_ARG.equalsIgnoreCase(args[i])) { String start = args[++i]; SimpleDateFormat df = new SimpleDateFormat(DATE_FORMAT); try { startTime = df.parse(start); } catch (ParseException e) { System.err.println("Invalid format for start parameter, must match: " + DATE_FORMAT); System.exit(1); } } else if (DURATION_ARG.equalsIgnoreCase(args[i])) { String dur = args[++i]; duration = Integer.parseInt(dur); } } Validate.notEmpty(ownerUsername, "owner argument cannot be empty"); Validate.notEmpty(visitorUsername, "visitor argument cannot be empty"); Validate.notNull(startTime, "start argument cannot be empty"); ApplicationContext applicationContext = new ClassPathXmlApplicationContext(CONFIG); AppointmentTool tool = new AppointmentTool( (SchedulingAssistantService) applicationContext.getBean("schedulingAssistantService"), (ICalendarAccountDao) applicationContext.getBean("calendarAccountDao"), (OwnerDao) applicationContext.getBean("ownerDao"), (VisitorDao) applicationContext.getBean("visitorDao"), (AvailableScheduleDao) applicationContext.getBean("availableScheduleDao")); Date endDate = DateUtils.addMinutes(startTime, duration); VEvent event = tool.createAvailableAppointment(visitorUsername, ownerUsername, startTime, endDate); System.out.println("Event successfully created: "); System.out.println(event.toString()); } else { System.err.println("Unrecognized command: " + args[0]); System.exit(1); } }
/** * Construct a new {@link MessagePayload} * * @param hostname the hostname to be sent in this passive check * @param level the level * @param serviceName the service name * @param message the message */ public MessagePayload(String hostname, Level level, String serviceName, String message) { Validate.notEmpty(hostname, "hostname cannot be null or an empty String"); Validate.notEmpty(serviceName, "serviceName cannot be null or an empty String"); this.hostname = hostname; this.level = level; this.serviceName = serviceName; this.message = message; }
@Override @PortalTransactional public IPortletDefinition savePortletDefinition(IPortletDefinition portletDefinition) { Validate.notNull(portletDefinition, "portletDefinition can not be null"); Validate.notNull(portletDefinition.getType(), "portletDefinition portlet type can not be null"); Validate.notEmpty(portletDefinition.getFName(), "portletDefinition fname can not be null"); Validate.notEmpty(portletDefinition.getName(), "portletDefinition name can not be null"); Validate.notEmpty(portletDefinition.getTitle(), "portletDefinition title can not be null"); this.getEntityManager().persist(portletDefinition); return portletDefinition; }
/* (non-Javadoc) * @see org.jasig.portal.layout.om.IStylesheetUserPreferences#removeLayoutAttribute(java.lang.String, java.lang.String) */ @Override public String removeLayoutAttribute(String nodeId, String name) { Validate.notEmpty(nodeId, "nodeId cannot be null"); Validate.notEmpty(name, "name cannot be null"); final Map<String, String> nodeAttributes = this.layoutAttributes.get(nodeId); if (nodeAttributes == null) { return null; } return nodeAttributes.remove(name); }
@Override public void createTagsForResources(Map<String, String> keyValueMap, String... resourceIds) { Validate.notNull(keyValueMap); Validate.notEmpty(keyValueMap); Validate.notNull(resourceIds); Validate.notEmpty(resourceIds); AmazonEC2 ec2Client = ec2Client(); List<Tag> tags = new ArrayList<Tag>(); for (Map.Entry<String, String> entry : keyValueMap.entrySet()) { tags.add(new Tag(entry.getKey(), entry.getValue())); } CreateTagsRequest req = new CreateTagsRequest(Arrays.asList(resourceIds), tags); ec2Client.createTags(req); }
public void mail( String aTo, String aSubject, String aMessage, Map<HeaderType, String> aHeaders, Map<String, byte[]> aAttachments) throws MessagingException { Validate.notEmpty(aTo, "The receiver must be specified."); Validate.notEmpty(aSubject, "The subject must be specified."); Validate.notEmpty(aMessage, "The message cannot be empty."); MimeMessage message = m_MailSender.createMimeMessage(); MimeMessageHelper helper = new MimeMessageHelper(message, true); helper.setFrom(m_From); helper.setSubject(aSubject); helper.setText(aMessage); setHelperMethod(addTo, aTo, helper); if (aHeaders != null) for (HeaderType headerType : aHeaders.keySet()) { Validate.notEmpty( aHeaders.get(headerType), "The value attached to headers key " + headerType + " cannot be empty."); if (HeaderType.CC.equals(headerType)) setHelperMethod(addCC, aHeaders.get(headerType), helper); if (HeaderType.BCC.equals(headerType)) setHelperMethod(addBCC, aHeaders.get(headerType), helper); } if (aAttachments != null) for (String attachmentName : aAttachments.keySet()) { Validate.notEmpty(attachmentName, "All attachments must have a non empty name"); Validate.isTrue( aAttachments.get(attachmentName).length > 0, "The content of attachment " + attachmentName + " cannot be empty."); helper.addAttachment( attachmentName, new ByteArrayResource(aAttachments.get(attachmentName))); } log.info("Sending message " + aSubject + " to " + aTo); m_MailSender.send(message); }
public RouteScriptLoader( final String pathToScript, final RouteConfigurationScriptEvaluator scriptEvaluator) { notEmpty(pathToScript, "Null or empty script path is not allowed."); notNull(scriptEvaluator, "Null evaluator is not allowed."); this.pathToScript = pathToScript; this.scriptEvaluator = scriptEvaluator; }
public void mkview(String viewPath, String viewTag, String streamSelector) throws IOException, InterruptedException { Validate.notEmpty(viewPath); boolean isOptionalParamContainsHost = false; ArgumentListBuilder cmd = new ArgumentListBuilder(); cmd.add("mkview"); cmd.add("-snapshot"); if (streamSelector != null) { cmd.add("-stream"); cmd.add(streamSelector); } cmd.add("-tag"); cmd.add(viewTag); if ((optionalMkviewParameters != null) && (optionalMkviewParameters.length() > 0)) { String variabledResolvedParams = Util.replaceMacro(optionalMkviewParameters, this.variableResolver); cmd.addTokenized(variabledResolvedParams); isOptionalParamContainsHost = optionalMkviewParameters.contains("-host"); } if (!isOptionalParamContainsHost) { cmd.add(viewPath); } launcher.run(cmd.toCommandArray(), null, null, null); }
private Criterion(String name, CriterionType type) { Validate.notEmpty(name); Validate.notNull(type); this.name = name; this.type = type; }
/** * Returns all values for the given key * * @param key key (case insensitive) * @return all values of the given header or {@code null}, if there is no such a key in this * instance */ public List<String> getValues(final String key) { Validate.notEmpty(key, "name cannot be empty"); @SuppressWarnings("unchecked") final List<String> result = (List<String>) values.get(key.toLowerCase()); return result == null || result.isEmpty() ? null : new ArrayList<String>(result); }
@Override public void delete(Account actor, String uuid) throws BusinessException { preChecks(actor); Validate.notEmpty(uuid, "filter uuid is required"); UploadPropositionFilter entity = find(actor, uuid); businessService.delete(entity); }
private void validateIntersections( final PreparedUpdate update, final UpdateContext updateContext, final IpInterval ipInterval, final IpTree ipTree) { final List<IpEntry> parent = ipTree.findFirstLessSpecific(ipInterval); Validate.notEmpty(parent, "Should always have a parent"); Interval firstIntersecting = null; final List<IpEntry> childEntries = ipTree.findFirstMoreSpecific((IpInterval) parent.get(0).getKey()); for (final IpEntry childEntry : childEntries) { final Interval child = childEntry.getKey(); if (child.intersects(ipInterval) && !(child.contains(ipInterval) || ipInterval.contains(child))) { if (firstIntersecting == null || firstIntersecting .singletonIntervalAtLowerBound() .compareUpperBound(child.singletonIntervalAtLowerBound()) > 0) { firstIntersecting = child; } } } if (firstIntersecting != null) { updateContext.addMessage(update, UpdateMessages.intersectingRange(firstIntersecting)); } }
public Client( String registrationId, String endpoint, InetAddress address, int port, String lwM2mVersion, Long lifetime, String smsNumber, BindingMode binding, String[] objectLinks, Date registrationDate, InetSocketAddress registrationEndpoint) { Validate.notEmpty(endpoint); Validate.notNull(address); Validate.notNull(port); Validate.notNull(registrationEndpoint); this.registrationId = registrationId; this.endpoint = endpoint; this.address = address; this.port = port; this.objectLinks = objectLinks; this.registrationDate = registrationDate == null ? new Date() : registrationDate; lifeTimeInSec = lifetime == null ? DEFAULT_LIFETIME_IN_SEC : lifetime; this.lwM2mVersion = lwM2mVersion == null ? DEFAULT_LWM2M_VERSION : lwM2mVersion; bindingMode = binding == null ? BindingMode.U : binding; this.smsNumber = smsNumber; lastUpdate = new Date(); registrationEndpointAddress = registrationEndpoint; }
public void computeStatus(String errorMessage, String warnMessage) { Validate.notEmpty(errorMessage, "Error message must not be null."); // computeStatus sets a message if none is set, // therefore we need to check before calling computeStatus boolean noMessage = StringUtils.isEmpty(message); computeStatus(); switch (status) { case FATAL_ERROR: case PARTIAL_ERROR: if (noMessage) { message = errorMessage; } break; case UNKNOWN: case WARNING: case NOT_APPLICABLE: if (noMessage) { if (StringUtils.isNotEmpty(warnMessage)) { message = warnMessage; } else { message = errorMessage; } } break; } }
@Override public UploadPropositionFilter create(Account actor, UploadPropositionFilter dto) throws BusinessException { preChecks(actor); Validate.notNull(dto, "filter is required"); Validate.notEmpty(dto.getUuid(), "filter uuid is required"); return businessService.create(dto); }
/** {@inheritDoc} */ @Override public T integrate(final Function1D<U, T> f, final U[] lower, final U[] upper) { Validate.notNull(f, "function was null"); Validate.notNull(lower, "lower bound array was null"); Validate.notNull(upper, "upper bound array was null"); Validate.notEmpty(lower, "lower bound array was empty"); Validate.notEmpty(upper, "upper bound array was empty"); Validate.notNull(lower[0], "lower bound was null"); Validate.notNull(upper[0], "upper bound was null"); if (lower.length > 1) { s_logger.info("Lower bound array had more than one element; only using the first"); } if (upper.length > 1) { s_logger.info("Upper bound array had more than one element; only using the first"); } return integrate(f, lower[0], upper[0]); }
/** {@inheritDoc} */ @Override public void deleteSnapshot(String snapshotId) { Validate.notEmpty(snapshotId); LOGGER.info(String.format("Deleting snapshot %s.", snapshotId)); AmazonEC2 ec2Client = ec2Client(); DeleteSnapshotRequest request = new DeleteSnapshotRequest().withSnapshotId(snapshotId); ec2Client.deleteSnapshot(request); }
@Override public String setLayoutAttribute(String nodeId, String name, String value) { Validate.notEmpty(nodeId, "nodeId cannot be null"); Validate.notEmpty(name, "name cannot be null"); Validate.notEmpty(value, "value cannot be null"); ConcurrentMap<String, String> nodeAttributes; synchronized (this.layoutAttributes) { nodeAttributes = this.layoutAttributes.get(nodeId); if (nodeAttributes == null) { nodeAttributes = new ConcurrentHashMap<String, String>(); this.layoutAttributes.put(nodeId, nodeAttributes); } } return nodeAttributes.put(name, value); }
public Collection<OralDefense> execute( List<TimeBox> timeboxes, List<Unavailability> unavailabilities) { // verify that a planning has been configure correctly Validate.notNull(planning); Validate.notNull(planning.getRooms()); Validate.notEmpty(planning.getRooms()); // verify that we have timeboxes Validate.notNull(timeboxes); Validate.notEmpty(timeboxes); // verify that we have participants Validate.notNull(planning.getParticipants()); Validate.notEmpty(planning.getParticipants()); // verify that we have enough timeboxes and rooms to create an oral defense for each participant Validate.isTrue(timeboxes.size() * rooms.size() >= planning.getParticipants().size()); this.results = Lists.newArrayList(); this.remainingTimeboxes = Lists.newArrayList(timeboxes); this.allocationsPerTimebox = Maps.newHashMap(); this.unavailabilities = Lists.newArrayList(); if (unavailabilities != null) { this.unavailabilities.addAll(unavailabilities); } this.buffer = Maps.newHashMap(); this.remainingParticipants = Lists.newArrayList(planning.getParticipants()); System.out.println("remaining participants: " + remainingParticipants.size()); while (!remainingParticipants.isEmpty()) { // try to allocate a timebox to each participant // when considering their unavailabilities tryAllocation(); // allocate a timebox to a participant from its list // of available timebox if (!remainingParticipants.isEmpty()) { forceAllocation(); } } // loop until every participant is allocated to a timebox return results; }
/** {@inheritDoc} */ @Override public void deleteVolume(String volumeId) { Validate.notEmpty(volumeId); LOGGER.info(String.format("Deleting volume %s.", volumeId)); AmazonEC2 ec2Client = ec2Client(); DeleteVolumeRequest request = new DeleteVolumeRequest().withVolumeId(volumeId); ec2Client.deleteVolume(request); }
/** * Get the UUID from the cache for the player named 'name'. * * <p>If the id does not exist in our database, then we will queue a fetch to get it, and return * null. A fetch at a later point will then be able to return this id. * * @param name the player name to lookup * @return the player's UUID */ public UUID getIdOptimistic(String name) { Validate.notEmpty(name); UUID uuid = cache.get(name); if (uuid == null) { ensurePlayerUUID(name); return null; } return uuid; }
public SimpleJdbcMapper(String tableName, ConnectionProvider connectionProvider) { Validate.notEmpty(tableName); Validate.notNull(connectionProvider); int queryTimeoutSecs = 30; connectionProvider.prepare(); JdbcClient client = new JdbcClient(connectionProvider, queryTimeoutSecs); this.schemaColumns = client.getColumnSchema(tableName); }
public static boolean isNoNullElements(Collection collection) { Validate.notEmpty(collection, "数组为空!"); for (Iterator it = collection.iterator(); it.hasNext(); ) { if (it.next() == null) { return false; } } return true; }
/** {@inheritDoc} */ @Override public void deleteAutoScalingGroup(String asgName) { Validate.notEmpty(asgName); LOGGER.info(String.format("Deleting auto-scaling group with name %s.", asgName)); AmazonAutoScalingClient asgClient = asgClient(); DeleteAutoScalingGroupRequest request = new DeleteAutoScalingGroupRequest().withAutoScalingGroupName(asgName); asgClient.deleteAutoScalingGroup(request); }
public static String readFile(String fileName) { Validate.notEmpty(fileName); String file = null; try { file = Utils.readFileToString(fileName); } catch (IOException e) { LOG.error("There was an error reading in file: " + fileName, e); } return file; }
public SegmentAndComponentPath(Segment theSegment, List<Integer> theComponentPath) { super(); Validate.notNull(theSegment); Validate.notNull(theComponentPath); Validate.notEmpty(theComponentPath); mySegment = theSegment; myComponentPath = theComponentPath; }
private GisFeatureNames( String name, String asciiName, AlternateNamesProvider alternateNamesProvider) { super(); Validate.notEmpty(name); this.name = name; this.asciiName = asciiName; this.alternateNamesProvider = alternateNamesProvider; }
@Override public void generateReport( Map<String, String> parameters, ServletOutputStream outputStream, String fileType) { String reportName = parameters.get("reportName"); Validate.notEmpty(reportName, "Missing parameter 'reportName'"); ReportTemplate template = loadTemplate(reportName); template.generateAndExport(parameters, outputStream, fileType); }