casfuncobj.h

Go to the documentation of this file.

// -*- C++ -*-
//
//  Copyright (c) 2006 by 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
//
// $Id: casfuncobj.h,v 1.19 2006/12/28 19:01:24 rafi Exp $
//

#ifndef _CASFUNCOBJ_H
#define _CASFUNCOBJ_H

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef DEBUG
#include <cassert>
#endif

#include <functional>
#include <vector>

#include "casobject.h"
#include "casexception.h"
#include "casnumeric.h"
#include "casterm.h"

#if defined(DEBUG) || defined(DEBUG2)
#include <iostream>

class CASPrintMemAddress {
    public:
        void operator() ( const CASObject* o ) const {
            std::cout << ( ( void* ) o ) << std::endl;
        }
};

class CASPrintObject {
    public:
        void operator() ( const CASObject* o ) const {
            assert ( o != 0 );
            o->Print();
            std::cout << std::endl;
        }
};

#endif

class CASTypeFinder_EQ : public std::unary_function<CASObject*, bool> {
    private:
        const CASObject* object;
    public:
        explicit CASTypeFinder_EQ ( const CASObject* o ) : object ( o ) {}

        bool operator() ( const CASObject* o ) const {
            return object->GetType() == o->GetType();
        }
};

class CASFindEqualObj : public std::unary_function<CASObject*, bool> {
    private:
        const CASObject* object;
    public:
        explicit inline CASFindEqualObj ( const CASObject *o ) : object ( o ) {
            checkptr ( o );
        }
        bool operator() ( const CASObject* o ) const {
            return object->IsEqual ( o );
        }

};

class CASDestroyObject {
    public:
        void operator() ( CASObject* o ) const;
};

class CASEvaluateObject {
    public:
        CASObject* operator() ( const CASObject* o ) const {
            checkptr ( o );
            return o->Evaluate();
        }
};

class CASExpandObject {
    public:
        CASObject* operator() ( const CASObject* o ) const;
};

class CASCloneObject {
    public:
        CASObject* operator() ( const CASObject* o ) const;
};

class CASInvertObject {
    public:
        CASObject* operator() ( const CASObject* o ) const;
};

class CASInvertObjectIP {
    public:
        void operator() ( CASObject* o ) const;
};

class CASAbsoluteObjectIP {
    public:
        void operator() ( CASObject* o ) const;
};

class CASSortObject {
    public:
        bool operator() ( const CASObject* o1, const CASObject* o2 ) const;
};

class CASGarbageSort_Cmp {
    public:
        bool operator() ( const CASObject* o1, const CASObject* o2 ) const;
};

class CASObjectEqual : public std::binary_function<CASObject *, CASObject*, bool> {
    public:
        bool operator() ( const CASObject* o1, const CASObject* o2 );
};

class CASObjectFindType : public std::unary_function<CASObject *, bool> {
    private:
        int t;
    public:
        CASObjectFindType ( int type );
        bool operator() ( const CASObject* o ) const;
};

class CASObjectFindType_Not : public std::unary_function<CASObject *, bool> {
    private:
        int t;
    public:
        CASObjectFindType_Not ( int type );
        bool operator() ( const CASObject* o ) const;
};

class CASObjectFindByAddr : public std::unary_function<CASObject *, bool> {
    private:
        const CASObject *needle;
    public:
        inline CASObjectFindByAddr ( const CASObject* o ) {
            needle = o;
        }
        bool operator() ( const CASObject* o ) const;
};

class CASIsPureNumerical {
    private:
        bool b;
    public:
        inline explicit CASIsPureNumerical() : b ( true ) {};
        inline CASIsPureNumerical ( const CASIsPureNumerical &o ) { b = o.b; }
        void operator() ( const CASObject* o );
        inline const CASIsPureNumerical &operator= ( const CASIsPureNumerical &o )
        {  if ( &o == this )
                return *this;
            b = o.b;
            return *this;
        }
    inline bool Result() const { return b; }
};

class CASExtractNonCoefficients {
    public:
        CASObject *operator() ( CASObject* o ) const {
            if ( !o->meta.IsCoefficient() ) {
                return o;
            } else {
                return 0;
            }
        }
};

class CASGetCoefficient {
    private:
        const CASObject *coe;
    public:
        inline CASGetCoefficient() : coe ( 0 ) {};
        inline CASGetCoefficient ( const CASGetCoefficient &o ) { coe = o.coe; }
        const CASObject *Result() const { return coe; }
        void operator() ( CASObject* o ) {
            if ( coe == 0 ) {
                checkptr ( o );
                if ( o->meta.IsCoefficient() ) {
                    coe = o;
                }
            }
        }
        const CASGetCoefficient &operator= ( const CASGetCoefficient &o ) {
            if ( &o == this )
                return *this;
            coe = o.coe;
            return *this;
        }
};

class CASExtractSingleValues {
    private:
        std::vector<const CASObject*> l;
    public:
        inline explicit CASExtractSingleValues() {};

        CASExtractSingleValues ( const CASExtractSingleValues& o );
        const CASExtractSingleValues &operator= ( const CASExtractSingleValues &o );

        void operator() ( CASObject* o );

        void Result ( std::vector<const CASObject*> &rl ) const;
};

class CASExtractNonSingleValues {
    private:
        std::vector<const CASObject*> l;
    public:
        inline explicit CASExtractNonSingleValues() {};

        CASExtractNonSingleValues ( const CASExtractNonSingleValues& o );

        const CASExtractNonSingleValues &operator= ( const CASExtractNonSingleValues &o );

        void operator() ( CASObject* o );

        void Result ( std::vector<const CASObject*> &rl ) const;
};

class CASCalculateSortWeight {
    private:
        CASObject *weight;

    public:
        inline explicit CASCalculateSortWeight() : weight ( 0 ) {}
        ~CASCalculateSortWeight();
        CASCalculateSortWeight ( const CASCalculateSortWeight& o );
        void operator() ( CASObject* o );
        const CASCalculateSortWeight &operator= ( const CASCalculateSortWeight &o );
        CASObject* Result() const;

};

#endif /* _CASFUNCOBJ_H */

---