internal static bool TableHeadDelegate(FieldDescriptor fieldDescriptor,
object obj,
ref EnumerationContext ctx)
{
if (fieldDescriptor != null) {
Console.Write(" {0}", fieldDescriptor.Name);
}
return true;
}
static internal bool ActiveFieldDelegate(FieldDescriptor fieldDescriptor,
object obj,
ref EnumerationContext ctx)
{
if (obj != null)
{
Console.Write(" {0}", obj.ToString());
}
return(true);
}
public System.Collections.Generic.IEnumerable <NativeCimClass> QueryClasses(NativeDestinationOptions options, string namespaceName, string queryDialect, string queryExpression)
{
var context = new EnumerationContext(CimNamespaces.CimNamespace, new Filter(queryDialect, new CimEnumerationFilter {
Namespace = namespaceName, Filter = queryExpression
}), new Selector[0]);
foreach (EndpointAddress address in _handler.Enumerate(context))
{
yield return(CimEnumerationHelper.CreateClass(address));
}
}
static internal bool fieldDelegate(FieldDescriptor fieldDescriptor,
object obj,
ref EnumerationContext context)
{
if ((fieldDescriptor != null) && (obj != null))
{
Console.WriteLine(" {0}:{1}:{2} = {3}",
fieldDescriptor.Offset,
fieldDescriptor.GetTypeName(),
fieldDescriptor.Name,
obj.ToString());
}
return(true);
}
static internal bool EntryDelegate(EventDescriptor currentEntry,
QueryBuffer buffer,
ref EnumerationContext context)
{
if (!DumpAll)
{
return(false);
}
if ((currentEntry != null) && (buffer != null))
{
currentEntry.EnumerateFields(new QueryFieldDelegate(fieldDelegate), buffer, ref context);
}
return(true);
}
public static void ListActiveSources()
{
Controller hostController = Controller.GetSystemController();
EnumerationContext ctx = new EnumerationContext();
if ((hostController == null) || (ctx == null)) {
return;
}
LoadEventTypes(hostController);
hostController.EnumerateActiveSources(
new QuerySourceDelegate(SourceDelegate),
new ActiveSourceEntryDelegate(ActiveEntryDelegate),
new QueryEntryDelegate(EntryDelegate),
0,
ref ctx);
}
internal static bool ActiveEntryDelegate(UIntPtr sourceHandle,
int index,
EventDescriptor descriptor,
QueryBuffer entryBuffer,
ref EnumerationContext context)
{
if (!DumpAll) {
return false;
}
if (descriptor != null) {
Console.Write("{0:d5}", index);
descriptor.EnumerateFields(new QueryFieldDelegate(ActiveFieldDelegate), entryBuffer, ref context);
Console.WriteLine("");
}
return true;
}
static internal bool SourceDelegate(UIntPtr sourceHandle,
UIntPtr storageHandle,
UIntPtr eventType,
UInt16 count,
string bufferName,
EventDescriptor descriptor,
ref EnumerationContext context)
{
if (SourceFilter != null)
{
if (!Regex.IsMatch(bufferName, SourceFilter))
{
return(true);
}
}
if (descriptor != null)
{
Console.WriteLine("Source: \"{0}\". {1} entries of type {2}",
bufferName, count, descriptor.GetName());
if (DumpAll)
{
Console.Write("Index");
descriptor.EnumerateFields(new QueryFieldDelegate(TableHeadDelegate), null, ref context);
Console.WriteLine("");
Console.Write("-----");
for (int i = 0; i < descriptor.GetFieldsCount(); i++)
{
Console.Write("----------");
}
Console.WriteLine("");
}
}
else
{
Console.WriteLine("Source: \"{0}\". Storage handle ={1}",
bufferName, sourceHandle);
}
return(true);
}
public XSComplexFinal(EnumerationContext owner, XmlSchemaDerivationMethod derivationMethod)
: base(owner) => _derivationMethod = derivationMethod;
public XSFormReference(EnumerationContext owner) : base(owner)
{
}
public CLREnumValueWrapper(EnumerationContext owner, T realValue) : base(owner)
{
_realValue = realValue;
}
public SymbolsEnumValue(EnumerationContext owner, string val)
: base(owner)
{
_val = val;
}
public bool MoveNext()
{
lock (this.client) {
if (resultIndex < results.Count)
{
this.current = results[resultIndex++];
return(true);
}
else
{
PullResponse response;
if (this.context == null)
{
if (resultIndex > 0)
{
// case: previous pull returned an invalid context
return(false);
}
EnumerationRequest request = new EnumerationRequest(filter);
if (attributes != null)
{
request.Selection = new List <string>();
request.Selection.AddRange(this.attributes);
}
response = client.Enumerate(request);
this.endOfSequence = response.EndOfSequence != null;
}
else
{
if (this.endOfSequence == true)
{
// case: previous pull returned an end of sequence flag
this.current = null;
return(false);
}
PullRequest request = new PullRequest();
request.EnumerationContext = this.context;
response = client.Pull(request);
}
if (response == null)
{
return(false);
}
resultIndex = 0;
this.results = resourceFactory.CreateResource(response);
this.context = response.EnumerationContext;
this.endOfSequence = response.IsEndOfSequence;
if (this.results.Count > 0)
{
this.current = results[resultIndex++];
return(true);
}
else
{
this.current = null;
return(false);
}
}
}
}
public void Dispose()
{
this.context = null;
this.results.Clear();
this.results = null;
}
public void Reset()
{
this.results.Clear();
this.context = null;
}
public CLREnumValueWrapper(EnumerationContext owner, T realValue, DataType newDataType) : base(owner)
{
_realValue = realValue;
_redefinedDataType = newDataType;
}
// Constructors
public RecordSet(EnumerationContext context, ExecutableProvider source)
{
Context = context;
Source = source;
}