Operator1Expr.cpp

Go to the documentation of this file.

// Operator1Expr.cpp: implementation of the COperator1Expr class.
/*
 * Copyright (c) 1996-2000 Erwin Coumans <coockie@acm.org>
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Erwin Coumans makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 */

#include "Operator1Expr.h"
#include "EmptyValue.h"

// Construction/Destruction

COperator1Expr::COperator1Expr()
/*
pre:
effect: constucts an empty COperator1Expr
*/
{
    m_lhs = NULL;
}

COperator1Expr::COperator1Expr(VALUE_OPERATOR op, CExpression * lhs)
/*
pre:
effect: constucts a COperator1Expr with op and lhs in it
*/
{
    m_lhs = lhs;
    m_op = op;
}

COperator1Expr::~COperator1Expr()
/*
pre:
effect: deletes the object
*/
{
    if (m_lhs) m_lhs->Release();
}

CValue * COperator1Expr::Calculate()
/*
pre:
ret: a new object containing the result of applying the operator m_op to the
     value of m_lhs
*/
{
    CValue *ret;
    CValue *temp = m_lhs->Calculate();
    CValue* empty = new CEmptyValue();
    ret = empty->Calc(m_op, temp);
    empty->Release();
    temp->Release();
    
    return ret;
}

/*
bool COperator1Expr::IsInside(float x, float y, float z,bool bBorderInclude)
{

    bool result = true;
    switch (m_op)
    {
        
    case VALUE_ADD_OPERATOR:
        {
            
            if (m_lhs)
            {
                result = result || m_lhs->IsInside(x,y,z,bBorderInclude);
            }
            break;
        }
    case VALUE_SUB_OPERATOR:
        {
            result = true;
            if (m_lhs)
            {
                result = result && (!m_lhs->IsInside(x,y,z,bBorderInclude));
            }
            break;
        }
    }
    return result;
}

*/
bool COperator1Expr::NeedsRecalculated()
{
    return m_lhs->NeedsRecalculated();
}

CExpression* COperator1Expr::CheckLink(std::vector<CBrokenLinkInfo*>& brokenlinks) {

    CExpression* newlhs = m_lhs->CheckLink(brokenlinks);

    if (newlhs)
    {
        if (newlhs==m_lhs) {
            // not changed
        } else {
            // changed
            //numchanges++;
            newlhs->AddRef();
            
            //m_lhs->Release();
            brokenlinks.push_back(new CBrokenLinkInfo(&m_lhs,m_lhs));

            m_lhs = newlhs;
        }
        return this;
    } else {
        //numchanges++;
        AddRef();

        return Release();
    }
    
}

void COperator1Expr::BroadcastOperators(VALUE_OPERATOR op)
{
    if (m_lhs)
        m_lhs->BroadcastOperators(m_op);
}




bool COperator1Expr::MergeExpression(CExpression *otherexpr)
{
    if (m_lhs)
        return m_lhs->MergeExpression(otherexpr);
    
    assertd(false); // should not get here, expression is not compatible for merge
    return false;
}