property_basics.h

Go to the documentation of this file.

/*
    Copyright (C) 2010 Paul Davis

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifndef __libpbd_property_basics_h__
#define __libpbd_property_basics_h__

#include <glib.h>
#include <set>
#include <vector>

#include "pbd/libpbd_visibility.h"
#include "pbd/xml++.h"

class Command;

namespace PBD {

class LIBPBD_API PropertyList;
class LIBPBD_API StatefulDiffCommand;   

typedef GQuark PropertyID;

template<typename T>
struct LIBPBD_TEMPLATE_API PropertyDescriptor {
        PropertyDescriptor () : property_id (0) {}
        PropertyDescriptor (PropertyID pid) : property_id (pid) {}
        
        PropertyID property_id;
        typedef T value_type;
};

class LIBPBD_TEMPLATE_API PropertyChange : public std::set<PropertyID>
{
public:
        LIBPBD_TEMPLATE_MEMBER_API PropertyChange() {}
        LIBPBD_TEMPLATE_MEMBER_API ~PropertyChange() {}

        template<typename T> PropertyChange(PropertyDescriptor<T> p);

        LIBPBD_TEMPLATE_MEMBER_API PropertyChange(const PropertyChange& other) : std::set<PropertyID> (other) {}

        LIBPBD_TEMPLATE_MEMBER_API PropertyChange operator=(const PropertyChange& other) {
                clear ();
                insert (other.begin (), other.end ());
                return *this;
        }

        template<typename T> PropertyChange operator=(PropertyDescriptor<T> p);
        template<typename T> bool contains (PropertyDescriptor<T> p) const;

        LIBPBD_TEMPLATE_MEMBER_API bool contains (const PropertyChange& other) const {
                for (const_iterator x = other.begin (); x != other.end (); ++x) {
                        if (find (*x) != end ()) {
                                return true;
                        }
                }
                return false;
        }

        void add (PropertyID id)               { insert (id); }
        void add (const PropertyChange& other) { insert (other.begin (), other.end ()); }
        template<typename T> void add (PropertyDescriptor<T> p);
};

class LIBPBD_API PropertyBase
{
public:
        PropertyBase (PropertyID pid)
                : _property_id (pid)
        {}

        virtual ~PropertyBase () {}


        /* MANAGEMENT OF Stateful STATE */

        virtual bool set_value (XMLNode const &) = 0;

        virtual void get_value (XMLNode& node) const = 0;


        /* MANAGEMENT OF HISTORY */

        virtual void clear_changes () = 0;

        virtual void clear_owned_changes () {}

        virtual bool changed () const = 0;

        virtual void invert () = 0;
        

        /* TRANSFERRING HISTORY TO / FROM A StatefulDiffCommand */

        virtual void get_changes_as_xml (XMLNode *) const = 0;
        
        virtual void get_changes_as_properties (PropertyList& changes, Command *) const = 0;

        virtual void rdiff (std::vector<Command*> &) const {}

        virtual PropertyBase* clone_from_xml (const XMLNode &) const { return 0; }


        /* VARIOUS */
        
        virtual PropertyBase* clone () const = 0;

        virtual void apply_changes (PropertyBase const *) = 0;

        const gchar* property_name () const { return g_quark_to_string (_property_id); }
        PropertyID   property_id () const   { return _property_id; }

        bool operator==(PropertyID pid) const {
                return _property_id == pid;
        }

protected:      
        /* copy construction only by subclasses */
        PropertyBase (PropertyBase const & b)
                : _property_id (b._property_id)
        {}
        
private:
        PropertyID _property_id;

};

}

#endif /* __libpbd_property_basics_h__ */