setunion.h

Go to the documentation of this file.

 
 
 
// Copyright (C) 1997-2020 by Pawel Pilarczyk.
//
// This file is part of my research software package. This 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 3 of the License, or (at your option) any later version.
//
// This software 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,
// please, see <https://www.gnu.org/licenses/>.
 
// 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 *this;
} /* 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_