activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r1393764 - in /activemq/activemq-cpp/trunk/activemq-cpp/src/main: activemq/transport/tcp/TcpTransport.cpp decaf/io/BufferedInputStream.cpp decaf/io/BufferedOutputStream.cpp
Date Wed, 03 Oct 2012 21:02:44 GMT
Author: tabish
Date: Wed Oct  3 21:02:44 2012
New Revision: 1393764

URL: http://svn.apache.org/viewvc?rev=1393764&view=rev
Log:
Polish up some of the code a bit, better destructor impls.

Modified:
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/activemq/transport/tcp/TcpTransport.cpp
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedInputStream.cpp
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedOutputStream.cpp

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/activemq/transport/tcp/TcpTransport.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/activemq/transport/tcp/TcpTransport.cpp?rev=1393764&r1=1393763&r2=1393764&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/activemq/transport/tcp/TcpTransport.cpp
(original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/activemq/transport/tcp/TcpTransport.cpp
Wed Oct  3 21:02:44 2012
@@ -42,19 +42,15 @@ using namespace decaf::lang;
 using namespace decaf::lang::exceptions;
 
 ////////////////////////////////////////////////////////////////////////////////
-TcpTransport::TcpTransport( const Pointer<Transport>& next ) :
+TcpTransport::TcpTransport(const Pointer<Transport>& next) :
     TransportFilter(next), connectTimeout(0), closed(false), socket(), dataInputStream(),
dataOutputStream() {
-
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 TcpTransport::~TcpTransport() {
-
     try {
         close();
     }
-    AMQ_CATCH_NOTHROW( ActiveMQException )
-    AMQ_CATCH_NOTHROW( Exception )
     AMQ_CATCHALL_NOTHROW()
 }
 
@@ -66,58 +62,52 @@ void TcpTransport::close() {
         this->closed = true;
 
         // Close the socket.
-        if( socket.get() != NULL ) {
+        if (socket.get() != NULL) {
             socket->close();
         }
 
         // Invoke the paren't close first.
         TransportFilter::close();
     }
-    AMQ_CATCH_RETHROW( IOException )
-    AMQ_CATCH_EXCEPTION_CONVERT( Exception, IOException )
-    AMQ_CATCHALL_THROW( IOException )
+    AMQ_CATCH_RETHROW( IOException)
+    AMQ_CATCH_EXCEPTION_CONVERT( Exception, IOException)
+    AMQ_CATCHALL_THROW( IOException)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void TcpTransport::connect( const decaf::net::URI& uri,
-                            const decaf::util::Properties& properties ) {
+void TcpTransport::connect(const decaf::net::URI& uri, const decaf::util::Properties&
properties) {
 
     try {
 
-        socket.reset( this->createSocket() );
+        socket.reset(this->createSocket());
 
         // Set all Socket Options from the URI options.
-        this->configureSocket( socket.get(), properties );
+        this->configureSocket(socket.get(), properties);
 
         // Ensure something is actually passed in for the URI
-        if( uri.getAuthority() == "" ) {
-            throw SocketException( __FILE__, __LINE__,
-                "Connection URI was not provided or is invalid: %s", uri.toString().c_str()
);
+        if (uri.getAuthority() == "") {
+            throw SocketException(__FILE__, __LINE__, "Connection URI was not provided or
is invalid: %s", uri.toString().c_str());
         }
 
         // Connect the socket.
         string host = uri.getHost();
         int port = uri.getPort();
 
-        socket->connect( host, port, connectTimeout );
+        socket->connect(host, port, connectTimeout);
 
         // Cast it to an IO transport so we can wire up the socket
         // input and output streams.
-        IOTransport* ioTransport = dynamic_cast<IOTransport*>( next.get() );
-        if( ioTransport == NULL ){
-            throw ActiveMQException(
-                __FILE__, __LINE__,
-                "TcpTransport::TcpTransport - "
-                "transport must be of type IOTransport");
+        IOTransport* ioTransport = dynamic_cast<IOTransport*>(next.get());
+        if (ioTransport == NULL) {
+            throw ActiveMQException(__FILE__, __LINE__, "TcpTransport::TcpTransport - "
+                    "transport must be of type IOTransport");
         }
 
         // Get the read buffer size.
-        int inputBufferSize = Integer::parseInt(
-            properties.getProperty( "inputBufferSize", "8192" ) );
+        int inputBufferSize = Integer::parseInt(properties.getProperty("inputBufferSize",
"8192"));
 
         // Get the write buffer size.
-        int outputBufferSize = Integer::parseInt(
-            properties.getProperty( "outputBufferSize", "8192" ) );
+        int outputBufferSize = Integer::parseInt(properties.getProperty("outputBufferSize",
"8192"));
 
         Pointer<InputStream> inputStream(socket->getInputStream());
         Pointer<OutputStream> outputStream(socket->getOutputStream());
@@ -144,12 +134,12 @@ void TcpTransport::connect( const decaf:
         this->dataOutputStream.reset(new DataOutputStream(outputStream.release(), true));
 
         // Give the IOTransport the streams.
-        ioTransport->setInputStream( dataInputStream.get() );
-        ioTransport->setOutputStream( dataOutputStream.get() );
+        ioTransport->setInputStream(dataInputStream.get());
+        ioTransport->setOutputStream(dataOutputStream.get());
     }
-    AMQ_CATCH_RETHROW( ActiveMQException )
-    AMQ_CATCH_EXCEPTION_CONVERT( Exception, ActiveMQException )
-    AMQ_CATCHALL_THROW( ActiveMQException )
+    AMQ_CATCH_RETHROW( ActiveMQException)
+    AMQ_CATCH_EXCEPTION_CONVERT( Exception, ActiveMQException)
+    AMQ_CATCHALL_THROW( ActiveMQException)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -159,59 +149,53 @@ Socket* TcpTransport::createSocket() {
         SocketFactory* factory = SocketFactory::getDefault();
         return factory->createSocket();
     }
-    DECAF_CATCH_RETHROW( IOException )
-    DECAF_CATCH_EXCEPTION_CONVERT( Exception, IOException )
-    DECAF_CATCHALL_THROW( IOException )
+    DECAF_CATCH_RETHROW( IOException)
+    DECAF_CATCH_EXCEPTION_CONVERT( Exception, IOException)
+    DECAF_CATCHALL_THROW( IOException)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void TcpTransport::configureSocket( Socket* socket, const Properties& properties ) {
+void TcpTransport::configureSocket(Socket* socket, const Properties& properties) {
 
     try {
 
         // Get the linger flag.
-        int soLinger = Integer::parseInt(
-            properties.getProperty( "soLinger", "-1" ) );
+        int soLinger = Integer::parseInt(properties.getProperty("soLinger", "-1"));
 
         // Get the keepAlive flag.
-        bool soKeepAlive = Boolean::parseBoolean(
-            properties.getProperty( "soKeepAlive", "false" ) );
+        bool soKeepAlive = Boolean::parseBoolean(properties.getProperty("soKeepAlive", "false"));
 
         // Get the socket receive buffer size.
-        int soReceiveBufferSize = Integer::parseInt(
-            properties.getProperty( "soReceiveBufferSize", "-1" ) );
+        int soReceiveBufferSize = Integer::parseInt(properties.getProperty("soReceiveBufferSize",
"-1"));
 
         // Get the socket send buffer size.
-        int soSendBufferSize = Integer::parseInt(
-            properties.getProperty( "soSendBufferSize", "-1" ) );
+        int soSendBufferSize = Integer::parseInt(properties.getProperty("soSendBufferSize",
"-1"));
 
         // Get the socket TCP_NODELAY flag.
-        bool tcpNoDelay = Boolean::parseBoolean(
-            properties.getProperty( "tcpNoDelay", "true" ) );
+        bool tcpNoDelay = Boolean::parseBoolean(properties.getProperty("tcpNoDelay", "true"));
 
         // Get the socket connect timeout in microseconds. (default to infinite wait).
-        this->connectTimeout = Integer::parseInt(
-            properties.getProperty( "soConnectTimeout", "0" ) );
+        this->connectTimeout = Integer::parseInt(properties.getProperty("soConnectTimeout",
"0"));
 
         // Set the socket options.
-        socket->setKeepAlive( soKeepAlive );
-        socket->setTcpNoDelay( tcpNoDelay );
+        socket->setKeepAlive(soKeepAlive);
+        socket->setTcpNoDelay(tcpNoDelay);
 
-        if( soLinger > 0 ) {
-            socket->setSoLinger( true, soLinger );
+        if (soLinger > 0) {
+            socket->setSoLinger(true, soLinger);
         }
 
-        if( soReceiveBufferSize > 0 ){
-            socket->setReceiveBufferSize( soReceiveBufferSize );
+        if (soReceiveBufferSize > 0) {
+            socket->setReceiveBufferSize(soReceiveBufferSize);
         }
 
-        if( soSendBufferSize > 0 ){
-            socket->setSendBufferSize( soSendBufferSize );
+        if (soSendBufferSize > 0) {
+            socket->setSendBufferSize(soSendBufferSize);
         }
     }
-    DECAF_CATCH_RETHROW( NullPointerException )
-    DECAF_CATCH_RETHROW( IllegalArgumentException )
-    DECAF_CATCH_RETHROW( SocketException )
-    DECAF_CATCH_EXCEPTION_CONVERT( Exception, SocketException )
-    DECAF_CATCHALL_THROW( SocketException )
+    DECAF_CATCH_RETHROW( NullPointerException)
+    DECAF_CATCH_RETHROW( IllegalArgumentException)
+    DECAF_CATCH_RETHROW( SocketException)
+    DECAF_CATCH_EXCEPTION_CONVERT( Exception, SocketException)
+    DECAF_CATCHALL_THROW( SocketException)
 }

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedInputStream.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedInputStream.cpp?rev=1393764&r1=1393763&r2=1393764&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedInputStream.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedInputStream.cpp Wed
Oct  3 21:02:44 2012
@@ -28,21 +28,16 @@ using namespace decaf::lang;
 using namespace decaf::lang::exceptions;
 
 ////////////////////////////////////////////////////////////////////////////////
-BufferedInputStream::BufferedInputStream( InputStream* stream, bool own ) :
-    FilterInputStream( stream, own ),
-    pos(0), count(0), markLimit(-1), markPos(-1), bufferSize(8192),
-    buff( new unsigned char[bufferSize] ), proxyBuffer( buff ) {
-
+BufferedInputStream::BufferedInputStream(InputStream* stream, bool own) :
+    FilterInputStream(stream, own), pos(0), count(0), markLimit(-1), markPos(-1), bufferSize(8192),
buff(new unsigned char[bufferSize]), proxyBuffer(buff) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-BufferedInputStream::BufferedInputStream( InputStream* stream, int bufferSize, bool own )
:
-        FilterInputStream( stream, own ),
-        pos(0), count(0), markLimit(-1), markPos(-1), bufferSize(bufferSize), buff(NULL),
proxyBuffer(NULL) {
+BufferedInputStream::BufferedInputStream(InputStream* stream, int bufferSize, bool own) :
+    FilterInputStream(stream, own), pos(0), count(0), markLimit(-1), markPos(-1), bufferSize(bufferSize),
buff(NULL), proxyBuffer(NULL) {
 
-    if( bufferSize < 0 ) {
-        throw new IllegalArgumentException(
-            __FILE__, __LINE__, "Size must be greater than zero");
+    if (bufferSize < 0) {
+        throw new IllegalArgumentException(__FILE__, __LINE__, "Size must be greater than
zero");
     }
 
     this->buff = new unsigned char[bufferSize];
@@ -51,41 +46,42 @@ BufferedInputStream::BufferedInputStream
 
 ////////////////////////////////////////////////////////////////////////////////
 BufferedInputStream::~BufferedInputStream() {
-    try{
+    try {
         this->close();
-        delete [] this->buff;
     }
-    DECAF_CATCH_NOTHROW( IOException )
     DECAF_CATCHALL_NOTHROW()
+
+    delete[] this->buff;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void BufferedInputStream::close() {
 
-    // let parent close the inputStream
-    FilterInputStream::close();
-
-    // Clear the proxy to the buffer, but don't actually delete the buffer yet since
-    // other methods holding onto the buffer while blocked.
-    this->proxyBuffer = NULL;
+    try {
+        // let parent close the inputStream
+        FilterInputStream::close();
+
+        // Clear the proxy to the buffer, but don't actually delete the buffer yet since
+        // other methods holding onto the buffer while blocked.
+        this->proxyBuffer = NULL;
+    }
+    DECAF_CATCH_RETHROW( IOException )
+    DECAF_CATCHALL_THROW( IOException )
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 int BufferedInputStream::available() const {
 
-    if( this->proxyBuffer == NULL || this->isClosed() ) {
-        throw IOException(
-            __FILE__, __LINE__,
-            "BufferedInputStream::available - Buffer was closed");
+    if (this->proxyBuffer == NULL || this->isClosed()) {
+        throw IOException(__FILE__, __LINE__, "BufferedInputStream::available - Buffer was
closed");
     }
 
-    return ( this->count - this->pos ) + inputStream->available();
+    return (this->count - this->pos) + inputStream->available();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void BufferedInputStream::mark( int readLimit ) {
-
-    if( this->proxyBuffer != NULL ) {
+void BufferedInputStream::mark(int readLimit) {
+    if (this->proxyBuffer != NULL) {
         this->markLimit = readLimit;
         this->markPos = this->pos;
     }
@@ -94,16 +90,12 @@ void BufferedInputStream::mark( int read
 ////////////////////////////////////////////////////////////////////////////////
 void BufferedInputStream::reset() {
 
-    if( this->proxyBuffer == NULL ) {
-        throw IOException(
-            __FILE__, __LINE__,
-            "BufferedInputStream::reset - This stream has been closed." );
+    if (this->proxyBuffer == NULL) {
+        throw IOException(__FILE__, __LINE__, "BufferedInputStream::reset - This stream has
been closed.");
     }
 
-    if( this->markPos == -1 ) {
-        throw IOException(
-            __FILE__, __LINE__,
-            "BufferedInputStream::reset - The mark position was invalidated." );
+    if (this->markPos == -1) {
+        throw IOException(__FILE__, __LINE__, "BufferedInputStream::reset - The mark position
was invalidated.");
     }
 
     this->pos = this->markPos;
@@ -112,79 +104,70 @@ void BufferedInputStream::reset() {
 ////////////////////////////////////////////////////////////////////////////////
 int BufferedInputStream::doReadByte() {
 
-    try{
+    try {
 
         // Use a local reference in case of unsynchronized close.
         InputStream* inputStream = this->inputStream;
         unsigned char* buffer = this->proxyBuffer;
 
-        if( isClosed() || buffer == NULL ){
-            throw IOException(
-                __FILE__, __LINE__,
-                "BufferedInputStream::bufferData - Stream is closed" );
+        if (isClosed() || buffer == NULL) {
+            throw IOException(__FILE__, __LINE__, "BufferedInputStream::bufferData - Stream
is closed");
         }
 
         // Are there buffered bytes available?  Or can we read more?
-        if( this->pos >= this->count && bufferData( inputStream, buffer
) == -1 ) {
+        if (this->pos >= this->count && bufferData(inputStream, buffer)
== -1) {
             return -1;
         }
 
         // Stream might have closed while we were buffering.
-        if( isClosed() ) {
-            throw IOException(
-                __FILE__, __LINE__,
-                "BufferedInputStream::bufferData - Stream is closed" );
+        if (isClosed()) {
+            throw IOException(__FILE__, __LINE__, "BufferedInputStream::bufferData - Stream
is closed");
         }
 
-        if( this->pos != this->count ) {
+        if (this->pos != this->count) {
             return buffer[this->pos++];;
         }
 
         return -1;
     }
-    DECAF_CATCH_RETHROW( IOException )
-    DECAF_CATCHALL_THROW( IOException )
+    DECAF_CATCH_RETHROW( IOException)
+    DECAF_CATCHALL_THROW( IOException)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-int BufferedInputStream::doReadArrayBounded( unsigned char* buffer, int size, int offset,
int length ) {
+int BufferedInputStream::doReadArrayBounded(unsigned char* buffer, int size, int offset,
int length) {
 
-    try{
+    try {
 
         // Use a local reference in case of unsynchronized close.
         unsigned char* lbuffer = this->proxyBuffer;
 
-        if( lbuffer == NULL ){
-            throw IOException(
-                __FILE__, __LINE__, "Stream is closed" );
+        if (lbuffer == NULL) {
+            throw IOException(__FILE__, __LINE__, "Stream is closed");
         }
 
-        if( buffer == NULL ) {
-            throw NullPointerException(
-                __FILE__, __LINE__, "Buffer passed was NULL." );
+        if (buffer == NULL) {
+            throw NullPointerException(__FILE__, __LINE__, "Buffer passed was NULL.");
         }
 
-        if( offset > size || offset < 0 ) {
-            throw IndexOutOfBoundsException(
-                __FILE__, __LINE__, "offset parameter out of Bounds: %d.", offset );
+        if (offset > size || offset < 0) {
+            throw IndexOutOfBoundsException(__FILE__, __LINE__, "offset parameter out of
Bounds: %d.", offset);
         }
 
-        if( length < 0 || length > size - offset ) {
-            throw IndexOutOfBoundsException(
-                __FILE__, __LINE__, "length parameter out of Bounds: %d.", length );
+        if (length < 0 || length > size - offset) {
+            throw IndexOutOfBoundsException(__FILE__, __LINE__, "length parameter out of
Bounds: %d.", length);
         }
 
         // For zero, do nothing
-        if( length == 0 ) {
+        if (length == 0) {
             return 0;
         }
 
         // Use a local reference in case of unsynchronized close.
         InputStream* inputStream = this->inputStream;
 
-        if( inputStream == NULL ){
-            throw IOException(
-                __FILE__, __LINE__, "Stream is closed" );
+        if (inputStream == NULL) {
+            throw IOException(__FILE__, __LINE__, "Stream is closed");
         }
 
         int required = 0;
@@ -192,16 +175,16 @@ int BufferedInputStream::doReadArrayBoun
         // There are bytes available in the buffer so use them up first and
         // then we check to see if any are available on the stream, if not
         // then just return what we had.
-        if( this->pos < this->count  ) {
+        if (this->pos < this->count) {
 
             int available = this->count - this->pos;
             int copylength = available >= length ? length : available;
 
-            System::arraycopy( lbuffer, this->pos, buffer, offset, copylength );
+            System::arraycopy(lbuffer, this->pos, buffer, offset, copylength);
             this->pos += copylength;
 
-            if( copylength == length || inputStream->available() == 0 ) {
-                return (int)copylength;
+            if (copylength == length || inputStream->available() == 0) {
+                return (int) copylength;
             }
 
             offset += copylength;
@@ -210,63 +193,61 @@ int BufferedInputStream::doReadArrayBoun
             required = length;
         }
 
-        while( true ) {
+        while (true) {
 
             int read = 0;
 
             // If we're not marked and the required size is greater than the
             // buffer, simply read the bytes directly bypassing the buffer.
-            if( this->markPos == -1 && required >= this->bufferSize ) {
+            if (this->markPos == -1 && required >= this->bufferSize) {
 
-                read = inputStream->read( buffer, size, offset, required );
-                if( read == -1 ) {
-                    return required == length ? -1 : (int)( length - required );
+                read = inputStream->read(buffer, size, offset, required);
+                if (read == -1) {
+                    return required == length ? -1 : (int) (length - required);
                 }
 
             } else {
 
-                if( bufferData( inputStream, lbuffer ) == -1 ) {
-                    return required == length ? -1 : (int)( length - required );
+                if (bufferData(inputStream, lbuffer) == -1) {
+                    return required == length ? -1 : (int) (length - required);
                 }
 
                 // Stream might have closed while we were buffering.
-                if( isClosed() || this->proxyBuffer == NULL ){
-                    throw IOException(
-                        __FILE__, __LINE__,
-                        "BufferedInputStream::bufferData - Stream is closed" );
+                if (isClosed() || this->proxyBuffer == NULL) {
+                    throw IOException(__FILE__, __LINE__, "BufferedInputStream::bufferData
- Stream is closed");
                 }
 
                 int available = this->count - this->pos;
                 read = available >= required ? required : available;
-                System::arraycopy( lbuffer, this->pos, buffer, offset, read );
+                System::arraycopy(lbuffer, this->pos, buffer, offset, read);
                 this->pos += read;
             }
 
             required -= read;
 
-            if( required == 0 ) {
+            if (required == 0) {
                 return length;
             }
 
-            if( inputStream->available() == 0 ) {
+            if (inputStream->available() == 0) {
                 return length - required;
             }
 
             offset += read;
         }
     }
-    DECAF_CATCH_RETHROW( IOException )
-    DECAF_CATCH_RETHROW( NullPointerException )
-    DECAF_CATCH_RETHROW( IndexOutOfBoundsException )
-    DECAF_CATCHALL_THROW( IOException )
+    DECAF_CATCH_RETHROW( IOException)
+    DECAF_CATCH_RETHROW( NullPointerException)
+    DECAF_CATCH_RETHROW( IndexOutOfBoundsException)
+    DECAF_CATCHALL_THROW( IOException)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-long long BufferedInputStream::skip( long long amount ) {
+long long BufferedInputStream::skip(long long amount) {
 
-    try{
+    try {
 
-        if( amount == 0 ) {
+        if (amount == 0) {
             return 0;
         }
 
@@ -274,14 +255,12 @@ long long BufferedInputStream::skip( lon
         InputStream* inputStream = this->inputStream;
         unsigned char* lbuffer = this->proxyBuffer;
 
-        if( isClosed() || lbuffer == NULL ){
-            throw IOException(
-                __FILE__, __LINE__,
-                "BufferedInputStream::skip - Stream is closed" );
+        if (isClosed() || lbuffer == NULL) {
+            throw IOException(__FILE__, __LINE__, "BufferedInputStream::skip - Stream is
closed");
         }
 
-        if( ( this->count - this->pos ) >= amount ) {
-            this->pos += (int)amount;
+        if ((this->count - this->pos) >= amount) {
+            this->pos += (int) amount;
             return amount;
         }
 
@@ -289,16 +268,16 @@ long long BufferedInputStream::skip( lon
 
         this->pos = this->count;
 
-        if( this->markPos != -1 ) {
+        if (this->markPos != -1) {
 
-            if( amount <= this->markLimit ) {
+            if (amount <= this->markLimit) {
 
-                if( bufferData( inputStream, lbuffer ) == -1 ) {
+                if (bufferData(inputStream, lbuffer) == -1) {
                     return read;
                 }
 
-                if( ( this->count - this->pos ) >= ( amount - read ) ) {
-                    this->pos += (int)( amount - read );
+                if ((this->count - this->pos) >= (amount - read)) {
+                    this->pos += (int) (amount - read);
                     return amount;
                 }
 
@@ -310,21 +289,21 @@ long long BufferedInputStream::skip( lon
             }
         }
 
-        return read + inputStream->skip( amount - read );
+        return read + inputStream->skip(amount - read);
     }
-    DECAF_CATCH_RETHROW( IOException )
-    DECAF_CATCHALL_THROW( IOException )
+    DECAF_CATCH_RETHROW( IOException)
+    DECAF_CATCHALL_THROW( IOException)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-int BufferedInputStream::bufferData( InputStream* inputStream, unsigned char*& buffer
) {
+int BufferedInputStream::bufferData(InputStream* inputStream, unsigned char*& buffer)
{
 
-    try{
+    try {
 
-        if( this->markPos == -1 || pos - markPos >= markLimit ) {
+        if (this->markPos == -1 || pos - markPos >= markLimit) {
             // Mark position not set or exceeded readlimit
-            int result = inputStream->read( buffer, this->bufferSize );
-            if( result > 0 ) {
+            int result = inputStream->read(buffer, this->bufferSize);
+            if (result > 0) {
                 this->markLimit = 0;
                 this->markPos = -1;
                 this->pos = this->count = 0;
@@ -334,39 +313,39 @@ int BufferedInputStream::bufferData( Inp
             return result;
         }
 
-        if( this->markPos == 0 && this->markLimit > this->bufferSize
) {
+        if (this->markPos == 0 && this->markLimit > this->bufferSize)
{
 
             // Increase buffer size to accommodate the readlimit.
             int newLength = this->bufferSize * 2;
-            if( newLength > markLimit ) {
+            if (newLength > markLimit) {
                 newLength = markLimit;
             }
 
             unsigned char* temp = new unsigned char[newLength];
-            System::arraycopy( temp, 0, buffer, 0, count );
-            std::swap( temp, buffer );
-            delete [] temp;
+            System::arraycopy(temp, 0, buffer, 0, count);
+            std::swap(temp, buffer);
+            delete[] temp;
             this->bufferSize = newLength;
 
-            if( this->proxyBuffer != NULL ) {
+            if (this->proxyBuffer != NULL) {
                 this->buff = buffer;
                 this->proxyBuffer = this->buff;
             }
 
-        } else if( this->markPos > 0 ) {
-            System::arraycopy( buffer, markPos, buffer, 0, this->bufferSize - markPos
);
+        } else if (this->markPos > 0) {
+            System::arraycopy(buffer, markPos, buffer, 0, this->bufferSize - markPos);
         }
 
         // Set the new position and mark position
         this->pos -= this->markPos;
         this->count = this->markPos = 0;
 
-        int bytesread = inputStream->read( buffer, this->bufferSize, this->pos,
this->bufferSize - this->pos );
+        int bytesread = inputStream->read(buffer, this->bufferSize, this->pos, this->bufferSize
- this->pos);
 
         this->count = bytesread <= 0 ? this->pos : this->pos + bytesread;
 
         return bytesread;
     }
-    DECAF_CATCH_RETHROW( IOException )
-    DECAF_CATCHALL_THROW( IOException )
+    DECAF_CATCH_RETHROW( IOException)
+    DECAF_CATCHALL_THROW( IOException)
 }

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedOutputStream.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedOutputStream.cpp?rev=1393764&r1=1393763&r2=1393764&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedOutputStream.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedOutputStream.cpp Wed
Oct  3 21:02:44 2012
@@ -27,46 +27,40 @@ using namespace decaf::lang;
 using namespace decaf::lang::exceptions;
 
 ////////////////////////////////////////////////////////////////////////////////
-BufferedOutputStream::BufferedOutputStream( OutputStream* stream, bool own )
-: FilterOutputStream( stream, own ), buffer(NULL), bufferSize(0), head(0), tail(0) {
+BufferedOutputStream::BufferedOutputStream(OutputStream* stream, bool own) :
+    FilterOutputStream(stream, own), buffer(NULL), bufferSize(0), head(0), tail(0) {
 
     // Default to 1k buffer.
-    init( 8192 );
+    init(8192);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-BufferedOutputStream::BufferedOutputStream( OutputStream* stream, int bufSize, bool own )
:
-    FilterOutputStream( stream, own ), buffer(NULL), bufferSize(0), head(0), tail(0) {
+BufferedOutputStream::BufferedOutputStream(OutputStream* stream, int bufSize, bool own) :
+    FilterOutputStream(stream, own), buffer(NULL), bufferSize(0), head(0), tail(0) {
 
     try {
-        this->init( bufSize );
+        this->init(bufSize);
     }
-    DECAF_CATCH_RETHROW( IllegalArgumentException )
-    DECAF_CATCHALL_THROW( IllegalArgumentException )
+    DECAF_CATCH_RETHROW(IllegalArgumentException)
+    DECAF_CATCHALL_THROW(IllegalArgumentException)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 BufferedOutputStream::~BufferedOutputStream() {
 
-    try{
+    try {
         this->close();
-
-        // Destroy the buffer.
-        if( buffer != NULL ){
-            delete [] buffer;
-            buffer = NULL;
-        }
     }
-    DECAF_CATCH_NOTHROW( IOException )
     DECAF_CATCHALL_NOTHROW()
+
+    delete [] buffer;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void BufferedOutputStream::init( int bufSize ) {
+void BufferedOutputStream::init(int bufSize) {
 
-    if( bufSize < 0 ) {
-        throw IllegalArgumentException(
-            __FILE__, __LINE__, "Size of Buffer cannot be negative." );
+    if (bufSize < 0) {
+        throw IllegalArgumentException(__FILE__, __LINE__, "Size of Buffer cannot be negative.");
     }
 
     this->bufferSize = bufSize;
@@ -78,16 +72,18 @@ void BufferedOutputStream::init( int buf
 ////////////////////////////////////////////////////////////////////////////////
 void BufferedOutputStream::emptyBuffer() {
 
-    if( this->outputStream == NULL ) {
-        throw IOException(
-            __FILE__, __LINE__,
-            "BufferedOutputStream::emptyBuffer - OutputStream is closed" );
+    if (this->outputStream == NULL) {
+        throw IOException(__FILE__, __LINE__, "BufferedOutputStream::emptyBuffer - OutputStream
is closed");
     }
 
-    if( this->head != this->tail ){
-        this->outputStream->write( this->buffer + this->head, this->tail -this->head
);
+    try {
+        if (this->head != this->tail) {
+            this->outputStream->write(this->buffer + this->head, this->tail
- this->head);
+        }
+        this->head = this->tail = 0;
     }
-    this->head = this->tail = 0;
+    DECAF_CATCH_RETHROW(IOException)
+    DECAF_CATCHALL_THROW(IOException)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -95,10 +91,8 @@ void BufferedOutputStream::flush() {
 
     try {
 
-        if( isClosed() ){
-            throw IOException(
-                __FILE__, __LINE__,
-                "BufferedOutputStream::write - Stream is clsoed" );
+        if (isClosed()) {
+            throw IOException(__FILE__, __LINE__, "BufferedOutputStream::write - Stream is
clsoed");
         }
 
         // Empty the contents of the buffer to the output stream.
@@ -107,100 +101,88 @@ void BufferedOutputStream::flush() {
         // Flush the output stream.
         outputStream->flush();
     }
-    DECAF_CATCH_RETHROW( IOException )
-    DECAF_CATCHALL_THROW( IOException )
+    DECAF_CATCH_RETHROW(IOException)
+    DECAF_CATCHALL_THROW(IOException)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void BufferedOutputStream::doWriteByte( const unsigned char c ) {
+void BufferedOutputStream::doWriteByte(const unsigned char c) {
 
-    try{
+    try {
 
-        if( isClosed() ){
-            throw IOException(
-                __FILE__, __LINE__,
-                "BufferedOutputStream::write - Stream is clsoed" );
+        if (isClosed()) {
+            throw IOException(__FILE__, __LINE__, "BufferedOutputStream::write - Stream is
clsoed");
         }
 
-        if( tail >= bufferSize ){
+        if (tail >= bufferSize) {
             emptyBuffer();
         }
 
         buffer[tail++] = c;
     }
-    DECAF_CATCH_RETHROW( IOException )
-    DECAF_CATCHALL_THROW( IOException )
+    DECAF_CATCH_RETHROW(IOException)
+    DECAF_CATCHALL_THROW(IOException)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void BufferedOutputStream::doWriteArray( const unsigned char* buffer, int size ) {
+void BufferedOutputStream::doWriteArray(const unsigned char* buffer, int size) {
 
-    try{
+    try {
 
-        if( size == 0 ) {
+        if (size == 0) {
             return;
         }
 
-        if( isClosed() ){
-            throw IOException(
-                __FILE__, __LINE__,
-                "BufferedOutputStream::write - Stream is clsoed" );
+        if (isClosed()) {
+            throw IOException(__FILE__, __LINE__, "BufferedOutputStream::write - Stream is
clsoed");
         }
 
-        this->doWriteArrayBounded( buffer, size, 0, size );
+        this->doWriteArrayBounded(buffer, size, 0, size);
     }
-    DECAF_CATCH_RETHROW( IOException )
-    DECAF_CATCHALL_THROW( IOException )
+    DECAF_CATCH_RETHROW(IOException)
+    DECAF_CATCHALL_THROW(IOException)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void BufferedOutputStream::doWriteArrayBounded( const unsigned char* buffer, int size,
-                                                int offset, int length ) {
+void BufferedOutputStream::doWriteArrayBounded(const unsigned char* buffer, int size, int
offset, int length) {
 
-    try{
+    try {
 
-        if( length == 0 ) {
+        if (length == 0) {
             return;
         }
 
-        if( isClosed() ){
-            throw IOException(
-                __FILE__, __LINE__,
-                "BufferedOutputStream::write - Stream is clsoed" );
+        if (isClosed()) {
+            throw IOException(__FILE__, __LINE__, "BufferedOutputStream::write - Stream is
clsoed");
         }
 
-        if( buffer == NULL ) {
-            throw NullPointerException(
-                __FILE__, __LINE__,
-                "BufferedOutputStream::write - Buffer passed is Null.");
+        if (buffer == NULL) {
+            throw NullPointerException(__FILE__, __LINE__, "BufferedOutputStream::write -
Buffer passed is Null.");
         }
 
-        if( size < 0 ) {
-            throw IndexOutOfBoundsException(
-                __FILE__, __LINE__, "size parameter out of Bounds: %d.", size );
+        if (size < 0) {
+            throw IndexOutOfBoundsException(__FILE__, __LINE__, "size parameter out of Bounds:
%d.", size);
         }
 
-        if( offset > size || offset < 0 ) {
-            throw IndexOutOfBoundsException(
-                __FILE__, __LINE__, "offset parameter out of Bounds: %d.", offset );
+        if (offset > size || offset < 0) {
+            throw IndexOutOfBoundsException(__FILE__, __LINE__, "offset parameter out of
Bounds: %d.", offset);
         }
 
-        if( length < 0 || length > size - offset ) {
-            throw IndexOutOfBoundsException(
-                __FILE__, __LINE__, "length parameter out of Bounds: %d.", length );
+        if (length < 0 || length > size - offset) {
+            throw IndexOutOfBoundsException(__FILE__, __LINE__, "length parameter out of
Bounds: %d.", length);
         }
 
         // Iterate until all the data is written.
-        for( int pos = 0; pos < length; ){
+        for (int pos = 0; pos < length;) {
 
-            if( tail >= bufferSize ){
+            if (tail >= bufferSize) {
                 emptyBuffer();
             }
 
             // Get the number of bytes left to write.
-            int bytesToWrite = Math::min( bufferSize - tail, length - pos );
+            int bytesToWrite = Math::min(bufferSize - tail, length - pos);
 
-            System::arraycopy( buffer, offset + pos, this->buffer, this->tail, bytesToWrite
);
+            System::arraycopy(buffer, offset + pos, this->buffer, this->tail, bytesToWrite);
 
             // Increase the tail position.
             tail += bytesToWrite;
@@ -209,8 +191,8 @@ void BufferedOutputStream::doWriteArrayB
             pos += bytesToWrite;
         }
     }
-    DECAF_CATCH_RETHROW( IOException )
-    DECAF_CATCH_RETHROW( NullPointerException )
-    DECAF_CATCH_RETHROW( IndexOutOfBoundsException )
-    DECAF_CATCHALL_THROW( IOException )
+    DECAF_CATCH_RETHROW(IOException)
+    DECAF_CATCH_RETHROW(NullPointerException)
+    DECAF_CATCH_RETHROW(IndexOutOfBoundsException)
+    DECAF_CATCHALL_THROW(IOException)
 }



Mime
View raw message