setunion.h

Go to the documentation of this file.

// Copyright (C) 1997-2010 by Pawel Pilarczyk.
//
// This file is part of the Homology Library.  This library 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 library 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 software; see the file "license.txt".  If not, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// Started on April 22, 2008. Last revision: April 23, 2008.


#ifndef _CHOMP_STRUCT_SETUNION_H_
#define _CHOMP_STRUCT_SETUNION_H_

#include "chomp/system/config.h"

namespace chomp {
namespace homology {


// class templates defined within this header file (in this order):
template <class set1type, class set2type>
class setunion;


// --------------------------------------------------
// ------------------- set union --------------------
// --------------------------------------------------

template <class set1type, class set2type>
class setunion
{
public:
        typedef typename set1type::value_type value_type;

        setunion (const set1type &_set1, const set2type &_set2);

        setunion (const setunion<set1type,set2type> &s);

        setunion &operator = (const setunion<set1type,set2type> &s);

        ~setunion ();

        const set1type &get1 () const;

        const set2type &get2 () const;

        int_t getnumber (const typename set1type::value_type &e) const;

        bool checknum (int_t n) const;

        bool check (const typename set1type::value_type &e) const;

        const typename setunion<set1type,set2type>::value_type &
                operator [] (int_t n) const;

        const typename setunion<set1type,set2type>::value_type &get (int_t n)
                const;

        int_t size () const;

        bool empty () const;

private:
        const set1type *set1;

        const set2type *set2;

}; /* class setunion */

// --------------------------------------------------

template <class set1type, class set2type>
inline setunion<set1type,set2type>::setunion (const set1type &_set1,
        const set2type &_set2): set1 (&_set1), set2 (&_set2)
{
        return;
} /* setunion::setunion */

template <class set1type, class set2type>
inline setunion<set1type,set2type>::~setunion ()
{
        return;
} /* setunion::~setunion */

template <class set1type, class set2type>
inline setunion<set1type,set2type>::setunion
        (const setunion<set1type,set2type> &)
{
        throw "Trying to use the copy constructor of a set union.";
        return;
} /* setunion::setunion */

template <class set1type, class set2type>
inline setunion<set1type,set2type> &setunion<set1type,set2type>::
	operator = (const setunion<set1type,set2type> &)
{
        throw "Trying to use the assignment operator of a set union.";
        return;
} /* setunion::setunion */

template <class set1type, class set2type>
inline const set1type &setunion<set1type,set2type>::get1 () const
{
        return *set1;
} /* setunion::get1 */

template <class set1type, class set2type>
inline const set2type &setunion<set1type,set2type>::get2 () const
{
        return *set2;
} /* setunion::get2 */

template <class set1type, class set2type>
inline int_t setunion<set1type,set2type>::getnumber
        (const typename set1type::value_type &e) const
{
        int_t n = set1 -> getnumber (e);
        if (n >= 0)
                return n;
        n = set2 -> getnumber (e);
        if (n >= 0)
                return set1 -> size () + n;
        else
                return n;
} /* setunion::getnumber */

template <class set1type, class set2type>
inline bool setunion<set1type,set2type>::checknum (int_t n) const
{
        return ((n >= 0) && (n < set1 -> size () + set2 -> size ()));
} /* setunion::checknum */

template <class set1type, class set2type>
inline bool setunion<set1type,set2type>::check
        (const typename set1type::value_type &e) const
{
        return (set1 -> check (e) || set2 -> check (e));
} /* setunion::check */

template <class set1type, class set2type>
inline const typename setunion<set1type,set2type>::value_type &
        setunion<set1type,set2type>::get (int_t n) const
{
        int_t size1 = set1 -> size ();
        if (n < size1)
                return set1 -> get (n);
        else
                return set2 -> get (n - size1);
} /* setunion::get */

template <class set1type, class set2type>
inline const typename setunion<set1type,set2type>::value_type &
        setunion<set1type,set2type>::operator [] (int_t n) const
{
        return get (n);
} /* setunion::operator [] */

template <class set1type, class set2type>
inline int_t setunion<set1type,set2type>::size () const
{
        return (set1 -> size () + set2 -> size ());
} /* setunion::size */

template <class set1type, class set2type>
inline bool setunion<set1type,set2type>::empty () const
{
        return (set1 -> empty () && set2 -> empty ());
} /* setunion::empty */

// --------------------------------------------------

template <class set1type, class set2type>
inline setunion<set1type,set2type> makesetunion (const set1type &set1,
        const set2type &set2)
{
        return setunion<set1type,set2type> (set1, set2);
} /* makesetunion */

// Assigns the union of two sets to a single set using the assignment
// operator and the "add" function.
//template <class set1type, class set2type>
//inline set1type &operator = (set1type &set1,
//      const setunion<set1type,set2type> &set2)
//{
//      set1 = set2. get1 ();
//      set1. add (set2. get2 ());
//      return set1;
//} /* operator = */


} // namespace homology
} // namespace chomp

#endif // _CHOMP_STRUCT_SETUNION_H_