static Value mathAbs(Context *ctx, const List<Value>& args)
{
if (args.getCount() != 1)
{
ctx->throwException(createException(ExcType::ValueError, "abs takes only one argument."));
}
switch (args[0].type)
{
case ValueType::Float:
{
return createFloat(std::abs(args[0].f));
}
case ValueType::Int:
{
return createInt(std::llabs(args[0].i));
}
default:
{
ctx->throwException(createException(ExcType::TypeError, "Value is not convertable to float."));
}
}
SDL_assert_release(false);
return createInt(0);
}
XMLElem ComplexXMLParser10x::convertMatchInformationToXML(
const MatchInformation* matchInfo,
XMLElem parent) const
{
XMLElem matchInfoXML = newElement("MatchInfo", parent);
createInt("NumMatchTypes",
matchInfo->types.size(),
matchInfoXML);
for (size_t i = 0; i < matchInfo->types.size(); ++i)
{
const MatchType* mt = matchInfo->types[i].get();
XMLElem mtXML = newElement("MatchType", matchInfoXML);
setAttribute(mtXML, "index", str::toString(i + 1));
createString("TypeID", mt->typeID, mtXML);
createInt("CurrentIndex", mt->currentIndex, mtXML);
createInt("NumMatchCollections", mt->matchCollects.size(), mtXML);
for (size_t j = 0; j < mt->matchCollects.size(); ++j)
{
XMLElem mcXML = newElement("MatchCollection", mtXML);
setAttribute(mcXML, "index", str::toString(j + 1));
createString("CoreName", mt->matchCollects[j].coreName, mcXML);
createInt("MatchIndex", mt->matchCollects[j].matchIndex, mcXML);
common().addParameters("Parameter",
mt->matchCollects[j].parameters, mcXML);
}
}
return matchInfoXML;
}
int main ( int argc, char *argv[] )
{
List* list = list_create ( sizeof ( int ),EqualInt );
int t;
ListNode* n;
int i;
for ( i=0; i<10; ++i )
list_push_back ( list,createInt ( &t,rand() ) );
/*list_foreach(list,printInt);*/
ListIter iter = list_get_iter ( list );
while ( list_iter_hasNext ( iter ) )
{
printInt ( list_iter_next ( iter ) );
}
printf ( "\n" );
list_pop_back ( list );
list_foreach ( list,incInt );
list_foreach ( list,printInt );
printf ( "\n" );
n = list_find_first_node ( list,createInt ( &t,846930887 ) );
list_erase_node ( list,n );
list_foreach ( list,printInt );
list_delete ( list );
return 0;
}
XMLElem ComplexXMLParser10x::convertRadarCollectionToXML(
const RadarCollection *radar,
XMLElem parent) const
{
XMLElem radarXML = newElement("RadarCollection", parent);
createTxFrequency(radar, radarXML);
if (!Init::isUndefined<int>(radar->refFrequencyIndex))
{
createInt("RefFreqIndex", radar->refFrequencyIndex, radarXML);
}
// SICD v1.0 removes PolarizationHVAnglePoly
createWaveform(radar, radarXML);
//! required in 1.0
createString("TxPolarization", six::toString(radar->txPolarization),
radarXML);
createTxSequence(radar, radarXML);
createRcvChannels(radar, radarXML);
createArea(radar, radarXML);
common().addParameters("Parameter", radar->parameters, radarXML);
return radarXML;
}
XMLElem ComplexXMLParser10x::createRcvChannels(const RadarCollection* radar,
XMLElem parent) const
{
const size_t numChannels = radar->rcvChannels.size();
XMLElem rcvChanXML = newElement("RcvChannels", parent);
setAttribute(rcvChanXML, "size", str::toString(numChannels));
for (size_t ii = 0; ii < numChannels; ++ii)
{
const ChannelParameters* const cp = radar->rcvChannels[ii].get();
XMLElem cpXML = newElement("ChanParameters", rcvChanXML);
setAttribute(cpXML, "index", str::toString(ii + 1));
//! required in 1.0
createString(
"TxRcvPolarization",
six::toString<DualPolarizationType>(cp->txRcvPolarization),
cpXML);
if (!Init::isUndefined<int>(cp->rcvAPCIndex))
{
createInt("RcvAPCIndex", cp->rcvAPCIndex, cpXML);
}
}
return rcvChanXML;
}
static Value classNew(Context *ctx, const List<Value>& args)
{
if (args.getCount() < 1)
{
ctx->throwException(createException(ExcType::ValueError, "__new__/__call__ takes at least 1 argument."));
}
Value class_ = args[0];
Value __base__ = createString("__base__");
Value base = getMember(ctx, class_, __base__);
destroy(ctx, __base__);
Value __typeID__ = createString("__typeID__");
Value typeID = getMember(ctx, class_, __typeID__);
destroy(ctx, __typeID__);
if (base.type != ValueType::Object)
{
ctx->throwException(createException(ExcType::TypeError, "Class base must be an object."));
}
if (typeID.type != ValueType::Int)
{
ctx->throwException(createException(ExcType::TypeError, "Class type ID must be an integer."));
}
Value resultHead = createObject();
HashMap<Str, Value>& resultMembers = ((ObjectData *)resultHead.p)->members;
HashMap<Str, Value>& baseMembers = ((ObjectData *)base.p)->members;
for (auto kv : baseMembers)
{
resultMembers.set(kv.first, createCopy(kv.second));
}
resultMembers.set("__classTypeID__", createInt(typeID.i));
resultMembers.set("__class__", createCopy(args[0]));
auto pos = resultMembers.find("__init__");
if (pos != resultMembers.end())
{
destroy(ctx, callMethod(ctx, resultHead, "__init__", List<Value>(args.getCount()-1, args.getData()+1)));
} else
{
if (args.getCount() != 1)
{
ctx->throwException(createException(ExcType::ValueError, "__new__/__call__ takes 1 argument."));
}
}
destroy(ctx, typeID);
destroy(ctx, base);
return resultHead;
}
void
PropertyManager::addAttribute(wxPropertyGridManager *pg, std::unique_ptr<Attribute> &a) {
switch (a->getType()) {
case Enums::ENUM: createEnum(pg, a); break;
case Enums::BOOL: createBool(pg, a); break;
case Enums::BVEC4: createBVec4(pg, a); break;
case Enums::INT: createInt(pg, a); break;
case Enums::IVEC3: createIVec3(pg, a); break;
case Enums::UINT: createUInt(pg, a); break;
case Enums::UIVEC2: createUIVec2(pg, a); break;
case Enums::UIVEC3: createUIVec3(pg, a); break;
case Enums::FLOAT: createFloat(pg, a); break;
case Enums::VEC2: createVec2(pg, a); break;
case Enums::VEC3: createVec3(pg, a); break;
case Enums::VEC4: createVec4(pg, a); break;
case Enums::MAT3: createMat3(pg, a); break;
case Enums::MAT4: createMat4(pg, a); break;
case Enums::STRING: createString(pg, a); break;
default: assert(false && "Missing datatype in property manager");
}
}
static Value createClass(Context *ctx, const List<Value>& args)
{
if (args.getCount() != 1)
{
ctx->throwException(createException(ExcType::ValueError, "__classify takes 1 argument."));
}
Value base = args[0];
if (base.type != ValueType::Object)
{
ctx->throwException(createException(ExcType::ValueError, "base must be an object."));
}
Value result = createObject();
HashMap<Str, Value>& resultMembers = ((ObjectData *)result.p)->members;
resultMembers.set("__base__", createCopy(args[0]));
resultMembers.set("__typeID__", createInt(ctx->getEngine()->createNewTypeID()));
resultMembers.set("__call__", createNativeFunction(classNew));
return result;
}
void XMLizer::writeFilter( QDomDocument &document, QDomNode &parent, bool audio, QSharedPointer<Filter> f )
{
QString s = audio ? "AudioFilter" : "VideoFilter";
QDomElement n1 = document.createElement( s );
parent.appendChild( n1 );
createText( document, n1, "Name", f->getIdentifier() );
createDouble( document, n1, "PosInTrack", f->getPosition() );
if ( f->getPositionOffset() > 0 )
createDouble( document, n1, "PosOffset", f->getPositionOffset() );
createDouble( document, n1, "Length", f->getLength() );
createInt( document, n1, "SnapMode", f->getSnap() );
QList<Parameter*> params = f->getParameters();
for ( int i = 0; i < params.count(); ++i ) {
Parameter *p = params[i];
QDomElement pel = document.createElement( "Parameter" );
n1.appendChild( pel );
pel.setAttribute( "name", p->id );
switch ( p->type ) {
case Parameter::PDOUBLE: {
pel.setAttribute( "type", "double" );
pel.setAttribute( "value", QString::number( p->value.toDouble(), 'e', 17 ) );
break;
}
case Parameter::PINPUTDOUBLE: {
pel.setAttribute( "type", "inputdouble" );
pel.setAttribute( "value", QString::number( p->value.toDouble(), 'e', 17 ) );
break;
}
case Parameter::PINT: {
pel.setAttribute( "type", "int" );
pel.setAttribute( "value", QString::number( p->value.toInt() ) );
break;
}
case Parameter::PBOOL: {
pel.setAttribute( "type", "bool" );
pel.setAttribute( "value", QString::number( p->value.toInt() ) );
break;
}
case Parameter::PRGBCOLOR: {
pel.setAttribute( "type", "rgb" );
pel.setAttribute( "value", p->value.value<QColor>().name() );
break;
}
case Parameter::PRGBACOLOR: {
QColor col = p->value.value<QColor>();
pel.setAttribute( "type", "rgba" );
pel.setAttribute( "value", col.name() + "." + QString::number( col.alpha() ) );
break;
}
case Parameter::PCOLORWHEEL: {
QColor col = p->value.value<QColor>();
pel.setAttribute( "type", "colorwheel" );
pel.setAttribute( "value", QString::number( col.blueF(), 'e', 17 ) );
pel.setAttribute( "hue", QString::number( col.redF(), 'e', 17 ) );
pel.setAttribute( "saturation", QString::number( col.greenF(), 'e', 17 ) );
break;
}
case Parameter::PSTRING: {
pel.setAttribute( "type", "string" );
pel.setAttribute( "value", p->value.toString().replace( "\n", QString::fromUtf8("¶") ) );
break;
}
case Parameter::PSHADEREDIT: {
pel.setAttribute( "type", "shader" );
pel.setAttribute( "value", Parameter::getShaderName( p->value.toString() ) );
break;
}
case Parameter::PSTATUS: {
pel.setAttribute( "type", "status" );
pel.setAttribute( "value", "" );
break;
}
}
for ( int i = 0; i < p->graph.keys.count(); ++i ) {
QDomElement ke = document.createElement( "Key" );
pel.appendChild( ke );
QString type;
switch ( p->graph.keys[i].keyType ) {
case AnimationKey::CONSTANT: type = "constant"; break;
case AnimationKey::CURVE: type = "curve"; break;
default: type = "linear";
}
ke.setAttribute( "type", type );
ke.setAttribute( "position", QString::number( p->graph.keys[i].x, 'e', 17 ) );
ke.setAttribute( "value", QString::number( p->getUnnormalizedKeyValue( i ), 'e', 17 ) );
}
}
}
