FeatureContainer.hpp

Go to the documentation of this file.

/* 
 * FeatureContainer.hpp 
 *
 * This file is part of the Chemical Data Processing Toolkit
 *
 * Copyright (C) 2003 Thomas Seidel <thomas.seidel@univie.ac.at>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; see the file COPYING. If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
 
#ifndef CDPL_PHARM_FEATURECONTAINER_HPP
#define CDPL_PHARM_FEATURECONTAINER_HPP
 
#include <memory>
 
#include "CDPL/Pharm/APIPrefix.hpp"
#include "CDPL/Pharm/FeatureCompareFunction.hpp"
#include "CDPL/Chem/Entity3DContainer.hpp"
#include "CDPL/Util/IndexedElementIterator.hpp"
#include "CDPL/Base/PropertyContainer.hpp"
 
 
namespace CDPL
{
 
    namespace Pharm
    {
 
        class Feature;
 
        class CDPL_PHARM_API FeatureContainer : public Chem::Entity3DContainer,
                                                public Base::PropertyContainer
        {
 
            class ConstFeatureAccessor;
            class FeatureAccessor;
 
          public:
            typedef std::shared_ptr<FeatureContainer> SharedPointer;
 
            typedef Util::IndexedElementIterator<const Feature, ConstFeatureAccessor> ConstFeatureIterator;
 
            typedef Util::IndexedElementIterator<Feature, FeatureAccessor> FeatureIterator;
 
            virtual ~FeatureContainer() {}
 
            virtual std::size_t getNumFeatures() const = 0;
 
            virtual const Feature& getFeature(std::size_t idx) const = 0;
 
            virtual Feature& getFeature(std::size_t idx) = 0;
 
            virtual std::size_t getFeatureIndex(const Feature& feature) const = 0;
 
            virtual bool containsFeature(const Feature& feature) const = 0;
 
            ConstFeatureIterator getFeaturesBegin() const;
 
            ConstFeatureIterator getFeaturesEnd() const;
 
            FeatureIterator getFeaturesBegin();
 
            FeatureIterator getFeaturesEnd();
 
            ConstFeatureIterator begin() const;
 
            ConstFeatureIterator end() const;
 
            FeatureIterator begin();
 
            FeatureIterator end();
 
            virtual void orderFeatures(const FeatureCompareFunction& func) = 0;
 
            virtual std::size_t getNumEntities() const;
 
            virtual const Chem::Entity3D& getEntity(std::size_t idx) const;
 
            virtual Chem::Entity3D& getEntity(std::size_t idx);
 
          protected:
            FeatureContainer& operator=(const FeatureContainer& cntnr);
 
          private:
            class CDPL_PHARM_API ConstFeatureAccessor
            {
 
              public:
                ConstFeatureAccessor(const FeatureAccessor& accessor):
                    container(accessor.container) {}
 
                ConstFeatureAccessor(const FeatureContainer* cntnr):
                    container(cntnr) {}
 
                const Feature& operator()(std::size_t idx) const;
 
                bool operator==(const ConstFeatureAccessor& accessor) const;
 
                ConstFeatureAccessor& operator=(const FeatureAccessor& accessor);
 
              private:
                const FeatureContainer* container;
            };
 
            class CDPL_PHARM_API FeatureAccessor
            {
 
                friend class ConstFeatureAccessor;
 
              public:
                FeatureAccessor(FeatureContainer* cntnr):
                    container(cntnr) {}
 
                Feature& operator()(std::size_t idx) const;
 
                bool operator==(const FeatureAccessor& accessor) const;
 
              private:
                FeatureContainer* container;
            };
        };
    } // namespace Pharm
} // namespace CDPL
 
#endif // CDPL_PHARM_FEATURECONTAINER_HPP