Example usage for java.nio IntBuffer remaining

List of usage examples for java.nio IntBuffer remaining

Introduction

In this page you can find the example usage for java.nio IntBuffer remaining.

Prototype

public final int remaining() 

Source Link

Document

Returns the number of remaining elements in this buffer, that is limit - position .

Usage

From source file:Main.java

private static String formatInts(byte[] data) {
    IntBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer();

    StringBuilder sb = new StringBuilder(bb.capacity() * 3);

    while (bb.remaining() > 0) {
        sb.append(bb.get());//from w  w w .j  a  va 2s  .c o  m
        sb.append(',');
        sb.append('\n');
    }

    return sb.toString();
}

From source file:info.varden.anatychia.Main.java

public static MaterialDataList materialList(SaveData save, ProgressUpdater pu, MaterialData[] filters) {
    Random random = new Random();
    boolean filtersNull = filters == null;
    pu.updated(0, 1);//w w w  .j ava  2 s  . c om
    pu.updated(-3, 1);
    MaterialDataList mdl = new MaterialDataList();
    File saveDir = save.getLocation();
    File[] regionFolders = listRegionContainers(saveDir);
    int depth = Integer.MAX_VALUE;
    File shallowest = null;
    for (File f : regionFolders) {
        String path = f.getAbsolutePath();
        Pattern p = Pattern.compile(Pattern.quote(File.separator));
        Matcher m = p.matcher(path);
        int count = 0;
        while (m.find()) {
            count++;
        }
        if (count < depth) {
            depth = count;
            if (shallowest == null || f.getName().equalsIgnoreCase("region")) {
                shallowest = f;
            }
        }
    }
    pu.updated(-1, 1);
    ArrayList<File> regions = new ArrayList<File>();
    int tfs = 0;
    for (File f : regionFolders) {
        String dimName = f.getParentFile().getName();
        boolean deleted = false;
        if (f.equals(shallowest)) {
            dimName = "DIM0";
        }
        if (!filtersNull) {
            for (MaterialData type : filters) {
                if (type.getType() == MaterialType.DIMENSION && type.getName().equals(dimName)) {
                    System.out.println("Deleting: " + dimName);
                    deleted = recursiveDelete(f);
                }
            }
        }
        if (deleted)
            continue;
        mdl.increment(new MaterialData(MaterialType.DIMENSION, dimName, 1L));
        File[] r = f.listFiles(new FilenameFilter() {

            @Override
            public boolean accept(File dir, String name) {
                return name.endsWith(".mca");
            }

        });
        int max = r.length;
        int cur = 0;
        for (File valid : r) {
            cur++;
            try {
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(valid));
                byte[] offsetHeader = new byte[4096];
                bis.read(offsetHeader, 0, 4096);
                bis.close();
                ByteBuffer bb = ByteBuffer.wrap(offsetHeader);
                IntBuffer ib = bb.asIntBuffer();
                while (ib.remaining() > 0) {
                    if (ib.get() != 0) {
                        tfs++;
                    }
                }
                bb = null;
                ib = null;
            } catch (IOException ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            }
            // tfs += Math.floor(valid.length() / 1000D);
            pu.updated(cur, max);
        }
        regions.addAll(Arrays.asList(r));
    }
    if (regions.size() <= 0) {
        pu.updated(1, 1);
        return mdl;
    }
    pu.updated(-2, 1);
    int fc = 0;
    int fs = 0;
    for (File region : regions) {
        fc++;
        //fs += Math.floor(region.length() / 1000D);
        try {
            RegionFile anvil = new RegionFile(region);
            for (int x = 0; x < 32; x++) {
                for (int z = 0; z < 32; z++) {
                    InputStream is = anvil.getChunkDataInputStream(x, z);
                    if (is == null)
                        continue;
                    NBTInputStream nbti = new NBTInputStream(is, CompressionMode.NONE);
                    CompoundTag root = (CompoundTag) nbti.readTag();
                    String rootName = root.getName();
                    CompoundTag level = (CompoundTag) root.getValue().get("Level");
                    Map<String, Tag> levelTags = level.getValue();
                    ListTag sectionTag = (ListTag) levelTags.get("Sections");
                    ArrayList<Tag> sections = new ArrayList<Tag>(sectionTag.getValue());
                    for (int i = 0; i < sections.size(); i++) {
                        mdl.setSectorsRelative(1);
                        CompoundTag sect = (CompoundTag) sections.get(i);
                        Map<String, Tag> sectTags = sect.getValue();
                        ByteArrayTag blockArray = (ByteArrayTag) sectTags.get("Blocks");
                        byte[] add = new byte[0];
                        boolean hasAdd = false;
                        if (sectTags.containsKey("Add")) {
                            hasAdd = true;
                            ByteArrayTag addArray = (ByteArrayTag) sectTags.get("Add");
                            add = addArray.getValue();
                        }
                        byte[] blocks = blockArray.getValue();
                        for (int j = 0; j < blocks.length; j++) {
                            short id;
                            byte aid = (byte) 0;
                            if (hasAdd) {
                                aid = ChunkFormat.Nibble4(add, j);
                                id = (short) ((blocks[j] & 0xFF) + (aid << 8));
                            } else {
                                id = (short) (blocks[j] & 0xFF);
                            }
                            if (!filtersNull) {
                                for (MaterialData type : filters) {
                                    if (type.getType() == MaterialType.BLOCK
                                            && type.getName().equals(String.valueOf(blocks[j] & 0xFF))
                                            && (type.getRemovalChance() == 1D
                                                    || random.nextDouble() < type.getRemovalChance())) {
                                        blocks[j] = (byte) 0;
                                        if (aid != 0) {
                                            add[j / 2] = (byte) (add[j / 2] & (j % 2 == 0 ? 0xF0 : 0x0F));
                                        }
                                        id = (short) 0;
                                    }
                                }
                            }
                            mdl.increment(new MaterialData(MaterialType.BLOCK, String.valueOf(id), 1L));
                        }
                        if (!filtersNull) {
                            HashMap<String, Tag> rSectTags = new HashMap<String, Tag>();
                            rSectTags.putAll(sectTags);
                            ByteArrayTag bat = new ByteArrayTag("Blocks", blocks);
                            rSectTags.put("Blocks", bat);
                            if (hasAdd) {
                                ByteArrayTag adt = new ByteArrayTag("Add", add);
                                rSectTags.put("Add", adt);
                            }
                            CompoundTag rSect = new CompoundTag(sect.getName(), rSectTags);
                            sections.set(i, rSect);
                        }
                    }
                    ListTag entitiesTag = (ListTag) levelTags.get("Entities");
                    ArrayList<Tag> entities = new ArrayList<Tag>(entitiesTag.getValue());
                    for (int i = entities.size() - 1; i >= 0; i--) {
                        CompoundTag entity = (CompoundTag) entities.get(i);
                        Map<String, Tag> entityTags = entity.getValue();
                        if (entityTags.containsKey("id")) {
                            StringTag idTag = (StringTag) entityTags.get("id");
                            String id = idTag.getValue();
                            boolean removed = false;
                            if (!filtersNull) {
                                for (MaterialData type : filters) {
                                    if (type.getType() == MaterialType.ENTITY
                                            && (type.getName().equals(id) || type.getName().equals(""))
                                            && (type.getRemovalChance() == 1D
                                                    || random.nextDouble() < type.getRemovalChance())) {
                                        if (type.fulfillsRequirements(entity)) {
                                            entities.remove(i);
                                            removed = true;
                                        }
                                    }
                                }
                            }
                            if (!removed) {
                                mdl.increment(new MaterialData(MaterialType.ENTITY, id, 1L));
                            }
                        }
                    }
                    nbti.close();
                    is.close();
                    if (!filtersNull) {
                        HashMap<String, Tag> rLevelTags = new HashMap<String, Tag>();
                        rLevelTags.putAll(levelTags);
                        ListTag rSectionTag = new ListTag("Sections", CompoundTag.class, sections);
                        rLevelTags.put("Sections", rSectionTag);
                        ListTag rEntityTag = new ListTag("Entities", CompoundTag.class, entities);
                        rLevelTags.put("Entities", rEntityTag);
                        final CompoundTag rLevel = new CompoundTag("Level", rLevelTags);
                        HashMap<String, Tag> rRootTags = new HashMap<String, Tag>() {
                            {
                                put("Level", rLevel);
                            }
                        };
                        CompoundTag rRoot = new CompoundTag(rootName, rRootTags);
                        OutputStream os = anvil.getChunkDataOutputStream(x, z);
                        NBTOutputStream nbto = new NBTOutputStream(os, CompressionMode.NONE);
                        nbto.writeTag(rRoot);
                        nbto.close();
                    }
                    fs++;
                    pu.updated(fs, tfs);
                }
            }
            anvil.close();
        } catch (Exception ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    MaterialData[] data = mdl.toArray();
    System.out.println("FILES SCANNED: " + fc);
    for (MaterialData d : data) {
        System.out.println(d.getType().getName() + ": " + d.getName() + " (" + d.getQuantity() + ")");
    }
    return mdl;
}

From source file:haven.Utils.java

public static IntBuffer bufcp(IntBuffer a) {
    a.rewind();/*w w w . ja v a2  s. co  m*/
    IntBuffer ret = mkibuf(a.remaining());
    ret.put(a).rewind();
    return (ret);
}

From source file:ubic.basecode.io.ByteArrayConverter.java

/**
 * @param barray/*  w w  w. ja va  2  s .co  m*/
 * @return int[]
 */
public int[] byteArrayToInts(byte[] barray) {
    if (barray == null)
        return null;

    IntBuffer intBuf = ByteBuffer.wrap(barray).asIntBuffer();
    int[] array = new int[intBuf.remaining()];
    intBuf.get(array);

    return array;

}

From source file:com.asakusafw.runtime.io.csv.CsvParser.java

private void addSeparator() {
    IntBuffer buf = cellBeginPositions;
    if (buf.remaining() == 0) {
        IntBuffer newBuf = IntBuffer.allocate(buf.capacity() * 2);
        newBuf.clear();/*from w  w  w .  jav  a 2  s . c  om*/
        buf.flip();
        newBuf.put(buf);
        buf = newBuf;
        cellBeginPositions = newBuf;
    }
    buf.put(lineBuffer.position());
}

From source file:uk.org.openseizuredetector.SdServer.java

/**
 * Set this server to receive pebble data by registering it as
 * A PebbleDataReceiver/* w  w  w  .j a  v a 2  s.c o  m*/
 */
private void startPebbleServer() {
    Log.v(TAG, "StartPebbleServer()");
    final Handler handler = new Handler();
    msgDataHandler = new PebbleKit.PebbleDataReceiver(SD_UUID) {
        @Override
        public void receiveData(final Context context, final int transactionId, final PebbleDictionary data) {
            Log.v(TAG,
                    "Received message from Pebble - data type=" + data.getUnsignedIntegerAsLong(KEY_DATA_TYPE));
            // If we have a message, the app must be running
            mPebbleAppRunningCheck = true;
            PebbleKit.sendAckToPebble(context, transactionId);
            //Log.v(TAG,"Message is: "+data.toJsonString());
            if (data.getUnsignedIntegerAsLong(KEY_DATA_TYPE) == DATA_TYPE_RESULTS) {
                Log.v(TAG, "DATA_TYPE = Results");
                sdData.dataTime.setToNow();
                Log.v(TAG, "sdData.dataTime=" + sdData.dataTime);

                sdData.alarmState = data.getUnsignedIntegerAsLong(KEY_ALARMSTATE);
                sdData.maxVal = data.getUnsignedIntegerAsLong(KEY_MAXVAL);
                sdData.maxFreq = data.getUnsignedIntegerAsLong(KEY_MAXFREQ);
                sdData.specPower = data.getUnsignedIntegerAsLong(KEY_SPECPOWER);
                sdData.roiPower = data.getUnsignedIntegerAsLong(KEY_ROIPOWER);
                sdData.alarmPhrase = "Unknown";
                if (sdData.alarmState == 0) {
                    sdData.alarmPhrase = "OK";
                }
                if (sdData.alarmState == 1) {
                    sdData.alarmPhrase = "WARNING";
                    if (mLogAlarms) {
                        Log.v(TAG, "WARNING - Loggin to SD Card");
                        writeAlarmToSD();
                        logData();
                    } else {
                        Log.v(TAG, "WARNING");
                    }
                    warningBeep();
                }
                if (sdData.alarmState == 2) {
                    sdData.alarmPhrase = "ALARM";
                    if (mLogAlarms) {
                        Log.v(TAG, "***ALARM*** - Loggin to SD Card");
                        writeAlarmToSD();
                        logData();
                    } else {
                        Log.v(TAG, "***ALARM***");
                    }
                    // Make alarm beep tone
                    alarmBeep();
                    // Send SMS Alarm.
                    if (mSMSAlarm) {
                        Time tnow = new Time(Time.getCurrentTimezone());
                        tnow.setToNow();
                        // limit SMS alarms to one per minute
                        if ((tnow.toMillis(false) - mSMSTime.toMillis(false)) > 60000) {
                            sendSMSAlarm();
                            mSMSTime = tnow;
                        }
                    }
                }

                // Read the data that has been sent, and convert it into
                // an integer array.
                byte[] byteArr = data.getBytes(KEY_SPEC_DATA);
                IntBuffer intBuf = ByteBuffer.wrap(byteArr).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer();
                int[] intArray = new int[intBuf.remaining()];
                intBuf.get(intArray);
                for (int i = 0; i < intArray.length; i++) {
                    sdData.simpleSpec[i] = intArray[i];
                }

            }
            if (data.getUnsignedIntegerAsLong(KEY_DATA_TYPE) == DATA_TYPE_SETTINGS) {
                Log.v(TAG, "DATA_TYPE = Settings");
                sdData.alarmFreqMin = data.getUnsignedIntegerAsLong(KEY_ALARM_FREQ_MIN);
                sdData.alarmFreqMax = data.getUnsignedIntegerAsLong(KEY_ALARM_FREQ_MAX);
                sdData.nMin = data.getUnsignedIntegerAsLong(KEY_NMIN);
                sdData.nMax = data.getUnsignedIntegerAsLong(KEY_NMAX);
                sdData.warnTime = data.getUnsignedIntegerAsLong(KEY_WARN_TIME);
                sdData.alarmTime = data.getUnsignedIntegerAsLong(KEY_ALARM_TIME);
                sdData.alarmThresh = data.getUnsignedIntegerAsLong(KEY_ALARM_THRESH);
                sdData.alarmRatioThresh = data.getUnsignedIntegerAsLong(KEY_ALARM_RATIO_THRESH);
                sdData.batteryPc = data.getUnsignedIntegerAsLong(KEY_BATTERY_PC);
                sdData.haveSettings = true;
            }
        }
    };
    PebbleKit.registerReceivedDataHandler(this, msgDataHandler);
}