Changeset 583 for trunk/src2

Timestamp:

Feb 22, 2007, 1:45:50 AM (18 years ago)

Author:

dkearney

Message:

updated RpBuffer? object, cleaning up much of the code.
added putData() calls to RpLibrary?, still need a getData call.
added new function to the scew extra functions to directly add a char* buffer to the xml
updated makefiles as needed

Location:

trunk/src2/core

Files:

• Makefile.in (modified) (5 diffs)
• RpBuffer.cc (modified) (24 diffs)
• RpBuffer.h (modified) (6 diffs)
• RpBuffer_test.cc (modified) (2 diffs)

trunk/src2/core/Makefile.in

@@ -13 +13 @@
 
 CXX             = @CXX@
-# CXX             = g++
 
 CFLAGS=-g -Wall
@@ -38 +37 @@
 
 prefix = @prefix@
-# prefix = /apps/rappture/20070216
 exec_prefix = ${prefix}
 libdir = ${exec_prefix}/lib
@@ -80 +78 @@
         ln -s $@ $(SHAREDLIBM)
 
-#test$(EXE): test.o $(LIBS)
-#       $(CXX) $(CFLAGS) -o $@ test.o $(LDFLAGS)
-
 test(EXE): test.o Ptr.o Outcome.o Lookup.o
         $(CXX) $(CFLAGS) -o $@ test.o Ptr.o Outcome.o Lookup.o
@@ -90 +85 @@
         $(CXX) $(CFLAGS) -o $@ RpBuffer_test.o $(LDFLAGS) -L ${libdir} -lz -lb64
 
-install: $(LIBS)
+install: $(LIBS) $(SHAREDLIBV)
         -@if [ ! -d $(exec_prefix) ]; then mkdir -p $(exec_prefix); fi
         -@if [ ! -d $(includedir)  ]; then mkdir -p $(includedir); fi
@@ -104 +99 @@
         chmod 644 $(includedir)/RpBuffer.h
         cp $(LIBS) $(libdir)
+        cp $(SHAREDLIBV) $(libdir)
         cd $(libdir); chmod 755 $(LIBS)
         -@(cd $(libdir); $(RANLIB) librappture2.a || true) >/dev/null 2>&1

trunk/src2/core/RpBuffer.cc

@@ -93 +93 @@
 SimpleBuffer::SimpleBuffer(const SimpleBuffer& b)
 {
-    _buf = NULL;
-    _pos =0;
-    _size = b._size;
-    _spaceAvl = b._spaceAvl;
-    _shallow = false;
-    _fileState = true;
-
-    _buf = new char[b._spaceAvl];
-    memcpy((void*) _buf, (void*) b._buf, (size_t) b._spaceAvl);
+    bufferInit();
+    append(b.bytes(),b.size());
 }
 
@@ -114 +107 @@
     bufferFree();
     bufferInit();
-
-    _buf = new char[b._spaceAvl];
-    memcpy((void*) _buf, (void*) b._buf, (size_t) b._spaceAvl);
-
-    _pos = b._pos;
-    _size = b._size;
-    _spaceAvl = b._spaceAvl;
-
+    append(b.bytes(),b.size());
+    return *this;
+}
+
+
+/**
+ * Operator +
+ * @param SimpleBuffer object to add
+ * @param SimpleBuffer object to add
+ */
+SimpleBuffer
+SimpleBuffer::operator+(const SimpleBuffer& b) const
+{
+    SimpleBuffer newBuffer(*this);
+    newBuffer.operator+=(b);
+    return newBuffer;
+}
+
+
+/**
+ * Operator +=
+ * @param SimpleBuffer object to add
+ */
+SimpleBuffer&
+SimpleBuffer::operator+=(const SimpleBuffer& b)
+{
+    append(b.bytes(),b.size());
     return *this;
 }
@@ -185 +197 @@
     char *newBuffer = NULL;
 
+    // User specified NULL buffer to append
+    if (bytes == NULL) {
+        return 0;
+    }
+
     if (nbytes == -1) {
         // user signaled null terminated string
@@ -195 +212 @@
     }
 
+    // Empty internal buffer, make sure its properly initialized.
     if (_buf == NULL) {
-        _size = 0;
-        _spaceAvl = 0;
+        bufferInit();
     }
 
@@ -243 +260 @@
  */
 int
