private void SetData(Keyword keyword, object value)
{
// The Uncompressed bit is also the sign bit (bit 63)
if (Flags < 0) // Same as (Flags & MPSchemaFlags.UncompressedBit)!=0
{
// Uncompressed data
Flags |= (SchemaFlags)(1L << (int)keyword);
(data as object[])[(int)keyword] = value;
}
else
{
// Compressed data
int index = GetIndex(keyword);
if (index >= 0)
{
(data as object[])[index] = value;
}
else if (index == -1)
{
data = value;
}
else
{
throw new InvalidOperationException("No space allocated");
}
}
}
public ISchemaGraphBuilder Delete(ITableConfig table, SchemaFlags flags)
{
var tables = default(HashSet <ITableConfig>);
var indexes = default(HashSet <IIndexConfig>);
var relations = default(HashSet <IRelationConfig>);
this.GetSchema(table, out tables, out indexes, out relations, flags);
return(this.OnDelete(tables, indexes, relations, flags));
}
private bool ValidateGeneric(Subschema schema, object instance)
{
bool finalResult = true;
for (SchemaFlags mask = schema.Flags & (SchemaFlags.GenericProperties & SchemaFlags.AllProperties);
mask != 0;
mask = (SchemaFlags)RemoveLowestBit((long)mask))
{
Keyword keyword = (Keyword)IndexOfLowestBit((long)mask);
bool? result = null;
Subschema[] schemaArray;
int index;
switch (keyword)
{
case Keyword.If:
int level = TurnOffErrors();
result = Validate(schema.If, instance, Keyword.If);
RestoreSuppressionLevel(level);
result = result == true
? Validate(schema.Then, instance, Keyword.Then)
: Validate(schema.Else, instance, Keyword.Else);
break;
case Keyword.Not:
level = TurnOffErrors();
result = !Validate(schema.Not, instance, Keyword.Not);
RestoreSuppressionLevel(level);
break;
case Keyword.AllOf:
result = true;
schemaArray = schema.AllOf;
SchemaPointer.Push(keyword);
for (index = 0; index < schemaArray.Length; index++)
{
if (!Validate(schemaArray[index], instance, index))
{
finalResult = false;
if (!IsRecordingErrors)
{
break;
}
}
}
SchemaPointer.Pop();
break;
case Keyword.AnyOf:
result = false;
level = TurnOffErrors();
schemaArray = schema.AnyOf;
SchemaPointer.Push(keyword);
for (index = 0; index < schemaArray.Length; index++)
{
if (Validate(schemaArray[index], instance, index))
{
result = true;
break;
}
}
SchemaPointer.Pop();
RestoreSuppressionLevel(level);
break;
case Keyword.OneOf:
result = false;
level = TurnOffErrors();
schemaArray = schema.OneOf;
SchemaPointer.Push(keyword);
for (index = 0; index < schemaArray.Length; index++)
{
if (Validate(schemaArray[index], instance, index))
{
result = !result;
if (result == false)
{
break;
}
}
}
SchemaPointer.Pop();
RestoreSuppressionLevel(level);
break;
case Keyword.Enum:
result = false;
// TODO: Provide support for type coercion
foreach (object v in (object[])schema.Enum.Value)
{
if (MPJson.Matches(v, instance))
{
result = true;
break;
}
}
break;
case Keyword.Const:
// TODO: Provide support for string to value coercion
result = MPJson.Matches(schema.Const.Value, instance);
break;
case Keyword._Ref:
var r = schema.Ref;
if (r.Version != 0)
{
var draft = new MPSchema(MPJson.From(instance), r.Version);
result = draft.IsValid;
break; // This was checked on creation
}
var rSchema = r.Schema;
result = rSchema != null && ReferenceUsageIsControlled();
if (result == true && !Validate(rSchema, instance, Keyword._Ref))
{
finalResult = false;
}
break;
case Keyword.Metadata:
break;
}
if (result == false)
{
finalResult = false;
if (ReportError(keyword, schema, instance))
{
return(false);
}
}
}
return(finalResult);
}
internal static TypeFlags SchemaFlagsToTypeFlags(SchemaFlags flags)
{
return((TypeFlags)((long)(flags & SchemaFlags.TypeAll) >> 56));
}
public ISchemaGraphBuilder Update(ITableConfig leftTable, ITableConfig rightTable, SchemaFlags flags)
{
var builder = this.Build();
builder.Alter.SetLeftTable(leftTable);
builder.Alter.SetRightTable(rightTable);
return(builder);
}
protected virtual ISchemaGraphBuilder OnAdd(IEnumerable <ITableConfig> tables, IEnumerable <IIndexConfig> indexes, IEnumerable <IRelationConfig> relations, SchemaFlags flags)
{
var queries = new List <ISchemaGraphBuilder>();
if (flags.HasFlag(SchemaFlags.Table))
{
queries.Add(this.OnAddTables(tables));
}
if (flags.HasFlag(SchemaFlags.Index))
{
queries.Add(this.OnAddIndexes(indexes));
}
if (flags.HasFlag(SchemaFlags.Relation))
{
queries.Add(this.OnAddRelations(relations));
}
return(new AggregateSchemaGraphBuilder(
this.Database,
queries
));
}
protected virtual void GetSchema(ITableConfig table, out HashSet <ITableConfig> tables, out HashSet <IIndexConfig> indexes, out HashSet <IRelationConfig> relations, SchemaFlags flags)
{
tables = new HashSet <ITableConfig>();
indexes = new HashSet <IIndexConfig>();
relations = new HashSet <IRelationConfig>();
if (flags.HasFlag(SchemaFlags.Recursive))
{
var queue = new Queue <ITableConfig>();
queue.Enqueue(table);
while (queue.Count > 0)
{
table = queue.Dequeue();
if (!tables.Add(table))
{
continue;
}
foreach (var index in table.Indexes)
{
indexes.Add(index);
}
foreach (var relation in table.Relations)
{
relations.Add(relation);
if (relation.MappingTable != null && !relation.MappingTable.Flags.HasFlag(TableFlags.Shared))
{
queue.Enqueue(relation.MappingTable);
}
if (relation.RightTable != null && !relation.RightTable.Flags.HasFlag(TableFlags.Shared))
{
queue.Enqueue(relation.RightTable);
}
}
}
}
else
{
tables.Add(table);
indexes.AddRange(table.Indexes);
relations.AddRange(table.Relations);
}
}
