OpenSceneGraph/include/osgIntrospection/ReaderWriter

#ifndef OSGINTROSPECTION_READERWRITER_
#define OSGINTROSPECTION_READERWRITER_

#include <osgIntrospection/Value>
#include <osgIntrospection/Type>
#include <osgIntrospection/Exceptions>
#include <osgIntrospection/variant_cast>

#include <osg/Vec2>
#include <osg/Vec3>
#include <osg/Vec4>
#include <osg/ref_ptr>

#include <iostream>


namespace osgIntrospection
{

    /// This is the base class for reader/writer objects. A ReaderWriter's
    /// purpose is to provide the means for writing the content of a Value
    /// object to a stream and for reading it back. Descendants can either
    /// be specialized for just one data type or they can handle several
    /// types, that's up to the implementor. A derived class is not required
    /// to support all streaming operations (text write, text read, bin write
    /// and bin read), it can implement just some of them, although full
    /// support is strongly encouraged.
    class ReaderWriter
    {
    public:
        class Options
        {
        public:
            Options(): fno_(false) {}
            virtual ~Options() {}

            bool getForceNumericOutput() const    { return fno_; }
            void setForceNumericOutput(bool fno)  { fno_ = fno; }

        private:
            bool fno_;
        };

        /// Writes a textual representation of the value's content to a stream.
        virtual std::ostream &writeTextValue(std::ostream &, const Value &v, const Options* = 0) const { throw StreamingNotSupportedException(StreamingNotSupportedException::TEXT_WRITE, v.getType().getStdTypeInfo()); }

        /// Reads a textual representation of the value's content from a stream.
        virtual std::istream &readTextValue(std::istream &, Value &v, const Options* = 0) const { throw StreamingNotSupportedException(StreamingNotSupportedException::TEXT_READ, v.getType().getStdTypeInfo()); }

        /// Writes a binary representation of the value's content to a stream.
        virtual std::ostream &writeBinaryValue(std::ostream &, const Value &v, const Options* = 0) const { throw StreamingNotSupportedException(StreamingNotSupportedException::BINARY_WRITE, v.getType().getStdTypeInfo()); }

        /// Reads a binary representation of the value's content from a stream.
        virtual std::istream &readBinaryValue(std::istream &, Value &v, const Options* = 0) const { throw StreamingNotSupportedException(StreamingNotSupportedException::BINARY_READ, v.getType().getStdTypeInfo()); }

        /// Virtual destructor.
        virtual ~ReaderWriter() {}
    };

    /// This class template provides basic default streaming capabilities
    /// for all types that define streaming operators (<< and >>). Most of
    /// the standard types are able to be read and written this way, so the
    /// StdReaderWriter template can be a convenient default for several
    /// types. The binary representation is a raw copy of the memory content.
    ///
    /// TO-DO: improve binary streaming and avoid arch dependency.
    ///
    template<typename T>
    class StdReaderWriter: public ReaderWriter
    {
    public:
        virtual std::ostream &writeTextValue(std::ostream &os, const Value &v, const Options * = 0) const
        {
            return (os << variant_cast<T>(v));
        }

        virtual std::istream &readTextValue(std::istream &is, Value &v, const Options * = 0) const
        {
            if (v.isEmpty()) v = Value(T());
            return (is >> variant_cast<T &>(v));
        }

        virtual std::ostream &writeBinaryValue(std::ostream &os, const Value &v, const Options * = 0) const
        {
            return os.write(reinterpret_cast<const char *>(extract_raw_data<T>(v)), sizeof(T));
        }

        virtual std::istream &readBinaryValue(std::istream &is, Value &v, const Options * = 0) const
        {
            if (v.isEmpty()) v = Value(T());
            return is.read(reinterpret_cast<char *>(extract_raw_data<T>(v)), sizeof(T));
        }

    };

    /// This ReaderWriter can be used to read and write enumeration values.
    /// The textual representation will be the enum label, if found, or the
    /// numerical value. The binary representation doesn't take label names
    /// into account.
    template<typename T>
    class EnumReaderWriter: public ReaderWriter
    {
        virtual std::ostream &writeTextValue(std::ostream &os, const Value &v, const Options *options = 0) const
        {
            int numeric = static_cast<int>(variant_cast<T>(v));

            if (!options || !options->getForceNumericOutput())
            {
                const Type &type = v.getType();
                const EnumLabelMap &elm = type.getEnumLabels();
                EnumLabelMap::const_iterator i = elm.find(numeric);
                if (i != elm.end())
                {
                    os << i->second;
                    return os;
                }
                else
                {
                    std::vector<std::string> labels;

                    // it could be a bitmask
                    for (EnumLabelMap::const_iterator i=elm.begin(); i!=elm.end(); ++i)
                    {
                        if (i->first != 0 && ((i->first & numeric) == i->first))
                        {
                            numeric ^= i->first;
                            labels.push_back(i->second);
                        }
                    }

                    // check whether all bits were discovered
                    if (numeric == 0)
                    {
                        for (std::vector<std::string>::const_iterator i=labels.begin(); i!=labels.end(); ++i)
                        {
                            os << *i;
                            if ((i+1) != labels.end()) os << " | ";
                        }
                        return os;
                    }
                }
            }

            return os << numeric;
        }

        virtual std::istream &readTextValue(std::istream &is, Value &v, const Options * = 0) const
        {
            if (v.isEmpty()) v = Value(T());

            int i;
            if (is >> i)
            {
                variant_cast<T &>(v) = static_cast<T>(i);
                return is;
            }

            is.clear();

            std::string s;            
            if (is >> s)
            {
                const Type &type = v.getType();
                const EnumLabelMap &elm = type.getEnumLabels();
                for (EnumLabelMap::const_iterator i=elm.begin(); i!=elm.end(); ++i)
                {
                    if (i->second.compare(s) == 0)
                    {
                        variant_cast<T &>(v) = static_cast<T>(i->first);
                        return is;
                    }
                }
            }

            return is;
        }

        virtual std::ostream &writeBinaryValue(std::ostream &os, const Value &v, const Options * = 0) const
        {
            return os.write(reinterpret_cast<const char *>(extract_raw_data<T>(v)), sizeof(T));
        }

        virtual std::istream &readBinaryValue(std::istream &is, Value &v, const Options * = 0) const
        {
            if (v.isEmpty())
                v = Value(T());
            return is.read(reinterpret_cast<char *>(extract_raw_data<T>(v)), sizeof(T));
        }

    };

    /// This is a ReaderWriter class that can be used to read and write
    /// pointer values. Note: template parameter T must be a pointer!
    template<typename T>
    class PtrReaderWriter: public ReaderWriter
    {
    public:
        virtual std::ostream &writeTextValue(std::ostream &os, const Value &v, const Options* = 0) const
        {
            return (os << (void*)variant_cast<T>(v));
        }

        virtual std::istream &readTextValue(std::istream &is, Value &v, const Options* = 0) const
        {
            void *ptr;
            is >> ptr;
            v = Value(T(ptr));
            return is;
        }

        virtual std::ostream &writeBinaryValue(std::ostream &os, const Value &v, const Options* = 0) const
        {
            return os.write(reinterpret_cast<const char *>(extract_raw_data<T>(v)), sizeof(T));
        }

        virtual std::istream &readBinaryValue(std::istream &is, Value &v, const Options* = 0) const
        {
            T ptr;
            is.read(reinterpret_cast<char *>(&ptr), sizeof(T));
            v = Value(ptr);
            return is;
        }
    };

}

#endif