element.hh

Go to the documentation of this file.

// element.hh: this file is part of the Vaucanson project.
//
// Vaucanson, a generic library for finite state machines.
//
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 The Vaucanson Group.
//
// 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.
//
// The complete GNU General Public Licence Notice can be found as the
// `COPYING' file in the root directory.
//
// The Vaucanson Group consists of people listed in the `AUTHORS' file.
//
#ifndef VCSN_DESIGN_PATTERN_ELEMENT_HH
# define VCSN_DESIGN_PATTERN_ELEMENT_HH

# include <vaucanson/design_pattern/predecls.hh>
# include <vaucanson/design_pattern/meta_element_root.hh>
# include <vaucanson/design_pattern/element_ops.hh>
# include <vaucanson/design_pattern/default_ops.hh>
# include <vaucanson/design_pattern/slots.hh>

namespace vcsn {

  /*--------.
  | Element |
  `--------*/

  template<typename S, typename T>
  class Element : public MetaElement<S, T>, private SetSlot<S>
  {
  public:
    typedef S         set_t;

    typedef T         value_t;

    static const bool dynamic    = dynamic_traits<S>::ret
                                   || MetaElement<S, T>::dynamic_value;

    /*--------------------.
    | Default constructor |
    `--------------------*/

    Element();

    /*--------------------------.
    | Constructors from Element |
    `--------------------------*/

    Element(const Element& other);

    template<typename U>
    Element(const Element<S, U>& other);

    template<typename OtherS, typename U>
    Element(const Element<OtherS, U>& other);

    /*-------------------------.
    | Constructors from values |
    `-------------------------*/


    Element(const T& other);

    template<typename U>
    Element(const U& other);

    /*-------------------------------------------------.
    | Constructors from structural elements and values |
    `-------------------------------------------------*/

    explicit Element(const S& structure);

    Element(const S& structure, const T& other);

    template<typename U> Element(const S& structure, const U& other);

    template<typename OtherS, typename U>
    Element(const S& structure, const Element<OtherS, U>& other);

    /*-----------.
    | Assignment |
    `-----------*/

    Element& operator=(const Element& other);

    template<typename U>
    Element& operator=(const Element<S, U>& other);

    template<typename OtherS, typename U>
    Element& operator=(const Element<OtherS, U>& other);

    template<typename U>
    Element& operator=(const U& other);

    /*--------------------------.
    | Design pattern facilities |
    `--------------------------*/

    const S&    structure() const;

    void        attach(const S& structure);


    T&          value();
    const T&    value() const;

  private :
    T                   value_;
  };

} // vcsn


# if !defined VCSN_USE_INTERFACE_ONLY || defined VCSN_USE_LIB
#  include <vaucanson/design_pattern/element.hxx>
# endif // VCSN_USE_INTERFACE_ONLY

#endif // ! VCSN_DESIGN_PATTERN_ELEMENT_HH