/// <summary> /// Creates a variable for the given spatial parameter variable and replaces it in parameter map. /// </summary> /// <param name="oldVar">Spatial parameter variable that needs to replaced.</param> /// <returns>A new ParameterVar instance created of <paramref name="oldVar"/>.</returns> /// <remarks> /// This method should be used only to replace external strong spatial parameter with a counterpart whose /// type is the appropriate union type for <paramref name="oldVar"/>. /// The operation invalidates the <paramref name="oldVar"/>. After the operation has completed /// the <paramref name="oldVar"/>) is invalidated internally and should no longer be used. /// </remarks> internal ParameterVar ReplaceStrongSpatialParameterVar(ParameterVar oldVar) { return ReplaceParameterVar(oldVar, t => TypeHelpers.CreateSpatialUnionTypeUsage(t)); }
/// <summary> /// Creates a variable for the given parameter variable and replaces it in parameter map. /// </summary> /// <param name="oldVar">Parameter variable that needs to replaced.</param> /// <param name="generateReplacementType">Delegate that generates the replacement parameter's type.</param> /// <returns>A new ParameterVar instance created of <paramref name="oldVar"/>.</returns> /// <remarks> /// This method should be used only to replace external enum or strong spatial parameters with a counterpart whose /// type is the underlying type of the enum type, or the union type contating the strong spatial type of the <paramref name="oldVar"/>. /// The operation invalidates the <paramref name="oldVar"/>. After the operation has completed /// the <paramref name="oldVar"/>) is invalidated internally and should no longer be used. /// </remarks>Func< private ParameterVar ReplaceParameterVar(ParameterVar oldVar, Func<TypeUsage, TypeUsage> generateReplacementType) { Debug.Assert(oldVar != null, "oldVar != null"); Debug.Assert(m_vars.Contains(oldVar)); ParameterVar v = new ParameterVar(NewVarId(), generateReplacementType(oldVar.Type), oldVar.ParameterName); m_parameterMap[oldVar.ParameterName] = v; m_vars.Add(v); return v; }
/// <summary> /// Creates a variable for the given enum parameter variable and replaces it in parameter map. /// </summary> /// <param name="oldVar">Enum parameter variable that needs to replaced.</param> /// <returns>A new ParameterVar instance created of <paramref name="oldVar"/>.</returns> /// <remarks> /// This method should be used only to replace external enum parameter with a counterpart whose /// type is the underlying type of the enum type of the <paramref name="oldVar"/>. /// The operation invalidates the <paramref name="oldVar"/>. After the operation has completed /// the <paramref name="oldVar"/>) is invalidated internally and should no longer be used. /// </remarks> internal ParameterVar ReplaceEnumParameterVar(ParameterVar oldVar) { return ReplaceParameterVar(oldVar, t => TypeHelpers.CreateEnumUnderlyingTypeUsage(t)); }
/// <summary> /// Creates a variable for a parameter in the query /// </summary> /// <param name="parameterName">The name of the parameter for which to create the var</param> /// <param name="parameterType">The type of the parameter, and therefore the new var</param> /// <returns>A new ParameterVar instance with the specified name and type</returns> internal ParameterVar CreateParameterVar(string parameterName, TypeUsage parameterType) { if (m_parameterMap.ContainsKey(parameterName)) throw new Exception("duplicate parameter name: " + parameterName); ParameterVar v = new ParameterVar(NewVarId(), parameterType, parameterName); m_vars.Add(v); m_parameterMap[parameterName] = v; return v; }