use of org.apache.commons.lang3.Range in project sirix by sirixdb.
the class AbstractSunburstControl method controlEvent.
/**
* Called on every change of the GUI.
*
* @param paramControlEvent
* the {@link ControlEvent}
*/
@Override
public void controlEvent(final ControlEvent paramControlEvent) {
assert paramControlEvent != null;
if (paramControlEvent.isController()) {
if (paramControlEvent.getController().getId() == 50) {
mModel.evaluateXPath(paramControlEvent.getController().getStringValue());
} else {
if (paramControlEvent.getController() instanceof Toggle) {
final Toggle toggle = (Toggle) paramControlEvent.getController();
switch(paramControlEvent.getController().getId()) {
case 0:
mGUI.setShowArcs(toggle.getState());
break;
case 1:
mGUI.setShowLines(toggle.getState());
break;
case 2:
mGUI.setUseBezierLine(toggle.getState());
break;
}
} else if (paramControlEvent.getController() instanceof Slider) {
switch(paramControlEvent.getController().getId()) {
case 0:
mGUI.setInnerNodeArcScale(paramControlEvent.getController().getValue());
break;
case 1:
mGUI.setLeafArcScale(paramControlEvent.getController().getValue());
break;
case 2:
mGUI.setModificationWeight(paramControlEvent.getController().getValue());
break;
case 3:
mGUI.setDotSize(paramControlEvent.getController().getValue());
break;
case 4:
mGUI.setDotBrightness(paramControlEvent.getController().getValue());
break;
case 5:
mGUI.setBackgroundBrightness(paramControlEvent.getController().getValue());
break;
}
} else if (paramControlEvent.getController() instanceof Range) {
final float[] f = paramControlEvent.getController().getArrayValue();
switch(paramControlEvent.getController().getId()) {
case 0:
mGUI.setHueStart(f[0]);
mGUI.setHueEnd(f[1]);
break;
case 1:
mGUI.setSaturationStart(f[0]);
mGUI.setSaturationEnd(f[1]);
break;
case 2:
mGUI.setBrightnessStart(f[0]);
mGUI.setBrightnessEnd(f[1]);
break;
case 3:
mGUI.setInnerNodeBrightnessStart(f[0]);
mGUI.setInnerNodeBrightnessEnd(f[1]);
break;
case 4:
mGUI.setInnerNodeStrokeBrightnessStart(f[0]);
mGUI.setInnerNodeStrokeBrightnessEnd(f[1]);
break;
case 5:
mGUI.setStrokeWeightStart(f[0]);
mGUI.setStrokeWeightEnd(f[1]);
break;
}
}
mGUI.update(EResetZoomer.YES);
}
}
}
use of org.apache.commons.lang3.Range in project sirix by sirixdb.
the class AbstractSunburstGUI method setupGUI.
/**
* Initial setup of the GUI.
*/
private void setupGUI() {
mParent.textFont(mFont);
mParent.smooth();
mParent.background(255f);
final int activeColor = mParent.color(0, 130, 164);
mControlP5.setColorActive(activeColor);
mControlP5.setColorBackground(mParent.color(170));
mControlP5.setColorForeground(mParent.color(50));
mControlP5.setColorLabel(mParent.color(50));
mControlP5.setColorValue(mParent.color(255));
final int len = 300;
final Range hueRange = mControlP5.addRange("leaf node hue range", 0, 360, getHueStart(), getHueEnd(), LEFT, TOP + mPosY + 0, len, 15);
mRanges.add(hueRange);
final Range saturationRange = mControlP5.addRange("leaf node saturation range", 0, 100, getSaturationStart(), getSaturationEnd(), LEFT, TOP + mPosY + 20, len, 15);
mRanges.add(saturationRange);
final Range brightnessRange = mControlP5.addRange("leaf node brightness range", 0, 100, getBrightnessStart(), getBrightnessEnd(), LEFT, TOP + mPosY + 40, len, 15);
mRanges.add(brightnessRange);
mPosY += 70;
final Range innerNodebrightnessRange = mControlP5.addRange("inner node brightness range", 0, 100, getInnerNodeBrightnessStart(), getInnerNodeBrightnessEnd(), LEFT, TOP + mPosY + 0, len, 15);
mRanges.add(innerNodebrightnessRange);
final Range innerNodeStrokeBrightnessRange = mControlP5.addRange("inner node stroke brightness range", 0, 100, getInnerNodeStrokeBrightnessStart(), getInnerNodeStrokeBrightnessEnd(), LEFT, TOP + mPosY + 20, len, 15);
mRanges.add(innerNodeStrokeBrightnessRange);
mPosY += 50;
// name, minimum, maximum, default value (float), x, y, width, height
final Slider innerNodeArcScale = mControlP5.addSlider("setInnerNodeArcScale", 0, 1, getInnerNodeArcScale(), LEFT, TOP + mPosY + 0, len, 15);
innerNodeArcScale.setCaptionLabel("innerNodeArcScale");
mSliders.add(innerNodeArcScale);
final Slider leafNodeArcScale = mControlP5.addSlider("setLeafArcScale", 0, 1, getLeafArcScale(), LEFT, TOP + mPosY + 20, len, 15);
leafNodeArcScale.setCaptionLabel("leafNodeArcScale");
mSliders.add(leafNodeArcScale);
mPosY += 50;
final Slider modWeight = mControlP5.addSlider("setModificationWeight", 0, 1, getModificationWeight(), LEFT, TOP + mPosY + 0, len, 15);
modWeight.setCaptionLabel("modification weight");
mSliders.add(modWeight);
mPosY += 50;
final Range strokeWeight = mControlP5.addRange("stroke weight range", 0, 10, getStrokeWeightStart(), getStrokeWeightEnd(), LEFT, TOP + mPosY + 0, len, 15);
mRanges.add(strokeWeight);
mPosY += 30;
final Slider dotSize = mControlP5.addSlider("setDotSize", 0, 10, mDotSize, LEFT, TOP + mPosY + 0, len, 15);
dotSize.setCaptionLabel("dot size");
mSliders.add(dotSize);
final Slider dotBrightness = mControlP5.addSlider("setDotBrightness", 0, 100, mDotBrightness, LEFT, TOP + mPosY + 20, len, 15);
dotBrightness.setCaptionLabel("dot brightness");
mSliders.add(dotBrightness);
mPosY += 50;
final Slider backgroundBrightness = mControlP5.addSlider("setBackgroundBrightness", 0, 100, getBackgroundBrightness(), LEFT, TOP + mPosY + 0, len, 15);
backgroundBrightness.setCaptionLabel("background brightness");
mSliders.add(backgroundBrightness);
mPosY += 50;
final Toggle showArcs = mControlP5.addToggle("isShowArcs", isShowArcs(), LEFT + 0, TOP + mPosY, 15, 15);
showArcs.setCaptionLabel("show arcs");
mToggles.add(showArcs);
final Toggle showLines = mControlP5.addToggle("isShowLines", isShowLines(), LEFT + 0, TOP + mPosY + 20, 15, 15);
showLines.setCaptionLabel("show lines");
mToggles.add(showLines);
final Toggle useBezier = mControlP5.addToggle("isUseBezierLine", isUseBezierLine(), LEFT + 0, TOP + mPosY + 40, 15, 15);
useBezier.setCaptionLabel("Bezier / Line");
mToggles.add(useBezier);
setup();
style();
}
use of org.apache.commons.lang3.Range in project incubator-pulsar by apache.
the class SimpleLoadManagerImpl method findBrokerForPlacement.
/**
* Assign owner for specified ServiceUnit from the given candidates, following the the principles: 1) Optimum
* distribution: fill up one broker till its load reaches optimum level (defined by underload threshold) before pull
* another idle broker in; 2) Even distribution: once all brokers' load are above optimum level, maintain all
* brokers to have even load; 3) Set the underload threshold to small value (like 1) for pure even distribution, and
* high value (like 80) for pure optimum distribution;
*
* Strategy to select broker: 1) The first choice is the least loaded broker which is underload but not idle; 2) The
* second choice is idle broker (if there is any); 3) Othewise simply select the least loaded broker if it is NOT
* overloaded; 4) If all brokers are overloaded, select the broker with maximum available capacity (considering
* brokers could have different hardware configuration, this usually means to select the broker with more hardware
* resource);
*
* Broker's load level: 1) Load ranking (triggered by LoadReport update) estimate the load level according to the
* resourse usage and namespace bundles already loaded by each broker; 2) When leader broker decide the owner for a
* new namespace bundle, it may take time for the real owner to actually load the bundle and refresh LoadReport,
* leader broker will store the bundle in a list called preAllocatedBundles, and the quota of all
* preAllocatedBundles in preAllocatedQuotas, and re-estimate the broker's load level by putting the
* preAllocatedQuota into calculation; 3) Everything (preAllocatedBundles and preAllocatedQuotas) will get reset in
* load ranking.
*/
private synchronized ResourceUnit findBrokerForPlacement(Multimap<Long, ResourceUnit> candidates, ServiceUnitId serviceUnit) {
long underloadThreshold = this.getLoadBalancerBrokerUnderloadedThresholdPercentage();
long overloadThreshold = this.getLoadBalancerBrokerOverloadedThresholdPercentage();
ResourceQuota defaultQuota = pulsar.getLocalZkCacheService().getResourceQuotaCache().getDefaultQuota();
double minLoadPercentage = 101.0;
long maxAvailability = -1;
ResourceUnit idleRU = null;
ResourceUnit maxAvailableRU = null;
ResourceUnit randomRU = null;
ResourceUnit selectedRU = null;
ResourceUnitRanking selectedRanking = null;
String serviceUnitId = serviceUnit.toString();
// If the ranking is expected to be in the range [0,100] (which is the case for LOADBALANCER_STRATEGY_LLS),
// the ranks are bounded. Otherwise (as is the case in LOADBALANCER_STRATEGY_LEAST_MSG, the ranks are simply
// the total message rate which is in the range [0,Infinity) so they are unbounded. The
// "boundedness" affects how two ranks are compared to see which one is better
boolean unboundedRanks = getLoadBalancerPlacementStrategy().equals(LOADBALANCER_STRATEGY_LEAST_MSG);
long randomBrokerIndex = (candidates.size() > 0) ? (this.brokerRotationCursor % candidates.size()) : 0;
// find the least loaded & not-idle broker
for (Map.Entry<Long, ResourceUnit> candidateOwner : candidates.entries()) {
ResourceUnit candidate = candidateOwner.getValue();
randomBrokerIndex--;
// skip broker which is not ranked. this should never happen except in unit test
if (!resourceUnitRankings.containsKey(candidate)) {
continue;
}
String resourceUnitId = candidate.getResourceId();
ResourceUnitRanking ranking = resourceUnitRankings.get(candidate);
// check if this ServiceUnit is already loaded
if (ranking.isServiceUnitLoaded(serviceUnitId)) {
ranking.removeLoadedServiceUnit(serviceUnitId, this.getResourceQuota(serviceUnitId));
}
// record a random broker
if (randomBrokerIndex < 0 && randomRU == null) {
randomRU = candidate;
}
// check the available capacity
double loadPercentage = ranking.getEstimatedLoadPercentage();
double availablePercentage = Math.max(0, (100 - loadPercentage) / 100);
long availability = (long) (ranking.estimateMaxCapacity(defaultQuota) * availablePercentage);
if (availability > maxAvailability) {
maxAvailability = availability;
maxAvailableRU = candidate;
}
// check the load percentage
if (ranking.isIdle()) {
if (idleRU == null) {
idleRU = candidate;
}
} else {
if (selectedRU == null) {
selectedRU = candidate;
selectedRanking = ranking;
minLoadPercentage = loadPercentage;
} else {
if ((unboundedRanks ? ranking.compareMessageRateTo(selectedRanking) : ranking.compareTo(selectedRanking)) < 0) {
minLoadPercentage = loadPercentage;
selectedRU = candidate;
selectedRanking = ranking;
}
}
}
}
if ((minLoadPercentage > underloadThreshold && idleRU != null) || selectedRU == null) {
// assigned to idle broker is the least loaded broker already have optimum load (which means NOT
// underloaded), or all brokers are idle
selectedRU = idleRU;
} else if (minLoadPercentage >= 100.0 && randomRU != null && !unboundedRanks) {
// all brokers are full, assign to a random one
selectedRU = randomRU;
} else if (minLoadPercentage > overloadThreshold && !unboundedRanks) {
// assign to the broker with maximum available capacity if all brokers are overloaded
selectedRU = maxAvailableRU;
}
// re-calculate load level for selected broker
if (selectedRU != null) {
this.brokerRotationCursor = (this.brokerRotationCursor + 1) % 1000000;
ResourceUnitRanking ranking = resourceUnitRankings.get(selectedRU);
String loadPercentageDesc = ranking.getEstimatedLoadPercentageString();
log.info("Assign {} to {} with ({}).", serviceUnitId, selectedRU.getResourceId(), loadPercentageDesc);
if (!ranking.isServiceUnitPreAllocated(serviceUnitId)) {
final String namespaceName = LoadManagerShared.getNamespaceNameFromBundleName(serviceUnitId);
final String bundleRange = LoadManagerShared.getBundleRangeFromBundleName(serviceUnitId);
ResourceQuota quota = this.getResourceQuota(serviceUnitId);
// Add preallocated bundle range so incoming bundles from the same namespace are not assigned to the
// same broker.
brokerToNamespaceToBundleRange.computeIfAbsent(selectedRU.getResourceId().replace("http://", ""), k -> new HashMap<>()).computeIfAbsent(namespaceName, k -> new HashSet<>()).add(bundleRange);
ranking.addPreAllocatedServiceUnit(serviceUnitId, quota);
resourceUnitRankings.put(selectedRU, ranking);
}
}
return selectedRU;
}
use of org.apache.commons.lang3.Range in project vind by RBMHTechnology.
the class SolrSearchServer method buildSolrQuery.
protected SolrQuery buildSolrQuery(FulltextSearch search, DocumentFactory factory) {
// build query
final SolrQuery query = new SolrQuery();
final String searchContext = search.getSearchContext();
if (search.getTimeZone() != null) {
query.set(CommonParams.TZ, search.getTimeZone());
}
// fulltext search
query.set(CommonParams.Q, search.getSearchString());
if (SearchConfiguration.get(SearchConfiguration.SEARCH_RESULT_SHOW_SCORE, true)) {
query.set(CommonParams.FL, "*,score");
} else {
query.set(CommonParams.FL, "*");
}
if (search.getGeoDistance() != null) {
final FieldDescriptor descriptor = factory.getField(search.getGeoDistance().getFieldName());
if (Objects.nonNull(descriptor)) {
query.setParam(CommonParams.FL, query.get(CommonParams.FL) + "," + DISTANCE + ":geodist()");
query.setParam("pt", search.getGeoDistance().getLocation().toString());
query.setParam("sfield", getFieldname(descriptor, UseCase.Facet, searchContext));
}
}
Collection<FieldDescriptor<?>> fulltext = factory.listFields().stream().filter(FieldDescriptor::isFullText).collect(Collectors.toList());
if (!fulltext.isEmpty()) {
query.setParam(DisMaxParams.QF, SolrUtils.Query.buildQueryFieldString(fulltext, searchContext));
query.setParam("defType", "edismax");
} else {
query.setParam(CommonParams.DF, TEXT);
}
// filters
query.add(CommonParams.FQ, "_type_:" + factory.getType());
if (search.hasFilter()) {
SolrUtils.Query.buildFilterString(search.getFilter(), factory, search.getChildrenFactory(), query, searchContext, search.getStrict());
}
// fulltext search deep search
if (search.isChildrenSearchEnabled()) {
// append childCount facet
search.facet(new Facet.SubdocumentFacet(factory));
// TODO: move to SolrUtils
final String parentSearchQuery = "((" + query.get(CommonParams.Q) + ") AND " + TYPE + ":" + factory.getType() + ")";
final String childrenSearchQuery = "_query_:\"{!parent which=" + TYPE + ":" + factory.getType() + "}(" + TYPE + ":" + search.getChildrenFactory().getType() + " AND (" + search.getChildrenSearchString().getEscapedSearchString() + "))\"";
query.set(CommonParams.Q, String.join(" ", parentSearchQuery, search.getChildrenSearchOperator().name(), childrenSearchQuery));
if (search.getChildrenSearchString().hasFilter()) {
// TODO clean up!
final String parentFilterQuery = "(" + String.join(" AND ", query.getFilterQueries()) + ")";
final String childrenFilterQuery = search.getChildrenSearchString().getFilter().accept(new SolrChildrenSerializerVisitor(factory, search.getChildrenFactory(), searchContext, search.getStrict()));
query.set(CommonParams.FQ, String.join(" ", parentFilterQuery, search.getChildrenSearchOperator().name(), "(" + childrenFilterQuery + ")"));
}
}
if (search.hasFacet()) {
query.setFacet(true);
query.setFacetMinCount(search.getFacetMinCount());
query.setFacetLimit(search.getFacetLimit());
// Query facets
search.getFacets().values().stream().filter(facet -> Facet.QueryFacet.class.isAssignableFrom(facet.getClass())).map(genericFacet -> (Facet.QueryFacet) genericFacet).forEach(queryFacet -> query.addFacetQuery(StringUtils.join(SolrUtils.Query.buildSolrFacetCustomName(SolrUtils.Query.buildFilterString(queryFacet.getFilter(), factory, search.getChildrenFactory(), searchContext, search.getStrict()), queryFacet))));
// Numeric Range facet
search.getFacets().values().stream().filter(facet -> Facet.NumericRangeFacet.class.isAssignableFrom(facet.getClass())).map(genericFacet -> (Facet.NumericRangeFacet) genericFacet).forEach(numericRangeFacet -> {
final UseCase useCase = UseCase.valueOf(numericRangeFacet.getScope().name());
final String fieldName = getFieldname(numericRangeFacet.getFieldDescriptor(), useCase, searchContext);
query.add(FacetParams.FACET_RANGE, SolrUtils.Query.buildSolrFacetCustomName(fieldName, numericRangeFacet));
query.add(String.format(Locale.ROOT, "f.%s.%s", fieldName, FacetParams.FACET_RANGE_START), numericRangeFacet.getStart().toString());
query.add(String.format(Locale.ROOT, "f.%s.%s", fieldName, FacetParams.FACET_RANGE_END), numericRangeFacet.getEnd().toString());
query.add(String.format(Locale.ROOT, "f.%s.%s", fieldName, FacetParams.FACET_RANGE_GAP), numericRangeFacet.getGap().toString());
/*query.addNumericRangeFacet(
SolrUtils.Query.buildSolrFacetCustomName(fieldName, numericRangeFacet.getName()),
numericRangeFacet.getStart(),
numericRangeFacet.getEnd(),
numericRangeFacet.getGap());*/
});
// Interval Range facet
search.getFacets().values().stream().filter(facet -> Facet.IntervalFacet.class.isAssignableFrom(facet.getClass())).map(genericFacet -> (Facet.IntervalFacet) genericFacet).forEach(intervalFacet -> {
final UseCase useCase = UseCase.valueOf(intervalFacet.getScope().name());
final String fieldName = getFieldname(intervalFacet.getFieldDescriptor(), useCase, searchContext);
query.add(FacetParams.FACET_INTERVAL, SolrUtils.Query.buildSolrFacetKey(intervalFacet.getName()) + fieldName);
for (Object o : intervalFacet.getIntervals()) {
// TODO why is this necessary?
Interval i = (Interval) o;
query.add(String.format("f.%s.%s", fieldName, FacetParams.FACET_INTERVAL_SET), String.format("%s%s%s,%s%s", SolrUtils.Query.buildSolrFacetKey(i.getName()), i.includesStart() ? "[" : "(", i.getStart() == null ? SOLR_WILDCARD : SolrUtils.Query.buildSolrQueryValue(i.getStart()), i.getEnd() == null ? SOLR_WILDCARD : SolrUtils.Query.buildSolrQueryValue(i.getEnd()), i.includesEnd() ? "]" : ")"));
}
});
// Date Range facet
search.getFacets().values().stream().filter(facet -> Facet.DateRangeFacet.class.isAssignableFrom(facet.getClass())).map(genericFacet -> (Facet.DateRangeFacet) genericFacet).forEach(dateRangeFacet -> generateDateRangeQuery(dateRangeFacet, query, searchContext));
// stats
search.getFacets().values().stream().filter(facet -> Facet.StatsFacet.class.isAssignableFrom(facet.getClass())).map(genericFacet -> (Facet.StatsFacet) genericFacet).forEach(statsFacet -> {
final UseCase useCase = UseCase.valueOf(statsFacet.getScope().name());
String fieldName = getFieldname(statsFacet.getField(), useCase, searchContext);
query.add(StatsParams.STATS, "true");
query.add(StatsParams.STATS_FIELD, SolrUtils.Query.buildSolrStatsQuery(fieldName, statsFacet));
});
// pivot facet
search.getFacets().values().stream().filter(facet -> Facet.PivotFacet.class.isAssignableFrom(facet.getClass())).map(genericFacet -> (Facet.PivotFacet) genericFacet).forEach(pivotFacet -> {
String[] fieldNames = pivotFacet.getFieldDescriptors().stream().map(fieldDescriptor -> getFieldname(fieldDescriptor, UseCase.Facet, searchContext)).toArray(String[]::new);
query.add(FacetParams.FACET_PIVOT, SolrUtils.Query.buildSolrPivotSubFacetName(pivotFacet.getName(), fieldNames));
});
// facet fields
final HashMap<String, Object> strings = SolrUtils.Query.buildJsonTermFacet(search.getFacets(), search.getFacetLimit(), factory, search.getChildrenFactory(), searchContext);
query.add("json.facet", strings.toString().replaceAll("=", ":"));
// facet Subdocument count
final String subdocumentFacetString = SolrUtils.Query.buildSubdocumentFacet(search, factory, searchContext);
if (Objects.nonNull(subdocumentFacetString)) {
query.add("json.facet", subdocumentFacetString);
}
}
// sorting
if (search.hasSorting()) {
final String sortString = SolrUtils.Query.buildSortString(search, search.getSorting(), factory);
query.set(CommonParams.SORT, sortString);
}
// TODO this is a mess
if (search.hasSorting()) {
query.set(DisMaxParams.BF, SolrUtils.Query.buildBoostFunction(search.getSorting(), searchContext));
}
// paging
switch(search.getResultSet().getType()) {
case page:
{
final Page resultSet = (Page) search.getResultSet();
query.setStart(resultSet.getOffset());
query.setRows(resultSet.getPagesize());
break;
}
case slice:
{
final Slice resultSet = (Slice) search.getResultSet();
query.setStart(resultSet.getOffset());
query.setRows(resultSet.getSliceSize());
break;
}
}
return query;
}
use of org.apache.commons.lang3.Range in project Eidolons by IDemiurge.
the class AttackTooltipFactory method createAttackTooltip.
public static AttackTooltip createAttackTooltip(DC_UnitAction el, boolean precalc, boolean costs, boolean additionalInfo, boolean combatMode, DC_Obj target) {
Pair<PARAMS, PARAMS> pair = ACTION_TOOLTIPS_PARAMS_MAP.get(ACTION_TOOLTIP_HEADER_KEY);
String name = ActionTooltipMaster.getStringForTableValue(ACTION_TOOLTIP_HEADER_KEY, el);
final String leftImage = ActionTooltipMaster.getIconPathForTableRow(pair.getLeft());
final String rightImage = ActionTooltipMaster.getIconPathForTableRow(pair.getRight());
MultiValueContainer head = new MultiValueContainer(name, leftImage, rightImage);
VALUE[] baseKeys = ACTION_TOOLTIP_BASE_KEYS;
final List<MultiValueContainer> base = extractActionValues(el, baseKeys);
baseKeys = ACTION_TOOLTIP_RANGE_KEYS;
final List<MultiValueContainer> range = extractActionValues(el, baseKeys);
List /*<List<MultiValueContainer>>*/
textsList = new ArrayList<>();
for (PARAMS[] params : ACTION_TOOLTIP_PARAMS_TEXT) {
textsList.add(Arrays.stream(params).map(p -> {
String textForTableValue = ActionTooltipMaster.getTextForTableValue(p, el);
textForTableValue = TextWrapper.wrapWithNewLine(textForTableValue, 50);
if (StringUtils.isEmpty(textForTableValue)) {
return null;
} else {
return new MultiValueContainer(textForTableValue, "");
}
}).filter(Objects::nonNull).collect(Collectors.toList()));
}
AttackTooltip toolTip = new AttackTooltip(el);
ValueContainer precalcRow = createPrecalcRow(precalc, el, target);
toolTip.setUserObject(new ActionTooltipSource() {
@Override
public MultiValueContainer getHead() {
return head;
}
@Override
public List<MultiValueContainer> getBase() {
return base;
}
@Override
public List<MultiValueContainer> getRange() {
return range;
}
@Override
public List<List<ValueContainer>> getText() {
return textsList;
}
@Override
public CostTableSource getCostsSource() {
return () -> ActionCostSourceImpl.getActionCostList(el);
}
@Override
public ValueContainer getPrecalcRow() {
return precalcRow;
}
});
return toolTip;
}
Aggregations