Sorting Java case statements

Sorting Java case statements - java

I came through here a little while ago trying to find out if there was in fact a way to auto sort case statements.. Eclipse doesn't have the answer to do this automatically. So I wanted to find out a way to do this. Sadly this doesn't appear to be something addressed anywhere. Is this something everyone will need to do... probably not.

Here is my solution:
Main call:
package com.debug;
import java.io.IOException;
public class DebugMain {
public static void main(String[] args) {
fixCases();
}
public static void fixCases() {
String filePath = System.getProperty("user.home").replace("\\", "/") + "/Documents/";
String fileName = "case.txt";
System.out.println("Organizing cases: " + filePath + fileName);
CaseHandler ch = new CaseHandler(filePath + fileName, CaseType.Integer);
try {
ch.readFile();
ch.sortCases();
ch.writeCases(filePath + "casetest.txt");
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("Organizing complete.");
}
}
CaseHandler:
package com.debug;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/**
* This handler allows you to read from a text file a list of case statements, sort the case statements<br />
* in natural order, and write to a file.
*
* #author Vincent
*/
public class CaseHandler {
/**
* This denotes the use of numerical or text based case statements.
*/
public enum CaseType {
String, Integer;
}
private boolean autoSort = false;
private ArrayList<Case> cases = new ArrayList<Case>();
private CaseType caseType;
private File file;
/**
* This construcs a basic <code>CaseHandler</code> in which a file must be provided
* within the {#link #readFile(String)} method.
* <b>Note:</b> The file expected should always be a text file with only the case statements.<br />
* The formatting is not important.
*
* #param caseType The type of case this instance should use.
* #see {#link CaseType}, {#link CaseHandler}
*/
public CaseHandler(CaseType caseType) {
this.caseType = caseType;
}
/**
* This construcs a <code>CaseHandler</code> with a file provided.<br />
* <b>Note:</b> The file expected should always be a text file with only the case statements.<br />
* The formatting is not important.
*
* #param fileName The full file path and name to be read from and/or written to.
* #param caseType The type of case this instance should use.
* #see {#link CaseType}, {#link CaseHandler}
*/
public CaseHandler(String fileName, CaseType caseType) {
this.caseType = caseType;
this.file = new File(fileName);
}
/**
* This construcs a <code>CaseHandler</code> with a file provided.<br />
* <b>Note:</b> The file expected should always be a text file with only the case statements.<br />
* The formatting is not important.
*
* #param fileName The full file path and name to be read from and/or written to.
* #param caseType The type of case this instance should use.
* #param autoSort Enables auto sorting in the {#link #readFile()}
*/
public CaseHandler(String fileName, CaseType caseType, boolean autoSort) {
this.caseType = caseType;
this.file = new File(fileName);
this.autoSort = autoSort;
}
/**
* Reads the file where the case statements are stored line by line.<br />
* When the word case is found it creates a new temp <code>ArrayList</code> of <code>String</code>. <br />
* If a temp <code>ArrayList</code> already exists then it overwrites the <code>ArrayList</code>. <br />
* When the word break is found it then creates a <code>Case<code> object and stores the lines.<br />
* This then stores the <code>Case</code> objects into an <code>ArrayList</code> for later use.
* If auto sort has been enabled in the constructor then this will also sort the <code>Case</code> objects.
*
* #throws IOException
* #see {#link ArrayList}, {#link FileReader}, {#link BufferedReader}, {#link Case}
*/
public void readFile() throws IOException {
if (this.file != null && this.file.exists()) {
FileReader fr = null;
BufferedReader br = null;
try {
fr = new FileReader(this.file);
br = new BufferedReader(fr);
String line = "";
ArrayList<String> lines = null;
while ((line = br.readLine()) != null) {
if (line.contains("case")) {
if (lines != null && lines.get(lines.size() - 1).contains("break")) {
lines = new ArrayList<String>();
} else {
lines = new ArrayList<String>();
}
}
lines.add(line);
if (line.contains("break")) {
String caseName = lines.get(0).replace("case", "").replace(":", "").trim();
Case aCase = null;
if (caseType == CaseType.Integer) {
aCase = new Case(Integer.parseInt(caseName), lines);
} else if (caseType == CaseType.String) {
aCase = new Case(caseName, lines);
}
cases.add(aCase);
}
}
if (this.autoSort) {
this.sortCases();
}
} finally {
if (br != null) {
br.close();
}
if (fr != null) {
fr.close();
}
}
} else {
System.out.println("File " + this.file.getName() + " does not exist!");
}
}
/**
* Reads the file where the case statements are stored line by line.<br />
* When the word case is found it creates a new temp <code>ArrayList</code> of <code>String</code>. <br />
* If a temp <code>ArrayList</code> already exists then it overwrites the <code>ArrayList</code>. <br />
* When the word break is found it then creates a <code>Case<code> object and stores the lines.<br />
* This then stores the <code>Case</code> objects into an <code>ArrayList</code> for later use.
* If auto sort has been enabled in the constructor then this will also sort the <code>Case</code> objects.
*
* #param fileName The full file path and name to be read from and/or written to.
* #throws IOException
* #see {#link ArrayList}, {#link FileReader}, {#link BufferedReader}, {#link Case}
*/
public void readFile(String fileName) throws IOException {
this.file = new File(fileName);
if (this.file != null && this.file.exists()) {
FileReader fr = null;
BufferedReader br = null;
try {
fr = new FileReader(this.file);
br = new BufferedReader(fr);
String line = "";
ArrayList<String> lines = null;
while ((line = br.readLine()) != null) {
if (line.contains("case")) {
if (lines != null && lines.get(lines.size() - 1).contains("break")) {
lines = new ArrayList<String>();
} else {
lines = new ArrayList<String>();
}
}
lines.add(line);
if (line.contains("break")) {
String caseName = lines.get(0).replace("case", "").replace(":", "").trim();
Case aCase = null;
if (caseType == CaseType.Integer) {
aCase = new Case(Integer.parseInt(caseName), lines);
} else if (caseType == CaseType.String) {
aCase = new Case(caseName, lines);
}
cases.add(aCase);
}
}
if (this.autoSort) {
this.sortCases();
}
} finally {
if (br != null) {
br.close();
}
if (fr != null) {
fr.close();
}
}
} else {
System.out.println("File " + this.file.getName() + " does not exist!");
}
}
/**
* Sorts the {#link ArrayList} in alphabetical or numerical order.<br />
* <b>Note:</b> This will <b>NOT</b> sort clusters of case statements.
* #see {#link Collections#sort(java.util.List)}
*/
public void sortCases() {
if (cases.size() > 0) {
Collections.sort(cases, Comparator.naturalOrder());
}
}
/**
* Overwrites the file provided to the <code>CaseHandler</code> with the cases list.
*
* #throws IOException
* #see {#link ArrayList}, {#link FileWriter}, {#link BufferedWriter}, {#link Case}
*/
public void writeCases() throws IOException {
if (this.file.exists()) {
FileWriter fw = null;
BufferedWriter bw = null;
try {
fw = new FileWriter(this.file);
bw = new BufferedWriter(fw);
for (Case aCase : cases) {
for (String line : aCase.getLines()) {
bw.write(line);
bw.newLine();
}
}
} finally {
if (bw != null) {
bw.close();
}
if (fw != null) {
fw.close();
}
}
}
}
/**
* Overwrites the file provided to with the cases list.
*
* #param fileName The full file path and name to be read from and/or written to.
* #throws IOException
* #see {#link ArrayList}, {#link FileWriter}, {#link BufferedWriter}, {#link Case}
*/
public void writeCases(String fileName) throws IOException {
File outFile = new File(fileName);
if (!outFile.exists()) {
outFile.createNewFile();
}
if (outFile.exists()) {
FileWriter fw = null;
BufferedWriter bw = null;
try {
fw = new FileWriter(outFile);
bw = new BufferedWriter(fw);
for (Case aCase : cases) {
for (String line : aCase.getLines()) {
bw.write(line);
bw.newLine();
}
}
} finally {
if (bw != null) {
bw.close();
}
if (fw != null) {
fw.close();
}
}
}
}
/**
* Changes the case type.
*
* #param caseType The new type of case this instance should use.
* #see {#link CaseType}
*/
public void setCaseType(CaseType caseType) {
this.caseType = caseType;
}
}
Case:
package com.debug;
import java.util.ArrayList;
/**
* This is the individual case statement starting at <code>case (Integer or String):</code> <br />
* The last line stored in the instance will be the <code>break;</code> statement.
*
* #author Vincent
*
*/
public class Case implements Comparable<Case> {
private int nameInt;
private String nameStr = null;
private ArrayList<String> lines;
/**
* Constructs a new <code>Case</code> using integer values as the name.
*
* #param nameInt The integer value name
* #param lines The lines within this case statement
* #see {#link ArrayList}
*/
public Case(int nameInt, ArrayList<String> lines) {
this.nameInt = nameInt;
this.lines = lines;
}
/**
* Constructs a new <code>Case</code> using string values as the name.
*
* #param nameStr The string value name
* #param lines The lines within this case statement
* #see {#link ArrayList}
*/
public Case(String nameStr, ArrayList<String> lines) {
this.nameStr = nameStr;
this.lines = lines;
}
#Override
public int compareTo(Case aCase) {
if (this.nameStr != null) {
return this.nameStr.compareTo(aCase.getNameStr());
} else {
if (this.nameInt < aCase.getNameInt()) {
return -1;
} else if (this.nameInt > aCase.getNameInt()) {
return 1;
} else {
return 0;
}
}
}
/**
* Returns the lines stored in this <code>Case</code> instance.
*
* #return {#link ArrayList}
*/
public ArrayList<String> getLines() {
return this.lines;
}
/**
* Returns the integer name of this <code>Case</code> instance.
*
* #return {#link Integer}
*/
public int getNameInt() {
return this.nameInt;
}
/**
* Returns the string name of this <code>Case</code> instance.
*
* #return {#link String}
*/
public String getNameStr() {
return this.nameStr;
}
}
Example input:
case 338:
// Code
break;
case 852:
// Code
break;
case 2:
// Code
break;
case 696:
// Code
break;
Example output:
case 2:
// Code
break;
case 338:
// Code
break;
case 696:
// Code
break;
case 852:
// Code
break;
Hope this potentially helps someone out. I needed this cause I was looking at a long list of cases (1000 of them to be exact) that were sorted in no particular order or with any reason to be sorted that way. So I wanted to see them in natural order.

Related

Send all contacts to mail as CSV file using Android code

Hello Every one here the below code is for sending all contacts to mail in CSV file format
This is my CSV sender class
public class CsvSender extends Activity {
private Cursor cursor;
private boolean csv_status = false;
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_csv_sender);
createCSV();
if(csv_status)
exportCSV();
}
private void createCSV() {
CSVWriter writer = null;
try {
writer = new CSVWriter(new FileWriter(Environment.getExternalStorageDirectory().getAbsolutePath() + "/my_test_contact.csv"));
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
String displayName;
String number;
long _id;
String columns[] = new String[]{ ContactsContract.Contacts._ID,
ContactsContract.Contacts.DISPLAY_NAME };
writer.writeColumnNames(); // Write column header
Cursor cursor = getContentResolver().query(ContactsContract.Contacts.CONTENT_URI,
columns,
null,
null,
ContactsContract.Data.DISPLAY_NAME +" COLLATE LOCALIZED ASC" );
startManagingCursor(cursor);
if(cursor.moveToFirst()) {
do {
_id = Long.parseLong(cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts._ID)));
displayName = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME)).trim();
number = getPrimaryNumber(_id);
writer.writeNext((displayName + "/" + number).split("/"));
} while(cursor.moveToNext());
csv_status = true;
} else {
csv_status = false;
}
try {
if(writer != null)
writer.close();
} catch (IOException e) {
Log.w("Test", e.toString());
}
}// Method close.
private void exportCSV() {
if(csv_status == true) {
//CSV file is created so we need to Export that ...
final File CSVFile = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + "/my_test_contact.csv");
//Log.i("SEND EMAIL TESTING", "Email sending");
Intent emailIntent = new Intent(android.content.Intent.ACTION_SEND);
emailIntent.setType("text/csv");
emailIntent .putExtra(android.content.Intent.EXTRA_SUBJECT, "Test contacts ");
emailIntent .putExtra(android.content.Intent.EXTRA_TEXT, "\n\nAdroid developer\n Sathish");
emailIntent.putExtra(Intent.EXTRA_STREAM, Uri.parse("file://" + CSVFile.getAbsolutePath()));
emailIntent.setType("message/rfc822"); // Shows all application that supports SEND activity
try {
startActivity(Intent.createChooser(emailIntent, "Send mail..."));
} catch (android.content.ActivityNotFoundException ex) {
Toast.makeText(getApplicationContext(), "Email client : " + ex.toString(), Toast.LENGTH_SHORT);
}
} else {
Toast.makeText(getApplicationContext(), "Information not available to create CSV.", Toast.LENGTH_SHORT).show();
}
}
/**
* Get primary Number of requested id.
*
* #return string value of primary number.
*/
private String getPrimaryNumber(long _id) {
String primaryNumber = null;
try {
Cursor cursor = getContentResolver().query( ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
new String[]{NUMBER, ContactsContract.CommonDataKinds.Phone.TYPE},
ContactsContract.CommonDataKinds.Phone.CONTACT_ID +" = "+ _id, // We need to add more selection for phone type
null,
null);
if(cursor != null) {
while(cursor.moveToNext()){
switch(cursor.getInt(cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.TYPE))){
case ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE :
primaryNumber = cursor.getString(cursor.getColumnIndex(NUMBER));
break;
case ContactsContract.CommonDataKinds.Phone.TYPE_HOME :
primaryNumber = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
break;
case ContactsContract.CommonDataKinds.Phone.TYPE_WORK :
primaryNumber = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
break;
case ContactsContract.CommonDataKinds.Phone.TYPE_OTHER :
}
if(primaryNumber != null)
break;
}
}
} catch (Exception e) {
Log.i("test", "Exception " + e.toString());
} finally {
if(cursor != null) {
cursor.deactivate();
cursor.close();
}
}
return primaryNumber;
}
}
This is my CSV writer class
/**
* Created by ADMIN on 23-01-2018.
*/
class CSVWriter {
private PrintWriter pw;
private char separator;
private char quotechar;
private char escapechar;
private String lineEnd;
/** The character used for escaping quotes. */
public static final char DEFAULT_ESCAPE_CHARACTER = '"';
/** The default separator to use if none is supplied to the constructor. */
public static final char DEFAULT_SEPARATOR = ',';
/**
* The default quote character to use if none is supplied to the
* constructor.
*/
public static final char DEFAULT_QUOTE_CHARACTER = '"';
/** The quote constant to use when you wish to suppress all quoting. */
public static final char NO_QUOTE_CHARACTER = '\u0000';
/** The escape constant to use when you wish to suppress all escaping. */
public static final char NO_ESCAPE_CHARACTER = '\u0000';
/** Default line terminator uses platform encoding. */
public static final String DEFAULT_LINE_END = "\n";
/** Default column name. */
public static final String DEFAULT_COLUMN_NAME = "Contact Name,Phone Number,";
/**
* Constructs CSVWriter using a comma for the separator.
*
* #param writer
* the writer to an underlying CSV source.
*/
public CSVWriter(Writer writer) {
this(writer, DEFAULT_SEPARATOR, DEFAULT_QUOTE_CHARACTER,
DEFAULT_ESCAPE_CHARACTER, DEFAULT_LINE_END);
}
/**
* Constructs CSVWriter with supplied separator, quote char, escape char and line ending.
*
* #param writer
* the writer to an underlying CSV source.
* #param separator
* the delimiter to use for separating entries
* #param quotechar
* the character to use for quoted elements
* #param escapechar
* the character to use for escaping quotechars or escapechars
* #param lineEnd
* the line feed terminator to use
*/
public CSVWriter(Writer writer, char separator, char quotechar, char escapechar, String lineEnd) {
this.pw = new PrintWriter(writer);
this.separator = separator;
this.quotechar = quotechar;
this.escapechar = escapechar;
this.lineEnd = lineEnd;
}
/**
* Writes the next line to the file.
*
* #param nextLine
* a string array with each comma-separated element as a separate
* entry.
*/
public void writeNext(String[] nextLine) {
if (nextLine == null)
return;
StringBuffer sb = new StringBuffer();
for (int i = 0; i < nextLine.length; i++) {
if (i != 0) {
sb.append(separator);
}
String nextElement = nextLine[i];
if (nextElement == null)
continue;
if (quotechar != NO_QUOTE_CHARACTER)
sb.append(quotechar);
for (int j = 0; j < nextElement.length(); j++) {
char nextChar = nextElement.charAt(j);
if (escapechar != NO_ESCAPE_CHARACTER && nextChar == quotechar) {
sb.append(escapechar).append(nextChar);
} else if (escapechar != NO_ESCAPE_CHARACTER && nextChar == escapechar) {
sb.append(escapechar).append(nextChar);
} else {
sb.append(nextChar);
}
}
if (quotechar != NO_QUOTE_CHARACTER)
sb.append(quotechar);
}
sb.append(lineEnd);
pw.write(sb.toString());
}
public void writeColumnNames() {
writeNext(DEFAULT_COLUMN_NAME.split(","));
}
/**
* Flush underlying stream to writer.
*
* #throws IOException if bad things happen
*/
public void flush() throws IOException {
pw.flush();
}
/**
* Close the underlying stream writer flushing any buffered content.
*
* #throws IOException if bad things happen
*
*/
public void close() throws IOException {
pw.flush();
pw.close();
}
}
Here I'm able to send my contacts but the mobile numbers which are starting with `+91 are display like (9.1903E+11). How can I solve this please help anyone.
Thanks in advance.

