Blob.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2012  Mark A Lindner

   This file is part of commonc++.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/

#ifndef __ccxx_Blob_hxx
#define __ccxx_Blob_hxx

#include <commonc++/Common.h++>
#include <commonc++/AtomicCounter.h++>
#include <commonc++/OutOfBoundsException.h++>

#include <sstream>

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251)
#endif // _MSC_VER

namespace ccxx {

class COMMONCPP_API Blob
{
  public:

  Blob() throw();

  Blob(byte_t *data, size_t length, bool copy = true);

  Blob(const Blob& other);

  Blob(const byte_t *data, size_t length);

  ~Blob() throw();

  inline size_t getLength() const throw()
  { return(_buf == NULL ? 0 : _buf->_length); };

  inline size_t length() const throw()
  { return(getLength()); }

  void setLength(uint_t length);

  inline byte_t * getData() throw()
  { return(_buf == NULL ? NULL : _buf->_data); }

  inline const byte_t * getData() const throw()
  { return(_buf == NULL ? NULL : _buf->_data); }

  inline Blob & clear()
  {
    setLength(0);
    return(*this);
  }

  inline bool isEmpty() const throw()
  { return((_buf->_data == NULL) || (_buf->_length == 0)); }

  inline bool isNull() const throw()
  { return(_buf->_data == NULL); }

  Blob& append(const byte_t *data, size_t len);

  Blob& append(const char *str, size_t len = 0);

  int indexOf(byte_t b, uint_t fromIndex = 0) const throw();

  int indexOf(const byte_t *buf, size_t len, uint_t fromIndex = 0) const
    throw();

  int lastIndexOf(byte_t b, uint_t fromIndex = END) const throw();

  int lastIndexOf(const byte_t *buf, size_t len, uint_t fromIndex = END)
    const throw();

  inline bool contains(byte_t b) const throw()
  { return(indexOf(b) >= 0); }

  int compareTo(const Blob &other) const throw();

  Blob& operator=(const Blob &other);

  byte_t& operator[](int index) throw(OutOfBoundsException);

  byte_t operator[](int index) const throw(OutOfBoundsException);

  inline bool operator!() const throw()
  { return(isNull()); }

  inline Blob& operator+=(byte_t b)
  { return(append(&b, 1)); }

  inline Blob& operator+=(int v)
  { return(operator+=(static_cast<byte_t>(v & 0xFF))); }

  inline Blob& operator+=(const char *str)
  { return(append(str)); }

  inline Blob& operator+=(const Blob &blob)
  { return(append(blob.getData(), blob.getLength())); }

  inline Blob& operator<<(byte_t val)
  { return(append(&val, 1)); }

  inline Blob& operator<<(int val)
  { return(operator+=(static_cast<byte_t>(val & 0xFF))); }

  inline Blob& operator<<(const char *str)
  { return(append(str)); }

  uint_t hash(uint_t modulo = 256) const throw();

  static const Blob null;

  static const uint_t END;

  private:

  class BlobBuf
  {
    friend class Blob;

    protected:

    byte_t *_data;
    size_t _capacity;
    size_t _length;
    AtomicCounter _refs;

    BlobBuf(const BlobBuf& other, size_t length);
    BlobBuf(byte_t *data = NULL, size_t offset = 0, size_t length = 0,
            bool copy = true);
    BlobBuf(const byte_t *data, size_t offset = 0, size_t length = 0);
    ~BlobBuf() throw();

    void reserve(size_t size);
    void makeNull();
    void makeCopy(const byte_t *data, size_t offset, size_t length);

    private:

    CCXX_COPY_DECLS(BlobBuf);
  };

  BlobBuf *_buf;

  void _release();
  void _makeCopy(size_t size, bool unshareable = false);
};

inline bool operator==(const Blob& b1, const Blob& b2) throw()
{ return(b1.compareTo(b2) == 0); }

inline bool operator!=(const Blob& b1, const Blob& b2) throw()
{ return(b1.compareTo(b2) != 0); }

inline bool operator<(const Blob& b1, const Blob& b2) throw()
{ return(b1.compareTo(b2) < 0); }

inline bool operator>(const Blob& b1, const Blob& b2) throw()
{ return(b1.compareTo(b2) > 0); }

inline bool operator<=(const Blob& b1, const Blob& b2) throw()
{ return(b1.compareTo(b2) <= 0); }

inline bool operator>=(const Blob& b1, const Blob& b2) throw()
{ return(b1.compareTo(b2) >= 0); }

inline std::ostream& operator<<(std::ostream& stream, const Blob& b)
{
  return(stream.write(reinterpret_cast<const char *>(b.getData()),
                      static_cast<std::streamsize>(b.getLength())));
}

}; // namespace ccxx

#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER

#endif // __ccxx_Blob_hxx

/* end of header file */