Blob.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2014  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();

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

  Blob(const Blob& other);

  Blob(const byte_t* data, uint_t length);

  ~Blob();

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

  inline uint_t length() const
  { return(getLength()); }

  void setLength(uint_t length);

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

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

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

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

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

  Blob& append(const byte_t* data, uint_t length);

  Blob& append(const char* str, uint_t length = 0);

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

  int indexOf(const byte_t* buf, uint_t length, uint_t fromIndex = 0) const;

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

  int lastIndexOf(const byte_t* buf, uint_t length, uint_t fromIndex = END)
    const;

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

  int compareTo(const Blob& other) const;

  Blob& operator=(const Blob& other);

  byte_t& operator[](int index);

  byte_t operator[](int index) const;

  inline bool operator!() const
  { 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;

  static const Blob null;

  static const uint_t END;

 private:

  class BlobBuf
  {
    friend class Blob;

   protected:

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

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

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

   private:

    CCXX_COPY_DECLS(BlobBuf);
  };

  BlobBuf *_buf;

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

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

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

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

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

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

inline bool operator>=(const Blob& b1, const Blob& b2)
{ 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