Logo Search packages:      
Sourcecode: vdr-plugin-burn version File versions  Download package

property.h

#ifndef VGS_PROCTOOLS_PROPERTY_H
#define VGS_PROCTOOLS_PROPERTY_H

#include <string>
#include <sstream>
#include <stdexcept>
#include <map>
#include <boost/utility/addressof.hpp>

namespace proctools
{

      // --- property_base -----------------------------------------------------

      class property_base
      {
      public:
            virtual void set( const std::string& value ) = 0;
            virtual std::string as_string() = 0;

            const std::string& name() const { return m_name; }

      protected:
            property_base( const std::string& name_ ): m_name( name_ ) {}
            virtual ~property_base() {}

      private:
            std::string m_name;
      };

      // --- property ----------------------------------------------------------

      template<typename Ty>
      class property;

      template<typename Ty>
      std::ostream& operator<<(std::ostream& os, const property<Ty>& value);

      class property_bag;

      template<typename Ty>
      class property: public property_base
      {
      public:
            typedef Ty value_type;

            property( const std::string& name_, const Ty& value_ );

            property& operator=(const value_type& value);

            template<typename From>
            property& operator=(const From& value);

            operator const value_type&() const { return m_value; }
            operator value_type&() { return m_value; }

            virtual void set(const std::string& value);
            virtual std::string as_string();

            friend std::ostream& operator<< <>(std::ostream& os, const property<Ty>& value);

      private:
            property(const value_type& value): m_value( value ) { }
            Ty m_value;
      };

      template<typename Ty>
      property<Ty>& property<Ty>::operator=(const Ty& value)
      {
            m_value = value;
            return *this;
      }

      template<typename Ty> template<typename From>
      property<Ty>& property<Ty>::operator=(const From& value)
      {
            std::stringstream str;
            str << value;
            if ((str >> m_value).fail())
                  throw std::invalid_argument("property<Ty>::operator=(const From& value)");
            return *this;
      }

      template<> template<typename From>
      property<std::string>& property<std::string>::operator=(const From& value)
      {
            std::ostringstream str;
            str << value;
            m_value = str.str();
            return *this;
      }

      template<typename Ty>
      void property<Ty>::set(const std::string& value)
      {
            *this = value;
      }

      template<typename Ty>
      std::string property<Ty>::as_string()
      {
            std::stringstream str;
            str << m_value;
            return str.str();
      }

      template<typename Ty>
      std::ostream& operator<<(std::ostream& os, const property<Ty>& value)
      {
            return os << value.m_value;
      }

      // --- property_bag ------------------------------------------------------

      class property_bag
      {
      public:
            typedef std::map<std::string, property_base*> property_map;

            const std::string& append( const std::string& name_, property_base* property_ );

            property_map::iterator begin() { return m_values.begin(); }
            property_map::iterator end() { return m_values.end(); }

            bool set(const std::string& name, const std::string& value);

            bool operator==(const property_bag& other);
            bool operator!=(const property_bag& other);

      protected:
            property_bag() {}
            virtual ~property_bag() {}

            property_bag& operator=(const property_bag& object);

      private:
            property_bag(const property_bag& object); // property bags must be constructed prior to copying

            property_map m_values;
      };

#define PROCTOOLS_INIT_PROPERTY( property_, default_ ) \
      property_( append( #property_, &property_ ), default_ )

      // --- property ----------------------------------------------------------

      template<typename Ty>
      property<Ty>::property( const std::string& name_, const Ty& value_ ):
                  property_base( name_ ),
                  m_value( value_ )
      {
      }

}

#endif // VGS_PROCTOOLS_PROPERTY_H

Generated by  Doxygen 1.6.0   Back to index