Variant Class Reference

#include <Variant.h>

Public Member Functions
	Variant ()
	Variant (const pInt i)
	Standard constructors.
	Variant (int i)
	Variant (const long unsigned int i)
	Variant (pDouble f)
	Variant (const double f)
	Variant (float f)
	Variant (const char *mystring)
	Variant (const char character)
	Variant (const char *mystring, VariantDataType type)
	Variant (const StackSignalType)
	This is an internal data type used by the stack evaluator.
	Variant (pFunc)
	Variant (const PComplexData *pcd)
	Variant (bool b)
	Variant (const std::string s)
	~Variant ()
	Standard Destructor.
	Variant (const Variant &v)
	Copy Constructor.
Variant	operator+ (const Variant &rhs) const
Variant	operator- (const Variant &rhs) const
	This overloads the - operator for Variants.
Variant	operator* (const Variant &rhs) const
	This overloads the * operator for Variants.
Variant	operator/ (const Variant &rhs) const
	This overloads the / operator for Variants.
bool	Equal (const Variant &rhs) const
bool	Less (const Variant &rhs) const
	Primitive Comparing Method.
bool	operator< (const Variant &rhs) const
bool	operator> (const Variant &rhs) const
bool	operator<= (const Variant &rhs) const
bool	operator>= (const Variant &rhs) const
bool	operator== (const Variant &rhs) const
bool	operator!= (const Variant &rhs) const
Variant	operator= (const Variant &value)
	Assignment Operator (overloaded)
Variant	operator= (const pDouble &value)
Variant	operator= (const pInt &value)
Variant	operator= (const long unsigned int &value)
Variant	operator= (const int &value)
Variant	operator= (const double &value)
Variant	operator= (const float &value)
Variant	operator= (const char *value)
Variant	operator= (const std::string value)
	operator pDouble ()
	Typecast Operators.
	operator pInt ()
	operator long unsigned int ()
	operator int ()
	operator const std::string () const
	operator bool ()
VariantDataType	GetDataType () const
	This returns the type as an enum.
std::string	GetDataTypeName () const
	This returns the type as a string.
bool	IsNumber () const
	This tests whether the Variant is a number (i.e., a float or an integer.)
bool	IsFloat () const
bool	IsInteger () const
bool	IsVariable () const
bool	IsLocalVariable () const
bool	IsGlobalVariable () const
bool	IsString () const
bool	IsFunction () const
bool	IsFunctionPointer () const
bool	IsComplexData () const
bool	IsStackSignal () const
pInt	GetInteger () const
pDouble	GetFloat () const
std::string	GetVariableName () const
std::string	GetVariableBaseName () const
std::string	GetVariablePropertyName () const
std::string	GetFunctionName () const
std::string	GetString () const
StackSignalType	GetSignal () const
Variant	GetSignalName () const
pFunc	GetFunctionPointer () const
PComplexData *	GetComplexData () const
void	SetComplexData (PComplexData *data)
void	SetCreationTime (long unsigned int time)
long unsigned int	GetCreationTime () const

Protected Member Functions
void	free_mData ()

Friends
std::ostream &	operator<< (std::ostream &out, const Variant &v)

Detailed Description

Definition at line 66 of file Variant.h.

Constructor & Destructor Documentation

Variant() [1/16]

Variant::Variant

(

)

Definition at line 58 of file Variant.cpp.

                :
   mDataType(P_DATA_UNDEFINED),
   mComplexData(NULL),
   mCreationTime(0)
{
 
    mData.iNumber = 0;
}

Referenced by GetSignalName(), operator*(), operator+(), operator-(), and operator/().

Variant() [2/16]

Variant::Variant

(

const pInt

i

)

Standard constructors.

Definition at line 69 of file Variant.cpp.

                            :
    mDataType(P_DATA_NUMBER_INTEGER),
    mComplexData(NULL),
    mCreationTime(0)
{
 
   mData.iNumber = i;
 
}

Variant() [3/16]

Variant::Variant

(

int

i

)

Definition at line 82 of file Variant.cpp.

                     :
    mDataType(P_DATA_NUMBER_INTEGER),
    mComplexData(NULL),
    mCreationTime(0)
{
    mData.iNumber = (pInt)i;
 
}

References pInt.

Variant() [4/16]

Variant::Variant

(

const long unsigned int

i

)

Definition at line 95 of file Variant.cpp.

                                         :
    mDataType(P_DATA_NUMBER_INTEGER),
    mComplexData(NULL),
    mCreationTime(0)
{
 
    mData.iNumber = static_cast<pInt>(i);
 
}

References pInt.

Variant() [5/16]

Variant::Variant

(

pDouble

f

)

Definition at line 108 of file Variant.cpp.

                               :
    mDataType(P_DATA_NUMBER_FLOAT),
    mComplexData(NULL),
    mCreationTime(0)
 
{
 
    mData.fNumber = f;
}

Variant() [6/16]

Variant::Variant

(

const double

f

)

Definition at line 120 of file Variant.cpp.

                        :
    mDataType(P_DATA_NUMBER_FLOAT),
    mComplexData(NULL),
    mCreationTime(0)
{
    mData.fNumber=(pDouble)f;
}

References pDouble.

Variant() [7/16]

Variant::Variant

(

float

f

)

Definition at line 130 of file Variant.cpp.

                       :
    mDataType(P_DATA_NUMBER_FLOAT),
    mComplexData(NULL),
    mCreationTime(0)
 
{
 
    mData.fNumber = (pDouble)f;
 
}

References pDouble.

Variant() [8/16]

Variant::Variant

(

const char *

mystring

)

Definition at line 143 of file Variant.cpp.

                                      :
    mDataType(P_DATA_STRING),
    mComplexData(NULL),
    mCreationTime(0)
  //  mData(NULL)
{
 
 
    //cout << P_DATA_STRING << endl;
    mData.String = strdup(mystring);
    if(!mData.String)
        PError::SignalFatalError("Failed to copy string.");
}

References PError::SignalFatalError().

Variant() [9/16]

Variant::Variant

(

const char

character

)

Definition at line 159 of file Variant.cpp.

                                    :
    mDataType(P_DATA_STRING),
    mComplexData(NULL),
    mCreationTime(0)
 
{
 
    //Make a dummy string to place the character into.
    char * dummy = (char*)malloc(2*sizeof(char));
    dummy[0]=character;
    dummy[1]='\0';
    mData.String = dummy;
 
}

Variant() [10/16]

Variant::Variant	(	const char *	mystring,
		VariantDataType	type
	)

Definition at line 188 of file Variant.cpp.

                                                          :
    mDataType(type),
    mComplexData(NULL),
//    mData((int)0),
    mCreationTime(0)
{
 
    switch(type)
        {
        case P_DATA_FUNCTION:
            mData.Function= strdup(mystring); break;
        case P_DATA_STRING:
            mData.String= strdup(mystring); break;
        case P_DATA_LOCALVARIABLE:
        case P_DATA_GLOBALVARIABLE:
            mData.Variable= strdup(mystring); break;
 
        case P_DATA_UNDEFINED:
        case P_DATA_NUMBER_INTEGER:
        case P_DATA_NUMBER_FLOAT:
        case P_DATA_COMPLEXDATA:
        default:
            //If it isn't one of the above, change it into a string
            mDataType = P_DATA_STRING;
            mData.String = strdup(mystring);
            break;
        }
}

References P_DATA_COMPLEXDATA, P_DATA_FUNCTION, P_DATA_GLOBALVARIABLE, P_DATA_LOCALVARIABLE, P_DATA_NUMBER_FLOAT, P_DATA_NUMBER_INTEGER, P_DATA_STRING, and P_DATA_UNDEFINED.