-SimpleBuffer::read(char* bytes, int nbytes)
+SimpleBuffer::read(const char* bytes, int nbytes)
 {
     int bytesRead = 0;
 
+    // SimpleBuffer is empty.
     if (_buf == NULL) {
         return 0;
     }
 
-    // make sure we dont read off the end of our buffer
+    // User specified NULL buffer.
+    if (bytes == NULL) {
+        return 0;
+    }
+
+    // make sure we don't read off the end of our buffer
     if ( (_pos + nbytes) >= _size) {
         bytesRead = (_size - _pos);
@@ -264 +287 @@
 
     if (bytesRead > 0) {
-        memcpy((void*) bytes, (void*) _buf, (size_t) bytesRead);
+        memcpy((void*) bytes, (void*) (_buf+_pos), (size_t) bytesRead);
     }
 
@@ -270 +293 @@
 
     return bytesRead;
+}
+
+
+/**
+ * Set buffer position indicator to spot within the buffer
+ * @param Offset from whence location in buffer.
+ * @param Place from where offset is added or subtracted.
+ * @return 0 on success, anything else is failure
+ */
+int
+SimpleBuffer::seek(int offset, int whence)
+{
+    int retVal = 0;
+
+    if (_buf == NULL) {
+        return -1 ;
+    }
+
+    if (whence == SEEK_SET) {
+        if (offset < 0) {
+            /* dont go off the beginning of data */
+            _pos = 0;
+        }
+        else if (offset >= _size) {
+            /* dont go off the end of data */
+            _pos = _size - 1;
+        }
+        else {
+            _pos = _pos + offset;
+        }
+    }
+    else if (whence == SEEK_CUR) {
+        if ( (_pos + offset) < 0) {
+            /* dont go off the beginning of data */
+            _pos = 0;
+        }
+        else if ((_pos + offset) >= _size) {
+            /* dont go off the end of data */
+            _pos = _size - 1;
+        }
+        else {
+            _pos = _pos + offset;
+        }
+    }
+    else if (whence == SEEK_END) {
+        if (offset <= (-1*_size)) {
+            /* dont go off the beginning of data */
+            _pos = 0;
+        }
+        else if (offset >= 0) {
+            /* dont go off the end of data */
+            _pos = _size - 1;
+        }
+        else {
+            _pos = (_size - 1) + offset;
+        }
+    }
+    else {
+        retVal = -1;
+    }
+
+    return retVal;
+}
+
+
+/**
+ * Tell caller the offset of the position indicator from the start of buffer
+ * @return Number of bytes the position indicator is from start of buffer
+ */
+int
+SimpleBuffer::tell()
+{
+   return _pos;
+}
+
+
+/**
+ * Read data from the buffer into a memory location provided by caller
+ */
+SimpleBuffer&
+SimpleBuffer::rewind()
+{
+    _pos = 0;
+    return *this;
 }
 
@@ -305 +412 @@
 {
     return (_pos >= _size);
-}
-
-
-/**
- * Use this SimpleBuffer as a temporary pointer to another SimpleBuffer
- * This SimpleBuffer does not own the data that it points to, thus
- * when clear() or operator=() is called, the data is not deleted,
- * but the _buf value is changed. This could lead to a memory leak if
- * used improperly.
- * @param Pointer location memory to temporarily own.
- * @param number of bytes used in the buffer.
- * @param number of total bytes in the allocated buffer.
- * @return True or false boolean value.
- */
-SimpleBuffer&
-SimpleBuffer::shallowCopy(char* bytes, int nBytes, int spaceAvl)
-{
-    bufferFree();
-
-    _buf = bytes;
-    _pos = 0;
-    _size = nBytes;
-    _spaceAvl = spaceAvl;
-    _shallow = true;
-    _fileState = true;
-
-    return *this;
 }
 
@@ -345 +425 @@
 SimpleBuffer::move(SimpleBuffer& b)
 {
-    b.bufferFree();
-
-    b._buf = _buf;
-    b._pos = 0;
-    b._size = _size;
-    b._spaceAvl = _spaceAvl;
-    b._shallow = _shallow;
-
-    bufferInit();
+    bufferFree();
+
+    _buf = b._buf;
+    _pos = b._pos;
+    _size = b._size;
+    _spaceAvl = b._spaceAvl;
+    _fileState = b._fileState;
+
+    b.bufferInit();
 
     return *this;
@@ -371 +451 @@
     _size = 0;
     _spaceAvl = 0;
-    _shallow = false;
     _fileState = true;
 }
@@ -383 +462 @@
 SimpleBuffer::bufferFree()
 {
-    if (_shallow == false) {
-        if (_buf != NULL) {
-            delete [] _buf;
-            _buf = NULL;
-        }
+    if (_buf != NULL) {
+        delete [] _buf;
+        _buf = NULL;
     }
     bufferInit();
@@ -422 +499 @@
  */
 Buffer::Buffer(const Buffer& b)
-  : _level(b._level),
+  : SimpleBuffer(b),
+    _level(b._level),
     _compressionType(b._compressionType),
     _windowBits(b._windowBits)
-{
-    bufferInit();
-
-    _buf = new char[b._spaceAvl];
-    memcpy((void*) _buf, (void*) b._buf, (size_t) b._spaceAvl);
-    _size = b._size;
-    _spaceAvl = b._spaceAvl;
-}
+{}
 
 /**
@@ -441 +512 @@
 Buffer::operator=(const Buffer& b)
 {
-    bufferFree();
-    bufferInit();
-
-    _buf = new char[b._spaceAvl];
-    memcpy((void*) _buf, (void*) b._buf, (size_t) b._spaceAvl);
-    _pos = b._pos;
-    _size = b._size;
-    _spaceAvl = b._spaceAvl;
+    SimpleBuffer::operator=(b);
 
     _level = b._level;
     _compressionType = b._compressionType;
     _windowBits = b._windowBits;
-    _fileState = b._fileState;
 
     return *this;
@@ -459 +522 @@
 
 
+Buffer
+Buffer::operator+(const Buffer& b) const
+{
+    Buffer newBuffer(*this);
+    newBuffer.operator+=(b);
+    return newBuffer;
+}
+
+
 Buffer&
-Buffer::operator=(const SimpleBuffer& b)
-{
-    bufferFree();
-    bufferInit();
-
-    _buf = new char[b.size()];
-    memcpy((void*) _buf, (void*) b.bytes(), (size_t) b.size());
-    _pos = 0;
-    _size = b.size();
-    _spaceAvl = b.size();
-
-    _level = 6;
-    _compressionType = RPCOMPRESS_GZIP;
-    _windowBits = 15;
-    _fileState = true;
-
+Buffer::operator+=(const Buffer& b)
+{
+    SimpleBuffer::operator+=(b);
     return *this;
 }
@@ -538 +597 @@
     }
 
-    outFile.write(_buf,_size);
+    outFile.write(bytes(),size());
     outFile.close();
 
@@ -555 +614 @@
     err.addContext("Rappture::Buffer::encode()");
 
-    bin.shallowCopy(_buf, _size, _spaceAvl);
+    rewind();
 
     if (compress) {
-        do_compress(err,bin,bout);
+        do_compress(err,*this,bout);
     }
 
     if (base64) {
         if (compress) {
-            bout.move(bin);
-        }
-        do_base64_enc(err,bin,bout);
+            bin.move(bout);
+            do_base64_enc(err,bin,bout);
+        }
+        else {
+            do_base64_enc(err,*this,bout);
+        }
     }
 
     if (!err) {
         // write the encoded data to the internal buffer
-        bufferFree();
-        operator=(bout);
+        move(bout);
     }
 
@@ -585 +646 @@
     SimpleBuffer bout;
 
-    bin.shallowCopy(_buf, _size, _spaceAvl);
+    rewind();
 
     if (base64) {
-        do_base64_dec(err,bin,bout);
+        do_base64_dec(err,*this,bout);
     }
 
     if (decompress) {
         if (base64) {
-            bout.move(bin);
-        }
-        do_decompress(err,bin,bout);
+            bin.move(bout);
+            do_decompress(err,bin,bout);
+        }
+        else {
+            do_decompress(err,*this,bout);
+        }
     }
 
     if (!err) {
         // write the decoded data to the internal buffer
-        bufferFree();
-        operator=(bout);
+        move(bout);
     }
 
@@ -609 +672 @@
 
 void
-Buffer::do_compress(Outcome& status, SimpleBuffer& bin, SimpleBuffer& bout)
-{
-    int ret, flush;
-    unsigned have;
+Buffer::do_compress(    Outcome& status,
+                        SimpleBuffer& bin,
+                        SimpleBuffer& bout  )
+{
+    int ret=0, flush=0;
+    unsigned have=0;
     z_stream strm;
 
@@ -638 +703 @@
     do {
         strm.avail_in = bin.read(in, CHUNK);
-        if (bad() == true) {
+        if (bin.bad() == true) {
             (void)deflateEnd(&strm);
             // return Z_ERRNO;
@@ -646 +711 @@
         }
         flush = bin.eof() ? Z_FINISH : Z_NO_FLUSH;
-        strm.next_in = (unsigned char*) in;
+        strm.next_in = (Bytef*) in;
         /* run deflate() on input until output buffer not full, finish
            compression if all of source has been read in */
         do {
             strm.avail_out = CHUNK;
-            strm.next_out = (unsigned char*) out;
+            strm.next_out = (Bytef*) out;
             ret = deflate(&strm, flush);    /* no bad return value */
             assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
@@ -681 +746 @@
 
 void
-Buffer::do_decompress(Outcome& status, SimpleBuffer& bin, SimpleBuffer& bout)
+Buffer::do_decompress(  Outcome& status,
+                        SimpleBuffer& bin,
+                        SimpleBuffer& bout  )
 {
     int ret;
@@ -709 +776 @@
     do {
         strm.avail_in = bin.read(in, CHUNK);
-        if (bad() == true) {
+        if (bin.bad() == true) {
             (void)inflateEnd(&strm);
             // return Z_ERRNO;
@@ -761 +828 @@
 void
 Buffer::do_base64_enc(  Outcome& status,
-                        SimpleBuffer& bin,
+                        const SimpleBuffer& bin,
                         SimpleBuffer& bout )
 {
@@ -782 +849 @@
 void
 Buffer::do_base64_dec(  Outcome& status,
-                        SimpleBuffer& bin,
+                        const SimpleBuffer& bin,
                         SimpleBuffer& bout )
 {

trunk/src2/core/RpBuffer.h

@@ -86 +86 @@
     SimpleBuffer(const SimpleBuffer& b);
     SimpleBuffer& operator=(const SimpleBuffer& b);
+    SimpleBuffer  operator+(const SimpleBuffer& b) const;
+    SimpleBuffer& operator+=(const SimpleBuffer& b);
     virtual ~SimpleBuffer();
 
@@ -93 +95 @@
     SimpleBuffer& clear();
     int append(const char* bytes, int nbytes=-1);
-    int read(char* bytes, int nbytes);
+    int read(const char* bytes, int nbytes);
+    int seek(int offset, int whence);
+    int tell();
+    SimpleBuffer& rewind();
 
     bool good() const;
@@ -99 +104 @@
     bool eof() const;
 
-    SimpleBuffer& shallowCopy(char* bytes, int nBytes, int spaceAvl);
     SimpleBuffer& move(SimpleBuffer& b);
 
 protected:
+
+    void bufferInit();
+    void bufferFree();
+
+private:
+
     /// Pointer to the memory that holds our buffer's data
     char* _buf;
@@ -115 +125 @@
     int _spaceAvl;
 
-    /// Shallow copy flag.
-    bool _shallow;
-
     /// State of the last file like operation.
     bool _fileState;
-
-    void bufferInit();
-    void bufferFree();
 };
 
@@ -137 +141 @@
     Buffer(const char* bytes, int nbytes=-1);
     Buffer(const Buffer& buffer);
-    Buffer& operator=(const Buffer& buffer);
+    Buffer& operator=(const Buffer& b);
+    Buffer  operator+(const Buffer& b) const;
+    Buffer& operator+=(const Buffer& b);
     virtual ~Buffer();
 
@@ -158 +164 @@
     enum { CHUNK = 4096 };
 
-    Buffer& operator=(const SimpleBuffer& buffer);
-    void do_compress(Outcome& status,SimpleBuffer& bin,SimpleBuffer& bout);
-    void do_decompress(Outcome& status,SimpleBuffer& bin,SimpleBuffer& bout);
-    void do_base64_enc(Outcome& status,SimpleBuffer& bin,SimpleBuffer& bout);
-    void do_base64_dec(Outcome& status,SimpleBuffer& bin,SimpleBuffer& bout);
+    void do_compress(   Outcome& status,
+                        SimpleBuffer& bin,
+                        SimpleBuffer& bout  );
+    void do_decompress( Outcome& status,
+                        SimpleBuffer& bin,
+                        SimpleBuffer& bout  );
+    void do_base64_enc( Outcome& status,
+                        const SimpleBuffer& bin,
+                        SimpleBuffer& bout  );
+    void do_base64_dec( Outcome& status,
+                        const SimpleBuffer& bin,
+                        SimpleBuffer& bout  );
 };
 

trunk/src2/core/RpBuffer_test.cc

@@ -449 +449 @@
         return (tests == passed);
     }
+
+    passed++;
+    /* =========================================================== */
+
+    return (tests == passed);
+}
+
+int testFile()
+{
+    int passed = 0;
+    int tests = 0;
+
+
+    /* =========================================================== */
+    tests++;
+    const char* inFile = "out.dx";
+    const char* outFile = "out.dx.gz";
+    Rappture::Buffer buffer1;
+    buffer1.load(inFile);
+
+    // compress, dont encode
+    buffer1.encode(true,false);
+    std::remove(outFile);
+    buffer1.dump(outFile);
+    buffer1.decode(true,false);
+
+    /*
+    if (size1before != 26) {
+        std::cout << "Error testClear1" << std::endl;
+        std::cout << "incorrect buffer size" << std::endl;
+        return (tests == passed);
+    }
+    if (size1after != 0) {
+        std::cout << "Error testClear1" << std::endl;
+        std::cout << "clear failed buffer size" << std::endl;
+        return (tests == passed);
+    }
+    */
 
     passed++;
@@ -468 +506 @@
     passed += testLoad();
     passed += testClear();
-
-    if (passed != 8) {
+    passed += testFile();
+
+    if (passed != 9) {
         printf("failed: %d\n", passed);
     }