---

TypeStream.h

/*****************************************************************************
 * Author:   Valient Gough <vgough@pobox.com>
 *
 *****************************************************************************
 * Copyright (c) 2001, Valient Gough
 *
 * This library is free software; you can distribute it and/or modify it under
 * the terms of the GNU Lesser General Public License (LGPL), as published by
 * the Free Software Foundation; either version 2.1 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 LGPL in the file COPYING for more
 * details.
 *
 */

#ifndef _TypeStream_incl_
#define _TypeStream_incl_

#include <rel/StreamCoder.h>

#include <string>

namespace rel
{

    // BeginKey is a marker used in TypeStream to tell when a named section
    // begins.
    struct BeginKey
    {
        OpaqueValue name;

        BeginKey() {}
        BeginKey(const BeginKey &src)
            : name(src.name) {}
    };

    // no value associated with EndKey - it is just a placeholder to tell when
    // a named section ends (corresponding to the the last BeginKey instance).
    struct EndKey
    {
    };


    class TypeStream
    {
    public:
        typedef StreamCoder::size_type size_type;

        typedef bool (*CodingWriteFunction)(TypeStream &, const OpaqueValue &);

        /* Register an encoding function for an object type.  All basic types
           are handled internally - but other types must have a registered
           encoder.  There is no decode function registry because the encode
           data is expected to be self-constructing.  That is, given the
           encoded data, a lookup into the global object map will produce the
           decoded object.
         */
        static void addEncoder(CodingWriteFunction func, const char *typeName);

        TypeStream(const SmartPtr<StreamCoder> &streamCoder);
        virtual ~TypeStream();


        bool atEnd() const;
        void flush();
        int getReadDescriptor() const;
        bool isDirectAccess() const;
        size_type at() const;
        void at(size_type offset);


        // two methods for writing integers
        bool read(uint8_t &) const;
        bool read(int32_t &) const;
        bool read(int64_t &) const;
        // method for floating point
        bool read(double &) const;
        // read string (can contain arbitrary binary data)
        bool read(std::string &) const;
        // read an arbitrary type (requires self-constructing data when treated
        // as a find operation in the Global Object Map). 
        bool read(OpaqueValue &) const;


        // two methods for writing integers
        bool write(const uint8_t &);
        bool write(const int32_t &);
        bool write(const int64_t &);
        // method for writing floating point
        bool write(const double &);
        // write string (can contain arbitrary binary data)
        bool write(const std::string &);
        bool write(const char *bytes, size_type length);

        // write an arbitrary type. 
        bool write(const OpaqueValue &);

        // write BeginKey marker (the next value written is the key, then any
        // number of values may be written, followed by EndKey)
        bool writeBeginKey();
        bool writeEndKey();

        bool readBeginKey() const;
        bool readEndKey() const;

        // write null marker..
        bool writeNull();
        bool readNull() const;

        bool append(const TypeStream &src);

        // for debugging
        SmartPtr<char*> print();

    private:
        void init();
        bool checkType(uint8_t expectedType) const;
        bool readConstructable(OpaqueValue &value) const;
        static void addEncoder(CodingWriteFunction func, const char *typeName,
                uint8_t marker);

        struct TypeStreamImpl *impl;
    };

    class OperationError : public std::exception
    {
        string _what;
    public:
        OperationError(const char *operationType, const char *operandType);
        OperationError(const char *operationType, 
                const std::string &operandType);
        const char *what() const;
    };

} // namespace rel


// Define the API for standard operator << types, along with smart pointer
// helpers.  These are defined outside of the rel namespace..
#define TYPEDIOINTERFACE(Type) \
rel::TypeStream &operator << (rel::TypeStream &, const Type &); \
const rel::TypeStream &operator >> (const rel::TypeStream &, Type &);

TYPEDIOINTERFACE(uint8_t)
TYPEDIOINTERFACE(int32_t)
TYPEDIOINTERFACE(int64_t)
TYPEDIOINTERFACE(double)
TYPEDIOINTERFACE(std::string)
TYPEDIOINTERFACE(rel::OpaqueValue)

// same as output for std::string, but write char*...
rel::TypeStream &operator << (rel::TypeStream &, const char *);

// embed one stream into another (not an append).  Use TypeStream::append to
// append one stream without any other markers..
rel::TypeStream &operator << (rel::TypeStream &, const rel::TypeStream &);
// read an embedded stream.
rel::TypeStream &operator >> (rel::TypeStream &, rel::TypeStream &);

#endif

---