public int findFirstViewWithTag(String testTag, int actualPosition) {
int itemPosInMap = 0;
for (int i = 0; i < pictureMap.size(); i++) {
EndlessPagerModel item = pictureMap.get(i);
Log.i(
TAG,
"findFirstViewWithTag (pos= "
+ String.valueOf(itemPosInMap)
+ "): "
+ item.getTag()
+ "\nTrue? - "
+ String.valueOf(item.getTag().equals(testTag)));
if (item.getTag().equals(testTag)) {
Log.i(TAG, "If-Case - Return of p: " + String.valueOf(itemPosInMap));
break;
}
itemPosInMap++;
}
// Because of FakeItems + 2
itemPosInMap += 1;
int newPosition = itemPosInMap + ((actualPosition / getRealSizeOfData()) * pictureMap.size());
Log.i(
TAG,
"End of Method - Return of p: "
+ String.valueOf(itemPosInMap)
+ "\nSwitchToPos: "
+ String.valueOf(newPosition));
return newPosition;
}
protected void killConnections(ibis.ipl.IbisIdentifier corpse) {
SendPort[] sps;
ReceivePort[] rps;
synchronized (this) {
sps = sendPorts.values().toArray(new SendPort[sendPorts.size()]);
rps = receivePorts.values().toArray(new ReceivePort[receivePorts.size()]);
}
for (SendPort s : sps) {
try {
s.killConnectionsWith(corpse);
} catch (Throwable e) {
if (logger.isDebugEnabled()) {
logger.debug("Got exception from killConnectionsWith", e);
}
}
}
for (ReceivePort p : rps) {
try {
p.killConnectionsWith(corpse);
} catch (Throwable e) {
if (logger.isDebugEnabled()) {
logger.debug("Got exception from killConnectionsWith", e);
}
}
}
}
/**
* @param modelNodeToDataNode
* @param mismatch
* @throws IllegalArgumentException if all of the data nodes in the sample are not unique.
*/
public Sample(
HashMap<Integer, Integer> modelNodeToDataNode,
HashMap<String, Integer> dataIDToDataNodeID,
double mismatch,
HashMap<String, RelationshipForSample> relationshipIDs) {
this.dataIDToDataNodeID = new HashMap<String, Integer>(dataIDToDataNodeID.size());
if (dataIDToDataNodeID != null)
for (Entry<String, Integer> e : dataIDToDataNodeID.entrySet()) {
this.dataIDToDataNodeID.put(new String(e.getKey()), new Integer(e.getValue()));
}
this.modelNodeToDataNode = new HashMap<Integer, Integer>(modelNodeToDataNode.size());
this.dataNodeToModelNode = new HashMap<Integer, Integer>(modelNodeToDataNode.size());
// Performing deep copy just in case
for (Entry<Integer, Integer> e : modelNodeToDataNode.entrySet()) {
this.modelNodeToDataNode.put(new Integer(e.getKey()), new Integer(e.getValue()));
this.dataNodeToModelNode.put(new Integer(e.getValue()), new Integer(e.getKey()));
}
HashSet<Integer> dataNodes = new HashSet<Integer>(this.modelNodeToDataNode.values());
if (dataNodes.size() != this.modelNodeToDataNode.size())
throw new IllegalArgumentException(
"Sample contains multiple instances of the same data node.");
this.relationshipIDs = new HashMap<String, RelationshipForSample>();
for (Entry<String, RelationshipForSample> e : relationshipIDs.entrySet()) {
this.relationshipIDs.put(e.getKey(), e.getValue());
}
this.additionalRelationshipIDs = new HashMap<String, ArrayList<String>>();
this.mismatch = mismatch;
}
synchronized void populate(List<ObaStop> stops, List<ObaRoute> routes) {
int count = 0;
if (mStopMarkers.size() >= FUZZY_MAX_MARKER_COUNT) {
// We've exceed our max, so clear the current marker cache and start over
Log.d(TAG, "Exceed max marker cache of " + FUZZY_MAX_MARKER_COUNT + ", clearing cache");
removeMarkersFromMap();
mStopMarkers.clear();
mStops.clear();
// Make sure the currently focused stop still exists on the map
if (mCurrentFocusStop != null && mFocusedRoutes != null) {
addMarkerToMap(mCurrentFocusStop, mFocusedRoutes);
count++;
}
}
for (ObaStop stop : stops) {
if (!mStopMarkers.containsKey(stop.getId())) {
addMarkerToMap(stop, routes);
count++;
}
}
Log.d(TAG, "Added " + count + " markers, total markers = " + mStopMarkers.size());
}
public static boolean isValid(HashMap<?, ?> expected, HashMap<?, ?> map) {
if (map == null) {
return false;
}
if (expected.size() != map.size()) {
return false;
}
Set<?> entries = expected.entrySet();
Iterator<?> entryIter = entries.iterator();
while (entryIter.hasNext()) {
Entry<?, ?> entry = (Entry<?, ?>) entryIter.next();
Object value = map.get(entry.getKey());
if (value != entry.getValue()) {
if (value == null || entry.getValue() == null) {
return false;
}
if (!map.get(entry.getKey()).equals(entry.getValue())) {
return false;
}
}
}
return true;
}
protected void computeEdgeAndThreadNo() {
Iterator it = iterator();
int numberOfEdge = 0;
while (it.hasNext()) {
List succList = (List) getSuccsOf(it.next());
numberOfEdge = numberOfEdge + succList.size();
}
numberOfEdge = numberOfEdge + startToThread.size();
System.err.println("**number of edges: " + numberOfEdge);
System.err.println("**number of threads: " + (startToThread.size() + 1));
/* Set keySet = startToThread.keySet();
Iterator keyIt = keySet.iterator();
while (keyIt.hasNext()){
List list = (List)startToThread.get(keyIt.next());
System.out.println("********start thread:");
Iterator itit = list.iterator();
while (itit.hasNext()){
System.out.println(it.next());
}
}
*/
}
private static void a(File paramFile, HashMap paramHashMap)
{
if (paramHashMap.size() >= 23);
label61: String str1;
String str2;
do
{
while (true)
{
return;
if (!paramFile.isDirectory())
break;
File[] arrayOfFile = paramFile.listFiles();
if (arrayOfFile != null)
for (int i = 0; ; i++)
{
if (i >= arrayOfFile.length)
break label61;
a(arrayOfFile[i], paramHashMap);
if (paramHashMap.size() >= 23)
break;
}
}
str1 = paramFile.getAbsolutePath();
str2 = str1.substring(1 + str1.lastIndexOf("/"));
}
while (!str2.startsWith("snst"));
paramHashMap.put(str2, str1);
}
void stopRandomServer() throws Exception {
lock.writeLock().lock();
TestRpcServer rpcServer = null;
try {
if (rpcServers.size() <= minServers) {
return;
}
int size = rpcServers.size();
int rand = random.nextInt(size);
rpcServer = serverList.remove(rand);
InetSocketAddress address = rpcServer.getListenerAddress();
if (address == null) {
// Throw exception here. We can't remove this instance from the server map because
// we no longer have access to its map key
throw new IOException("Listener channel is closed");
}
rpcServers.remove(address);
if (rpcServer != null) {
stopServer(rpcServer);
}
} finally {
lock.writeLock().unlock();
}
}
/** @param args the command line arguments */
public static void main(String[] args) throws IOException {
String snpMappings = "E:\\LLD_HRC_IMPUTATION\\SNPMappings.txt";
String snps = "E:\\LLD_HRC_IMPUTATION\\SNPs.txt";
String bedFolder = "E:\\dbSNP_147\\";
String snpsOut = "E:\\LLD_HRC_IMPUTATION\\SNPs2.txt";
String snpMappingsOut = "E:\\LLD_HRC_IMPUTATION\\SNPMappings2.txt";
System.out.println("Processing original SNP file: ");
LinkedHashSet<String> OrderingEst = readSnpOrderFile(snps);
System.out.println("Done found: " + OrderingEst.size() + " SNPs");
System.out.println("Processing original mapping file: ");
HashMap<String, String> mappingEst = readSnpMappings(snpMappings, false, (OrderingEst.size()));
System.out.println("Done found: " + mappingEst.size() + " mappings");
System.out.println("Processing dbSNP bed folder: ");
HashMap<String, String> mappingUmcg =
readSnpMappingsBed(bedFolder, mappingEst, mappingEst.size());
System.out.println("Done found: " + mappingUmcg.size() + " mappings");
System.out.println("Remapping original data.");
remapPositionsAndSnps(OrderingEst, mappingEst, mappingUmcg, snpsOut, snpMappingsOut);
}
private Node getReferenceTable(Results r) {
String[] subH = new String[r.getNumberOfClusters()];
for (int i = 0; i < subH.length; i++) subH[i] = "Cluster " + i;
DataTable refTable = new DataTable();
refTable.addHiddenClusterHeaders(subH);
// Fetch the reference labels
String[] refLabels = r.getReferenceLabels();
refTable.setLabelRowRelationship(getReferenceRowRelationship(refLabels));
refTable.setTotalLabelCount(mRefLabelToRow.size());
// For each cluster, we add the reference data means as labels, and link that data to the
// corresponding label
double[][] refMeans = r.getReferenceDataMeans();
for (int col = 0; col < r.getNumberOfClusters(); col++) {
ArrayList<Pair<String, String>> pairs = new ArrayList<Pair<String, String>>();
double[] thisCol = refMeans[col];
for (int j = 0; j < refLabels.length; j++) {
Pair<String, String> pair =
new Pair<String, String>(refLabels[j], String.valueOf(thisCol[j]));
pairs.add(pair);
}
refTable.setColumnData(col, mRefLabelToRow.size(), pairs);
}
mRefDataTables.add(refTable);
return refTable;
}
public void invalidateCompiledNativeCodeBlocks(int startAddress, int endAddress) {
// Most common case: nothing to do.
if (compiledNativeCodeBlocks.size() == 0) {
return;
}
// What is the most efficient?
// To scan all the addressed between startAddress and endAddres or
// to scan all the compiledNativeCodeBlocks?
if ((endAddress - startAddress) >>> 2 < compiledNativeCodeBlocks.size()) {
for (int address = startAddress; address <= endAddress; address += 4) {
compiledNativeCodeBlocks.remove(address);
}
} else {
List<Integer> toBeRemoved = new LinkedList<Integer>();
for (Integer address : compiledNativeCodeBlocks.keySet()) {
if (startAddress >= address.intValue() && address.intValue() <= endAddress) {
toBeRemoved.add(address);
}
}
for (Integer address : toBeRemoved) {
compiledNativeCodeBlocks.remove(address);
}
toBeRemoved.clear();
}
}
public static ArrayList<String> getRetunItemToList(
HashMap<String, String> urlParam, HashMap<Integer, String> searchIndisItemHm) {
ArrayList<String> li = new ArrayList<String>();
Set key = urlParam.keySet();
// 필수 항목 체크 (url에 필수적으로 들어가야 할 항목 체크)
for (Iterator iterator = key.iterator(); iterator.hasNext(); ) {
String keyName = (String) iterator.next();
String valueName = (String) urlParam.get(keyName);
int chkNum = urlParam.size(); // 필수항목 체크 숫자
for (int i = 0; i < searchIndisItemHm.size(); i++) {
if (keyName.toUpperCase().equals(searchIndisItemHm.get(i).toUpperCase())) {
chkNum = chkNum - urlParam.size();
}
}
if (chkNum > 0) {
li.add(keyName);
}
}
return li;
}
/**
* *
*
* <p>검색 필수 유효성체크 필수항목체크
*
* @param HashMap<String,String> urlParam, HashMap<Integer,String> searchIndisItemHm
* @return HashMap<String,String>
*/
public static HashMap<String, String> getValidataIndisItem(
HashMap<String, String> urlParam,
HashMap<Integer, String> searchIndisItemHm,
HashMap<String, String> errHm) {
// 필수 항목 체크 (url에 필수적으로 들어가야 할 항목 체크)
int allchkNum = 0;
for (int i = 0; i < searchIndisItemHm.size(); i++) {
Set key = urlParam.keySet();
int chkNum = searchIndisItemHm.size(); // 필수항목 체크 숫자
for (Iterator iterator = key.iterator(); iterator.hasNext(); ) {
String keyName = (String) iterator.next();
String valueName = (String) urlParam.get(keyName);
if (searchIndisItemHm.get(i).toUpperCase().equals(keyName.toUpperCase())) {
allchkNum = allchkNum + 1;
chkNum = chkNum - searchIndisItemHm.size();
}
}
if (chkNum > 0) {
errHm.put(searchIndisItemHm.get(i), "필수 항목 변수를 존재하지 않습니다.");
}
}
int num = searchIndisItemHm.size() - allchkNum;
errHm.put("errCnt", String.valueOf(num));
return errHm;
}
private Double CosineSimilarity(HashMap<String, Double> table1, HashMap<String, Double> table2)
throws Exception {
if (table1.size() != table2.size()) {
throw new Exception("Table sizes must be equal");
}
// length of table 1
double length1 = 0;
double length2 = 0;
// Double firstValue;
double secValue;
// sum of vector multiplication
double svMul = 0;
for (Entry<String, Double> kv : table1.entrySet()) {
length1 += Math.pow(kv.getValue(), 2);
secValue = table2.get(kv.getKey());
length2 += Math.pow(secValue, 2);
svMul += secValue * kv.getValue();
}
length1 = Math.sqrt(length1);
length2 = Math.sqrt(length2);
return Double.parseDouble(NumericFormat.getNumberFormated(svMul / (length1 * length2)));
}
@Test
public void testExecute() throws Exception {
HashMap<UserOptions, String> configMap = new HashMap<UserOptions, String>();
configMap.put(UserOptions.DisplayButtons, Boolean.toString(true));
configMap.put(UserOptions.EditorPageSize, Integer.toString(25));
configMap.put(UserOptions.EnterSavesApproved, Boolean.toString(true));
SaveOptionsAction action = new SaveOptionsAction(configMap);
SaveOptionsResult result = handler.execute(action, null);
assertThat(result.isSuccess(), Matchers.equalTo(true));
List<HAccountOption> accountOptions =
getEm().createQuery("from HAccountOption").getResultList();
assertThat(accountOptions, Matchers.hasSize(configMap.size()));
Map<String, HAccountOption> editorOptions = authenticatedAccount.getEditorOptions();
assertThat(editorOptions.values(), Matchers.containsInAnyOrder(accountOptions.toArray()));
handler.execute(action, null); // save again should override previous
// value
accountOptions = getEm().createQuery("from HAccountOption").getResultList();
assertThat(accountOptions, Matchers.hasSize(configMap.size()));
assertThat(editorOptions.values(), Matchers.containsInAnyOrder(accountOptions.toArray()));
}
@Test
public void readTest() {
String insertKey = "user0";
Map<String, ByteIterator> insertMap = insertRow(insertKey);
HashSet<String> readFields = new HashSet<>();
HashMap<String, ByteIterator> readResultMap = new HashMap<>();
// Test reading a single field
readFields.add("FIELD0");
orientDBClient.read(CLASS, insertKey, readFields, readResultMap);
assertEquals(
"Assert that result has correct number of fields", readFields.size(), readResultMap.size());
for (String field : readFields) {
assertEquals(
"Assert " + field + " was read correctly",
insertMap.get(field).toString(),
readResultMap.get(field).toString());
}
readResultMap = new HashMap<>();
// Test reading all fields
readFields.add("FIELD1");
readFields.add("FIELD2");
orientDBClient.read(CLASS, insertKey, readFields, readResultMap);
assertEquals(
"Assert that result has correct number of fields", readFields.size(), readResultMap.size());
for (String field : readFields) {
assertEquals(
"Assert " + field + " was read correctly",
insertMap.get(field).toString(),
readResultMap.get(field).toString());
}
}
public ArrayList<String> getTop() {
String most = "";
ArrayList<String> top = new ArrayList<String>();
HashMap<String, Integer> hold = new HashMap<String, Integer>();
for (Entry<String, Integer> e : score.entrySet()) {
hold.put(e.getKey(), e.getValue());
}
int theMax = 10;
if (hold.size() < 10) theMax = hold.size();
for (int i = 0; i < theMax; i++) {
System.out.println("**" + i + "**");
for (Entry<String, Integer> info : hold.entrySet()) {
System.out.println(info.getKey());
if (info.getValue() > getScore(most)) {
most = info.getKey();
}
}
top.add(most);
hold.remove(most);
}
return top;
}
private ArrayList<StudentPersonalType> fetchStudents(
HashMap<String, StudentPersonalType> studentMap, PagingInfo pagingInfo) {
ArrayList<StudentPersonalType> studentList = new ArrayList<StudentPersonalType>();
if (pagingInfo == null) // return all
{
studentList.addAll(studentMap.values());
} else {
pagingInfo.setTotalObjects(studentMap.size());
if ((pagingInfo.getPageSize() * (pagingInfo.getCurrentPageNo())) > studentMap.size()) {
return null; // Requested page outside of limits.
}
// retrieve applicable students
Collection<StudentPersonalType> allStudent = studentMap.values();
int i = 0;
int startPos = pagingInfo.getPageSize() * pagingInfo.getCurrentPageNo();
int endPos = startPos + pagingInfo.getPageSize();
for (Iterator<StudentPersonalType> iter = allStudent.iterator(); iter.hasNext(); ) {
StudentPersonalType student = iter.next();
if ((i >= startPos) && (i < endPos)) {
studentList.add(student);
}
i++;
}
// Set the number of object that are returned in the paging info. Will ensure HTTP headers are
// set correctly.
pagingInfo.setPageSize(studentList.size());
}
return studentList;
}
private Node getDataTable(Results r, Pane pane) {
// The grid part contains the cluster's centoid data, as well as the "X" button
String[] subH = new String[r.getNumberOfClusters()];
for (int i = 0; i < subH.length; i++) subH[i] = "Cluster " + i;
DataTable dataTable = new DataTable("Run " + mNextRun++, subH);
// Fetch the labels. Inform the data table of the label-row relationships
String[] labels = r.getLabels();
dataTable.setLabelRowRelationship(getLabelRowRelationship(labels));
dataTable.setTotalLabelCount(mDataLabelToRow.size());
// For each cluster, we create a list of Label - Data pairs, where the label denotes what
// feature we are looking at
// and the Data represents that clusters centoid for the current feature
for (int col = 0; col < r.getNumberOfClusters(); col++) {
ArrayList<Pair<String, String>> labelDataPairs = new ArrayList<Pair<String, String>>();
double[] clusterCentoid = r.getCentoid(col);
for (int j = 0; j < labels.length; j++) {
Pair<String, String> pair =
new Pair<String, String>(labels[j], String.valueOf(clusterCentoid[j]));
labelDataPairs.add(pair);
}
dataTable.setColumnData(col, mDataLabelToRow.size(), labelDataPairs);
}
dataTable.addCloseButton(pane);
mDataTables.add(dataTable);
return dataTable;
}
public HeatMapData generateMeanHeatMapData(ArrayList<String> probeList) {
HeatMapData hmd = new HeatMapData(HeatMapData.ONE_COLOR);
double[][] ddata = new double[probeList.size()][tissues.size() * meanStrains.size()];
int actualSize = 0;
for (int i = 0; i < probeList.size(); i++) {
// System.out.println("get data:"+probeList.get(i));
HashMap tmp = (HashMap) data.get(probeList.get(i));
if (tmp != null) {
ArrayList<Double> row = (ArrayList<Double>) tmp.get("meanRow");
for (int j = 0; j < row.size(); j++) {
ddata[i][j] = row.get(j).doubleValue();
}
actualSize++;
} else {
// System.out.println();
probeList.remove(i);
i--;
}
}
double[][] tmpdata = new double[actualSize][tissues.size() * meanStrains.size()];
for (int i = 0; i < tmpdata.length; i++) {
tmpdata[i] = ddata[i];
}
hmd.setDataString(tmpdata, probeList, false);
return hmd;
}
/**
* Use for slider: limits the categories visualization from cat selected to cat
* selected+numberscatsVisualization.
*
* @param dataset the dataset
* @param categories the categories
* @param catSelected the cat selected
* @param numberCatsVisualization the number cats visualization
* @return the dataset
*/
public Dataset filterDataset(
Dataset dataset, HashMap categories, int catSelected, int numberCatsVisualization) {
logger.debug("IN");
DefaultCategoryDataset catDataset = (DefaultCategoryDataset) dataset;
int numCats = categories.size();
Vector visCat = new Vector();
// from the choice point to min(chose point+interval, end point)
// int startPoint=((catSelected-1)*numberCatsVisualization)+1;
int startPoint = catSelected;
int endPoint;
if ((startPoint + numberCatsVisualization - 1) <= (categories.size()))
endPoint = startPoint + numberCatsVisualization - 1;
else endPoint = categories.size();
for (int i = (startPoint); i <= endPoint; i++) {
String name = (String) categories.get(new Integer(i));
visCat.add(name);
}
List columns = new Vector(catDataset.getColumnKeys());
for (Iterator iterator = columns.iterator(); iterator.hasNext(); ) {
String col = (String) iterator.next();
if (!(visCat.contains(col))) {
catDataset.removeColumn(col);
}
}
logger.debug("OUT");
return catDataset;
}
/**
* getting a list of itemGrading for a publishedItemId is a lot of work, read the code in
* GradingService.getItemScores() after we get the list, we are saving it in
* QuestionScoreBean.itemScoresMap itemScoresMap = (publishedItemId, HashMap) = (Long
* publishedItemId, (Long publishedItemId, Array itemGradings)) itemScoresMap will be refreshed
* when the next QuestionScore link is click
*/
private HashMap getItemScores(
Long publishedId, Long itemId, String which, boolean isValueChange) {
log.debug("getItemScores");
GradingService delegate = new GradingService();
QuestionScoresBean questionScoresBean =
(QuestionScoresBean) ContextUtil.lookupBean("questionScores");
HashMap itemScoresMap = questionScoresBean.getItemScoresMap();
log.debug("getItemScores: itemScoresMap ==null ?" + itemScoresMap);
log.debug("getItemScores: isValueChange ?" + isValueChange);
if (itemScoresMap == null
|| isValueChange
|| questionScoresBean.getIsAnyItemGradingAttachmentListModified()) {
log.debug("getItemScores: itemScoresMap == null or isValueChange == true ");
log.debug("getItemScores: isValueChange = " + isValueChange);
itemScoresMap = new HashMap();
questionScoresBean.setItemScoresMap(itemScoresMap);
// reset this anyway (because the itemScoresMap will be refreshed as well as the
// attachment list)
questionScoresBean.setIsAnyItemGradingAttachmentListModified(false);
}
log.debug("getItemScores: itemScoresMap.size() " + itemScoresMap.size());
HashMap map = (HashMap) itemScoresMap.get(itemId);
if (map == null) {
log.debug("getItemScores: map == null ");
map = delegate.getItemScores(publishedId, itemId, which, true);
log.debug("getItemScores: map size " + map.size());
itemScoresMap.put(itemId, map);
}
return map;
}
synchronized void transfer(Object oldGroup, Object newGroup) {
HashMap from = (HashMap) groups.get(oldGroup);
if (from == null) return;
HashMap to = (HashMap) groups.get(newGroup);
if (to == null) {
// simple case
groups.put(newGroup, from);
clearLimit(oldGroup);
groups.remove(oldGroup);
return;
}
if (to.size() < from.size()) {
// place the contents of to into from
mergeGroups(to, from);
Object oldTo = groups.put(newGroup, from);
if (SanityManager.DEBUG) {
SanityManager.ASSERT(oldTo == to, "inconsistent state in LockSpace");
}
} else {
mergeGroups(from, to);
}
clearLimit(oldGroup);
groups.remove(oldGroup);
}
/**
* Shows the skill tree for the player. If the player has multiple trees, this will show the list
* of skill trees they can view.
*
* @param player player to show the skill tree for
* @return true if able to show the player, false otherwise
*/
public boolean showSkills(Player player) {
// Cannot show an invalid player, and cannot show no skills
if (player == null || classes.size() == 0 || skills.size() == 0) {
return false;
}
// Show skill tree of only class
if (classes.size() == 1) {
PlayerClass playerClass = classes.get(classes.keySet().toArray(new String[1])[0]);
if (playerClass.getData().getSkills().size() == 0) {
return false;
}
player.openInventory(
((InventoryTree) playerClass.getData().getSkillTree()).getInventory(this));
return true;
}
// Show list of classes that have skill trees
else {
Inventory inv =
InventoryManager.createInventory(
TreeListener.CLASS_LIST_KEY, (classes.size() + 8) / 9, player.getName());
for (PlayerClass c : classes.values()) {
inv.addItem(c.getData().getIcon());
}
player.openInventory(inv);
return true;
}
}
@Override
public void onItemLongClickListener(View view, int position) {
if (selectedApps.get(position) == null) {
selectedApps.put(position, adapter.getModelList().get(position));
adapter.setItemChecked(position, true);
} else {
selectedApps.remove(position);
adapter.setItemChecked(position, false);
}
if (selectedApps.size() != 0) {
if (actionMode == null) {
actionMode = toolbar.startActionMode(this);
AppHelper.actionModeColor(this);
}
if (selectedApps.size() > 1) {
actionMode.setTitle("Backup ( " + selectedApps.size() + " Apps )");
} else {
actionMode.setTitle("Backup ( " + selectedApps.size() + " App )");
}
enableDisableMenuItem(false);
} else {
actionMode.finish();
actionMode = null;
}
}
// Compute a compressed double buffer
private Chunk chunkD() {
HashMap<Long, Byte> hs = new HashMap<>(CUDChunk.MAX_UNIQUES);
Byte dummy = 0;
final byte[] bs = MemoryManager.malloc1(_len * 8, true);
int j = 0;
boolean fitsInUnique = true;
for (int i = 0; i < _len; ++i) {
double d = 0;
if (_id == null || _id.length == 0 || (j < _id.length && _id[j] == i)) {
d =
_ds != null
? _ds[j]
: (isNA2(j) || isCategorical(j)) ? Double.NaN : _ls[j] * PrettyPrint.pow10(_xs[j]);
++j;
}
if (fitsInUnique) {
if (hs.size() < CUDChunk.MAX_UNIQUES) // still got space
hs.put(
Double.doubleToLongBits(d),
dummy); // store doubles as longs to avoid NaN comparison issues during extraction
else
fitsInUnique =
(hs.size() == CUDChunk.MAX_UNIQUES)
&& // full, but might not need more space because of repeats
hs.containsKey(Double.doubleToLongBits(d));
}
UnsafeUtils.set8d(bs, 8 * i, d);
}
assert j == sparseLen() : "j = " + j + ", _len = " + sparseLen();
if (fitsInUnique && CUDChunk.computeByteSize(hs.size(), len()) < 0.8 * bs.length)
return new CUDChunk(bs, hs, len());
else return new C8DChunk(bs);
}
private String toStringSingle() {
String indent = " ";
if (sf == null && children.size() > 0)
return children.values().iterator().next().toStringSingle();
if (children.size() == 0) return indent + sf;
return children.values().iterator().next().toStringSingle() + "\n" + indent + sf;
}
@Test
public void testAddGraph() {
final String graphName = "bo";
assertEquals(0, managedGraphs.size());
manager.addGraph(graphName);
assertEquals(1, managedGraphs.size());
assertNotNull(managedGraphs.get(graphName));
}
/**
* returns true, if the query block contains any query, or subquery without a source table Like
* select current_user(), select current_database()
*
* @return true, if the query block contains any query without a source table
*/
public boolean containsQueryWithoutSourceTable() {
for (QBExpr qbexpr : aliasToSubq.values()) {
if (qbexpr.containsQueryWithoutSourceTable()) {
return true;
}
}
return aliasToTabs.size() == 0 && aliasToSubq.size() == 0;
}
public String toString() {
String s =
String.format("NameableMap %d - %d - %d\n", _nameMap.size(), _UUIDMap.size(), _list.size());
for (INameable n : _list) {
s += "\t" + n.getQualifiedLabel() + "\n";
}
return s;
}