/**
* Finds the {@link DataSet} that contains the given file. This methods will also performs some
* checks to make sure the given file is a valid file in the data set.
*
* <p>All the information is set in a {@link FileValidity} object that is returned. If an instance
* is passed, then this object is filled instead, and returned.
*
* <p>{@link FileValidity} contains information about the changed file including: - is it from an
* known set, is it an ignored file, or is it unknown? - what data set does it belong to - what
* source folder in the data set does it belong to.
*
* <p>"belong" means that the DataSet has a source file/folder that is the root folder of this
* file. The folder and/or file doesn't have to exist.
*
* @param file the file to check
* @param fileValidity an optional FileValidity to fill. If null a new one is returned.
* @return a new FileValidity or the one given as a parameter.
*/
public FileValidity<S> findDataSetContaining(
@NonNull File file, @Nullable FileValidity<S> fileValidity) {
if (fileValidity == null) {
fileValidity = new FileValidity<S>();
}
if (mDataSets.isEmpty()) {
fileValidity.status = FileValidity.FileStatus.UNKNOWN_FILE;
return fileValidity;
}
if (DataSet.isIgnored(file)) {
fileValidity.status = FileValidity.FileStatus.IGNORED_FILE;
return fileValidity;
}
for (S dataSet : mDataSets) {
File sourceFile = dataSet.findMatchingSourceFile(file);
if (sourceFile != null) {
fileValidity.dataSet = dataSet;
fileValidity.sourceFile = sourceFile;
fileValidity.status =
dataSet.isValidSourceFile(sourceFile, file)
? FileValidity.FileStatus.VALID_FILE
: FileValidity.FileStatus.IGNORED_FILE;
return fileValidity;
}
}
fileValidity.status = FileValidity.FileStatus.UNKNOWN_FILE;
return fileValidity;
}
@Override
public Double getValue(S solution) {
if (getConstraintIndex() >= solution.getNumberOfConstraints())
throw new IllegalArgumentException(
"Solution does not have " + getConstraintIndex() + 1 + " constraints.");
return solution.getConstraint(getConstraintIndex());
}
@Override
public <S> Entry<S> loadSaga(Class<S> sagaType, String sagaIdentifier) {
EntityManager entityManager = entityManagerProvider.getEntityManager();
List<SerializedSaga> serializedSagaList =
entityManager
.createNamedQuery(LOAD_SAGA_NAMED_QUERY, SerializedSaga.class)
.setParameter("sagaId", sagaIdentifier)
.setParameter("sagaType", getSagaTypeName(sagaType))
.setMaxResults(1)
.getResultList();
if (serializedSagaList == null || serializedSagaList.isEmpty()) {
return null;
}
SerializedSaga serializedSaga = serializedSagaList.get(0);
S loadedSaga = serializer.deserialize(serializedSaga);
if (injector != null) {
injector.injectResources(loadedSaga);
}
Set<AssociationValue> associationValues =
loadAssociationValues(entityManager, sagaType, sagaIdentifier);
if (logger.isDebugEnabled()) {
logger.debug(
"Loaded saga id [{}] of type [{}]", sagaIdentifier, loadedSaga.getClass().getName());
}
return new EntryImpl<>(associationValues, loadedSaga);
}
@SuppressWarnings("unchecked")
public static <S, T> CollectionRemovedFromEvent<S, T> newEvent(
final Class<? extends CollectionRemovedFromEvent<S, T>> type,
final S source,
final Identifier identifier,
final T value)
throws InstantiationException, IllegalAccessException, IllegalArgumentException,
InvocationTargetException, NoSuchMethodException, SecurityException {
final Constructor<?>[] constructors = type.getConstructors();
for (final Constructor<?> constructor : constructors) {
final Class<?>[] parameterTypes = constructor.getParameterTypes();
if (parameterTypes.length != 3) {
continue;
}
if (!parameterTypes[0].isAssignableFrom(source.getClass())) {
continue;
}
if (!parameterTypes[1].isAssignableFrom(Identifier.class)) {
continue;
}
if (value != null && !parameterTypes[2].isAssignableFrom(value.getClass())) {
continue;
}
final Object event = constructor.newInstance(source, identifier, value);
return (CollectionRemovedFromEvent<S, T>) event;
}
throw new NoSuchMethodException(
type.getName()
+ ".<init>(? super "
+ source.getClass().getName()
+ ", "
+ Identifier.class.getName()
+ ", java.lang.Object)");
}
/** 强制出票 */
public String batchForcePrint() {
Map<String, Object> map = new HashMap<String, Object>();
try {
AdminUser adminUser = getAdminUser();
if (null == adminUser) {
throw new WebDataException("你还没有登录！");
}
if (this.id == null) {
throw new DataException("方案ID不能为空.");
}
S s = kenoService.forcePrint(this.id);
// 记录操作日志
eventLogManager.saveSimpleEventLog(
null,
getLottery(),
adminUser,
EventLogType.ForcePrint,
"方案为ID：" + s.getId() + "方案号为+" + s.getSchemeNumber());
map.put("success", true);
map.put("msg", "强制出票成功");
} catch (ServiceException e) {
e.printStackTrace();
map.put("success", false);
map.put("msg", e.getMessage());
} catch (Exception e) {
e.printStackTrace();
map.put("success", false);
map.put("msg", "强制出票发生异常！");
}
Struts2Utils.renderJson(map);
return null;
}
/**
* Removes the specified service from this service manager, stopping and terminating it as
* required. If this service manager is in a started state then the service will be stopped. After
* removal, the service will be terminated.
*/
public <S extends Service<T>> void removeService(S s) {
if (started) {
s.stop();
}
services.remove(s);
s.terminate(getParent());
}
/**
* Runs a range query on the local machine by iterating over the whole file.
*
* @param fs - FileSystem that contains input file
* @param file - path to the input file
* @param queryRange - The range to look in
* @param shape - An instance of the shape stored in file
* @param output - Output is sent to this collector. If <code>null</code>, output is not collected
* and only the number of results is returned.
* @return number of results found
* @throws IOException
*/
public static <S extends Shape> long rangeQueryLocal(
FileSystem fs, Path file, Shape queryRange, S shape, ResultCollector<S> output)
throws IOException {
long file_size = fs.getFileStatus(file).getLen();
ShapeRecordReader<S> shapeReader = new ShapeRecordReader<S>(fs.open(file), 0, file_size);
long resultCount = 0;
Prism cell = shapeReader.createKey();
while (shapeReader.next(cell, shape)) {
if (shape.isIntersected(queryRange)) {
boolean report_result;
if (cell.isValid()) {
// Check for duplicate avoidance
Prism intersection_mbr = queryRange.getMBR().getIntersection(shape.getMBR());
report_result =
cell.contains(intersection_mbr.t1, intersection_mbr.x1, intersection_mbr.y1);
} else {
report_result = true;
}
if (report_result) {
resultCount++;
if (output != null) {
output.collect(shape);
}
}
}
}
shapeReader.close();
return resultCount;
}
/**
* Adds the specified service and initializes it. If the service manager has already been started
* then the service will also be started.
*/
public <S extends Service<T>> void addService(S s) {
services.add(s);
s.initialize(getParent());
if (started) {
s.start();
}
}
@SuppressWarnings({"unchecked", "rawtypes"})
@Override
protected boolean executeMoveImplem(S solution, IMove move) {
if (!(move instanceof TwoOptMove)) {
throw new IllegalArgumentException("The move must be of type TwoOptMove");
}
boolean r;
TwoOptMove twoOptMove = (TwoOptMove) move;
IRoute rI = solution.getRoute(twoOptMove.getRouteI());
IRoute rJ = null;
int i = twoOptMove.getI();
int j = twoOptMove.getJ();
// Intra route move
if (twoOptMove.getRouteI() == twoOptMove.getRouteJ()) {
// Remove (nodeI,nodeI+1) and (nodeJ,nodeJ+1)
// Reconnect nodeI with nodeJ and nodeI+1 with nodeJ+1
rI.reverseSubRoute(i + 1, j);
// rI.updateCost(-twoOptMove.getImprovement());
r = true;
// Inter route move
} else {
rJ = solution.getRoute(twoOptMove.getRouteJ());
// Auxiliary method to solve type safety problems
r = executeMove(rI, rJ, i, j, twoOptMove.isStar());
}
return r;
}
/**
* Process a new session : - initialize it - create its chain - fire the CREATED listeners if any
*
* @param session The session to create
* @return true if the session has been registered
*/
private boolean addNow(S session) {
boolean registered = false;
try {
init(session);
registered = true;
// Build the filter chain of this session.
IoFilterChainBuilder chainBuilder = session.getService().getFilterChainBuilder();
chainBuilder.buildFilterChain(session.getFilterChain());
// DefaultIoFilterChain.CONNECT_FUTURE is cleared inside here
// in AbstractIoFilterChain.fireSessionOpened().
// Propagate the SESSION_CREATED event up to the chain
IoServiceListenerSupport listeners =
((AbstractIoService) session.getService()).getListeners();
listeners.fireSessionCreated(session);
} catch (Throwable e) {
ExceptionMonitor.getInstance().exceptionCaught(e);
try {
destroy(session);
} catch (Exception e1) {
ExceptionMonitor.getInstance().exceptionCaught(e1);
} finally {
registered = false;
}
}
return registered;
}
@Override
@SuppressWarnings("unchecked")
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
S serverChannel = (S) ctx.getAttachment();
T childChannel = createChildChannel(serverChannel, e.getChannel());
fireChannelOpen(childChannel);
ChannelAddress localAddress = serverChannel.getLocalAddress();
childChannel.setLocalAddress(localAddress);
childChannel.setBound();
fireChannelBound(childChannel, localAddress);
ctx.setAttachment(childChannel);
ctx.sendUpstream(e);
// TODO: fire CONNECTED_BARRIER event to next pipeline
// then fire CONNECTED event when future completes successfully
ChannelAddress remoteAddress = localAddress.newEphemeralAddress();
childChannel.setRemoteAddress(remoteAddress);
childChannel.setConnected();
fireChannelConnected(childChannel, remoteAddress);
}
@Override
public <S extends StreamDefinition> S save(S entity) {
try {
Map<String, String> map = new HashMap<>();
map.put(DEFINITION_KEY, entity.getDefinition());
map.put(
MODULE_DEFINITIONS_KEY, objectWriter.writeValueAsString(entity.getModuleDefinitions()));
CuratorFramework client = zkConnection.getClient();
String path = Paths.build(Paths.STREAMS, entity.getName());
byte[] binary = ZooKeeperUtils.mapToBytes(map);
BackgroundPathAndBytesable<?> op =
client.checkExists().forPath(path) == null ? client.create() : client.setData();
op.forPath(path, binary);
logger.trace("Saved stream {} with properties {}", path, map);
StreamDefinitionRepositoryUtils.saveDependencies(moduleDependencyRepository, entity);
} catch (Exception e) {
// NodeExistsException indicates that we tried to create the
// path just after another thread/jvm successfully created it
ZooKeeperUtils.wrapAndThrowIgnoring(e, NodeExistsException.class);
}
return entity;
}
@Override
public S merge(@Nullable S parentType) {
if (parentType == null) {
//noinspection unchecked
return (S) this;
}
super.merge(parentType);
if (_minimum == null) {
_minimum = parentType.getMinimum();
}
if (_minimumExclusive == null) {
_minimumExclusive = parentType.getMinimumExclusive();
}
if (_maximum == null) {
_maximum = parentType.getMaximum();
}
if (_maximumExclusive == null) {
_maximumExclusive = parentType.getMaximumExclusive();
}
if (_divisibleBy == null) {
_divisibleBy = parentType.getDivisibleBy();
}
//noinspection unchecked
return (S) this;
}
@Override
public void loadAllEntries() {
final Connection connection = getConnectionpool().getConnection();
if (connection == null) return;
Statement query = null;
try {
query = connection.createStatement();
final ResultSet result = query.executeQuery("SELECT * FROM `" + tableName + "` WHERE 1=1");
while (result.next())
try {
final S data = constructor.newInstance(result, columnNames);
datas.put(data.getName().toLowerCase(), data);
} catch (final InvocationTargetException e) {
shortPrintStackTrace(e, e.getCause());
} catch (final Exception e) {
e.printStackTrace();
}
result.close();
} catch (final SQLException e) {
} finally {
if (query != null)
try {
query.close();
} catch (final Exception e) {
}
getConnectionpool().releaseConnection(connection);
}
}
/**
* Post merge clean up.
*
* <p>- Remove the removed items. - Clear the state of all the items (this allow newly overridden
* items to lose their WRITTEN state) - Set the items that are part of the new merge to be WRITTEN
* to allow the next merge to be incremental.
*/
private void postMergeCleanUp() {
ListMultimap<String, I> itemMap = ArrayListMultimap.create();
// remove all removed items, and copy the rest in the full map while resetting their state.
for (S dataSet : mDataSets) {
ListMultimap<String, I> map = dataSet.getDataMap();
List<String> keys = Lists.newArrayList(map.keySet());
for (String key : keys) {
List<I> list = map.get(key);
for (int i = 0; i < list.size(); ) {
I item = list.get(i);
if (item.isRemoved()) {
list.remove(i);
} else {
//noinspection unchecked
itemMap.put(key, (I) item.resetStatus());
i++;
}
}
}
}
// for the last items (the one that have been written into the consumer), set their
// state to WRITTEN
for (String key : itemMap.keySet()) {
List<I> itemList = itemMap.get(key);
itemList.get(itemList.size() - 1).resetStatusToWritten();
}
}
/** Returns null if not supported. */
private Clob masterClob() throws PersistException {
Clob masterClob = mMasterClob;
if (mMasterClobLoaded) {
return masterClob;
}
S master = mMasterStorage.prepare();
mReplica.copyPrimaryKeyProperties(master);
try {
// FIXME: handle missing master with resync
master.load();
if (master.isPropertySupported(mClobName)) {
masterClob = (Clob) master.getPropertyValue(mClobName);
if (masterClob == null) {
// FIXME: perform resync, but still throw exception
throw new PersistNoneException("Master Clob is null: " + mClobName);
}
}
mMasterClob = masterClob;
mMasterClobLoaded = true;
return masterClob;
} catch (FetchException e) {
throw e.toPersistException();
}
}
public static void main(String[] args) {
T t = new T();
System.out.println("t.z()=" + t.z() + when("t", t));
S s = new S();
System.out.println("s.z()=" + s.z() + when("s", s));
s = t;
System.out.println("s.z()=" + s.z() + when("s", s));
}
/**
* Transforms all tokens that are represented by this list.
*
* @param visitor The visitor to apply to all tokens.
* @return A list containing the transformed tokens.
*/
public TokenList<S> accept(
GenericTypeDescription.Visitor<? extends GenericTypeDescription> visitor) {
List<S> tokens = new ArrayList<S>(this.tokens.size());
for (S token : this.tokens) {
tokens.add(token.accept(visitor));
}
return new TokenList<S>(tokens);
}
public static class ResourceSpec {
public static IComponentSpec getInstance() {
return S.getResourceSpec();
}
public static final JsResource RESOURCE = S.getJsResource();
public static final IJsResourceRef REF = S.getJsResourceRef();
}
// ----------------------------------------------------------------------
// ASF: Achivement Scalarization Function
// I implement here a effcient version of it, which only receives the index
// of the objective which uses 1.0; the rest will use 0.00001. This is
// different to the one impelemented in C++
// ----------------------------------------------------------------------
private double ASF(S s, int index) {
double max_ratio = Double.NEGATIVE_INFINITY;
for (int i = 0; i < s.getNumberOfObjectives(); i++) {
double weight = (index == i) ? 1.0 : 0.000001;
max_ratio = Math.max(max_ratio, s.getObjective(i) / weight);
}
return max_ratio;
}
protected S processNextStart() {
while (true) {
final S element = this.starts.next();
if (this.predicate.evaluate(element.getProperty(this.key), this.value)) {
return element;
}
}
}
@JsonApiSave
public <S extends Project> S save(S entity) {
if (entity.getId() == null) {
entity.setId(ID_GENERATOR.getAndIncrement());
}
REPOSITORY.put(entity.getId(), entity);
return entity;
}
private void validateForPrioritize(S s) {
if (s.strict()) {
throw new IllegalArgumentException(s.name() + ": not prioritizable: is strict");
}
if (!this.range.contains(s)) {
throw new IllegalArgumentException(s.name() + ": not contained or is backup");
}
}
private boolean containsName(List<S> source, String strategyName) {
for (S s : source) {
if (s.name().equals(strategyName)) {
return true;
}
}
return false;
}
@Override
public void save(final S entry) {
if (entry == null) return;
super.save(entry);
entries.put(
entry.getName(),
ChatHelper.listingString(DATASEPARATOR, entry.saveToFlatDatabase()) + LINESEPERATOR);
asyncSaveDatabase();
}
private <T, S extends ResponseObjectBuilder<T>> T parseMap(
S builder, Map<String, Reply> response) {
for (Map.Entry<String, Reply> entry : response.entrySet()) {
String method = buildSetterName(entry.getKey());
Class valueType = getObjectClass(entry.getValue());
builder.set(method, entry.getValue(), valueType);
}
return builder.build();
}
/** {@inheritDoc} */
public void write(S session, WriteRequest writeRequest) {
WriteRequestQueue writeRequestQueue = session.getWriteRequestQueue();
writeRequestQueue.offer(session, writeRequest);
if (!session.isWriteSuspended()) {
this.flush(session);
}
}
protected AbstractDocumentServiceIT(final List<S> indexes) {
this.indexes = new ArrayList<>(indexes);
indexesArray = new String[indexes.size()];
int i = 0;
for (final S index : indexes) {
indexesArray[i++] = index.toString();
}
}
public void add(int index, S section) {
SectionViewer<? extends Section> viewer = section.getViewer();
try {
sections.add(index, section);
section.setViewer(this.viewer);
} catch (Exception ignored) {
section.setViewer(viewer);
}
}
void addSubscription(S subscription) {
RegistryItem<String, S> subscriptionItem =
new RegistryItem<String, S>(
subscription.getSubscriptionId(),
subscription,
subscription.getActualDurationSeconds());
subscriptionItems.add(subscriptionItem);
}
