CNormalCall Class Reference

#include <CNormalCall.h>

Inheritance diagram for CNormalCall:

Collaboration diagram for CNormalCall:

Public Types
enum	Type { FUNCTION, EXPRESSION, DELAY, INVALID }

Public Member Functions
bool	add (const CNormalFraction &fraction)
	CNormalCall ()
	CNormalCall (const CNormalCall &src)
virtual CNormalBase *	copy () const
const std::vector < CNormalFraction * > &	getFractions () const
const std::string &	getName () const
int	getSize () const
Type	getType () const
bool	operator< (const CNormalCall &rhs) const
CNormalCall &	operator= (const CNormalCall &src)
bool	operator== (const CNormalCall &rhs) const
void	setFractions (const std::vector< CNormalFraction * > &set)
void	setName (const std::string &name)
void	setType (Type type)
virtual bool	simplify ()
virtual std::string	toString () const
virtual	~CNormalCall ()
Public Member Functions inherited from CNormalBase
virtual bool	areEqual (const CNormalBase &rhs) const
virtual	~CNormalBase ()

Private Attributes
std::vector< CNormalFraction * >	mFractions
std::string	mName
Type	mType

Friends
std::ostream &	operator<< (std::ostream &os, const CNormalCall &d)

Detailed Description

The class for function calls used in CNormal

Definition at line 33 of file CNormalCall.h.

Member Enumeration Documentation

enum CNormalCall::Type

Enumerator
FUNCTION
EXPRESSION
DELAY
INVALID

Definition at line 36 of file CNormalCall.h.

  {
    FUNCTION,
    EXPRESSION,
    DELAY,
    INVALID
  };

Constructor & Destructor Documentation

CNormalCall::CNormalCall

(

)

Default constructor

Definition at line 25 of file CNormalCall.cpp.

Referenced by copy().

                        : CNormalBase(), mName(""), mType(CNormalCall::INVALID)
{};

CNormalCall::CNormalCall

(

const CNormalCall &

src

)

Copy Constructor

Definition at line 31 of file CNormalCall.cpp.

References mFractions, mName, mType, and setFractions().

                                              : CNormalBase(src)
{
  this->mName = src.mName;
  this->mType = src.mType;
  this->setFractions(src.mFractions);
}

CNormalCall::~CNormalCall ( )

virtual

Destructor

Definition at line 109 of file CNormalCall.cpp.

References mFractions.

{
  // delete all fractions
  std::vector<CNormalFraction*>::iterator it = this->mFractions.begin(), endit = this->mFractions.end();

  while (it != endit)
    {
      delete *it;
      ++it;
    }
}

Member Function Documentation

bool CNormalCall::add

(

const CNormalFraction &

fraction

)

Add fraction to this sum.

Returns

true.

Definition at line 139 of file CNormalCall.cpp.

References mFractions.

Referenced by createCall(), and setFractions().

{
  this->mFractions.push_back(new CNormalFraction(fraction));
  return true;
}

CNormalBase * CNormalCall::copy ( ) const

virtual

Implements CNormalBase.

Definition at line 121 of file CNormalCall.cpp.

References CNormalCall().

{
  return new CNormalCall(*this);
}

const std::vector< CNormalFraction * > & CNormalCall::getFractions

(

)

const

Retrieve the set of fractions of this sum.

Returns

mFractions.

Definition at line 149 of file CNormalCall.cpp.

References mFractions.

Referenced by convertToCEvaluationNode().

{
  return this->mFractions;
}

const std::string & CNormalCall::getName

(

)

const

Definition at line 262 of file CNormalCall.cpp.

References mName.

Referenced by convertToCEvaluationNode().

{
  return this->mName;
}

int CNormalCall::getSize

(

)

const

Retrieve the number of summands of this sum.

Returns

int

Definition at line 130 of file CNormalCall.cpp.

References mFractions.

{
  return this->mFractions.size();
}

CNormalCall::Type CNormalCall::getType

(

)

const

Definition at line 272 of file CNormalCall.cpp.

References mType.

Referenced by convertToCEvaluationNode().

{
  return this->mType;
}

bool CNormalCall::operator<

(

const CNormalCall &

rhs

)

const

Smaller operator

Definition at line 56 of file CNormalCall.cpp.

References mFractions, mName, and mType.

{
  bool result = false;

  if (this->mType < rhs.mType)
    {
      result = true;
    }
  else
    {
      if (this->mName < rhs.mName)
        {
          result = true;
        }
      else
        {
          if (this->mName == rhs.mName)
            {
              if (this->mFractions.size() < rhs.mFractions.size())
                {
                  result = true;
                }
              else
                {
                  if (this->mFractions.size() == rhs.mFractions.size())
                    {
                      bool smaller = true;
                      std::vector<CNormalFraction*>::const_iterator it = this->mFractions.begin(), endit = this->mFractions.end();
                      std::vector<CNormalFraction*>::const_iterator it2 = rhs.mFractions.begin();

                      while (it != endit && smaller == true)
                        {
                          smaller = ((*it2) < (*it));
                          ++it;
                          ++it2;
                        }

                      if (smaller)
                        {
                          result = true;
                        }
                    }
                }
            }
        }
    }

  return result;
}

