//[TestMethod]
public void SimpleLazyDemonstration()
{
Debug.WriteLine("-- Lazy Demonstration --");
var simpleLazy = new SimpleLazy<SimpleClass>();
Debug.WriteLine("Not created yet");
simpleLazy.Value.Description = "New description";
}
public StudioSceneNavigation()
{
_lastLoadedScenes = new SimpleLazy <Dictionary <string, string> >(() =>
TrackLastLoadedSceneEnabled.Value ? LoadTrackingFile() : new Dictionary <string, string>());
_isSceneValid = new SimpleLazy <Func <string, bool> >(() =>
{
var pluginInfo = Chainloader.PluginInfos.Where(pi => pi.Key.EndsWith("InvalidSceneFileProtection"))
.Select(pi => pi.Value).FirstOrDefault();
if (pluginInfo == null)
{
return(_ => true);
}
var pluginType = pluginInfo.Instance.GetType();
var method = AccessTools.Method(pluginType, "IsFileValid");
if (method == null)
{
return(_ => true);
}
Logger.LogDebug(
$"Will use {pluginType.Name}.{method.Name} to pre-check images during navigation");
return((Func <string, bool>)Delegate.CreateDelegate(typeof(Func <string, bool>), method));
});
_saveTrackingFileDelay = new WaitUntil(IsSaveReady);
}
public void NoExceptionCaching()
{
var responseProvider = new SimpleLazy <String>(() => chaoticService());
String result = default;
Parallel.For(0, 15, t =>
{
for (int i = 0; i < 10; i++)
{
if (result != default) // once value is set value should not be changed
{
if (result != responseProvider.Value)
{
Assert.Equal(result, responseProvider.Value);
}
}
else
{
try
{
result = responseProvider.Value;
}
catch (Exception ex)
{
_testOutputHelper.WriteLine(ex.ToString());
}
}
}
});
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="jsonLightOutputContext">The output context to write to.</param>
/// <param name="initContextUriBuilder">Whether contextUriBuilder should be initialized.</param>
internal ODataJsonLightSerializer(ODataJsonLightOutputContext jsonLightOutputContext, bool initContextUriBuilder = false)
: base(jsonLightOutputContext)
{
Debug.Assert(jsonLightOutputContext != null, "jsonLightOutputContext != null");
this.jsonLightOutputContext = jsonLightOutputContext;
this.instanceAnnotationWriter = new SimpleLazy <JsonLightInstanceAnnotationWriter>(() =>
new JsonLightInstanceAnnotationWriter(new ODataJsonLightValueSerializer(jsonLightOutputContext), jsonLightOutputContext.TypeNameOracle));
// NOTE: Ideally, we should instantiate a JsonLightODataAnnotationWriter that supports EITHER synchronous OR asynchronous writing.
// Based on the value of `jsonLightOutputContext.Synchronous`
// However, some higher level classes expose asynchronous wrappers for synchronous methods. Asynchronous wrappers for synchronous methods
// that depend on the instance of JsonLightODataAnnotationWriter that supports synchronous writing would break hence the reason to maintain
// the two separate instances when asynchronous API implementation is in progress
this.odataAnnotationWriter = new SimpleLazy <JsonLightODataAnnotationWriter>(
() => new JsonLightODataAnnotationWriter(
jsonLightOutputContext.JsonWriter,
this.JsonLightOutputContext.OmitODataPrefix,
this.MessageWriterSettings.Version));
this.asynchronousODataAnnotationWriter = new SimpleLazy <JsonLightODataAnnotationWriter>(
() => new JsonLightODataAnnotationWriter(
jsonLightOutputContext.AsynchronousJsonWriter,
this.JsonLightOutputContext.OmitODataPrefix,
this.MessageWriterSettings.Version));
if (initContextUriBuilder)
{
// DEVNOTE: grab this early so that any validation errors are thrown at creation time rather than when Write___ is called.
this.ContextUriBuilder = ODataContextUriBuilder.Create(
this.jsonLightOutputContext.MessageWriterSettings.MetadataDocumentUri,
this.jsonLightOutputContext.WritingResponse && !(this.jsonLightOutputContext.MetadataLevel is JsonNoMetadataLevel));
}
}
public void TestBinpow()
{
int Binpow()
{
int a = 3;
int p = 8;
int res = 1;
while (p != 0)
{
if (p % 2 == 1)
{
res *= a;
}
a *= a;
p /= 2;
}
return(res);
}
SimpleLazy <int> binpowLazy = LazyFactory.CreateSimpleLazy(Binpow);
Assert.AreEqual(Binpow(), binpowLazy.Get);
}
private CardNameCacheData(string familyName, string givenName, string fullName)
{
FamilyName = familyName;
GivenName = givenName;
FullName = fullName;
_identity = new SimpleLazy <string>(MakeIdentity);
}
public void LazyNullTest()
{
Func <Object> NullSupplier() => null;
SimpleLazy <Object> simpleNullLazy = LazyFactory.CreateSimpleLazy <Object>(NullSupplier);
Assert.IsNull(simpleNullLazy.Get);
}
//[TestMethod]
public void SimpleLazyDemonstration()
{
Debug.WriteLine("-- Lazy Demonstration --");
var simpleLazy = new SimpleLazy <SimpleClass>();
Debug.WriteLine("Not created yet");
simpleLazy.Value.Description = "New description";
}
/// <summary>
/// Constructs a new instance of DataServiceOperationContext object
/// </summary>
/// <param name="host">RequestMessage instance for the current operation context.</param>
internal DataServiceOperationContext(IDataServiceHost host)
{
Debug.Assert(host != null, "host != null");
this.hostInterface = host;
this.lazyMetadataUri = new SimpleLazy <Uri>(() =>
{
Debug.Assert(this.AbsoluteServiceUri != null, "Cannot get the metadata uri if the absolute service uri is not initialized");
return(RequestUriProcessor.AppendEscapedSegment(this.AbsoluteServiceUri, XmlConstants.UriMetadataSegment));
});
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="jsonLightOutputContext">The output context to write to.</param>
internal ODataJsonLightSerializer(ODataJsonLightOutputContext jsonLightOutputContext)
: base(jsonLightOutputContext)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(jsonLightOutputContext != null, "jsonLightOutputContext != null");
this.jsonLightOutputContext = jsonLightOutputContext;
this.instanceAnnotationWriter = new SimpleLazy <JsonLightInstanceAnnotationWriter>(() =>
new JsonLightInstanceAnnotationWriter(new ODataJsonLightValueSerializer(jsonLightOutputContext), jsonLightOutputContext.TypeNameOracle));
}
/// <summary>
/// Constructs a new instance of DataServiceOperationContext object
/// </summary>
/// <param name="host">RequestMessage instance for the current operation context.</param>
internal DataServiceOperationContext(IDataServiceHost host)
{
Debug.Assert(host != null, "host != null");
this.hostInterface = host;
this.lazyMetadataUri = new SimpleLazy<Uri>(() =>
{
Debug.Assert(this.AbsoluteServiceUri != null, "Cannot get the metadata uri if the absolute service uri is not initialized");
return RequestUriProcessor.AppendEscapedSegment(this.AbsoluteServiceUri, XmlConstants.UriMetadataSegment);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="LazySerializedEntityKey"/> class which uses the same syntax for identity and edit link.
/// </summary>
/// <param name="lazyRelativeIdentity">The identity as a lazy string relative to the service URI.</param>
/// <param name="absoluteServiceUri">The absolute service URI.</param>
/// <param name="editLinkSuffix">The optional suffix to append to the edit link. Null means nothing will be appended.</param>
internal LazySerializedEntityKey(SimpleLazy<string> lazyRelativeIdentity, Uri absoluteServiceUri, string editLinkSuffix)
{
Debug.Assert(absoluteServiceUri != null && absoluteServiceUri.IsAbsoluteUri, "absoluteServiceUri != null && absoluteServiceUri.IsAbsoluteUri");
this.lazyAbsoluteEditLinkWithoutSuffix = new SimpleLazy<Uri>(() => RequestUriProcessor.AppendEscapedSegment(absoluteServiceUri, lazyRelativeIdentity.Value));
this.lazyIdentity = new SimpleLazy<Uri>(() => this.lazyAbsoluteEditLinkWithoutSuffix.Value, false);
this.lazyAbsoluteEditLink = AppendLazilyIfNeeded(this.lazyAbsoluteEditLinkWithoutSuffix, editLinkSuffix);
SimpleLazy<Uri> relativeEdit = new SimpleLazy<Uri>(() => new Uri(lazyRelativeIdentity.Value, UriKind.Relative), false);
this.lazyRelativeEditLink = AppendLazilyIfNeeded(relativeEdit, editLinkSuffix);
}
/// <summary>
/// Initializes a new instance of the <see cref="LazySerializedEntityKey"/> class which uses the same syntax for identity and edit link.
/// </summary>
/// <param name="lazyRelativeIdentity">The identity as a lazy string relative to the service URI.</param>
/// <param name="absoluteServiceUri">The absolute service URI.</param>
/// <param name="editLinkSuffix">The optional suffix to append to the edit link. Null means nothing will be appended.</param>
internal LazySerializedEntityKey(SimpleLazy <string> lazyRelativeIdentity, Uri absoluteServiceUri, string editLinkSuffix)
{
Debug.Assert(absoluteServiceUri != null && absoluteServiceUri.IsAbsoluteUri, "absoluteServiceUri != null && absoluteServiceUri.IsAbsoluteUri");
this.lazyAbsoluteEditLinkWithoutSuffix = new SimpleLazy <Uri>(() => RequestUriProcessor.AppendEscapedSegment(absoluteServiceUri, lazyRelativeIdentity.Value));
this.lazyIdentity = new SimpleLazy <Uri>(() => this.lazyAbsoluteEditLinkWithoutSuffix.Value, false);
this.lazyAbsoluteEditLink = AppendLazilyIfNeeded(this.lazyAbsoluteEditLinkWithoutSuffix, editLinkSuffix);
SimpleLazy <Uri> relativeEdit = new SimpleLazy <Uri>(() => new Uri(lazyRelativeIdentity.Value, UriKind.Relative), false);
this.lazyRelativeEditLink = AppendLazilyIfNeeded(relativeEdit, editLinkSuffix);
}
/// <summary>
/// Get the stream reference value for media resource (the default stream of an entity).
/// </summary>
/// <param name="entityToSerialize">Entity that is currently being serialized.</param>
/// <param name="title">The title for the element being written.</param>
/// <returns>
/// An instance of ODataStreamReferenceValue containing the metadata about the media resource.
/// </returns>
private ODataStreamReferenceValue GetMediaResource(EntityToSerialize entityToSerialize, string title)
{
Debug.Assert(entityToSerialize.Entity != null, "element != null");
Debug.Assert(entityToSerialize.ResourceType != null && entityToSerialize.ResourceType.ResourceTypeKind == ResourceTypeKind.EntityType, "type != null && type.ResourceTypeKind == ResourceTypeKind.EntityType");
Debug.Assert(!string.IsNullOrEmpty(title), "!string.IsNullOrEmpty(title)");
ODataStreamReferenceValue mediaResource = null;
// Handle MLE
if (entityToSerialize.ResourceType.IsMediaLinkEntry)
{
string mediaETag;
Uri readStreamUri;
string mediaContentType;
Debug.Assert(entityToSerialize.ResourceType.ResourceTypeKind == ResourceTypeKind.EntityType, "type.ResourceTypeKind == ResourceTypeKind.EntityType");
this.Service.StreamProvider.GetStreamDescription(entityToSerialize.Entity, null /*null for MLE*/, this.Service.OperationContext, out mediaETag, out readStreamUri, out mediaContentType);
Debug.Assert(WebUtil.IsETagValueValid(mediaETag, true), "WebUtil.IsETagValueValid(mediaETag, true)");
Debug.Assert(!string.IsNullOrEmpty(mediaContentType), "!string.IsNullOrEmpty(mediaContentType)");
mediaResource = new ODataStreamReferenceValue();
// build the stream's edit link lazily to avoid creating the entity's edit link if it is not needed.
SimpleLazy <Uri> lazyStreamEditLink = new SimpleLazy <Uri>(() => RequestUriProcessor.AppendEscapedSegment(entityToSerialize.SerializedKey.RelativeEditLink, XmlConstants.UriValueSegment));
this.PayloadMetadataPropertyManager.SetEditLink(mediaResource, () => lazyStreamEditLink.Value);
this.PayloadMetadataPropertyManager.SetContentType(mediaResource, mediaContentType);
// If the stream provider did not provider a read link, then we should use the edit link as the read link.
this.PayloadMetadataPropertyManager.SetReadLink(mediaResource, () => readStreamUri ?? lazyStreamEditLink.Value);
#pragma warning disable 618
if (this.contentFormat == ODataFormat.Atom)
#pragma warning restore 618
{
AtomStreamReferenceMetadata mediaResourceAtom = new AtomStreamReferenceMetadata()
{
EditLink = new AtomLinkMetadata {
Title = title
}
};
mediaResource.SetAnnotation(mediaResourceAtom);
}
if (!string.IsNullOrEmpty(mediaETag))
{
this.PayloadMetadataPropertyManager.SetETag(mediaResource, mediaETag);
}
}
return(mediaResource);
}
public void SimpleLazyOfTDefaultConstructorShouldDelayConstructValue()
{
int factoryCallCount = 0;
SimpleLazy<int> lazy = new SimpleLazy<int>(() =>
{
factoryCallCount++;
return 1;
});
factoryCallCount.Should().Be(0);
lazy.Value.Should().Be(1);
factoryCallCount.Should().Be(1);
lazy.Value.Should().Be(1);
factoryCallCount.Should().Be(1);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="jsonLightOutputContext">The output context to write to.</param>
/// <param name="initContextUriBuilder">Whether contextUriBuilder should be initialized.</param>
internal ODataJsonLightSerializer(ODataJsonLightOutputContext jsonLightOutputContext, bool initContextUriBuilder = false)
: base(jsonLightOutputContext)
{
Debug.Assert(jsonLightOutputContext != null, "jsonLightOutputContext != null");
this.jsonLightOutputContext = jsonLightOutputContext;
this.instanceAnnotationWriter = new SimpleLazy<JsonLightInstanceAnnotationWriter>(() =>
new JsonLightInstanceAnnotationWriter(new ODataJsonLightValueSerializer(jsonLightOutputContext), jsonLightOutputContext.TypeNameOracle));
if (initContextUriBuilder)
{
// DEVNOTE: grab this early so that any validation errors are thrown at creation time rather than when Write___ is called.
this.ContextUriBuilder = jsonLightOutputContext.CreateContextUriBuilder();
}
}
public void SimpleLazyOfTDefaultConstructorShouldDelayConstructValue()
{
int factoryCallCount = 0;
SimpleLazy <int> lazy = new SimpleLazy <int>(() =>
{
factoryCallCount++;
return(1);
});
Assert.Equal(0, factoryCallCount);
Assert.Equal(1, lazy.Value);
Assert.Equal(1, factoryCallCount);
Assert.Equal(1, lazy.Value);
Assert.Equal(1, factoryCallCount);
}
public void SimpleLazyOfTNotThreadSafeShouldDelayConstructValue()
{
Uri abcpqr = new Uri("http://abc/pqr", UriKind.Absolute);
int factoryCallCount = 0;
SimpleLazy<Uri> lazy = new SimpleLazy<Uri>(() =>
{
factoryCallCount++;
return abcpqr;
}, false /*isThreadSafe*/);
factoryCallCount.Should().Be(0);
lazy.Value.Should().Be(abcpqr);
factoryCallCount.Should().Be(1);
lazy.Value.Should().Be(abcpqr);
factoryCallCount.Should().Be(1);
}
public void SimpleLazyOfTDefaultConstructorShouldDelayConstructValue()
{
int factoryCallCount = 0;
SimpleLazy <int> lazy = new SimpleLazy <int>(() =>
{
factoryCallCount++;
return(1);
});
factoryCallCount.Should().Be(0);
lazy.Value.Should().Be(1);
factoryCallCount.Should().Be(1);
lazy.Value.Should().Be(1);
factoryCallCount.Should().Be(1);
}
public void RandomTest()
{
int GetRandom() => this.random.Next(50, 100);
SimpleLazy <int> randomLazy = LazyFactory.CreateSimpleLazy(GetRandom);
int result = randomLazy.Get;
const int n = 10;
for (int i = 0; i < n; ++i)
{
Assert.AreEqual(result, randomLazy.Get);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="jsonLightOutputContext">The output context to write to.</param>
/// <param name="initContextUriBuilder">Whether contextUriBuilder should be initialized.</param>
internal ODataJsonLightSerializer(ODataJsonLightOutputContext jsonLightOutputContext, bool initContextUriBuilder = false)
: base(jsonLightOutputContext)
{
Debug.Assert(jsonLightOutputContext != null, "jsonLightOutputContext != null");
this.jsonLightOutputContext = jsonLightOutputContext;
this.instanceAnnotationWriter = new SimpleLazy <JsonLightInstanceAnnotationWriter>(() =>
new JsonLightInstanceAnnotationWriter(new ODataJsonLightValueSerializer(jsonLightOutputContext), jsonLightOutputContext.TypeNameOracle));
if (initContextUriBuilder)
{
// DEVNOTE: grab this early so that any validation errors are thrown at creation time rather than when Write___ is called.
this.ContextUriBuilder = jsonLightOutputContext.CreateContextUriBuilder();
}
}
public void SimpleLazyOfTThreadSafeShouldDelayConstructValue()
{
int factoryCallCount = 0;
SimpleLazy<string> lazy = new SimpleLazy<string>(() =>
{
factoryCallCount++;
return "foo";
},
true /*isThreadSafe*/);
factoryCallCount.Should().Be(0);
lazy.Value.Should().Be("foo");
factoryCallCount.Should().Be(1);
lazy.Value.Should().Be("foo");
factoryCallCount.Should().Be(1);
}
public void SimpleLazyOfTNotThreadSafeShouldDelayConstructValue()
{
Uri abcpqr = new Uri("http://abc/pqr", UriKind.Absolute);
int factoryCallCount = 0;
SimpleLazy <Uri> lazy = new SimpleLazy <Uri>(() =>
{
factoryCallCount++;
return(abcpqr);
}, false /*isThreadSafe*/);
Assert.Equal(0, factoryCallCount);
Assert.Equal(abcpqr, lazy.Value);
Assert.Equal(1, factoryCallCount);
Assert.Equal(abcpqr, lazy.Value);
Assert.Equal(1, factoryCallCount);
}
/// <summary>
/// Constructs a new instance of ServiceOperationProvider.
/// </summary>
/// <param name="type">Type implementing service operations.</param>
/// <param name="resourceTypeResolver">Resolver that gives a <see cref="ResourceSet"/> corresponding to given <see cref="ResourceType"/> and <see cref="MethodInfo"/>.</param>
/// <param name="resourceSetResolver">Resolver that gives a <see cref="ResourceType"/> corresponding to given CLR type.</param>
public ServiceOperationProvider(Type type, Func<Type, ResourceType> resourceTypeResolver, Func<ResourceType, MethodInfo, ResourceSet> resourceSetResolver)
{
WebUtil.CheckArgumentNull(type, "type");
WebUtil.CheckArgumentNull(resourceTypeResolver, "resourceTypeResolver");
WebUtil.CheckArgumentNull(resourceSetResolver, "resourceSetResolver");
if (type.IsAbstract)
{
throw new InvalidOperationException(Strings.ServiceOperationProvider_TypeIsAbstract(type));
}
this.type = type;
this.resourceTypeResolver = resourceTypeResolver;
this.resourceSetResolver = resourceSetResolver;
this.serviceOperations = new SimpleLazy<List<ServiceOperation>>(this.FindServiceOperations, true);
}
public void SimpleLazyOfTThreadSafeShouldDelayConstructValue()
{
int factoryCallCount = 0;
SimpleLazy <string> lazy = new SimpleLazy <string>(() =>
{
factoryCallCount++;
return("foo");
},
true /*isThreadSafe*/);
Assert.Equal(0, factoryCallCount);
Assert.Equal("foo", lazy.Value);
Assert.Equal(1, factoryCallCount);
Assert.Equal("foo", lazy.Value);
Assert.Equal(1, factoryCallCount);
}
public void SimpleLazyOfTNotThreadSafeShouldDelayConstructValue()
{
Uri abcpqr = new Uri("http://abc/pqr", UriKind.Absolute);
int factoryCallCount = 0;
SimpleLazy <Uri> lazy = new SimpleLazy <Uri>(() =>
{
factoryCallCount++;
return(abcpqr);
}, false /*isThreadSafe*/);
factoryCallCount.Should().Be(0);
lazy.Value.Should().Be(abcpqr);
factoryCallCount.Should().Be(1);
lazy.Value.Should().Be(abcpqr);
factoryCallCount.Should().Be(1);
}
public void SimpleLazyOfTThreadSafeShouldDelayConstructValue()
{
int factoryCallCount = 0;
SimpleLazy <string> lazy = new SimpleLazy <string>(() =>
{
factoryCallCount++;
return("foo");
},
true /*isThreadSafe*/);
factoryCallCount.Should().Be(0);
lazy.Value.Should().Be("foo");
factoryCallCount.Should().Be(1);
lazy.Value.Should().Be("foo");
factoryCallCount.Should().Be(1);
}
/// <summary>
/// Constructs a new instance of ServiceOperationProvider.
/// </summary>
/// <param name="type">Type implementing service operations.</param>
/// <param name="resourceTypeResolver">Resolver that gives a <see cref="ResourceSet"/> corresponding to given <see cref="ResourceType"/> and <see cref="MethodInfo"/>.</param>
/// <param name="resourceSetResolver">Resolver that gives a <see cref="ResourceType"/> corresponding to given CLR type.</param>
public ServiceOperationProvider(Type type, Func <Type, ResourceType> resourceTypeResolver, Func <ResourceType, MethodInfo, ResourceSet> resourceSetResolver)
{
WebUtil.CheckArgumentNull(type, "type");
WebUtil.CheckArgumentNull(resourceTypeResolver, "resourceTypeResolver");
WebUtil.CheckArgumentNull(resourceSetResolver, "resourceSetResolver");
if (type.IsAbstract)
{
throw new InvalidOperationException(Strings.ServiceOperationProvider_TypeIsAbstract(type));
}
this.type = type;
this.resourceTypeResolver = resourceTypeResolver;
this.resourceSetResolver = resourceSetResolver;
this.serviceOperations = new SimpleLazy <List <ServiceOperation> >(this.FindServiceOperations, true);
}
/// <summary>
/// Tries to serialize the operation.
/// </summary>
/// <param name="entityToSerialize">The entity to serialize.</param>
/// <param name="resourceInstanceInFeed">Whether or not the entity is being serialized in a feed.</param>
/// <param name="entityHasMultipleActionsWithSameName">Whether or not there are multiple operations in the current scope with the same name as the current operation.</param>
/// <param name="serviceOperationWrapper">The service operation wrapper.</param>
/// <param name="odataAction">The ODL object-model representation of the action.</param>
/// <returns>Whether or not to serialize the operation.</returns>
private bool TrySerializeOperation(EntityToSerialize entityToSerialize, bool resourceInstanceInFeed, bool entityHasMultipleActionsWithSameName, OperationWrapper serviceOperationWrapper, out ODataAction odataAction)
{
Debug.Assert(serviceOperationWrapper != null, "serviceOperationWrapper != null");
// We only advertise actions. This is a debug assert because GetServiceOperationsByResourceType only returns actions.
Debug.Assert(serviceOperationWrapper.Kind == OperationKind.Action, "Only actions can be advertised");
Uri metadata = this.operationLinkBuilder.BuildMetadataLink(serviceOperationWrapper, entityHasMultipleActionsWithSameName);
// If the action has OperationParameterBindingKind set to "Always" then we advertise the action without calling "AdvertiseServiceAction".
bool isAlwaysAvailable = serviceOperationWrapper.OperationParameterBindingKind == OperationParameterBindingKind.Always;
odataAction = new ODataAction {
Metadata = metadata
};
// There is some subtlety to the interaction between action advertisement and whether or not to include title/target on the wire.
//
// 1) If an action is always available:
// The provider author does not get a chance to customize the title/target values...
// so the values will be based on conventions...
// so by default do not write them on the wire
// 2) If it is only sometimes available:
// The values need to be computed to provide them on the instance given to the provider...
// but they might not be changed by the provider author...
// so compare them to the computed values, and do not write them if they match.
// TODO: Action provider should be able to customize title/target even if the action is 'always' advertised
// If this gets fixed, then all the behavior should collapse to emulate case #2 above
// Create a lazy Uri for the target, because we may need it more than once (see case #2 above).
SimpleLazy <Uri> lazyActionTargetUri = new SimpleLazy <Uri>(() => this.operationLinkBuilder.BuildTargetLink(entityToSerialize, serviceOperationWrapper, entityHasMultipleActionsWithSameName));
this.metadataPropertyManager.SetTitle(odataAction, isAlwaysAvailable, serviceOperationWrapper.Name);
this.metadataPropertyManager.SetTarget(odataAction, isAlwaysAvailable, () => lazyActionTargetUri.Value);
// If the operation is always available,
// 1. Return true for MetadataQueryOption.All.
// 2. Return false for MetadataQueryOption.None.
// 3. Return false for MetadataQueryOption.Default.
if (isAlwaysAvailable)
{
return(this.payloadMetadataParameterInterpreter.ShouldIncludeAlwaysAvailableOperation());
}
return(this.AskProviderIfActionShouldBeAdvertised(entityToSerialize, resourceInstanceInFeed, serviceOperationWrapper, lazyActionTargetUri, entityHasMultipleActionsWithSameName, ref odataAction));
}
public XUnityAutoTranslationHelper()
{
_defaultCache = new SimpleLazy <object>(LazyReflectionGetter <object>(() => DefaultTranslator, "TextCache"));
_reloadTranslations = new SimpleLazy <ReloadTranslationsDelegate>(ReloadTranslationsDelegateLoader);
_addTranslationToCache = new SimpleLazy <AddTranslationToCacheDelegate>(AddTranslationToCacheLoader);
var settingsType = new SimpleLazy <Type>(() =>
typeof(IPluginEnvironment).Assembly.GetType("XUnity.AutoTranslator.Plugin.Core.Configuration.Settings",
true));
_getReplacements = LazyReflectionGetter <Dictionary <string, string> >(settingsType, "Replacements");
_getAutoTranslationsFilePath = LazyReflectionGetter <string>(settingsType, "AutoTranslationsFilePath");
_getTranslations = LazyReflectionGetter <Dictionary <string, string> >(_defaultCache, "_translations");
_getRegisteredRegexes = LazyReflectionGetter <HashSet <string> >(_defaultCache, "_registeredRegexes");
_getRegisteredSplitterRegexes =
LazyReflectionGetter <HashSet <string> >(_defaultCache, "_registeredSplitterRegexes");
}
/// <summary>
/// Creates an instance of <see cref="SerializedEntityKey"/> for the given properties and values.
/// </summary>
/// <param name="keySerializer">The key serializer to use.</param>
/// <param name="absoluteServiceUri">The absolute service URI.</param>
/// <param name="entitySetName">Name of the entity set.</param>
/// <param name="keyProperties">The key properties.</param>
/// <param name="getPropertyValue">The callback to get each property's value.</param>
/// <param name="editLinkSuffix">The suffix to append to the edit-link, or null.</param>
/// <returns>A serialized-key instance.</returns>
internal static SerializedEntityKey Create(
KeySerializer keySerializer,
Uri absoluteServiceUri,
string entitySetName,
ICollection <ResourceProperty> keyProperties,
Func <ResourceProperty, object> getPropertyValue,
string editLinkSuffix)
{
SimpleLazy <string> lazyRelativeIdentity = new SimpleLazy <string>(() =>
{
var builder = new StringBuilder();
builder.Append(entitySetName);
keySerializer.AppendKeyExpression(builder, keyProperties, p => p.Name, getPropertyValue);
return(builder.ToString());
});
return(new LazySerializedEntityKey(lazyRelativeIdentity, absoluteServiceUri, editLinkSuffix));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="jsonLightOutputContext">The output context to write to.</param>
/// <param name="initContextUriBuilder">Whether contextUriBuilder should be initialized.</param>
internal ODataJsonLightSerializer(ODataJsonLightOutputContext jsonLightOutputContext, bool initContextUriBuilder = false)
: base(jsonLightOutputContext)
{
Debug.Assert(jsonLightOutputContext != null, "jsonLightOutputContext != null");
this.jsonLightOutputContext = jsonLightOutputContext;
this.instanceAnnotationWriter = new SimpleLazy <JsonLightInstanceAnnotationWriter>(() =>
new JsonLightInstanceAnnotationWriter(new ODataJsonLightValueSerializer(jsonLightOutputContext), jsonLightOutputContext.TypeNameOracle));
this.odataAnnotationWriter = new SimpleLazy <JsonLightODataAnnotationWriter>(() =>
new JsonLightODataAnnotationWriter(jsonLightOutputContext.JsonWriter,
this.JsonLightOutputContext.ODataSimplifiedOptions.EnableWritingODataAnnotationWithoutPrefix, this.MessageWriterSettings.Version));
if (initContextUriBuilder)
{
// DEVNOTE: grab this early so that any validation errors are thrown at creation time rather than when Write___ is called.
this.ContextUriBuilder = ODataContextUriBuilder.Create(
this.jsonLightOutputContext.MessageWriterSettings.MetadataDocumentUri,
this.jsonLightOutputContext.WritingResponse && !(this.jsonLightOutputContext.MetadataLevel is JsonNoMetadataLevel));
}
}
/// <summary>
/// Wraps a lazy URI with another that will have the given string appended if it is not null.
/// </summary>
/// <param name="lazyUri">The lazy URI to wrap.</param>
/// <param name="suffix">The suffix for the URI.</param>
/// <returns>A new lazy URI which will have the suffix, or the same instance if the suffix was null.</returns>
private static SimpleLazy <Uri> AppendLazilyIfNeeded(SimpleLazy <Uri> lazyUri, string suffix)
{
return(suffix == null ? lazyUri : new SimpleLazy <Uri>(() => RequestUriProcessor.AppendUnescapedSegment(lazyUri.Value, suffix), false));
}
public CharaId(byte[] bytes)
{
_value = bytes;
_sortKey = new SimpleLazy <string>(() => Convert.ToBase64String(_value));
_hashCode = new SimpleLazy <int>(() => GetSortKey().GetHashCode());
}
/// <summary>
/// Asks the provider if the action should be advertised in payloads.
/// </summary>
/// <param name="entityToSerialize">The entity to serialize.</param>
/// <param name="resourceInstanceInFeed">Whether or not the entity is being serialized in a feed.</param>
/// <param name="serviceOperationWrapper">The service operation wrapper.</param>
/// <param name="lazyActionTargetUri">Target uri of the action, which will only be generated if needed.</param>
/// <param name="entityHasMultipleActionsWithSameName">Whether or not there are multiple operations in the current scope with the same name as the current operation.</param>
/// <param name="odataAction">The ODL object-model representation of the action.</param>
/// <returns>Whether or not the action should be advertised.</returns>
private bool AskProviderIfActionShouldBeAdvertised(EntityToSerialize entityToSerialize, bool resourceInstanceInFeed, OperationWrapper serviceOperationWrapper, SimpleLazy <Uri> lazyActionTargetUri, bool entityHasMultipleActionsWithSameName, ref ODataAction odataAction)
{
if (this.advertiseServiceAction(serviceOperationWrapper, entityToSerialize.Entity, resourceInstanceInFeed, ref odataAction))
{
if (odataAction == null)
{
throw new DataServiceException(500, Microsoft.OData.Service.Strings.DataServiceActionProviderWrapper_AdvertiseServiceActionCannotReturnNullActionToSerialize);
}
// Always set target and title if there are overloaded actions.
if (!entityHasMultipleActionsWithSameName)
{
this.metadataPropertyManager.CheckForUnmodifiedTitle(odataAction, serviceOperationWrapper.Name);
this.metadataPropertyManager.CheckForUnmodifiedTarget(odataAction, () => lazyActionTargetUri.Value);
}
// make the target link relative
this.MakeOperationTargetRelativeFromMetadataUriIfJsonLight(odataAction);
return(true);
}
odataAction = null;
return(false);
}
public AutoTranslationHelperBase()
{
_logger = new SimpleLazy <ManualLogSource>(() => BepInEx.Logging.Logger.CreateLogSource(GetType().FullName));
}
/// <summary>
/// Get the stream reference value for media resource (the default stream of an entity).
/// </summary>
/// <param name="entityToSerialize">Entity that is currently being serialized.</param>
/// <param name="title">The title for the element being written.</param>
/// <returns>
/// An instance of ODataStreamReferenceValue containing the metadata about the media resource.
/// </returns>
private ODataStreamReferenceValue GetMediaResource(EntityToSerialize entityToSerialize, string title)
{
Debug.Assert(entityToSerialize.Entity != null, "element != null");
Debug.Assert(entityToSerialize.ResourceType != null && entityToSerialize.ResourceType.ResourceTypeKind == ResourceTypeKind.EntityType, "type != null && type.ResourceTypeKind == ResourceTypeKind.EntityType");
Debug.Assert(!string.IsNullOrEmpty(title), "!string.IsNullOrEmpty(title)");
ODataStreamReferenceValue mediaResource = null;
// Handle MLE
if (entityToSerialize.ResourceType.IsMediaLinkEntry)
{
string mediaETag;
Uri readStreamUri;
string mediaContentType;
Debug.Assert(entityToSerialize.ResourceType.ResourceTypeKind == ResourceTypeKind.EntityType, "type.ResourceTypeKind == ResourceTypeKind.EntityType");
this.Service.StreamProvider.GetStreamDescription(entityToSerialize.Entity, null /*null for MLE*/, this.Service.OperationContext, out mediaETag, out readStreamUri, out mediaContentType);
Debug.Assert(WebUtil.IsETagValueValid(mediaETag, true), "WebUtil.IsETagValueValid(mediaETag, true)");
Debug.Assert(!string.IsNullOrEmpty(mediaContentType), "!string.IsNullOrEmpty(mediaContentType)");
mediaResource = new ODataStreamReferenceValue();
// build the stream's edit link lazily to avoid creating the entity's edit link if it is not needed.
SimpleLazy<Uri> lazyStreamEditLink = new SimpleLazy<Uri>(() => RequestUriProcessor.AppendEscapedSegment(entityToSerialize.SerializedKey.RelativeEditLink, XmlConstants.UriValueSegment));
this.PayloadMetadataPropertyManager.SetEditLink(mediaResource, () => lazyStreamEditLink.Value);
this.PayloadMetadataPropertyManager.SetContentType(mediaResource, mediaContentType);
// If the stream provider did not provider a read link, then we should use the edit link as the read link.
this.PayloadMetadataPropertyManager.SetReadLink(mediaResource, () => readStreamUri ?? lazyStreamEditLink.Value);
#pragma warning disable 618
if (this.contentFormat == ODataFormat.Atom)
#pragma warning restore 618
{
AtomStreamReferenceMetadata mediaResourceAtom = new AtomStreamReferenceMetadata() { EditLink = new AtomLinkMetadata { Title = title } };
mediaResource.SetAnnotation(mediaResourceAtom);
}
if (!string.IsNullOrEmpty(mediaETag))
{
this.PayloadMetadataPropertyManager.SetETag(mediaResource, mediaETag);
}
}
return mediaResource;
}
/// <summary>
/// Initializes a new instance of the <see cref="PrimitiveValueMaterializationPolicy" /> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="lazyPrimitivePropertyConverter">The lazy primitive property converter.</param>
internal PrimitiveValueMaterializationPolicy(IODataMaterializerContext context, SimpleLazy<PrimitivePropertyConverter> lazyPrimitivePropertyConverter)
{
this.context = context;
this.lazyPrimitivePropertyConverter = lazyPrimitivePropertyConverter;
}
/// <summary>
/// Wraps a lazy URI with another that will have the given string appended if it is not null.
/// </summary>
/// <param name="lazyUri">The lazy URI to wrap.</param>
/// <param name="suffix">The suffix for the URI.</param>
/// <returns>A new lazy URI which will have the suffix, or the same instance if the suffix was null.</returns>
private static SimpleLazy<Uri> AppendLazilyIfNeeded(SimpleLazy<Uri> lazyUri, string suffix)
{
return suffix == null ? lazyUri : new SimpleLazy<Uri>(() => RequestUriProcessor.AppendUnescapedSegment(lazyUri.Value, suffix), false);
}
/// <summary>
/// Tries to serialize the operation.
/// </summary>
/// <param name="entityToSerialize">The entity to serialize.</param>
/// <param name="resourceInstanceInFeed">Whether or not the entity is being serialized in a feed.</param>
/// <param name="entityHasMultipleActionsWithSameName">Whether or not there are multiple operations in the current scope with the same name as the current operation.</param>
/// <param name="serviceOperationWrapper">The service operation wrapper.</param>
/// <param name="odataAction">The ODL object-model representation of the action.</param>
/// <returns>Whether or not to serialize the operation.</returns>
private bool TrySerializeOperation(EntityToSerialize entityToSerialize, bool resourceInstanceInFeed, bool entityHasMultipleActionsWithSameName, OperationWrapper serviceOperationWrapper, out ODataAction odataAction)
{
Debug.Assert(serviceOperationWrapper != null, "serviceOperationWrapper != null");
// We only advertise actions. This is a debug assert because GetServiceOperationsByResourceType only returns actions.
Debug.Assert(serviceOperationWrapper.Kind == OperationKind.Action, "Only actions can be advertised");
Uri metadata = this.operationLinkBuilder.BuildMetadataLink(serviceOperationWrapper, entityHasMultipleActionsWithSameName);
// If the action has OperationParameterBindingKind set to "Always" then we advertise the action without calling "AdvertiseServiceAction".
bool isAlwaysAvailable = serviceOperationWrapper.OperationParameterBindingKind == OperationParameterBindingKind.Always;
odataAction = new ODataAction { Metadata = metadata };
// There is some subtlety to the interaction between action advertisement and whether or not to include title/target on the wire.
//
// 1) If an action is always available:
// The provider author does not get a chance to customize the title/target values...
// so the values will be based on conventions...
// so by default do not write them on the wire
// 2) If it is only sometimes available:
// The values need to be computed to provide them on the instance given to the provider...
// but they might not be changed by the provider author...
// so compare them to the computed values, and do not write them if they match.
// TODO: Action provider should be able to customize title/target even if the action is 'always' advertised
// If this gets fixed, then all the behavior should collapse to emulate case #2 above
// Create a lazy Uri for the target, because we may need it more than once (see case #2 above).
SimpleLazy<Uri> lazyActionTargetUri = new SimpleLazy<Uri>(() => this.operationLinkBuilder.BuildTargetLink(entityToSerialize, serviceOperationWrapper, entityHasMultipleActionsWithSameName));
this.metadataPropertyManager.SetTitle(odataAction, isAlwaysAvailable, serviceOperationWrapper.Name);
this.metadataPropertyManager.SetTarget(odataAction, isAlwaysAvailable, () => lazyActionTargetUri.Value);
// If the operation is always available,
// 1. Return true for MetadataQueryOption.All.
// 2. Return false for MetadataQueryOption.None.
// 3. Return false for MetadataQueryOption.Default.
if (isAlwaysAvailable)
{
return this.payloadMetadataParameterInterpreter.ShouldIncludeAlwaysAvailableOperation();
}
return this.AskProviderIfActionShouldBeAdvertised(entityToSerialize, resourceInstanceInFeed, serviceOperationWrapper, lazyActionTargetUri, entityHasMultipleActionsWithSameName, ref odataAction);
}
/// <summary>
/// Creates an instance of <see cref="SerializedEntityKey"/> for the given properties and values.
/// </summary>
/// <param name="keySerializer">The key serializer to use.</param>
/// <param name="absoluteServiceUri">The absolute service URI.</param>
/// <param name="entitySetName">Name of the entity set.</param>
/// <param name="keyProperties">The key properties.</param>
/// <param name="getPropertyValue">The callback to get each property's value.</param>
/// <param name="editLinkSuffix">The suffix to append to the edit-link, or null.</param>
/// <returns>A serialized-key instance.</returns>
internal static SerializedEntityKey Create(
KeySerializer keySerializer,
Uri absoluteServiceUri,
string entitySetName,
ICollection<ResourceProperty> keyProperties,
Func<ResourceProperty, object> getPropertyValue,
string editLinkSuffix)
{
SimpleLazy<string> lazyRelativeIdentity = new SimpleLazy<string>(() =>
{
var builder = new StringBuilder();
builder.Append(entitySetName);
keySerializer.AppendKeyExpression(builder, keyProperties, p => p.Name, getPropertyValue);
return builder.ToString();
});
return new LazySerializedEntityKey(lazyRelativeIdentity, absoluteServiceUri, editLinkSuffix);
}
/// <summary>
/// Asks the provider if the action should be advertised in payloads.
/// </summary>
/// <param name="entityToSerialize">The entity to serialize.</param>
/// <param name="resourceInstanceInFeed">Whether or not the entity is being serialized in a feed.</param>
/// <param name="serviceOperationWrapper">The service operation wrapper.</param>
/// <param name="lazyActionTargetUri">Target uri of the action, which will only be generated if needed.</param>
/// <param name="entityHasMultipleActionsWithSameName">Whether or not there are multiple operations in the current scope with the same name as the current operation.</param>
/// <param name="odataAction">The ODL object-model representation of the action.</param>
/// <returns>Whether or not the action should be advertised.</returns>
private bool AskProviderIfActionShouldBeAdvertised(EntityToSerialize entityToSerialize, bool resourceInstanceInFeed, OperationWrapper serviceOperationWrapper, SimpleLazy<Uri> lazyActionTargetUri, bool entityHasMultipleActionsWithSameName, ref ODataAction odataAction)
{
if (this.advertiseServiceAction(serviceOperationWrapper, entityToSerialize.Entity, resourceInstanceInFeed, ref odataAction))
{
if (odataAction == null)
{
throw new DataServiceException(500, Microsoft.OData.Service.Strings.DataServiceActionProviderWrapper_AdvertiseServiceActionCannotReturnNullActionToSerialize);
}
// Always set target and title if there are overloaded actions.
if (!entityHasMultipleActionsWithSameName)
{
this.metadataPropertyManager.CheckForUnmodifiedTitle(odataAction, serviceOperationWrapper.Name);
this.metadataPropertyManager.CheckForUnmodifiedTarget(odataAction, () => lazyActionTargetUri.Value);
}
// make the target link relative
this.MakeOperationTargetRelativeFromMetadataUriIfJsonLight(odataAction);
return true;
}
odataAction = null;
return false;
}
/// <summary>
/// Initializes a new instance of the <see cref="PrimitiveValueMaterializationPolicy" /> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="lazyPrimitivePropertyConverter">The lazy primitive property converter.</param>
internal PrimitiveValueMaterializationPolicy(IODataMaterializerContext context, SimpleLazy <PrimitivePropertyConverter> lazyPrimitivePropertyConverter)
{
this.context = context;
this.lazyPrimitivePropertyConverter = lazyPrimitivePropertyConverter;
}
public GeBoAPI()
{
_autoTranslationHelper = new SimpleLazy <IAutoTranslationHelper>(AutoTranslationHelperLoader);
}
