/// <summary>
/// Gets the parameter by name from an element from the parameter cache.
/// </summary>
/// <param name="elementId">The element id.</param>
/// <param name="propertyName">The property name.</param>
/// <returns>The Parameter.</returns>
static private Parameter getParameterByNameFromCache(ElementId elementId, string propertyName)
{
Parameter parameter = null;
string cleanPropertyName = NamingUtil.RemoveSpaces(propertyName);
if (m_IFCParameters[elementId].ParameterCache.TryGetValue(cleanPropertyName, out parameter))
{
return(parameter);
}
foreach (ParameterElementCache otherCache in m_NonIFCParameters[elementId].Values)
{
if (otherCache.ParameterCache.TryGetValue(cleanPropertyName, out parameter))
{
return(parameter);
}
}
return(parameter);
}
/// <summary>
/// Gets the parameter by name from an element from the parameter cache.
/// </summary>
/// <param name="elementId">The element id.</param>
/// <param name="group">The parameter group.</param>
/// <param name="propertyName">The property name.</param>
/// <returns>The Parameter.</returns>
static private Parameter getParameterByNameFromCache(ElementId elementId, BuiltInParameterGroup group,
string propertyName)
{
Parameter parameter = null;
string cleanPropertyName = NamingUtil.RemoveSpaces(propertyName);
if (group == BuiltInParameterGroup.PG_IFC)
{
m_IFCParameters[elementId].ParameterCache.TryGetValue(cleanPropertyName, out parameter);
return(null);
}
ParameterElementCache otherCache = null;
m_NonIFCParameters[elementId].TryGetValue(group, out otherCache);
if (otherCache != null)
{
otherCache.ParameterCache.TryGetValue(cleanPropertyName, out parameter);
}
return(parameter);
}
/// <summary>
/// Gets the parameter value by name from the subelement parameter value cache.
/// </summary>
/// <param name="elementId">The element id.</param>
/// <param name="handle">The subelement ifc handle.</param>
/// <param name="propertyName">The property name.</param>
/// <returns>The Parameter.</returns>
static public ParameterValue getParameterValueByNameFromSubelementCache(ElementId elementId, IFCAnyHandle subelementHandle, string propertyName)
{
ParameterValue parameterVal = null;
string cleanPropertyName = NamingUtil.RemoveSpaces(propertyName);
IDictionary <IFCAnyHandle, ParameterValueSubelementCache> anyHandleParamValMap;
if (!m_SubelementParameterValueCache.TryGetValue(elementId, out anyHandleParamValMap))
{
return(parameterVal);
}
ParameterValueSubelementCache paramValueCache;
if (!anyHandleParamValMap.TryGetValue(subelementHandle, out paramValueCache))
{
return(parameterVal);
}
paramValueCache.ParameterValueCache.TryGetValue(cleanPropertyName, out parameterVal);
return(parameterVal);
}
/// <summary>
/// Cache the parameters for an element's subelement (subelementHandle), allowing quick access later.
/// </summary>
/// <param name="elementId">The element id.</param>
/// <param name="subelementHandle">The subelement ifc handle.</param>
/// <param name="param">The element's parameter that we want to override.</param>
/// <param name="paramVal">The override value.</param>
static public void CacheParameterValuesForSubelementHandle(ElementId elementId, IFCAnyHandle subelementHandle, Parameter param, ParameterValue paramVal)
{
if ((elementId == ElementId.InvalidElementId) ||
(subelementHandle == null) ||
(param == null) ||
(paramVal == null))
{
return;
}
if (IsDuplicateParameter(param))
{
return;
}
Definition paramDefinition = param.Definition;
if (paramDefinition == null)
{
return;
}
// Don't cache parameters that aren't visible to the user.
InternalDefinition internalDefinition = paramDefinition as InternalDefinition;
if (internalDefinition != null && internalDefinition.Visible == false)
{
return;
}
if (string.IsNullOrWhiteSpace(paramDefinition.Name))
{
return;
}
string cleanPropertyName = NamingUtil.RemoveSpaces(paramDefinition.Name);
IDictionary <IFCAnyHandle, ParameterValueSubelementCache> anyHandleParamValMap;
if (!m_SubelementParameterValueCache.TryGetValue(elementId, out anyHandleParamValMap))
{
anyHandleParamValMap = new Dictionary <IFCAnyHandle, ParameterValueSubelementCache>();
m_SubelementParameterValueCache[elementId] = anyHandleParamValMap;
}
ParameterValueSubelementCache paramCache;
if (!anyHandleParamValMap.TryGetValue(subelementHandle, out paramCache))
{
paramCache = new ParameterValueSubelementCache();
anyHandleParamValMap[subelementHandle] = paramCache;
}
ParameterValue cachedParamVal;
if (paramCache.ParameterValueCache.TryGetValue(cleanPropertyName, out cachedParamVal))
{
return;
}
paramCache.ParameterValueCache[cleanPropertyName] = paramVal;
}
/// <summary>
/// Cache the parameters for an element, allowing quick access later.
/// </summary>
/// <param name="id">The element id.</param>
static private void CacheParametersForElement(ElementId id)
{
if (id == ElementId.InvalidElementId)
{
return;
}
if (m_NonIFCParameters.ContainsKey(id))
{
return;
}
IDictionary <BuiltInParameterGroup, ParameterElementCache> nonIFCParameters = new SortedDictionary <BuiltInParameterGroup, ParameterElementCache>();
ParameterElementCache ifcParameters = new ParameterElementCache();
m_NonIFCParameters[id] = nonIFCParameters;
m_IFCParameters[id] = ifcParameters;
Element element = ExporterCacheManager.Document.GetElement(id);
if (element == null)
{
return;
}
ParameterSet parameterIds = element.Parameters;
if (parameterIds.Size == 0)
{
return;
}
// We will do two passes. In the first pass, we will look at parameters in the IFC group.
// In the second pass, we will look at all other groups.
ParameterSetIterator parameterIt = parameterIds.ForwardIterator();
while (parameterIt.MoveNext())
{
Parameter parameter = parameterIt.Current as Parameter;
if (parameter == null)
{
continue;
}
if (IsDuplicateParameter(parameter))
{
continue;
}
Definition paramDefinition = parameter.Definition;
if (paramDefinition == null)
{
continue;
}
// Don't cache parameters that aren't visible to the user.
InternalDefinition internalDefinition = paramDefinition as InternalDefinition;
if (internalDefinition != null && internalDefinition.Visible == false)
{
continue;
}
if (string.IsNullOrWhiteSpace(paramDefinition.Name))
{
continue;
}
string cleanPropertyName = NamingUtil.RemoveSpaces(paramDefinition.Name);
BuiltInParameterGroup groupId = paramDefinition.ParameterGroup;
if (groupId != BuiltInParameterGroup.PG_IFC)
{
ParameterElementCache cacheForGroup = null;
if (!nonIFCParameters.TryGetValue(groupId, out cacheForGroup))
{
cacheForGroup = new ParameterElementCache();
nonIFCParameters[groupId] = cacheForGroup;
}
cacheForGroup.ParameterCache[cleanPropertyName] = parameter;
}
else
{
ifcParameters.ParameterCache[cleanPropertyName] = parameter;
}
}
}
/// <summary>
/// Cache the parameters for an element, allowing quick access later.
/// </summary>
/// <param name="id">The element id.</param>
static private void CacheParametersForElement(ElementId id)
{
if (id == ElementId.InvalidElementId)
{
return;
}
if (m_NonIFCParameters.ContainsKey(id))
{
return;
}
IDictionary <BuiltInParameterGroup, ParameterElementCache> nonIFCParameters = new SortedDictionary <BuiltInParameterGroup, ParameterElementCache>();
ParameterElementCache ifcParameters = new ParameterElementCache();
m_NonIFCParameters[id] = nonIFCParameters;
m_IFCParameters[id] = ifcParameters;
Element element = ExporterCacheManager.Document.GetElement(id);
if (element == null)
{
return;
}
ParameterSet parameterIds = element.Parameters;
if (parameterIds.Size == 0)
{
return;
}
// We will do two passes. In the first pass, we will look at parameters in the IFC group.
// In the second pass, we will look at all other groups.
ParameterSetIterator parameterIt = parameterIds.ForwardIterator();
while (parameterIt.MoveNext())
{
Parameter parameter = parameterIt.Current as Parameter;
if (parameter == null)
{
continue;
}
if (IsDuplicateParameter(parameter))
{
continue;
}
Definition paramDefinition = parameter.Definition;
if (paramDefinition == null)
{
continue;
}
// Don't cache parameters that aren't visible to the user.
InternalDefinition internalDefinition = paramDefinition as InternalDefinition;
if (internalDefinition != null && internalDefinition.Visible == false)
{
continue;
}
if (string.IsNullOrWhiteSpace(paramDefinition.Name))
{
continue;
}
string cleanPropertyName = NamingUtil.RemoveSpaces(paramDefinition.Name);
BuiltInParameterGroup groupId = paramDefinition.ParameterGroup;
ParameterElementCache cacheForGroup = null;
if (groupId != BuiltInParameterGroup.PG_IFC)
{
if (!nonIFCParameters.TryGetValue(groupId, out cacheForGroup))
{
cacheForGroup = new ParameterElementCache();
nonIFCParameters[groupId] = cacheForGroup;
}
}
else
{
cacheForGroup = ifcParameters;
}
if (cacheForGroup != null)
{
// We may have situations (due to bugs) where a parameter with the same name appears multiple times.
// In this case, we will preserve the first parameter with a value.
// Note that this can still cause inconsistent behavior in the case where multiple parameters with the same
// name have values, and we should warn about that when we start logging.
if (!cacheForGroup.ParameterCache.ContainsKey(cleanPropertyName) ||
!cacheForGroup.ParameterCache[cleanPropertyName].HasValue)
{
cacheForGroup.ParameterCache[cleanPropertyName] = parameter;
}
}
}
}