Variant() [11/16]

Variant::Variant

(

const StackSignalType

signal

)

This is an internal data type used by the stack evaluator.

Definition at line 228 of file Variant.cpp.

                                            :
    mDataType(P_DATA_STACK_SIGNAL),
    mComplexData(NULL),
   // mData((StackSignalType)signal),
    mCreationTime(0)
 
{
   mData.Signal = signal;
}

Variant() [12/16]

Variant::Variant

(

pFunc

pfunc

)

Definition at line 239 of file Variant.cpp.

                            :
    mDataType(P_DATA_FUNCTION_POINTER),
    mComplexData(NULL),
    mCreationTime(0)
{
    mData.pFunction = pfunc;
}

Variant() [13/16]

Variant::Variant

(

const PComplexData *

pcd

)

Definition at line 217 of file Variant.cpp.

                                        :
    mDataType(P_DATA_COMPLEXDATA),
    mComplexData(NULL),
    mCreationTime(0)
{
 
    mComplexData = new PComplexData(pcd);
}

Variant() [14/16]

Variant::Variant

(

bool

b

)

Definition at line 250 of file Variant.cpp.

                      :
    mDataType(P_DATA_NUMBER_INTEGER),
    mComplexData(NULL),
    mCreationTime(0)
 
{
 
    mData.iNumber = (pInt)b;
}

References pInt.

Variant() [15/16]

Variant::Variant

(

const std::string

s

)

Definition at line 175 of file Variant.cpp.

                                   :
    mDataType(P_DATA_STRING),
    mComplexData(NULL),
    mCreationTime(0)
 
{
 
    const char* dummy = mystring.c_str();
    mData.String = strdup(dummy);
 
}

~Variant()

Variant::~Variant

(

)

Standard Destructor.

Standard destructor. This should take care of cleaning up after data subtypes that put stuff on the stack.

Definition at line 376 of file Variant.cpp.

{
    //This is needed to destroy counted pointers, but it leads to a
    //crash later.
    free_mData();
}

References free_mData().

Variant() [16/16]

Variant::Variant

(

const Variant &

v

)

Copy Constructor.

Copy Constructor for variant

Definition at line 265 of file Variant.cpp.

                                :
    mDataType(v.GetDataType()),
    mComplexData(NULL),
    mCreationTime(v.GetCreationTime())
{
 
    //    cout << "creating/copy10:[" << v << "]("<<GetCreationTime()<<")"<< endl;
 
    //This should behave differently depending on what type of variant v is
    // mDataType already initialized in initializer list above
 
#ifdef PEBL_EMSCRIPTEN
    // Validate that mDataType is within valid range
    if(mDataType < 0 || mDataType > P_DATA_COMPLEXDATA) {
        cerr << "ERROR: Variant copy constructor received corrupted source Variant" << endl;
        cerr << "Invalid mDataType value: " << mDataType << " (expected 0-" << P_DATA_COMPLEXDATA << ")" << endl;
        cerr << "Source address: " << &v << endl;
        cerr << "Source mComplexData: " << v.mComplexData << endl;
        cerr << "Source mCreationTime: " << v.mCreationTime << endl;
 
        // Print stack trace using Emscripten
        EM_ASM({
            console.error("Stack trace at corruption point:");
            console.trace();
        });
 
        cerr << "This indicates memory corruption or uninitialized Variant" << endl;
        // Set to undefined and continue rather than crash
        mDataType = P_DATA_UNDEFINED;
        mData.iNumber = 0;
        return;
    }
#endif
 
    switch(mDataType)
        {
 
        case P_DATA_NUMBER_INTEGER:  // an integer
            mData.iNumber = v.GetInteger();
            break;
 
        case P_DATA_NUMBER_FLOAT:    // a float
            mData.fNumber = v.GetFloat();
            break;
 
        case P_DATA_STRING:
            //            cout << "testing case string:<" << v << ">"<<endl;
            mData.String = strdup(v.GetString().c_str());
            break;
 
        case P_DATA_LOCALVARIABLE:        // a variable name
        case P_DATA_GLOBALVARIABLE:        // a variable name
            mData.Variable = strdup(v.GetVariableName().c_str());
            break;
 
        case P_DATA_FUNCTION:
            {
            //Memory problem here, diagnosed by efence:
                std::string tmpfname = v.GetFunctionName();
                //   const char* tmpfname2 = tmpfname.c_str();
                char* cstr = new char[tmpfname.length()+1];
                strcpy(cstr,tmpfname.c_str());
                mData.Function = cstr;
 
            }
 
            break;
 
        case P_DATA_FUNCTION_POINTER:
            mData.pFunction = v.GetFunctionPointer();
            break;
 
 
        case P_DATA_STACK_SIGNAL:
            mData.Signal = v.GetSignal();
            break;
 
            //This needs to  make a deep copy
 
        case P_DATA_COMPLEXDATA:
            {
 
                //cout<<"TYPE:" << v << endl;
                PComplexData * pcd = v.GetComplexData();
 
                if(pcd)
                    mComplexData  = new PComplexData(*pcd);
                else
                    mComplexData = NULL;
 
            }
            break;
 
        case P_DATA_UNDEFINED: // undefined, not an error
            break;
        default:
 
            cerr << "Undefined Data Type in Variant copy constructor. Type: " << mDataType << endl;
            cerr << v << endl;
            PError::SignalFatalError("Undefined Data Type.");
        break;
 
        }
 
}

References GetComplexData(), GetFloat(), GetFunctionName(), GetFunctionPointer(), GetInteger(), GetSignal(), GetString(), GetVariableName(), NULL, P_DATA_COMPLEXDATA, P_DATA_FUNCTION, P_DATA_FUNCTION_POINTER, P_DATA_GLOBALVARIABLE, P_DATA_LOCALVARIABLE, P_DATA_NUMBER_FLOAT, P_DATA_NUMBER_INTEGER, P_DATA_STACK_SIGNAL, P_DATA_STRING, P_DATA_UNDEFINED, and PError::SignalFatalError().

Member Function Documentation

Equal()

bool Variant::Equal

(

const Variant &

rhs

)

const

Primitive Compare Method

Definition at line 491 of file Variant.cpp.

{
    //std::cout << "variant equal: "<< *this << "==" << rhs << endl;
    //If they are both integers, make equality be exact.
    //If one is a float, make equality be with some tolerance.
 
    if(this->IsInteger()  && rhs.IsInteger())
        {
            return (this->GetInteger() == rhs.GetInteger());
        }
    else if (this->IsNumber() && rhs.IsNumber())
        {
            return (std::abs(this->GetFloat() - rhs.GetFloat()) < .00000000001);
        }
    else if (this->IsString() && rhs.IsString())
        { //If both are strings, compare them
 
            //Get copies of the strings.
            std::string str1 = this->GetString();
            std::string str2 = rhs.GetString();
 
            //strcmp returns 0 if they are identical, a number otherwise
            bool b = (str1 == str2);
            return b;
        }
    else if (this->IsStackSignal() && rhs.IsStackSignal())
        {
            return (this->GetSignal() == rhs.GetSignal());
        }
    else if (this->IsComplexData() && rhs.IsComplexData())
        {
            // Compare complex data objects by their underlying pointer addresses
            // Two Variants are equal if they reference the SAME object instance
            PComplexData* pcd1 = this->GetComplexData();
            PComplexData* pcd2 = rhs.GetComplexData();
 
            if(!pcd1 || !pcd2)
                return false;  // One or both are null
 
            // Get the underlying object pointers and compare
            counted_ptr<PEBLObjectBase> obj1 = pcd1->GetObject();
            counted_ptr<PEBLObjectBase> obj2 = pcd2->GetObject();
 
            // Compare raw pointers - same object instance?
            return (obj1.get() == obj2.get());
        }
    return false;
}

