internal void FromPivotCacheDefinition(PivotCacheDefinition pcd)
{
SetAllNull();
if (pcd.Id != null)
{
Id = pcd.Id.Value;
}
if (pcd.Invalid != null)
{
Invalid = pcd.Invalid.Value;
}
if (pcd.SaveData != null)
{
SaveData = pcd.SaveData.Value;
}
if (pcd.RefreshOnLoad != null)
{
RefreshOnLoad = pcd.RefreshOnLoad.Value;
}
if (pcd.OptimizeMemory != null)
{
OptimizeMemory = pcd.OptimizeMemory.Value;
}
if (pcd.EnableRefresh != null)
{
EnableRefresh = pcd.EnableRefresh.Value;
}
if (pcd.RefreshedBy != null)
{
RefreshedBy = pcd.RefreshedBy.Value;
}
if (pcd.RefreshedDate != null)
{
RefreshedDate = pcd.RefreshedDate.Value;
}
if (pcd.BackgroundQuery != null)
{
BackgroundQuery = pcd.BackgroundQuery.Value;
}
if (pcd.MissingItemsLimit != null)
{
MissingItemsLimit = pcd.MissingItemsLimit.Value;
}
if (pcd.CreatedVersion != null)
{
CreatedVersion = pcd.CreatedVersion.Value;
}
if (pcd.RefreshedVersion != null)
{
RefreshedVersion = pcd.RefreshedVersion.Value;
}
if (pcd.MinRefreshableVersion != null)
{
MinRefreshableVersion = pcd.MinRefreshableVersion.Value;
}
if (pcd.RecordCount != null)
{
RecordCount = pcd.RecordCount.Value;
}
if (pcd.UpgradeOnRefresh != null)
{
UpgradeOnRefresh = pcd.UpgradeOnRefresh.Value;
}
if (pcd.IsTupleCache != null)
{
IsTupleCache = pcd.IsTupleCache.Value;
}
if (pcd.SupportSubquery != null)
{
SupportSubquery = pcd.SupportSubquery.Value;
}
if (pcd.SupportAdvancedDrill != null)
{
SupportAdvancedDrill = pcd.SupportAdvancedDrill.Value;
}
if (pcd.CacheSource != null)
{
CacheSource.FromCacheSource(pcd.CacheSource);
}
// doing one by one because it's bloody hindering awkward complicated.
if (pcd.CacheFields != null)
{
SLCacheField cf;
using (var oxr = OpenXmlReader.Create(pcd.CacheFields))
{
while (oxr.Read())
{
if (oxr.ElementType == typeof(CacheField))
{
cf = new SLCacheField();
cf.FromCacheField((CacheField)oxr.LoadCurrentElement());
CacheFields.Add(cf);
}
}
}
}
if (pcd.CacheHierarchies != null)
{
SLCacheHierarchy ch;
using (var oxr = OpenXmlReader.Create(pcd.CacheHierarchies))
{
while (oxr.Read())
{
if (oxr.ElementType == typeof(CacheHierarchy))
{
ch = new SLCacheHierarchy();
ch.FromCacheHierarchy((CacheHierarchy)oxr.LoadCurrentElement());
CacheHierarchies.Add(ch);
}
}
}
}
if (pcd.Kpis != null)
{
SLKpi k;
using (var oxr = OpenXmlReader.Create(pcd.Kpis))
{
while (oxr.Read())
{
if (oxr.ElementType == typeof(Kpi))
{
k = new SLKpi();
k.FromKpi((Kpi)oxr.LoadCurrentElement());
Kpis.Add(k);
}
}
}
}
if (pcd.TupleCache != null)
{
TupleCache.FromTupleCache(pcd.TupleCache);
HasTupleCache = true;
}
if (pcd.CalculatedItems != null)
{
SLCalculatedItem ci;
using (var oxr = OpenXmlReader.Create(pcd.CalculatedItems))
{
while (oxr.Read())
{
if (oxr.ElementType == typeof(CalculatedItem))
{
ci = new SLCalculatedItem();
ci.FromCalculatedItem((CalculatedItem)oxr.LoadCurrentElement());
CalculatedItems.Add(ci);
}
}
}
}
if (pcd.CalculatedMembers != null)
{
SLCalculatedMember cm;
using (var oxr = OpenXmlReader.Create(pcd.CalculatedMembers))
{
while (oxr.Read())
{
if (oxr.ElementType == typeof(CalculatedMember))
{
cm = new SLCalculatedMember();
cm.FromCalculatedMember((CalculatedMember)oxr.LoadCurrentElement());
CalculatedMembers.Add(cm);
}
}
}
}
if (pcd.Dimensions != null)
{
SLDimension d;
using (var oxr = OpenXmlReader.Create(pcd.Dimensions))
{
while (oxr.Read())
{
if (oxr.ElementType == typeof(Dimension))
{
d = new SLDimension();
d.FromDimension((Dimension)oxr.LoadCurrentElement());
Dimensions.Add(d);
}
}
}
}
if (pcd.MeasureGroups != null)
{
SLMeasureGroup mg;
using (var oxr = OpenXmlReader.Create(pcd.MeasureGroups))
{
while (oxr.Read())
{
if (oxr.ElementType == typeof(MeasureGroup))
{
mg = new SLMeasureGroup();
mg.FromMeasureGroup((MeasureGroup)oxr.LoadCurrentElement());
MeasureGroups.Add(mg);
}
}
}
}
if (pcd.Maps != null)
{
SLMeasureDimensionMap mdm;
using (var oxr = OpenXmlReader.Create(pcd.Maps))
{
while (oxr.Read())
{
if (oxr.ElementType == typeof(MeasureDimensionMap))
{
mdm = new SLMeasureDimensionMap();
mdm.FromMeasureDimensionMap((MeasureDimensionMap)oxr.LoadCurrentElement());
Maps.Add(mdm);
}
}
}
}
}