Array.h

/*
(c) Thales group, 2012

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation;
    version 2 of the License.

    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 GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
Contact: http://eodev.sourceforge.net

Authors:
    Benjamin Bouvier <benjamin.bouvier@gmail.com>
*/
# ifndef __EOSERIAL_ARRAY_H__
# define __EOSERIAL_ARRAY_H__

# include <vector>

# include "Entity.h"
# include "Serializable.h"
# include "Object.h"

namespace eoserial
{

    // Forward declaration for below declarations.
    class Array;

    /*
     * Declarations of functions present in Utils.h
     * These are put here to avoid instead of including the file Utils.h, which would
     * cause a circular inclusion.
     */

    template< class T >
        void unpack( const Array & array, unsigned int index, T & value );

    void unpackObject( const Array & array, unsigned int index, Persistent & value );

    template< class Container, template<class> class UnpackAlgorithm >
        void unpackArray( const Array & array, unsigned int index, Container & container );

    class Array : public eoserial::Entity, public std::vector< eoserial::Entity* >
    {
        protected:
            typedef std::vector< eoserial::Entity* > ArrayChildren;

        public:
            void push_back( const eoserial::Printable* obj )
            {
                ArrayChildren::push_back( obj->pack() );
            }

            void push_back( eoserial::Entity* json )
            {
                ArrayChildren::push_back( json );
            }

            virtual std::ostream& print( std::ostream& out ) const;

            ~Array();

            /*
             * The following parts allows the user to automatically deserialize an eoserial::Array into a
             * standard container, by giving the algorithm which will be used to deserialize contained entities.
             */

            template<class Container>
                struct BaseAlgorithm
                {
                    virtual void operator()( const eoserial::Array& array, unsigned int i, Container & container ) const = 0;
                };

            template<typename C>
                struct UnpackAlgorithm : public BaseAlgorithm<C>
            {
                void operator()( const eoserial::Array& array, unsigned int i, C & container ) const
                {
                    typename C::value_type t;
                    unpack( array, i, t );
                    container.push_back( t );
                }
            };

            template<typename C>
                struct UnpackObjectAlgorithm : public BaseAlgorithm<C>
            {
                void operator()( const eoserial::Array& array, unsigned int i, C & container ) const
                {
                    typename C::value_type t;
                    unpackObject( array, i, t );
                    container.push_back( t );
                }
            };

            template<class Container, template<class T> class UnpackAlgorithm>
                inline void deserialize( Container & array )
                {
                    UnpackAlgorithm< Container > algo;
                    for( unsigned int i = 0, size = this->size();
                            i < size;
                            ++i)
                    {
                        algo( *this, i, array );
                    }
                }
    };

} // namespace eoserial

# endif // __EOSERIAL_ARRAY_H__