bufferflow.h

/*
 *  Copyright (c) 2003    National Research Council
 *
 *  All rights reserved.
 *
 *  This material is confidential and proprietary information of
 *  National Research Council Canada ("Confidential Information").
 *  This Confidential Information may only be used and reproduced
 *  in accordance with the terms of the license agreement.
 *
 */
 
#ifndef __INCLUDED_SCOPIRA_TOOL_BUFFERFLOW_H__
#define __INCLUDED_SCOPIRA_TOOL_BUFFERFLOW_H__

#include <scopira/tool/flow.h>
#include <scopira/tool/export.h>

#include <assert.h>

#include <vector>

namespace scopira
{
  namespace tool
  {
    class bufferflow;
    class bufferiflow;
    class bufferoflow;
  }
}

class scopira::tool::bufferflow : public scopira::tool::iflow_i, public scopira::tool::oflow_i
{
  public:
    typedef std::vector<tool::flow_i::byte_t> byte_buffer_t;

  private:
    bufferflow& operator=(const bufferflow& rhs) { assert(false); return *this; }
    bufferflow(const bufferflow& rhs) { assert(false); }

    size_t dm_index;
    byte_buffer_t dm_buffer;

  public:

    SCOPIRA_EXPORT bufferflow(void);
    SCOPIRA_EXPORT virtual ~bufferflow(void);

    SCOPIRA_EXPORT virtual bool failed(void) const;

    SCOPIRA_EXPORT virtual size_t read(byte_t* buf, size_t maxsize);

    SCOPIRA_EXPORT virtual size_t write(const byte_t* buf, size_t size);


    byte_t* c_array(void) { assert(size()>0); return &dm_buffer[0]; }
    const byte_t* c_array(void) const { assert(size()>0); return &dm_buffer[0]; }

    size_t size(void) const { return dm_buffer.size(); }

    size_t capacity(void) const { return dm_buffer.capacity(); }

    SCOPIRA_EXPORT void reset(void);
    SCOPIRA_EXPORT void reserve(size_t _size);
    SCOPIRA_EXPORT void reset_resize(size_t _size);
};

class scopira::tool::bufferiflow : public scopira::tool::iflow_i
{
  protected:
    const byte_t *dm_data, *dm_cur, *dm_end;

  public:
    SCOPIRA_EXPORT bufferiflow(const byte_t *data, size_t sz);

    SCOPIRA_EXPORT virtual bool failed(void) const;

    SCOPIRA_EXPORT virtual size_t read(byte_t* _buf, size_t _maxsize);
};

class scopira::tool::bufferoflow : public scopira::tool::oflow_i
{
  protected:
    byte_t *dm_data, *dm_cur, *dm_end;

  public:
    SCOPIRA_EXPORT bufferoflow(byte_t *data, size_t sz);

    SCOPIRA_EXPORT virtual bool failed(void) const;

    SCOPIRA_EXPORT virtual size_t write(const byte_t* _buf, size_t _size);
};

#endif