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

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

#include <cassert>

#include "casconvert.h"
#include "casobject.h"
#include "casfuncobj.h"
#include "casexception.h"


// Private methods
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------

// Protected methods
// ----------------------------------------------------------------------------
template<class T> T*
CASConvert::vector2type() const throw ( EDoesNotApply ) {
    if ( vector.size() < 1 ) {
        throw EDoesNotApply();
    }

    T* typed = new T;
    typed->operands.clear();

    std::transform ( vector.begin(),
                     vector.end(),
                     std::back_inserter ( typed->operands ),
                     CASCloneObject() );
    typed->Sort();

    return typed;
}

template<class T> T*
CASConvert::casobject2type() const throw ( EDoesNotApply ) {
    if ( casobject == 0 ) {
        throw EDoesNotApply();
    }

    T *typed = new T;
    if ( casobject->meta.IsSingleValue() ) {
        typed->Append ( casobject );
        return typed;
    }

    switch ( casobject->GetType() ) {
    case CT_SUM: {
            Sum *tmp = dynamic_cast<Sum*> ( casobject );
#ifdef DEBUG
            assert ( tmp != 0 );
#endif
            std::transform ( tmp->operands.begin(),
                             tmp->operands.end(),
                             std::back_inserter ( typed->operands ),
                             CASCloneObject() );
            return typed;
        }
    case CT_PRODUCT: {
            Product *tmp = dynamic_cast<Product*> ( casobject->Clone() );
#ifdef DEBUG
            assert ( tmp != 0 );
#endif
            std::transform ( tmp->operands.begin(),
                             tmp->operands.end(),
                             std::back_inserter ( typed->operands ),
                             CASCloneObject() );
            return typed;
        }
    case CT_FRACTION: {
            Fraction *tmp = dynamic_cast<Fraction*> ( casobject );
#ifdef DEBUG
            assert ( tmp != 0 );
#endif
            typed->Append ( tmp->numerator );
            typed->Append ( tmp->denominator );
            return typed;
        }

    default:
        std::string m ( "Cannot convert to " );
        m += typeid ( T ).name();
        throw ( EDoesNotApply ( m ) );
    }
}

Variable*
CASConvert::vector2variable() const throw ( EDoesNotApply ) {
    if ( vector.size() != 1 ) {
        throw EDoesNotApply();
    }

    if ( !vector[0]->meta.IsSingleValue() ) {
        throw EDoesNotApply();
    }

    if ( vector[0]->meta.IsPureNumerical() ) {
        throw EDoesNotApply();
    }

    Variable *tmp = dynamic_cast<Variable*> ( vector[0] );
    if ( tmp == 0 ) {
        throw EDoesNotApply();
    }

    Variable *var = new Variable();
    *var = *tmp;

    return var;
}

Variable*
CASConvert::casobject2variable() const throw ( EDoesNotApply ) {
    if ( casobject == 0 ) {
        throw EDoesNotApply();
    }

    if ( !casobject->meta.IsSingleValue() ) {
        throw EDoesNotApply();
    }

    if ( casobject->meta.IsPureNumerical() ) {
        throw EDoesNotApply();
    }

    Variable *tmp = dynamic_cast<Variable*> ( casobject );
    if ( tmp == 0 ) {
        throw EDoesNotApply();
    }

    Variable *var = new Variable();
    *var = *tmp;

    return var;
}

LongInt*
CASConvert::vector2longint() const throw ( EDoesNotApply ) {
    if ( vector.size() != 1 ) {
        throw EDoesNotApply();
    }

    if ( !vector[0]->meta.IsSingleValue() ) {
        throw EDoesNotApply();
    }

    if ( !vector[0]->meta.IsPureNumerical() ) {
        throw EDoesNotApply();
    }

    LongInt *tmp = dynamic_cast<LongInt*> ( vector[0] );
    if ( tmp == 0 ) {
        throw EDoesNotApply();
    }

    LongInt *lint = new LongInt();
    *lint = *tmp;

    return lint;
}

