vstorefuncs.h

Go to the documentation of this file.

// -*- C++ -*-
//
// This file is part of libgvectors.
// libgvectors is a C++ library intended for visualizing mathematical vectors.
// Copyright (C) 2007  Rafael Ostertag
//
// 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.
//
// This program 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 program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
// USA.
//
// $Id: vstorefuncs_8h-source.html,v 1.1 2007-09-08 19:02:38 rafi Exp $
//
// File:   vstorefuncs.h
// Author: Rafael Ostertag
//
// Created on August 2, 2007, 12:36 AM
//

#ifndef _VSTOREFUNCS_H
#define _VSTOREFUNCS_H

#include <functional>
#include <map>

namespace GVectors {
   
    // Forward declaration.
    class VStoreItem;
    // Forward declaration.
    class Rotation;
    // Forward declaration.
    class FileWriter;
    
    class VDelete {
    private:
        inline VDelete& operator=(const VDelete&) {return *this;}
    public:
        inline explicit VDelete() {}
        inline VDelete(const VDelete&){};
        inline ~VDelete() {}
        void operator()(VStoreItem* i) const;
    };
    
    class VSetOrigin {
    private:
        const Coordinates& origin;
        inline VSetOrigin& operator=(const VSetOrigin&) {return *this;}
    public:
        inline explicit VSetOrigin(const Coordinates &c) : origin(c) {}
        inline VSetOrigin(const VSetOrigin& t) : origin(t.origin) {}
        inline ~VSetOrigin() {}
        void operator()(VStoreItem *i) const;
    };
    
    class VSetScale {
    private:
        double& scale;
        inline VSetScale& operator=(const VSetScale&) { return *this; }
    public:
        inline explicit VSetScale(double& sc) : scale(sc) {}
        inline VSetScale(const VSetScale& t) : scale(t.scale) {}
        inline ~VSetScale() {}
        void operator()(VStoreItem *i) const;
    };
    
    class VSetArrowLength {
    private:
        double& arrowlength;
        inline const VSetArrowLength& operator=(const VSetArrowLength&) { return *this; }
    public:
        inline explicit VSetArrowLength(double& arl) : arrowlength(arl) {}
        inline VSetArrowLength(const VSetArrowLength& t) : arrowlength(t.arrowlength) {}
        inline ~VSetArrowLength() {}
        void operator()(VStoreItem *i) const;
    };
    
    class VSetRotation {
    private:
        const Rotation& rotation;
        inline const VSetRotation& operator=(const VSetRotation&) { return *this; }
    public:
        inline explicit VSetRotation(const Rotation& r) : rotation(r) {}
        inline VSetRotation(const VSetRotation& r) : rotation(r.rotation) {}
        inline ~VSetRotation() {}
        void operator()(VStoreItem *i) const;
    };
    
    class VDraw {
    private:
        Drawer& drawer;
        inline VDraw& operator=(const VDraw&) {return *this;}
    public:
        inline explicit VDraw(Drawer& d) : drawer(d) {}
        inline VDraw(const VDraw& t) : drawer(t.drawer) {}
        inline ~VDraw() {};
        void operator()(VStoreItem *i) const;
    };
    
    class VRemoveItemByAddress {
    private:
        const VStoreItem* item;
        inline const VRemoveItemByAddress& operator=(const VRemoveItemByAddress&) { return *this; }
        
    public:
        explicit VRemoveItemByAddress(const VStoreItem* i) : item(i) {}
        inline VRemoveItemByAddress(const VRemoveItemByAddress& c) : item(c.item) {}
        inline ~VRemoveItemByAddress() {}
        inline bool operator()(const VStoreItem* a) {
            if (a==item)
                return true;
            return false;
        }
    };
    
    class GetMinMax {
    private:
        Coordinates max;
        Coordinates min;
        
    public:
        explicit GetMinMax();
        inline GetMinMax(const GetMinMax& gmm) : max(gmm.max), min(gmm.min) {}
        inline ~GetMinMax() {;}
        const GetMinMax& operator=(const GetMinMax& gmm);
        void operator()(const Coordinates& f, const Coordinates& t);
        void reset();

        inline Coordinates getMax() const { return max; }
        inline Coordinates getMin() const { return min; }
    };
    
    class ForEachMinMax {
    private:
        GetMinMax& getminmax;
        
    public:
        inline explicit ForEachMinMax(GetMinMax& gmm) : getminmax(gmm) {;}
        inline ForEachMinMax(const ForEachMinMax& mm) : getminmax(mm.getminmax) {;}
        const ForEachMinMax& operator=(const ForEachMinMax& femm);
        inline ~ForEachMinMax() {;}
        void operator()(VStoreItem* i);
        inline GetMinMax get() const { return getminmax; }
        inline void reset() { getminmax.reset(); }
    };
    
    class SyncLookup {
    private:
        std::map<gvid_t, VStoreItem*>& lookup_ref;

        inline SyncLookup& operator=(const SyncLookup&) {return *this;}

    public:
        inline explicit SyncLookup(std::map<gvid_t, VStoreItem*>& lr)
        : lookup_ref(lr) { /* Empty */ }
        inline ~SyncLookup() { /* Empty */ }
        inline SyncLookup(const SyncLookup& sl)
        : lookup_ref(sl.lookup_ref) { /* Empty */ }
        void operator()(gvid_t id) const;
    };
    
    class FindTopLevel : public std::unary_function<VStoreItem*, bool> {
    private:
        gvid_t id_to_find;
    public:
        inline explicit FindTopLevel(gvid_t id) : id_to_find(id) { /* Empty */ }
        bool operator() (const VStoreItem* vsi) const;
    };
    
    class CountItems {
    private:
        vssize_t items;
        
    public:
        inline explicit CountItems() : items(0) { ; }
        inline explicit CountItems(vssize_t sv) : items(sv) { ; }
        inline ~CountItems() { ; }
        inline CountItems(const CountItems& ci) : items(ci.items) { ; }
        inline const CountItems& operator=(const CountItems& ci) {
            items = ci.items;
            return *this;
        }
        inline vssize_t amount() const { return items; }
        inline void reset() { items = 0; }
        void operator() (const VStoreItem* vsi);
        inline CountItems operator+(const CountItems& ci) const {
            return CountItems(items+ci.items);
        }
        inline const CountItems& operator+=(const CountItems& ci) {
            items += ci.items;
            return *this;
        }
    };
    
    class SaveItems {
    private:
        vslevel_t level;
        FileWriter& filewriter;
        
        inline const SaveItems& operator=(const SaveItems&) { return *this; }
        
    public:
        inline explicit SaveItems(vslevel_t l, FileWriter& fw) : level(l), filewriter(fw) { ; }
        inline SaveItems(const SaveItems& si) : level(si.level), filewriter(si.filewriter) { ; }
        inline ~SaveItems() { ; }
        void operator() (const VStoreItem* vsi) const;
    };
}

#endif  /* _VSTOREFUNCS_H */

---