private static void Compress(CreateStreamDelegate sc, Stream source, Stream dest)
{
using (DeflateStream zsDest = sc(dest, CompressionMode.Compress, true))
{
source.CopyTo(zsDest);
}
}
private static void DeCompress(CreateStreamDelegate sc, Stream source, Stream dest)
{
using (DeflateStream zsSource = sc(source, CompressionMode.Decompress, true))
{
zsSource.CopyTo(dest);
}
}
private static void Compress(CreateStreamDelegate sc, Stream source, Stream dest, ZLibCompLevel level)
{
using (DeflateStream zsDest = sc(dest, ZLibMode.Compress, level, true))
{
source.CopyTo(zsDest);
}
}
public static MemoryStream DeCompress(CreateStreamDelegate sc, Stream source)
{
MemoryStream result = new MemoryStream();
DeCompress(sc, source, result);
result.Position = 0;
return(result);
}
public static byte[] Decompress(CreateStreamDelegate sc, byte[] source)
{
using (MemoryStream srcStream = new MemoryStream(source))
using (MemoryStream dstStream = Decompress(sc, srcStream))
{
return(dstStream.ToArray());
}
}
public static byte[] Compress(CreateStreamDelegate sc, byte[] source, ZLibCompLevel level = ZLibCompLevel.Default)
{
using (MemoryStream srcStream = new MemoryStream(source))
using (MemoryStream dstStream = Compress(sc, srcStream, level))
{
return(dstStream.ToArray());
}
}
public static MemoryStream Compress(CreateStreamDelegate sc, Stream source, ZLibCompLevel level = ZLibCompLevel.Default)
{
MemoryStream result = new MemoryStream();
Compress(sc, source, result, level);
result.Position = 0;
return(result);
}
private static void Decompress(CreateStreamDelegate sc, Stream source, Stream dest)
{
// CompressionLevel.Default in CompressionMode.Decompress does not affect performance or efficiency
using (DeflateStream zsSource = sc(source, ZLibMode.Decompress, ZLibCompLevel.Default, true))
{
zsSource.CopyTo(dest);
}
}
public Stream StreamCallback(string name, string extension, Encoding encoding, string mimeType, bool useChunking, StreamOper operation)
{
int num;
switch (operation)
{
case StreamOper.RegisterOnly:
return(null);
case StreamOper.CreateAndRegister:
if (this.m_mainStream == null)
{
num = ((!this.m_mainStreamDetached) ? 1 : 0);
break;
}
goto default;
default:
num = 0;
break;
}
bool flag = (byte)num != 0;
CreateStreamDelegate createStreamDelegate = flag ? this.m_createMainStreamDelegate : new CreateStreamDelegate(StreamCache.DefaultCreateStreamDelegate);
CachedStream cachedStream = new CachedStream(createStreamDelegate(), encoding, mimeType, extension);
if (operation == StreamOper.CreateAndRegister)
{
if (flag)
{
this.m_mainStream = cachedStream;
}
else
{
this.m_secondaryStreams.Add(name, cachedStream);
}
}
return(cachedStream.Stream);
}
private void ResolveFieldSelection(
CompilerContext context,
FieldNode selection,
SelectionIncludeCondition?includeCondition)
{
NameString fieldName = selection.Name.Value;
NameString responseName = selection.Alias is null
? selection.Name.Value
: selection.Alias.Value;
if (context.Type.Fields.TryGetField(fieldName, out IObjectField? field))
{
if ((selection.SelectionSet is null ||
selection.SelectionSet.Selections.Count == 0) &&
field.Type.NamedType().IsCompositeType())
{
throw OperationCompiler_NoCompositeSelections(selection);
}
if (context.Fields.TryGetValue(responseName, out Selection? preparedSelection))
{
preparedSelection.AddSelection(selection, includeCondition);
}
else
{
Func <object, IAsyncEnumerable <object?> >?createStream = null;
bool isStreamable = selection.IsStreamable();
if (field.MaybeStream || field.Type.IsListType() && isStreamable)
{
IType elementType = field.Type.ElementType();
if (elementType.IsCompositeType())
{
Type runtimeType = elementType.ToRuntimeType();
CreateStreamDelegate streamDelegate = CreateStream(runtimeType);
createStream = o => streamDelegate(o);
}
}
// if this is the first time we find a selection to this field we have to
// create a new prepared selection.
preparedSelection = new Selection(
GetNextId(),
context.Type,
field,
selection.SelectionSet is not null
? selection.WithSelectionSet(
selection.SelectionSet.WithSelections(
selection.SelectionSet.Selections))
: selection,
responseName: responseName,
resolverPipeline: CreateFieldMiddleware(field, selection),
pureResolver: TryCreatePureField(field, selection),
strategy: field.IsParallelExecutable
? null // use default strategy
: SelectionExecutionStrategy.Serial,
arguments: CoerceArgumentValues(field, selection, responseName),
includeCondition: includeCondition,
internalSelection: context.IsInternalSelection,
createStream: createStream,
isStreamable: isStreamable);
context.Fields.Add(responseName, preparedSelection);
}
if (includeCondition is not null && selection.SelectionSet is not null)
{
SelectionPath selectionPath = context.SelectionPath.Append(responseName);
for (var i = 0; i < selection.SelectionSet.Selections.Count; i++)
{
ISelectionNode child = selection.SelectionSet.Selections[i];
var reference = new SelectionReference(selectionPath, child);
if (!context.IncludeConditionLookup.ContainsKey(reference))
{
context.IncludeConditionLookup.Add(reference, includeCondition);
}
}
}
}
else
{
throw FieldDoesNotExistOnType(selection, context.Type.Name);
}
}
public StreamCache(CreateStreamDelegate createMainStreamDelegate)
{
this.m_createMainStreamDelegate = (createMainStreamDelegate ?? new CreateStreamDelegate(StreamCache.DefaultCreateStreamDelegate));
}
