flow.h

/*
 *  Copyright (c) 2002-2007    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_FLOW_H__
#define __INCLUDED_SCOPIRA_TOOL_FLOW_H__

#include <string>

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

// THIS FILE HAS BEEN FULLY DOCUMENTED

//
// the *file_i* based streams provide "simple persistance" (rouge wave
// guide, ver 7, p124). conceptually then are somewhere above
// C FILE and slightly below iostreams (although theyre more
// virtual/runtime polymorphic than iostrmea). theyre modeled after
// Java File.
//
// @author Aleksander Demko
//

//
// the flow_i interfaces allow polymorphic persinance, often wrapped
// around a file_i based driver. depending on the driver (see polyflow.h)
//
// @author Aleksander Demko
//


namespace scopira
{
  namespace tool
  {
    class flow_i;
    class iflow_i;
    class oflow_i;
    class otflow_i;
    class itflow_i;
    class iobjflow_i;
    class oobjflow_i;

    typedef unsigned char byte_t;
  }
}

class scopira::tool::flow_i :  public virtual scopira::tool::object
{
  public:
    typedef scopira::tool::byte_t byte_t;
    typedef int mode_t;

    enum {
      input_c = 1,
      output_c = 2
    };

      // by powers of 2. bits 0-9 are reserved by this
      // header file. your first bit should be 10 (2^10 == 1024)
      // other decentdants may reserve
      // more
      
    // common methods... seek, close, eof-testing, size ?

    SCOPIRA_EXPORT virtual bool failed(void) const = 0;
};

class scopira::tool::iflow_i : public virtual scopira::tool::flow_i
{
  public:
    SCOPIRA_EXPORT virtual size_t read(byte_t *_buf, size_t _maxsize) = 0;
    virtual size_t read_byte(byte_t &out) {
      return read(&out, 1);
    }

    template <class TT>
      size_t read_array(TT *_buf, size_t _numelem) {
        return read(reinterpret_cast<byte_t*>(_buf), _numelem*sizeof(TT))/sizeof(TT);
      }

    inline size_t read_void(void *_buf, size_t _maxsize) { return read(reinterpret_cast<byte_t*>(_buf), _maxsize); }
};

class scopira::tool::oflow_i : public virtual scopira::tool::flow_i
{
  public:
    SCOPIRA_EXPORT virtual size_t write(const byte_t *_buf, size_t _size) = 0;
    virtual size_t write_byte(byte_t b) {
      return write(&b, sizeof(b));
    }

    template <class TT>
      size_t write_array(const TT *_buf, size_t _numelem) {
        return write(reinterpret_cast<const byte_t*>(_buf), _numelem*sizeof(TT))/sizeof(TT);
      }

    inline size_t write_void(const void *_buf, size_t _size) { return write(reinterpret_cast<const byte_t*>(_buf), _size); }
};

class scopira::tool::itflow_i : public virtual scopira::tool::iflow_i
{
  public:
    SCOPIRA_EXPORT virtual bool read_bool(bool&) = 0;
    SCOPIRA_EXPORT virtual bool read_char(char&) = 0;
    SCOPIRA_EXPORT virtual bool read_short(short&) = 0;
    SCOPIRA_EXPORT virtual bool read_int(int&) = 0;
    SCOPIRA_EXPORT virtual bool read_size_t(size_t&) = 0;
    SCOPIRA_EXPORT virtual bool read_int64_t(int64_t&) = 0;
    SCOPIRA_EXPORT virtual bool read_long(long&) = 0;
    SCOPIRA_EXPORT virtual bool read_float(float&) = 0;
    SCOPIRA_EXPORT virtual bool read_double(double&) = 0;
    SCOPIRA_EXPORT virtual bool read_string(std::string&) = 0;
    template <class TT>
      inline bool read_generic(TT &v);
      // implementation in traits.h to avoid circular refs
};

class scopira::tool::otflow_i : public virtual scopira::tool::oflow_i
{
  public:
    SCOPIRA_EXPORT virtual void write_bool(bool) = 0;
    SCOPIRA_EXPORT virtual void write_char(char) = 0;
    SCOPIRA_EXPORT virtual void write_short(short) = 0;
    SCOPIRA_EXPORT virtual void write_int(int) = 0;
    SCOPIRA_EXPORT virtual void write_size_t(size_t) = 0;
    SCOPIRA_EXPORT virtual void write_int64_t(int64_t) = 0;
    SCOPIRA_EXPORT virtual void write_long(long) = 0;
    SCOPIRA_EXPORT virtual void write_float(float) = 0;
    /***
     * Writes a double
     * @author Aleksander Demko
     */ 
    SCOPIRA_EXPORT virtual void write_double(double) = 0;
    SCOPIRA_EXPORT virtual void write_string(const std::string&) = 0;
    template <class TT>
      inline void write_generic(const TT &v);
      // implementation in traits.h to avoid circular refs
};


