public Index(File file, string name, BiosParameterBlock bpb, UpperCase upCase)
{
_file = file;
_name = name;
_bpb = bpb;
_isFileIndex = name == "$I30";
_blockCache = new ObjectCache<long, IndexBlock>();
_root = _file.GetStream(AttributeType.IndexRoot, _name).GetContent<IndexRoot>();
_comparer = _root.GetCollator(upCase);
using (Stream s = _file.OpenStream(AttributeType.IndexRoot, _name, FileAccess.Read))
{
byte[] buffer = Utilities.ReadFully(s, (int)s.Length);
_rootNode = new IndexNode(WriteRootNodeToDisk, 0, this, true, buffer, IndexRoot.HeaderOffset);
// Give the attribute some room to breathe, so long as it doesn't squeeze others out
// BROKEN, BROKEN, BROKEN - how to figure this out? Query at the point of adding entries to the root node?
_rootNode.TotalSpaceAvailable += _file.MftRecordFreeSpace(AttributeType.IndexRoot, _name) - 100;
}
if (_file.StreamExists(AttributeType.IndexAllocation, _name))
{
_indexStream = _file.OpenStream(AttributeType.IndexAllocation, _name, FileAccess.ReadWrite);
}
if (_file.StreamExists(AttributeType.Bitmap, _name))
{
_indexBitmap = new Bitmap(_file.OpenStream(AttributeType.Bitmap, _name, FileAccess.ReadWrite), long.MaxValue);
}
}
public ReflectionOnlyAssemblyLoader(ObjectCache cache, IEnumerable<string> assemblyLocation)
{
this._cache = cache;
this._locations = assemblyLocation.ToArray();
this._loadedAssemblies = new HashSet<Assembly>();
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += this.OnFailedAssemblyResolve;
}
public FilterContext(ObjectCache cache, CompositionContainer container, FilterState state, params IAssetFilter[] filters)
{
this.Container = container;
this.Cache = cache;
this.State = state;
this._filters = filters;
}
public ChannelAdvisorServicesFactory( string developerKey, string developerPassword, ObjectCache cache, TimeSpan slidingCacheExpiration )
{
this._developerPassword = developerPassword;
this._developerKey = developerKey;
this._cache = cache;
this._slidingCacheExpiration = slidingCacheExpiration;
}
public FilterContext(ObjectCache cache, CompositionContainer container, IAssetResolver assetResolver, FilterState state)
{
this.Container = container;
this.Cache = cache;
this.AssetResolver = assetResolver;
this.State = state;
}
public CacheUnorderedNeuralVectorProvider(IUnorderedNeuralVectorsProvider baseProvider, ObjectCache cache = null)
{
Contract.Requires(baseProvider != null);
BaseProvider = baseProvider;
this.cache = cache ?? MemoryCache.Default;
}
public AssetOutputManager(IHtmlBuilder htmlBuilder, IEnumerable<IProcessor> processors, IAssetManagerSettings settings)
{
_htmlBuilder = htmlBuilder;
_settings = settings;
_processors = processors ?? new List<IProcessor>();
_cache = AssetManager.Settings.CacheFactory.GetCache();
}
public static void RegisterCacheInfrastructure(IKernel kernel, ObjectCache cache, ICacheKeyRegistrationService cacheKeyRegistrationService)
{
kernel.Bind<ICacheKeyGenerationService>().To<CacheKeyGenerationService>();
kernel.Bind<ICacheKeyRegistrationService>().ToConstant(cacheKeyRegistrationService);
kernel.Bind<ObjectCache>().ToConstant(cache);
}
/// <summary>
/// Adds the Cash-specific registrations to the Autofac container builder.
/// </summary>
/// <param name="builder">The Autofac <see cref="ContainerBuilder"/></param>
/// <param name="cacheProvider">The <see cref="ObjectCache"/> instance to use as a cache provider.</param>
/// <param name="registrationService">The <see cref="ICacheKeyRegistrationService"/> that contains the registrations for this solution. </param>
public static void RegisterCacheInfrastructure(ContainerBuilder builder, ObjectCache cacheProvider, ICacheKeyRegistrationService registrationService)
{
builder.Register(x => cacheProvider).As<ObjectCache>().SingleInstance();
builder.RegisterType<CacheKeyGenerationService>().As<ICacheKeyGenerationService>().SingleInstance();
builder.Register(x => registrationService).As<ICacheKeyRegistrationService>().SingleInstance();
builder.Register(c => new CachingInterceptor(c.Resolve<ObjectCache>(), c.Resolve<ICacheKeyGenerationService>())).InstancePerDependency();
}
public Template(CompositionContainer container)
{
this._cache = new MemoryCache("TemplateCache");
this._fileResolver = new FileResolver();
this._resolvers = new List<IAssetUriResolver>();
this._resolvers.Add(this._fileResolver);
this._resolvers.Add(new MsdnResolver());
this._container = container;
}
/// <summary>
/// full constructor
/// </summary>
/// <param name="region"></param>
/// <param name="properties">cache configuration properties</param>
/// <remarks>
/// There are two (2) configurable parameters:
/// <ul>
/// <li>expiration = number of seconds to wait before expiring each item</li>
/// <li>priority = a numeric cost of expiring each item, where 1 is a low cost, 5 is the highest, and 3 is normal. Only values 1 through 5 are valid.</li>
/// </ul>
/// All parameters are optional. The defaults are an expiration of 300 seconds and the default priority of 3.
/// </remarks>
/// <exception cref="IndexOutOfRangeException">The "priority" property is not between 1 and 5</exception>
/// <exception cref="ArgumentException">The "expiration" property could not be parsed.</exception>
public RtMemoryCache(string region, IDictionary<string,string> properties)
{
this.region = region;
cache = MemoryCache.Default;
Configure(properties);
rootCacheKey = GenerateRootCacheKey();
StoreRootCacheKey();
}
public Template(IFileProvider fileProvider)
{
this._cache = new MemoryCache("TemplateCache");
this._fileProvider = fileProvider;
this._fileResolver = new FileResolver();
this._resolvers = new List<IAssetUriResolver>();
this._resolvers.Add(this._fileResolver);
this._resolvers.Add(new MsdnResolver());
}
/// <summary>
/// Initializes a new instance of the <see cref="InternalSegmentStream"/> class.
/// </summary>
/// <param name="objectCache">The object cache.</param>
/// <param name="key">The key.</param>
/// <param name="segmentSize">Size of the segment.</param>
/// <param name="region">The region.</param>
public InternalSegmentStream(ObjectCache objectCache, string key, int segmentSize, string region)
{
_segmentSize = segmentSize;
_cache = objectCache;
_regionKey = new RegionKey { Key = key, Region = region };
_canRead = true;
_canWrite = true;
_canSeek = true;
}
public CSharpCodeChecker(ObjectCache compiledCustomCheckersCache)
{
if (compiledCustomCheckersCache == null)
{
throw new ArgumentNullException(nameof(compiledCustomCheckersCache));
}
this.compiledCustomCheckersCache = compiledCustomCheckersCache;
}
/// <summary>
/// Creates a new instance from a stream.
/// </summary>
/// <param name="stream">The stream containing the NTFS file system</param>
public NtfsFileSystem(Stream stream)
: base(new NtfsOptions())
{
_context = new NtfsContext();
_context.RawStream = stream;
_context.Options = NtfsOptions;
_context.GetFileByIndex = GetFile;
_context.GetFileByRef = GetFile;
_context.GetDirectoryByRef = GetDirectory;
_context.GetDirectoryByIndex = GetDirectory;
_context.AllocateFile = AllocateFile;
_context.ForgetFile = ForgetFile;
_context.ReadOnly = !stream.CanWrite;
_fileCache = new ObjectCache<long, File>();
stream.Position = 0;
byte[] bytes = Utilities.ReadFully(stream, 512);
_context.BiosParameterBlock = BiosParameterBlock.FromBytes(bytes, 0);
// Bootstrap the Master File Table
_context.Mft = new MasterFileTable(_context);
File mftFile = new File(_context, _context.Mft.GetBootstrapRecord());
_fileCache[MasterFileTable.MftIndex] = mftFile;
_context.Mft.Initialize(mftFile);
// Initialize access to the other well-known metadata files
_context.ClusterBitmap = new ClusterBitmap(GetFile(MasterFileTable.BitmapIndex));
_context.AttributeDefinitions = new AttributeDefinitions(GetFile(MasterFileTable.AttrDefIndex));
_context.UpperCase = new UpperCase(GetFile(MasterFileTable.UpCaseIndex));
_context.SecurityDescriptors = new SecurityDescriptors(GetFile(MasterFileTable.SecureIndex));
_context.ObjectIds = new ObjectIds(GetFile(GetDirectoryEntry(@"$Extend\$ObjId").Reference));
_context.ReparsePoints = new ReparsePoints(GetFile(GetDirectoryEntry(@"$Extend\$Reparse").Reference));
_context.Quotas = new Quotas(GetFile(GetDirectoryEntry(@"$Extend\$Quota").Reference));
File volumeInfoFile = GetFile(MasterFileTable.VolumeIndex);
_volumeInfo = volumeInfoFile.GetStream(AttributeType.VolumeInformation, null).GetContent<VolumeInformation>();
#if false
byte[] buffer = new byte[1024];
for (int i = 0; i < buffer.Length; ++i)
{
buffer[i] = 0xFF;
}
using (Stream s = OpenFile("$LogFile", FileMode.Open, FileAccess.ReadWrite))
{
while (s.Position != s.Length)
{
s.Write(buffer, 0, (int)Math.Min(buffer.Length, s.Length - s.Position));
}
}
#endif
}
/// <summary>
/// Initializes a new instance of the <see cref="ObjectCacheAmbientContextManager" /> class.
/// </summary>
/// <param name="cache">The cache.</param>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="cache"/> is null.</exception>
public ObjectCacheAmbientContextManager(ObjectCache cache)
{
if (cache == null)
{
throw new ArgumentNullException("cache");
}
_Cache = cache;
}
public DocGenerator()
{
this._assemblyPaths = new List<string>();
this._filters = new List<IAssetFilter>();
this._enrichers = new List<IEnricher>();
this.Enrichers.Add(new AttributeDataEnricher());
this.AssetFilters.Add(new EnumMetadataFilter());
this._cache = new MemoryCache("DocGeneratorCache");
}
public AutoChartingService(ILogger logger,
IConfigurationService configurationService,
ITradeIdeasStorage tradeIdeasStorage,
ObjectCache cache)
{
_logger = logger;
_cache = cache;
_configurationService = configurationService;
_tradeIdeasStorage = tradeIdeasStorage;
}
public CachedLifetime(ObjectCache cache, CacheItemPolicy policy)
{
if (cache == null)
throw new ArgumentNullException("cache");
if (policy == null)
throw new ArgumentNullException("policy");
_cache = cache;
_cachePolicy = policy;
}
public AuthorizationService(IRepository<User> users, IRepository<Activity> activities,
IRepository<Permission> permissions, IRepository<Group> groups,
ObjectCache cache)
{
_users = users;
_activities = activities;
_permissions = permissions;
_groups = groups;
_cache = cache;
}
public RoutineManager(ITransaction transaction)
{
if (transaction == null)
throw new ArgumentNullException("transaction");
routinesCache = new ObjectCache<IRoutine>();
this.transaction = transaction;
this.transaction.Context.RouteImmediate<TransactionEvent>(OnTransactionEnd, e => e.EventType != TransactionEventType.Begin);
}
void Reload()
{
MemoryStream ms = new MemoryStream();
Cache.Save(ms);
ms.Position = 0;
Cache = new ObjectCache();
Cache.Load(ms);
}
public RssParserService(ILogger logger,
IConfigurationService configurationService,
INewsStorage newsStorage,
ObjectCache cache)
{
_logger = logger;
_cache = cache;
_configurationService = configurationService;
_newsStorage = newsStorage;
}
public ProcessingContext(ObjectCache cache, CompositionContainer container, IEnumerable<IAssetFilter> filters, IAssemblyLoader assemblyLoader, IAssetResolver assetResolver, XElement element, HashSet<AssetIdentifier> references, int phase)
{
this._filters = filters.ToArray();
this.AssetResolver = assetResolver;
this.Element = element;
this._references = references;
Container = container;
this.Phase = phase;
this.Cache = cache;
this.AssemblyLoader = assemblyLoader;
}
public CacheEntryRemovedArguments(ObjectCache source, CacheEntryRemovedReason reason, CacheItem cacheItem) {
if (source == null) {
throw new ArgumentNullException("source");
}
if (cacheItem == null) {
throw new ArgumentNullException("cacheItem");
}
_source = source;
_reason = reason;
_cacheItem = cacheItem;
}
public File(INtfsContext context, FileRecord baseRecord)
{
_context = context;
_mft = _context.Mft;
_records = new List<FileRecord>();
_records.Add(baseRecord);
_indexCache = new ObjectCache<string, Index>();
_attributes = new List<NtfsAttribute>();
LoadAttributes();
}
public CacheEntryRemovedArguments (ObjectCache source, CacheEntryRemovedReason reason, CacheItem cacheItem)
{
if (source == null)
throw new ArgumentNullException ("source");
if (cacheItem == null)
throw new ArgumentNullException ("cacheItem");
this.CacheItem = cacheItem;
this.RemovedReason = reason;
this.Source = source;
}
public void GetByIDTest()
{
ObjectCache target = new ObjectCache(_DOFactory);
Assert.Null( target.GetByID(1));
//GetByID with a type argument should return an object and added it to the cache
SaleDO tempSale = target.GetByID<SaleDO>(1) as SaleDO;
Assert.NotNull(tempSale);
Assert.NotNull(target.GetByID(1));
}
public CacheEntryUpdateArguments(ObjectCache source, CacheEntryRemovedReason reason, String key, String regionName) {
if (source == null) {
throw new ArgumentNullException("source");
}
if (key == null) {
throw new ArgumentNullException("key");
}
_source = source;
_reason = reason;
_key = key;
_regionName = regionName;
}
public static DefaultCacheProvider GetInstance()
{
lock (locker)
{
if (instance == null)
{
instance = new DefaultCacheProvider();
cache = MemoryCache.Default;
}
}
return instance;
}
public static IAlteredPipeline <TRequest, TResponse> WithAlteredCache <TRequest, TResponse>(this IAlteredPipeline <TRequest, TResponse> f, Func <TRequest, string> getKey, CacheItemPolicy cacheItemPolicy = null, ObjectCache cache = null, AsyncLock cacheLock = null)
where TResponse : class
{
cache = cache ?? MemoryCache.Default;
cacheItemPolicy = cacheItemPolicy ?? DefaultCacheItemPolicy;
cacheLock = cacheLock ?? new AsyncLock();
return(new AlteredCache <TRequest, TResponse>(f, getKey, cacheItemPolicy, cache, cacheLock));
}
public AlteredCache(IAlteredPipeline <TRequest, TResponse> f, Func <TRequest, string> getKey, CacheItemPolicy cacheItemPolicy, ObjectCache cache, AsyncLock cacheLock) : base(async(request) =>
{
var key = $"{f.GetType().GUID}:{getKey(request)}";
using (await cacheLock.LockAsync())
{
var response = cache.Get(key) as TResponse;
if (response == null)
{
response = await f.Execute(request);
cache.AddOrGetExisting(key, response, cacheItemPolicy);
}
return(response);
}
})
{
}
private static object GetOneToOneChild <T>(this SQLiteConnection conn, T element,
PropertyInfo relationshipProperty,
bool recursive, ObjectCache objectCache)
{
var type = element.GetType();
EnclosedType enclosedType;
var entityType = relationshipProperty.GetEntityType(out enclosedType);
Assert(enclosedType == EnclosedType.None, type, relationshipProperty, "OneToOne relationship cannot be of type List or Array");
var currentEntityPrimaryKeyProperty = type.GetPrimaryKey();
var otherEntityPrimaryKeyProperty = entityType.GetPrimaryKey();
Assert(currentEntityPrimaryKeyProperty != null || otherEntityPrimaryKeyProperty != null, type, relationshipProperty,
"At least one entity in a OneToOne relationship must have Primary Key");
var currentEntityForeignKeyProperty = type.GetForeignKeyProperty(relationshipProperty);
var otherEntityForeignKeyProperty = type.GetForeignKeyProperty(relationshipProperty, inverse: true);
Assert(currentEntityForeignKeyProperty != null || otherEntityForeignKeyProperty != null, type, relationshipProperty,
"At least one entity in a OneToOne relationship must have Foreign Key");
var hasForeignKey = otherEntityPrimaryKeyProperty != null && currentEntityForeignKeyProperty != null;
var hasInverseForeignKey = currentEntityPrimaryKeyProperty != null && otherEntityForeignKeyProperty != null;
Assert(hasForeignKey || hasInverseForeignKey, type, relationshipProperty,
"Missing either ForeignKey or PrimaryKey for a complete OneToOne relationship");
var tableMapping = conn.GetMapping(entityType);
Assert(tableMapping != null, type, relationshipProperty, "There's no mapping table for OneToOne relationship");
var inverseProperty = type.GetInverseProperty(relationshipProperty);
object value = null;
var isLoadedFromCache = false;
if (hasForeignKey)
{
var foreignKeyValue = currentEntityForeignKeyProperty.GetValue(element, null);
if (foreignKeyValue != null)
{
// Try to load from cache when possible
if (recursive)
{
value = GetObjectFromCache(entityType, foreignKeyValue, objectCache);
}
if (value == null)
{
value = conn.Find(foreignKeyValue, tableMapping);
}
else
{
isLoadedFromCache = true;
}
}
}
else
{
var primaryKeyValue = currentEntityPrimaryKeyProperty.GetValue(element, null);
if (primaryKeyValue != null)
{
var query = string.Format("select * from [{0}] where [{1}] = ? limit 1", entityType.GetTableName(),
otherEntityForeignKeyProperty.GetColumnName());
value = conn.Query(tableMapping, query, primaryKeyValue).FirstOrDefault();
// Its a OneToOne, take only the first
}
// Try to replace the loaded entity with the same object from the cache whenever possible
value = recursive ? ReplaceWithCacheObjectIfPossible(value, otherEntityPrimaryKeyProperty, objectCache, out isLoadedFromCache) : value;
}
relationshipProperty.SetValue(element, value, null);
if (value != null && inverseProperty != null)
{
inverseProperty.SetValue(value, element, null);
}
if (value != null && !isLoadedFromCache && recursive)
{
SaveObjectToCache(value, otherEntityPrimaryKeyProperty.GetValue(value, null), objectCache);
conn.GetChildrenRecursive(value, true, recursive, objectCache);
}
return(value);
}
/// <summary>
/// Get the cache footprint in XML.
/// </summary>
/// <param name="cache">The cache.</param>
/// <param name="expanded">Whether to show details of each entity item.</param>
/// <param name="requestUrl">The request URL.</param>
/// <returns></returns>
public static XmlDocument GetCacheFootprintXml(this ObjectCache cache, bool expanded, Uri requestUrl)
{
var alternateLink = new Uri(requestUrl.GetLeftPart(UriPartial.Path));
var doc = new XmlDocument();
var rootElement = doc.CreateElement("CacheFootprint");
var entityElements = new List <XmlElement>();
var footprint = GetCacheFootprint(cache, alternateLink);
foreach (var entityType in footprint)
{
var entityElement = doc.CreateElement("Entity");
entityElement.SetAttribute("Name", entityType.Name);
entityElement.SetAttribute("Count", entityType.GetCount().ToString());
entityElement.SetAttribute("Size", entityType.GetSize().ToString());
if (expanded)
{
foreach (var item in entityType.Items)
{
var itemElement = doc.CreateElement("Item");
itemElement.SetAttribute("LogicalName", item.Entity.LogicalName);
itemElement.SetAttribute("Name", item.Entity.GetAttributeValueOrDefault("adx_name", String.Empty));
itemElement.SetAttribute("Id", item.Entity.Id.ToString());
var cacheElement = doc.CreateElement("Cache");
cacheElement.SetAttribute("Id", item.CacheItemKey);
cacheElement.SetAttribute("Type", item.CacheItemType.ToString());
cacheElement.SetAttribute("Link", item.Link.ToString());
cacheElement.SetAttribute("Size", GetEntitySizeInMemory(item.Entity).ToString());
itemElement.AppendChild(cacheElement);
entityElement.AppendChild(itemElement);
}
}
entityElements.Add(entityElement);
}
// Sort the entities by descending size
entityElements = entityElements.OrderByDescending(el => int.Parse(el.GetAttribute("Size"))).ToList();
var entitiesElement = doc.CreateElement("Entities");
foreach (var entityElement in entityElements)
{
entitiesElement.AppendChild(entityElement);
}
if (!expanded)
{
// Add link to the Expanded view with entity record details
var query = System.Web.HttpUtility.ParseQueryString(requestUrl.Query);
query[Web.Handlers.CacheFeedHandler.QueryKeys.Expanded] = Boolean.TrueString;
var uriBuilder = new UriBuilder(requestUrl.ToString())
{
Query = query.ToString()
};
var expandedView = doc.CreateElement("expandedView");
expandedView.InnerText = uriBuilder.ToString();
rootElement.AppendChild(expandedView);
}
rootElement.AppendChild(entitiesElement);
doc.AppendChild(rootElement);
return(doc);
}
/// <summary>
/// 初始化一个<see cref="RuntimeMemoryCache"/>类型的新实例
/// </summary>
public RuntimeMemoryCache(string region)
{
_region = region;
_cache = MemoryCache.Default;
}
public static SortedList <long, TKey> History <TKey, TValue>(this ObjectCache <TKey, TValue> cache) where TKey : IEquatable <TKey> where TValue : class
{
return((SortedList <long, TKey>)GetField(cache, "accessHistory").GetValue(cache));
}
private static void GetChildrenRecursive(this SQLiteConnection conn, object element, bool onlyCascadeChildren, bool recursive, ObjectCache objectCache = null)
{
objectCache = objectCache ?? new ObjectCache();
foreach (var relationshipProperty in element.GetType().GetRelationshipProperties())
{
var relationshipAttribute = relationshipProperty.GetAttribute <RelationshipAttribute>();
if (!onlyCascadeChildren || relationshipAttribute.IsCascadeRead)
{
conn.GetChildRecursive(element, relationshipProperty, recursive, objectCache);
}
else if (relationshipAttribute is TextBlobAttribute)
{
conn.GetChildRecursive(element, relationshipProperty, false, objectCache);
}
}
}
public override DbgDotNetValueNode[] GetChildren(LanguageValueNodeFactory valueNodeFactory, DbgEvaluationInfo evalInfo, ulong index, int count, DbgValueNodeEvaluationOptions options)
{
var res = count == 0 ? Array.Empty <DbgDotNetValueNode>() : new DbgDotNetValueNode[count];
DbgDotNetValueResult newValue = default;
try {
var output = ObjectCache.AllocDotNetTextOutput();
var elementType = valueInfo.Value.Type.GetElementType();
var castType = NeedCast(slotType, valueInfo.Value.Type) ? valueInfo.Value.Type : null;
for (int i = 0; i < res.Length; i++)
{
evalInfo.CancellationToken.ThrowIfCancellationRequested();
string expression;
uint arrayIndex = (uint)index + (uint)i;
newValue = valueInfo.Value.GetArrayElementAt(arrayIndex);
if (dimensionInfos.Length == 1)
{
int baseIndex = (int)arrayIndex + dimensionInfos[0].BaseIndex;
expression = valueNodeFactory.GetExpression(valueInfo.Expression, baseIndex, castType, addParens);
owner.FormatArrayName(output, baseIndex);
}
else
{
uint indexLeft = arrayIndex;
for (int j = dimensionInfos.Length - 1; j >= 0; j--)
{
indexes[j] = (int)(indexLeft % dimensionInfos[j].Length) + dimensionInfos[j].BaseIndex;
indexLeft = indexLeft / dimensionInfos[j].Length;
}
expression = valueNodeFactory.GetExpression(valueInfo.Expression, indexes, castType, addParens);
owner.FormatArrayName(output, indexes);
}
var name = output.CreateAndReset();
DbgDotNetValueNode newNode;
if (newValue.HasError)
{
newNode = valueNodeFactory.CreateError(evalInfo, name, newValue.ErrorMessage, expression, false);
}
else
{
newNode = null;
if (CSharpDynamicPropertyHelper.IsCSharpDynamicProperty(newValue.Value.Type))
{
var info = CSharpDynamicPropertyHelper.GetRealValue(evalInfo, newValue.Value);
if (info.name != null)
{
newValue.Value.Dispose();
name = new DbgDotNetText(new DbgDotNetTextPart(BoxedTextColor.DebugViewPropertyName, info.name));
expression = valueNodeFactory.GetFieldExpression(expression, info.valueField.Name, null, false);
newNode = valueNodeFactory.Create(evalInfo, name, info.value, null, options, expression, PredefinedDbgValueNodeImageNames.DynamicViewElement, true, false, info.valueField.FieldType, false);
}
}
if (newNode == null)
{
newNode = valueNodeFactory.Create(evalInfo, name, newValue.Value, null, options, expression, PredefinedDbgValueNodeImageNames.ArrayElement, false, false, elementType, false);
}
}
newValue = default;
res[i] = newNode;
}
ObjectCache.Free(ref output);
}
catch {
evalInfo.Context.Process.DbgManager.Close(res.Where(a => a != null));
newValue.Value?.Dispose();
throw;
}
return(res);
}
TypeState CreateTypeStateCore(DmdType type)
{
var typeExpression = GetTypeExpression(type);
if (HasNoChildren(type) || type.IsFunctionPointer)
{
return(new TypeState(type, typeExpression));
}
MemberValueNodeInfoCollection instanceMembers, staticMembers;
TupleField[] tupleFields;
Debug.Assert(!type.IsByRef);
if (type.TypeSignatureKind == DmdTypeSignatureKind.Type || type.TypeSignatureKind == DmdTypeSignatureKind.GenericInstance)
{
tupleFields = TryCreateTupleFields(type) ?? Array.Empty <TupleField>();
var instanceMembersList = new List <MemberValueNodeInfo>();
var staticMembersList = new List <MemberValueNodeInfo>();
bool instanceHasHideRoot = false;
bool staticHasHideRoot = false;
bool instanceHasShowNever = false;
bool staticHasShowNever = false;
byte inheritanceLevel;
DmdType currentType;
inheritanceLevel = 0;
currentType = type;
foreach (var field in type.Fields)
{
var declType = field.DeclaringType;
while (declType != currentType)
{
Debug2.Assert(!(currentType.BaseType is null));
currentType = currentType.BaseType;
if (inheritanceLevel != byte.MaxValue)
{
inheritanceLevel++;
}
}
var nodeInfo = new MemberValueNodeInfo(field, inheritanceLevel);
if (field.IsStatic)
{
staticHasHideRoot |= nodeInfo.HasDebuggerBrowsableState_RootHidden;
staticHasShowNever |= nodeInfo.HasDebuggerBrowsableState_Never;
staticMembersList.Add(nodeInfo);
}
else
{
instanceHasHideRoot |= nodeInfo.HasDebuggerBrowsableState_RootHidden;
instanceHasShowNever |= nodeInfo.HasDebuggerBrowsableState_Never;
instanceMembersList.Add(nodeInfo);
}
}
inheritanceLevel = 0;
currentType = type;
foreach (var property in type.Properties)
{
if (property.GetMethodSignature().GetParameterTypes().Count != 0)
{
continue;
}
var declType = property.DeclaringType;
while (declType != currentType)
{
Debug2.Assert(!(currentType.BaseType is null));
currentType = currentType.BaseType;
if (inheritanceLevel != byte.MaxValue)
{
inheritanceLevel++;
}
}
var getter = property.GetGetMethod(DmdGetAccessorOptions.All);
if (getter is null || getter.GetMethodSignature().GetParameterTypes().Count != 0)
{
continue;
}
var nodeInfo = new MemberValueNodeInfo(property, inheritanceLevel);
if (getter.IsStatic)
{
staticHasHideRoot |= nodeInfo.HasDebuggerBrowsableState_RootHidden;
staticHasShowNever |= nodeInfo.HasDebuggerBrowsableState_Never;
staticMembersList.Add(nodeInfo);
}
else
{
instanceHasHideRoot |= nodeInfo.HasDebuggerBrowsableState_RootHidden;
instanceHasShowNever |= nodeInfo.HasDebuggerBrowsableState_Never;
instanceMembersList.Add(nodeInfo);
}
}
var instanceMembersArray = InitializeOverloadedMembers(instanceMembersList.ToArray());
var staticMembersArray = InitializeOverloadedMembers(staticMembersList.ToArray());
instanceMembers = instanceMembersList.Count == 0 ? MemberValueNodeInfoCollection.Empty : new MemberValueNodeInfoCollection(instanceMembersArray, instanceHasHideRoot, instanceHasShowNever);
staticMembers = staticMembersList.Count == 0 ? MemberValueNodeInfoCollection.Empty : new MemberValueNodeInfoCollection(staticMembersArray, staticHasHideRoot, staticHasShowNever);
Array.Sort(instanceMembers.Members, MemberValueNodeInfoEqualityComparer.Instance);
Array.Sort(staticMembers.Members, MemberValueNodeInfoEqualityComparer.Instance);
var output = ObjectCache.AllocDotNetTextOutput();
UpdateNames(instanceMembers.Members, output);
UpdateNames(staticMembers.Members, output);
ObjectCache.Free(ref output);
}
else
{
staticMembers = instanceMembers = MemberValueNodeInfoCollection.Empty;
tupleFields = Array.Empty <TupleField>();
}
return(new TypeState(type, typeExpression, instanceMembers, staticMembers, tupleFields));
}
/// <summary>
/// Initializes a new instance of the <see cref="TradeTickSerializer"/> class.
/// </summary>
public TradeTickSerializer()
{
this.cachedSymbols = new ObjectCache <string, Symbol>(Symbol.FromString);
}
///<summary>
///Updates SNO Cache Values
///</summary>
public virtual bool UpdateData(DiaObject thisObj, int raguid)
{
bool failureDuringUpdate = false;
if (InternalName == null)
{
try
{
InternalName = thisObj.Name;
}
catch
{
Logger.Write(LogLevel.Cache, "Failure to get internal name on object, SNO {0}", SNOID);
return(false);
}
}
if (!Actortype.HasValue)
{
#region ActorType
try
{
Actortype = thisObj.ActorType;
}
catch
{
Logger.Write(LogLevel.Cache, "Failure to get actorType for object, SNO: {0}", SNOID);
return(false);
}
#endregion
}
//Ignored actor types..
if (BlacklistCache.IgnoredActorTypes.Contains(Actortype.Value)) //||!LootBehaviorEnabled&&this.Actortype.Value==ActorType.Item)
{
BlacklistCache.IgnoreThisObject(this, raguid);
return(false);
}
if (!targetType.HasValue)
{
#region EvaluateTargetType
try
{
//Evaluate Target Type..
// See if it's an avoidance first from the SNO
if (IsAvoidance || IsObstacle)
{
targetType = TargetType.None;
if (IsAvoidance)
{
if (IsProjectileAvoidance)
{
Obstacletype = ObstacleType.MovingAvoidance;
}
else
{
Obstacletype = ObstacleType.StaticAvoidance;
}
AvoidanceType AT = AvoidanceCache.FindAvoidanceUsingSNOID(SNOID);
//Check if avoidance is enabled or if the avoidance type is set to 0
if (!Bot.Settings.Avoidance.AttemptAvoidanceMovements || AT != AvoidanceType.None && AvoidanceCache.IgnoringAvoidanceType(AT))
{
BlacklistCache.AddObjectToBlacklist(raguid, BlacklistType.Temporary);
return(false);
}
// Avoidance isn't disabled, so set this object type to avoidance
targetType = TargetType.Avoidance;
}
else
{
Obstacletype = ObstacleType.ServerObject;
}
}
else
{
// Calculate the object type of this object
if (Actortype.Value == ActorType.Monster ||
CacheIDLookup.hashActorSNOForceTargetUnit.Contains(SNOID))
{
targetType = TargetType.Unit;
Obstacletype = ObstacleType.Monster;
if (CacheIDLookup.hashActorSNOForceTargetUnit.Contains(SNOID))
{
//Fill in monster data?
Actortype = ActorType.Monster;
}
}
else if (Actortype.Value == ActorType.Item ||
CacheIDLookup.hashForceSNOToItemList.Contains(SNOID))
{
string testname = InternalName.ToLower();
//Check if this item is gold/globe..
if (testname.StartsWith("gold"))
{
targetType = TargetType.Gold;
}
else if (testname.StartsWith("healthglobe"))
{
targetType = TargetType.Globe;
}
else if (testname.StartsWith("console_powerglobe"))
{
targetType = TargetType.PowerGlobe;
}
else
{
targetType = TargetType.Item;
}
//Gold/Globe?
}
else if (Actortype.Value == ActorType.Gizmo)
{
GizmoType thisGizmoType;
try
{
thisGizmoType = thisObj.ActorInfo.GizmoType;
}
catch
{
Logger.Write(LogLevel.Cache, "Failure to get actor Gizmo Type!");
return(false);
}
if (thisGizmoType == GizmoType.DestroyableObject || thisGizmoType == GizmoType.BreakableChest)
{
targetType = TargetType.Destructible;
}
else if (thisGizmoType == GizmoType.PowerUp || thisGizmoType == GizmoType.HealingWell || thisGizmoType == GizmoType.PoolOfReflection)
{
targetType = TargetType.Shrine;
}
else if (thisGizmoType == GizmoType.Chest)
{
targetType = TargetType.Container;
}
else if (thisGizmoType == GizmoType.BreakableDoor)
{
targetType = TargetType.Barricade;
}
else if (thisGizmoType == GizmoType.Door)
{
targetType = TargetType.Door;
}
else if (thisGizmoType == GizmoType.Waypoint || thisGizmoType == GizmoType.Portal || thisGizmoType == GizmoType.DungeonPortal || thisGizmoType == GizmoType.BossPortal)
{ //Special Interactive Object -- Add to special cache!
targetType = TargetType.ServerInteractable;
}
else if (thisGizmoType == GizmoType.Switch)
{
targetType = TargetType.CursedShrine;
}
else
{ //All other gizmos should be ignored!
BlacklistCache.IgnoreThisObject(this, raguid);
return(false);
}
if (targetType.HasValue)
{
if (targetType.Value == TargetType.Destructible || targetType.Value == TargetType.Barricade || targetType.Value == TargetType.Door)
{
Obstacletype = ObstacleType.Destructable;
}
else if (targetType.Value == TargetType.Shrine || IsChestContainer)
{
Obstacletype = ObstacleType.ServerObject;
}
}
if (!Gizmotype.HasValue)
{
Gizmotype = thisGizmoType;
}
}
else if (CacheIDLookup.hashSNOInteractWhitelist.Contains(SNOID))
{
targetType = TargetType.Interactable;
}
else if (Actortype.Value == ActorType.ServerProp)
{
string TestString = InternalName.ToLower();
//Server props with Base in name are the destructibles "remains" which is considered an obstacle!
if (TestString.Contains("base") || TestString.Contains("fence"))
{
//Add this to the obstacle navigation cache
if (!IsObstacle)
{
CacheIDLookup.hashSNONavigationObstacles.Add(SNOID);
}
Obstacletype = ObstacleType.ServerObject;
//Use unknown since we lookup SNO ID for server prop related objects.
targetType = TargetType.None;
}
else if (TestString.StartsWith("monsteraffix_"))
{
AvoidanceType T = AvoidanceCache.FindAvoidanceUsingName(TestString);
if (T == AvoidanceType.Wall)
{
//Add this to the obstacle navigation cache
if (!IsObstacle)
{
CacheIDLookup.hashSNONavigationObstacles.Add(SNOID);
}
Obstacletype = ObstacleType.ServerObject;
//Use unknown since we lookup SNO ID for server prop related objects.
targetType = TargetType.None;
}
//else if (Bot.AvoidancesHealth.ContainsKey(T))
//{
// Logger.DBLog.InfoFormat("Found Avoidance not recongized by SNO! Name {0} SNO {1}", TestString, this.SNOID);
// CacheIDLookup.hashAvoidanceSNOList.Add(this.SNOID);
// this.targetType=TargetType.Avoidance;
//}
else
{
//Blacklist all other monster affixes
BlacklistCache.IgnoreThisObject(this, raguid);
return(false);
}
}
else
{
BlacklistCache.IgnoreThisObject(this, raguid);
return(false);
}
}
else
{ //Misc?? Ignore it!
BlacklistCache.IgnoreThisObject(this, raguid);
return(false);
}
}
}
catch
{
Logger.Write(LogLevel.Cache, "Failure to get actorType for object, SNO: {0}", SNOID);
return(false);
}
#endregion
}
if (!Obstacletype.HasValue)
{
Obstacletype = ObstacleType.None;
}
if (ObjectCache.CheckTargetTypeFlag(targetType.Value, TargetType.Unit))
{
SNORecordMonster monsterInfo;
try
{
monsterInfo = thisObj.CommonData.MonsterInfo;
}
catch
{
Logger.Write(LogLevel.Cache, "Safely Handled MonsterInfo Exception for Object {0}", InternalName);
return(false);
}
if (!Monstertype.HasValue || ShouldRefreshMonsterType)
{
#region MonsterType
try
{
Monstertype = monsterInfo.MonsterType;
}
catch
{
Logger.Write(LogLevel.Cache, "Failure to get MonsterType for SNO: {0}", SNOID);
failureDuringUpdate = true;
}
#endregion
}
if (!Monstersize.HasValue)
{
#region MonsterSize
try
{
Monstersize = monsterInfo.MonsterSize;
}
catch
{
Logger.Write(LogLevel.Cache, "Failure to get MonsterSize for SNO: {0}", SNOID);
failureDuringUpdate = true;
}
#endregion
}
}
if (Actortype.HasValue && targetType.HasValue &&
(Actortype.Value != ActorType.Item && targetType.Value != TargetType.Avoidance && targetType.Value != TargetType.ServerInteractable))
{
//Validate sphere info
Sphere sphereInfo = thisObj.CollisionSphere;
if (!CollisionRadius.HasValue)
{
#region CollisionRadius
try
{
CollisionRadius = sphereInfo.Radius;
}
catch
{
Logger.Write(LogLevel.Cache, "Failure to get CollisionRadius for SNO: {0}", SNOID);
failureDuringUpdate = true;
}
#endregion
if (CacheIDLookup.dictFixedCollisionRadius.ContainsKey(SNOID))
{ //Override The Default Collision Sphere Value
CollisionRadius = CacheIDLookup.dictFixedCollisionRadius[SNOID];
}
}
if (!ActorSphereRadius.HasValue)
{
#region ActorSphereRadius
try
{
ActorSphereRadius = thisObj.ActorInfo.Sphere.Radius;
}
catch
{
Logger.Write(LogLevel.Cache, "Safely handled getting attribute Sphere radius for gizmo {0}", InternalName);
failureDuringUpdate = true;
}
#endregion
}
#region GizmoProperties
if (ObjectCache.CheckTargetTypeFlag(targetType.Value, TargetType.Destructible | TargetType.Interactable))
{
//No Loot
if (!DropsNoLoot.HasValue)
{
#region DropsNoLoot
try
{
DropsNoLoot = thisObj.CommonData.GetAttribute <float>(ActorAttributeType.DropsNoLoot) <= 0;
}
catch
{
Logger.Write(LogLevel.Cache, "Safely handled reading DropsNoLoot for gizmo {0}", InternalName);
failureDuringUpdate = true;
}
#endregion
}
//No XP
if (!GrantsNoXP.HasValue)
{
#region GrantsNoXP
try
{
GrantsNoXP = thisObj.CommonData.GetAttribute <float>(ActorAttributeType.GrantsNoXP) <= 0;
}
catch
{
Logger.Write(LogLevel.Cache, "Safely handled reading GrantsNoXp for gizmo {0}", InternalName);
failureDuringUpdate = true;
}
#endregion
}
//Barricade flag
if (!IsBarricade.HasValue)
{
#region Barricade
try
{
IsBarricade = ((DiaGizmo)thisObj).IsBarricade;
}
catch
{
Logger.Write(LogLevel.Cache, "Safely handled getting attribute IsBarricade for gizmo {0}", InternalName);
failureDuringUpdate = true;
}
#endregion
}
}
#endregion
}
return(!failureDuringUpdate);
}
public static long CurrentAccessCount <TKey, TValue>(this ObjectCache <TKey, TValue> cache) where TKey : IEquatable <TKey> where TValue : class
{
return((long)GetField(cache, "currentAccessCount").GetValue(cache));
}
public static Dictionary <TKey, TValue> Cache <TKey, TValue>(this ObjectCache <TKey, TValue> cache) where TKey : IEquatable <TKey> where TValue : class
{
return((Dictionary <TKey, TValue>)GetField(cache, "cache").GetValue(cache));
}
public RuntimeMemoryCache()
{
this._cache = MemoryCache.Default;
}
public OtherService(ISessionFactory sessionFactory, IUserPermissionContext permissionContext, IEntryLinkFactory entryLinkFactory,
IUserIconFactory userIconFactory, EntryForApiContractFactory entryForApiContractFactory, ObjectCache cache)
: base(sessionFactory, permissionContext, entryLinkFactory)
{
this.userIconFactory = userIconFactory;
this.entryForApiContractFactory = entryForApiContractFactory;
this.cache = cache;
}
private static IEnumerable GetManyToManyChildren <T>(this SQLiteConnection conn, T element,
PropertyInfo relationshipProperty,
bool recursive, ObjectCache objectCache)
{
var type = element.GetType();
EnclosedType enclosedType;
var entityType = relationshipProperty.GetEntityType(out enclosedType);
var currentEntityPrimaryKeyProperty = type.GetPrimaryKey();
var otherEntityPrimaryKeyProperty = entityType.GetPrimaryKey();
var manyToManyMetaInfo = type.GetManyToManyMetaInfo(relationshipProperty);
var currentEntityForeignKeyProperty = manyToManyMetaInfo.OriginProperty;
var otherEntityForeignKeyProperty = manyToManyMetaInfo.DestinationProperty;
var intermediateType = manyToManyMetaInfo.IntermediateType;
var tableMapping = conn.GetMapping(entityType);
Assert(enclosedType != EnclosedType.None, type, relationshipProperty, "ManyToMany relationship must be a List or Array");
Assert(currentEntityPrimaryKeyProperty != null, type, relationshipProperty, "ManyToMany relationship origin must have Primary Key");
Assert(otherEntityPrimaryKeyProperty != null, type, relationshipProperty, "ManyToMany relationship destination must have Primary Key");
Assert(intermediateType != null, type, relationshipProperty, "ManyToMany relationship intermediate type cannot be null");
Assert(currentEntityForeignKeyProperty != null, type, relationshipProperty, "ManyToMany relationship origin must have a foreign key defined in the intermediate type");
Assert(otherEntityForeignKeyProperty != null, type, relationshipProperty, "ManyToMany relationship destination must have a foreign key defined in the intermediate type");
Assert(tableMapping != null, type, relationshipProperty, "There's no mapping table defined for ManyToMany relationship origin");
IList cascadeElements = new List <object>();
IList values = null;
var primaryKeyValue = currentEntityPrimaryKeyProperty.GetValue(element, null);
if (primaryKeyValue != null)
{
// Obtain the relationship keys
var keysQuery = string.Format("select [{0}] from [{1}] where [{2}] = ?", otherEntityForeignKeyProperty.GetColumnName(),
intermediateType.GetTableName(), currentEntityForeignKeyProperty.GetColumnName());
var query = string.Format("select * from [{0}] where [{1}] in ({2})", entityType.GetTableName(),
otherEntityPrimaryKeyProperty.GetColumnName(), keysQuery);
var queryResults = conn.Query(tableMapping, query, primaryKeyValue);
Array array = null;
// Create a generic list of the expected type
if (enclosedType == EnclosedType.List)
{
values = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(entityType));
}
else if (enclosedType == EnclosedType.ObservableCollection)
{
values = (IList)Activator.CreateInstance(typeof(ObservableCollection <>).MakeGenericType(entityType));
}
else
{
values = array = Array.CreateInstance(entityType, queryResults.Count);
}
int i = 0;
foreach (var result in queryResults)
{
// Replace obtained value with a cached one whenever possible
bool loadedFromCache = false;
var value = recursive ? ReplaceWithCacheObjectIfPossible(result, otherEntityPrimaryKeyProperty, objectCache, out loadedFromCache) : result;
if (array != null)
{
array.SetValue(value, i);
}
else
{
values.Add(value);
}
if (!loadedFromCache)
{
cascadeElements.Add(result);
}
i++;
}
}
relationshipProperty.SetValue(element, values, null);
if (recursive)
{
foreach (var child in cascadeElements)
{
conn.GetChildrenRecursive(child, true, recursive, objectCache);
}
}
return(values);
}
private static int Run(string preferencesFileName)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Messager.Caption = "Document Converter Demo";
// Initialize Trace
Trace.Listeners.Add(new TextWriterTraceListener(Console.Out));
Console.WriteLine("LEADTOOLS " + Messager.Caption);
DocumentConverterPreferences preferences;
ConvertRedactionOptions convertRedactionOptions = null;
if (!string.IsNullOrEmpty(preferencesFileName))
{
// Load it from the file specified by the user
preferences = DocumentConverterPreferences.Load(preferencesFileName);
preferences.IsSilentMode = true;
}
else
{
// Load the preferences file
DocumentConverterPreferences.DemoName = "Document Converter Demo";
DocumentConverterPreferences.XmlFileName = "DocumentConverterDemo";
preferences = DocumentConverterPreferences.Load();
preferences.IsSilentMode = false;
}
if (!Support.SetLicense(preferences.IsSilentMode))
{
if (preferences.IsSilentMode)
{
throw new Exception("Your license file is missing, invalid or expired.");
}
return(-1);
}
// Create the rendering engine
try
{
if (preferences.AnnRenderingEngine == null)
{
preferences.AnnRenderingEngine = new AnnWinFormsRenderingEngine();
preferences.AnnRenderingEngine.Resources = Tools.LoadResources();
}
}
catch { }
if (!preferences.IsSilentMode)
{
// Show the OCR engine selection dialog to startup the OCR engine
Trace.WriteLine("Starting OCR engine");
var engineType = preferences.OCREngineType;
using (var dlg = new OcrEngineSelectDialog(DocumentConverterPreferences.DemoName, engineType.ToString(), true))
{
dlg.AllowNoOcr = true;
dlg.AllowNoOcrMessage = "The demo runs without OCR functionality but you will not be able to parse text from non-document files such as TIFF or Raster PDF. Click 'Cancel' to start this demo without an OCR engine.";
if (dlg.ShowDialog() == DialogResult.OK)
{
preferences.OcrEngineInstance = dlg.OcrEngine;
preferences.OCREngineType = dlg.OcrEngine.EngineType;
Trace.WriteLine(string.Format("OCR engine {0} started", preferences.OCREngineType));
}
}
}
else
{
// Initialize the default OCR engine
preferences.OcrEngineInstance = InitOcrEngine(preferences);
}
// Initialize the RasterCodecs instance
var rasterCodecs = new RasterCodecs();
rasterCodecs.Options = DocumentFactory.RasterCodecsTemplate.Options.Clone();
preferences.RasterCodecsInstance = rasterCodecs;
if (!string.IsNullOrEmpty(preferences.RasterCodecsOptionsPath))
{
preferences.RasterCodecsInstance.LoadOptions(preferences.RasterCodecsOptionsPath);
}
// Initialize the DocumentWriter instance
preferences.DocumentWriterInstance = new DocumentWriter();
if (!string.IsNullOrEmpty(preferences.DocumentWriterOptionsPath))
{
preferences.DocumentWriterInstance.LoadOptions(preferences.DocumentWriterOptionsPath);
}
// Cache to use
ObjectCache cache = null;
// Initialize the cache
if (!string.IsNullOrEmpty(preferences.CacheDirectory))
{
var fileCache = new FileCache();
fileCache.CacheDirectory = preferences.CacheDirectory;
fileCache.DataSerializationMode = preferences.CacheDataSerializationMode;
fileCache.PolicySerializationMode = preferences.CachePolicySerializationMode;
cache = fileCache;
}
// Do conversions
var more = true;
while (more)
{
Console.WriteLine("Obtaining conversion options");
if (!preferences.IsSilentMode)
{
// Collect the options
using (var dlg = new DocumentConverterDialog())
{
dlg.Preferences = preferences.Clone();
dlg.RedactionOptions = convertRedactionOptions;
if (dlg.ShowDialog() == DialogResult.OK)
{
preferences = dlg.Preferences.Clone();
convertRedactionOptions = dlg.RedactionOptions;
}
else
{
more = false;
}
}
}
if (more)
{
try
{
// Save the preferences
if (!preferences.IsSilentMode)
{
preferences.Save();
}
// Run the conversion
if (preferences.DocumentId != null)
{
var loadFromCacheOptions = new LoadFromCacheOptions
{
Cache = cache,
DocumentId = preferences.DocumentId,
UserToken = preferences.DocumentUserToken
};
using (var document = DocumentFactory.LoadFromCache(loadFromCacheOptions))
{
if (document == null)
{
throw new Exception(string.Format("Could not load document with ID '{0}' from the cache", preferences.DocumentId));
}
preferences.Run(cache, document, null, convertRedactionOptions);
}
}
else
{
preferences.Run(null, null, null, convertRedactionOptions);
}
}
catch (Exception ex)
{
if (!preferences.IsSilentMode)
{
Messager.ShowError(null, ex.Message);
}
else
{
preferences.ErrorMessage = ex.Message;
}
}
}
if (more)
{
if (!preferences.IsSilentMode)
{
// Ask if user wants to convert another document
more = (Messager.ShowQuestion(null, "Convert more?", MessageBoxButtons.YesNo) == DialogResult.Yes);
}
else
{
more = false;
}
}
}
if (preferences.OcrEngineInstance != null)
{
preferences.OcrEngineInstance.Dispose();
}
if (preferences.RasterCodecsInstance != null)
{
preferences.RasterCodecsInstance.Dispose();
}
if (preferencesFileName != null)
{
preferences.Save(preferencesFileName);
}
if (preferences.ErrorMessage != null)
{
return(1);
}
return(0);
}
public ArtistRelationsQuery(IDatabaseContext ctx, ContentLanguagePreference languagePreference, ObjectCache cache, IAggregatedEntryImageUrlFactory entryThumbPersister)
{
_ctx = ctx;
_languagePreference = languagePreference;
_cache = cache;
_entryThumbPersister = entryThumbPersister;
}
public DefaultCache()
{
_cacheContext = MemoryCache.Default;
}
public void DrawMessages(SpriteBatch b)
{
if (Game1.chatBox != null)
{
ObjectCache cache = MemoryCache.Default;
long uniqueMultiplayerID = Game1.player.UniqueMultiplayerID;
int startIndex = chatCommandsIsLoaded ? displayLineIndexField.GetValue() : messagesField.GetValue().Count - 1;
int endIndex = chatCommandsIsLoaded ? getEndDisplayIndexMethod.Invoke <int>() : 0;
int verticalPosAcum = 0;
for (int i = startIndex; i >= endIndex; --i)
{
ChatMessage message = messagesField.GetValue()[i];
verticalPosAcum += message.verticalSize;
int messageHash = message.GetHashCode();
if (!(cache[$"{messageHash}_message"] is PlayerMessage cachedPlayerMessage))
{
#if DEBUG
ModEntry.ModLogger.LogToMonitor = false;
ModEntry.ModLogger.Log($"Message hash: {messageHash}");
ModEntry.ModLogger.LogToMonitor = true;
#endif
cachedPlayerMessage = PlayerMessageList.Find(msg => msg.MessageHash == messageHash);
if (cachedPlayerMessage == null)
{
string msg = string.Concat(message.message.Select(chatSnippet => chatSnippet.message));
cachedPlayerMessage = new PlayerMessage(Game1.player, LocalizedContentManager.CurrentLanguageCode, msg, messageHash);
PlayerMessageList.Add(cachedPlayerMessage);
}
// Cache message for later
cache[$"{messageHash}_message"] = cachedPlayerMessage;
#if DEBUG
ModEntry.ModLogger.LogToMonitor = false;
ModEntry.ModLogger.Log($"vvvvvv Cached {cache.GetCount()} elements vvvvvv");
foreach (var item in cache)
{
ModEntry.ModLogger.Log($"Message hash: {item}");
}
ModEntry.ModLogger.Log($"^^^^^^ Cached {cache.GetCount()} elements ^^^^^^");
ModEntry.ModLogger.LogToMonitor = true;
#endif
}
int x = 12;
int y = Game1.chatBox.yPositionOnScreen - verticalPosAcum - 8 + (Game1.chatBox.chatBox.Selected ? 0 : Game1.chatBox.chatBox.Height);
foreach (MessageEmoji msgEmoji in cachedPlayerMessage.MessageEmojis)
{
Vector2 position = new Vector2(msgEmoji.HorizontalPosition + x + 1.0f, msgEmoji.VerticalPosition + y - 4.0f);
bool playerLeft = Game1.getAllFarmers().Any(farmer => farmer.UniqueMultiplayerID == cachedPlayerMessage.Player.UniqueMultiplayerID);
if (playerLeft && Game1.chatBox.isWithinBounds((int)position.X, (int)position.Y) && msgEmoji.Index >= NumberVanillaEmoji)
{
msgEmoji.DrawEmoji(b, position, message.alpha);
}
}
}
// Draw the emoji menu
if (choosingEmojiField.GetValue())
{
Game1.chatBox.emojiMenu.draw(b);
}
// Draw the cursor on top
if ((Game1.chatBox.isWithinBounds(Game1.getMouseX(), Game1.getMouseY()) || Game1.chatBox.isActive()) && !Game1.options.hardwareCursor)
{
b.Draw(Game1.mouseCursors, new Vector2((float)Game1.getOldMouseX(), (float)Game1.getOldMouseY()), new Rectangle?(Game1.getSourceRectForStandardTileSheet(Game1.mouseCursors, Game1.options.gamepadControls ? 44 : 0, 16, 16)), Color.White, 0.0f, Vector2.Zero, (float)(4.0 + Game1.dialogueButtonScale / 150.0), SpriteEffects.None, 1f);
}
}
}
private static CacheItemTelemetry GetCacheItemTelemetry(ObjectCache cache, string cacheKey, string regionName)
{
var itemTelemetryCacheKey = GetItemTelemetryCacheKey(cacheKey);
return(cache.Get(itemTelemetryCacheKey, regionName) as CacheItemTelemetry);
}
/// <summary>
/// Increment cache item stale access count.
/// </summary>
/// <param name="cache">The cache.</param>
/// <param name="cacheKey">The cache item key.</param>
/// <param name="regionName">The cache region.</param>
public static void IncrementStaleAccessCount(this ObjectCache cache, string cacheKey, string regionName = null)
{
var item = GetCacheItemTelemetry(cache, cacheKey, regionName);
item?.IncrementStaleAccessCount();
}
public void Initialize(IFileSystem fileSystem, IPathResolver resolver, IScriptRuntimeListener listener, IScriptLogger logger, IO.IByteBufferAllocator byteBufferAllocator)
{
if (logger == null)
{
throw new NullReferenceException(nameof(logger));
}
if (fileSystem == null)
{
throw new NullReferenceException(nameof(fileSystem));
}
MethodInfo bindAll = null;
if (!isWorker)
{
if (listener == null)
{
throw new NullReferenceException(nameof(listener));
}
bindAll = typeof(Values).GetMethod("BindAll", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
if (bindAll == null)
{
throw new Exception("generate binding code before run");
}
var codeGenVersionField = typeof(Values).GetField("CodeGenVersion");
if (codeGenVersionField == null || !codeGenVersionField.IsStatic || !codeGenVersionField.IsLiteral || codeGenVersionField.FieldType != typeof(uint))
{
throw new Exception("binding code version mismatch");
}
var codeGenVersion = (uint)codeGenVersionField.GetValue(null);
if (codeGenVersion != ScriptEngine.VERSION)
{
if (logger != null)
{
logger.Write(LogLevel.Warn, "CodeGenVersion: {0} != {1}", codeGenVersion, ScriptEngine.VERSION);
}
}
}
_isValid = true;
_isRunning = true;
// _rwlock = new ReaderWriterLockSlim();
_rt = JSApi.JS_NewRuntime();
JSApi.JS_SetHostPromiseRejectionTracker(_rt, JSApi.PromiseRejectionTracker, IntPtr.Zero);
JSApi.JS_SetRuntimeOpaque(_rt, (IntPtr)_runtimeId);
JSApi.JS_SetModuleLoaderFunc(_rt, module_normalize, module_loader, IntPtr.Zero);
CreateContext();
JSApi.JS_NewClass(_rt, JSApi.JSB_GetBridgeClassID(), "CSharpClass", JSApi.class_finalizer);
_listener = listener;
_pathResolver = resolver;
_byteBufferAllocator = byteBufferAllocator;
_autorelease = new Utils.AutoReleasePool();
_fileSystem = fileSystem;
_logger = logger;
_objectCache = new ObjectCache(_logger);
_timerManager = new TimerManager(_logger);
_typeDB = new TypeDB(this, _mainContext);
listener.OnCreate(this);
var register = new TypeRegister(this, _mainContext);
register.RegisterType(typeof(Unity.JSBehaviour));
#if UNITY_EDITOR
register.RegisterType(typeof(Unity.JSEditorWindow));
#endif
// await Task.Run(() => runner.OnBind(this, register));
if (bindAll != null)
{
bindAll.Invoke(null, new object[] { register });
}
listener.OnBind(this, register);
if (!_isWorker)
{
JSWorker.Bind(register);
}
TimerManager.Bind(register);
ScriptContext.Bind(register);
register.Finish();
listener.OnComplete(this);
}
bool TryFormatTuple(DbgDotNetValue value, int tupleArity)
{
Debug.Assert(TypeFormatterUtils.GetTupleArity(value.Type) == tupleArity && tupleArity > 0);
OutputWrite(TupleTypeOpenParen, BoxedTextColor.Punctuation);
var values = ObjectCache.AllocDotNetValueList();
var runtime = evalInfo.Runtime.GetDotNetRuntime();
int index = 0;
foreach (var info in TupleTypeUtils.GetTupleFields(value.Type, tupleArity))
{
if (index++ > 0)
{
OutputWrite(",", BoxedTextColor.Punctuation);
WriteSpace();
}
if (info.tupleIndex < 0)
{
OutputWrite("???", BoxedTextColor.Error);
break;
}
else
{
var objValue = value;
DbgDotNetValueResult valueResult = default;
try {
foreach (var field in info.fields)
{
valueResult = runtime.LoadField(evalInfo, objValue, field);
if (valueResult.Value != null)
{
values.Add(valueResult.Value);
}
if (valueResult.HasError || valueResult.ValueIsException)
{
objValue = null;
break;
}
objValue = valueResult.Value;
}
valueResult = default;
if (objValue == null)
{
OutputWrite("???", BoxedTextColor.Error);
break;
}
Format(objValue);
}
finally {
valueResult.Value?.Dispose();
foreach (var v in values)
{
v?.Dispose();
}
values.Clear();
}
}
}
ObjectCache.Free(ref values);
OutputWrite(TupleTypeCloseParen, BoxedTextColor.Punctuation);
return(true);
}
public static Tuple <bool, string, int, int, IList> where < T > (
T[] items, string s_key, string s_select, string s_where, string s_order_by, string s_distinct, int page_number, int page_size)
{
string s_tab = typeof(T).FullName;
string key_cache = s_tab + "|" +
s_key + "|" +
s_select + "|" + s_where + "|" + Guid.NewGuid().ToString() +
s_order_by + "|" + s_distinct;
int rs_total = items.Length;
int rs_count = 0;
try
{
IList dy;
ObjectCache cache = MemoryCache.Default;
if (cache[key_cache] == null)
{
#region // query ...
T[] a = new T[] { };
if (!string.IsNullOrEmpty(s_where))
{
a = items.Where(s_where).Cast <T>().ToArray();
}
else
{
a = items;
}
IList ls = new List <dynamic>()
{
};
IList dt = new List <dynamic>()
{
};
if (!string.IsNullOrEmpty(s_distinct))
{
string[] adis = s_distinct.Split(',').Select(x => "Key." + x.Trim()).ToArray();
string s_dis_select = string.Join(",", adis);
s_select = "";
if (string.IsNullOrEmpty(s_order_by))
{
ls = a.AsQueryable().GroupBy("new(" + s_distinct + ")").Select("new(" + s_dis_select + ")").ToListDynamic();
}
else
{
//var ls =
//ls = a.SortMultiple(s_order_by).AsQueryable().GroupBy("new(" + s_distinct + ")").Select("new(" + s_dis_select + ")").ToListDynamic();
ls = a.AsQueryable().GroupBy("new(" + s_distinct + ")").Select("new(" + s_dis_select + ")").ToListDynamic();
}
}
else
{
if (string.IsNullOrEmpty(s_order_by))
{
ls = a;
}
else
{
ls = a.SortMultiple(s_order_by).ToArray();
}
}
rs_count = ls.Count;
//ObjectCache cache = MemoryCache.Default;
CacheItemPolicy policy = new CacheItemPolicy();
policy.Priority = System.Runtime.Caching.CacheItemPriority.Default;
policy.AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(30);
//Muốn tạo sự kiện thì tạo ở đây còn k thì hoy
//(MyCacheItemPriority == MyCachePriority.Default) ? CacheItemPriority.Default : CacheItemPriority.NotRemovable;
///Globals.policy.RemovedCallback = callback;
cache.Set(key_cache, ls, policy, null);
dbCache.dicKeys.AddDistinct(s_tab, key_cache);
if (rs_count <= page_size)
{
dt = ls;
}
else
{
int startRowIndex = page_size * (page_number - 1);
dt = ls.Cast <dynamic>().Skip(startRowIndex).Take(page_size).ToArray();
}
//IList dy = dt;
dy = dt;
if (!string.IsNullOrEmpty(s_select))
{
dy = ls.Select("new(" + s_select + ")").ToListDynamic();
}
//string json = JsonConvert.SerializeObject(dy);
#endregion
}
else
{
dy = cache[key_cache] as IList;
rs_count = dy.Count;
if (rs_count <= page_size)
{
}
else
{
int startRowIndex = page_size * (page_number - 1);
dy = dy.Cast <dynamic>().Skip(startRowIndex).Take(page_size).ToArray();
}
if (!string.IsNullOrEmpty(s_select))
{
dy = dy.Select("new(" + s_select + ")").ToListDynamic();
}
}
return(new Tuple <bool, string, int, int, IList>(true, "", rs_total, rs_count, dy));
}
catch (Exception ex)
{
return(new Tuple <bool, string, int, int, IList>(false, ex.Message, rs_total, 0, null));
}
}
private static void GetChildRecursive(this SQLiteConnection conn, object element, PropertyInfo relationshipProperty, bool recursive, ObjectCache objectCache)
{
var relationshipAttribute = relationshipProperty.GetAttribute <RelationshipAttribute>();
if (relationshipAttribute is OneToOneAttribute)
{
conn.GetOneToOneChild(element, relationshipProperty, recursive, objectCache);
}
else if (relationshipAttribute is OneToManyAttribute)
{
conn.GetOneToManyChildren(element, relationshipProperty, recursive, objectCache);
}
else if (relationshipAttribute is ManyToOneAttribute)
{
conn.GetManyToOneChild(element, relationshipProperty, recursive, objectCache);
}
else if (relationshipAttribute is ManyToManyAttribute)
{
conn.GetManyToManyChildren(element, relationshipProperty, recursive, objectCache);
}
else if (relationshipAttribute is TextBlobAttribute)
{
TextBlobOperations.GetTextBlobChild(element, relationshipProperty);
}
}
/// <summary>
/// Removes site from cache
/// </summary>
/// <param name="id"></param>
public static void Flush(int id)
{
ObjectCache cache = MemoryCache.Default;
cache.Remove(Site.CacheKey(id));
}
public EmpresaServicio()
{
this.servicioWeb = new ServicioWebEmpresas.ServicioWebEmpresas();
this.cache = MemoryCache.Default;
}
static object ReplaceWithCacheObjectIfPossible(object element, PropertyInfo primaryKeyProperty, ObjectCache objectCache, out bool isLoadedFromCache)
{
isLoadedFromCache = false;
if (element == null || primaryKeyProperty == null || objectCache == null)
{
return(element);
}
object primaryKey = null;
primaryKey = primaryKeyProperty.GetValue(element, null);
if (primaryKey == null)
{
return(element);
}
var cachedElement = GetObjectFromCache(element.GetType(), primaryKey, objectCache);
object result;
if (cachedElement != null)
{
result = cachedElement;
isLoadedFromCache = true;
}
else
{
result = element;
SaveObjectToCache(element, primaryKey, objectCache);
}
return(result);
}
/// <summary>
/// Get the cache footprint in the form of a JSON-serializable object.
/// </summary>
/// <param name="cache">The cache.</param>
/// <param name="expanded">Whether to show details of each entity item.</param>
/// <param name="requestUrl">The request URL.</param>
/// <returns></returns>
public static Dictionary <string, object> GetCacheFootprintJson(this ObjectCache cache, bool expanded, Uri requestUrl)
{
var alternateLink = new Uri(requestUrl.GetLeftPart(UriPartial.Path));
var entities = new List <Dictionary <string, object> >();
var footprint = GetCacheFootprint(cache, alternateLink);
foreach (var entityType in footprint)
{
var entity = new Dictionary <string, object>
{
{ "Name", entityType.Name },
{ "Count", entityType.GetCount() },
{ "Size", entityType.GetSize() }
};
if (expanded)
{
var records = new Collection <Dictionary <string, object> >();
foreach (var item in entityType.Items)
{
var record = new Dictionary <string, object>
{
{ "LogicalName", item.Entity.LogicalName },
{ "Name", item.Entity.GetAttributeValueOrDefault("adx_name", string.Empty) },
{ "Id", item.Entity.Id }
};
var recordCache = new Dictionary <string, object>
{
{ "Id", item.CacheItemKey },
{ "Type", item.CacheItemType },
{ "Link", item.Link.ToString() },
{ "Size", GetEntitySizeInMemory(item.Entity) }
};
record.Add("Cache", recordCache);
records.Add(record);
}
entity.Add("Items", records);
}
entities.Add(entity);
}
var entitiesWrapper = new Dictionary <string, object>();
if (!expanded)
{
// Add link to the Expanded view with entity record details
var query = System.Web.HttpUtility.ParseQueryString(requestUrl.Query);
query[Web.Handlers.CacheFeedHandler.QueryKeys.Expanded] = bool.TrueString;
var uriBuilder = new UriBuilder(requestUrl.ToString())
{
Query = query.ToString()
};
entitiesWrapper.Add("ExpandedView", uriBuilder.ToString());
}
entitiesWrapper.Add("Entities", entities.OrderByDescending(e => e["Size"]));
var retval = new Dictionary <string, object> {
{ "CacheFootprint", entitiesWrapper }
};
return(retval);
}