LongInt*
CASConvert::casobject2longint() const throw ( EDoesNotApply ) {
    if ( casobject == 0 ) {
        throw EDoesNotApply();
    }

    if ( !casobject->meta.IsSingleValue() ) {
        throw EDoesNotApply();
    }

    if ( !casobject->meta.IsPureNumerical() ) {
        throw EDoesNotApply();
    }

    LongInt  *tmp = dynamic_cast<LongInt*> ( casobject );
    if ( tmp == 0 ) {
        throw EDoesNotApply();
    }

    LongInt *lint = new LongInt();
    *lint = *tmp;

    return lint;
}

Fraction*
CASConvert::vector2fraction() const throw ( EDoesNotApply ) {
    if ( vector.size() < 2 ) {
        throw EDoesNotApply();
    }

    Fraction *frac = new Fraction();
#ifdef DEBUG
    assert ( frac->numerator != 0 );
    assert ( frac->denominator != 0 );
#endif
    CASObject::Garbage->Put ( frac->numerator );
    CASObject::Garbage->Put ( frac->denominator );
    frac->numerator = vector[0]->Clone();
    frac->denominator = vector[1]->Clone();

    return frac;
}

Fraction*
CASConvert::casobject2fraction() const throw ( EDoesNotApply ) {
    if ( casobject == 0 ) {
        throw EDoesNotApply();
    }

    Fraction *frac = new Fraction();
#ifdef DEBUG
    assert ( frac->numerator != 0 );
#endif
    CASObject::Garbage->Put ( frac->numerator );
    frac->numerator = casobject->Clone();

    return frac;
}
// ----------------------------------------------------------------------------

// Constructors & Destructor methods
// ----------------------------------------------------------------------------
CASConvert::CASConvert ( const CASObject* o ) {
    checkptr ( o );
    casobject = o->Clone();
}

CASConvert::CASConvert ( const std::vector<const CASObject*>& v ) : casobject ( 0 ) {
    std::transform ( v.begin(),
                     v.end(),
                     std::back_inserter ( vector ),
                     CASCloneObject() );
}

CASConvert::~CASConvert() {
    if ( casobject != 0 ) {
        CASObject::Garbage->Put ( casobject );
    }

    CASObject::Garbage->Put ( vector );
}

CASConvert::CASConvert ( const CASConvert &o ) {
    if ( o.casobject != 0 ) {
        casobject = o.casobject->Clone();
    }

    std::transform ( o.vector.begin(),
                     o.vector.end(),
                     std::back_inserter ( vector ),
                     CASCloneObject() );
}

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

// Public methods
// ----------------------------------------------------------------------------
Sum*
CASConvert::ToSum() const throw ( EDoesNotApply ) {
    if ( casobject != 0 ) {
        return casobject2type<Sum>();
    } else {
        return vector2type<Sum>();
    }
}

Product*
CASConvert::ToProduct() const throw ( EDoesNotApply ) {
    if ( casobject != 0 ) {
        return casobject2type<Product>();
    } else {
        return vector2type<Product>();
    }
}

Variable*
CASConvert::ToVariable() const throw ( EDoesNotApply ) {
    if ( casobject != 0 ) {
        return casobject2variable();
    } else {
        return vector2variable();
    }
}

LongInt*
CASConvert::ToLongInt() const throw ( EDoesNotApply ) {
    if ( casobject != 0 ) {
        return casobject2longint();
    } else {
        return vector2longint();
    }
}

Fraction*
CASConvert::ToFraction() const throw ( EDoesNotApply ) {
    if ( casobject != 0 ) {
        return casobject2fraction();
    } else {
        return vector2fraction();
    }
}
// ----------------------------------------------------------------------------

// Operator methods
// ----------------------------------------------------------------------------
CASConvert&
CASConvert::operator= ( const CASConvert &o ) {
    if ( this == &o ) {
        return *this;
    }

    if ( casobject != 0 ) {
        CASObject::Garbage->Put ( casobject );
    }

    CASObject::Garbage->Put ( vector );
    vector.clear();

    if ( o.casobject != 0 ) {
        casobject = o.casobject->Clone();
    }

    std::transform ( o.vector.begin(),
                     o.vector.end(),
                     std::back_inserter ( vector ),
                     CASCloneObject() );

    return *this;
}

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

---