casfuncobj.cc

Go to the documentation of this file.

//
//  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.cc,v 1.15 2006/12/31 00:51:31 rafi Exp $
//

#include "casfuncobj.h"
#include "casnumeric.h"
#include "casgarbage.h"
// ---------------------------------------------------------------------------
// CASDestroyObject
// ---------------------------------------------------------------------------
void
CASDestroyObject::operator() ( CASObject* o ) const {
    checkptr ( o );
    delete o;
}
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// CASExpandObject
// ---------------------------------------------------------------------------
CASObject*
CASExpandObject::operator() ( const CASObject* o ) const {
    checkptr ( o );
    const CASTerm *term = dynamic_cast<const CASTerm*> ( o );
    if ( term != 0 )
        return term->Expand();
    else
        return o->Clone();
}
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// CASCloneObject
// ---------------------------------------------------------------------------
CASObject*
CASCloneObject::operator() ( const CASObject* o ) const {
    checkptr ( o );
    return o->Clone();
}
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// CASInvertObject
// ---------------------------------------------------------------------------
CASObject*
CASInvertObject::operator() ( const CASObject* o ) const {
    checkptr ( o );
    return o->Invert();
}
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// CASInvertObjectIP
// ---------------------------------------------------------------------------
void
CASInvertObjectIP::operator() ( CASObject* o ) const {
    checkptr ( o );
    o->InvertIP();
    o->meta.UnsetSorted();
}
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// CASAbsoluteObjectIP
// ---------------------------------------------------------------------------
void
CASAbsoluteObjectIP::operator() ( CASObject* o ) const {
    checkptr ( o );
    o->AbsoluteIP();
    o->meta.UnsetSorted();
}
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// CASSortObject
// ---------------------------------------------------------------------------
bool
CASSortObject::operator() ( const CASObject* o1, const CASObject* o2 ) const {
    checkptr ( o1 );
    checkptr ( o2 );
    if ( o1->GetType() == o2->GetType() ) {
        CASObject *sort_weight_o1 = o1->SortWeight();
        CASObject *sort_weight_o2 = o2->SortWeight();
        if ( sort_weight_o1->IsEqual ( sort_weight_o2 ) &&
                ! ( o1->exponent == 0 || o2->exponent == 0 ) ) {
            CASObject::Garbage->Put ( sort_weight_o1 );
            CASObject::Garbage->Put ( sort_weight_o2 );
            sort_weight_o1 = o1->exponent->SortWeight();
            sort_weight_o2 = o2->exponent->SortWeight();
            bool result = sort_weight_o1->IsLT ( sort_weight_o2 );
            CASObject::Garbage->Put ( sort_weight_o1 );
            CASObject::Garbage->Put ( sort_weight_o2 );
            return result;
        }
        bool result = sort_weight_o1->IsLT ( sort_weight_o2 );
        CASObject::Garbage->Put ( sort_weight_o1 );
        CASObject::Garbage->Put ( sort_weight_o2 );
        return result;
    }

    return o1->GetType() < o2->GetType();
}
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// CASGarbageSort_Cmp
// ---------------------------------------------------------------------------
bool
CASGarbageSort_Cmp::operator() ( const CASObject* o1, const CASObject* o2 ) const {
    checkptr ( o1 );
    checkptr ( o2 );
    return o1 > o2;
}
// ---------------------------------------------------------------------------


// ---------------------------------------------------------------------------
// CASObjectEqual
// ---------------------------------------------------------------------------
bool
CASObjectEqual::operator() ( const CASObject* o1, const CASObject* o2 ) {
    checkptr ( o1 );
    checkptr ( o2 );
    return o1->IsEqual ( o2 );
}
// ---------------------------------------------------------------------------


// ---------------------------------------------------------------------------
// CASObjectFindType
// ---------------------------------------------------------------------------
CASObjectFindType::CASObjectFindType ( int type ) : t ( type ) {
}

