public async Task StreamDb_adds_more_than_md_capacity()
{
// Arrange
var stream = await _fixture.GetStreamADAsync();
var addCount = Math.Round(1.3 * Constants.MdCapacity);
var sw = new Stopwatch();
for (int i = 0; i < addCount; i++)
{
var theData = new StoredValue(i);
// Act
sw.Restart();
var addResult = await stream.AppendAsync(theData).ConfigureAwait(false);
sw.Stop();
// Assert 1
Assert.IsNotNull(addResult);
Assert.IsInstanceOfType(addResult, typeof(Result <Pointer>));
Assert.IsTrue(addResult.HasValue);
Debug.WriteLine($"{i}: {sw.ElapsedMilliseconds}");
}
// Assert 2
var events = await stream.ReadForwardFromAsync(0).ToListAsync();
Assert.IsNotNull(events);
Assert.AreEqual(addCount, events.Count);
}
private TValue Retrieve(TKey sKey, out bool bContains)
{
bContains = false;
TValue oResult = null;
bool foundInCache = false;
lock (this.dataLock) {
if (this.data.ContainsKey(sKey))
{
StoredValue <TValue> oValue = this.data[sKey];
foundInCache = true;
if (!oValue.IsTooOld(this.age))
{
oResult = oValue.Value;
bContains = true;
} // if
} // if
} // lock
if (OnRetrieve != null)
{
OnRetrieve(sKey, foundInCache, foundInCache && !bContains);
}
return(oResult);
} // Retrieve
// Returns existing or creates new
public async Task <Result <MdFileStream> > CreateFile(FileSystemPath path)
{
if (!_path.IsParentOf(path))
{
return(new InvalidOperation <MdFileStream>("Incorrect path"));
}
if (!path.IsFile)
{
return(new InvalidOperation <MdFileStream>("Path is not a file"));
}
var fileResult = await FindFileAsync(path);
if (fileResult.HasValue)
{
return(Result.OK(fileResult.Value));
}
await AddOrLoad(FILE_INFO_KEY);
var md = await MdAccess.CreateAsync(0);
var info = SetupFileInfo(path, md);
var value = new StoredValue(info);
var pointer = await _dataTreeCache[FILE_INFO_KEY].AddAsync(path.Path, value);
if (!pointer.HasValue)
{
return(Result.Fail <MdFileStream>(pointer.ErrorCode.Value, pointer.ErrorMsg));
}
await _indexer.IndexAsync(path.Path, pointer.Value);
//ScheduleIndexing(path, pointer.Value);
return(Result.OK(new MdFileStream(info)));
}
/// <summary>
/// The get edit data types.
/// </summary>
/// <returns>
/// </returns>
private List <StoredValue> GetEditDataTypes()
{
var list = new List <StoredValue>();
if (this.CurrentRow > 0)
{
list = this.GetStoredValueRow(this.CurrentRow).Cells;
}
else
{
foreach (var config in this.ColumnConfigurations)
{
var dtd = DataTypeDefinition.GetDataTypeDefinition(config.DataTypeId);
var dt = dtd.DataType;
var s = new StoredValue {
Name = config.Name, Alias = config.Alias, Value = dt
};
list.Add(s);
}
}
return(list);
}
Result <Pointer> Set(string key, StoredValue value)
{
switch (Type)
{
case MdType.Pointers:
return(new InvalidOperation <Pointer>($"Cannot set values directly on pointers. Key {key}, value type {value.ValueType}"));
case MdType.Values:
using (var db = GetRocksDb())
{
var formattedKey = GetKey(key);
var column = db.GetColumnFamily(COLUMN_FAMILY);
db.Put(formattedKey, value.Json(), cf: column);
_keys.Add(formattedKey);
}
return(Result.OK(new Pointer
{
MdLocator = this.MdLocator,
MdKey = key,
ValueType = value.ValueType
}));
default:
return(new ArgumentOutOfRange <Pointer>(nameof(Type)));
}
}
Result <Pointer> ExpandLevel(string key, StoredValue value)
{
if (Level == 0)
{
return(new ArgumentOutOfRange <Pointer>(nameof(Level)));
}
var md = LocalMd.Create(Level - 1);
var leafPointer = (md as LocalMd).Add(key, value);
if (!leafPointer.HasValue)
{
return(leafPointer);
}
switch (md.Type)
{
case MdType.Pointers: // i.e. we have still not reached the end of the tree
Add(new Pointer
{
MdLocator = md.MdLocator,
ValueType = typeof(Pointer).Name
});
break;
case MdType.Values: // i.e. we are now right above leaf level
Add(leafPointer.Value);
break;
default:
return(new ArgumentOutOfRange <Pointer>(nameof(md.Type)));
}
return(leafPointer);
}
async Task <Result <Pointer> > AddObjectAsync(string key, StoredValue value)
{
try
{
await _dataOps.AddObjectAsync(key, value).ConfigureAwait(false);
Interlocked.Increment(ref _count);
return(Result.OK(new Pointer // return pointer, to be used for indexing
{
MdLocator = MdLocator,
MdKey = key,
ValueType = value.ValueType
}));
}
catch (FfiException ex) when(ex.ErrorCode == -107)
{
return(new ValueAlreadyExists <Pointer>(ex.Message));
}
catch (FfiException ex) when(ex.ErrorCode == -108)
{
return(new MdOutOfEntriesError <Pointer>($"Filled: {Count}/{Constants.MdCapacity}"));
} // entry limit exceeded
// todo: handle transient error
}
public List<StoredValue> GetValues(Material m)
{
var list = GetShaderProperties(m);
var output = new List<StoredValue>();
foreach(var p in list)
{
var o = new StoredValue { Property = p };
output.Add(o);
switch(p.type)
{
case MaterialProperty.PropertyType.color:
o.Value = m.GetColor(p.name);
break;
case MaterialProperty.PropertyType.real:
o.Value = m.GetFloat(p.name);
break;
case MaterialProperty.PropertyType.texture:
o.Value = m.GetTexture(p.name);
break;
case MaterialProperty.PropertyType.vector:
o.Value = m.GetVector(p.name);
break;
case MaterialProperty.PropertyType.textureOffset:
o.Value = m.GetTextureOffset(p.name);
break;
case MaterialProperty.PropertyType.textureScale:
o.Value = m.GetTextureScale(p.name);
break;
case MaterialProperty.PropertyType.matrix:
o.Value = m.GetMatrix(p.name);
break;
}
}
return output;
}
public ActionResult <StoredValue> Post([FromBody] StoredValue value)
{
var id = _random.Next();
_redis.StringSet(id.ToString(), value.Value);
return(CreatedAtRoute("GetValue", new { id }, value));
}
public bool Retrieve(long id, out object retreived)
{
StoredValue found = null;
var success = values.TryGetValue(id, out found);
retreived = found;
return(success);
}
public IActionResult PickupPayload(
[FromHeader] string AccessToken,
[FromRoute] string dropzoneName,
[FromQuery] string recipient = null)
{
var recipientKey = string.IsNullOrWhiteSpace(recipient) ? "*" : recipient;
var clientIp = _Accessor.HttpContext.Connection.RemoteIpAddress.ToString();
if (!IsValidatedClient(clientIp, AccessToken, TokenType.Access, dropzoneName, System.Reflection.MethodBase.GetCurrentMethod().Name))
{
return(Unauthorized());
}
lock (_LockDropZoneInfo)
{
if (!_Storage.DropZoneList.ContainsKey(dropzoneName))
{
if (_Storage.DropZoneList.Count >= _Storage.MaxDropzones)
{
return(StatusCode(429, $"Can't create new dropzone {dropzoneName}.. at maximum of {_Storage.MaxDropzones} dropzone definitions."));
}
CreateDropZone(dropzoneName);
}
var dropzone = _Storage.DropZoneList[dropzoneName];
StoredValue payload = null;
bool recipientKeyIsKnown = dropzone.Payloads.ContainsKey(recipientKey);
bool payloadAvailable = false;
int retriesRemaining = 3;
while (recipientKeyIsKnown && !dropzone.Payloads[recipientKey].IsEmpty && !payloadAvailable)
{
if (!dropzone.Payloads[recipientKey].TryDequeue(out payload))
{
if (retriesRemaining > 0)
{
retriesRemaining--;
System.Threading.Thread.Sleep(50);
continue;
}
return(StatusCode(500, $"Dropzone exists with payloads, but failed to acquire a payload after three attempts."));
}
dropzone.Statistics.PayloadSize -= payload.Value.Length;
dropzone.Statistics.PayloadCount--;
dropzone.Statistics.Recipients[recipientKey]--;
if (payload.Expires < DateTime.Now)
{
dropzone.Statistics.PayloadExpiredCount++;
continue;
}
dropzone.Statistics.LastPickup = DateTime.Now;
payloadAvailable = true;
}
if (!payloadAvailable)
{
return(StatusCode(204));
}
return(StatusCode(200, payload.Value));
}
}
public IActionResult SetReference(
[FromHeader] string AccessToken,
[FromRoute] string dropzoneName,
[FromRoute] string key,
[FromBody] string value,
[FromQuery] DateTime?expiresOn)
{
var clientIp = _Accessor.HttpContext.Connection.RemoteIpAddress.ToString();
if (!IsValidatedClient(clientIp, AccessToken, TokenType.Access, dropzoneName, System.Reflection.MethodBase.GetCurrentMethod().Name))
{
return(Unauthorized());
}
var fixedValue = new StoredValue
{
Value = value ?? string.Empty,
Expires = expiresOn ?? DateTime.MaxValue
};
lock (_LockDropZoneInfo)
{
if (!_Storage.DropZoneList.ContainsKey(dropzoneName))
{
if (_Storage.DropZoneList.Count >= _Storage.MaxDropzones)
{
return(StatusCode(429, $"Can't create new dropzone {dropzoneName}.. at maximum of {_Storage.MaxDropzones} dropzone definitions."));
}
CreateDropZone(dropzoneName);
}
var dropzone = _Storage.DropZoneList[dropzoneName];
int sizeOffset = 0;
if (dropzone.References.ContainsKey(key))
{
sizeOffset = dropzone.References[key].Value.Length;
}
if ((dropzone.Statistics.ReferenceSize - sizeOffset + fixedValue.Value.Length) > dropzone.Statistics.Metrics.MaxReferenceSize)
{
dropzone.Statistics.ReferenceSetsFailedCount++;
return(StatusCode(429, $"Can't accept: Exceeds maximum reference value size of {dropzone.Statistics.Metrics.MaxReferenceSize}"));
}
if (dropzone.References.Count >= dropzone.Statistics.Metrics.MaxReferencesCount)
{
dropzone.Statistics.ReferenceSetsFailedCount++;
return(StatusCode(429, $"Can't accept: Exceeds maximum reference count of {dropzone.Statistics.Metrics.MaxReferencesCount}"));
}
dropzone.Statistics.ReferenceSize -= sizeOffset;
dropzone.References.Remove(key);
dropzone.References.Add(key, fixedValue);
dropzone.Statistics.ReferenceSize += fixedValue.Value.Length;
dropzone.Statistics.ReferenceCount = dropzone.References.Count;
dropzone.Statistics.LastSetReference = DateTime.Now;
return(StatusCode(201, "Reference accepted"));
}
}
/// <summary>
/// Makes DelegateCommand listen on PropertyChanged events of some object,
/// so that DelegateCommand can update its IsEnabled property.
/// </summary>
public static TObj ListenOn <T, TObj>(this TObj delegateCommand, StoredValue <T> observedObject) where TObj : CommandBase
{
WeakEventManager <INotifyPropertyChanged, PropertyChangedEventArgs> .AddHandler(observedObject, nameof(INotifyPropertyChanged.PropertyChanged),
(sender, e) => {
if (e.PropertyName == nameof(observedObject.Value))
{
delegateCommand.RaiseCanExecuteChanged();
}
});
return(delegateCommand);
}
public bool Update(long id, string newValue)
{
StoredValue existing = null;
var success = values.TryGetValue(id, out existing);
if (success)
{
existing.Value = newValue;
existing.Updated = DateTime.Now;
}
return(success);
}
public void Store(string value)
{
var now = DateTime.Now;
var storedValue = new StoredValue {
Id = Interlocked.Increment(ref idCounter),
Value = value,
Created = now,
Updated = now
};
values.Add(storedValue.Id, storedValue);
}
async Task AppendToStream(IStreamAD stream, int addCount)
{
for (int i = 0; i < addCount; i++)
{
var theData = new StoredValue(i);
var addResult = await stream.AppendAsync(theData).ConfigureAwait(false);
Assert.IsNotNull(addResult);
Assert.IsInstanceOfType(addResult, typeof(Result <Pointer>));
Assert.IsTrue(addResult.HasValue);
}
}
/// <summary>
/// Returns the smallest value that is currently being stored.
/// </summary>
/// <returns></returns>
public StoredValue GetMinimum()
{
Cleanup();
StoredValue min = null;
foreach (StoredValue v in q)
{
if (min == null || v.speed <= min.speed)
{
min = v;
}
}
return(min);
}
public void WriteContent(byte[] value)
{
var data = new StoredValue(value);
var res = _infoWriter($"{Path}/Content", data);
if (res.HasValue)
{
Content = value;
}
else
{
throw new Exception(res.ErrorMsg);
}
}
/// <summary>
/// Returns the largest value that is currently being stored.
/// </summary>
/// <returns></returns>
public StoredValue GetMaximum()
{
Cleanup();
StoredValue max = null;
foreach (StoredValue v in q)
{
if (max == null || v.speed >= max.speed)
{
max = v;
}
}
return(max);
}
/// <summary>
/// Gets the values given a material
/// </summary>
/// <param name="m">The material</param>
/// <returns>A StoredValue containing value and type information</returns>
public List <StoredValue> GetValues(Material m)
{
var list = GetShaderProperties(m);
var output = new List <StoredValue>();
foreach (var p in list)
{
var o = new StoredValue
{
property = p
};
output.Add(o);
switch (p.type)
{
case MaterialProperty.PropertyType.Color:
o.value = new object[1];
o.value[0] = m.GetColor(p.name);
break;
case MaterialProperty.PropertyType.Float:
o.value = new object[1];
o.value[0] = m.GetFloat(p.name);
break;
case MaterialProperty.PropertyType.Range:
o.value = new object[1];
o.value[0] = m.GetFloat(p.name);
break;
case MaterialProperty.PropertyType.TexEnv:
o.value = new object[3];
o.value[0] = m.GetTexture(p.name);
o.value[1] = m.GetTextureOffset(p.name);
o.value[2] = m.GetTextureScale(p.name);
break;
case MaterialProperty.PropertyType.Vector:
o.value = new object[1];
o.value[0] = m.GetVector(p.name);
break;
default:
Debug.LogError("Unsupported type: " + p.type.ToString());
break;
}
}
return(output);
}
/// <summary>
/// Gets the insert data types.
/// </summary>
/// <returns>
/// </returns>
private List <StoredValue> GetInsertDataTypes()
{
var list = new List <StoredValue>();
foreach (var config in this.ColumnConfigurations)
{
var dtd = DataTypeDefinition.GetDataTypeDefinition(config.DataTypeId);
var dt = dtd.DataType;
var s = new StoredValue {
Name = config.Name, Alias = config.Alias, Value = dt
};
list.Add(s);
}
return(list);
}
async Task ThreadedFillMd(Func <int> incrCount)
{
var sw = new Stopwatch();
var md = await GetNewMd().ConfigureAwait(false);
await NewMetadata(md);
for (int i = 0; i < MdMetadata.Capacity; i++)
{
var key = $"theKey_{i}";
var obj = new StoredValue(i);
sw.Restart();
await AddObjectAsync(md, key, obj).ConfigureAwait(false);
sw.Stop();
Debug.WriteLine($"{incrCount()}: {sw.ElapsedMilliseconds}");
}
}
public List <StoredValue> GetValues(Material m)
{
var list = GetShaderProperties(m);
var output = new List <StoredValue>();
foreach (var p in list)
{
var o = new StoredValue {
Property = p
};
output.Add(o);
switch (p.type)
{
case MaterialProperty.PropertyType.color:
o.Value = m.GetColor(p.name);
break;
case MaterialProperty.PropertyType.real:
o.Value = m.GetFloat(p.name);
break;
case MaterialProperty.PropertyType.texture:
o.Value = m.GetTexture(p.name);
break;
case MaterialProperty.PropertyType.vector:
o.Value = m.GetVector(p.name);
break;
case MaterialProperty.PropertyType.textureOffset:
o.Value = m.GetTextureOffset(p.name);
break;
case MaterialProperty.PropertyType.textureScale:
o.Value = m.GetTextureScale(p.name);
break;
case MaterialProperty.PropertyType.matrix:
o.Value = m.GetMatrix(p.name);
break;
}
}
return(output);
}
public async Task <Result <Directory> > CreateSubDirectory(FileSystemPath path)
{
// validate that parent path is
if (!_path.IsParentOf(path))
{
return(new InvalidOperation <Directory>("Incorrect path"));
}
if (!path.IsDirectory)
{
return(new InvalidOperation <Directory>("Path is not a directory"));
}
var directoryResult = await FindDirectoryAsync(path);
if (directoryResult.HasValue)
{
return(new ValueAlreadyExists <Directory>(path.Path));
}
var res = await DirectoryFactory.GetOrAddAsync(path.Path);
if (!res.HasValue)
{
return(res);
}
await AddOrLoad(DIR_INFO_KEY);
var info = SetupDirectoryInfo(path, res.Value._info);
var value = new StoredValue(info.Locator);
var pointer = await _dataTreeCache[DIR_INFO_KEY].AddAsync(path.Path, value);
if (!pointer.HasValue)
{
return(Result.Fail <Directory>(pointer.ErrorCode.Value, pointer.ErrorMsg));
}
await _indexer.IndexAsync(path.Path, pointer.Value);
//ScheduleIndexing(path, pointer.Value);
return(res);
}
/// <summary>
/// Initializes a new instance of the <see cref="ClientSideRequiredFieldValidator" /> class.
/// </summary>
/// <param name="prefix">The prefix.</param>
/// <param name="cell">The cell.</param>
/// <param name="enabled">If the validator is e enabled.</param>
public ClientSideRequiredFieldValidator(string prefix, StoredValue cell, bool enabled = true)
{
this.ID = prefix + "_" + cell.Alias + "_required";
this.Enabled = enabled;
this.CssClass = "validator";
this.ClientValidationFunction = "RequiredFieldValidate";
this.Display = ValidatorDisplay.Dynamic;
this.ErrorMessage = cell.Name + " is mandatory";
// Set control to validate
this.Attributes["data-controltovalidate"] = DataTypeHandlerServiceLocator.Instance.GetControlToValidate(cell.Value, cell.Value.DataEditor.Editor).ClientID;
var validationAttribute = (ValidationPropertyAttribute)TypeDescriptor.GetAttributes(cell.Value.DataEditor.Editor)[typeof(ValidationPropertyAttribute)];
if (validationAttribute != null)
{
this.Attributes["data-validationproperty"] = validationAttribute.Name;
}
}
async Task FillMd(int iteration)
{
iteration *= 1000;
var sw = new Stopwatch();
var md = await GetNewMd().ConfigureAwait(false);
await NewMetadata(md);
for (int i = 0; i < MdMetadata.Capacity; i++)
{
var key = $"theKey_{i}";
var obj = new StoredValue(i);
sw.Restart();
await AddObjectAsync(md, key, obj).ConfigureAwait(false);
sw.Stop();
Debug.WriteLine($"{i + iteration + 1}: {sw.ElapsedMilliseconds}");
}
}
/// <summary>
/// Handles the Click event of the addRow control.
/// </summary>
/// <param name="sender">
/// The source of the event.
/// </param>
/// <param name="e">
/// The <see cref="System.EventArgs"/> instance containing the event data.
/// </param>
protected void addRow_Click(object sender, EventArgs e)
{
var row = new StoredValueRow {
Id = this.GetAvailableId(), SortOrder = this.Rows.Count() + 1
};
foreach (var t in this.InsertDataTypes)
{
// Save value to datatype
DataTypeFactoryServiceLocator.Instance.Save(t.Value);
// Create new storedvalue object
var v = new StoredValue {
Name = t.Name, Alias = t.Alias, Value = t.Value
};
row.Cells.Add(v);
}
this.Rows.Add(row);
Store();
Save();
}
public void CTS_PerHttpRequestCache_Add_Get_Remove_Test()
{
var wapper = this.MockHttpContext();
var cache = new PerHttpRequestCache(wapper);
var key = "xxx";
var value = new StoredValue {
Value = "123"
};
var addResult = cache.Add(key, value, null);
Assert.IsTrue(addResult);
var obj1 = cache.Get(key) as StoredValue;
Assert.IsNotNull(obj1);
Assert.IsTrue(obj1.Value == value.Value);
cache.Remove(key);
var obj2 = cache.Get(key) as StoredValue;
Assert.IsNull(obj2);
}
async Task <Result <Pointer> > ExpandLevelAsync(StoredValue value, ExpectedVersion expectedVersion, IMdNode previous)
{
if (Level == 0)
{
return(new ArgumentOutOfRange <Pointer>(nameof(Level)));
}
byte[] snapshot = default;
if (_snapshotter != null && previous != null)
{
var snapshotResult = await _snapshotter.StoreSnapshot(previous);
if (!snapshotResult.HasValue)
{
return(snapshotResult.CastError <byte[], Pointer>());
}
snapshot = snapshotResult.Value;
}
var meta = new MdMetadata
{
Level = this.Level - 1,
Snapshot = snapshot,
Previous = previous?.MdLocator,
StartIndex = previous?.EndIndex + 1 ?? 0
};
var md = await _dataOps.NodeFactory.CreateNewMdNodeAsync(meta).ConfigureAwait(false);
var leafPointer = await md.TryAppendAsync(value, expectedVersion).ConfigureAwait(false);
if (!leafPointer.HasValue)
{
return(leafPointer);
}
switch (md.Type)
{
case MdType.Pointers: // i.e. we have still not reached the end of the tree
await AddAsync(new Pointer
{
MdLocator = md.MdLocator,
ValueType = typeof(Pointer).Name
}).ConfigureAwait(false);
break;
case MdType.Values: // i.e. we are now right above leaf level
await AddAsync(new Pointer
{
MdLocator = leafPointer.Value.MdLocator,
ValueType = typeof(Pointer).Name
}).ConfigureAwait(false);
break;
default:
return(new ArgumentOutOfRange <Pointer>(nameof(md.Type)));
}
return(leafPointer);
}
public async Task <Result <Pointer> > TryAppendAsync(StoredValue value, ExpectedVersion expectedVersion)
{
if (IsFull)
{
return(new MdOutOfEntriesError <Pointer>($"Filled: {Count}/{Constants.MdCapacity}"));
}
switch (Type)
{
case MdType.Values:
var versionRes = ValidateVersion(expectedVersion);
if (!versionRes.HasValue) // optimistic concurrency
{
return(new VersionMismatch <Pointer>(versionRes.ErrorMsg));
}
return(await AddObjectAsync($"{NextVersion}", value).ConfigureAwait(false));
case MdType.Pointers:
if (Count > 0)
{
var pointer = await GetLastPointer().ConfigureAwait(false);
if (!pointer.HasValue)
{
return(pointer);
}
var targetResult = await _dataOps.NodeFactory.LocateAsync(pointer.Value.MdLocator).ConfigureAwait(false);
if (!targetResult.HasValue)
{
return(targetResult.CastError <IMdNode, Pointer>());
}
var target = targetResult.Value;
if (target.IsFull)
{
return(await ExpandLevelAsync(value, expectedVersion, previous : target).ConfigureAwait(false));
}
return(await target.TryAppendAsync(value, expectedVersion).ConfigureAwait(false));
}
// Count == 0, i.e. we must get last MdNode held by Previous for this node.
// (i.e. last node, one level down, of previous node on this level)
if (Previous == null) // (if null Previous, this would be the very first, still empty, MdNode in the tree)
{
return(await ExpandLevelAsync(value, expectedVersion, previous : default).ConfigureAwait(false));
}
var prevNode = await _dataOps.NodeFactory.LocateAsync(Previous).ConfigureAwait(false);
if (!prevNode.HasValue)
{
return(prevNode.CastError <IMdNode, Pointer>());
}
var lastPointerOfPrevNode = await(prevNode.Value as MdNode).GetLastPointer();
if (!lastPointerOfPrevNode.HasValue)
{
return(lastPointerOfPrevNode);
}
var prevNodeForNewNode = await _dataOps.NodeFactory.LocateAsync(lastPointerOfPrevNode.Value.MdLocator).ConfigureAwait(false);
if (!prevNodeForNewNode.HasValue)
{
return(prevNodeForNewNode.CastError <IMdNode, Pointer>());
}
return(await ExpandLevelAsync(value, expectedVersion, previous : prevNodeForNewNode.Value).ConfigureAwait(false));
default:
return(new ArgumentOutOfRange <Pointer>(nameof(Type)));
}
}
/// <summary>
/// Gets the values given a material
/// </summary>
/// <param name="m">The material</param>
/// <returns>A StoredValue containing value and type information</returns>
public List<StoredValue> GetValues(Material m)
{
var list = GetShaderProperties(m);
var output = new List<StoredValue>();
foreach (var p in list) {
var o = new StoredValue {
property = p
};
output.Add(o);
switch (p.type) {
case MaterialProperty.PropertyType.Color:
o.value = new object[1];
o.value[0] = m.GetColor(p.name);
break;
case MaterialProperty.PropertyType.Float:
o.value = new object[1];
o.value[0] = m.GetFloat(p.name);
break;
case MaterialProperty.PropertyType.Range:
o.value = new object[1];
o.value[0] = m.GetFloat(p.name);
break;
case MaterialProperty.PropertyType.TexEnv:
o.value = new object[3];
o.value[0] = m.GetTexture(p.name);
o.value[1] = m.GetTextureOffset(p.name);
o.value[2] = m.GetTextureScale(p.name);
break;
case MaterialProperty.PropertyType.Vector:
o.value = new object[1];
o.value[0] = m.GetVector(p.name);
break;
default:
Debug.LogError("Unsupported type: " + p.type.ToString());
break;
}
}
return output;
}
// Adds if not exists // It will return the direct pointer to the stored value // which makes it readily available for indexing at higher levels. public Task <Result <Pointer> > AppendAsync(StoredValue value) => TryAppendAsync(value, ExpectedVersion.Any);
