dataformfield.h

/*
  Copyright (c) 2005-2009 by Jakob Schroeter <js@camaya.net>
  This file is part of the gloox library. http://camaya.net/gloox

  This software is distributed under a license. The full license
  agreement can be found in the file LICENSE in this distribution.
  This software may not be copied, modified, sold or distributed
  other than expressed in the named license agreement.

  This software is distributed without any warranty.
*/


#ifndef DATAFORMFIELD_H__
#define DATAFORMFIELD_H__

#include "gloox.h"

#include <utility>
#include <string>

namespace gloox
{

  class Tag;

  class GLOOX_API DataFormField
  {

    public:
      enum FieldType
      {
        TypeBoolean,              
        TypeFixed,                
        TypeHidden,               
        TypeJidMulti,             
        TypeJidSingle,            
        TypeListMulti,            
        TypeListSingle,           
        TypeTextMulti,            
        TypeTextPrivate,          
        TypeTextSingle,           
        TypeNone,                 
        TypeInvalid               
      };

    public:

      DataFormField( FieldType type = TypeTextSingle );

      DataFormField( const std::string& name, const std::string& value = EmptyString,
              const std::string& label = EmptyString, FieldType type = TypeTextSingle );

      DataFormField( const Tag* tag );

      virtual ~DataFormField();

      const StringMultiMap& options() const { return m_options; }

      virtual Tag* tag() const;

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

      void setName( const std::string& name ) { m_name = name; }

      void setOptions( const StringMultiMap& options ) { m_options = options; }

      void addOption( const std::string& label, const std::string& value )
          { m_options.insert( std::make_pair( label, value ) ); }

      bool required() const { return m_required; }

      void setRequired( bool required ) { m_required = required; }

      const std::string& label() const { return m_label; }

      void setLabel( const std::string& label ) { m_label = label; }

      const std::string& description() const { return m_desc; }

      void setDescription( const std::string& desc ) { m_desc = desc; }

          const std::string& value() const { return ( m_values.size() > 0 ) ? m_values.front() : EmptyString; }

      void setValue( const std::string& value ) { m_values.clear(); addValue( value ); }

      const StringList& values() const { return m_values; }

      void setValues( const StringList& values ) { m_values = values; }

      void addValue( const std::string& value ) { m_values.push_back( value ); }

      FieldType type() const { return m_type; }

      operator bool() const { return m_type != TypeInvalid; }

    private:
      FieldType m_type;

      StringMultiMap m_options;
      StringList m_values;

      std::string m_name;
      std::string m_desc;
      std::string m_label;

      bool m_required;
  };

}

#endif // DATAFORMFIELD_H__