float ReceivedMessageArgument::AsFloat() const
{
if( !typeTagPtr_ )
throw MissingArgumentException();
else if( *typeTagPtr_ == FLOAT_TYPE_TAG )
return AsFloatUnchecked();
else
throw WrongArgumentTypeException();
}
bool ReceivedMessageArgument::AsBoolUnchecked() const
{
if( !typeTagPtr_ )
throw MissingArgumentException();
else if( *typeTagPtr_ == TRUE_TYPE_TAG )
return true;
else
return false;
}
int32 ReceivedMessageArgument::AsInt32() const
{
if( !typeTagPtr_ )
throw MissingArgumentException();
else if( *typeTagPtr_ == INT32_TYPE_TAG )
return AsInt32Unchecked();
else
throw WrongArgumentTypeException();
}
const char* ReceivedMessageArgument::AsSymbol() const
{
if( !typeTagPtr_ )
throw MissingArgumentException();
else if( *typeTagPtr_ == SYMBOL_TYPE_TAG )
return argumentPtr_;
else
throw WrongArgumentTypeException();
}
void ReceivedMessageArgument::AsBlob( const void*& data, osc_bundle_element_size_t& size ) const
{
if( !typeTagPtr_ )
throw MissingArgumentException();
else if( *typeTagPtr_ == BLOB_TYPE_TAG )
AsBlobUnchecked( data, size );
else
throw WrongArgumentTypeException();
}
uint64 ReceivedMessageArgument::AsTimeTag() const
{
if( !typeTagPtr_ )
throw MissingArgumentException();
else if( *typeTagPtr_ == TIME_TAG_TYPE_TAG )
return AsTimeTagUnchecked();
else
throw WrongArgumentTypeException();
}
double ReceivedMessageArgument::AsDouble() const
{
if( !typeTagPtr_ )
throw MissingArgumentException();
else if( *typeTagPtr_ == DOUBLE_TYPE_TAG )
return AsDoubleUnchecked();
else
throw WrongArgumentTypeException();
}
uint32 ReceivedMessageArgument::AsRgbaColor() const
{
if( !typeTagPtr_ )
throw MissingArgumentException();
else if( *typeTagPtr_ == RGBA_COLOR_TYPE_TAG )
return AsRgbaColorUnchecked();
else
throw WrongArgumentTypeException();
}
uint32 ReceivedMessageArgument::AsMidiMessage() const
{
if( !typeTagPtr_ )
throw MissingArgumentException();
else if( *typeTagPtr_ == MIDI_MESSAGE_TYPE_TAG )
return AsMidiMessageUnchecked();
else
throw WrongArgumentTypeException();
}
char ReceivedMessageArgument::AsChar() const
{
if( !typeTagPtr_ )
throw MissingArgumentException();
else if( *typeTagPtr_ == CHAR_TYPE_TAG )
return AsCharUnchecked();
else
throw WrongArgumentTypeException();
}
void ReceivedMessageArgument::AsBlob( const void*& data, unsigned long& size ) const
{
if( !typeTag_ )
throw MissingArgumentException();
else if( *typeTag_ == BLOB_TYPE_TAG )
AsBlobUnchecked( data, size );
else
throw WrongArgumentTypeException();
}
const char* ReceivedMessageArgument::AsString() const
{
if( !typeTag_ )
throw MissingArgumentException();
else if( *typeTag_ == STRING_TYPE_TAG )
return argument_;
else
throw WrongArgumentTypeException();
}
int64 ReceivedMessageArgument::AsInt64() const
{
if( !typeTag_ )
throw MissingArgumentException();
else if( *typeTag_ == INT64_TYPE_TAG )
return AsInt64Unchecked();
else
throw WrongArgumentTypeException();
}
bool ReceivedMessageArgument::AsBool() const
{
if( !typeTag_ )
throw MissingArgumentException();
else if( *typeTag_ == TRUE_TYPE_TAG )
return true;
else if( *typeTag_ == FALSE_TYPE_TAG )
return false;
else
throw WrongArgumentTypeException();
}
void Option::process(const std::string& option, std::string& arg) const
{
std::string::size_type pos = option.find_first_of(":=");
std::string::size_type len = pos == std::string::npos ? option.length() : pos;
if (icompare(option, 0, len, _fullName, 0, len) == 0)
{
if (takesArgument())
{
if (argumentRequired() && pos == std::string::npos)
throw MissingArgumentException(_fullName + " requires " + argumentName());
if (pos != std::string::npos)
arg.assign(option, pos + 1, option.length() - pos - 1);
else
arg.clear();
}
else if (pos != std::string::npos)
{
throw UnexpectedArgumentException(option);
}
else arg.clear();
}
else if (!_shortName.empty() && option.compare(0, _shortName.length(), _shortName) == 0)
{
if (takesArgument())
{
if (argumentRequired() && option.length() == _shortName.length())
throw MissingArgumentException(_shortName + " requires " + argumentName());
arg.assign(option, _shortName.length(), option.length() - _shortName.length());
}
else if (option.length() != _shortName.length())
{
throw UnexpectedArgumentException(option);
}
else arg.clear();
}
else throw UnknownOptionException(option);
}
/*** Evaluate this object ***/
Object* Equal::evaluate()
{
if(arg1 == 0)
throw MissingArgumentException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL | OBJ_SEQUENCE | OBJ_TEXT | OBJ_LOGICAL, 1);
if(arg2 == 0)
throw MissingArgumentException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL | OBJ_SEQUENCE | OBJ_TEXT | OBJ_LOGICAL, 2);
std::auto_ptr<Object> obj1(arg1->evaluate());
std::auto_ptr<Object> obj2(arg2->evaluate());
if(obj1->getType() == OBJ_EMPTY && obj2->getType() == OBJ_EMPTY)
return new Logical(true);
if(obj1->getType() == OBJ_EMPTY || obj2->getType() == OBJ_EMPTY)
return new Logical(false);
if(obj1->getType() == OBJ_LOGICAL)
{
if(obj2->getType() != OBJ_LOGICAL)
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_LOGICAL, obj2->getType(), 2);
Logical* cast1 = static_cast<Logical*>(obj1.get());
Logical* cast2 = static_cast<Logical*>(obj2.get());
return new Logical(cast1->getValue() == cast2->getValue());
}
if(obj1->getType() == OBJ_INTEGER)
{
Integer* cast1 = static_cast<Integer*>(obj1.get());
if(obj2->getType() == OBJ_INTEGER)
{
Integer* cast2 = static_cast<Integer*>(obj2.get());
return new Logical(cast1->getValue() == cast2->getValue());
}
if(obj2->getType() == OBJ_REAL)
{
Real* cast2 = static_cast<Real*>(obj2.get());
return new Logical(cast1->getValue() == cast2->getValue());
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, obj2->getType(), 2);
}
if(obj1->getType() == OBJ_REAL)
{
Real* cast1 = static_cast<Real*>(obj1.get());
if(obj2->getType() == OBJ_INTEGER)
{
Integer* cast2 = static_cast<Integer*>(obj2.get());
return new Logical(cast1->getValue() == cast2->getValue());
}
if(obj2->getType() == OBJ_REAL)
{
Real* cast2 = static_cast<Real*>(obj2.get());
return new Logical(cast1->getValue() == cast2->getValue());
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, obj2->getType(), 2);
}
if(obj1->getType() == OBJ_TEXT)
{
if(obj2->getType() != OBJ_TEXT)
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_TEXT, obj2->getType(), 2);
Text* cast1 = static_cast<Text*>(obj1.get());
Text* cast2 = static_cast<Text*>(obj2.get());
return new Logical(cast1->getValue().compare(cast2->getValue()) == 0);
}
if(obj1->getType() == OBJ_SEQUENCE)
{
if(obj2->getType() != OBJ_SEQUENCE)
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_SEQUENCE, obj2->getType(), 2);
Sequence* cast1 = static_cast<Sequence*>(obj1.get());
Sequence* cast2 = static_cast<Sequence*>(obj2.get());
if(cast1->getLength() != cast2->getLength())
return new Logical(false);
for(unsigned int i = 0; i < cast1->getLength(); i++)
{
std::auto_ptr<Object> eqResult(Equal(cast1->getObject(i)->clone(), cast2->getObject(i)->clone()).evaluate());
Logical* logResult = static_cast<Logical*>(eqResult.get());
if(logResult->getValue() == false)
return new Logical(false);
}
return new Logical(true);
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_LOGICAL | OBJ_REAL | OBJ_TEXT | OBJ_SEQUENCE | OBJ_INTEGER, obj1->getType(), 1);
return 0;
}
