src/client/proxies/VertexBasedProxy.hh

/*
 * Copyright Staffan Gimåker 2008-2010.
 *
 * ---
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 */

#ifndef PEEKABOT_CLIENT_VERTEX_BASED_PROXY_HH_INCLUDED
#define PEEKABOT_CLIENT_VERTEX_BASED_PROXY_HH_INCLUDED


#include "ObjectProxy.hh"
#include "../DelayedDispatch.hh"
#include "../../Deprecated.hh"

#include <boost/scoped_ptr.hpp>
#include <cstddef>


namespace peekabot
{
    namespace client
    {
        class PEEKABOT_API VertexSet
        {
            friend class VertexBasedProxyBase;

        public:
            VertexSet();

            VertexSet(const VertexSet &other);

            ~VertexSet();

            VertexSet &operator=(const VertexSet &other);

            void add_vertex(
                float x, float y, float z) PEEKABOT_DEPRECATED;

            void add(float x, float y, float z);

            void clear();

            std::size_t size() const;

            bool empty() const;

        private:
            class Impl;
            boost::scoped_ptr<Impl> m_impl;
        };


        class PEEKABOT_API ColoredVertexSet
        {
            friend class VertexBasedProxyBase;

        public:
            ColoredVertexSet();

            ColoredVertexSet(const ColoredVertexSet &other);

            ~ColoredVertexSet();

            ColoredVertexSet &operator=(const ColoredVertexSet &other);

            void add(
                float x, float y, float z,
                float r, float g, float b);

            void clear();

            std::size_t size() const;

            bool empty() const;

        private:
            class Impl;
            boost::scoped_ptr<Impl> m_impl;
        };


        class PEEKABOT_API VertexBasedProxyBase : virtual public ObjectProxyBase
        {
        public:
            typedef peekabot::client::VertexSet VertexSet;


            VertexBasedProxyBase();

            VertexBasedProxyBase(const VertexBasedProxyBase &p);

            DelayedDispatch set_vertices(const VertexSet &vertices);

            DelayedDispatch add_vertices(const VertexSet &vertices);

            DelayedDispatch set_vertices(const ColoredVertexSet &vertices);

            DelayedDispatch add_vertices(const ColoredVertexSet &vertices);

            DelayedDispatch add_vertex(
                float x, float y, float z) PEEKABOT_DEPRECATED;

            DelayedDispatch clear_vertices();

            DelayedDispatch set_max_vertices(boost::uint32_t n);

            DelayedDispatch set_vertex_overflow_policy(
                VertexOverflowPolicy overflow_policy);
        };

        class PEEKABOT_API VertexBasedProxy : public VertexBasedProxyBase
        {
        public:
            VertexBasedProxy();

            VertexBasedProxy(const VertexBasedProxyBase &p);

            VertexBasedProxy &operator=(const VertexBasedProxy &p);

            VertexBasedProxy &operator=(const VertexBasedProxyBase &p);

            DelayedDispatch assign(const ObjectProxyBase &p);

            DelayedDispatch assign(
                PeekabotClient &client,
                const std::string &path);

            DelayedDispatch assign(
                const ObjectProxyBase &parent,
                const std::string &rel_path);
        };
    }
}


#endif // PEEKABOT_CLIENT_VERTEX_BASED_PROXY_HH_INCLUDED