data.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2001 by Rick L. Vinyard, Jr.                            *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This file is part of the conexus library.                             *
 *                                                                         *
 *   The conexus library is free software; you can redistribute it and/or  *
 *   modify it under the terms of the GNU General Public License           *
 *   version 3 as published by the Free Software Foundation.               *
 *                                                                         *
 *   The conexus 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   *
 *   General Public License for more details.                              *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this software. If not see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
#ifndef CONEXUSDATA_H
#define CONEXUSDATA_H

#include <cstdlib>
#include <stdexcept>
#include <string>

#include <sigc++/sigc++.h>

#include <conexus/pointer.h>
#include <conexus/timeval.h>

#include <glibmm/thread.h>

namespace Conexus
{

  typedef enum DataMode {
    COPY,
    MANAGED,
    UNMANAGED,
  } DataMode;

  class Data
  {
    public:

      Data( size_t s = 0, unsigned priority = 0 ) throw (std::bad_alloc);

      Data( const void* d, size_t s, unsigned priority = 0, DataMode mode=COPY ) throw (std::bad_alloc);

      Data( const Data& other );

      ~Data();

      uint8_t* data();

      const uint8_t* data() const;

      bool set_data( const void* newdata, size_t newsize, DataMode mode=COPY ) throw (std::bad_alloc);

      size_t size() const;

      bool resize( size_t s ) throw (std::bad_alloc);

      Data clone() const;

      operator bool();

      operator bool() const;

      operator uint8_t*();

      operator const uint8_t*() const;

      operator char*();

      operator const char*() const;

      operator void*();

      operator const void*() const;

      uint8_t& operator[](const ssize_t offset);

      const uint8_t& operator[](const ssize_t offset) const;

      std::string hex_string( std::string separator = std::string() ) const;

      void clear();

      const TimeVal& time() const;

      void set_time( const TimeVal& );

      void set_current_time();

      unsigned priority() const;

      void set_priority( unsigned p );

      bool operator<( const Data& other ) const;
      bool operator<=( const Data& other ) const;
      bool operator==( const Data& other ) const;
      bool operator!=( const Data& other ) const;
      bool operator>=( const Data& other ) const;
      bool operator>( const Data& other ) const;

      int compare( const Data& other ) const;

      bool append( const Data& other );

      Data operator+( const Data& other ) const;

      Data& operator+=( const Data& other );

    protected:

      class Storage {
        public:

          Storage(): data(NULL), size(0), manage_data(false), priority(0) { }

          ~Storage() {
            if ( data && manage_data ) {
                ::free( data );
                data = NULL;
            }
          }

          typedef ConexusPointer<Storage> pointer;

          uint8_t* data;

          size_t size;

          bool manage_data;

          unsigned int priority;

          TimeVal time;

      };

      Storage::pointer m_storage;

  };


}

#endif