ModelObject *ModelData::createDataType(eModelDataTypes type, const std::string &id)
{
ModelObject *obj = nullptr;
switch(type)
{
case DT_DataType:
{
ModelType *dataType = new ModelType(id);
/// @todo - use make_unique when supported.
addType(std::unique_ptr<ModelType>(dataType));
obj = dataType;
}
break;
case DT_Class:
{
ModelClassifier *classifier = new ModelClassifier(id);
/// @todo - use make_unique when supported.
addType(std::unique_ptr<ModelType>(classifier));
obj = classifier;
break;
}
default:
break;
}
return obj;
}
void EAM::addExplicitInteraction(AtomType* atype1, AtomType* atype2,
RealType dr, int nr,
vector<RealType> phiVals) {
// in case these weren't already in the map
addType(atype1);
addType(atype2);
EAMInteractionData mixer;
CubicSpline* cs = new CubicSpline();
vector<RealType> rVals;
for (int i = 0; i < nr; i++) rVals.push_back(i * dr);
cs->addPoints(rVals, phiVals);
mixer.phi = cs;
mixer.rcut = mixer.phi->getLimits().second;
mixer.explicitlySet = true;
int eamtid1 = EAMtids[ atype1->getIdent() ];
int eamtid2 = EAMtids[ atype2->getIdent() ];
MixingMap[eamtid1][eamtid2] = mixer;
if (eamtid2 != eamtid1) {
MixingMap[eamtid2][eamtid1] = mixer;
}
return;
}
int fbtBuildInfo::getLengths(fbtBuildStructs& struct_builders)
{
makeBuiltinTypes();
fbtBuildStructs::Iterator bit = struct_builders.iterator();
while (bit.hasMoreElements())
{
fbtBuildStruct& bs = bit.getNext();
bs.m_structId = addType(bs.m_name, 0);
m_strc.push_back(bs.m_structId);
m_strc.push_back((FBTint16)bs.m_data.size());
m_alloc.m_strc += (sizeof(FBTtype) * 2);
fbtVariables::Iterator it = bs.m_data.iterator();
while (it.hasMoreElements())
{
fbtVariable& cvar = it.getNext();
cvar.m_typeId = addType(cvar.m_type, 0);
cvar.m_nameId = addName(cvar.m_name);
m_strc.push_back(cvar.m_typeId);
m_strc.push_back(cvar.m_nameId);
m_alloc.m_strc += (sizeof(FBTtype) * 2);
}
}
return getTLengths(struct_builders);
}
void GmacsParser::parse(GmacsToken **token)
{
bool isType = false;
for (int i = 0; token[i] != NULL; i++) {
if (searchFromType(token[i])) {
token[i]->type = TYPE_T;
isType = true;
} else if (searchFromPreserve(token[i])) {
token[i]->type = PRESERVE_T;
if (isClassType == true) {
if (token[i + 1] != NULL && token[i + 1]->type == SPACE_T &&
token[i + 2] != NULL && token[i + 2]->word.contains(QRegExp("^\\w*$"))) {
addType(token[i + 2]->word);
} else if (token[i + 1] != NULL && token[i + 1]->type != SPACE_T &&
token[i + 1]->word.contains(QRegExp("^\\w*$"))) {
addType(token[i + 1]->word);
}
}
isClassType = false;
} else if (token[i]->type == DEF_T && isType &&
token[i]->word.contains(QRegExp("^\\w*$"))) {
token[i]->type = VAR_T;
isType = false;
}
}
int name_idx = getFuncNameIdx(token);
if (name_idx > 0) {
token[name_idx]->type = FUNC_T;
}
}
ArcherGuy::ArcherGuy()
{
addType(TYP_CLIPS);
addType(TYP_HAS_GRAV);
size->set(.5, .95);
dir_facing = DIR_RIGHT;
firingArrow = 0;
fireArrowCount = 0;
fireArrowCooldown = 0;
}
explicit TypeValidator(const dynamic& schema) {
if (schema.isString()) {
addType(schema.stringPiece());
} else if (schema.isArray()) {
for (const auto& item : schema) {
if (item.isString()) {
addType(item.stringPiece());
}
}
}
}
void SC::addExplicitInteraction(AtomType* atype1, AtomType* atype2,
RealType epsilon, RealType m, RealType n,
RealType alpha) {
// in case these weren't already in the map
addType(atype1);
addType(atype2);
SCInteractionData mixer;
mixer.epsilon = epsilon;
mixer.m = m;
mixer.n = n;
mixer.alpha = alpha;
mixer.rCut = 2.0 * mixer.alpha;
RealType dr = mixer.rCut / (np_ - 1);
vector<RealType> rvals;
vector<RealType> vvals;
vector<RealType> phivals;
rvals.push_back(0.0);
vvals.push_back(0.0);
phivals.push_back(0.0);
for (int k = 1; k < np_; k++) {
RealType r = dr * k;
rvals.push_back(r);
vvals.push_back( mixer.epsilon * pow(mixer.alpha/r, mixer.n) );
phivals.push_back( pow(mixer.alpha/r, mixer.m) );
}
mixer.vCut = mixer.epsilon * pow(mixer.alpha/mixer.rCut, mixer.n);
CubicSpline* V = new CubicSpline();
V->addPoints(rvals, vvals);
CubicSpline* phi = new CubicSpline();
phi->addPoints(rvals, phivals);
mixer.V = V;
mixer.phi = phi;
mixer.explicitlySet = true;
int sctid1 = SCtids[ atype1->getIdent() ];
int sctid2 = SCtids[ atype2->getIdent() ];
MixingMap[sctid1][sctid2] = mixer;
if (sctid2 != sctid1) {
MixingMap[sctid2][sctid1] = mixer;
}
return;
}
static std::shared_ptr<SymbolTable> getPredefinedTable()
{
auto table = std::make_shared<SymbolTable>(nullptr);
table->addType(std::string("integer"), BuiltInType::getInt());
table->addType(std::string("INTEGER"), BuiltInType::getInt());
table->addType(std::string("boolean"), BuiltInType::getBool());
table->addType(std::string("BOOLEAN"), BuiltInType::getBool());
table->addType(std::string("char"), BuiltInType::getChar());
table->addType(std::string("CHAR"), BuiltInType::getChar());
table->addType(std::string("string"), BuiltInType::getStr());
table->addType(std::string("STRING"), BuiltInType::getStr());
return table;
}
bool MJGroup::init_BJ()
{
// if (mjList!= NULL) {
// mjList->removeAllObjects();
// }
// else
{
setMjList(__Array::create());
}
addType(MJType_Wang);
addType(MJType_Tiao);
addType(MJType_Tong);
return this;
}
DocTypeRep
DocumenttypesConfigBuilderHelper::document(int32_t id, const vespalib::string &name,
const DatatypeConfig &header,
const DatatypeConfig &body) {
assert(header.type == DatatypeConfig::STRUCT);
assert(body.type == DatatypeConfig::STRUCT);
_config.documenttype.resize(_config.documenttype.size() + 1);
_config.documenttype.back().id = id;
_config.documenttype.back().name = name;
_config.documenttype.back().headerstruct = header.id;
_config.documenttype.back().bodystruct = body.id;
addType(header, _config.documenttype.back());
addType(body, _config.documenttype.back());
return DocTypeRep(_config.documenttype.back());
}
void KeyModifiers::init()
{
m_bitmask = 0x00000001;
addType("Shift");
addType("Control");
addType("Alt");
ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
cfg.setGroup("Global");
QString timeout = cfg.readEntry("ToggleTimeout", "10");
int msec = timeout.toInt();
msec *= 1000; /* sec to msec */
m_timeout = msec;
}
t_tree addType(t_tree pVariables, eType pType)
{
if (pVariables == NULL) return NULL;
pVariables->Node.Variable.Type = pType;
addType (pVariables->Node.Variable.Next, pType);
return pVariables;
}
status_t MediaCodecList::addTypeFromAttributes(const char **attrs) {
const char *name = NULL;
size_t i = 0;
while (attrs[i] != NULL) {
if (!strcmp(attrs[i], "name")) {
if (attrs[i + 1] == NULL) {
return -EINVAL;
}
name = attrs[i + 1];
++i;
} else {
return -EINVAL;
}
++i;
}
if (name == NULL) {
return -EINVAL;
}
addType(name);
return OK;
}
Weapon::Weapon(RenderLayers layer, const float damage, const sf::Texture &texture, const sf::IntRect &rect)
: Item(layer, texture, rect)
, m_damage{ damage }
, m_damageMultiplicator{ 1.f }
{
addType(WorldObjectTypes::WEAPON);
}
//put data onto the dataPtr of the data array
OSCMessage& OSCMessage::add(int32_t data){
//add type
addType('i');
//add data;
addToBuffer(data);
return *this;
}
//put data onto the data part of the data array
OSCMessage& OSCMessage::add(unsigned int data){
//add type
addType('i');
//add data;
addToBuffer(int32_t(data));
return *this;
}
void BasicScope::declareType(string name, Type *type){
if(this->isDefined(name)){
throw NoticeException("Type '" + name + "' redeclaration #1!");
}
addType(name, type);
}
OSCMessage& OSCMessage::add(double data){
//add type
addType('f');
//add data;
addToBuffer(float(data));
return *this;
}
/* this function gets the index of a dihedral angle in the table
(adding an entry if none exists). The required number of
parameters (see notes on class DihedralTable) must be stored in
the array <c> */
int DihedralTable::getIndex(const float *c, int mult, int funct) {
/* check to see if it is in the table already */
int i,j,jmax;
if(funct==1 || funct==2) { /* for these we only need two params */
jmax=2;
} else { /* for RB we need all 6 */
jmax=6;
}
for(i=0;i<cArray.size();i++) {
int mismatch=0;
if(mult != multArray[i]) continue;
if(funct != functArray[i]) continue;
for(j=0;j<jmax;j++) {
if(fabs(c[j]-cArray[i][j])>=0.00001) {
mismatch=1;
break;
}
}
if(!mismatch) {
/* all of the parameters matched */
return i;
}
}
/* nope, it wasn't in the table add a new element! */
addType(NULL,NULL,c,mult,funct);
return cArray.size()-1;
}
Ingredient::Ingredient(const Vector &pos, IngredientData *data, int amount)
: Entity(), data(data), amount(amount), gone(false), used(false)
{
addType(SCO_INGREDIENT);
entityType = ET_INGREDIENT;
position = pos;
lifeSpan = 30;
if (data)
{
setTexture("Ingredients/"+data->gfx);
}
int mag = 600;
if (isRotKind())
velocity = randVector(mag)*0.5f + Vector(0, -mag)*0.5f;
else
velocity = Vector(0,-mag*0.5f);
gravity = Vector(0, 250); //300
scale = Vector(0.2,0.2);
scale.interpolateTo(Vector(1, 1), 0.75);
if (isRotKind())
rotation.z = randAngle360();
layer = LR_ENTITIES;
}
bool KnownPluginList::scanAndAddFile (const String& fileOrIdentifier,
const bool dontRescanIfAlreadyInList,
OwnedArray <PluginDescription>& typesFound,
AudioPluginFormat& format)
{
const ScopedLock sl (scanLock);
if (dontRescanIfAlreadyInList
&& getTypeForFile (fileOrIdentifier) != nullptr)
{
bool needsRescanning = false;
for (int i = types.size(); --i >= 0;)
{
const PluginDescription* const d = types.getUnchecked(i);
if (d->fileOrIdentifier == fileOrIdentifier && d->pluginFormatName == format.getName())
{
if (format.pluginNeedsRescanning (*d))
needsRescanning = true;
else
typesFound.add (new PluginDescription (*d));
}
}
if (! needsRescanning)
return false;
}
if (blacklist.contains (fileOrIdentifier))
return false;
OwnedArray <PluginDescription> found;
{
const ScopedUnlock sl2 (scanLock);
if (scanner != nullptr)
{
if (! scanner->findPluginTypesFor (format, found, fileOrIdentifier))
addToBlacklist (fileOrIdentifier);
}
else
{
format.findAllTypesForFile (found, fileOrIdentifier);
}
}
for (int i = 0; i < found.size(); ++i)
{
PluginDescription* const desc = found.getUnchecked(i);
jassert (desc != nullptr);
addType (*desc);
typesFound.add (new PluginDescription (*desc));
}
return found.size() > 0;
}
Array<ProjectExporter::ExporterTypeInfo> ProjectExporter::getExporterTypes()
{
Array<ProjectExporter::ExporterTypeInfo> types;
addType (types, XCodeProjectExporter::getNameMac(), BinaryData::projectIconXcode_png, BinaryData::projectIconXcode_pngSize);
addType (types, XCodeProjectExporter::getNameiOS(), BinaryData::projectIconXcodeIOS_png, BinaryData::projectIconXcodeIOS_pngSize);
addType (types, MSVCProjectExporterVC2015::getName(), BinaryData::projectIconVisualStudio_png, BinaryData::projectIconVisualStudio_pngSize);
addType (types, MSVCProjectExporterVC2013::getName(), BinaryData::projectIconVisualStudio_png, BinaryData::projectIconVisualStudio_pngSize);
addType (types, MSVCProjectExporterVC2012::getName(), BinaryData::projectIconVisualStudio_png, BinaryData::projectIconVisualStudio_pngSize);
addType (types, MSVCProjectExporterVC2010::getName(), BinaryData::projectIconVisualStudio_png, BinaryData::projectIconVisualStudio_pngSize);
addType (types, MakefileProjectExporter::getNameLinux(), BinaryData::projectIconLinuxMakefile_png, BinaryData::projectIconLinuxMakefile_pngSize);
addType (types, AndroidProjectExporter::getName(), BinaryData::projectIconAndroid_png, BinaryData::projectIconAndroid_pngSize);
addType (types, CodeBlocksProjectExporter::getNameWindows(), BinaryData::projectIconCodeblocks_png, BinaryData::projectIconCodeblocks_pngSize);
addType (types, CodeBlocksProjectExporter::getNameLinux(), BinaryData::projectIconCodeblocks_png, BinaryData::projectIconCodeblocks_pngSize);
return types;
}
CRBFFeatureCalculator::CRBFFeatureCalculator(unsigned int numDim, unsigned int dimensions[], unsigned int partitions[], double offsets[], double sigma[]) : CLinearMultiFeatureCalculator(numDim, dimensions, partitions, offsets, 0)
{
this->sigma = new double[numDim];
memcpy(this->sigma, sigma, sizeof(double) * numDim);
sigmaMaxSize = 2.0;
initAreaSize();
addType(FEATURESTATEDERIVATIONX);
}
OSCMessage& OSCMessage::add(char * data) {
//first put in the type
addType('s');
//then the data
addToBuffer((uint8_t *) data, strlen(data));
//pad the string;
addPadToBuffer(padSize(strlen(data)));
return *this;
}
Weapon::Weapon(RenderLayers layer, const float damage, const sf::Texture &texture,
const std::vector<sf::IntRect> frameRects, bool centerOrigin,
float totalTime, bool repeat)
: Item(layer, texture, frameRects, centerOrigin, totalTime, repeat)
, m_damage{ damage }
, m_damageMultiplicator{ 1.f }
{
addType(WorldObjectTypes::WEAPON);
}
static std::shared_ptr<SymbolTable> getPredefinedTable()
{
auto table = std::make_shared<SymbolTable>(nullptr, cs6300::GLOBAL);
table->addType(std::string("integer"), BuiltInType::getInt());
table->addType(std::string("INTEGER"), BuiltInType::getInt());
table->addType(std::string("boolean"), BuiltInType::getBool());
table->addType(std::string("BOOLEAN"), BuiltInType::getBool());
table->addType(std::string("char"), BuiltInType::getChar());
table->addType(std::string("CHAR"), BuiltInType::getChar());
table->addType(std::string("string"), BuiltInType::getStr());
table->addType(std::string("STRING"), BuiltInType::getStr());
table->addConstant("true", std::make_shared<LiteralExpression>(true));
table->addConstant("TRUE", std::make_shared<LiteralExpression>(true));
table->addConstant("false", std::make_shared<LiteralExpression>(false));
table->addConstant("FALSE", std::make_shared<LiteralExpression>(false));
return table;
}
bool KnownPluginList::scanAndAddFile (const String& fileOrIdentifier,
const bool dontRescanIfAlreadyInList,
OwnedArray<PluginDescription>& typesFound,
AudioPluginFormat& format)
{
const ScopedLock sl (scanLock);
if (dontRescanIfAlreadyInList
&& getTypeForFile (fileOrIdentifier) != nullptr)
{
bool needsRescanning = false;
ScopedLock lock (typesArrayLock);
for (auto* d : types)
{
if (d->fileOrIdentifier == fileOrIdentifier && d->pluginFormatName == format.getName())
{
if (format.pluginNeedsRescanning (*d))
needsRescanning = true;
else
typesFound.add (new PluginDescription (*d));
}
}
if (! needsRescanning)
return false;
}
if (blacklist.contains (fileOrIdentifier))
return false;
OwnedArray<PluginDescription> found;
{
const ScopedUnlock sl2 (scanLock);
if (scanner != nullptr)
{
if (! scanner->findPluginTypesFor (format, found, fileOrIdentifier))
addToBlacklist (fileOrIdentifier);
}
else
{
format.findAllTypesForFile (found, fileOrIdentifier);
}
}
for (auto* desc : found)
{
jassert (desc != nullptr);
addType (*desc);
typesFound.add (new PluginDescription (*desc));
}
return ! found.isEmpty();
}
void CGeorgesNewDialog::getTypes( /* std::string& dir // not needed anymore? */ )
{
//nlinfo ("Found %d files in directory '%s'", files.size(), dir.c_str());
for(uint i = 0; i < _files.size(); i++)
{
addType(NLMISC::CFile::getFilename(_files[i]));
QApplication::processEvents();
}
}
Quad::Quad() : RenderObject()
{
addType(SCO_QUAD);
borderAlpha = 0.5;
//debugLog("Quad::Quad()");
initQuad();
//debugLog("End Quad::Quad()");
//textureSize = Vector(1,1);
}
Weapon::Weapon(RenderLayers layer, const float damage,
const std::string &textureId,
const ResourceHolder<sf::Texture> &textureHolder)
: Item(layer, textureId, textureHolder)
, m_damage{ damage }
, m_damageMultiplicator{ 1.f }
{
addType(WorldObjectTypes::WEAPON);
}