How to encode images into a video file in Java through programming?

I am trying to encode some images of same resolution into a video file using, For that I have tried:
jCodec
jcodec..example description
But it is very time consuming and not a proper tool to encode large number of images and it creates a quick time extension.
FFMPEG
FFMPEG..example description
But ffmpeg only able to create video from image files. Images need to be create on physical system.
I have heard Xuggler that its APIs can be used in java program to create video file but as its site seems broken. I am unable to try it.
Does anybody know how to encode images in java format into a video file Please help!
THanks in Advance !

Xuggler is deprecated, use Humble-Video instead. It already comes with some demo projects, including how to take screenshots and convert it to a video file: RecordAndEncodeVideo.java
/*******************************************************************************
* Copyright (c) 2014, Art Clarke. All rights reserved.
* <p>
* This file is part of Humble-Video.
* <p>
* Humble-Video is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* <p>
* Humble-Video is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
* <p>
* You should have received a copy of the GNU Affero General Public License
* along with Humble-Video. If not, see <http://www.gnu.org/licenses/>.
*******************************************************************************/
package io.humble.video.demos;
import io.humble.video.*;
import io.humble.video.awt.MediaPictureConverter;
import io.humble.video.awt.MediaPictureConverterFactory;
import org.apache.commons.cli.*;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
/**
* Records the contents of your computer screen to a media file for the passed in duration.
* This is meant as a demonstration program to teach the use of the Humble API.
* <p>
* Concepts introduced:
* </p>
* <ul>
* <li>Muxer: A {#link Muxer} object is a container you can write media data to.</li>
* <li>Encoders: An {#link Encoder} object lets you convert {#link MediaAudio} or {#link MediaPicture} objects into {#link MediaPacket} objects
* so they can be written to {#link Muxer} objects.</li>
* </ul>
*
* <p>
* To run from maven, do:
* </p>
* <pre>
* mvn install exec:java -Dexec.mainClass="io.humble.video.demos.RecordAndEncodeVideo" -Dexec.args="filename.mp4"
* </pre>
*
* #author aclarke
*
*/
public class RecordAndEncodeVideo
{
/**
* Records the screen
*/
private static void recordScreen (String filename, String formatname, String codecname, int duration, int snapsPerSecond) throws AWTException, InterruptedException, IOException
{
/**
* Set up the AWT infrastructure to take screenshots of the desktop.
*/
final Robot robot = new Robot();
final Toolkit toolkit = Toolkit.getDefaultToolkit();
final Rectangle screenbounds = new Rectangle(toolkit.getScreenSize());
final Rational framerate = Rational.make(1, snapsPerSecond);
/** First we create a muxer using the passed in filename and formatname if given. */
final Muxer muxer = Muxer.make(filename, null, formatname);
/** Now, we need to decide what type of codec to use to encode video. Muxers
* have limited sets of codecs they can use. We're going to pick the first one that
* works, or if the user supplied a codec name, we're going to force-fit that
* in instead.
*/
final MuxerFormat format = muxer.getFormat();
final Codec codec;
if (codecname != null)
{
codec = Codec.findEncodingCodecByName(codecname);
}
else
{
codec = Codec.findEncodingCodec(format.getDefaultVideoCodecId());
}
/**
* Now that we know what codec, we need to create an encoder
*/
Encoder encoder = Encoder.make(codec);
/**
* Video encoders need to know at a minimum:
* width
* height
* pixel format
* Some also need to know frame-rate (older codecs that had a fixed rate at which video files could
* be written needed this). There are many other options you can set on an encoder, but we're
* going to keep it simpler here.
*/
encoder.setWidth(screenbounds.width);
encoder.setHeight(screenbounds.height);
// We are going to use 420P as the format because that's what most video formats these days use
final PixelFormat.Type pixelformat = PixelFormat.Type.PIX_FMT_YUV420P;
encoder.setPixelFormat(pixelformat);
encoder.setTimeBase(framerate);
/** An annoynace of some formats is that they need global (rather than per-stream) headers,
* and in that case you have to tell the encoder. And since Encoders are decoupled from
* Muxers, there is no easy way to know this beyond
*/
if (format.getFlag(MuxerFormat.Flag.GLOBAL_HEADER))
{
encoder.setFlag(Encoder.Flag.FLAG_GLOBAL_HEADER, true);
}
/** Open the encoder. */
encoder.open(null, null);
/** Add this stream to the muxer. */
muxer.addNewStream(encoder);
/** And open the muxer for business. */
muxer.open(null, null);
/** Next, we need to make sure we have the right MediaPicture format objects
* to encode data with. Java (and most on-screen graphics programs) use some
* variant of Red-Green-Blue image encoding (a.k.a. RGB or BGR). Most video
* codecs use some variant of YCrCb formatting. So we're going to have to
* convert. To do that, we'll introduce a MediaPictureConverter object later. object.
*/
MediaPictureConverter converter = null;
final MediaPicture picture = MediaPicture.make(encoder.getWidth(), encoder.getHeight(), pixelformat);
picture.setTimeBase(framerate);
/** Now begin our main loop of taking screen snaps.
* We're going to encode and then write out any resulting packets. */
final MediaPacket packet = MediaPacket.make();
for (int i = 0; i < duration / framerate.getDouble(); i++)
{
/** Make the screen capture && convert image to TYPE_3BYTE_BGR */
final BufferedImage screen = convertToType(robot.createScreenCapture(screenbounds), BufferedImage.TYPE_3BYTE_BGR);
/** This is LIKELY not in YUV420P format, so we're going to convert it using some handy utilities. */
if (converter == null)
{
converter = MediaPictureConverterFactory.createConverter(screen, picture);
}
converter.toPicture(picture, screen, i);
do
{
encoder.encode(packet, picture);
if (packet.isComplete())
{
muxer.write(packet, false);
}
} while (packet.isComplete());
/** now we'll sleep until it's time to take the next snapshot. */
Thread.sleep((long) (1000 * framerate.getDouble()));
}
/** Encoders, like decoders, sometimes cache pictures so it can do the right key-frame optimizations.
* So, they need to be flushed as well. As with the decoders, the convention is to pass in a null
* input until the output is not complete.
*/
do
{
encoder.encode(packet, null);
if (packet.isComplete())
{
muxer.write(packet, false);
}
} while (packet.isComplete());
/** Finally, let's clean up after ourselves. */
muxer.close();
}
#SuppressWarnings("static-access")
public static void main (String[] args) throws InterruptedException, IOException, AWTException
{
final Options options = new Options();
options.addOption("h", "help", false, "displays help");
options.addOption("v", "version", false, "version of this library");
options.addOption(OptionBuilder.withArgName("format").withLongOpt("format").hasArg().
withDescription("muxer format to use. If unspecified, we will guess from filename").create("f"));
options.addOption(OptionBuilder.withArgName("codec")
.withLongOpt("codec")
.hasArg()
.withDescription("codec to use when encoding video; If unspecified, we will guess from format")
.create("c"));
options.addOption(OptionBuilder.withArgName("duration")
.withLongOpt("duration")
.hasArg()
.withDescription("number of seconds of screenshot to record; defaults to 10.")
.create("d"));
options.addOption(OptionBuilder.withArgName("snaps per second")
.withLongOpt("snaps")
.hasArg()
.withDescription("number of pictures to take per second (i.e. the frame rate); defaults to 5")
.create("s"));
final CommandLineParser parser = new org.apache.commons.cli.BasicParser();
try
{
final CommandLine cmd = parser.parse(options, args);
final String[] parsedArgs = cmd.getArgs();
if (cmd.hasOption("version"))
{
// let's find what version of the library we're running
final String version = io.humble.video_native.Version.getVersionInfo();
System.out.println("Humble Version: " + version);
}
else if (cmd.hasOption("help") || parsedArgs.length != 1)
{
final HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(RecordAndEncodeVideo.class.getCanonicalName() + " <filename>", options);
}
else
{
/**
* Read in some option values and their defaults.
*/
final int duration = Integer.parseInt(cmd.getOptionValue("duration", "10"));
if (duration <= 0)
{
throw new IllegalArgumentException("duration must be > 0");
}
final int snaps = Integer.parseInt(cmd.getOptionValue("snaps", "5"));
if (snaps <= 0)
{
throw new IllegalArgumentException("snaps must be > 0");
}
final String codecname = cmd.getOptionValue("codec");
final String formatname = cmd.getOptionValue("format");
final String filename = cmd.getArgs()[0];
recordScreen(filename, formatname, codecname, duration, snaps);
}
} catch (ParseException e)
{
System.err.println("Exception parsing command line: " + e.getLocalizedMessage());
}
}
/**
* Convert a {#link BufferedImage} of any type, to {#link BufferedImage} of a
* specified type. If the source image is the same type as the target type,
* then original image is returned, otherwise new image of the correct type is
* created and the content of the source image is copied into the new image.
*
* #param sourceImage
* the image to be converted
* #param targetType
* the desired BufferedImage type
*
* #return a BufferedImage of the specifed target type.
*
* #see BufferedImage
*/
public static BufferedImage convertToType (BufferedImage sourceImage, int targetType)
{
BufferedImage image;
// if the source image is already the target type, return the source image
if (sourceImage.getType() == targetType)
{
image = sourceImage;
}
// otherwise create a new image of the target type and draw the new
// image
else
{
image = new BufferedImage(sourceImage.getWidth(), sourceImage.getHeight(), targetType);
image.getGraphics().drawImage(sourceImage, 0, 0, null);
}
return image;
}
}
Check other demos too : humble-video-demos
I am using it for real time using on a webapp.
If you will gonna stream this in real time you will need a RTSP server. You can either use big frameworks like Red 5 Server, Wowza Streaming Engine or you can built your own server using Netty which has a built in RTSP codec since version 3.2.