References counted_ptr< X >::get(), GetComplexData(), GetFloat(), GetInteger(), PComplexData::GetObject(), GetSignal(), GetString(), IsComplexData(), IsInteger(), IsNumber(), IsStackSignal(), and IsString().

Referenced by operator==().

free_mData()

void Variant::free_mData ( )

protected

This method just clears out any part of mData That is on the free store, including any PComplexData that is held by the variant. PCDs are 1-1 with variants; they should not be shared by multiple variants, although the data they reference is ref-counted and may be shared.

Definition at line 1320 of file Variant.cpp.

{
    // Debug: std::cout << "[VARIANT] free_mData() called. Type: " << mDataType
    //           << ", mComplexData: " << mComplexData << std::endl;
 
    if(mComplexData)
     {
         // Debug: std::cout << "[VARIANT] Deleting PComplexData at: " << mComplexData << std::endl;
         delete mComplexData;
         mComplexData =NULL;
 
         //mDataType=P_DATA_UNDEFINED;
     } else
         {
 
             if(mDataType == P_DATA_STRING )
                 {
                     if(mData.String)
                         {
                             free(mData.String);
                             mData.String = NULL;
                         }
                 }
             else if(IsVariable())
                 {
                     if(mData.Variable)
                         {
                             free(mData.Variable);
                             mData.Variable = NULL;
                         }
                 }
             else if(mDataType == P_DATA_FUNCTION)
                 {
                     if(mData.Function)
                         {
                             free(mData.Function);
                             mData.Function = NULL;
                         }
                 }
 
             else if(mDataType == P_DATA_COMPLEXDATA)
                 {
                 }
 
         }
 
    //    mDataType = P_DATA_UNDEFINED;
}

References IsVariable(), NULL, P_DATA_COMPLEXDATA, P_DATA_FUNCTION, and P_DATA_STRING.

Referenced by operator=(), operator=(), operator=(), operator=(), operator=(), operator=(), operator=(), operator=(), operator=(), and ~Variant().

GetComplexData()

PComplexData * Variant::GetComplexData

(

)

const

This will return a pointer to the complex data held within the variant.

Definition at line 1299 of file Variant.cpp.

{
    return mComplexData;
}

Referenced by PEBLMath::Abs(), PEBLMath::AbsFloor(), PEBLMath::ACos(), PEBLObjects::AddObject(), PEBLList::Append(), PEBLStream::AppendFile(), PEBLMath::ASin(), PEBLMath::ATan(), PEBLObjects::Bezier(), Evaluator::CallFunction(), PEBLEnvironment::CallFunction(), PEBLMath::Ceiling(), PEBLEnvironment::CheckProcessStatus(), PEBLObjects::Circle(), PEBLStream::CopyFile(), PEBLEnvironment::CopyToClipboard(), PEBLString::CopyToClipboard(), PEBLMath::Cos(), PEBLList::CrossFactorWithoutDuplicates(), PEBLMath::DegToRad(), PEBLEnvironment::DeleteFile(), PEBLList::DesignFullCounterbalance(), PEBLString::DetectTextScript(), PlatformPolygon::Draw(), PlatformBezier::Draw(), PlatformWindow::Draw(), PEBLObjects::Draw(), PEBLObjects::DrawFor(), PEBLObjects::Ellipse(), PEBLStream::EndOfFile(), PEBLStream::EndOfLine(), Equal(), Evaluator::Evaluate(), Evaluator::Evaluate1(), PEBLEnvironment::ExitQuietly(), PEBLMath::Exp(), PEBLList::Fifth(), PEBLStream::FileClose(), PEBLEnvironment::FileExists(), PEBLStream::FileOpenAppend(), PEBLStream::FileOpenOverwrite(), PEBLStream::FileOpenRead(), PEBLStream::FileOpenWrite(), PEBLStream::FilePrint(), PEBLStream::FilePrint_(), PEBLStream::FileReadCharacter(), PEBLStream::FileReadLine(), PEBLStream::FileReadList(), PEBLStream::FileReadTable(), PEBLStream::FileReadText(), PEBLStream::FileReadWord(), PEBLString::FindInString(), PEBLList::First(), PEBLMath::Floor(), PEBLStream::Format(), PEBLList::Fourth(), PEBLObjects::GetAudioStats(), PFont::GetBackgroundColorPtr(), PDrawObject::GetColor(), PEBLObjects::GetCursorPosition(), PEBLEnvironment::GetDirectoryListing(), PEBLObjects::GetEyeObject(), PFont::GetFontColorPtr(), PEBLString::GetFontForText(), PEBLEnvironment::GetInput0(), PEBLEnvironment::GetJoystick(), PEBLEnvironment::GetJoystickAxisState(), PEBLEnvironment::GetJoystickBallState(), PEBLEnvironment::GetJoystickButtonState(), PEBLEnvironment::GetJoystickHatState(), PEBLObjects::GetLineBreaks(), PEBLEnvironment::GetNumJoystickAxes(), PEBLEnvironment::GetNumJoystickBalls(), PEBLEnvironment::GetNumJoystickButtons(), PEBLEnvironment::GetNumJoystickHats(), PEBLEnvironment::GetObjectTime(), PDrawObject::GetOutlineColor(), PEBLObjects::GetParent(), PEBLObjects::GetPixelColor(), PEBLObjects::GetProperty(), PEBLObjects::GetPropertyList(), PEBLObjects::GetSize(), GetString(), PEBLObjects::GetText(), PEBLEnvironment::GetTextBoxCursorFromClick(), PError::GetTypeName(), PEBLEnvironment::GetVideoModes(), PEBLObjects::GetVocalResponseTime(), PEBLObjects::Hide(), PEBLEnvironment::IsAudioOut(), PEBLEnvironment::IsCanvas(), PEBLEnvironment::IsColor(), PEBLEnvironment::IsCustomObject(), PEBLEnvironment::IsDirectory(), PEBLEnvironment::IsFileStream(), PEBLEnvironment::IsFloat(), PEBLEnvironment::IsFont(), PEBLEnvironment::IsImage(), PEBLEnvironment::IsInteger(), PEBLEnvironment::IsJoystick(), PEBLEnvironment::IsKeyDown(), PEBLEnvironment::IsKeyUp(), PEBLEnvironment::IsLabel(), PEBLEnvironment::IsList(), PEBLList::IsMember(), PEBLEnvironment::IsNumber(), PEBLEnvironment::IsPEBLObject(), PEBLString::IsRTL(), PEBLEnvironment::IsShape(), PEBLEnvironment::IsString(), PEBLEnvironment::IsText(), PEBLEnvironment::IsTextBox(), PEBLEnvironment::IsWidget(), PEBLEnvironment::IsWindow(), PEBLList::Last(), PEBLEnvironment::LaunchFile(), PEBLList::Length(), PEBLObjects::Line(), PEBLList::ListToString(), PEBLMath::Ln(), PEBLObjects::LoadAudioFile(), PEBLObjects::LoadMovie(), PEBLObjects::LoadSound(), PEBLMath::Log10(), PEBLMath::Log2(), PEBLMath::LogN(), PEventLoop::Loop1(), PEBLString::Lowercase(), PEBLObjects::MakeAudioInputBuffer(), PEBLObjects::MakeCanvas(), PEBLObjects::MakeColor(), PEBLObjects::MakeColorRGB(), PEBLObjects::MakeCustomObject(), PEBLEnvironment::MakeDirectory(), PEBLObjects::MakeFont(), PEBLObjects::MakeImage(), PEBLObjects::MakeLabel(), PEBLObjects::MakeSineWave(), PEBLObjects::MakeTextBox(), PEBLObjects::MakeWindow(), PEBLStream::MD5File(), PEBLStream::MD5Sum(), PEBLList::Merge(), PEBLMath::Mod(), PEBLList::ModList(), PEBLObjects::Move(), PEBLList::Nth(), PEBLMath::NthRoot(), operator<<(), operator=(), PEBLStream::ParseJSON(), PEBLObjects::PausePlayback(), PEBLInterpret(), PEBLObjects::PlayBackground(), PEBLObjects::PlayForeground(), PEBLEnvironment::PlayMovie(), PEBLObjects::Polygon(), PEBLMath::Pow(), PEBLStream::Print(), PEBLStream::Print_(), PEBLObjects::PrintProperties(), PEBLObjects::PropertyExists(), PEBLList::PushOnEnd(), PEBLMath::RadToDeg(), PEBLMath::RandomBernoulli(), PEBLMath::RandomBinomial(), PEBLMath::RandomDiscrete(), PEBLMath::RandomExponential(), PEBLMath::RandomLogNormal(), PEBLMath::RandomNormal(), PEBLMath::RandomUniform(), PEBLObjects::RecordToBuffer(), PEBLObjects::Rectangle(), PEBLMath::Recurse(), PEBLMath::Recurse2(), PEBLString::RegexMatch(), PEBLEnvironment::RegisterEvent(), PEBLObjects::RemoveObject(), PEBLList::Repeat(), PEBLList::RepeatList(), PEBLObjects::ResizeWindow(), PEBLUtility::ResolvePropertyChain(), PEBLList::Rotate(), PEBLObjects::RotoZoom(), PEBLMath::Round(), PEBLObjects::SaveAudioToWaveFile(), PEBLList::Second(), PEBLMath::SeedRNG(), PEBLList::Sequence(), PCanvas::SetColor(), PEBLEnvironment::SetCursorPosition(), PEBLObjects::SetCursorPosition(), PEBLObjects::SetEditable(), PEBLList::SetElement(), PEBLObjects::SetEyeTrackerHandler(), PEBLObjects::SetFont(), PEBLObjects::SetPanning(), PEBLObjects::SetPlayRepeats(), PEBLObjects::SetPoint(), PFont::SetProperty(), PlatformLabel::SetProperty(), PlatformTextBox::SetProperty(), PEBLObjects::SetProperty(), PEBLUtility::SetPropertyChain(), PEBLObjects::SetText(), PEBLEnvironment::SetWorkingDirectory(), PEBLObjects::Show(), PEBLEnvironment::ShowCursor(), PEBLList::Shuffle(), PEBLMath::Sign(), PEBLEnvironment::SignalFatalError(), PEBLMath::Sin(), PEBLList::Sort(), PEBLList::SortBy(), PEBLString::SplitString(), PEBLMath::Sqrt(), PEBLObjects::Square(), PEBLObjects::StartAudioMonitor(), PEBLObjects::StartPlayback(), PEBLObjects::Stop(), PEBLObjects::StopAudioMonitor(), PEBLString::StringLength(), PEBLList::SubList(), PEBLString::SubString(), PEBLEnvironment::SystemCall(), PEBLEnvironment::SystemCallUpdate(), PEBLMath::Tan(), PEBLObjects::ThickLine(), PEBLList::Third(), PEBLString::ToASCII(), PEBLMath::ToFloat(), PEBLMath::ToInt(), PEBLMath::ToNumber(), PEBLMath::ToString(), PEBLEnvironment::TranslateKeyCode(), PEBLEnvironment::TranslateString(), PEBLList::Transpose(), PEBLString::Uppercase(), PEBLEnvironment::VariableExists(), Variant(), PEBLEnvironment::Wait(), PEBLEnvironment::WaitForAnyKeyDownWithTimeout(), PEBLEnvironment::WaitForAnyKeyPressWithTimeout(), PEBLEnvironment::WaitForKeyDown(), PEBLEnvironment::WaitForKeyListDown(), PEBLEnvironment::WaitForKeyPress(), PEBLEnvironment::WaitForKeyRelease(), PEBLEnvironment::WaitForKeyUp(), PEBLEnvironment::WaitForListKeyPress(), PEBLEnvironment::WaitForListKeyPressWithTimeout(), PEBLEnvironment::WaitForMouseButtonWithTimeout(), and PEBLStream::WritePNG().

