_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q175300 | VlenIO.writeVInt | test | public int writeVInt(int i) throws IOException {
int count = 0;
while ((i & ~0x7F) != 0) {
writeByte((byte) ((i & 0x7f) | 0x80));
i >>>= 7;
count++;
}
writeByte((byte) i);
return count + 1;
} | java | {
"resource": ""
} |
q175301 | VlenIO.writeChars | test | public int writeChars(String s, int start, int length) throws IOException {
final int end = start + length;
int count = 0;
for (int i = start; i < end; i++) {
final int code = (int) s.charAt(i);
if (code >= 0x01 && code <= 0x7F) {
writeByte((byte) code);
count++;
} else if (((code >= 0x80) && (code <= 0x7FF)) || code == 0) {
writeByte((byte) (0xC0 | (code >> 6)));
writeByte((byte) (0x80 | (code & 0x3F)));
count += 2;
} else {
writeByte((byte) (0xE0 | (code >>> 12)));
writeByte((byte) (0x80 | ((code >> 6) & 0x3F)));
writeByte((byte) (0x80 | (code & 0x3F)));
count += 3;
}
}
return count;
} | java | {
"resource": ""
} |
q175302 | VlenIO.readChars | test | public void readChars(char[] buffer, int start, int length) throws IOException {
final int end = start + length;
for (int i = start; i < end; i++) {
byte b = readByte();
if ((b & 0x80) == 0)
buffer[i] = (char) (b & 0x7F);
else if ((b & 0xE0) != 0xE0) {
buffer[i] = (char) (((b & 0x1F) << 6)
| (readByte() & 0x3F));
} else
buffer[i] = (char) (((b & 0x0F) << 12)
| ((readByte() & 0x3F) << 6)
| (readByte() & 0x3F));
}
} | java | {
"resource": ""
} |
q175303 | Grib.setDebugFlags | test | public static void setDebugFlags(ucar.nc2.util.DebugFlags debugFlag) {
debugRead = debugFlag.isSet("Grib/showRead");
debugIndexOnly = debugFlag.isSet("Grib/indexOnly");
debugIndexOnlyShow = debugFlag.isSet("Grib/indexOnlyShow");
debugGbxIndexOnly = debugFlag.isSet("Grib/debugGbxIndexOnly");
} | java | {
"resource": ""
} |
q175304 | StructureMembers.addMember | test | public void addMember(Member m) {
members.add(m);
if (memberHash != null)
memberHash.put(m.getName(), m);
} | java | {
"resource": ""
} |
q175305 | StructureMembers.hideMember | test | public int hideMember(Member m) {
if (m == null) return -1;
int index = members.indexOf(m);
members.remove(m);
if (memberHash != null) memberHash.remove(m.getName());
return index;
} | java | {
"resource": ""
} |
q175306 | StructureMembers.getMemberNames | test | public java.util.List<String> getMemberNames() {
List<String> memberNames = new ArrayList<>();
for (Member m : members) {
memberNames.add(m.getName());
}
return memberNames;
} | java | {
"resource": ""
} |
q175307 | StructureMembers.findMember | test | public Member findMember(String memberName) {
if (memberName == null) return null;
if (memberHash == null) { // delay making the hash table until needed
int initial_capacity = (int) (members.size() / .75) + 1;
memberHash = new HashMap<>(initial_capacity);
for (Member m : members)
memberHash.put(m.getName(), m);
}
return memberHash.get(memberName);
} | java | {
"resource": ""
} |
q175308 | Grib1SectionBitMap.getBitmap | test | @Nullable
public byte[] getBitmap(RandomAccessFile raf) throws IOException {
if (startingPosition <= 0) {
throw new IllegalStateException("Grib1 Bit map has bad starting position");
}
raf.seek(startingPosition);
// octet 1-3 (length of section)
int length = GribNumbers.uint3(raf);
// octet 4 unused bits
raf.read(); // unused
// octets 5-6
int bm = raf.readShort();
if (bm != 0) {
logger.warn("Grib1 Bit map section pre-defined (provided by center) bitmap number = {}", bm);
return null;
}
// not sure if length is set correctly when pre-define bitmap is used, so wait until that to test
// seeing a -1, bail out
if (length <= 6 || length > 10e6) { // look max ??
return null;
}
// read the bits as integers
int n = length - 6;
byte[] data = new byte[n];
raf.readFully(data);
return data;
} | java | {
"resource": ""
} |
q175309 | JTreeTableSorted.restoreState | test | public void restoreState(PreferencesExt store) {
if (store == null)
return;
int ncols = table.getColumnCount();
// stored column order
int[] modelIndex = (int[]) store.getBean("ColumnOrder", null);
if ((modelIndex != null) && (modelIndex.length == ncols)) { // what about invisible ??
// make invisible any not stored
boolean[] visible = new boolean[ncols];
for (int aModelIndex : modelIndex)
if (aModelIndex < ncols)
visible[aModelIndex] = true;
// modify popup menu
for (int i = 0; i < ncols; i++)
if (!visible[i]) {
//System.out.println( colName[i]+" hide "+i);
acts[i].hideColumn();
acts[i].putValue(BAMutil.STATE, new Boolean(false));
}
// now set the header order
TableColumnModel tcm = table.getColumnModel();
int n = Math.min(modelIndex.length, table.getColumnCount());
for (int i = 0; i < n; i++) {
TableColumn tc = tcm.getColumn(i);
tc.setModelIndex(modelIndex[i]);
String name = model.getColumnName(modelIndex[i]);
tc.setHeaderValue(name);
tc.setIdentifier(name);
if (useThreads && (modelIndex[i] == threadCol)) {
threadHeaderRenderer = new ThreadHeaderRenderer(threadCol);
tc.setHeaderRenderer(threadHeaderRenderer);
} else
tc.setHeaderRenderer(new SortedHeaderRenderer(name, modelIndex[i]));
}
}
// set the column widths
Object colWidths = store.getBean("ColumnWidths", null);
if (colWidths == null)
return;
int[] size = (int[]) colWidths;
setColumnWidths(size);
if (debug) {
System.out.println(" read widths = ");
for (int aSize : size)
System.out.print(" " + aSize);
System.out.println();
}
boolean isThreadsOn = store.getBoolean("isThreadsOn", false);
if (useThreads) {
model.setThreadsOn(isThreadsOn);
threadHeaderRenderer.setOn(isThreadsOn);
}
int colNo = store.getInt("SortOnCol", 0);
boolean reverse = store.getBoolean("SortReverse", false);
model.setSortCol(colNo);
model.setReverse(reverse);
setSortCol(colNo, reverse);
model.sort();
table.fireDataChanged();
}
private void setColumnWidths(int[] sizes) {
TableColumnModel tcm = table.getColumnModel();
for (int i = 0; i < table.getColumnCount(); i++) {
TableColumn tc = tcm.getColumn(i);
int maxw = ((sizes == null) || (i >= sizes.length)) ? 10 : sizes[i];
// model.getPreferredWidthForColumn(tc) : sizes[i];
tc.setPreferredWidth(maxw);
}
//table.sizeColumnsToFit(0); // must be called due to a JTable bug
}
public void setColOn(int colno, boolean state, int pos) {
// System.out.println("setColOn "+colno+" "+state+" "+pos);
acts[colno].putValue(BAMutil.STATE, new Boolean(state));
if (state)
acts[colno].addAtPos(pos);
else
acts[colno].hideColumn();
} | java | {
"resource": ""
} |
q175310 | JTreeTableSorted.getSelectedRows | test | public Iterator getSelectedRows() {
TreePath[] paths = table.getSelectionPaths();
if ((paths == null) || (paths.length < 1))
return null;
HashSet set = new HashSet(2 * paths.length);
for (TreePath path : paths) {
model.addRowsToSetFromPath(table.getTree(), path, set);
}
return set.iterator();
} | java | {
"resource": ""
} |
q175311 | JTreeTableSorted.getModelIndex | test | public int[] getModelIndex() {
int[] modelIndex = new int[model.getColumnCount()];
try {
TableColumnModel tcm = table.getColumnModel();
for (int i = 0; i < model.getColumnCount(); i++) {
TableColumn tc = tcm.getColumn(i);
modelIndex[i] = tc.getModelIndex();
}
} catch (java.lang.ArrayIndexOutOfBoundsException e) {
//can happen when model size increases
}
return modelIndex;
} | java | {
"resource": ""
} |
q175312 | StructureDataW.getArray | test | public Array getArray(StructureMembers.Member m) {
if (m == null) throw new IllegalArgumentException("member is null");
return memberData.get(m);
} | java | {
"resource": ""
} |
q175313 | StructureDataW.getScalarDouble | test | public double getScalarDouble(StructureMembers.Member m) {
Array data = getArray(m);
return data.getDouble(Index.scalarIndexImmutable);
} | java | {
"resource": ""
} |
q175314 | StructureDataW.getJavaArrayDouble | test | public double[] getJavaArrayDouble(StructureMembers.Member m) {
Array data = getArray(m);
return (double []) data.getStorage();
} | java | {
"resource": ""
} |
q175315 | StructureDataW.getScalarFloat | test | public float getScalarFloat(StructureMembers.Member m) {
Array data = getArray(m);
return data.getFloat(Index.scalarIndexImmutable);
} | java | {
"resource": ""
} |
q175316 | StructureDataW.getJavaArrayFloat | test | public float[] getJavaArrayFloat(StructureMembers.Member m) {
Array data = getArray(m);
return (float []) data.getStorage();
} | java | {
"resource": ""
} |
q175317 | StructureDataW.getScalarByte | test | public byte getScalarByte(StructureMembers.Member m) {
Array data = getArray(m);
return data.getByte(Index.scalarIndexImmutable);
} | java | {
"resource": ""
} |
q175318 | StructureDataW.getJavaArrayByte | test | public byte[] getJavaArrayByte(StructureMembers.Member m) {
Array data = getArray(m);
return (byte []) data.getStorage();
} | java | {
"resource": ""
} |
q175319 | StructureDataW.getScalarInt | test | public int getScalarInt(StructureMembers.Member m) {
Array data = getArray(m);
return data.getInt(Index.scalarIndexImmutable);
} | java | {
"resource": ""
} |
q175320 | StructureDataW.getJavaArrayInt | test | public int[] getJavaArrayInt(StructureMembers.Member m) {
Array data = getArray(m);
return (int []) data.getStorage();
} | java | {
"resource": ""
} |
q175321 | StructureDataW.getScalarShort | test | public short getScalarShort(StructureMembers.Member m) {
Array data = getArray(m);
return data.getShort(Index.scalarIndexImmutable);
} | java | {
"resource": ""
} |
q175322 | StructureDataW.getJavaArrayShort | test | public short[] getJavaArrayShort(StructureMembers.Member m) {
Array data = getArray(m);
return (short []) data.getStorage();
} | java | {
"resource": ""
} |
q175323 | StructureDataW.getScalarLong | test | public long getScalarLong(StructureMembers.Member m) {
Array data = getArray(m);
return data.getLong(Index.scalarIndexImmutable);
} | java | {
"resource": ""
} |
q175324 | StructureDataW.getJavaArrayLong | test | public long[] getJavaArrayLong(StructureMembers.Member m) {
Array data = getArray(m);
return (long []) data.getStorage();
} | java | {
"resource": ""
} |
q175325 | StructureDataW.getScalarChar | test | public char getScalarChar(StructureMembers.Member m) {
Array data = getArray(m);
return data.getChar(Index.scalarIndexImmutable);
} | java | {
"resource": ""
} |
q175326 | StructureDataW.getJavaArrayChar | test | public char[] getJavaArrayChar(StructureMembers.Member m) {
Array data = getArray(m);
return (char []) data.getStorage();
} | java | {
"resource": ""
} |
q175327 | DIFWriter.doOneDataset | test | public void doOneDataset( InvDataset ds) {
if (debug) System.out.println("doDataset "+ds.getName());
if (isDatasetUseable( ds, messBuffer)) {
String id = StringUtil2.replace(ds.getID(), "/", "-");
String fileOutName = fileDir+"/"+id+".dif.xml";
try {
OutputStream out = new BufferedOutputStream(new FileOutputStream( fileOutName));
// writeOneEntry(ds, System.out, mess);
writeOneEntry(ds, out, messBuffer);
out.close();
messBuffer.append(" OK on Write\n");
} catch (IOException ioe) {
messBuffer.append("DIFWriter failed on write " + ioe.getMessage() + "\n");
log.error("DIFWriter failed on write "+ioe.getMessage(), ioe);
}
}
} | java | {
"resource": ""
} |
q175328 | DIFWriter.isDatasetUseable | test | public boolean isDatasetUseable(InvDataset ds, StringBuilder sbuff) {
boolean ok = true;
sbuff.append("Dataset " + ds.getName() + " id = " + ds.getID() + ": ");
if (!ds.isHarvest()) {
ok = false;
sbuff.append("Dataset " + ds.getName() + " id = " + ds.getID() + " has harvest = false\n");
}
if (ds.getName() == null) {
ok = false;
sbuff.append(" missing Name field\n");
}
if (ds.getUniqueID() == null) {
ok = false;
sbuff.append(" missing ID field\n");
}
ThreddsMetadata.Variables vs = ds.getVariables("DIF");
if ((vs == null) || (vs.getVariableList().size() == 0))
vs = ds.getVariables("GRIB-1");
if ((vs == null) || (vs.getVariableList().size() == 0))
vs = ds.getVariables("GRIB-2");
if ((vs == null) || (vs.getVariableList().size() == 0)) {
ok = false;
sbuff.append(" missing Variables with DIF or GRIB compatible vocabulary\n");
}
List list = ds.getPublishers();
if ((list == null) || (list.size() == 0)) {
ok = false;
sbuff.append(" must have publisher element that defines the data center\n");
}
String summary = ds.getDocumentation("summary");
if (summary == null) {
ok = false;
sbuff.append(" must have documentation element of type summary\n");
}
sbuff.append(" useable= "+ok+"\n");
return ok;
} | java | {
"resource": ""
} |
q175329 | DatasetBuilder.copyDataset | test | public Dataset copyDataset(DatasetNode parent) {
return new Dataset(parent, name, flds, accessBuilders, datasetBuilders);
} | java | {
"resource": ""
} |
q175330 | DatasetBuilder.transferMetadata | test | public void transferMetadata( DatasetNode from, boolean parentsAlso) {
if (parentsAlso) {
ThreddsMetadata inherit = getInheritableMetadata(); // make sure exists
inheritMetadata(from, inherit.getFlds());
}
// local metadata
for (Map.Entry<String, Object> entry : from.getFldIterator()) {
if (parentsAlso && entry.getKey().equals(Dataset.ThreddsMetadataInheritable)) continue; // already did this
if (Dataset.listFlds.contains(entry.getKey()))
addToNewList(flds, entry.getKey(), entry.getValue());
else
flds.put(entry.getKey(), entry.getValue());
}
// tmi must be mutable, transfer if not
ThreddsMetadata tmiOld = (ThreddsMetadata) get(Dataset.ThreddsMetadataInheritable);
if (tmiOld != null && tmiOld.isImmutable()) {
ThreddsMetadata tmiNew = new ThreddsMetadata(tmiOld);
flds.put(Dataset.ThreddsMetadataInheritable, tmiNew);
}
} | java | {
"resource": ""
} |
q175331 | DatasetBuilder.getInheritableMetadata | test | public ThreddsMetadata getInheritableMetadata() {
ThreddsMetadata tmi = (ThreddsMetadata) get(Dataset.ThreddsMetadataInheritable);
if (tmi == null) {
tmi = new ThreddsMetadata();
put(Dataset.ThreddsMetadataInheritable, tmi);
}
return tmi;
} | java | {
"resource": ""
} |
q175332 | GridVariable.addProduct | test | void addProduct(GridRecord record) {
records.add(record);
if (firstRecord == null) {
firstRecord = record;
}
} | java | {
"resource": ""
} |
q175333 | GridVariable.showMissing | test | public void showMissing(Formatter f) {
//System.out.println(" " +name+" ntimes (across)= "+ ntimes+" nlevs (down)= "+ nlevels+":");
int count = 0, total = 0;
f.format(" %s%n", name);
for (int j = 0; j < nlevels; j++) {
f.format(" ");
for (int i = 0; i < ntimes; i++) {
boolean missing = recordTracker[i * nlevels + j] == null;
f.format("%s", missing ? "-" : "X");
if (missing) count++;
total++;
}
f.format("%n");
}
f.format(" MISSING= %d / %d for %s%n",count,total, name);
} | java | {
"resource": ""
} |
q175334 | GridVariable.showMissingSummary | test | public int showMissingSummary(Formatter f) {
int count = 0;
int total = recordTracker.length;
for (int i = 0; i < total; i++) {
if (recordTracker[i] == null)
count++;
}
f.format(" MISSING= %d / %d for %s%n", count, total, name);
return count;
} | java | {
"resource": ""
} |
q175335 | GridVariable.findRecord | test | public GridRecord findRecord(int ens, int time, int level) {
if (hasEnsemble()) {
return recordTracker[ens * (ntimes * nlevels) + (time * nlevels) + level];
} else {
return recordTracker[time * nlevels + level];
}
} | java | {
"resource": ""
} |
q175336 | GridVariable.dump | test | public String dump() {
DateFormatter formatter = new DateFormatter();
Formatter sbuff = new Formatter();
sbuff.format("%s %d %n", name, records.size());
for (GridRecord record : records) {
sbuff.format(" level = %d %f", record.getLevelType1(), record.getLevel1());
if (null != record.getValidTime())
sbuff.format(" time = %s", formatter.toDateTimeString(record.getValidTime()));
sbuff.format("%n");
}
return sbuff.toString();
} | java | {
"resource": ""
} |
q175337 | GridVariable.makeLongName | test | protected String makeLongName() {
Formatter f = new Formatter();
GridParameter param = lookup.getParameter(firstRecord);
if (param == null) return null;
f.format("%s", param.getDescription());
String levelName = makeLevelName(firstRecord, lookup);
if (levelName.length() != 0)
f.format(" @ %s", levelName);
return f.toString();
} | java | {
"resource": ""
} |
q175338 | CoverageCoordAxis1D.subsetByIntervals | test | public Optional<CoverageCoordAxis> subsetByIntervals(List<MAMath.MinMax> lonIntvs, int stride) {
if (axisType != AxisType.Lon)
return Optional.empty("subsetByIntervals only for longitude");
if (!isRegular())
return Optional.empty("subsetByIntervals only for regular longitude");
CoordAxisHelper helper = new CoordAxisHelper(this);
double start = Double.NaN;
boolean first = true;
List<RangeIterator> ranges = new ArrayList<>();
for (MAMath.MinMax lonIntv : lonIntvs) {
if (first) start = lonIntv.min;
first = false;
Optional<RangeIterator> opt = helper.makeRange(lonIntv.min, lonIntv.max, stride);
if (!opt.isPresent())
return Optional.empty(opt.getErrorMessage());
ranges.add(opt.get());
}
try {
RangeComposite compositeRange = new RangeComposite(AxisType.Lon.toString(), ranges);
int npts = compositeRange.length();
double end = start + npts * resolution;
CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(this); // copy
builder.subset(npts, start, end, resolution, null);
builder.setRange(null);
builder.setCompositeRange(compositeRange);
return Optional.of(new CoverageCoordAxis1D(builder));
} catch (InvalidRangeException e) {
return Optional.empty(e.getMessage());
}
} | java | {
"resource": ""
} |
q175339 | NCheader.memequal | test | static boolean
memequal(byte[] b1, byte[] b2, int len)
{
if(b1 == b2) return true;
if(b1 == null || b2 == null) return false;
if(b1.length < len || b2.length < len) return false;
for(int i = 0; i < len; i++) {
if(b1[i] != b2[i]) return false;
}
return true;
} | java | {
"resource": ""
} |
q175340 | AbstractDSP.parseDMR | test | protected DapDataset
parseDMR(String document)
throws DapException
{
// Parse the dmr
Dap4Parser parser;
//if(USEDOM)
parser = new DOM4Parser(null);
//else
// parser = new DOM4Parser(new DefaultDMRFactory());
if(PARSEDEBUG)
parser.setDebugLevel(1);
try {
if(!parser.parse(document))
throw new DapException("DMR Parse failed");
} catch (SAXException se) {
throw new DapException(se);
}
if(parser.getErrorResponse() != null)
throw new DapException("Error Response Document not supported");
DapDataset result = parser.getDMR();
processAttributes(result);
return result;
} | java | {
"resource": ""
} |
q175341 | AbstractDSP.processAttributes | test | protected void
processAttributes(DapDataset dataset)
throws DapException
{
List<DapNode> nodes = dataset.getNodeList();
for(DapNode node : nodes) {
switch (node.getSort()) {
case GROUP:
case DATASET:
case VARIABLE:
Map<String, DapAttribute> attrs = node.getAttributes();
if(attrs.size() > 0) {
List<DapAttribute> suppressed = new ArrayList<>();
for(DapAttribute dattr : attrs.values()) {
if(suppress(dattr.getShortName()))
suppressed.add(dattr);
}
for(DapAttribute dattr : suppressed) {
node.removeAttribute(dattr);
}
}
break;
default:
break; /*ignore*/
}
}
// Try to extract the byte order
getEndianAttribute(dataset);
} | java | {
"resource": ""
} |
q175342 | CoordinatePartitionUnionizer.addCoords | test | public void addCoords(List<Coordinate> coords, PartitionCollectionMutable.Partition part) {
Coordinate runtime = null;
for (Coordinate coord : coords) {
switch (coord.getType()) {
case runtime:
CoordinateRuntime rtime = (CoordinateRuntime) coord;
if (runtimeBuilder == null) runtimeBuilder = new CoordinateRuntime.Builder2(rtime.getTimeUnits());
runtimeBuilder.addAll(coord);
runtime = coord;
if (debugPartitionErrors && !duplicateRuntimeMessage && part != null)
testDuplicateRuntime(rtime, part);
break;
case time:
CoordinateTime time = (CoordinateTime) coord;
if (timeBuilder == null) timeBuilder = new CoordinateTime.Builder2(coord.getCode(), time.getTimeUnit(), time.getRefDate());
timeBuilder.addAll(coord);
break;
case timeIntv:
CoordinateTimeIntv timeIntv = (CoordinateTimeIntv) coord;
if (timeIntvBuilder == null) timeIntvBuilder = new CoordinateTimeIntv.Builder2(null, coord.getCode(), timeIntv.getTimeUnit(), timeIntv.getRefDate());
timeIntvBuilder.addAll(intervalFilter((CoordinateTimeIntv)coord));
break;
case time2D:
CoordinateTime2D time2D = (CoordinateTime2D) coord;
if (time2DBuilder == null) time2DBuilder = new CoordinateTime2DUnionizer(time2D.isTimeInterval(), time2D.getTimeUnit(), coord.getCode(), false, logger);
time2DBuilder.addAll(time2D);
// debug
CoordinateRuntime runtimeFrom2D = time2D.getRuntimeCoordinate();
if (!runtimeFrom2D.equals(runtime))
logger.warn("HEY CoordinateUnionizer runtimes not equal");
break;
case ens:
if (ensBuilder == null) ensBuilder = new CoordinateEns.Builder2(coord.getCode());
ensBuilder.addAll(coord);
break;
case vert:
CoordinateVert vertCoord = (CoordinateVert) coord;
if (vertBuilder == null) vertBuilder = new CoordinateVert.Builder2(coord.getCode(), vertCoord.getVertUnit());
vertBuilder.addAll(coord);
break;
}
}
} | java | {
"resource": ""
} |
q175343 | GdsHorizCoordSys.setGaussianLats | test | public void setGaussianLats(int nparallels, float la1, float la2) {
log.debug ("la1 {}, la2 {}", la1, la2);
if (this.gaussLats != null) throw new RuntimeException("Cant modify GdsHorizCoordSys");
int nlats = (2 * nparallels);
GaussianLatitudes gaussLats = GaussianLatitudes.factory(nlats);
int bestStartIndex = 0, bestEndIndex = 0;
double bestStartDiff = Double.MAX_VALUE;
double bestEndDiff = Double.MAX_VALUE;
for (int i = 0; i < nlats; i++) {
double diff = Math.abs(gaussLats.latd[i] - la1);
if (diff < bestStartDiff) {
bestStartDiff = diff;
bestStartIndex = i;
}
diff = Math.abs(gaussLats.latd[i] - la2);
if (diff < bestEndDiff) {
bestEndDiff = diff;
bestEndIndex = i;
}
}
log.debug ("first pass: bestStartIndex {}, bestEndIndex {}", bestStartIndex, bestEndIndex);
if (Math.abs(bestEndIndex - bestStartIndex) + 1 != nyRaw) {
log.warn("GRIB gaussian lats: NP != NY, use NY"); // see email from Toussaint@dkrz.de datafil:
nlats = nyRaw;
gaussLats = GaussianLatitudes.factory(nlats);
bestStartIndex = 0;
bestEndIndex = nyRaw - 1;
}
boolean goesUp = bestEndIndex > bestStartIndex;
log.debug ("bestStartIndex {}, bestEndIndex {}, goesUp {}", bestStartIndex, bestEndIndex, goesUp);
// create the data
int useIndex = bestStartIndex;
float[] data = new float[nyRaw];
float[] gaussw = new float[nyRaw];
for (int i = 0; i < nyRaw; i++) {
data[i] = (float) gaussLats.latd[useIndex];
gaussw[i] = (float) gaussLats.gaussw[useIndex];
log.trace ("i {}, useIndex {}, data {}, gaussw {}", i, useIndex, data[i], gaussw[i]);
if (goesUp) {
useIndex++;
} else {
useIndex--;
}
}
this.gaussLats = Array.factory(DataType.FLOAT, new int[]{nyRaw}, data);
this.gaussw = Array.factory(DataType.FLOAT, new int[]{nyRaw}, gaussw);
} | java | {
"resource": ""
} |
q175344 | ParsedSectionSpec.parseVariableSelector | test | private static ParsedSectionSpec parseVariableSelector(Object parent, String selector) throws InvalidRangeException {
String varNameEsc, indexSelect = null;
int pos1 = EscapeStrings.indexOf(selector, '(');
if (pos1 < 0) { // no index
varNameEsc = selector;
} else {
varNameEsc = selector.substring(0, pos1);
int pos2 = selector.indexOf(')', pos1+1);
indexSelect = selector.substring(pos1, pos2);
}
if (debugSelector)
System.out.println(" parseVariableSection <" + selector + "> = <" + varNameEsc + ">, <" + indexSelect + ">");
Variable v = null;
if (parent instanceof NetcdfFile) { // then varNameEsc = varFullNameEsc (i.e. includes groups)
NetcdfFile ncfile = (NetcdfFile) parent;
v = ncfile.findVariable(varNameEsc);
} else if (parent instanceof Structure) { // then varNameEsc = memberNameEsc (i.e. includes groups)
Structure s = (Structure) parent;
v = s.findVariable( NetcdfFile.makeNameUnescaped(varNameEsc) ); // s.findVariable wants unescaped version
}
if (v == null)
throw new IllegalArgumentException(" cant find variable: " + varNameEsc + " in selector=" + selector);
if (v.getDataType() == DataType.SEQUENCE)
indexSelect = null; // ignore whatever was sent
// get the selected Ranges, or all, and add to the list
Section section;
if (indexSelect != null) {
section = new Section(indexSelect);
section = Section.fill(section, v.getShape()); // Check section has no nulls, set from shape array.
} else {
section = v.getShapeAsSection(); // all
}
return new ParsedSectionSpec(v, section);
} | java | {
"resource": ""
} |
q175345 | ParsedSectionSpec.makeSectionSpecString | test | public static String makeSectionSpecString(Variable v, List<Range> ranges) throws InvalidRangeException {
StringBuilder sb = new StringBuilder();
makeSpec(sb, v, ranges);
return sb.toString();
} | java | {
"resource": ""
} |
q175346 | GeoGridCoordinate2D.box9 | test | private boolean box9(double wantLat, double wantLon, int[] rectIndex) {
int row = rectIndex[0];
int minrow = Math.max(row-1, 0);
int maxrow = Math.min(row+1, nrows);
int col = rectIndex[1];
int mincol= Math.max(col-1, 0);
int maxcol = Math.min(col+1, ncols);
if (debug) System.out.printf("%n box9:");
for (int i=minrow; i<=maxrow; i++)
for (int j=mincol; j<=maxcol; j++) {
rectIndex[0] = i;
rectIndex[1] = j;
if (contains(wantLat, wantLon, rectIndex)) return true;
}
return false;
} | java | {
"resource": ""
} |
q175347 | HTTPMethod.close | test | public synchronized void
close()
{
if(closed)
return; // recursive calls ok
closed = true; // mark as closed to prevent recursive calls
if(methodstream != null) {
try {
this.methodstream.close(); // May recursr
} catch (IOException ioe) {/*failure is ok*/}
this.methodstream = null;
}
// Force release underlying connection back to the connection manager
if(this.lastresponse != null) {
if(false) {
try {
try {
// Attempt to keep connection alive by consuming its remaining content
EntityUtils.consume(this.lastresponse.getEntity());
} finally {
HttpClientUtils.closeQuietly(this.lastresponse); // Paranoia
}
} catch (IOException ignore) {/*ignore*/}
} else
HttpClientUtils.closeQuietly(this.lastresponse);
this.lastresponse = null;
}
if(session != null) {
session.removeMethod(this);
if(localsession) {
session.close();
session = null;
}
}
this.lastrequest = null;
} | java | {
"resource": ""
} |
q175348 | HTTPMethod.execute | test | public int execute()
throws HTTPException
{
HttpResponse res = executeRaw();
if(res != null)
return res.getStatusLine().getStatusCode();
else
throw new HTTPException("HTTPMethod.execute: null response");
} | java | {
"resource": ""
} |
q175349 | CFpointObs.identifyEncodingStation | test | protected boolean identifyEncodingStation(NetcdfDataset ds, EncodingInfo info, CF.FeatureType ftype, Formatter errlog) {
// find the obs dimension
Dimension obsDim = null;
if (info.time.getRank() > 0)
obsDim = info.time.getDimension(info.time.getRank() - 1); // may be time(time) or time(stn, obs)
else if (info.time.getParentStructure() != null) {
Structure parent = info.time.getParentStructure(); // if time axis is a structure member, try pulling dimension out of parent structure
obsDim = parent.getDimension(parent.getRank() - 1);
}
if (obsDim == null) {
errlog.format("CFpointObs: must have a non-scalar Time coordinate%n");
return false;
}
// find the station dimension
if (info.lat.getRank() == 0) {// scalar means single
info.set(Encoding.single, null, obsDim);
return true;
}
Dimension stnDim = info.lat.getDimension(0);
if (obsDim == stnDim) {
info.set(Encoding.flat, null, obsDim); // not used ?
return true;
}
// the raggeds
if (identifyRaggeds(ds, info, stnDim, obsDim, errlog))
return true;
// heres whats left
if (info.lat.getRank() == 1) {
//Encoding e = (info.time.getParentStructure() != null) ? Encoding.multiStructure : Encoding.multidim;
info.set(Encoding.multidim, stnDim, obsDim);
return true;
}
errlog.format("CFpointObs: %s Must have Lat/Lon coordinates of rank 0 or 1%n", ftype);
return false;
} | java | {
"resource": ""
} |
q175350 | CFpointObs.matchAxisTypeAndDimension | test | protected String matchAxisTypeAndDimension(NetcdfDataset ds, AxisType type, final Dimension outer) {
Variable var = CoordSysEvaluator.findCoordByType(ds, type, new CoordSysEvaluator.Predicate() {
public boolean match(CoordinateAxis axis) {
if ((outer == null) && (axis.getRank() == 0))
return true;
if ((outer != null) && (axis.getRank() == 1) && (outer.equals(axis.getDimension(0))))
return true;
// if axis is structure member, try pulling dimension out of parent structure
if (axis.getParentStructure() != null) {
Structure parent = axis.getParentStructure();
if ((outer != null) && (parent.getRank() == 1) && (outer.equals(parent.getDimension(0))))
return true;
}
return false;
}
});
if (var == null) return null;
return var.getFullName();
} | java | {
"resource": ""
} |
q175351 | CBZip2InputStream.setStream | test | public void setStream(InputStream zStream) {
last=0;
origPtr=0;
blockSize100k=0;
blockRandomised=false;
bsBuff=0;
bsLive=0;
mCrc = new CRC();
nInUse=0;
bsStream=null;
streamEnd = false;
currentChar = -1;
currentState = START_BLOCK_STATE;
storedBlockCRC= storedCombinedCRC=0;
computedBlockCRC= computedCombinedCRC=0;
i2= count= chPrev= ch2=0;
i= tPos=0;
rNToGo = 0;
rTPos = 0;
j2=0;
z=0;
bsSetStream(zStream);
initialize();
if (!streamEnd) { // Handle if initialize does not detect valid bz2 stream
initBlock();
setupBlock();
}
} | java | {
"resource": ""
} |
q175352 | CBZip2InputStream.read | test | public int read() {
if (streamEnd) {
return -1;
} else {
int retChar = currentChar;
switch (currentState) {
case START_BLOCK_STATE:
break;
case RAND_PART_A_STATE:
break;
case RAND_PART_B_STATE:
setupRandPartB();
break;
case RAND_PART_C_STATE:
setupRandPartC();
break;
case NO_RAND_PART_A_STATE:
break;
case NO_RAND_PART_B_STATE:
setupNoRandPartB();
break;
case NO_RAND_PART_C_STATE:
setupNoRandPartC();
break;
default:
break;
}
return retChar;
}
} | java | {
"resource": ""
} |
q175353 | ProgressMonitor.start | test | public void start(java.awt.Component top, String taskName, int progressMaxCount) {
// create ProgressMonitor
pm = new javax.swing.ProgressMonitor(top, taskName, "", 0, progressMaxCount);
pm.setMillisToDecideToPopup(millisToDecideToPopup);
pm.setMillisToPopup(millisToPopup);
// do task in a seperate, non-event, thread
taskThread = new Thread(task);
taskThread.start();
// create timer, whose events happen on the awt event Thread
ActionListener watcher = new ActionListener() {
public void actionPerformed(ActionEvent evt) {
secs++;
if (pm.isCanceled()) {
task.cancel();
} else {
// indicate progress
String note = task.getNote();
pm.setNote(note == null ? secs + " secs" : note);
int progress = task.getProgress();
pm.setProgress(progress <= 0 ? secs : progress);
}
// need to make sure task acknowledges the cancel; so dont shut down
// until the task is done
if (task.isDone()) {
timer.stop();
pm.close();
// Toolkit.getDefaultToolkit().beep();
if (task.isError()) {
javax.swing.JOptionPane.showMessageDialog(null, task.getErrorMessage());
}
if (task.isSuccess())
fireEvent(new ActionEvent(this, 0, "success"));
else if (task.isError())
fireEvent(new ActionEvent(this, 0, "error"));
else if (task.isCancel())
fireEvent(new ActionEvent(this, 0, "cancel"));
else
fireEvent(new ActionEvent(this, 0, "done"));
}
}
};
timer = new javax.swing.Timer(1000, watcher); // every second
timer.start();
} | java | {
"resource": ""
} |
q175354 | HTTPUtil.parseToURI | test | static public URI
parseToURI(final String u)
throws URISyntaxException
{
StringBuilder buf = new StringBuilder();
int i = 0;
while(i < u.length()) {
char c = u.charAt(i);
if(c == '\\') {
if(i + 1 == u.length())
throw new URISyntaxException(u, "Trailing '\' at end of url");
buf.append("%5c");
i++;
c = u.charAt(i);
buf.append(String.format("%%%02x", (int) c));
} else
buf.append(c);
i++;
}
return new URI(buf.toString());
} | java | {
"resource": ""
} |
q175355 | HTTPUtil.uriExclude | test | static URI
uriExclude(final URI uri, URIPart... excludes)
{
URIBuilder urib = new URIBuilder();
EnumSet<URIPart> set = EnumSet.of(excludes[0], excludes);
for(URIPart part : URIPart.values()) {
if(set.contains(part)) continue;
switch (part) {
case SCHEME:
urib.setScheme(uri.getScheme());
break;
case USERINFO:
urib.setUserInfo(uri.getUserInfo());
break;
case HOST:
urib.setHost(uri.getHost());
break;
case PORT:
urib.setPort(uri.getPort());
break;
case PATH:
urib.setPath(uri.getPath());
break;
case QUERY:
urib.setCustomQuery(uri.getQuery());
break;
case FRAGMENT:
urib.setFragment(uri.getFragment());
break;
}
}
try {
return urib.build();
} catch (URISyntaxException e) {
throw new IllegalArgumentException(e.getMessage());
}
} | java | {
"resource": ""
} |
q175356 | HTTPUtil.nullify | test | static public String nullify(String s)
{
if(s != null && s.length() == 0) s = null;
return s;
} | java | {
"resource": ""
} |
q175357 | HTTPUtil.canonjoin | test | static public String
canonjoin(String prefix, String suffix)
{
if(prefix == null) prefix = "";
if(suffix == null) suffix = "";
prefix = HTTPUtil.canonicalpath(prefix);
suffix = HTTPUtil.canonicalpath(suffix);
StringBuilder result = new StringBuilder();
result.append(prefix);
int prelen = prefix.length();
if(prelen > 0 && result.charAt(prelen - 1) != '/') {
result.append('/');
prelen++;
}
if(suffix.length() > 0 && suffix.charAt(0) == '/')
result.append(suffix.substring(1));
else
result.append(suffix);
int len = result.length();
if(len > 0 && result.charAt(len - 1) == '/') {
result.deleteCharAt(len - 1);
len--;
}
return result.toString();
} | java | {
"resource": ""
} |
q175358 | LastModifiedLimitFilter.accept | test | public boolean accept( CrawlableDataset dataset)
{
Date lastModDate = dataset.lastModified();
if ( lastModDate != null )
{
long now = System.currentTimeMillis();
if ( now - lastModDate.getTime() > lastModifiedLimitInMillis )
return true;
}
return false;
} | java | {
"resource": ""
} |
q175359 | GribCollectionMutable.copyInfo | test | void copyInfo(GribCollectionMutable from) {
this.center = from.center;
this.subcenter = from.subcenter;
this.master = from.master;
this.local = from.local;
this.genProcessType = from.genProcessType;
this.genProcessId = from.genProcessId;
this.backProcessId = from.backProcessId;
} | java | {
"resource": ""
} |
q175360 | GribCollectionMutable.getFilenames | test | public List<String> getFilenames() {
List<String> result = new ArrayList<>();
for (MFile file : fileMap.values())
result.add(file.getPath());
Collections.sort(result);
return result;
} | java | {
"resource": ""
} |
q175361 | GribCollectionMutable.setIndexRaf | test | void setIndexRaf(RandomAccessFile indexRaf) {
this.indexRaf = indexRaf;
if (indexRaf != null) {
this.indexFilename = indexRaf.getLocation();
}
} | java | {
"resource": ""
} |
q175362 | GribCollectionMutable.getIndexFilepathInCache | test | private String getIndexFilepathInCache() {
File indexFile = GribCdmIndex.makeIndexFile(name, directory);
return GribIndexCache.getFileOrCache(indexFile.getPath()).getPath();
} | java | {
"resource": ""
} |
q175363 | GribCollectionMutable.close | test | public void close() throws java.io.IOException {
if (indexRaf != null) {
indexRaf.close();
indexRaf = null;
}
} | java | {
"resource": ""
} |
q175364 | BitCounterCompressed.ncounters | test | public int ncounters() {
if (nested == null)
return 1;
else {
int ncounters = 0;
for (BitCounterCompressed[] counters : nested) {
if (counters == null) continue;
for (BitCounterCompressed counter : counters)
if (counter != null) ncounters += counter.ncounters();
}
return ncounters;
}
} | java | {
"resource": ""
} |
q175365 | NetcdfFileWriteable.addGlobalAttribute | test | public Attribute addGlobalAttribute(String name, String value) {
return addGlobalAttribute( new Attribute(name, value));
} | java | {
"resource": ""
} |
q175366 | NetcdfFileWriteable.addGlobalAttribute | test | public Attribute addGlobalAttribute(String name, Array values) {
return addGlobalAttribute( new Attribute(name, values));
} | java | {
"resource": ""
} |
q175367 | NetcdfFileWriteable.deleteGlobalAttribute | test | public Attribute deleteGlobalAttribute(String attName) {
if (!defineMode) throw new UnsupportedOperationException("not in define mode");
Attribute att = findGlobalAttribute(attName);
if (null == att) return null;
rootGroup.remove(att);
return att;
} | java | {
"resource": ""
} |
q175368 | NetcdfFileWriteable.renameGlobalAttribute | test | public Attribute renameGlobalAttribute(String oldName, String newName) {
if (!defineMode) throw new UnsupportedOperationException("not in define mode");
Attribute att = findGlobalAttribute(oldName);
if (null == att) return null;
rootGroup.remove(att);
att = new Attribute( newName, att.getValues());
rootGroup.addAttribute( att);
return att;
} | java | {
"resource": ""
} |
q175369 | NetcdfFileWriteable.addVariableAttribute | test | public void addVariableAttribute(String varName, String attName, String value) {
addVariableAttribute(varName, new Attribute(attName, value));
} | java | {
"resource": ""
} |
q175370 | NetcdfFileWriteable.addVariableAttribute | test | public void addVariableAttribute(String varName, String attName, Array value) {
Attribute att = new Attribute(attName, value);
addVariableAttribute(varName, att);
} | java | {
"resource": ""
} |
q175371 | NetcdfFileWriteable.deleteVariableAttribute | test | public Attribute deleteVariableAttribute(String varName, String attName) {
if (!defineMode) throw new UnsupportedOperationException("not in define mode");
Variable v = findVariable(varName);
if (v == null) return null;
Attribute att = v.findAttribute(attName);
if (null == att) return null;
v.remove(att);
return att;
} | java | {
"resource": ""
} |
q175372 | NetcdfFileWriteable.renameVariableAttribute | test | public Attribute renameVariableAttribute(String varName, String attName, String newName) {
if (!defineMode) throw new UnsupportedOperationException("not in define mode");
Variable v = findVariable(varName);
if (v == null) return null;
Attribute att = v.findAttribute(attName);
if (null == att) return null;
v.remove(att);
att = new Attribute( newName, att.getValues());
v.addAttribute( att);
return att;
} | java | {
"resource": ""
} |
q175373 | GempakSurfaceFileReader.makeFileSubType | test | protected void makeFileSubType() {
// determine file type
Key key = findKey(GempakStation.SLAT);
if (key == null)
throw new IllegalStateException("File does not have key="+GempakStation.SLAT);
String latType = key.type;
Key dateKey = findKey(DATE);
if (dateKey != null && !dateKey.type.equals(latType)) {
if (latType.equals(ROW)) {
subType = CLIMATE;
} else {
subType = STANDARD;
}
} else {
subType = SHIP;
}
} | java | {
"resource": ""
} |
q175374 | WFSGetFeatureWriter.writeHeadersAndBB | test | private void writeHeadersAndBB() {
fileOutput += "<wfs:FeatureCollection xsi:schemaLocation=" + WFSXMLHelper.encQuotes("http://www.opengis.net/wfs/2.0 http://schemas.opengis.net/wfs/2.0/wfs.xsd " + namespace + " " + server
+ "?request=DescribeFeatureType" + WFSXMLHelper.AMPERSAND + "service=wfs" + WFSXMLHelper.AMPERSAND + "version=2.0.0" + WFSXMLHelper.AMPERSAND + "typename="
+ WFSController.TDSNAMESPACE + "%3A" + ftName)
+ " xmlns:xsi=" + WFSXMLHelper.encQuotes("http://www.w3.org/2001/XMLSchema-instance")
+ " xmlns:xlink=" + WFSXMLHelper.encQuotes("http://www.w3.org/1999/xlink")
+ " xmlns:gml=" + WFSXMLHelper.encQuotes("http://opengis.net/gml/3.2")
+ " xmlns:fes=" + WFSXMLHelper.encQuotes("http://www.opengis.net/fes/2.0")
+ " xmlns:ogc=" + WFSXMLHelper.encQuotes("http://www.opengis.net/ogc")
+ " xmlns:wfs=" + WFSXMLHelper.encQuotes("http://opengis.net/wfs/2.0")
+ " xmlns:" + WFSController.TDSNAMESPACE +"=" + WFSXMLHelper.encQuotes(namespace)
+ " xmlns=" + WFSXMLHelper.encQuotes("http://www.opengis.net/wfs/2.0")
+ " version=\"2.0.0\" numberMatched=" + WFSXMLHelper.encQuotes(String.valueOf(geometries.size())) + " numberReturned="
+ WFSXMLHelper.encQuotes(String.valueOf(geometries.size())) + ">";
double[] boundLower;
double[] boundUpper;
if(geometries.isEmpty()) {
boundLower = new double[2]; boundUpper = new double[2];
boundLower[0] = -180; boundLower[1] = -90;
boundUpper[0] = 180; boundUpper[1] = 90;
}
else {
boundLower = geometries.get(0).getBBLower();
boundUpper = geometries.get(0).getBBUpper();
}
// WFS Bounding Box
for(SimpleGeometry item: geometries) {
// Find the overall BB
// Test Lower
double[] low = item.getBBLower();
if(boundLower[0] > low[0]) boundLower[0] = low[0];
if(boundLower[1] > low[1]) boundLower[1] = low[1];
// Test Upper
double[] upper = item.getBBUpper();
if(boundUpper[0] < upper[0]) boundUpper[0] = upper[0];
if(boundUpper[1] < upper[1]) boundUpper[1] = upper[1];
// Add some padding
boundLower[0] -= 10; boundLower[1] -= 10;
boundUpper[0] += 10; boundUpper[1] += 10;
}
fileOutput += "<wfs:boundedBy>"
+ "<wfs:Envelope srsName=" + "\"urn:ogc:def:crs:EPSG::4326\"" + ">"
+ "<wfs:lowerCorner>" + boundLower[0] + " " + boundLower[1] + "</wfs:lowerCorner>"
+ "<wfs:upperCorner>" + boundUpper[0] + " " + boundUpper[1] + "</wfs:upperCorner>"
+ "</wfs:Envelope>"
+ "</wfs:boundedBy>";
} | java | {
"resource": ""
} |
q175375 | WFSGetFeatureWriter.writeMembers | test | public void writeMembers() {
int index = 1;
GMLFeatureWriter writer = new GMLFeatureWriter();
for(SimpleGeometry geometryItem: geometries) {
// Find bounding box information
double[] lowerCorner = geometryItem.getBBLower();
double[] upperCorner = geometryItem.getBBUpper();
fileOutput
+= "<wfs:member>"
// Write Geometry Information
+ "<" + WFSController.TDSNAMESPACE + ":" + ftName + " gml:id=\"" + ftName + "." + index + "\">"
// GML Bounding Box
+ "<gml:boundedBy>"
+ "<gml:Envelope srsName=" + "\"urn:ogc:def:crs:EPSG::4326\"" + ">"
+ "<gml:lowerCorner>" + lowerCorner[0] + " " + lowerCorner[1] + "</gml:lowerCorner>"
+ "<gml:upperCorner>" + upperCorner[0] + " " + upperCorner[1] + "</gml:upperCorner>"
+ "</gml:Envelope>"
+ "</gml:boundedBy>"
+ "<" + WFSController.TDSNAMESPACE + ":geometryInformation>";
//write GML features
fileOutput += writer.writeFeature(geometryItem);
// Cap off headers
fileOutput
+="</" + WFSController.TDSNAMESPACE + ":geometryInformation>"
+ "</" + WFSController.TDSNAMESPACE + ":" + ftName +">"
+ "</wfs:member>";
index++;
}
} | java | {
"resource": ""
} |
q175376 | StationObsDatasetInfo.writeStationObsDatasetXML | test | public String writeStationObsDatasetXML() {
XMLOutputter fmt = new XMLOutputter(Format.getPrettyFormat());
return fmt.outputString(makeStationObsDatasetDocument());
} | java | {
"resource": ""
} |
q175377 | StationObsDatasetInfo.writeStationCollectionXML | test | public String writeStationCollectionXML() throws IOException {
XMLOutputter fmt = new XMLOutputter(Format.getPrettyFormat());
return fmt.outputString(makeStationCollectionDocument());
} | java | {
"resource": ""
} |
q175378 | ChunkWriter.writeDSR | test | public void
writeDSR(String dsr)
throws IOException
{
if(state != State.INITIAL)
throw new DapException("Attempt to write DSR twice");
if(dsr == null)
throw new DapException("Attempt to write empty DSR");
// Strip off any trailing sequence of CR or LF.
int len = dsr.length();
while(len > 0) {
char c = dsr.charAt(len - 1);
if(c != '\r' && c != '\n') break;
len--;
}
if(dsr.length() == 0)
throw new DapException("Attempt to write empty DSR");
dsr = dsr.substring(0, len) + DapUtil.CRLF;
// Add <?xml...?> prefix
dsr = XMLDOCUMENTHEADER + "\n" + dsr;
// Convert the dsr to UTF-8 and then to byte[]
byte[] dsr8 = DapUtil.extract(DapUtil.UTF8.encode(dsr));
sendDXR(dsr8);
state = State.END;
} | java | {
"resource": ""
} |
q175379 | ChunkWriter.sendDXR | test | void
sendDXR(byte[] dxr8)
throws IOException
{
if(dxr8 == null || dxr8.length == 0)
return; // do nothing
if(mode == RequestMode.DMR || mode == RequestMode.DSR) {
state = State.END;
} else {//mode == DATA
// Prefix with chunk header
int flags = DapUtil.CHUNK_DATA;
if(this.writeorder == ByteOrder.LITTLE_ENDIAN)
flags |= DapUtil.CHUNK_LITTLE_ENDIAN;
chunkheader(dxr8.length, flags, this.header);
// write the header
output.write(DapUtil.extract(this.header));
state = State.DATA;
}
// write the DXR
output.write(dxr8);
output.flush();
} | java | {
"resource": ""
} |
q175380 | ChunkWriter.writeError | test | public void
writeError(int httpcode,
String msg,
String cxt,
String other)
throws IOException
{
dmr8 = null;
ErrorResponse response = new ErrorResponse(httpcode, msg, cxt, other);
String errorbody = response.buildXML();
// Convert the error body into utf8 then to byte[]
byte[] errbody8 = DapUtil.extract(DapUtil.UTF8.encode(errorbody));
if(mode == RequestMode.DMR) {
sendDXR(errbody8);
} else {//mode == DATA
// clear any partial chunk
chunk.clear();
// create an error header
int flags = DapUtil.CHUNK_ERROR | DapUtil.CHUNK_END;
chunkheader(errbody8.length, flags, header);
output.write(DapUtil.extract(header));
output.write(errbody8);
output.flush();
}
state = State.ERROR;
} | java | {
"resource": ""
} |
q175381 | ChunkWriter.close | test | public void close()
throws IOException
{
if(closed)
return;
closed = true;
if(dmr8 != null) {
sendDXR(dmr8);
dmr8 = null;
}
if(mode == RequestMode.DMR)
return; // only DMR should be sent
// If there is no partial chunk to write then
// we are done; else verify we can write and write the last
// chunk; => multiple closes are ok.
if(chunk == null || chunk.position() == 0)
return;
// There is data left to write.
verifystate(); // are we in a state supporting data write?
// Force out the current chunk (might be empty)
// but do not close the underlying output stream
state = State.DATA; // pretend
int flags = DapUtil.CHUNK_END;
writeChunk(flags);
state = State.END;
this.output.flush(); // Do not close
if(this.saveoutput != null) {
// write to true output target
this.saveoutput.write(((ByteArrayOutputStream) this.output).toByteArray());
}
} | java | {
"resource": ""
} |
q175382 | ChunkWriter.flush | test | @Override
public void
flush()
throws IOException
{
if(mode == RequestMode.DMR)
return; // leave to close() to do this
if(dmr8 != null) {
sendDXR(dmr8);
dmr8 = null;
}
} | java | {
"resource": ""
} |
q175383 | UtmProjection.constructCopy | test | @Override
public ProjectionImpl constructCopy() {
ProjectionImpl result = (saveParams == null) ? new UtmProjection(getZone(), isNorth()) : new UtmProjection(saveParams.a, saveParams.f, getZone(), isNorth());
result.setDefaultMapArea(defaultMapArea);
result.setName(name);
return result;
} | java | {
"resource": ""
} |
q175384 | Range.contains | test | public boolean contains(int want) {
if (want < first())
return false;
if (want > last())
return false;
if (stride == 1) return true;
return (want - first) % stride == 0;
} | java | {
"resource": ""
} |
q175385 | Range.element | test | public int element(int i) throws InvalidRangeException {
if (i < 0)
throw new InvalidRangeException("i must be >= 0");
if (i >= length)
throw new InvalidRangeException("i must be < length");
return first + i * stride;
} | java | {
"resource": ""
} |
q175386 | Range.shiftOrigin | test | public Range shiftOrigin(int origin) throws InvalidRangeException {
if (this == VLEN)
return VLEN;
int first = first() - origin;
int last = last() - origin;
return new Range(name, first, last, stride);
} | java | {
"resource": ""
} |
q175387 | N3raf.readData | test | protected Object readData( Layout index, DataType dataType) throws java.io.IOException {
return IospHelper.readDataFill(raf, index, dataType, null, -1);
} | java | {
"resource": ""
} |
q175388 | N3raf.readData | test | protected long readData( Layout index, DataType dataType, WritableByteChannel out) throws java.io.IOException {
long count = 0;
if (dataType.getPrimitiveClassType() == byte.class || dataType == DataType.CHAR) {
while (index.hasNext()) {
Layout.Chunk chunk = index.next();
count += raf.readToByteChannel( out, chunk.getSrcPos(), chunk.getNelems());
}
} else if (dataType.getPrimitiveClassType() == short.class) {
while (index.hasNext()) {
Layout.Chunk chunk = index.next();
count += raf.readToByteChannel( out, chunk.getSrcPos(), 2 * chunk.getNelems());
}
} else if (dataType.getPrimitiveClassType() == int.class || (dataType == DataType.FLOAT)) {
while (index.hasNext()) {
Layout.Chunk chunk = index.next();
count += raf.readToByteChannel( out, chunk.getSrcPos(), 4 * chunk.getNelems());
}
} else if ((dataType == DataType.DOUBLE) || dataType.getPrimitiveClassType() == long.class) {
while (index.hasNext()) {
Layout.Chunk chunk = index.next();
count += raf.readToByteChannel( out, chunk.getSrcPos(), 8 * chunk.getNelems());
}
}
return count;
} | java | {
"resource": ""
} |
q175389 | BooleanPrimitiveVector.subset | test | public PrimitiveVector subset(int start, int stop, int stride) {
BooleanPrimitiveVector n = new BooleanPrimitiveVector(getTemplate());
stride = Math.max(stride, 1);
stop = Math.max(start, stop);
int length = 1 + (stop - start) / stride;
n.setLength(length);
int count = 0;
for (int i = start; i <= stop; i += stride) {
n.setValue(count, vals[i]);
count++;
}
return n;
} | java | {
"resource": ""
} |
q175390 | CatalogTracker.getCatalogs | test | public Iterable<? extends CatalogExt> getCatalogs() {
if (catalogs == null) readCatalogs();
List<CatalogExt> result = new ArrayList<>();
for (CatalogExt ext : catalogs.values())
result.add(ext);
Collections.sort(result, (o1, o2) -> o1.getCatRelLocation().compareTo(o2.getCatRelLocation())); // java 8 lambda, baby
return result;
} | java | {
"resource": ""
} |
q175391 | DatasetTrackerChronicle.cleanupBefore | test | public static void cleanupBefore(String pathname, long trackerNumber) {
for (long tnum = trackerNumber - 1; tnum > 0; tnum--) {
File oldDatabaseFile = new File(pathname + datasetName + "." + tnum);
if (!oldDatabaseFile.exists()) break;
if (oldDatabaseFile.delete()) {
catalogInitLog.info("DatasetTrackerChronicle deleted {} ", oldDatabaseFile.getAbsolutePath());
} else {
catalogInitLog.error("DatasetTrackerChronicle not able to delete {} ", oldDatabaseFile.getAbsolutePath());
}
}
} | java | {
"resource": ""
} |
q175392 | NavigationBlock.setValues | test | public void setValues(float[] values) {
vals = values;
proj = GempakUtil.ST_ITOC(Float.floatToIntBits(vals[1])).trim();
addParam(PROJ, proj);
addParam(GDS_KEY, this.toString());
setParams();
} | java | {
"resource": ""
} |
q175393 | DataBTree.getDataChunkIteratorNoFilter | test | LayoutTiled.DataChunkIterator getDataChunkIteratorNoFilter(Section want, int nChunkDim) throws IOException {
/*
if (if (debugChunkOrder) ) {
DataChunkIteratorNoFilter iter = new DataChunkIteratorNoFilter(null, nChunkDim);
int count = 0;
int last = -1;
while (iter.hasNext()) {
LayoutTiled.DataChunk chunk = iter.next();
System.out.printf("%d : %d%n", count++, tiling.order(chunk.offset));
if (tiling.order(chunk.offset) <= last)
System.out.println("HEY");
last = tiling.order(chunk.offset);
}
}*/
return new DataChunkIteratorNoFilter(want, nChunkDim);
} | java | {
"resource": ""
} |
q175394 | McIDASAreaProjection.makeDoubleArray | test | private double[] makeDoubleArray(int[] ints) {
double[] newArray = new double[ints.length];
for (int i = 0; i < ints.length; i++) {
newArray[i] = ints[i];
}
return newArray;
} | java | {
"resource": ""
} |
q175395 | NcssGridController.getDatasetBoundaries | test | @RequestMapping("**/datasetBoundaries.xml")
public void getDatasetBoundaries(NcssParamsBean params, HttpServletRequest req, HttpServletResponse res)
throws IOException, UnsupportedResponseFormatException {
SupportedFormat format = SupportedOperation.DATASET_BOUNDARIES_REQUEST.getSupportedFormat(params.getAccept());
switch (format) {
case WKT: getDatasetBoundariesWKT(req, res); break;
case JSON: getDatasetBoundariesGeoJSON(req, res); break;
default: throw new IllegalArgumentException(String.format(
"Expected %s or %s, but got %s", SupportedFormat.WKT, SupportedFormat.JSON, format));
}
} | java | {
"resource": ""
} |
q175396 | NcssGridController.checkRequestedVars | test | private void checkRequestedVars(CoverageCollection gcd, NcssGridParamsBean params)
throws VariableNotContainedInDatasetException {
// if var == all --> all variables requested
if (params.getVar().get(0).equalsIgnoreCase("all")) {
params.setVar(getAllGridNames(gcd));
return;
}
// Check vars are contained in the grid
for (String gridName : params.getVar()) {
Coverage grid = gcd.findCoverage(gridName);
if (grid == null)
throw new VariableNotContainedInDatasetException(
"Variable: " + gridName + " is not contained in the requested dataset");
}
} | java | {
"resource": ""
} |
q175397 | DatasetSourceStructure.getStructure | test | public static DatasetSourceStructure getStructure( String name)
{
if ( name == null) return null;
return (DatasetSourceStructure) hash.get( name);
} | java | {
"resource": ""
} |
q175398 | Dap4Controller.getResourcePath | test | @Override
public String
getResourcePath(DapRequest drq, String location)
throws DapException
{
String realpath;
if(TdsRequestedDataset.getDatasetManager() != null) {
realpath = TdsRequestedDataset.getLocationFromRequestPath(location);
} else {
assert TdsRequestedDataset.getDatasetManager() == null;
String prefix = drq.getResourceRoot();
assert (prefix != null);
realpath = DapUtil.canonjoin(prefix, location);
}
if (!TESTING) {
if (!TdsRequestedDataset.resourceControlOk(drq.getRequest(), drq.getResponse(), realpath))
throw new DapException("Not authorized: " + location)
.setCode(DapCodes.SC_FORBIDDEN);
}
File f = new File(realpath);
if (!f.exists() || !f.canRead())
throw new DapException("Not found: " + location)
.setCode(DapCodes.SC_NOT_FOUND);
//ncfile = TdsRequestedDataset.getNetcdfFile(this.request, this.response, path);
return realpath;
} | java | {
"resource": ""
} |
q175399 | GridIndexToNC.makeVerticalDimensions | test | private void makeVerticalDimensions(List<GridVertCoord> vertCoordList, NetcdfFile ncfile, Group group) {
// find biggest vert coord
GridVertCoord gvcs0 = null;
int maxLevels = 0;
for (GridVertCoord gvcs : vertCoordList) {
if (gvcs.getNLevels() > maxLevels) {
gvcs0 = gvcs;
maxLevels = gvcs.getNLevels();
}
}
int seqno = 1;
for (GridVertCoord gvcs : vertCoordList) {
if (gvcs != gvcs0) {
gvcs.setSequence(seqno++);
}
gvcs.addDimensionsToNetcdfFile(ncfile, group);
}
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.