package com.ximple.io.dgn7;
|
|
import com.ximple.util.DgnUtility;
|
import org.apache.log4j.LogManager;
|
import org.apache.log4j.Logger;
|
|
import java.io.EOFException;
|
import java.io.IOException;
|
import java.nio.ByteBuffer;
|
import java.nio.ByteOrder;
|
import java.nio.MappedByteBuffer;
|
import java.nio.ShortBuffer;
|
import java.nio.channels.FileChannel;
|
import java.nio.channels.ReadableByteChannel;
|
import java.nio.channels.WritableByteChannel;
|
|
public class Dgn7fileWriter {
|
private static final Logger logger = LogManager.getLogger(Dgn7fileWriter.class);
|
|
private Dgn7fileHeader header;
|
private FileChannel channel;
|
ByteBuffer buffer;
|
private ElementType fileElementType = ElementType.UNDEFINED;
|
private ByteBuffer headerTransfer;
|
private final Element.FileRecord record = new Element.FileRecord();
|
private final boolean randomAccessEnabled;
|
private Lock lock;
|
private boolean useMemoryMappedBuffer;
|
private long currentOffset = 0L;
|
private StreamLogging streamLogger = new StreamLogging("Dgn7 Writer");
|
private int maxElementId = 0;
|
|
public Dgn7fileWriter(FileChannel channel, boolean strict, boolean useMemoryMapped, Lock lock)
|
throws IOException, Dgn7fileException {
|
this.channel = channel;
|
this.useMemoryMappedBuffer = useMemoryMapped;
|
streamLogger.open();
|
randomAccessEnabled = channel instanceof FileChannel;
|
this.lock = lock;
|
lock.lockRead();
|
lock.lockWrite();
|
// init(strict);
|
}
|
|
public Dgn7fileWriter(FileChannel channel, Lock lock) throws IOException, Dgn7fileException {
|
this(channel, true, true, lock);
|
}
|
|
protected boolean hasNext() throws IOException {
|
// mark current position
|
int position = buffer.position();
|
|
// ensure the proper position, regardless of read or handler behavior
|
try {
|
buffer.position(this.toBufferOffset(record.end));
|
} catch (IllegalArgumentException e) {
|
logger.warn("position=" + this.toBufferOffset(record.end), e);
|
|
return false;
|
}
|
|
// no more data left
|
if (buffer.remaining() < 4) {
|
return false;
|
}
|
|
// looks good
|
boolean hasNext = true;
|
short type = buffer.getShort();
|
|
if (type == -1) {
|
hasNext = false;
|
}
|
|
// reset things to as they were
|
buffer.position(position);
|
|
return hasNext;
|
}
|
|
protected Element.FileRecord nextElement() throws IOException, Dgn7fileException {
|
// need to update position
|
buffer.position(this.toBufferOffset(record.end));
|
|
// record header is big endian
|
buffer.order(ByteOrder.LITTLE_ENDIAN);
|
|
// read shape record header
|
int recordNumber = ++maxElementId;
|
short signature = buffer.getShort();
|
|
// byte type = (byte) (buffer.get() & 0x7f);
|
byte type = (byte) ((signature >>> 8) & 0x007f);
|
|
// silly Bentley say contentLength is in 2-byte words
|
// and ByteByffer uses bytes.
|
// track the record location
|
int elementLength = (buffer.getShort() * 2) + 4;
|
|
if (!buffer.isReadOnly() && !useMemoryMappedBuffer) {
|
// capacity is less than required for the record
|
// copy the old into the newly allocated
|
if (buffer.capacity() < elementLength) {
|
this.currentOffset += buffer.position();
|
|
ByteBuffer old = buffer;
|
|
// ensure enough capacity for one more record header
|
buffer = Dgn7fileReader.ensureCapacity(buffer, elementLength, useMemoryMappedBuffer);
|
buffer.put(old);
|
fill(buffer, channel);
|
buffer.position(0);
|
} else
|
|
// remaining is less than record length
|
// compact the remaining data and read again,
|
// allowing enough room for one more record header
|
if (buffer.remaining() < elementLength) {
|
this.currentOffset += buffer.position();
|
buffer.compact();
|
fill(buffer, channel);
|
buffer.position(0);
|
}
|
}
|
|
// shape record is all little endian
|
// buffer.order(ByteOrder.LITTLE_ENDIAN);
|
// read the type, handlers don't need it
|
ElementType recordType = ElementType.forID(type);
|
|
logger.debug("nextElement at " + this.toBufferOffset(record.end) + ":type=" + type);
|
|
// this usually happens if the handler logic is bunk,
|
// but bad files could exist as well...
|
|
/*
|
* if (recordType != ElementType.NULL && recordType != fileElementType)
|
* {
|
* throw new IllegalStateException("ShapeType changed illegally from " + fileElementType + " to " + recordType);
|
* }
|
*/
|
|
// peek at bounds, then reset for handler
|
// many handler's may ignore bounds reading, but we don't want to
|
// second guess them...
|
buffer.mark();
|
|
if (recordType.isMultiPoint()) {
|
int lowCoorX = buffer.getInt();
|
|
lowCoorX = DgnUtility.convertFromDGN(lowCoorX);
|
record.minX = DgnUtility.converUnitToCoord(lowCoorX);
|
|
int lowCoorY = buffer.getInt();
|
|
lowCoorY = DgnUtility.convertFromDGN(lowCoorY);
|
record.minY = DgnUtility.converUnitToCoord(lowCoorY);
|
|
int lowCoorZ = buffer.getInt();
|
|
lowCoorZ = DgnUtility.convertFromDGN(lowCoorZ);
|
record.minZ = DgnUtility.converUnitToCoord(lowCoorZ);
|
|
int highCoorX = buffer.getInt();
|
|
highCoorX = DgnUtility.convertFromDGN(highCoorX);
|
record.maxX = DgnUtility.converUnitToCoord(highCoorX);
|
|
int highCoorY = buffer.getInt();
|
|
highCoorY = DgnUtility.convertFromDGN(highCoorY);
|
record.maxY = DgnUtility.converUnitToCoord(highCoorY);
|
|
int highCoorZ = buffer.getInt();
|
|
highCoorZ = DgnUtility.convertFromDGN(highCoorZ);
|
record.maxZ = DgnUtility.converUnitToCoord(highCoorZ);
|
}
|
|
buffer.reset();
|
record.offset = record.end;
|
|
// update all the record info.
|
record.length = elementLength;
|
record.signature = signature;
|
record.number = recordNumber;
|
record.buffer = buffer;
|
|
// remember, we read one int already...
|
record.end = this.toFileOffset(buffer.position()) + elementLength - 4;
|
// record.end = this.toFileOffset(buffer.position()) + elementLength;
|
|
// mark this position for the reader
|
record.start = buffer.position();
|
|
// clear any cached record
|
record.handler = recordType.getElementHandler();
|
record.element = null;
|
|
return record;
|
}
|
|
private void init(boolean strict) throws IOException, Dgn7fileException {
|
header = readHeader(channel, strict);
|
|
if (useMemoryMappedBuffer) {
|
FileChannel fc = channel;
|
|
buffer = fc.map(FileChannel.MapMode.READ_WRITE, 0, fc.size());
|
|
// buffer.position(100);
|
buffer.position(header.size());
|
this.currentOffset = 0;
|
} else {
|
// force useMemoryMappedBuffer to false
|
this.useMemoryMappedBuffer = false;
|
|
// start with 8K buffer
|
buffer = ByteBuffer.allocateDirect(8 * 1024);
|
fill(buffer, channel);
|
buffer.flip();
|
this.currentOffset = header.size();
|
}
|
|
headerTransfer = ByteBuffer.allocate(4);
|
headerTransfer.order(ByteOrder.LITTLE_ENDIAN);
|
|
// make sure the record end is set now...
|
record.end = toFileOffset(buffer.position());
|
}
|
|
public static Dgn7fileHeader readHeader(FileChannel channel, boolean strict) throws IOException {
|
ByteBuffer buffer = ByteBuffer.allocateDirect(4);
|
|
if (fill(buffer, channel) == -1) {
|
throw new EOFException("Premature end of header");
|
}
|
|
buffer.order(ByteOrder.LITTLE_ENDIAN);
|
|
int length = buffer.getShort(2) * 2;
|
ByteBuffer old = buffer;
|
|
old.position(0);
|
|
// ensure enough capacity for one more record header
|
buffer = ByteBuffer.allocateDirect(length + 4);
|
buffer.put(old);
|
|
if (fill(buffer, channel) == -1) {
|
throw new EOFException("Premature end of header");
|
}
|
|
buffer.position(0);
|
|
Dgn7fileHeader header = new Dgn7fileHeader();
|
|
header.read(buffer, strict);
|
|
return header;
|
}
|
|
protected static int fill(ByteBuffer buffer, FileChannel channel) throws IOException {
|
int r = buffer.remaining();
|
|
// channel reads return -1 when EOF or other error
|
// because they a non-blocking reads, 0 is a valid return value!!
|
while ((buffer.remaining() > 0) && (r != -1)) {
|
r = channel.read(buffer);
|
}
|
|
if (r == -1) {
|
buffer.limit(buffer.position());
|
}
|
|
return r;
|
}
|
|
private void allocateBuffers() {
|
buffer = ByteBuffer.allocateDirect(16 * 1024);
|
}
|
|
private void checkShapeBuffer(int size) {
|
if (buffer.capacity() < size) {
|
if (buffer != null)
|
NIOUtilities.clean(buffer);
|
buffer = ByteBuffer.allocateDirect(size);
|
}
|
}
|
|
private void drain() throws IOException {
|
buffer.flip();
|
while (buffer.remaining() > 0)
|
channel.write(buffer);
|
buffer.flip().limit(buffer.capacity());
|
}
|
|
private int toBufferOffset(int offset) {
|
return (int) (offset - currentOffset);
|
}
|
|
private int toFileOffset(int offset) {
|
return (int) (currentOffset + offset);
|
}
|
|
public void writeElement(Element element) throws IOException {
|
if (element == null) return;
|
if (element.getElementType().isComplexElement()) {
|
writeTo(element);
|
ComplexElement complexElement = (ComplexElement) element;
|
for (Element component : complexElement) {
|
writeTo(component);
|
}
|
} else {
|
writeTo(element);
|
}
|
}
|
|
private void writeTo(Element element) throws IOException {
|
ByteBuffer writeBuffer = ByteBuffer.allocateDirect(element.raw.length * 2);
|
writeBuffer.order(ByteOrder.LITTLE_ENDIAN);
|
for (short word : element.raw) {
|
writeBuffer.putShort(word);
|
}
|
writeBuffer.rewind();
|
|
channel.write(writeBuffer);
|
}
|
|
|
|
public void toEnd() throws IOException, Dgn7fileException {
|
while (hasNext()) {
|
nextElement();
|
}
|
}
|
|
public void close() throws IOException {
|
lock.unlockWrite();
|
lock.unlockRead();
|
|
if (channel.isOpen()) {
|
channel.close();
|
streamLogger.close();
|
}
|
|
if (buffer instanceof MappedByteBuffer) {
|
NIOUtilities.clean(buffer);
|
}
|
|
channel = null;
|
header = null;
|
}
|
|
public void writeEOF() throws IOException {
|
ByteBuffer writeBuffer = ByteBuffer.allocateDirect(2);
|
writeBuffer.order(ByteOrder.LITTLE_ENDIAN);
|
writeBuffer.putShort((short) -1);
|
channel.write(writeBuffer);
|
|
}
|
}
|