GetCreationTime()

long unsigned int Variant::GetCreationTime ( ) const

inline

Definition at line 185 of file Variant.h.

{return mCreationTime;} ;

Referenced by PEBLEnvironment::GetObjectTime().

GetDataType()

VariantDataType Variant::GetDataType

(

)

const

This returns the type as an enum.

Data Accessors

Definition at line 885 of file Variant.cpp.

{
    return mDataType;
}

Referenced by Evaluator::Evaluate(), Evaluator::Evaluate(), Evaluator::Evaluate1(), Evaluator::Evaluate1(), DataNode::GetDataType(), operator<<(), and operator=().

GetDataTypeName()

std::string Variant::GetDataTypeName

(

)

const

This returns the type as a string.

Definition at line 891 of file Variant.cpp.

{
    switch(mDataType)
        {
        case P_DATA_NUMBER_INTEGER:
            return "PEBL Integer Type";
 
        case P_DATA_NUMBER_FLOAT:
            return "PEBL Floating-Point Type";
 
        case P_DATA_STRING:
            return "PEBL String Type";
 
        case P_DATA_LOCALVARIABLE:
            return "PEBL Local Variable Type";
 
        case P_DATA_GLOBALVARIABLE:
            return "PEBL Global Variable Type";
 
        case P_DATA_FUNCTION:
            return "PEBL Function Type";
 
        case P_DATA_FUNCTION_POINTER:
            return "PEBL Function Pointer Type";
 
        case P_DATA_STACK_SIGNAL:
            return "PEBL Internal Stack Signal Type";
 
        case P_DATA_COMPLEXDATA:
            return "PEBL Complex data within Variant";
 
        case P_DATA_UNDEFINED:
        default:
            return "Undefined PEBL Variant Type";
        }
}

References P_DATA_COMPLEXDATA, P_DATA_FUNCTION, P_DATA_FUNCTION_POINTER, P_DATA_GLOBALVARIABLE, P_DATA_LOCALVARIABLE, P_DATA_NUMBER_FLOAT, P_DATA_NUMBER_INTEGER, P_DATA_STACK_SIGNAL, P_DATA_STRING, and P_DATA_UNDEFINED.

Referenced by VCG::Evaluate(), PError::GetTypeName(), main(), and operator<<().

GetFloat()

pDouble Variant::GetFloat

(

)

const

Definition at line 1025 of file Variant.cpp.

{
    switch(mDataType)
        {
        case P_DATA_NUMBER_INTEGER: // an integer
            return (pDouble)mData.iNumber;
 
        case P_DATA_NUMBER_FLOAT:   // a float
            return mData.fNumber;
 
        case P_DATA_STRING:
 
            return PEBLUtility::StringToPDouble(mData.String);
 
        case P_DATA_STACK_SIGNAL:
        case P_DATA_LOCALVARIABLE:
        case P_DATA_GLOBALVARIABLE:
        case P_DATA_FUNCTION:
        case P_DATA_FUNCTION_POINTER:
        case P_DATA_UNDEFINED:      // undefined, error
        default:
            PError::SignalWarning("Erroneous Data type in Variant::GetFloat(); returning 0");
            return (pDouble)0;
 
        }
 
}