class scopira::tool::iobjflow_i : public virtual scopira::tool::itflow_i
{
  public:

    SCOPIRA_EXPORT virtual bool read_object(object* &out) = 0;

    template <class TT> bool read_object_type(TT * &out);
    template <class TT> bool read_object_type(count_ptr<TT> &out);
};
template <class TT> bool scopira::tool::iobjflow_i::read_object_type(TT * &out)
{
  object *o;

  if (!read_object(o))
    return false;
  assert(!o || dynamic_cast<TT*>(o));
  out = dynamic_cast<TT*>(o);
  return true;
};
template <class TT> bool scopira::tool::iobjflow_i::read_object_type(count_ptr<TT> &out)
{
  object *o;

  if (!read_object(o))
    return false;
  assert(!o || dynamic_cast<TT*>(o));
  out = dynamic_cast<TT*>(o);
  return true;
};


class scopira::tool::oobjflow_i : public virtual scopira::tool::otflow_i
{
  public:
    SCOPIRA_EXPORT virtual void write_object(const scopira::tool::object* o) = 0;
    template <class L>
      void write_object_type(const scopira::tool::count_ptr<L> &o)
        { write_object(o.get()); }
};

//
// Friend functions to allow visual ascii conversion of basic types
// (like printoflow)
//

SCOPIRA_EXPORT scopira::tool::oflow_i& operator<<(scopira::tool::oflow_i& o, const char* val);
SCOPIRA_EXPORT scopira::tool::oflow_i& operator<<(scopira::tool::oflow_i& o, const std::string& val);
SCOPIRA_EXPORT scopira::tool::oflow_i& operator<<(scopira::tool::oflow_i& o, char val);
SCOPIRA_EXPORT scopira::tool::oflow_i& operator<<(scopira::tool::oflow_i& o, bool val);
SCOPIRA_EXPORT scopira::tool::oflow_i& operator<<(scopira::tool::oflow_i& o, int val);
SCOPIRA_EXPORT scopira::tool::oflow_i& operator<<(scopira::tool::oflow_i& o, long val);
SCOPIRA_EXPORT scopira::tool::oflow_i& operator<<(scopira::tool::oflow_i& o, double val);
SCOPIRA_EXPORT scopira::tool::oflow_i& operator<<(scopira::tool::oflow_i& o, unsigned int val);
SCOPIRA_EXPORT scopira::tool::oflow_i& operator<<(scopira::tool::oflow_i& o, unsigned long val);
SCOPIRA_EXPORT scopira::tool::oflow_i& operator<<(scopira::tool::oflow_i& o, long long val);
SCOPIRA_EXPORT scopira::tool::oflow_i& operator<<(scopira::tool::oflow_i& o, unsigned long long val);
SCOPIRA_EXPORT scopira::tool::oflow_i& operator<<(scopira::tool::oflow_i& o, scopira::tool::iflow_i& i);

#endif