bool
CASObjectFindType::operator() ( const CASObject* o ) const {
    // This is special: It does not throw an exception if it finds a
    // NULL pointer. So it can be used to search list holding NULL
    // pointer as markers.
    if ( o == 0 ) {
        return false;
    }
    return o->GetType() == t;
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
// CASObjectFindType_Not
// ---------------------------------------------------------------------------
CASObjectFindType_Not::CASObjectFindType_Not ( int type ) {
    t = type;
}

bool
CASObjectFindType_Not::operator() ( const CASObject* o ) const {
    // This is special: It does not raise an exception
    // if it finds a NULL pointer. So it can be used to
    // search list holding NULL pointer as markers.
    if ( o == 0 ) {
        return false;
    }
    return o->GetType() != t;
}
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// CASObjectFindByAddr
// ---------------------------------------------------------------------------
bool
CASObjectFindByAddr::operator() ( const CASObject* o ) const {
    if ( needle == o )
        return true;
    return false;
}

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

// ---------------------------------------------------------------------------
// CASIsPureNumerical
// ---------------------------------------------------------------------------
void
CASIsPureNumerical::operator() ( const CASObject* o ) {
    if ( !o->meta.IsPureNumerical() )
        b = false;
}
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// CASExtractSingleValues
// ---------------------------------------------------------------------------
CASExtractSingleValues::CASExtractSingleValues ( const CASExtractSingleValues& o ) {
    l = o.l;
}

const CASExtractSingleValues&
CASExtractSingleValues::operator= ( const CASExtractSingleValues &o ) {
    if ( this == &o ) {
        return *this;
    }

    l.clear();
    l = o.l;

    return *this;
}

void
CASExtractSingleValues::operator() ( CASObject* o ) {
    checkptr ( o );
    if ( o->meta.IsSingleValue() ) {
        l.push_back ( o );
    }
}

void
CASExtractSingleValues::Result ( std::vector<const CASObject*> &rl ) const {
    rl = l;
}
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// CASExtractNonSingleValues
// ---------------------------------------------------------------------------
CASExtractNonSingleValues::CASExtractNonSingleValues ( const CASExtractNonSingleValues& o ) {
    l = o.l;
}

const CASExtractNonSingleValues&
CASExtractNonSingleValues::operator= ( const CASExtractNonSingleValues &o ) {
    if ( this == &o ) {
        return *this;
    }

    l.clear();
    l = o.l;

    return *this;
}

void
CASExtractNonSingleValues::operator() ( CASObject* o ) {
    checkptr ( o );
    if ( !o->meta.IsSingleValue() ) {
        l.push_back ( o );
    }
}

void
CASExtractNonSingleValues::Result ( std::vector<const CASObject*> &rl ) const {
    rl = l;
}
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// CASCalculateSortWeight
// ---------------------------------------------------------------------------
CASCalculateSortWeight::~CASCalculateSortWeight() {
    if ( weight != 0 )
        CASObject::Garbage->Put ( weight );
}

CASCalculateSortWeight::CASCalculateSortWeight ( const CASCalculateSortWeight& o ) {
    weight = o.weight->Clone();
}

void
CASCalculateSortWeight::operator() ( CASObject* o ) {
    if ( o->meta.IsCoefficient() )
        return;

    if ( weight == 0 ) {
        weight = o->SortWeight();
    } else {
        CASObject* oldweight = weight;
        CASObject* weight_o = o->SortWeight();
        weight = oldweight->Add ( weight_o );
        CASObject::Garbage->Put ( weight_o );
        CASObject::Garbage->Put ( oldweight );
    }
}

const CASCalculateSortWeight&
CASCalculateSortWeight::operator= ( const CASCalculateSortWeight &o ) {
    if ( &o == this )
        return *this;

    if ( weight != 0 )
        CASObject::Garbage->Put ( weight );

    weight = o.weight->Clone();

    return *this;
}

CASObject*
CASCalculateSortWeight::Result() const {
    return weight->Clone();
}
// ---------------------------------------------------------------------------

---