References P_DATA_FUNCTION, P_DATA_FUNCTION_POINTER, P_DATA_GLOBALVARIABLE, P_DATA_LOCALVARIABLE, P_DATA_NUMBER_FLOAT, P_DATA_NUMBER_INTEGER, P_DATA_STACK_SIGNAL, P_DATA_STRING, P_DATA_UNDEFINED, pDouble, PError::SignalWarning(), and PEBLUtility::StringToPDouble().

Referenced by PEBLMath::Abs(), PEBLMath::AbsFloor(), PEBLMath::ACos(), PEBLMath::ASin(), PEBLMath::ATan(), PEBLMath::Ceiling(), PEBLMath::Cos(), PEBLMath::DegToRad(), Equal(), PEBLMath::Exp(), PEBLMath::Floor(), Less(), PEBLMath::Ln(), PEBLMath::Log10(), PEBLMath::Log2(), PEBLMath::LogN(), PEBLMath::NthRoot(), operator*(), operator+(), operator-(), operator/(), operator<<(), operator=(), PEBLMath::RadToDeg(), PEBLMath::Round(), PEBLMath::Sign(), PEBLMath::Sin(), PEBLMath::Sqrt(), PEBLMath::Tan(), PEBLMath::ToFloat(), PEBLMath::ToNumber(), and Variant().

GetFunctionName()

std::string Variant::GetFunctionName

(

)

const

Definition at line 1208 of file Variant.cpp.

{
 
    if( mDataType == P_DATA_FUNCTION)
        {
 
            const char* fname = mData.Function;
 
            //hmm--memory error here in efence.
            //may have to do with page allocation stuff,
            //affecting NOT pebl itself but PEBL+efence.
            //try cat /proc/sys/vm/max_map_count
            //and something like
            //echo 165535 > /proc/sys/vm/max_map_count
            std::string tmp = std::string(fname);
            //cout <<"tmp obtained" << tmp << endl;
            return tmp;
        }
    else
        {
 
            PError::SignalFatalError("Erroneous Data type in Variant::GetFunctionName()");
            return NULL;
        }
}

References NULL, P_DATA_FUNCTION, and PError::SignalFatalError().

Referenced by Evaluator::CallFunction(), Evaluator::Evaluate1(), Less(), operator<<(), operator=(), and Variant().

GetFunctionPointer()

pFunc Variant::GetFunctionPointer

(

)

const

Definition at line 1280 of file Variant.cpp.

{
 
    if( mDataType == P_DATA_FUNCTION_POINTER)
        {
            return mData.pFunction;
        }
    else
        {
            return NULL;
        }
}

References NULL, and P_DATA_FUNCTION_POINTER.

Referenced by Evaluator::Evaluate(), Evaluator::Evaluate1(), operator=(), and Variant().

GetInteger()

pInt Variant::GetInteger

(

)

const

Definition at line 997 of file Variant.cpp.

{
    switch(mDataType)
        {
        case P_DATA_NUMBER_INTEGER: // an integer
            return mData.iNumber;
 
        case P_DATA_NUMBER_FLOAT:   // a float
            return (pInt)mData.fNumber;
 
        case P_DATA_STRING:
            return strtol(mData.String,0,10);
 
        case P_DATA_STACK_SIGNAL:
        case P_DATA_LOCALVARIABLE:       //
        case P_DATA_GLOBALVARIABLE:       //
        case P_DATA_FUNCTION:       //
        case P_DATA_FUNCTION_POINTER:
        case P_DATA_UNDEFINED:      // undefined, error
        default:
            PError::SignalWarning("Erroneous Data type in Variant::GetInteger(); returning 0");
            return (pInt)0;
            break;
        }
 
}

References P_DATA_FUNCTION, P_DATA_FUNCTION_POINTER, P_DATA_GLOBALVARIABLE, P_DATA_LOCALVARIABLE, P_DATA_NUMBER_FLOAT, P_DATA_NUMBER_INTEGER, P_DATA_STACK_SIGNAL, P_DATA_STRING, P_DATA_UNDEFINED, pInt, and PError::SignalWarning().

Referenced by PEBLEnvironment::CheckProcessStatus(), PlatformTextBox::Draw(), Equal(), Evaluator::Evaluate(), Evaluator::Evaluate1(), PEBLEnvironment::ExitQuietly(), operator*(), operator+(), operator-(), operator<<(), operator=(), PlatformLabel::RenderText(), PlatformTextBox::RenderText(), PEBLMath::Round(), PEBLMath::SeedRNG(), PEBLObjects::SetCursorPosition(), PlatformTextBox::SetEditable(), PlatformTextBox::SetFont(), PFont::SetProperty(), PImageBox::SetProperty(), PMovie::SetProperty(), PEBLMath::ToInt(), PEBLMath::ToNumber(), and Variant().

GetSignal()

StackSignalType Variant::GetSignal

(

)

const

Definition at line 1265 of file Variant.cpp.

{
 
    if( mDataType == P_DATA_STACK_SIGNAL)
        {
            return mData.Signal;
        }else
        {
            return STACK_UNDEFINED;
        }
}

References P_DATA_STACK_SIGNAL, and STACK_UNDEFINED.

Referenced by Equal(), Evaluator::Evaluate(), Evaluator::Evaluate1(), GetSignalName(), operator=(), and Variant().

GetSignalName()

Variant Variant::GetSignalName

(

)

const

Definition at line 1236 of file Variant.cpp.

{
 
    if( mDataType == P_DATA_STACK_SIGNAL)
        {
 
            int val = GetSignal();
            switch (val)
                {
                case STACK_LIST_HEAD:
                    return Variant(val)+Variant("|STACK_LIST_HEAD");
                case STACK_RETURN_DUMMY:
                    return Variant(val)+Variant("|STACK_RETURN_DUMMY");
                case STACK_TERMINATE_EVENT_LOOP:
                    return Variant(val)+Variant("|STACK_TERMINATE_EVENT_LOOP");
                case STACK_BREAK:
                    return Variant(val)+Variant("|STACK_BREAK");
                case STACK_UNDEFINED:
                default:
                    return Variant(val)+Variant("STACK_UNDEFINED");
 
                }
        }else{
            return STACK_UNDEFINED;
    }
}

References GetSignal(), P_DATA_STACK_SIGNAL, STACK_BREAK, STACK_LIST_HEAD, STACK_RETURN_DUMMY, STACK_TERMINATE_EVENT_LOOP, STACK_UNDEFINED, and Variant().

Referenced by operator<<().

GetString()

std::string Variant::GetString

(

)

const

Definition at line 1056 of file Variant.cpp.

{
 
    switch(mDataType)
        {
        case P_DATA_NUMBER_INTEGER: // an integer
            {
                std::ostringstream o;
                o <<  mData.iNumber;
                return o.str();
            }
 
        case P_DATA_NUMBER_FLOAT:   // a float
            {
                std::ostringstream o;
                o <<  mData.fNumber;
                return o.str();
            }
 
        case P_DATA_STRING:
            return std::string(mData.String);
        case P_DATA_FUNCTION:
            return mData.Function;
 
 
        case P_DATA_LOCALVARIABLE:
        case P_DATA_GLOBALVARIABLE:
            return std::string(mData.Variable);
 
        case P_DATA_COMPLEXDATA:
            {
                PComplexData * pcd = GetComplexData();
                counted_ptr<PEBLObjectBase> pob = pcd->GetObject();
 
                //                 cout << *pob << endl;
 
 
                 //                 std::string tmp = pob->ObjectName();
                 //                 return tmp;
 
 
                 std::ostringstream o;
                 o << *pob << std::flush;
 
                 return o.str();
 
//                 std::stringstream tmp;
//                 tmp <<  *pob << std::flush;
 
//                 std::string tmpstring;
//                 tmp >> tmpstring;
 
//                 return tmpstring.c_str();
                //                return pcd->GetTypeName().c_str();
 
 
//                 cout << *pcd << endl;
//                 cout << "Getting Variant string\n";
 
//
//                  cout << "[[["<< tmpstring << "]]]"<< endl;
//                  cout << "done Getting Variant string\n";
//                  return tmpstring.c_str();
 
            }
 
        case P_DATA_STACK_SIGNAL:
        case P_DATA_FUNCTION_POINTER:
 
        case P_DATA_UNDEFINED:      // undefined, error
        default:
            cout << mDataType << endl;
            PError::SignalWarning("Erroneous Data type in Variant::GetString");
            return "";
 
        }
 
 
}

