/// <summary>
/// Return the qualifier set associated with its type
/// </summary>
private IWbemQualifierSetFreeThreaded GetTypeQualifierSet(QualifierType qualifierSetType)
{
IWbemQualifierSetFreeThreaded qualifierSet = null;
int status = qualifierSetType switch
{
QualifierType.ObjectQualifier => parent.wbemObject.GetQualifierSet_(out qualifierSet),
QualifierType.PropertyQualifier => parent.wbemObject.GetPropertyQualifierSet_(propertyOrMethodName, out qualifierSet),
QualifierType.MethodQualifier => parent.wbemObject.GetMethodQualifierSet_(propertyOrMethodName, out qualifierSet),
_ => throw new ManagementException(ManagementStatus.Unexpected, null, null), // Is this the best fit error ??
};
if (status < 0)
{
if ((status & 0xfffff000) == 0x80041000)
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus)status);
}
else
{
Marshal.ThrowExceptionForHR(status, WmiNetUtilsHelper.GetErrorInfo_f());
}
}
return(qualifierSet);
}
public override IEffectDescription Generate()
{
DrawEffectDescription desc = new DrawEffectDescription();
desc.drawModifier = ProceduralUtils.GetRandomValue <DrawModifier>(random, model);
// Find the bounds of card amounts
int max = ProceduralUtils.GetUpperBound(desc, ref desc.amount, MIN_CARDS, MAX_CARDS, maxAllocatedBudget);
int min = ProceduralUtils.GetLowerBound(desc, ref desc.amount, MIN_CARDS, max, minAllocatedBudget);
Assert.IsTrue(max >= min);
desc.amount = random.Next(min, max);
// Attempt to narrow down the qualifier pool
SortedSet <QualifierType> allowableQualifiers = CardEnums.GetValidFlags <QualifierType>(EffectType.DRAW_CARDS);
QualifierType qualifier = ProceduralUtils.GetRandomValue(random, model, allowableQualifiers);
if (qualifier != QualifierType.NONE)
{
IProceduralQualifierGenerator qualifierGen = ProceduralUtils.GetProceduralGenerator(qualifier);
qualifierGen.SetupParameters(random, model, minAllocatedBudget / desc.PowerLevel(), maxAllocatedBudget / desc.PowerLevel());
desc.cardQualifier = qualifierGen.Generate();
}
return(desc);
}
private IWbemQualifierSetFreeThreaded GetTypeQualifierSet(QualifierType qualifierSetType)
{
IWbemQualifierSetFreeThreaded ppQualSet = null;
int errorCode = 0;
switch (qualifierSetType)
{
case QualifierType.ObjectQualifier:
errorCode = this.parent.wbemObject.GetQualifierSet_(out ppQualSet);
break;
case QualifierType.PropertyQualifier:
errorCode = this.parent.wbemObject.GetPropertyQualifierSet_(this.propertyOrMethodName, out ppQualSet);
break;
case QualifierType.MethodQualifier:
errorCode = this.parent.wbemObject.GetMethodQualifierSet_(this.propertyOrMethodName, out ppQualSet);
break;
default:
throw new ManagementException(ManagementStatus.Unexpected, null, null);
}
if (errorCode < 0)
{
if ((errorCode & 0xfffff000L) == 0x80041000L)
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus)errorCode);
return(ppQualSet);
}
Marshal.ThrowExceptionForHR(errorCode);
}
return(ppQualSet);
}
/// <summary>
/// Return the qualifier set associated with its type
/// </summary>
private IWbemQualifierSetFreeThreaded GetTypeQualifierSet(QualifierType qualifierSetType)
{
IWbemQualifierSetFreeThreaded qualifierSet = null;
int status = (int)ManagementStatus.NoError;
switch (qualifierSetType)
{
case QualifierType.ObjectQualifier :
status = parent.wbemObject.GetQualifierSet_(out qualifierSet);
break;
case QualifierType.PropertyQualifier :
status = parent.wbemObject.GetPropertyQualifierSet_(propertyOrMethodName, out qualifierSet);
break;
case QualifierType.MethodQualifier :
status = parent.wbemObject.GetMethodQualifierSet_(propertyOrMethodName, out qualifierSet);
break;
default :
throw new ManagementException(ManagementStatus.Unexpected, null, null); // Is this the best fit error ??
}
if (status < 0)
{
if ((status & 0xfffff000) == 0x80041000)
ManagementException.ThrowWithExtendedInfo((ManagementStatus)status);
else
Marshal.ThrowExceptionForHR(status);
}
return qualifierSet;
}
public static IQualifier GetQualifier(INHElement @this, QualifierType qualifierType)
{
if (qualifierType == QualifierType.Type)
return GetNameReferenceName(@this);
return null;
}
private IWbemQualifierSetFreeThreaded GetTypeQualifierSet(QualifierType qualifierSetType)
{
IWbemQualifierSetFreeThreaded wbemQualifierSetFreeThreaded = null;
int qualifierSet_ = 0;
QualifierType qualifierType = qualifierSetType;
if (qualifierType == QualifierType.ObjectQualifier)
{
qualifierSet_ = this.parent.wbemObject.GetQualifierSet_(out wbemQualifierSetFreeThreaded);
}
else if (qualifierType == QualifierType.PropertyQualifier)
{
qualifierSet_ = this.parent.wbemObject.GetPropertyQualifierSet_(this.propertyOrMethodName, out wbemQualifierSetFreeThreaded);
}
else if (qualifierType == QualifierType.MethodQualifier)
{
qualifierSet_ = this.parent.wbemObject.GetMethodQualifierSet_(this.propertyOrMethodName, out wbemQualifierSetFreeThreaded);
}
else
{
throw new ManagementException(ManagementStatus.Unexpected, null, null);
}
if (qualifierSet_ < 0)
{
if (((long)qualifierSet_ & (long)-4096) != (long)-2147217408)
{
Marshal.ThrowExceptionForHR(qualifierSet_);
}
else
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus)qualifierSet_);
}
}
return(wbemQualifierSetFreeThreaded);
}
internal QualifierData(ManagementBaseObject parent, string propName, string qualName, QualifierType type)
{
this.parent = parent;
this.propertyOrMethodName = propName;
this.qualifierName = qualName;
this.qualifierType = type;
RefreshQualifierInfo();
}
internal Qualifier(ushort index, QualifierType type, ushort priority, float fallbackScore, string value)
{
Index = index;
Type = type;
Priority = priority;
FallbackScore = fallbackScore;
Value = value;
}
internal QualifierData(ManagementBaseObject parent, string propName, string qualName, QualifierType type)
{
this.parent = parent;
this.propertyOrMethodName = propName;
this.qualifierName = qualName;
this.qualifierType = type;
RefreshQualifierInfo();
}
public Parameter(QualifierType qualifier, VariableType type, string name, string description, List <string> values)
{
Qualifier = qualifier;
Type = type;
Name = name;
Description = description;
Values = values;
}
static public IProceduralQualifierGenerator GetProceduralGenerator(QualifierType type)
{
if (proceduralQualifierGenerators.ContainsKey(type))
{
return(proceduralQualifierGenerators[type]);
}
Assert.IsTrue(false);
return(null);
}
//Internal constructor
internal QualifierDataEnumerator(ManagementBaseObject parent, string propertyOrMethodName,
QualifierType qualifierType)
{
this.parent = parent;
this.propertyOrMethodName = propertyOrMethodName;
this.qualifierType = qualifierType;
this.qualifierNames = null;
IWbemQualifierSetFreeThreaded qualifierSet = null;
int status = (int)ManagementStatus.NoError;
switch (qualifierType)
{
case QualifierType.ObjectQualifier:
status = parent.wbemObject.GetQualifierSet_(out qualifierSet);
break;
case QualifierType.PropertyQualifier:
status = parent.wbemObject.GetPropertyQualifierSet_(propertyOrMethodName, out qualifierSet);
break;
case QualifierType.MethodQualifier:
status = parent.wbemObject.GetMethodQualifierSet_(propertyOrMethodName, out qualifierSet);
break;
default:
throw new ManagementException(ManagementStatus.Unexpected, null, null); // Is this the best fit error ??
}
// If we got an error code back, assume there are NO qualifiers for this object/property/method
if (status < 0)
{
//
qualifierNames = new String[] {};
}
else
{
status = qualifierSet.GetNames_(0, out qualifierNames);
if (status < 0)
{
if ((status & 0xfffff000) == 0x80041000)
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus)status);
}
else
{
Marshal.ThrowExceptionForHR(status, WmiNetUtilsHelper.GetErrorInfo_f());
}
}
}
}
//Internal constructor
internal QualifierDataEnumerator(ManagementBaseObject parent, string propertyOrMethodName,
QualifierType qualifierType)
{
this.parent = parent;
this.propertyOrMethodName = propertyOrMethodName;
this.qualifierType = qualifierType;
this.qualifierNames = null;
IWbemQualifierSetFreeThreaded qualifierSet = null;
int status = (int)ManagementStatus.NoError;
switch (qualifierType)
{
case QualifierType.ObjectQualifier:
status = parent.wbemObject.GetQualifierSet_(out qualifierSet);
break;
case QualifierType.PropertyQualifier:
status = parent.wbemObject.GetPropertyQualifierSet_(propertyOrMethodName, out qualifierSet);
break;
case QualifierType.MethodQualifier:
status = parent.wbemObject.GetMethodQualifierSet_(propertyOrMethodName, out qualifierSet);
break;
default:
throw new ManagementException(ManagementStatus.Unexpected, null, null); // Is this the best fit error ??
}
// If we got an error code back, assume there are NO qualifiers for this object/property/method
if (status < 0)
{
// TODO: Should we look at specific error codes. For example, if you ask
// for the qualifier set on a system property, GetPropertyQualifierSet() returns
// WBEM_E_SYSTEM_PROPERTY.
qualifierNames = new String[] {};
}
else
{
status = qualifierSet.GetNames_(0, out qualifierNames);
if (status < 0)
{
if ((status & 0xfffff000) == 0x80041000)
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus)status);
}
else
{
Marshal.ThrowExceptionForHR(status);
}
}
}
}
public static IQualifier GetQualifier(INHElement @this, QualifierType qualifierType)
{
if (qualifierType == QualifierType.Type)
return (IQualifier)@this;
if(qualifierType == QualifierType.Table)
{
var table = GetNameReferenceTable(@this);
return table;
}
throw new NotImplementedException();
}
public static ConsiderationsQualifier GetQualifier(QualifierType type)
{
switch (type)
{
case QualifierType.Product:
return(new ProductQualifier());
case QualifierType.Average:
return(new AverageQualifier());
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
internal QualifierDataEnumerator(ManagementBaseObject parent, string propertyOrMethodName, QualifierType qualifierType)
{
this.index = -1;
this.parent = parent;
this.propertyOrMethodName = propertyOrMethodName;
this.qualifierType = qualifierType;
this.qualifierNames = null;
IWbemQualifierSetFreeThreaded wbemQualifierSetFreeThreaded = null;
int qualifierSet_ = 0;
QualifierType qualifierType1 = qualifierType;
if (qualifierType1 == QualifierType.ObjectQualifier)
{
qualifierSet_ = parent.wbemObject.GetQualifierSet_(out wbemQualifierSetFreeThreaded);
}
else if (qualifierType1 == QualifierType.PropertyQualifier)
{
qualifierSet_ = parent.wbemObject.GetPropertyQualifierSet_(propertyOrMethodName, out wbemQualifierSetFreeThreaded);
}
else if (qualifierType1 == QualifierType.MethodQualifier)
{
qualifierSet_ = parent.wbemObject.GetMethodQualifierSet_(propertyOrMethodName, out wbemQualifierSetFreeThreaded);
}
else
{
throw new ManagementException(ManagementStatus.Unexpected, null, null);
}
if (qualifierSet_ >= 0)
{
qualifierSet_ = wbemQualifierSetFreeThreaded.GetNames_(0, out this.qualifierNames);
if (qualifierSet_ < 0)
{
if (((long)qualifierSet_ & (long)-4096) != (long)-2147217408)
{
Marshal.ThrowExceptionForHR(qualifierSet_);
}
else
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus)qualifierSet_);
return;
}
}
return;
}
else
{
this.qualifierNames = new string[0];
return;
}
}
internal QualifierDataEnumerator(ManagementBaseObject parent, string propertyOrMethodName, QualifierType qualifierType)
{
this.parent = parent;
this.propertyOrMethodName = propertyOrMethodName;
this.qualifierType = qualifierType;
this.qualifierNames = null;
IWbemQualifierSetFreeThreaded ppQualSet = null;
int errorCode = 0;
switch (qualifierType)
{
case QualifierType.ObjectQualifier:
errorCode = parent.wbemObject.GetQualifierSet_(out ppQualSet);
break;
case QualifierType.PropertyQualifier:
errorCode = parent.wbemObject.GetPropertyQualifierSet_(propertyOrMethodName, out ppQualSet);
break;
case QualifierType.MethodQualifier:
errorCode = parent.wbemObject.GetMethodQualifierSet_(propertyOrMethodName, out ppQualSet);
break;
default:
throw new ManagementException(ManagementStatus.Unexpected, null, null);
}
if (errorCode < 0)
{
this.qualifierNames = new string[0];
}
else
{
errorCode = ppQualSet.GetNames_(0, out this.qualifierNames);
if (errorCode < 0)
{
if ((errorCode & 0xfffff000L) == 0x80041000L)
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus)errorCode);
}
else
{
Marshal.ThrowExceptionForHR(errorCode);
}
}
}
}
private void RefreshQualifierInfo()
{
int qualifierSet_ = -2147217407;
this.qualifierSet = null;
QualifierType qualifierType = this.qualifierType;
if (qualifierType == QualifierType.ObjectQualifier)
{
qualifierSet_ = this.parent.wbemObject.GetQualifierSet_(out this.qualifierSet);
}
else if (qualifierType == QualifierType.PropertyQualifier)
{
qualifierSet_ = this.parent.wbemObject.GetPropertyQualifierSet_(this.propertyOrMethodName, out this.qualifierSet);
}
else if (qualifierType == QualifierType.MethodQualifier)
{
qualifierSet_ = this.parent.wbemObject.GetMethodQualifierSet_(this.propertyOrMethodName, out this.qualifierSet);
}
else
{
throw new ManagementException(ManagementStatus.Unexpected, null, null);
}
if (((long)qualifierSet_ & (long)-2147483648) == (long)0)
{
this.qualifierValue = null;
if (this.qualifierSet != null)
{
qualifierSet_ = this.qualifierSet.Get_(this.qualifierName, 0, ref this.qualifierValue, ref this.qualifierFlavor);
}
}
if (((long)qualifierSet_ & (long)-4096) != (long)-2147217408)
{
if (((long)qualifierSet_ & (long)-2147483648) != (long)0)
{
Marshal.ThrowExceptionForHR(qualifierSet_);
}
return;
}
else
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus)qualifierSet_);
return;
}
}
static private void RegisterProceduralGenerator(QualifierType type, IProceduralQualifierGenerator generator)
{
Assert.IsFalse(proceduralQualifierGenerators.ContainsKey(type));
Assert.AreEqual(type, generator.GetQualifierType());
proceduralQualifierGenerators[type] = generator;
double minCost = generator.GetMinCost();
int i;
for (i = 0; i < qualifierMinCosts.Count; i++)
{
if (minCost <= qualifierMinCosts[i].Item1)
{
break;
}
}
qualifierMinCosts.Insert(i, new Tuple <double, QualifierType>(minCost, type));
qualifiersByAlignment[generator.GetDescriptionType().GetAlignment()].Add(type);
}
/// <summary>
/// Return the qualifier set associated with its type
/// </summary>
private IWbemQualifierSetFreeThreaded GetTypeQualifierSet(QualifierType qualifierSetType)
{
IWbemQualifierSetFreeThreaded qualifierSet = null;
int status = (int)ManagementStatus.NoError;
switch (qualifierSetType)
{
case QualifierType.ObjectQualifier:
status = parent.wbemObject.GetQualifierSet_(out qualifierSet);
break;
case QualifierType.PropertyQualifier:
status = parent.wbemObject.GetPropertyQualifierSet_(propertyOrMethodName, out qualifierSet);
break;
case QualifierType.MethodQualifier:
status = parent.wbemObject.GetMethodQualifierSet_(propertyOrMethodName, out qualifierSet);
break;
default:
throw new ManagementException(ManagementStatus.Unexpected, null, null); // Is this the best fit error ??
}
if (status < 0)
{
if ((status & 0xfffff000) == 0x80041000)
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus)status);
}
else
{
Marshal.ThrowExceptionForHR(status);
}
}
return(qualifierSet);
}
/// <summary>
/// Method to generate a list of qualifiers in a ValuesDataSet
/// This is done as a separate method since Values can could contain other VariableValue Types
///
/// </summary>
/// <param name="ds">ValuesDataSet with the values used in the timeSeries</param>
/// <param name="valuesWhereClause"></param>
/// <returns></returns>
public static List<QualifierType> datasetQualifiers(ValuesDataSet ds, string valuesWhereClause)
{
/* generate a list
* create a distinct DataSet
* - new data view
* - set filter (no nulls)
* - use toTable with unique to get unique list
* foreach to generate qualifiers
* */
List<QualifierType> qualifiers = new List<QualifierType>();
try
{
DataView qview = new DataView(ds.DataValues);
qview.RowFilter = valuesWhereClause;
DataTable qids = qview.ToTable("Qualifiers", true, new string[] {"QualifierID"});
foreach (DataRow q in qids.Rows)
{
try
{
if (q["QualifierID"]==DBNull.Value)
{
continue;
}
int? qid = Convert.ToInt32(q["QualifierID"]);
ValuesDataSet.QualifiersRow qual = ds.Qualifiers.FindByQualifierID((int) qid.Value);
if (qual != null)
{
QualifierType qt = new QualifierType();
qt.qualifierID = qual.QualifierID;
if (!qual.IsQualifierCodeNull())
{
qt.qualifierCode = qual.QualifierCode;
} else
{
qt.qualifierCode = qual.QualifierID.ToString();
}
if (!String.IsNullOrEmpty(qual.QualifierDescription))
qt.qualifierDescription = qual.QualifierDescription;
qualifiers.Add(qt);
}
}
catch (Exception e)
{
log.Error("Error generating a qualifier " + q.ToString() + e.Message);
}
}
return qualifiers;
}
catch (Exception e)
{
log.Error("Error generating a qualifiers " + e.Message);
// non fatal exceptions
return null;
}
}
protected override bool ParseSectionContent(BinaryReader binaryReader)
{
ushort numDistinctQualifiers = binaryReader.ReadUInt16();
ushort numQualifiers = binaryReader.ReadUInt16();
ushort numQualifierSets = binaryReader.ReadUInt16();
ushort numDecisions = binaryReader.ReadUInt16();
ushort numIndexTableEntries = binaryReader.ReadUInt16();
ushort totalDataLength = binaryReader.ReadUInt16();
List <DecisionInfo> decisionInfos = new List <DecisionInfo>(numDecisions);
for (int i = 0; i < numDecisions; i++)
{
ushort firstQualifierSetIndexIndex = binaryReader.ReadUInt16();
ushort numQualifierSetsInDecision = binaryReader.ReadUInt16();
decisionInfos.Add(new DecisionInfo(firstQualifierSetIndexIndex, numQualifierSetsInDecision));
}
List <QualifierSetInfo> qualifierSetInfos = new List <QualifierSetInfo>(numQualifierSets);
for (int i = 0; i < numQualifierSets; i++)
{
ushort firstQualifierIndexIndex = binaryReader.ReadUInt16();
ushort numQualifiersInSet = binaryReader.ReadUInt16();
qualifierSetInfos.Add(new QualifierSetInfo(firstQualifierIndexIndex, numQualifiersInSet));
}
List <QualifierInfo> qualifierInfos = new List <QualifierInfo>(numQualifiers);
for (int i = 0; i < numQualifiers; i++)
{
ushort index = binaryReader.ReadUInt16();
ushort priority = binaryReader.ReadUInt16();
ushort fallbackScore = binaryReader.ReadUInt16();
binaryReader.ExpectUInt16(0);
qualifierInfos.Add(new QualifierInfo(index, priority, fallbackScore));
}
List <DistinctQualifierInfo> distinctQualifierInfos = new List <DistinctQualifierInfo>(numDistinctQualifiers);
for (int i = 0; i < numDistinctQualifiers; i++)
{
binaryReader.ReadUInt16();
QualifierType qualifierType = (QualifierType)binaryReader.ReadUInt16();
binaryReader.ReadUInt16();
binaryReader.ReadUInt16();
uint operandValueOffset = binaryReader.ReadUInt32();
distinctQualifierInfos.Add(new DistinctQualifierInfo(qualifierType, operandValueOffset));
}
ushort[] indexTable = new ushort[numIndexTableEntries];
for (int i = 0; i < numIndexTableEntries; i++)
{
indexTable[i] = binaryReader.ReadUInt16();
}
long dataStartOffset = binaryReader.BaseStream.Position;
List <Qualifier> qualifiers = new List <Qualifier>(numQualifiers);
for (int i = 0; i < numQualifiers; i++)
{
DistinctQualifierInfo distinctQualifierInfo = distinctQualifierInfos[qualifierInfos[i].Index];
binaryReader.BaseStream.Seek(dataStartOffset + distinctQualifierInfo.OperandValueOffset * 2, SeekOrigin.Begin);
string value = binaryReader.ReadNullTerminatedString(Encoding.Unicode);
qualifiers.Add(new Qualifier(
(ushort)i,
distinctQualifierInfo.QualifierType,
qualifierInfos[i].Priority,
qualifierInfos[i].FallbackScore / 1000f,
value));
}
Qualifiers = qualifiers;
List <QualifierSet> qualifierSets = new List <QualifierSet>(numQualifierSets);
for (int i = 0; i < numQualifierSets; i++)
{
List <Qualifier> qualifiersInSet = new List <Qualifier>(qualifierSetInfos[i].NumQualifiersInSet);
for (int j = 0; j < qualifierSetInfos[i].NumQualifiersInSet; j++)
{
qualifiersInSet.Add(qualifiers[indexTable[qualifierSetInfos[i].FirstQualifierIndexIndex + j]]);
}
qualifierSets.Add(new QualifierSet((ushort)i, qualifiersInSet));
}
QualifierSets = qualifierSets;
List <Decision> decisions = new List <Decision>(numDecisions);
for (int i = 0; i < numDecisions; i++)
{
List <QualifierSet> qualifierSetsInDecision = new List <QualifierSet>(decisionInfos[i].NumQualifierSetsInDecision);
for (int j = 0; j < decisionInfos[i].NumQualifierSetsInDecision; j++)
{
qualifierSetsInDecision.Add(qualifierSets[indexTable[decisionInfos[i].FirstQualifierSetIndexIndex + j]]);
}
decisions.Add(new Decision((ushort)i, qualifierSetsInDecision));
}
Decisions = decisions;
return(true);
}
public static Boolean Generate(DataTable dTable, Boolean writeHeader, String columnDemiliter, String textQualifier, QualifierType qType, String outputFile, Boolean isAppend)
{
return(Generate(dTable.DefaultView, writeHeader, null, columnDemiliter, textQualifier, qType, outputFile, isAppend));
}
public IQualifier GetQualifier(QualifierType qualifierType)
{
return ClassLikeElementImplUtils.GetQualifier(this, qualifierType);
}
private static Boolean Generate(DataView dView, Boolean writeHeader, String[] Headers, String columnDemiliter, String textQualifier, QualifierType qType, String outputFile, Boolean isAppend)
{
Boolean result = false, hasHeader = false;
String headerOutput = "", cell = "", head = "";
Writer _w = null;
try
{
//Validating parameter
if (dView == null)
{
throw new Exception("No source data!");
}
if (File.Exists(outputFile) && !isAppend)
{
throw new Exception("Output file already exists!");
}
if (String.IsNullOrEmpty(columnDemiliter))
{
throw new Exception("Column Demiliter cannot be null or empty!");
}
if (columnDemiliter == textQualifier)
{
throw new Exception("Column Demiliter cannot same with Text Qualifier!");
}
//if (File.Exists(outputFile) && append)
// File.Delete(outputFile);
if (Headers != null)
{
if (dView.Table.Columns.Count != Headers.Length)
{
throw new Exception("Number of headers not match with source data!");
}
hasHeader = true;
}
Type[] columnsType = new Type[dView.Table.Columns.Count];
_w = new Writer(outputFile, Writer.LogType.Custome, isAppend);
#region Write Header
if (writeHeader)
{
headerOutput = "";
for (int h = 0; h < dView.Table.Columns.Count; h++)
{
if (hasHeader)
{
head = Headers[h];
}
else
{
head = dView.Table.Columns[h].ToString();
}
columnsType[h] = dView.Table.Columns[h].DataType;
if (qType == QualifierType.All)
{
headerOutput += textQualifier + head + textQualifier;
}
else if (qType == QualifierType.Auto)
{
if (columnsType[h] == typeof(String) || columnsType[h] == typeof(DateTime) || columnsType[h] == typeof(Char))
{
headerOutput += textQualifier + head + textQualifier;
}
else
{
headerOutput += head;
}
}
else
{
headerOutput += head;
}
headerOutput += columnDemiliter.ToString();
}
if (!String.IsNullOrEmpty(headerOutput))
{
headerOutput = headerOutput.Substring(0, headerOutput.Length - columnDemiliter.Length);
_w.WriteLine(headerOutput);
}
}
#endregion
#region Write Detail
for (int i = 0; i < dView.Count; i++)
{
cell = String.Empty;
for (int h = 0; h < dView.Table.Columns.Count; h++)
{
if (qType == QualifierType.All)
{
cell += textQualifier + dView[i][h].ToString() + textQualifier;
}
else if (qType == QualifierType.Auto)
{
if (columnsType[h] == typeof(String) || columnsType[h] == typeof(DateTime) || columnsType[h] == typeof(Char))
{
cell += textQualifier + dView[i][h].ToString() + textQualifier;
}
else
{
cell += dView[i][h].ToString();
}
}
else
{
cell += dView[i][h].ToString();
}
cell += columnDemiliter.ToString();
}
if (!String.IsNullOrEmpty(cell))
{
cell = cell.Substring(0, cell.Length - columnDemiliter.Length);
_w.WriteLine(cell);
}
}
#endregion
result = true;
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (_w != null)
{
_w.Close();
}
}
return(result);
}
internal QualifierDataCollection(ManagementBaseObject parent) : base()
{
this.parent = parent;
this.qualifierSetType = QualifierType.ObjectQualifier;
this.propertyOrMethodName = null;
}
public static Boolean Generate(DictionaryBase busineesObject, Object item, String[] Headers, String columnDemiliter, String textQualifier, QualifierType qType, String outputFile, Boolean isAppend)
{
return(Generate(busineesObject, item, true, Headers, columnDemiliter, textQualifier, qType, outputFile, isAppend));
}
private IWbemQualifierSetFreeThreaded GetTypeQualifierSet(QualifierType qualifierSetType)
{
IWbemQualifierSetFreeThreaded wbemQualifierSetFreeThreaded = null;
int qualifierSet_ = 0;
QualifierType qualifierType = qualifierSetType;
if (qualifierType == QualifierType.ObjectQualifier)
{
qualifierSet_ = this.parent.wbemObject.GetQualifierSet_(out wbemQualifierSetFreeThreaded);
}
else if (qualifierType == QualifierType.PropertyQualifier)
{
qualifierSet_ = this.parent.wbemObject.GetPropertyQualifierSet_(this.propertyOrMethodName, out wbemQualifierSetFreeThreaded);
}
else if (qualifierType == QualifierType.MethodQualifier)
{
qualifierSet_ = this.parent.wbemObject.GetMethodQualifierSet_(this.propertyOrMethodName, out wbemQualifierSetFreeThreaded);
}
else
{
throw new ManagementException(ManagementStatus.Unexpected, null, null);
}
if (qualifierSet_ < 0)
{
if (((long)qualifierSet_ & (long)-4096) != (long)-2147217408)
{
Marshal.ThrowExceptionForHR(qualifierSet_);
}
else
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus)qualifierSet_);
}
}
return wbemQualifierSetFreeThreaded;
}
public static Boolean Generate(DataView dView, Boolean writeHeader, String columnDemiliter, String textQualifier, QualifierType qType, String outputFile)
{
return(Generate(dView, writeHeader, null, columnDemiliter, textQualifier, qType, outputFile, false));
}
public static Boolean Generate(DataView dView, String[] Headers, String columnDemiliter, String textQualifier, QualifierType qType, String outputFile, Boolean isAppend)
{
return(Generate(dView, true, Headers, columnDemiliter, textQualifier, qType, outputFile, isAppend));
}
/// <summary>
/// Method to generate a list of qualifiers in a ValuesDataSet
/// This is done as a separate method since Values can could contain other VariableValue Types
///
/// </summary>
/// <param name="ds">ValuesDataSet with the values used in the timeSeries</param>
/// <param name="valuesWhereClause"></param>
/// <returns></returns>
public static List <QualifierType> datasetQualifiers(ValuesDataSet ds, string valuesWhereClause)
{
/* generate a list
* create a distinct DataSet
* - new data view
* - set filter (no nulls)
* - use toTable with unique to get unique list
* foreach to generate qualifiers
* */
List <QualifierType> qualifiers = new List <QualifierType>();
try
{
DataView qview = new DataView(ds.DataValues);
qview.RowFilter = valuesWhereClause;
DataTable qids = qview.ToTable("Qualifiers", true, new string[] { "QualifierID" });
foreach (DataRow q in qids.Rows)
{
try
{
if (q["QualifierID"] == DBNull.Value)
{
continue;
}
int?qid = Convert.ToInt32(q["QualifierID"]);
ValuesDataSet.QualifiersRow qual = ds.Qualifiers.FindByQualifierID((int)qid.Value);
if (qual != null)
{
QualifierType qt = new QualifierType();
qt.qualifierID = qual.QualifierID;
if (!qual.IsQualifierCodeNull())
{
qt.qualifierCode = qual.QualifierCode;
}
else
{
qt.qualifierCode = qual.QualifierID.ToString();
}
if (!String.IsNullOrEmpty(qual.QualifierDescription))
{
qt.qualifierDescription = qual.QualifierDescription;
}
qualifiers.Add(qt);
}
}
catch (Exception e)
{
log.Error("Error generating a qualifier " + q.ToString() + e.Message);
}
}
return(qualifiers);
}
catch (Exception e)
{
log.Error("Error generating a qualifiers " + e.Message);
// non fatal exceptions
return(null);
}
}
internal QualifierDataEnumerator(ManagementBaseObject parent, string propertyOrMethodName, QualifierType qualifierType)
{
this.parent = parent;
this.propertyOrMethodName = propertyOrMethodName;
this.qualifierType = qualifierType;
this.qualifierNames = null;
IWbemQualifierSetFreeThreaded ppQualSet = null;
int errorCode = 0;
switch (qualifierType)
{
case QualifierType.ObjectQualifier:
errorCode = parent.wbemObject.GetQualifierSet_(out ppQualSet);
break;
case QualifierType.PropertyQualifier:
errorCode = parent.wbemObject.GetPropertyQualifierSet_(propertyOrMethodName, out ppQualSet);
break;
case QualifierType.MethodQualifier:
errorCode = parent.wbemObject.GetMethodQualifierSet_(propertyOrMethodName, out ppQualSet);
break;
default:
throw new ManagementException(ManagementStatus.Unexpected, null, null);
}
if (errorCode < 0)
{
this.qualifierNames = new string[0];
}
else
{
errorCode = ppQualSet.GetNames_(0, out this.qualifierNames);
if (errorCode < 0)
{
if ((errorCode & 0xfffff000L) == 0x80041000L)
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus) errorCode);
}
else
{
Marshal.ThrowExceptionForHR(errorCode);
}
}
}
}
public static TsValuesSingleVariableType CreateTimeSeriesValuesElement(
//TimeSeriesResponseType result,
VariableParam vp,
string aURL,
Boolean provisional)
{
// add the URL to be requested to the result
//result.queryInfo.queryURL = aURL;
// download the iformation
String resultFile = GetHTTPFile(aURL, 10);
//result.timeSeries.values = new TsValuesSingleVariableType();
//result.TimeSeries.Values.valueUnits = units; // this needs to be done earlier
TsValuesSingleVariableType values = new TsValuesSingleVariableType();
DataTable aTable = NWISDelimitedTextParser.ParseFileIntoDT(resultFile);
// dwv add code to get the code, and use that to find the correct columns
int time = 2; // present location of time column
// String code = result.timeSeries.variable.variableCode[0].Value;
String code = vp.Code;
String stat = null;
try
{
stat = option2UsgsStatCode(vp);
}
catch (Exception ex)
{
log.Debug("option2UsgsStatCode() failed :" + ex.ToString());
stat = null;
}
int aValue;
int qualifier;
//if (result.timeSeries.variable.options != null)
//{
// stat = result.timeSeries.variable.options[0].Value;
//}
try
{
aValue = getVarColumn(aTable, code, stat);
qualifier = getVarQualifiersColumn(aTable, code, stat);
}
catch (WaterOneFlowException we)
{
/* even I'm confused here...
* parsing column names gives an error
*
* This is post data rereiveal, so
* if we do not find the correct column, then throw an error
* */
string mess = "BAD COLUMN HEADER FROM USGS URL: " + aURL;
// need to insert the URL in the exception
if (string.IsNullOrEmpty(stat))
{
log.Error("Bad Column varCode:" + code + " stat_cd:NULL " + mess, we);
throw new WaterOneFlowSourceException("Improper COLUMN HEADER FROM USGS URL: " + aURL, we);
//+"' variable '"+code+"' not found at site.");
}
else
{
log.Error("Bad Column varCode:" + code + " Stat_cd: " + stat + " " + mess, we);
throw new WaterOneFlowSourceException("Improper COLUMN HEADER FROM USGS URL: " + aURL, we);
//+ "' variable '"+code+"' statistic '"+stat +"' not found at site. Try not using the statistic", we);
}
}
List <ValueSingleVariable> tsTypeList = new List <ValueSingleVariable>();
TimeSeriesFromRDB(aTable, time, aValue, qualifier,
tsTypeList, provisional);
// values.count = tsTypeList.Count;
values.value = tsTypeList.ToArray();
if (provisional)
{
List <QualifierType> quals = new List <QualifierType>();
if (values.qualifier != null)
{
quals = new List <QualifierType>(values.qualifier);
}
// this code is take from the daily values remark code
// unit values just says provisional data in the header
QualifierType qual = new QualifierType();
qual.qualifierCode = "P";
qual.network = "USGS";
qual.vocabulary = "dv_rmk_cd";
qual.qualifierDescription = "Provisional data subject to revision.";
quals.Add(qual);
values.qualifier = quals.ToArray();
}
return(values);
}
public static Boolean Generate(DataTable dTable, String[] Headers, String columnDemiliter, String textQualifier, QualifierType qType, String outputFile)
{
return(Generate(dTable.DefaultView, true, Headers, columnDemiliter, textQualifier, qType, outputFile, false));
}
internal QualifierDataEnumerator(ManagementBaseObject parent, string propertyOrMethodName, QualifierType qualifierType)
{
this.index = -1;
this.parent = parent;
this.propertyOrMethodName = propertyOrMethodName;
this.qualifierType = qualifierType;
this.qualifierNames = null;
IWbemQualifierSetFreeThreaded wbemQualifierSetFreeThreaded = null;
int qualifierSet_ = 0;
QualifierType qualifierType1 = qualifierType;
if (qualifierType1 == QualifierType.ObjectQualifier)
{
qualifierSet_ = parent.wbemObject.GetQualifierSet_(out wbemQualifierSetFreeThreaded);
}
else if (qualifierType1 == QualifierType.PropertyQualifier)
{
qualifierSet_ = parent.wbemObject.GetPropertyQualifierSet_(propertyOrMethodName, out wbemQualifierSetFreeThreaded);
}
else if (qualifierType1 == QualifierType.MethodQualifier)
{
qualifierSet_ = parent.wbemObject.GetMethodQualifierSet_(propertyOrMethodName, out wbemQualifierSetFreeThreaded);
}
else
{
throw new ManagementException(ManagementStatus.Unexpected, null, null);
}
if (qualifierSet_ >= 0)
{
qualifierSet_ = wbemQualifierSetFreeThreaded.GetNames_(0, out this.qualifierNames);
if (qualifierSet_ < 0)
{
if (((long)qualifierSet_ & (long)-4096) != (long)-2147217408)
{
Marshal.ThrowExceptionForHR(qualifierSet_);
}
else
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus)qualifierSet_);
return;
}
}
return;
}
else
{
this.qualifierNames = new string[0];
return;
}
}
internal QualifierDataCollection(ManagementBaseObject parent)
{
this.parent = parent;
this.qualifierSetType = QualifierType.ObjectQualifier;
this.propertyOrMethodName = null;
}
public static Boolean Generate(DictionaryBase busineesObject, Object item, Boolean writeHeader, String columnDemiliter, String textQualifier, QualifierType qType, String outputFile)
{
return(Generate(busineesObject, item, writeHeader, null, columnDemiliter, textQualifier, qType, outputFile, false));
}
internal QualifierDataCollection(ManagementBaseObject parent, string propertyOrMethodName, QualifierType type)
{
this.parent = parent;
this.propertyOrMethodName = propertyOrMethodName;
this.qualifierSetType = type;
}
internal QualifierDataCollection(ManagementBaseObject parent, string propertyOrMethodName, QualifierType type) : base()
{
this.parent = parent;
this.propertyOrMethodName = propertyOrMethodName;
this.qualifierSetType = type;
}
public DistinctQualifierInfo(QualifierType qualifierType, uint operandValueOffset)
{
QualifierType = qualifierType;
OperandValueOffset = operandValueOffset;
}
static private bool GenerateCardEffect(System.Random random, IHistogram model, CreatureModelIndex creatureModels, CardEffectDescription effectDesc, EffectType effect, double minBudget, double maxBudget, bool positive)
{
IProceduralEffectGenerator effectGen = ProceduralUtils.GetProceduralGenerator(effect);
effectGen.SetupParameters(random, model, creatureModels, minBudget, maxBudget);
effectDesc.effectType = effectGen.Generate();
// Adjust budgets
minBudget /= effectDesc.effectType.PowerLevel();
maxBudget /= effectDesc.effectType.PowerLevel();
if (minBudget > maxBudget)
{
double temp = minBudget;
minBudget = maxBudget;
maxBudget = temp;
}
// Always allow for default targetting (multiplier 1.0x)
if (maxBudget < 1.0)
{
maxBudget = 1.0;
}
TargetType targetType = TargetType.CREATURES;
SortedSet <TargetType> validTargets = CardEnums.GetValidFlags <TargetType>(effect);
SortedSet <TargettingType> allowableTargetting = new SortedSet <TargettingType>();
SortedSet <QualifierType> allowableQualifiers = new SortedSet <QualifierType>();
while (validTargets.Count > 0 && allowableTargetting.Count == 0)
{
targetType = ProceduralUtils.GetRandomValue(random, model, validTargets);
validTargets.Remove(targetType);
switch (effectDesc.effectType.GetAlignment())
{
case Alignment.POSITIVE:
if (positive)
{
allowableTargetting = ProceduralUtils.GetTargettingByAlignment(Alignment.POSITIVE);
allowableQualifiers = ProceduralUtils.GetQualifiersByAlignment(Alignment.NEUTRAL);
allowableQualifiers.UnionWith(ProceduralUtils.GetQualifiersByAlignment(Alignment.POSITIVE));
allowableQualifiers.IntersectWith(CardEnums.GetValidFlags <QualifierType>(targetType));
if (allowableQualifiers.Count > 0)
{
allowableTargetting.UnionWith(ProceduralUtils.GetTargettingByAlignment(Alignment.NEUTRAL));
}
}
else
{
allowableTargetting = ProceduralUtils.GetTargettingByAlignment(Alignment.NEGATIVE);
allowableQualifiers = ProceduralUtils.GetQualifiersByAlignment(Alignment.NEGATIVE);
allowableQualifiers.IntersectWith(CardEnums.GetValidFlags <QualifierType>(targetType));
if (allowableQualifiers.Count > 0)
{
allowableTargetting.UnionWith(ProceduralUtils.GetTargettingByAlignment(Alignment.NEUTRAL));
}
}
break;
case Alignment.NEGATIVE:
if (positive)
{
allowableTargetting = ProceduralUtils.GetTargettingByAlignment(Alignment.NEGATIVE);
allowableQualifiers = ProceduralUtils.GetQualifiersByAlignment(Alignment.NEUTRAL);
allowableQualifiers.UnionWith(ProceduralUtils.GetQualifiersByAlignment(Alignment.NEGATIVE));
allowableQualifiers.IntersectWith(CardEnums.GetValidFlags <QualifierType>(targetType));
if (allowableQualifiers.Count > 0)
{
allowableTargetting.UnionWith(ProceduralUtils.GetTargettingByAlignment(Alignment.NEUTRAL));
}
}
else
{
allowableTargetting = ProceduralUtils.GetTargettingByAlignment(Alignment.POSITIVE);
allowableQualifiers = ProceduralUtils.GetQualifiersByAlignment(Alignment.POSITIVE);
allowableQualifiers.IntersectWith(CardEnums.GetValidFlags <QualifierType>(targetType));
if (allowableQualifiers.Count > 0)
{
allowableTargetting.UnionWith(ProceduralUtils.GetTargettingByAlignment(Alignment.NEUTRAL));
}
}
break;
default:
if (positive)
{
allowableTargetting = new SortedSet <TargettingType>((TargettingType[])Enum.GetValues(typeof(TargettingType)));
allowableQualifiers = new SortedSet <QualifierType>((QualifierType[])Enum.GetValues(typeof(QualifierType)));
allowableQualifiers.IntersectWith(CardEnums.GetValidFlags <QualifierType>(targetType));
}
else
{
allowableTargetting = new SortedSet <TargettingType>();
}
break;
}
allowableTargetting.IntersectWith(CardEnums.GetValidFlags <TargettingType>(targetType));
allowableTargetting.IntersectWith(CardEnums.GetValidFlags <TargettingType>(effectDesc.triggerCondition));
// Special case
// Up to can never be a downside because you can choose 0 targets
if (!positive)
{
allowableTargetting.Remove(TargettingType.UP_TO_TARGET);
allowableTargetting.Remove(TargettingType.UP_TO_TARGET_ALLY);
allowableTargetting.Remove(TargettingType.UP_TO_TARGET_ENEMY);
}
}
// Could not find any valid targetting to achieve the desired alignment
if (allowableTargetting.Count == 0)
{
SortedSet <TargetType> targets = CardEnums.GetValidFlags <TargetType>(effect);
Debug.Log("Wasn't able to generate targets for effect <" + effect.ToString() + ">");
return(false);
}
// Attempt to narrow down the targetting pool
SortedSet <TargettingType> targettingWithinBudget = new SortedSet <TargettingType>(allowableTargetting.Intersect(ProceduralUtils.GetTargettingWithinBudget(maxBudget)));
if (targettingWithinBudget.Count > 0)
{
allowableTargetting = targettingWithinBudget;
}
else
{
Debug.Log("Unable to narrow down targetting types for <" + effect.ToString() + ", " + targetType.ToString() + "> for budget " + maxBudget);
}
TargettingType targettingType = ProceduralUtils.GetRandomValue(random, model, allowableTargetting);
IProceduralTargettingGenerator targettingGen = ProceduralUtils.GetProceduralGenerator(targettingType);
targettingGen.SetupParameters(targetType, random, model, minBudget, maxBudget);
effectDesc.targettingType = targettingGen.Generate();
// Adjust budgets
minBudget /= effectDesc.targettingType.PowerLevel();
maxBudget /= effectDesc.targettingType.PowerLevel();
if (minBudget > maxBudget)
{
double temp = minBudget;
minBudget = maxBudget;
maxBudget = temp;
}
if (effectDesc.targettingType is IQualifiableTargettingDescription qualifiable)
{
// Generate a possible qualifier
// Attempt to narrow down the qualifier pool
SortedSet <QualifierType> qualifiersWithinBudget = new SortedSet <QualifierType>(allowableQualifiers.Intersect(ProceduralUtils.GetQualifiersWithinBudget(maxBudget)));
if (targettingWithinBudget.Count > 0)
{
allowableQualifiers = qualifiersWithinBudget;
}
else
{
Debug.Log("Unable to narrow down qualifier types for <" + effect.ToString() + ", " + targetType.ToString() + "> for budget " + maxBudget);
}
QualifierType qualifier = ProceduralUtils.GetRandomValue(random, model, allowableQualifiers);
if (qualifier != QualifierType.NONE)
{
IProceduralQualifierGenerator qualifierGen = ProceduralUtils.GetProceduralGenerator(qualifier);
qualifierGen.SetupParameters(random, model, minBudget, maxBudget);
qualifiable.qualifier = qualifierGen.Generate();
}
}
return(true);
}
public IQualifier GetQualifier(QualifierType qualifierType)
{
return CompositeElementLikeImplUtils.GetQualifier(this, QualifierType.Type);
}
//Internal constructor
internal QualifierDataEnumerator(ManagementBaseObject parent, string propertyOrMethodName,
QualifierType qualifierType)
{
this.parent = parent;
this.propertyOrMethodName = propertyOrMethodName;
this.qualifierType = qualifierType;
this.qualifierNames = null;
IWbemQualifierSetFreeThreaded qualifierSet = null;
int status = (int)ManagementStatus.NoError;
switch (qualifierType)
{
case QualifierType.ObjectQualifier :
status = parent.wbemObject.GetQualifierSet_(out qualifierSet);
break;
case QualifierType.PropertyQualifier :
status = parent.wbemObject.GetPropertyQualifierSet_(propertyOrMethodName, out qualifierSet);
break;
case QualifierType.MethodQualifier :
status = parent.wbemObject.GetMethodQualifierSet_(propertyOrMethodName, out qualifierSet);
break;
default :
throw new ManagementException(ManagementStatus.Unexpected, null, null); // Is this the best fit error ??
}
// If we got an error code back, assume there are NO qualifiers for this object/property/method
if(status < 0)
{
//
qualifierNames = new String[]{};
}
else
{
status = qualifierSet.GetNames_(0, out qualifierNames);
if (status < 0)
{
if ((status & 0xfffff000) == 0x80041000)
ManagementException.ThrowWithExtendedInfo((ManagementStatus)status);
else
Marshal.ThrowExceptionForHR(status);
}
}
}
private IWbemQualifierSetFreeThreaded GetTypeQualifierSet(QualifierType qualifierSetType)
{
IWbemQualifierSetFreeThreaded ppQualSet = null;
int errorCode = 0;
switch (qualifierSetType)
{
case QualifierType.ObjectQualifier:
errorCode = this.parent.wbemObject.GetQualifierSet_(out ppQualSet);
break;
case QualifierType.PropertyQualifier:
errorCode = this.parent.wbemObject.GetPropertyQualifierSet_(this.propertyOrMethodName, out ppQualSet);
break;
case QualifierType.MethodQualifier:
errorCode = this.parent.wbemObject.GetMethodQualifierSet_(this.propertyOrMethodName, out ppQualSet);
break;
default:
throw new ManagementException(ManagementStatus.Unexpected, null, null);
}
if (errorCode < 0)
{
if ((errorCode & 0xfffff000L) == 0x80041000L)
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus) errorCode);
return ppQualSet;
}
Marshal.ThrowExceptionForHR(errorCode);
}
return ppQualSet;
}