CNormalCall & CNormalCall::operator=

(

const CNormalCall &

src

)

Assignment operator

Definition at line 41 of file CNormalCall.cpp.

References mFractions, mName, mType, and setFractions().

{
  if (&src != this)
    {
      this->mName = src.mName;
      this->mType = src.mType;
      this->setFractions(src.mFractions);
    }

  return *this;
}

bool CNormalCall::operator==

(

const CNormalCall &

rhs

)

const

Examine equality of two sums.

Returns

bool.

Definition at line 158 of file CNormalCall.cpp.

References mFractions, mName, and mType.

{
  bool result = true;

  if (this->mType == rhs.mType)
    {
      if (this->mName == rhs.mName)
        {
          if (this->mFractions.size() == rhs.mFractions.size())
            {
              std::vector<CNormalFraction*>::const_iterator it = this->mFractions.begin();
              std::vector<CNormalFraction*>::const_iterator it2 = rhs.mFractions.begin();
              std::vector<CNormalFraction*>::const_iterator endit = this->mFractions.end();

              while (it != endit && result == true)
                {
                  result = ((**it) == (**it2));
                  ++it;
                  ++it2;
                }
            }
          else
            {
              result = false;
            }
        }
      else
        {
          result = false;
        }
    }
  else
    {
      result = false;
    }

  return result;
}

void CNormalCall::setFractions

(

const std::vector< CNormalFraction * > &

set

)

Sets the fractions of this product.

Definition at line 200 of file CNormalCall.cpp.

References add(), and mFractions.

Referenced by CNormalCall(), and operator=().

{
  // delete all fractions
  std::vector<CNormalFraction*>::iterator it = this->mFractions.begin(), endit = this->mFractions.end();

  while (it != endit)
    {
      delete *it;
      ++it;
    }

  this->mFractions.clear();
  std::vector<CNormalFraction*>::const_iterator it2 = set.begin(), endit2 = set.end();

  while (it2 != endit2)
    {
      this->add(**it2);
      ++it2;
    }
}

void CNormalCall::setName

(

const std::string &

name

)

Definition at line 267 of file CNormalCall.cpp.

References mName.

Referenced by createCall().

{
  this->mName = name;
}

void CNormalCall::setType

(

CNormalCall::Type

type

)

Definition at line 277 of file CNormalCall.cpp.

References mType.

Referenced by createCall().

{
  this->mType = type;
}

bool CNormalCall::simplify ( )

virtual

Implements CNormalBase.

Definition at line 242 of file CNormalCall.cpp.

References mFractions.

{
  // simplify all children
  std::vector<CNormalFraction*>::iterator it = this->mFractions.begin(), endit = this->mFractions.end();

  while (it != endit)
    {
      (*it)->simplify();
      ++it;
    }

  return true;
}

std::string CNormalCall::toString ( ) const

virtual

Implements CNormalBase.

Definition at line 221 of file CNormalCall.cpp.

References mFractions, and mName.

Referenced by operator<<().

{
  std::ostringstream os;
  os << this->mName << "(";
  std::vector<CNormalFraction*>::const_iterator it = this->mFractions.begin(), endit = this->mFractions.end();

  while (it != endit)
    {
      os << (**it);
      ++it;

      if (it != endit)
        {
          os << ",";
        }
    }

  os << ")";
  return os.str();
}

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os, const CNormalCall &  d  )

friend

Definition at line 256 of file CNormalCall.cpp.

{
  os << d.toString();
  return os;
}

Member Data Documentation

std::vector<CNormalFraction*> CNormalCall::mFractions

private

Enumeration of members The members of a call have to be kept in the correct order since the order of arguments to a call matters.

Definition at line 60 of file CNormalCall.h.

Referenced by add(), CNormalCall(), getFractions(), getSize(), operator<(), operator=(), operator==(), setFractions(), simplify(), toString(), and ~CNormalCall().

std::string CNormalCall::mName

private

The name of the called function

Definition at line 48 of file CNormalCall.h.

Referenced by CNormalCall(), getName(), operator<(), operator=(), operator==(), setName(), and toString().

Type CNormalCall::mType

private

the call type

Definition at line 53 of file CNormalCall.h.

Referenced by CNormalCall(), getType(), operator<(), operator=(), operator==(), and setType().

---

The documentation for this class was generated from the following files:

• CNormalCall.h
• CNormalCall.cpp