References GetComplexData(), PComplexData::GetObject(), P_DATA_COMPLEXDATA, P_DATA_FUNCTION, P_DATA_FUNCTION_POINTER, P_DATA_GLOBALVARIABLE, P_DATA_LOCALVARIABLE, P_DATA_NUMBER_FLOAT, P_DATA_NUMBER_INTEGER, P_DATA_STACK_SIGNAL, P_DATA_STRING, P_DATA_UNDEFINED, and PError::SignalWarning().

Referenced by PEBLStream::AppendFile(), Evaluator::CallFunction(), PEBLEnvironment::CallFunction(), PEBLStream::CopyFile(), Equal(), Evaluator::Evaluate1(), PEBLEnvironment::ExitQuietly(), PEBLStream::FilePrint(), PEBLStream::FileReadList(), PEBLStream::FileReadTable(), PEBLStream::FileReadText(), PlatformWindow::Initialize(), PEBLEnvironment::LaunchFile(), Less(), PEBLObjects::MakeWindow(), PColor::ObjectName(), operator+(), operator<<(), operator=(), PlatformAudioOut::SaveBufferToWave(), PTextBox::SetProperty(), PEBLObjects::SetText(), PEBLEnvironment::SignalFatalError(), PEBLEnvironment::SystemCall(), PEBLEnvironment::SystemCallUpdate(), PEBLMath::ToNumber(), PEBLMath::ToString(), and Variant().

GetVariableBaseName()

std::string Variant::GetVariableBaseName

(

)

const

Definition at line 1160 of file Variant.cpp.

{
 
    if( mDataType == P_DATA_LOCALVARIABLE || mDataType == P_DATA_GLOBALVARIABLE)
        {
 
            std::string tmp = PEBLUtility::ToUpper(mData.Variable);
            std::string::size_type pos = tmp.find(".");
            if(pos == std::string::npos)
                return tmp;
            else
                return tmp.substr(0, pos);
 
        }
    else
        {
            PError::SignalFatalError("Erroneous Data type in Variant::GetVariableBaseName()");
            return NULL;
 
        }
}

References NULL, P_DATA_GLOBALVARIABLE, P_DATA_LOCALVARIABLE, PError::SignalFatalError(), and PEBLUtility::ToUpper().

Referenced by Evaluator::Evaluate(), Evaluator::Evaluate(), Evaluator::Evaluate1(), and Evaluator::Evaluate1().

GetVariableName()

std::string Variant::GetVariableName

(

)

const

Definition at line 1138 of file Variant.cpp.

{
 
    if( mDataType == P_DATA_LOCALVARIABLE || mDataType == P_DATA_GLOBALVARIABLE)
        {
            return std::string(mData.Variable);
        }
    else
        {
 
            PError::SignalFatalError("Erroneous Data type in Variant::GetVariableName()");
            return NULL;
 
        }
}

References NULL, P_DATA_GLOBALVARIABLE, P_DATA_LOCALVARIABLE, and PError::SignalFatalError().

Referenced by Evaluator::Evaluate(), Evaluator::Evaluate1(), operator<<(), operator=(), and Variant().

GetVariablePropertyName()

std::string Variant::GetVariablePropertyName

(

)

const

Definition at line 1185 of file Variant.cpp.

{
 
    if( mDataType == P_DATA_LOCALVARIABLE || mDataType == P_DATA_GLOBALVARIABLE)
        {
 
            std::string tmp = PEBLUtility::ToUpper(mData.Variable);
            std::string::size_type pos = tmp.find(".");
            if(pos == std::string::npos)
                return "";
            else
                return tmp.substr(pos+1,tmp.size());
        }
    else
        {
            PError::SignalFatalError("Erroneous Data type in Variant::GetVariablePropertyName()");
            return NULL;
 
        }
}

References NULL, P_DATA_GLOBALVARIABLE, P_DATA_LOCALVARIABLE, PError::SignalFatalError(), and PEBLUtility::ToUpper().

Referenced by Evaluator::Evaluate(), Evaluator::Evaluate(), Evaluator::Evaluate1(), and Evaluator::Evaluate1().

IsComplexData()

bool Variant::IsComplexData

(

)

const

Definition at line 984 of file Variant.cpp.

{
    return mDataType == P_DATA_COMPLEXDATA;
}

References P_DATA_COMPLEXDATA.

Referenced by Evaluator::CallFunction(), Equal(), Evaluator::Evaluate(), Evaluator::Evaluate1(), PError::GetTypeName(), PEBLEnvironment::IsAudioOut(), PEBLEnvironment::IsCanvas(), PEBLEnvironment::IsColor(), PEBLEnvironment::IsCustomObject(), PEBLEnvironment::IsFileStream(), PEBLEnvironment::IsFont(), PEBLEnvironment::IsImage(), PEBLEnvironment::IsJoystick(), PEBLEnvironment::IsLabel(), PEBLEnvironment::IsList(), PEBLEnvironment::IsPEBLObject(), PEBLEnvironment::IsShape(), PEBLEnvironment::IsTextBox(), PEBLEnvironment::IsWidget(), PEBLEnvironment::IsWindow(), and PEBLObjects::MakeWindow().

IsFloat()

bool Variant::IsFloat

(

)

const

Definition at line 937 of file Variant.cpp.

{
    return mDataType == P_DATA_NUMBER_FLOAT;
}

References P_DATA_NUMBER_FLOAT.

Referenced by PEBLEnvironment::IsFloat().

IsFunction()

bool Variant::IsFunction

(

)

const

Definition at line 970 of file Variant.cpp.

{
    return mDataType == P_DATA_FUNCTION;
}

References P_DATA_FUNCTION.

Referenced by Less().

IsFunctionPointer()

bool Variant::IsFunctionPointer

(

)

const

Definition at line 976 of file Variant.cpp.

{
    return mDataType == P_DATA_FUNCTION_POINTER;
}

References P_DATA_FUNCTION_POINTER.

IsGlobalVariable()

bool Variant::IsGlobalVariable

(

)

const

Definition at line 964 of file Variant.cpp.

{
    return  mDataType == P_DATA_GLOBALVARIABLE;
}

References P_DATA_GLOBALVARIABLE.

Referenced by Evaluator::Evaluate(), and Evaluator::Evaluate1().

IsInteger()

bool Variant::IsInteger

(

)

const

Definition at line 942 of file Variant.cpp.

{
    return  mDataType == P_DATA_NUMBER_INTEGER;
 
}

References P_DATA_NUMBER_INTEGER.

Referenced by Equal(), Evaluator::Evaluate(), Evaluator::Evaluate1(), PEBLEnvironment::IsInteger(), operator*(), operator+(), and operator-().

IsLocalVariable()

bool Variant::IsLocalVariable

(

)

const

Definition at line 959 of file Variant.cpp.

{
    return  mDataType == P_DATA_LOCALVARIABLE;
}

