public IComponentDescriptor AddNewComponent(IndexSpec index)
{
var compo = new Component();
compo.Descriptor.Nest(this, index);
return(compo.Descriptor);
}
/// <summary>
/// Constructs a signal reference literal.
/// </summary>
/// <param name="desc">referenced descriptor</param>
/// <param name="prop">referenced signal property</param>
public SignalRef(ISignalOrPortDescriptor desc, EReferencedProperty prop)
{
Contract.Requires(desc != null);
Desc = desc;
Prop = prop;
Indices = new List <Expression[]>();
IndexSample = new IndexSpec();
IsStaticIndex = true;
}
public static IndexSpec[] JsonToIndexSpecCollection(string json)
{
var jarray = JArray.Parse(json);
List<IndexSpec> specs = new List<IndexSpec>();
foreach (JObject next in jarray)
{
var indexSpec = new IndexSpec(next.ExtractValue<string>("path"), new SmartStoreType(next.ExtractValue<string>("type")));
specs.Add(indexSpec);
}
return specs.ToArray();
}
/// <summary>
/// Returns the signal reference which results from applying an index to this one.
/// </summary>
/// <param name="index">index specifier to apply</param>
/// <returns>the indexed reference</returns>
public SignalRef ApplyIndex(IndexSpec index)
{
if (!IsStaticIndex)
{
throw new InvalidOperationException("Only applicable to static indices");
}
var asmRef = AssimilateIndices();
var resultIndex = index.Project(asmRef.IndexSample);
return(new SignalRef(asmRef.Desc, Prop, resultIndex.AsExpressions(), resultIndex, true));
}
/// <summary>
/// Constructs a signal reference literal.
/// </summary>
/// <param name="desc">referenced descriptor</param>
/// <param name="prop">referenced signal property</param>
/// <param name="indices">indices to apply</param>
/// <param name="indexSample">sample index</param>
/// <param name="isStaticIndex">whether the indices are static (i.e.) constant, in which case the sample index can be taken
/// for granted</param>
public SignalRef(ISignalOrPortDescriptor desc, EReferencedProperty prop,
IEnumerable <Expression[]> indices, IndexSpec indexSample, bool isStaticIndex)
{
Contract.Requires(desc != null);
Contract.Requires(indices != null);
Contract.Requires(indexSample != null);
Contract.Requires(indices.Count() == indexSample.Indices.Length);
Desc = desc;
Prop = prop;
Indices = indices.ToList();
IndexSample = indexSample;
IsStaticIndex = isStaticIndex;
}
public async Task <IndexerStatus> IndexAndWait(IndexSpec indexSpec, TimeSpan maxWait)
{
var timer = new Timer(maxWait.TotalMilliseconds);
timer.Elapsed += (sender, args) => { ((Timer)sender).Stop(); };
timer.Start();
var id = await Index(indexSpec);
IndexerStatus status;
do
{
status = await Status(id);
} while (status == IndexerStatus.Running && timer.Enabled);
return(status == IndexerStatus.Running ? IndexerStatus.Pending : status);
}
private void PopulateIndexList(List <Expression[]> result, IndexSpec indexSpec, TypeDescriptor elemType)
{
int count = indexSpec.Indices.Length;
var curSeq = indexSpec.Indices.Reverse();
while (curSeq.Any())
{
var seq = curSeq.Take(elemType.Rank).Reverse();
result.Add(seq
.Select(ds => ds.Kind == DimSpec.EKind.Index ?
LiteralReference.CreateConstant((int)ds) :
LiteralReference.CreateConstant((Range)ds))
.ToArray());
if (seq.Any(ds => ds.Kind == DimSpec.EKind.Range))
{
break;
}
curSeq = curSeq.Skip(elemType.Rank);
elemType = elemType.Element0Type;
}
}
protected override void DeclareAlgorithm()
{
var srCur = SignalRef.Create(_taSite._portSignal, SignalRef.EReferencedProperty.Cur);
var lrCur = new LiteralReference(srCur);
if (_taSite._portSignal.ElementType.CILType.Equals(typeof(StdLogic)))
{
var index = new IndexSpec((DimSpec)0);
var srSLV = new SignalRef(
_taSite._slvSignal,
SignalRef.EReferencedProperty.Next,
index.AsExpressions(),
index, true);
Store(srSLV, lrCur);
}
else
{
var convFn = IntrinsicFunctions.Cast(lrCur,
_taSite._portSignal.ElementType.CILType,
_taSite._slvSignal.ElementType);
var srSLV = SignalRef.Create(_taSite._slvSignal, SignalRef.EReferencedProperty.Next);
Store(srSLV, convFn);
}
}
/// <summary>
/// Constructs a signal reference literal.
/// </summary>
/// <param name="desc">referenced descriptor</param>
/// <param name="prop">referenced signal property</param>
/// <param name="indices">indices to apply</param>
/// <param name="indexSample">sample index</param>
/// <param name="isStaticIndex">whether the indices are static (i.e.) constant, in which case the sample index can be taken
/// for granted</param>
public SignalRef(ISignalOrPortDescriptor desc, EReferencedProperty prop,
IEnumerable<Expression[]> indices, IndexSpec indexSample, bool isStaticIndex)
{
Contract.Requires(desc != null);
Contract.Requires(indices != null);
Contract.Requires(indexSample != null);
Contract.Requires(indices.Count() == indexSample.Indices.Length);
Desc = desc;
Prop = prop;
Indices = indices.ToList();
IndexSample = indexSample;
IsStaticIndex = isStaticIndex;
}
private void PopulateIndexList(List<Expression[]> result, IndexSpec indexSpec, TypeDescriptor elemType)
{
int count = indexSpec.Indices.Length;
var curSeq = indexSpec.Indices.Reverse();
while (curSeq.Any())
{
var seq = curSeq.Take(elemType.Rank).Reverse();
result.Add(seq
.Select(ds => ds.Kind == DimSpec.EKind.Index ?
LiteralReference.CreateConstant((int)ds) :
LiteralReference.CreateConstant((Range)ds))
.ToArray());
if (seq.Any(ds => ds.Kind == DimSpec.EKind.Range))
break;
curSeq = curSeq.Skip(elemType.Rank);
elemType = elemType.Element0Type;
}
}
/// <summary>
/// Constructs a signal reference literal.
/// </summary>
/// <param name="desc">referenced descriptor</param>
/// <param name="prop">referenced signal property</param>
public SignalRef(ISignalOrPortDescriptor desc, EReferencedProperty prop)
{
Contract.Requires(desc != null);
Desc = desc;
Prop = prop;
Indices = new List<Expression[]>();
IndexSample = new IndexSpec();
IsStaticIndex = true;
}
public IndexSpecBuilder(string dataSource)
{
_spec = new IndexSpec();
_spec.Spec.DataSchema.DataSource = dataSource;
_spec.Type = _spec.Spec.TuningConfig.Type = _spec.Spec.IoConfig.Type = IndexType;
}
public IndexDetail(IndexSpec index)
: base(index)
{
}
public override bool Rewrite(
CodeDescriptor decompilee,
MethodBase callee,
StackElement[] args,
IDecompiler stack,
IFunctionBuilder builder)
{
if (args.Length < 2)
throw new InvalidOperationException("The attribute SignalIndexer was applied to the wrong method");
LiteralReference refExpr = args[0].Expr as LiteralReference;
if (refExpr == null)
throw new InvalidOperationException("Unable to resolve port/signal reference expression");
DimSpec[] dimSamples = new DimSpec[args.Length - 1];
Expression[] indices = args.Skip(1).Select(arg => arg.Expr).ToArray();
bool isStatic = true;
for (int i = 1; i < args.Length; i++)
{
var convidx = TypeConversions.ConvertValue(args[i].Sample, typeof(int));
if (convidx != null)
{
dimSamples[i - 1] = (int)convidx;
}
else if (args[i].Sample is Range)
{
dimSamples[i - 1] = (Range)args[i].Sample;
}
else
{
dimSamples = null;
break;
}
// EVariability.LocalVariable is not static as well, since variables
// inside for loops will have that variability.
if (args[i].Variability != EVariability.Constant)
isStatic = false;
}
IndexSpec indexSpec = null;
indexSpec = new IndexSpec(dimSamples);
SignalRef sigRef = null;
LambdaLiteralVisitor llv = new LambdaLiteralVisitor()
{
OnVisitConstant = x =>
{
sigRef = new SignalRef(
((SignalBase)x.ConstantValue).Descriptor,
SignalRef.EReferencedProperty.Instance,
new Expression[][] { indices }, indexSpec, isStatic);
},
OnVisitFieldRef = x => { throw new InvalidOperationException(); },
OnVisitSignalRef = x =>
{
sigRef = new SignalRef(
x.Desc,
x.Prop,
x.Indices.Concat(new Expression[][] { indices }),
indexSpec.Project(x.IndexSample),
x.IsStaticIndex && isStatic);
},
OnVisitVariable = x => { throw new InvalidOperationException(); },
OnVisitThisRef = x => { throw new InvalidOperationException(); }
};
refExpr.ReferencedObject.Accept(llv);
object rsample = null;
Type[] argTypes = args
.Skip(1)
.Select(a => a.Expr.ResultType.CILType)
.ToArray();
object[] argSamples = args
.Select(a => a.Sample)
.ToArray();
MethodInfo indexerSampleMethod = callee.DeclaringType.GetMethod(
"GetIndexerSample",
BindingFlags.Instance | BindingFlags.NonPublic,
null,
argTypes,
null);
if (indexerSampleMethod != null && argSamples.All(a => a != null))
{
rsample = indexerSampleMethod.Invoke(argSamples);
}
else
{
try
{
rsample = callee.Invoke(args.Select(x => x.Sample).ToArray());
}
catch (TargetInvocationException)
{
}
}
stack.Push(sigRef, rsample);
return true;
}
public DescriptorNestingByIndex(IndexSpec index)
{
_index = index;
}
public PrimaryKeyDetail(IndexSpec index)
: base(index)
{
}
public DescriptorNestingByNameAndIndex(string name, IndexSpec index) :
base(index)
{
_name = name;
}
public virtual void Nest(IDescriptor owner, IndexSpec index)
{
owner.AddChild(this);
Owner = owner;
_implementation = new DescriptorNestingByIndex(index);
}
public DescriptorNestingByNameAndIndex(string name, IndexSpec index) :
base(index)
{
_name = name;
}
/// <summary>
/// Builds the schema
/// </summary>
/// <param name="dbStore"></param>
private void Build(DbStore dbStore)
{
// Get all "tables"
var storeSchemaProperties = this.GetType().GetProperties()
.Where(x => x.PropertyType.IsGenericType && x.PropertyType.GetGenericTypeDefinition() == typeof(IndexedSet <>));
// For all tables
foreach (var schemaProperty in storeSchemaProperties)
{
// Create schema
var schema = new StoreSchema()
{
Name = schemaProperty.Name,
Indexes = new List <IndexSpec>(),
};
// Get generic parameter of list<T> (type T, only supports IndexedSet<T> ergo 1 parameter)
var propertyType = schemaProperty.PropertyType.GetGenericArguments()[0];
// Get all properties of the generic type T
var properties = propertyType.GetProperties();
Dictionary <string, List <string> > compoundIndices = new Dictionary <string, List <string> >();
foreach (var property in properties)
{
// If any non supported object is used throw exception here
if (property.PropertyType.IsGenericType && !property.PropertyType.Namespace.StartsWith("System"))
{
throw new NotSupportedException(property.PropertyType.FullName);
}
// Get attributes from the entity property, ergo column
var attributes = property.CustomAttributes;
var id = false;
var unique = false;
var autoIncrement = false;
var foreignKey = false;
var multiEntry = false;
// Check for settings via attributes here (additonal attributes have to be checked here)
if (attributes.Any(x => x.AttributeType == typeof(KeyAttribute)))
{
id = true;
}
if (attributes.Any(x => x.AttributeType == typeof(UniqueAttribute)))
{
unique = true;
}
if (attributes.Any(x => x.AttributeType == typeof(MultiEntryAttribute)))
{
multiEntry = true;
}
if (attributes.Any(x => x.AttributeType == typeof(AutoIncrementAttribute)))
{
autoIncrement = true;
}
if (attributes.Any(x => x.AttributeType == typeof(ForeignKeyAttribute)))
{
if (id)
{
throw new NotSupportedException("PK cannot be FK");
}
foreignKey = true;
}
var columnName = this.FirstToLower(property.Name);
foreach (var attributeData in attributes.Where(x => x.AttributeType == typeof(CompoundIndexAttribute)))
//foreach (var attribute in attributes.OfType<CompoundIndexAttribute>())
{
var name = attributeData.ConstructorArguments[0].Value as string;
name = this.FirstToLower(name);
compoundIndices.TryGetValue(name, out var list);
if (list == null)
{
list = new List <string>();
}
list.Add(columnName);
compoundIndices[name] = list;
Debug.WriteLine($"{nameof(IndexedDb)} -Compound key detected: {name}:{columnName}={string.Join(",",list)}");
}
// Define index
var index = new IndexSpec {
Name = columnName, KeyPath = columnName, Auto = autoIncrement, Unique = unique, MultiEntry = multiEntry
};
// Register index
if (id)
{
// Throw invalid operation when index has already been defined
if (schema.PrimaryKey != null)
{
throw new InvalidOperationException("PK already defined");
}
Debug.WriteLine($"{nameof(IndexedDb)} - {schemaProperty.Name} - PK-> {columnName}");
index.Auto = true;
schema.PrimaryKey = index;
}
else if (!foreignKey)
{
Debug.WriteLine($"{nameof(IndexedDb)} - {schemaProperty.Name} - Property -> {columnName}");
schema.Indexes.Add(index);
}
}
foreach (var compound in compoundIndices)
{
Debug.WriteLine($"{nameof(IndexedDb)} -Compound key queued: {compound.Key} : {string.Join(",", compound.Value)}");
var index = new IndexSpec {
Name = compound.Key, KeyPaths = compound.Value.ToArray(), Compound = true /*Unique = unique, MultiEntry = multiEntry*/
};
schema.Indexes.Add(index);
}
// Create PK when not defined
if (schema.PrimaryKey == null)
{
var idPropertyName = "Id";
var idColumnName = this.FirstToLower(idPropertyName);
// Check for registered id property without declared key attribute
if (properties.Any(x => x.Name == idPropertyName))
{
var idProperty = schema.Indexes.Single(x => x.Name == idColumnName);
// Remove from schema
schema.Indexes.Remove(idProperty);
// And set as primary key
schema.PrimaryKey = idProperty;
// Set to auto, default setting
schema.PrimaryKey.Auto = true;
}
else
{
throw new NotSupportedException("Missing id property");
// Not supported because no implementation for changed check when deleted (missing id to resolve object in store)
//schema.PrimaryKey = new IndexSpec { Name = idColumnName, KeyPath = idColumnName, Auto = true };
}
}
// Add schema to registered schemas
dbStore.Stores.Add(schema);
}
Debug.WriteLine($"{nameof(IndexedDb)} - Schema has been built");
}
public async Task <string> Index(IndexSpec indexSpec)
{
return((await GetIndexer().Index(indexSpec)).Task);
}
public UniqueKeyDetail(IndexSpec index) : base(index)
{
}
/// <summary>
/// Returns the signal reference which results from applying an index to this one.
/// </summary>
/// <param name="index">index specifier to apply</param>
/// <returns>the indexed reference</returns>
public SignalRef ApplyIndex(IndexSpec index)
{
if (!IsStaticIndex)
throw new InvalidOperationException("Only applicable to static indices");
var asmRef = AssimilateIndices();
var resultIndex = index.Project(asmRef.IndexSample);
return new SignalRef(asmRef.Desc, Prop, resultIndex.AsExpressions(), resultIndex, true);
}
/// <summary>
/// Converts an index specifier to an array of expressions.
/// </summary>
/// <param name="indexSpec">index specifier to convert</param>
/// <returns>nested array of expressions, each representing an individual index</returns>
public static Expression[][] AsExpressions(this IndexSpec indexSpec)
{
return(indexSpec.Indices.Select(idx => new Expression[] { idx.AsExpression() }).ToArray());
}
public IndexBasedConstraintDetail(IndexSpec index) : base(index.ConstraintName, index.DatabaseName, index.SchemaName, index.TableName)
{
_index = index;
}
public IndexGetSuffix(IndexSpec indexSpec) => this.indexSpec = indexSpec;
internal static SDK.SmartStore.Store.IndexSpec[] ConvertToSdkIndexSpecs(IndexSpec[] indexSpecs)
{
var specs = from n in indexSpecs select n._indexSpec;
return specs.ToArray();
}
public DescriptorNestingByIndex(IndexSpec index)
{
_index = index;
}