/** Remove a constraint * @param parName :: The name of a parameter which constarint to remove. */ void CompositeFunction::removeConstraint(const std::string &parName) { auto i = parameterIndex(parName); auto constraint = IFunction::getConstraint(i); if (constraint != nullptr) { IFunction::removeConstraint(parName); } else { size_t iPar = parameterIndex(parName); size_t iFun = functionIndex(iPar); getFunction(iFun)->removeConstraint(parameterLocalName(iPar)); } }
/** Remove a constraint * @param parName :: The name of a parameter which constarint to remove. */ void ParamFunction::removeConstraint(const std::string &parName) { size_t iPar = parameterIndex(parName); for (auto it = m_constraints.begin(); it != m_constraints.end(); ++it) { if (iPar == (**it).getIndex()) { delete *it; m_constraints.erase(it); break; } } }
void Database::Statement::output(const Pair &pair) { String key; LineSerializer keySerializer(&key); pair.serializeKey(keySerializer); key.trim(); int parameter = parameterIndex(key); if(parameter != 0) { mOutputParameter = parameter; ++mOutputLevel; pair.serializeValue(*this); --mOutputLevel; } }
/** Removes the tie off a parameter. The parameter becomes active * This method can be used when constructing and editing the IFunction in a GUI * @param parName :: The name of the parameter which ties will be removed. */ void IFunction::removeTie(const std::string& parName) { size_t i = parameterIndex(parName); this->removeTie(i); }
bool CallCandidate::isMoreSpecific(const CallCandidate * other) const { bool same = true; if (paramAssignments_.size() != other->paramAssignments_.size()) { diag.info() << "different number of args."; return false; } // TODO: Factor in return type. /*if (!resultType()->isEqual(other->resultType())) { if (!resultType()->isSubtype(other->resultType())) { return false; } same = false; }*/ // Note - I think we want to compare candidates in their *unbound* state. // So other than type aliases, we don't want to dereference any types. size_t argCount = paramAssignments_.size(); for (size_t i = 0; i < argCount; ++i) { QualifiedType t0 = paramType(i); QualifiedType t1 = other->paramType(i); TypeRelation::RelativeSpecificity rspec = TypeRelation::isMoreSpecific(t0, t1); if (rspec == TypeRelation::NOT_MORE_SPECIFIC) { return false; } else if (rspec == TypeRelation::MORE_SPECIFIC) { same = false; } else { // Variadic parameters are less specific than non-variadic parameters. const ParameterDefn * p0 = fnType_->param(parameterIndex(i)); const ParameterDefn * p1 = other->fnType_->param(other->parameterIndex(i)); if (p0->isVariadic()) { if (!p1->isVariadic()) { return false; } } else if (p1->isVariadic()) { same = false; } } } if (same) { // If this method has fewer default params than the other, then it is more // specific. if (method_->params().size() < other->method()->params().size()) { return true; } // If one is a template, than it is less specific than the other. // TODO: If they are both templates, choose the one with the smaller number // of template parameters. Although explicitly bound parameters should not count, only // deduced parameters. if (!method_->isTemplate() && other->method()->isTemplate()) { return true; } if (method_->isTemplate() && !other->method()->isTemplate()) { return false; } if (typeParams_ == NULL && other->typeParams_ != NULL) { return true; } if (typeParams_ != NULL && other->typeParams_ != NULL) { } // TODO: This is a temporary kludge - should really compare the two template parameter // lists and see which one is more tightly bound. if (!method_->hasUnboundTypeParams() && other->method()->hasUnboundTypeParams()) { return true; } if (conditionCount_ > other->conditionCount_) { return true; } } // Return true if they are not the same. return !same; }
QualifiedType CallCandidate::paramType(int argIndex) const { return paramTypes_[parameterIndex(argIndex)]; }
/** Remove a constraint * @param parName :: The name of a parameter which constarint to remove. */ void CompositeFunction::removeConstraint(const std::string &parName) { size_t iPar = parameterIndex(parName); size_t iFun = functionIndex(iPar); getFunction(iFun)->removeConstraint(parameterLocalName(iPar)); }