stream.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 2008 Autodesk, Inc.
// All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
//
//**************************************************************************/
// DESCRIPTION:
// CREATED: October 2008
//**************************************************************************/

namespace mudbox {

typedef Node *NodePointer;

class MBDLL_DECL Stream : public Node
{
    DECLARE_CLASS;
protected:
    Stream( void );
    
public:
    enum { chunk = 0x800000 };

    virtual ~Stream( void );

    virtual QString FileName( void ) const;

    virtual bool IsValid( void );

    virtual bool IsOlderThan(
        int iVersion    
        ) const;

    virtual bool IsNewerThan(
                             int iVersion   
                             ) const;
    
    virtual int ClassVersion( const class ClassDesc *pClass ) const;
    
    template <typename Type>
    bool IsOlderThan(
                     int iVersion,  
                     Type * 
                     ) const { return ClassVersion( Type::StaticClass() ) < iVersion; };
    
    template <typename Type>
    bool IsNewerThan(
                     int iVersion,  
                     Type * 
                     ) const { return ClassVersion( Type::StaticClass() ) > iVersion; };

    virtual bool IsStoring( void ) const;

    virtual void SetError( bool bError );

    virtual int Version( void ) const;

    virtual uint64 CurrentPosition( void ) const;

    virtual void SetCurrentPosition(
        uint64 iPosition        
        );

    virtual void ReportCorruption( void );
    
    virtual void Open(
        const QString &sFileName,       
        bool bStoring = false,      
        int iProjectedFileSize = 0,     
        bool bProgressBar = true        
    );
    
    virtual void Reopen(
        bool bStoring = false   
        );

    virtual bool Close( void );

    virtual bool Eof( void );

    virtual bool ReadContents( void );

    virtual size_t Read(
        void *pBuffer,  
        size_t iSize    
        );

    virtual size_t Write(
        const void *pBuffer,    
        size_t iSize            
        );

    inline int ReadInt( void ) { int i=0; operator >>( i ); return i; };

    virtual void ReadToFile(
        const QString &sFile    
        );

    virtual void WriteFromFile(
        const QString &sFile    
        );

    template < typename type >
    inline Stream &operator >>( type &v ) { MB_VERIFY_EQ( Read( &v, sizeof(type) ), sizeof(type) ); return *this; };

    template < typename type >
    inline Stream &operator <<( const type &v ) { MB_VERIFY_EQ( Write( &v, sizeof(type) ), sizeof(type) ); return *this; };

    virtual Node *ReadPointer( void );
    virtual void WritePointer( Node *pPointer );

    template < typename type >
    inline Stream &operator >>( type *&p ) { p = dynamic_cast<type *>( ReadPointer() ); return *this; }; 

    template < typename type >
    inline Stream &operator <<( type *&p ) { WritePointer( p ); return *this; };

    template < typename type >
    inline Stream &operator >>( Store<type> &s );

    template < typename type >
    inline Stream &operator <<( const Store<type> &s );

    Stream &operator >>( QString &s );
    Stream &operator <<( const QString &s );

    template < typename type >
    inline Stream &operator >>( QVector<type> &s )
    {
        int iSize = ReadInt();
        s.resize( iSize );
        Read( s.data(), iSize*sizeof(type) );
        return *this;
    };

    template < typename type >
    inline Stream &operator <<( const QVector<type> &s )
    {
        (*this) << s.size();
        Write( s.data(), s.size()*sizeof(type) );
        return *this;
    };

    virtual void WriteIntArray( const Store< unsigned int >& s );

    virtual void ReadIntArray( Store< unsigned int >& s );

private:
    virtual void RegisterBlock( const QString &sName, qint64 iSize, qint64 iItemSize );
};

template < typename type >
inline Stream &operator ==( Stream &s, type &v ) { if ( s.IsStoring() ) s << v; else s >> v; return s; };

template < typename type >
inline Stream &operator ==( Stream &s, const type &v ) { if ( s.IsStoring() ) s << v; else s >> *((type*)&v); return s; };

template < typename type >
void Store<type>::Serialize( class Stream &s )
{
    if ( !s.IsStoring() )
        SetItemCount( s.ReadInt() );
    else
        s << m_iSize;
    for ( unsigned int i = 0; i < m_iSize; i++ )
        s == operator[]( i );
};

template < typename type >
inline Stream &Stream::operator <<( const Store<type> &o ) { (*this) << o.ItemCount(); Write( &(o[0]), sizeof(type)*o.ItemCount() ); RegisterBlock( o.Name(), o.Size(), sizeof(type) ); return *this; };
template < typename type >
inline Stream &Stream::operator >>( Store<type> &o ) { unsigned int iSize; (*this) >> iSize; if ( o.SetItemCount( iSize ) && iSize ) Read( &(o[0]), sizeof(type)*iSize ); RegisterBlock( o.Name(), o.Size(), sizeof(type) ); return *this; };


template<>
inline Stream &Stream::operator <<( const Store<unsigned int> &o ) { WriteIntArray(o); return *this; };

template<>
inline Stream &Stream::operator >>( Store<unsigned int> &o ) { ReadIntArray(o); return *this; };



template < typename type >
inline void AttributeInstance<type>::Serialize( Stream &s ) { s == m_cValue; };
template < typename type >
inline void AttributePointer<type>::Serialize( Stream &s )
{
    if ( s.IsStoring() )
        s.WritePointer( AttributeInstance<type *>::Value() );
    else
        SetValue( dynamic_cast<type *>( s.ReadPointer() ), true );
};
    
    
template< typename T >    
void ExtendableStore<T>::Serialize( Stream& s )
{
    s == m_iBlockItemCount;
    s == m_iBlockPow;
    s == m_iBlockMask;
    s == m_iLogicalItemCount;
    s == m_iAlignment;
       
    if( s.IsStoring() )
    {
        s << m_aBlocks.ItemCount();
        for( unsigned int i = 0; i < m_aBlocks.ItemCount(); ++i )
           s.Write( (void*)m_aBlocks[i], sizeof(T) * m_iBlockItemCount );
    }
    else
    {
        unsigned int iC = 0;
        s >> iC;
        m_aBlocks.SetItemCount( iC );
        for( unsigned int i = 0; i < m_aBlocks.ItemCount(); ++i )
        {
            m_aBlocks[i] = (T*)Block::AlignedAlloc( sizeof(T) * m_iBlockItemCount, m_iAlignment );
            s.Read( (void*)m_aBlocks[i], sizeof(T) * m_iBlockItemCount );
        }
    }
}; 

}; // end of namespace mudbox