Using command line, there are various ways to convert image to video. You can use those command in java for saving. You can get those commands from the following link:
Using ffmpeg to convert a set of images into a video
Create a video slideshow from images
I am sharing a code snippet to solve the issue:
code to save png image from HTML5 canvas
Base64 decoder = new Base64();
byte[] pic = decoder.decodeBase64(request.getParameter("pic"));
String frameCount = request.getParameter("frame");
InputStream in = new ByteArrayInputStream(pic);
BufferedImage bImageFromConvert = ImageIO.read(in);
String outdir = "output\\"+frameCount;
//Random rand = new Random();
File file = new File(outdir);
if(file.isFile()){
if(file.delete()){
File writefile = new File(outdir);
ImageIO.write(bImageFromConvert, "png", file);
}
}
Code for creating image from video
String filePath = "D:\\temp\\some.mpg";
String outdir = "output";
File file = new File(outdir);
file.mkdirs();
Map<String, String> m = System.getenv();
/*
* String command[] =
* {"D:\\ffmpeg-win32-static\\bin\\ffmpeg","-i",filePath
* ,"-r 30","-f","image2",outdir,"\\user%03d.jpg"};
*
* ProcessBuilder pb = new ProcessBuilder(command); pb.start();
*/
String commands = "D:\\ffmpeg-win32-static\\bin\\ffmpeg -i " + filePath
+ " -r 30 -f image2 " + outdir + "\\image%5d.png";
Process p = Runtime.getRuntime().exec(commands);
code for creating video from image
String filePath = "output";
File fileP = new File(filePath);
String commands = "D:\\ffmpeg-win32-static\\bin\\ffmpeg -f image2 -i "
+ fileP + "\\image%5d.png " + fileP + "\\video.mp4";
System.out.println(commands);
Runtime.getRuntime().exec(commands);
System.out.println(fileP.getAbsolutePath());
Credit goes to #yashprit
Another approach for Android developers:
Create a temporary folder inside the Android.
Copy your images in the new folder
First, rename your pictures to follow a numerical sequence. For
example, img1.jpg, img2.jpg, img3.jpg,... Then you may run:
Run this program programmetcally ffmpeg -f image2 -i img%d.jpg
/tmp/a.mpg To run this programmatically,
Use the following code:
void convertImg_to_vid()
{
Process chperm;
try {
chperm=Runtime.getRuntime().exec("su");
DataOutputStream os =
new DataOutputStream(chperm.getOutputStream());
os.writeBytes("ffmpeg -f image2 -i img%d.jpg /tmp/a.mpg\n");
os.flush();
chperm.waitFor();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Resource Link:
Create a Video file from images using ffmpeg

There is a utility in Java Media Framework which, It can create Video from List of Jpeg Images Link
Here is the source code:
JpegImagesToMovie.java
/*
* #(#)JpegImagesToMovie.java 1.3 01/03/13
* Copyright (c) 1999-2001 Sun Microsystems, Inc. All Rights Reserved.
* Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
* modify and redistribute this software in source and binary code form,
* provided that i) this copyright notice and license appear on all copies of
* the software; and ii) Licensee does not utilize the software in a manner
* which is disparaging to Sun.
* This software is provided "AS IS," without a warranty of any kind. ALL
* EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
* IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
* LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
* OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
* LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
* INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
* CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
* OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGES.
*
* This software is not designed or intended for use in on-line control of
* aircraft, air traffic, aircraft navigation or aircraft communications; or in
* the design, construction, operation or maintenance of any nuclear
* facility. Licensee represents and warrants that it will not use or
* redistribute the Software for such purposes.
*/
package imagetovideo;
import java.awt.Dimension;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.MalformedURLException;
import java.util.Vector;
import javax.media.Buffer;
import javax.media.ConfigureCompleteEvent;
import javax.media.ControllerEvent;
import javax.media.ControllerListener;
import javax.media.DataSink;
import javax.media.EndOfMediaEvent;
import javax.media.Format;
import javax.media.Manager;
import javax.media.MediaLocator;
import javax.media.PrefetchCompleteEvent;
import javax.media.Processor;
import javax.media.RealizeCompleteEvent;
import javax.media.ResourceUnavailableEvent;
import javax.media.Time;
import javax.media.control.TrackControl;
import javax.media.datasink.DataSinkErrorEvent;
import javax.media.datasink.DataSinkEvent;
import javax.media.datasink.DataSinkListener;
import javax.media.datasink.EndOfStreamEvent;
import javax.media.format.VideoFormat;
import javax.media.protocol.ContentDescriptor;
import javax.media.protocol.DataSource;
import javax.media.protocol.FileTypeDescriptor;
import javax.media.protocol.PullBufferDataSource;
import javax.media.protocol.PullBufferStream;
/**
* This program takes a list of JPEG image files and convert them into a
* QuickTime movie.
*/
public class JpegImagesToMovie implements ControllerListener, DataSinkListener {
public boolean doIt(int width, int height, int frameRate, Vector inFiles,
MediaLocator outML) throws MalformedURLException {
ImageDataSource ids = new ImageDataSource(width, height, frameRate,
inFiles);
Processor p;
try {
//System.err
// .println("- create processor for the image datasource ...");
p = Manager.createProcessor(ids);
} catch (Exception e) {
System.err
.println("Yikes! Cannot create a processor from the data source.");
return false;
}
p.addControllerListener(this);
// Put the Processor into configured state so we can set
// some processing options on the processor.
p.configure();
if (!waitForState(p, p.Configured)) {
System.err.println("Failed to configure the processor.");
return false;
}
// Set the output content descriptor to QuickTime.
p.setContentDescriptor(new ContentDescriptor(
FileTypeDescriptor.QUICKTIME));
// Query for the processor for supported formats.
// Then set it on the processor.
TrackControl tcs[] = p.getTrackControls();
Format f[] = tcs[0].getSupportedFormats();
if (f == null || f.length <= 0) {
System.err.println("The mux does not support the input format: "
+ tcs[0].getFormat());
return false;
}
tcs[0].setFormat(f[0]);
//System.err.println("Setting the track format to: " + f[0]);
// We are done with programming the processor. Let's just
// realize it.
p.realize();
if (!waitForState(p, p.Realized)) {
System.err.println("Failed to realize the processor.");
return false;
}
// Now, we'll need to create a DataSink.
DataSink dsink;
if ((dsink = createDataSink(p, outML)) == null) {
System.err
.println("Failed to create a DataSink for the given output MediaLocator: "
+ outML);
return false;
}
dsink.addDataSinkListener(this);
fileDone = false;
System.out.println("Generating the video : "+outML.getURL().toString());
// OK, we can now start the actual transcoding.
try {
p.start();
dsink.start();
} catch (IOException e) {
System.err.println("IO error during processing");
return false;
}
// Wait for EndOfStream event.
waitForFileDone();
// Cleanup.
try {
dsink.close();
} catch (Exception e) {
}
p.removeControllerListener(this);
System.out.println("Video creation completed!!!!!");
return true;
}
/**
* Create the DataSink.
*/
DataSink createDataSink(Processor p, MediaLocator outML) {
DataSource ds;
if ((ds = p.getDataOutput()) == null) {
System.err
.println("Something is really wrong: the processor does not have an output DataSource");
return null;
}
DataSink dsink;
try {
//System.err.println("- create DataSink for: " + outML);
dsink = Manager.createDataSink(ds, outML);
dsink.open();
} catch (Exception e) {
System.err.println("Cannot create the DataSink: " + e);
return null;
}
return dsink;
}
Object waitSync = new Object();
boolean stateTransitionOK = true;
/**
* Block until the processor has transitioned to the given state. Return
* false if the transition failed.
*/
boolean waitForState(Processor p, int state) {
synchronized (waitSync) {
try {
while (p.getState() < state && stateTransitionOK)
waitSync.wait();
} catch (Exception e) {
}
}
return stateTransitionOK;
}
/**
* Controller Listener.
*/
public void controllerUpdate(ControllerEvent evt) {
if (evt instanceof ConfigureCompleteEvent
|| evt instanceof RealizeCompleteEvent
|| evt instanceof PrefetchCompleteEvent) {
synchronized (waitSync) {
stateTransitionOK = true;
waitSync.notifyAll();
}
} else if (evt instanceof ResourceUnavailableEvent) {
synchronized (waitSync) {
stateTransitionOK = false;
waitSync.notifyAll();
}
} else if (evt instanceof EndOfMediaEvent) {
evt.getSourceController().stop();
evt.getSourceController().close();
}
}
Object waitFileSync = new Object();
boolean fileDone = false;
boolean fileSuccess = true;
/**
* Block until file writing is done.
*/
boolean waitForFileDone() {
synchronized (waitFileSync) {
try {
while (!fileDone)
waitFileSync.wait();
} catch (Exception e) {
}
}
return fileSuccess;
}
/**
* Event handler for the file writer.
*/
public void dataSinkUpdate(DataSinkEvent evt) {
if (evt instanceof EndOfStreamEvent) {
synchronized (waitFileSync) {
fileDone = true;
waitFileSync.notifyAll();
}
} else if (evt instanceof DataSinkErrorEvent) {
synchronized (waitFileSync) {
fileDone = true;
fileSuccess = false;
waitFileSync.notifyAll();
}
}
}
/*public static void main(String args[]) {
if (args.length == 0)
prUsage();
// Parse the arguments.
int i = 0;
int width = -1, height = -1, frameRate = 1;
Vector inputFiles = new Vector();
String outputURL = null;
while (i < args.length) {
if (args[i].equals("-w")) {
i++;
if (i >= args.length)
prUsage();
width = new Integer(args[i]).intValue();
} else if (args[i].equals("-h")) {
i++;
if (i >= args.length)
prUsage();
height = new Integer(args[i]).intValue();
} else if (args[i].equals("-f")) {
i++;
if (i >= args.length)
prUsage();
frameRate = new Integer(args[i]).intValue();
} else if (args[i].equals("-o")) {
i++;
if (i >= args.length)
prUsage();
outputURL = args[i];
} else {
inputFiles.addElement(args[i]);
}
i++;
}
if (outputURL == null || inputFiles.size() == 0)
prUsage();
// Check for output file extension.
if (!outputURL.endsWith(".mov") && !outputURL.endsWith(".MOV")) {
System.err
.println("The output file extension should end with a .mov extension");
prUsage();
}
if (width < 0 || height < 0) {
System.err.println("Please specify the correct image size.");
prUsage();
}
// Check the frame rate.
if (frameRate < 1)
frameRate = 1;
// Generate the output media locators.
MediaLocator oml;
if ((oml = createMediaLocator(outputURL)) == null) {
System.err.println("Cannot build media locator from: " + outputURL);
System.exit(0);
}
JpegImagesToMovie imageToMovie = new JpegImagesToMovie();
imageToMovie.doIt(width, height, frameRate, inputFiles, oml);
System.exit(0);
}*/
static void prUsage() {
System.err
.println("Usage: java JpegImagesToMovie -w <width> -h <height> -f <frame rate> -o <output URL> <input JPEG file 1> <input JPEG file 2> ...");
System.exit(-1);
}
/**
* Create a media locator from the given string.
*/
static MediaLocator createMediaLocator(String url) {
MediaLocator ml;
if (url.indexOf(":") > 0 && (ml = new MediaLocator(url)) != null)
return ml;
if (url.startsWith(File.separator)) {
if ((ml = new MediaLocator("file:" + url)) != null)
return ml;
} else {
String file = "file:" + System.getProperty("user.dir")
+ File.separator + url;
if ((ml = new MediaLocator(file)) != null)
return ml;
}
return null;
}
// /////////////////////////////////////////////
//
// Inner classes.
// /////////////////////////////////////////////
/**
* A DataSource to read from a list of JPEG image files and turn that into a
* stream of JMF buffers. The DataSource is not seekable or positionable.
*/
class ImageDataSource extends PullBufferDataSource {
ImageSourceStream streams[];
ImageDataSource(int width, int height, int frameRate, Vector images) {
streams = new ImageSourceStream[1];
streams[0] = new ImageSourceStream(width, height, frameRate, images);
}
public void setLocator(MediaLocator source) {
}
public MediaLocator getLocator() {
return null;
}
/**
* Content type is of RAW since we are sending buffers of video frames
* without a container format.
*/
public String getContentType() {
return ContentDescriptor.RAW;
}
public void connect() {
}
public void disconnect() {
}
public void start() {
}
public void stop() {
}
/**
* Return the ImageSourceStreams.
*/
public PullBufferStream[] getStreams() {
return streams;
}
/**
* We could have derived the duration from the number of frames and
* frame rate. But for the purpose of this program, it's not necessary.
*/
public Time getDuration() {
return DURATION_UNKNOWN;
}
public Object[] getControls() {
return new Object[0];
}
public Object getControl(String type) {
return null;
}
}
/**
* The source stream to go along with ImageDataSource.
*/
class ImageSourceStream implements PullBufferStream {
Vector images;
int width, height;
VideoFormat format;
int nextImage = 0; // index of the next image to be read.
boolean ended = false;
public ImageSourceStream(int width, int height, int frameRate,
Vector images) {
this.width = width;
this.height = height;
this.images = images;
format = new VideoFormat(VideoFormat.JPEG, new Dimension(width,
height), Format.NOT_SPECIFIED, Format.byteArray,
(float) frameRate);
}
/**
* We should never need to block assuming data are read from files.
*/
public boolean willReadBlock() {
return false;
}
/**
* This is called from the Processor to read a frame worth of video
* data.
*/
public void read(Buffer buf) throws IOException {
// Check if we've finished all the frames.
if (nextImage >= images.size()) {
// We are done. Set EndOfMedia.
//System.err.println("Done reading all images.");
buf.setEOM(true);
buf.setOffset(0);
buf.setLength(0);
ended = true;
return;
}
String imageFile = (String) images.elementAt(nextImage);
nextImage++;
//System.err.println(" - reading image file: " + imageFile);
// Open a random access file for the next image.
RandomAccessFile raFile;
raFile = new RandomAccessFile(imageFile, "r");
byte data[] = null;
// Check the input buffer type & size.
if (buf.getData() instanceof byte[])
data = (byte[]) buf.getData();
// Check to see the given buffer is big enough for the frame.
if (data == null || data.length < raFile.length()) {
data = new byte[(int) raFile.length()];
buf.setData(data);
}
// Read the entire JPEG image from the file.
raFile.readFully(data, 0, (int) raFile.length());
//System.err.println(" read " + raFile.length() + " bytes.");
buf.setOffset(0);
buf.setLength((int) raFile.length());
buf.setFormat(format);
buf.setFlags(buf.getFlags() | buf.FLAG_KEY_FRAME);
// Close the random access file.
raFile.close();
}
/**
* Return the format of each video frame. That will be JPEG.
*/
public Format getFormat() {
return format;
}
public ContentDescriptor getContentDescriptor() {
return new ContentDescriptor(ContentDescriptor.RAW);
}
public long getContentLength() {
return 0;
}
public boolean endOfStream() {
return ended;
}
public Object[] getControls() {
return new Object[0];
}
public Object getControl(String type) {
return null;
}
}
}
Its doIt function can be called from another class having main function:
CreatVideo.java
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package imagetovideo;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.net.MalformedURLException;
import java.util.Vector;
import javax.media.MediaLocator;
public class CreateVideo{
public static final File dir = new File("D:\\imagesFolder\\");
public static final String[] extensions = new String[]{"jpg", "png"};
public static final FilenameFilter imageFilter = new FilenameFilter() {
#Override
public boolean accept(final File dir, String name) {
for (final String ext : extensions) {
if (name.endsWith("." + ext)) {
return (true);
}
}
return (false);
}
};
// Main function
public static void main(String[] args) throws IOException {
File file = new File("D:\\a.mp4");
if (!file.exists()) {
file.createNewFile();
}
Vector<String> imgLst = new Vector<>();
if (dir.isDirectory()) {
int counter = 1;
for (final File f : dir.listFiles(imageFilter)) {
imgLst.add(f.getAbsolutePath());
}
}
makeVideo("file:\\" + file.getAbsolutePath(), imgLst);
}
public static void makeVideo(String fileName, Vector imgLst) throws MalformedURLException {
JpegImagesToMovie imageToMovie = new JpegImagesToMovie();
MediaLocator oml;
if ((oml = imageToMovie.createMediaLocator(fileName)) == null) {
System.err.println("Cannot build media locator from: " + fileName);
System.exit(0);
}
int interval = 40;
imageToMovie.doIt(720, 360, (1000 / interval), imgLst, oml);
}
}
Requirements:
Include jmf-2.1.1e.jar in your Library Folder (using this library)

How to traverse berkeley-db database in descending order of 'value'?

I have a Berkeley-db database where both 'key' and 'value' are of type integer. Is there any way to traverse the database in descending order of 'value'?
I'm using Berkeley-db je-5.0.58 API. The sample code that i'm using from its documentation is shown below.
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 2004-2010 Oracle. All rights reserved.
*
*/
package je;
import java.io.File;
import com.sleepycat.bind.tuple.IntegerBinding;
import com.sleepycat.je.Cursor;
import com.sleepycat.je.Database;
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseEntry;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
import com.sleepycat.je.LockMode;
import com.sleepycat.je.OperationStatus;
import com.sleepycat.je.Transaction;
/**
* SimpleExample creates a database environment, a database, and a database
* cursor, inserts and retrieves data.
*/
class SimpleExample {
private static final int EXIT_SUCCESS = 0;
private static final int EXIT_FAILURE = 1;
private int numRecords; // num records to insert or retrieve
private int offset; // where we want to start inserting
private boolean doInsert; // if true, insert, else retrieve
private File envDir;
public SimpleExample(int numRecords,
boolean doInsert,
File envDir,
int offset) {
this.numRecords = numRecords;
this.doInsert = doInsert;
this.envDir = envDir;
this.offset = offset;
}
/**
* Usage string
*/
public static void usage() {
System.out.println("usage: java " +
"je.SimpleExample " +
"<dbEnvHomeDirectory> " +
"<insert|retrieve> <numRecords> [offset]");
System.exit(EXIT_FAILURE);
}
/**
* Main
*/
public static void main(String argv[]) {
if (argv.length < 2) {
usage();
return;
}
File envHomeDirectory = new File(argv[0]);
boolean doInsertArg = false;
if (argv[1].equalsIgnoreCase("insert")) {
doInsertArg = true;
} else if (argv[1].equalsIgnoreCase("retrieve")) {
doInsertArg = false;
} else {
usage();
}
int startOffset = 0;
int numRecordsVal = 0;
if (doInsertArg) {
if (argv.length > 2) {
numRecordsVal = Integer.parseInt(argv[2]);
} else {
usage();
return;
}
if (argv.length > 3) {
startOffset = Integer.parseInt(argv[3]);
}
}
try {
SimpleExample app = new SimpleExample(numRecordsVal,
doInsertArg,
envHomeDirectory,
startOffset);
app.run();
} catch (DatabaseException e) {
e.printStackTrace();
System.exit(EXIT_FAILURE);
}
System.exit(EXIT_SUCCESS);
}
/**
* Insert or retrieve data
*/
public void run() throws DatabaseException {
/* Create a new, transactional database environment */
EnvironmentConfig envConfig = new EnvironmentConfig();
envConfig.setTransactional(true);
envConfig.setAllowCreate(true);
Environment exampleEnv = new Environment(envDir, envConfig);
/*
* Make a database within that environment
*
* Notice that we use an explicit transaction to
* perform this database open, and that we
* immediately commit the transaction once the
* database is opened. This is required if we
* want transactional support for the database.
* However, we could have used autocommit to
* perform the same thing by simply passing a
* null txn handle to openDatabase().
*/
Transaction txn = exampleEnv.beginTransaction(null, null);
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setTransactional(true);
dbConfig.setAllowCreate(true);
dbConfig.setSortedDuplicates(true);
Database exampleDb = exampleEnv.openDatabase(txn,
"simpleDb",
dbConfig);
txn.commit();
/*
* Insert or retrieve data. In our example, database records are
* integer pairs.
*/
/* DatabaseEntry represents the key and data of each record */
DatabaseEntry keyEntry = new DatabaseEntry();
DatabaseEntry dataEntry = new DatabaseEntry();
if (doInsert) {
/* put some data in */
for (int i = offset; i < numRecords + offset; i++) {
/*
* Note that autocommit mode, described in the Getting
* Started Guide, is an alternative to explicitly
* creating the transaction object.
*/
txn = exampleEnv.beginTransaction(null, null);
/* Use a binding to convert the int into a DatabaseEntry. */
IntegerBinding.intToEntry(i, keyEntry);
IntegerBinding.intToEntry(i+1, dataEntry);
OperationStatus status =
exampleDb.put(txn, keyEntry, dataEntry);
/*
* Note that put will throw a DatabaseException when
* error conditions are found such as deadlock.
* However, the status return conveys a variety of
* information. For example, the put might succeed,
* or it might not succeed if the record alread exists
* and the database was not configured for duplicate
* records.
*/
if (status != OperationStatus.SUCCESS) {
throw new RuntimeException("Data insertion got status " +
status);
}
txn.commit();
}
} else {
/* retrieve the data */
Cursor cursor = exampleDb.openCursor(null, null);
while (cursor.getNext(keyEntry, dataEntry, LockMode.DEFAULT) ==
OperationStatus.SUCCESS) {
System.out.println("key=" +
IntegerBinding.entryToInt(keyEntry) +
" data=" +
IntegerBinding.entryToInt(dataEntry));
}
cursor.close();
}
exampleDb.close();
exampleEnv.close();
}
}

you can use a custom comparator and use a cursor to traverse the data in descending order.
In java you have to implement a custom Comparator:
EDIT:
import java.util.Comparator;
import com.sleepycat.bind.tuple.IntegerBinding;
import com.sleepycat.je.DatabaseEntry;
public class IntegerSorter implements Comparator<byte[]>
{
#Override
public int compare(byte[] o1, byte[] o2)
{
return
IntegerBinding.entryToInt(new DatabaseEntry(o1)) -
IntegerBinding.entryToInt(new DatabaseEntry(o2));
}
}
(...)
dbConfig.setBtreeComparator(IntegerSorter.class);
(...)

Using JavaFileManager to compile projects

I'm currently creating a system that will allow the user to compile a single or multiple projects. I have been doing a bit of research and have decided to use the JavaCompilerAPI to do this. I have being playing around with it and have managed to get single java files compiling and a list of single java files compiling.
What i am not able to do is get a single java project compiling let alone a group of them. I read somewhere that you can use the JavaFileManager to do this and I have read up on it a bit but i am unable to find any examples of this so I'm stuck.
This is what i have done so far:
public List doCompilation(String sourceCode, String locationOfFile) {
List<String> compile = new ArrayList<>();
SimpleJavaFileObject fileObject = new DynamicJavaSourceCodeObject(locationOfFile, sourceCode);
JavaFileObject javaFileObjects[] = new JavaFileObject[]{fileObject};
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager stdFileManager = compiler.getStandardFileManager(null, Locale.getDefault(), null);
Iterable<? extends JavaFileObject> compilationUnits = Arrays.asList(javaFileObjects);
String[] compileOptions = new String[]{"-d", "C:/projects/Compiler/TempBINfolder/bin"};
Iterable<String> compilationOptions = Arrays.asList(compileOptions);
DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();
CompilationTask compilerTask = compiler.getTask(null, stdFileManager, diagnostics, compilationOptions, null, compilationUnits);
boolean status = compilerTask.call();
if (!status) {//If compilation error occurs
// Iterate through each compilation problem and print it
for (Diagnostic diagnostic : diagnostics.getDiagnostics()) {
compile.add(diagnostic.getKind().toString()+" on line "+ diagnostic.getLineNumber() +"\nIn file: \n"+ diagnostic.toString()+"\n\n");
}
}
try {
stdFileManager.close();//Close the file manager
} catch (IOException e) {
e.printStackTrace();
}
return compile;
}
Does anybody know how to do this?

try using shrinkwrap, it's very easy to use...

You could enumerate the files (and directories recursively, if desired) under the specified project directory and compile them one-by-one the way you do now.

You need to include the output directory in the compiler classpath. Notice how I include targetDirectory in the classpath below:
/**
* Compiles Java source-code.
* <p/>
* #author Gili Tzabari
*/
public final class JavaCompiler
{
private List<Path> sourcePath = new ArrayList<>();
private List<Path> classPath = new ArrayList<>();
private final Set<DebugType> debugOptions = new HashSet<>(Arrays.asList(DebugType.LINES,
DebugType.SOURCE, DebugType.VARIABLES));
/**
* Sets the compiler classpath.
* <p/>
* #param sourcePath the paths to search for the source format of dependent classes
* #throws NullPointerException if sourcePath is null
* #throws IllegalArgumentException if sourcePath refers to a non-existent path or a non-directory
* #return the JavaCompiler
*/
public JavaCompiler sourcePath(List<Path> sourcePath)
{
Preconditions.checkNotNull(sourcePath, "sourcePath may not be null");
for (Path path: sourcePath)
{
if (!Files.exists(path))
{
throw new IllegalArgumentException("sourcePath refers to non-existant path: " + path.
toAbsolutePath());
}
if (!Files.isDirectory(path))
{
throw new IllegalArgumentException("sourcePath refers to a non-directory: " + path.
toAbsolutePath());
}
}
this.sourcePath = ImmutableList.copyOf(sourcePath);
return this;
}
/**
* Sets the compiler classpath.
* <p/>
* #param classPath the paths to search for the compiled format of dependent classes
* #throws NullPointerException if classPath is null
* #throws IllegalArgumentException if classPath refers to a non-existent path
* #return the JavaCompiler
*/
public JavaCompiler classPath(List<Path> classPath)
{
Preconditions.checkNotNull(classPath, "classPath may not be null");
for (Path path: classPath)
{
if (!Files.exists(path))
{
throw new IllegalArgumentException("classPath refers to non-existant path: " + path.
toAbsolutePath());
}
}
this.classPath = ImmutableList.copyOf(classPath);
return this;
}
/**
* Indicates the kind of debugging information the generated files should contain.
* <p/>
* #param debugOptions the kind of debugging information the generated files should contain. By
* default all debugging information is generated.
* #return the JavaCompiler object
*/
public JavaCompiler debug(DebugType... debugOptions)
{
this.debugOptions.clear();
this.debugOptions.addAll(Arrays.asList(debugOptions));
return this;
}
/**
* Compiles the source code.
* <p/>
* #param sourceFiles the source files to compile
* #param targetDirectory the directory to compile into. This path included in the compiler
* classpath.
* #throws IllegalArgumentException if sourceFiles, targetDirectory are null; or if sourceFiles
* refers to a non-existent file or a non-file; or if targetDirectory is not a directory
* #throws CompilationException if the operation fails
*/
public void run(final Collection<Path> sourceFiles, final Path targetDirectory)
throws IllegalArgumentException, CompilationException
{
if (sourceFiles == null)
throw new IllegalArgumentException("sourceFiles may not be null");
if (sourceFiles.isEmpty())
return;
for (Path file: sourceFiles)
{
if (!Files.exists(file))
{
throw new IllegalArgumentException("sourceFiles refers to a non-existant file: "
+ file.toAbsolutePath());
}
if (!Files.isRegularFile(file))
{
throw new IllegalArgumentException("sourceFiles refers to a non-file: "
+ file.toAbsolutePath());
}
}
if (targetDirectory == null)
throw new IllegalArgumentException("targetDirectory may not be null");
if (!Files.exists(targetDirectory))
{
throw new IllegalArgumentException("targetDirectory must exist: " + targetDirectory.
toAbsolutePath());
}
if (!Files.isDirectory(targetDirectory))
{
throw new IllegalArgumentException("targetDirectory must be a directory: " + targetDirectory.
toAbsolutePath());
}
Set<Path> uniqueSourceFiles = ImmutableSet.copyOf(sourceFiles);
Set<Path> uniqueSourcePath = ImmutableSet.copyOf(sourcePath);
final javax.tools.JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
if (compiler == null)
{
throw new AssertionError("javax.tools.JavaCompiler is not available. Is tools.jar missing "
+ "from the classpath?");
}
final DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
final StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null,
null);
Iterable<? extends JavaFileObject> compilationUnits;
try
{
Set<File> modifiedFiles = getModifiedFiles(uniqueSourceFiles, uniqueSourcePath,
targetDirectory, new HashSet<Path>());
if (modifiedFiles.isEmpty())
return;
compilationUnits = fileManager.getJavaFileObjectsFromFiles(modifiedFiles);
}
catch (IOException e)
{
throw new CompilationException(e);
}
final List<Path> effectiveClasspath = new ArrayList<>();
effectiveClasspath.add(targetDirectory);
effectiveClasspath.addAll(classPath);
final List<String> options = new ArrayList<>();
options.add("-cp");
options.add(Joiner.on(File.pathSeparatorChar).join(effectiveClasspath));
final StringBuilder debugLine = new StringBuilder("-g:");
for (DebugType type: debugOptions)
{
switch (type)
{
case LINES:
{
debugLine.append("lines,");
break;
}
case SOURCE:
{
debugLine.append("source,");
break;
}
case VARIABLES:
{
debugLine.append("vars,");
break;
}
default:
throw new AssertionError(type);
}
}
if (!debugOptions.isEmpty())
{
debugLine.deleteCharAt(debugLine.length() - ",".length());
options.add(debugLine.toString());
}
if (!uniqueSourcePath.isEmpty())
{
options.add("-sourcepath");
options.add(Joiner.on(File.pathSeparatorChar).join(uniqueSourcePath));
}
options.add("-s");
options.add(targetDirectory.toString());
options.add("-d");
options.add(targetDirectory.toString());
final Writer output = null;
final CompilationTask task = compiler.getTask(output, fileManager, diagnostics, options, null,
compilationUnits);
final boolean result = task.call();
try
{
printDiagnostics(diagnostics, options, sourceFiles);
}
catch (IOException e)
{
throw new BuildException(e);
}
if (!result)
throw new CompilationException();
try
{
fileManager.close();
}
catch (IOException e)
{
throw new BuildException(e);
}
}
/**
* Returns the java source-code file corresponding to a class name.
* <p/>
* #param className the fully-qualified class name to look up
* #param sourcePath the source-code search path
* #return null if no match was found
*/
private static File getJavaSource(String className, Set<File> sourcePath)
{
// TODO: check for class files instead of source
for (File path: sourcePath)
{
File result = classNameToFile(path, className);
if (!result.exists())
continue;
return result;
}
return null;
}
/**
* Converts a class name to its source-code file.
* <p/>
* #param sourcePath the source-code search path
* #param className the fully-qualified class name
* #return the source-code file
*/
private static File classNameToFile(File sourcePath, String className)
{
return new File(sourcePath, className.replace(".", "/") + ".java");
}
/**
* Displays any compilation errors.
* <p/>
* #param diagnostics the compiler diagnostics
* #param options the command-line options passed to the compiler
* #param sourceFiles the source files to compile
* #throws IOException if an I/O error occurs
*/
private void printDiagnostics(final DiagnosticCollector<JavaFileObject> diagnostics,
final List<String> options, final Collection<Path> sourceFiles) throws IOException
{
Logger log = LoggerFactory.getLogger(JavaCompiler.class.getName() + ".stderr");
int errors = 0;
int warnings = 0;
boolean firstTime = true;
for (Diagnostic<? extends JavaFileObject> diagnostic: diagnostics.getDiagnostics())
{
if (firstTime)
{
firstTime = false;
StringBuilder message = new StringBuilder();
message.append("Invoking: javac ");
for (String token: options)
message.append(token).append(" ");
message.append(Joiner.on(" ").join(sourceFiles));
log.debug(message.toString());
}
JavaFileObject source = diagnostic.getSource();
if (source == null)
log.error(diagnostic.getMessage(null));
else
{
StringBuilder message = new StringBuilder();
message.append(source.getName());
if (diagnostic.getLineNumber() != Diagnostic.NOPOS)
message.append(":").append(diagnostic.getLineNumber());
message.append(": ").append(diagnostic.getMessage(null));
log.error(message.toString());
try (BufferedReader reader =
new BufferedReader(new InputStreamReader(source.openInputStream())))
{
String line = null;
for (long lineNumber = 0, size = diagnostic.getLineNumber(); lineNumber < size;
++lineNumber)
{
line = reader.readLine();
if (line == null)
break;
}
if (line != null)
{
log.error(line);
message = new StringBuilder();
for (long i = 1, size = diagnostic.getColumnNumber(); i < size; ++i)
message.append(" ");
message.append("^");
log.error(message.toString());
}
}
}
switch (diagnostic.getKind())
{
case ERROR:
{
++errors;
break;
}
case NOTE:
case OTHER:
case WARNING:
case MANDATORY_WARNING:
{
++warnings;
break;
}
default:
throw new AssertionError(diagnostic.getKind());
}
}
if (errors > 0)
{
StringBuilder message = new StringBuilder();
message.append(errors).append(" error");
if (errors > 1)
message.append("s");
log.error(message.toString());
}
if (warnings > 0)
{
StringBuilder message = new StringBuilder();
message.append(warnings).append(" warning");
if (warnings > 1)
message.append("s");
log.warn(message.toString());
}
}
/**
* Returns the source-code files that have been modified.
* <p/>
* #param sourceFiles the source files to process
* #param sourcePath the source file search path
* #param targetDirectory the directory to compile into
* #param unmodifiedFiles files that are known not to have been modified
* #return all changed source-code files that are accepted by the filter
* #throws IOException if an I/O error occurs
*/
private Set<File> getModifiedFiles(final Set<Path> sourceFiles,
final Set<Path> sourcePath, final Path targetDirectory, final Set<Path> unmodifiedFiles)
throws IOException
{
// TODO: Right now all files are assumed to have been modified
Set<File> result = new HashSet<>();
for (Path path: sourceFiles)
result.add(path.toFile());
return result;
}
/**
* Returns the command-line representation of the object.
* <p/>
* #param sourceFiles the source files to compile
* #param targetDirectory the directory to compile into
* #param sourcePath the source file search path
* #return the command-line representation of the object
* #throws IllegalArgumentException if the classpath contains non-file components
* #throws IOException if an I/O error occurs
*/
private List<String> toCommandLine(final Collection<Path> sourceFiles, final Path targetDirectory,
final Collection<Path> sourcePath)
throws IOException
{
final List<String> result = Lists.newArrayList("javac");
if (!classPath.isEmpty())
{
result.add("-cp");
try
{
final StringBuilder line = new StringBuilder();
for (final Iterator<Path> i = classPath.iterator(); i.hasNext();)
{
line.append(i.next().getParent().toString());
if (i.hasNext())
line.append(File.pathSeparatorChar);
}
result.add(line.toString());
}
catch (IllegalArgumentException e)
{
// Occurs if URL does not refer to a file
throw new IllegalStateException(e);
}
}
for (File javaFile: getModifiedFiles(ImmutableSet.copyOf(sourceFiles),
ImmutableSet.copyOf(sourcePath), targetDirectory, new HashSet<Path>()))
{
result.add(javaFile.getPath());
}
result.add("-d");
result.add(targetDirectory.getParent().toString());
return result;
}
#Override
public String toString()
{
return getClass().getName() + "[classPath=" + classPath + "]";
}
/**
* The type of debugging information that generated files may contain.
* <p/>
* #author Gili Tzabari
*/
#SuppressWarnings("PublicInnerClass")
public enum DebugType
{
/**
* No debugging information.
*/
NONE,
/**
* Line number information.
*/
LINES,
/**
* Local variable information.
*/
VARIABLES,
/**
* Source file information.
*/
SOURCE
}
}

A couple of questions about a music project in Java

I have a couple of questions about a school project I'm working on. The code is as follows.
public class Player
{
private PlayList playList;
private Track track;
private int tracksPlayed;
private int totalTrackTime;
private double averageTrackTime;
/**
* Constructor ...
*/
public Player()
{
playList = new PlayList("audio");
track = playList.getTrack(0);
this.tracksPlayed = tracksPlayed;
this.totalTrackTime = totalTrackTime;
this.averageTrackTime = averageTrackTime;
}
/**
* Return the track collection currently loaded in this player.
*/
public PlayList getPlayList()
{
return playList;
}
/**
*
*/
public void play()
{
track.play();
tracksPlayed++;
int trackDuration = track.getDuration();
totalTrackTime = totalTrackTime + trackDuration;
averageTrackTime = totalTrackTime / tracksPlayed;
}
/**
*
*/
public void stop()
{
track.stop();
}
/**
*
*/
public void setTrack(int trackNumber)
{
int currentTrack = trackNumber;
track = playList.getTrack(currentTrack);
}
/**
*
*/
public String getTrackName()
{
String currentTrack = track.getName();
return currentTrack;
}
/**
*
*/
public String getTrackInfo()
{
String currentTrack = track.getName();
int trackDuration = track.getDuration();
return currentTrack + " " + "(" + trackDuration + ")";
}
/**
*
*/
public int getNumberOfTracksPlayed()
{
return tracksPlayed;
}
/**
*
*/
public int getTotalPlayedTrackLength()
{
return totalTrackTime;
}
/**
*
*/
public double averageTrackLength()
{
return averageTrackTime;
}
}
public class Track
{
private Clip soundClip;
private String name;
/**
* Create a track from an audio file.
*/
public Track(File soundFile)
{
soundClip = loadSound(soundFile);
name = soundFile.getName();
}
/**
* Play this sound track. (The sound will play asynchronously, until
* it is stopped or reaches the end.)
*/
public void play()
{
if(soundClip != null) {
soundClip.start();
}
}
/**
* Stop this track playing. (This method has no effect if the track is not
* currently playing.)
*/
public void stop()
{
if(soundClip != null) {
soundClip.stop();
}
}
/**
* Reset this track to its start.
*/
public void rewind()
{
if(soundClip != null) {
soundClip.setFramePosition(0);
}
}
/**
* Return the name of this track.
*/
public String getName()
{
return name;
}
/**
* Return the duration of this track, in seconds.
*/
public int getDuration()
{
if (soundClip == null) {
return 0;
}
else {
return (int) soundClip.getMicrosecondLength()/1000000;
}
}
/**
* Set the playback volume of the current track.
*
* #param vol Volume level as a percentage (0..100).
*/
public void setVolume(int vol)
{
if(soundClip == null) {
return;
}
if(vol < 0 || vol > 100) {
vol = 100;
}
double val = vol / 100.0;
try {
FloatControl volControl =
(FloatControl) soundClip.getControl(FloatControl.Type.MASTER_GAIN);
float dB = (float)(Math.log(val == 0.0 ? 0.0001 : val) / Math.log(10.0) * 20.0);
volControl.setValue(dB);
} catch (Exception ex) {
System.err.println("Error: could not set volume");
}
}
/**
* Return true if this track has successfully loaded and can be played.
*/
public boolean isValid()
{
return soundClip != null;
}
/**
* Load the sound file supplied by the parameter.
*
* #return The sound clip if successful, null if the file could not be decoded.
*/
private Clip loadSound(File file)
{
Clip newClip;
try {
AudioInputStream stream = AudioSystem.getAudioInputStream(file);
AudioFormat format = stream.getFormat();
// we cannot play ALAW/ULAW, so we convert them to PCM
//
if ((format.getEncoding() == AudioFormat.Encoding.ULAW) ||
(format.getEncoding() == AudioFormat.Encoding.ALAW))
{
AudioFormat tmp = new AudioFormat(
AudioFormat.Encoding.PCM_SIGNED,
format.getSampleRate(),
format.getSampleSizeInBits() * 2,
format.getChannels(),
format.getFrameSize() * 2,
format.getFrameRate(),
true);
stream = AudioSystem.getAudioInputStream(tmp, stream);
format = tmp;
}
DataLine.Info info = new DataLine.Info(Clip.class,
stream.getFormat(),
((int) stream.getFrameLength() *
format.getFrameSize()));
newClip = (Clip) AudioSystem.getLine(info);
newClip.open(stream);
return newClip;
} catch (Exception ex) {
return null;
}
}
}
public class PlayList
{
private List<Track> tracks;
/**
* Constructor for objects of class TrackCollection
*/
public PlayList(String directoryName)
{
tracks = loadTracks(directoryName);
}
/**
* Return a track from this collection.
*/
public Track getTrack(int trackNumber)
{
return tracks.get(trackNumber);
}
/**
* Return the number of tracks in this collection.
*/
public int numberOfTracks()
{
return tracks.size();
}
/**
* Load the file names of all files in the given directory.
* #param dirName Directory (folder) name.
* #param suffix File suffix of interest.
* #return The names of files found.
*/
private List<Track> loadTracks(String dirName)
{
File dir = new File(dirName);
if(dir.isDirectory()) {
File[] allFiles = dir.listFiles();
List<Track> foundTracks = new ArrayList<Track>();
for(File file : allFiles) {
//System.out.println("found: " + file);
Track track = new Track(file);
if(track.isValid()) {
foundTracks.add(track);
}
}
return foundTracks;
}
else {
System.err.println("Error: " + dirName + " must be a directory");
return null;
}
}
/**
* Return this playlist as an array of strings with the track names.
*/
public String[] asStrings()
{
String[] names = new String[tracks.size()];
int i = 0;
for(Track track : tracks) {
names[i++] = track.getName();
}
return names;
}
}
I understand that to call the play methods in the player class, I have to initialize a Track class variable. I also need to initialize it using the PlayList getTrack method. However, how can I initialize it without defining a starting index variable (i.e I don't want it to automatically initialize to a specific song in the index, I want the user to have to select a song first)?
Also, how do I code the play method in the player class to stop a existing song if one is playing before starting a new song and to restart a song if the play method is called again one the same song?

1.
how can I initialize it without defining a starting index variable
public Player (int initTrack){
...
track = playList.getTrack(initTrack);
...
}
2.
You should try with a field storing the track that it is currently playing!

Develop Reference

Java is a programming language and computing platform first released by Sun Microsystems in 1995.

Sorting Java case statements - java

Related

Send all contacts to mail as CSV file using Android code

How to encode images into a video file in Java through programming?

How to traverse berkeley-db database in descending order of 'value'?

Using JavaFileManager to compile projects

A couple of questions about a music project in Java

Categories

Resources