References P_DATA_LOCALVARIABLE.

Referenced by Evaluator::Evaluate(), and Evaluator::Evaluate1().

IsNumber()

bool Variant::IsNumber

(

)

const

This tests whether the Variant is a number (i.e., a float or an integer.)

Definition at line 930 of file Variant.cpp.

{
    return ( mDataType == P_DATA_NUMBER_INTEGER ||
             mDataType == P_DATA_NUMBER_FLOAT);
}

References P_DATA_NUMBER_FLOAT, and P_DATA_NUMBER_INTEGER.

Referenced by PEBLMath::Abs(), PEBLMath::AbsFloor(), PEBLMath::ACos(), PEBLMath::ASin(), PEBLMath::ATan(), PEBLMath::Ceiling(), PEBLMath::Cos(), PEBLMath::DegToRad(), Equal(), PEBLMath::Exp(), PEBLMath::Floor(), PEBLEnvironment::IsNumber(), Less(), PEBLMath::Ln(), PEBLMath::Log10(), PEBLMath::Log2(), PEBLMath::LogN(), PEBLMath::NthRoot(), operator*(), operator+(), operator-(), operator/(), PEBLInterpret(), PEBLMath::Pow(), PEBLMath::RadToDeg(), PEBLEnvironment::RegisterEvent(), PEBLMath::Round(), PEBLMath::Sign(), PEBLMath::Sin(), PEBLMath::Sqrt(), PEBLMath::Tan(), and PColor::ValidateProperty().

IsStackSignal()

bool Variant::IsStackSignal

(

)

const

Definition at line 989 of file Variant.cpp.

{
    return mDataType == P_DATA_STACK_SIGNAL;
}

References P_DATA_STACK_SIGNAL.

Referenced by PEBLObjects::Draw(), Equal(), Evaluator::Evaluate(), Evaluator::Evaluate1(), PEBLEnvironment::GetVideoModes(), PEBLObjects::MakeWindow(), and PEBLEnvironment::RegisterEvent().

IsString()

bool Variant::IsString

(

)

const

Definition at line 948 of file Variant.cpp.

{
    return mDataType == P_DATA_STRING;
}

References P_DATA_STRING.

Referenced by Equal(), PEBLEnvironment::IsString(), PEBLEnvironment::IsText(), Less(), operator+(), and PEBLMath::ToNumber().

IsVariable()

bool Variant::IsVariable

(

)

const

Definition at line 954 of file Variant.cpp.

{
    return( mDataType == P_DATA_LOCALVARIABLE || mDataType == P_DATA_GLOBALVARIABLE);
}

References P_DATA_GLOBALVARIABLE, and P_DATA_LOCALVARIABLE.

Referenced by free_mData().

Less()

bool Variant::Less

(

const Variant &

rhs

)

const

Primitive Comparing Method.

Definition at line 543 of file Variant.cpp.

{
 
        if (this->IsNumber() && rhs.IsNumber())
                {
                        return ((this->GetFloat()) < (rhs.GetFloat()));
                }
        else if (this->IsString() && rhs.IsString())
            { //If both are strings, compare them
 
            //Get copies of the strings.
            std::string  str1 = this->GetString();
            std::string  str2 = rhs.GetString();
 
            return str1 < str2;
            }
        else if (this->IsFunction() && rhs.IsFunction())
        {
            //Get copies of the strings.
 
            std::string  str1 = this->GetFunctionName();
            std::string  str2 = rhs.GetFunctionName();
 
            return (str1 < str2);
        }
            //This should be handled more elegantly.
            return false;
}

References GetFloat(), GetFunctionName(), GetString(), IsFunction(), IsNumber(), and IsString().

Referenced by operator<().

operator bool()

Variant::operator bool

(

)

Definition at line 866 of file Variant.cpp.

{
    if((*this) == Variant((pInt)0) ||
       (*this) == Variant((pDouble)0.0) ||
       (*this) == Variant("") ||
       (*this) == Variant("F") ||
       (*this) == Variant("FALSE")
       )
 
        return false;
    else
        return true;
}

References pDouble, and pInt.

operator const std::string()

Variant::operator const std::string

(

)

const

Definition at line 855 of file Variant.cpp.

{
    return GetString();
}

operator int()

Variant::operator int

(

)

Definition at line 830 of file Variant.cpp.

{
    return static_cast<int>(GetInteger());
}

operator long unsigned int()

Variant::operator long unsigned int

(

)

Definition at line 837 of file Variant.cpp.

{
    return static_cast<long unsigned int>(GetInteger());
}

operator pDouble()

Variant::operator pDouble

(

)

Typecast Operators.

Definition at line 844 of file Variant.cpp.

{
    return GetFloat();
}

operator pInt()

Variant::operator pInt

(

)

Definition at line 824 of file Variant.cpp.

{
    return GetInteger();
}

operator!=()

bool Variant::operator!=

(

const Variant &

rhs

)

const

Definition at line 581 of file Variant.cpp.

{ return ! ((*this) == rhs); }

operator*()

Variant Variant::operator*

(

const Variant &

rhs

)

const

This overloads the * operator for Variants.

Definition at line 444 of file Variant.cpp.

{
    pInt i;
    pDouble f;
 
    if(this->IsInteger()  && rhs.IsInteger())
        {
            i = this->GetInteger() * rhs.GetInteger();
            return Variant(i);
        }
    else if (this->IsNumber() && rhs.IsNumber())
        {
 
            f = this->GetFloat() * rhs.GetFloat();
            return Variant(f);
        }
    else
        i=0;
    return Variant(i);
 
}

References GetFloat(), GetInteger(), IsInteger(), IsNumber(), pDouble, pInt, and Variant().

operator+()

Variant Variant::operator+

(

const Variant &

rhs

)

const

This overloads the + operator for Variants. for strings, this concatenates them.

Definition at line 386 of file Variant.cpp.

{
    pInt i;
    pDouble f;
 
    if(this->IsInteger()  && rhs.IsInteger())
        {
            i = this->GetInteger() + rhs.GetInteger();
            return Variant(i);
        }
    else if (this->IsNumber() && rhs.IsNumber())
        {
            f = this->GetFloat() + rhs.GetFloat();
            return Variant(f);
        }
    else if (this->IsString() || rhs.IsString())
        {
            std::string  tmp1, tmp2;
            tmp1 = GetString();
            tmp2 = rhs.GetString();
            tmp1 += tmp2;
            return Variant(tmp1);
        }
    else
        //There should be an error emmitted here
        i=0;
    return Variant(i);
 
}

References GetFloat(), GetInteger(), GetString(), IsInteger(), IsNumber(), IsString(), pDouble, pInt, and Variant().

operator-()

Variant Variant::operator-

(

const Variant &

rhs

)

const

This overloads the - operator for Variants.

Definition at line 418 of file Variant.cpp.

{
    pInt i;
    pDouble f;
 
    if(this->IsInteger()  && rhs.IsInteger())
        {
            i = this->GetInteger() - rhs.GetInteger();
            return Variant(i);
        }
    else if (this->IsNumber() && rhs.IsNumber())
        {
 
            f = this->GetFloat() - rhs.GetFloat();
            return Variant(f);
        }
    else
        i=0;
    return Variant(i);
 
}

References GetFloat(), GetInteger(), IsInteger(), IsNumber(), pDouble, pInt, and Variant().

operator/()

Variant Variant::operator/

(

const Variant &

rhs

)

const

This overloads the / operator for Variants.

Definition at line 469 of file Variant.cpp.

{
    pInt i;
    pDouble f;
 
    if(this->IsNumber() && rhs.IsNumber())
        {
 
            f = this->GetFloat() / rhs.GetFloat();
            return Variant(f);
        }
    else
        i=0;
    return Variant(i);
 
}

References GetFloat(), IsNumber(), pDouble, pInt, and Variant().

operator<()

bool Variant::operator<

(

const Variant &

rhs

)

const

Definition at line 586 of file Variant.cpp.

{ return Less(rhs); }

References Less().

operator<=()

bool Variant::operator<=

(

const Variant &

rhs

)

const

Definition at line 596 of file Variant.cpp.

{ return ! ((*this) > rhs); }

operator=() [1/9]

Variant Variant::operator=

(

const char *

value

)

Definition at line 744 of file Variant.cpp.

{
    //First, clean up 'this' if it contains data on free store
    // (e.g., a Variable or a string)
    free_mData();
 
    mDataType = P_DATA_STRING;
    mData.String = strdup(value);
    return *this;
}

References free_mData(), and P_DATA_STRING.

operator=() [2/9]

Variant Variant::operator=

(

const double &

value

)

Definition at line 718 of file Variant.cpp.

{
    //First, clean up 'this' if it contains data on free store
    // (e.g., a Variable or a string)
    free_mData();
 
    mDataType = P_DATA_NUMBER_FLOAT;
    mData.fNumber = (pDouble)value;
    return *this;
}

References free_mData(), P_DATA_NUMBER_FLOAT, and pDouble.

operator=() [3/9]

Variant Variant::operator=

(

const float &

value

)

Definition at line 730 of file Variant.cpp.

{
    //First, clean up 'this' if it contains data on free store
    // (e.g., a Variable or a string)
    free_mData();
 
    mDataType = P_DATA_NUMBER_FLOAT;
    mData.fNumber = (pDouble)value;
    return *this;
}

References free_mData(), P_DATA_NUMBER_FLOAT, and pDouble.

operator=() [4/9]

Variant Variant::operator=

(

const int &

value

)

Definition at line 707 of file Variant.cpp.

{
    //First, clean up 'this' if it contains data on free store
    // (e.g., a Variable or a string)
    free_mData();
 
    mDataType = P_DATA_NUMBER_INTEGER;
    mData.iNumber = (pInt)value;
    return *this;
}

References free_mData(), P_DATA_NUMBER_INTEGER, and pInt.

operator=() [5/9]

Variant Variant::operator=

(

const long unsigned int &

value

)

Definition at line 694 of file Variant.cpp.

{
    //First, clean up 'this' if it contains data on free store
    // (e.g., a Variable or a string)
    free_mData();
 
 
    mDataType = P_DATA_NUMBER_INTEGER;
    mData.iNumber = value;
    return *this;
}

References free_mData(), and P_DATA_NUMBER_INTEGER.

operator=() [6/9]

Variant Variant::operator=

(

const pDouble &

value

)

Definition at line 669 of file Variant.cpp.

{
    //First, clean up 'this' if it contains data on free store
    // (e.g., a Variable or a string)
    free_mData();
 
    mDataType = P_DATA_NUMBER_FLOAT;
    mData.fNumber = value;
    return *this;
}

References free_mData(), and P_DATA_NUMBER_FLOAT.

operator=() [7/9]

Variant Variant::operator=

(

const pInt &

value

)

Definition at line 681 of file Variant.cpp.

{
    //First, clean up 'this' if it contains data on free store
    // (e.g., a Variable or a string)
    free_mData();
 
 
    mDataType = P_DATA_NUMBER_INTEGER;
    mData.iNumber = value;
    return *this;
}

References free_mData(), and P_DATA_NUMBER_INTEGER.

operator=() [8/9]

Variant Variant::operator=

(

const std::string

value

)

Definition at line 757 of file Variant.cpp.

{
    //First, clean up 'this' if it contains data on free store
    // (e.g., a Variable or a string)
    free_mData();
 
    mDataType = P_DATA_STRING;
    mData.String = strdup(value.c_str());
    return *this;
}

References free_mData(), and P_DATA_STRING.

operator=() [9/9]

Variant Variant::operator=

(

const Variant &

value

)

Assignment Operator (overloaded)

Definition at line 610 of file Variant.cpp.

{
    // Debug: std::cout << "[VARIANT] Assignment operator called. Old type: " << mDataType
    //           << " (" << GetDataTypeName() << "), New type: " << value.GetDataType()
    //           << " (" << value.GetDataTypeName() << ")" << std::endl;
 
    //First, clean up 'this' if it contains data on free store
    // (e.g., a Variable or a string)
    free_mData();
 
    mDataType=value.GetDataType();
    switch(mDataType)
        {
        case P_DATA_NUMBER_INTEGER:  // an integer
            mData.iNumber = value.GetInteger();
            break;
 
        case P_DATA_NUMBER_FLOAT:    // a float
            mData.fNumber = value.GetFloat();
            break;
 
        case P_DATA_STRING:
            mData.String = strdup(value.GetString().c_str());
            break;
 
        case P_DATA_LOCALVARIABLE:        // a char* variable name
        case P_DATA_GLOBALVARIABLE:        // a char* variable name
            mData.Variable = strdup(value.GetVariableName().c_str());
            break;
 
        case P_DATA_FUNCTION:
            mData.Function = strdup(value.GetFunctionName().c_str());
            break;
 
        case P_DATA_FUNCTION_POINTER:
            mData.pFunction = value.GetFunctionPointer();
            break;
 
        case P_DATA_STACK_SIGNAL:
            mData.Signal = value.GetSignal();
            break;
 
        case P_DATA_COMPLEXDATA:
            {
            PComplexData * tmp = value.GetComplexData();
            //tmp is a pointer to complex data, which
            //is just a holder for the object.  We want to make a
            //copy of tmp
            mComplexData = new PComplexData(*tmp);
            break;
            }
        case P_DATA_UNDEFINED: // undefined, error
        default:
            PError::SignalFatalError( "Undefined Variant type in Variant::operator = (Variant).");
            break;
        }
    return (*this);
}

References free_mData(), GetComplexData(), GetDataType(), GetFloat(), GetFunctionName(), GetFunctionPointer(), GetInteger(), GetSignal(), GetString(), GetVariableName(), P_DATA_COMPLEXDATA, P_DATA_FUNCTION, P_DATA_FUNCTION_POINTER, P_DATA_GLOBALVARIABLE, P_DATA_LOCALVARIABLE, P_DATA_NUMBER_FLOAT, P_DATA_NUMBER_INTEGER, P_DATA_STACK_SIGNAL, P_DATA_STRING, P_DATA_UNDEFINED, and PError::SignalFatalError().

operator==()

bool Variant::operator==

(

const Variant &

rhs

)

const

Definition at line 576 of file Variant.cpp.

{ return Equal(rhs); }

References Equal().

operator>()

bool Variant::operator>

(

const Variant &

rhs

)

const

Definition at line 591 of file Variant.cpp.

{ return rhs < (*this); }

operator>=()

bool Variant::operator>=

(

const Variant &

rhs

)

const

Definition at line 601 of file Variant.cpp.

{ return rhs <= (*this); }

SetComplexData()

void Variant::SetComplexData

(

PComplexData *

data

)

This sets the complex data type to the argument. It does not delete the complex data currently held in the pointer.

Definition at line 1309 of file Variant.cpp.

{
    mComplexData = data;
}

SetCreationTime()

void Variant::SetCreationTime ( long unsigned int  time )

inline

Definition at line 184 of file Variant.h.

{mCreationTime = time;};

Referenced by PEvent::operator Variant(), and PEBLEnvironment::WaitForAnyKeyPress().

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream &  out, const Variant &  v  )

friend

---

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

• Variant.h
• Variant.cpp