static void CheckNodes(Referenced original, Referenced copy)
{
while (original != null)
{
Assert.That(copy.Data, Is.EqualTo(original.Data));
original = original.Next;
copy = copy.Next;
}
}
protected virtual bool OnReferenced(ReferencingEventArgs args)
{
if (Referenced != null)
{
Referenced.Invoke(this, args);
}
return(!args.Cancel);
}
public void Dispose()
{
if (Referenced != null)
{
Referenced.RemoveReference(Owner);
Referenced = null;
Owner = default;
}
}
public void InitializeNonparsableProperties(out IEnumerable <IConceptInfo> createdConcepts)
{
if (Referenced != null && Referenced != DataStructure)
{
throw new DslSyntaxException(this, string.Format(
"Incorrectly constructed Hierarchy property: it should reference itself. Reference='{0}', DataStructure='{1}'.",
Referenced.GetUserDescription(),
DataStructure.GetUserDescription()));
}
Referenced = DataStructure;
createdConcepts = null;
}
static Referenced GenerateNodes(int count)
{
var head = new Referenced()
{
Data = 123
};
for (int i = 0; i < count; i++)
{
head = new Referenced()
{
Data = i, Next = head
};
}
return(head);
}
public TypeRefDefinition Copy()
{
var t = new TypeRefDefinition
{
HasTemplateTypeParameter = HasTemplateTypeParameter,
IsConst = IsConst,
IsIncomplete = IsIncomplete,
Name = Name,
Referenced = Referenced != null?Referenced.Copy() : null,
TemplateParams = TemplateParams?.Select(p => p.Copy()).ToList(),
Target = Target,
Kind = Kind
};
return(t);
}
public override object Clone()
{
return(new TypeRefDefinition(Name)
{
HasTemplateTypeParameter = HasTemplateTypeParameter,
IsBasic = IsBasic,
Header = Header,
IsConst = IsConst,
IsConstantArray = IsConstantArray,
IsExcluded = IsExcluded,
IsPointer = IsPointer,
IsReference = IsReference,
Parent = Parent,
Referenced = Referenced != null ? (TypeRefDefinition)Referenced.Clone() : null,
SpecializedTemplateType = SpecializedTemplateType != null ? (TypeRefDefinition)SpecializedTemplateType.Clone() : null,
Target = Target
});
}
public TypeRefDefinition CopyTemplated(IDictionary <string, string> templateParams)
{
// Clang shows template parameters only as unexposed
if (HasTemplateTypeParameter && Kind == TypeKind.Unexposed)
{
return(new TypeRefDefinition(templateParams[Name]));
}
var t = new TypeRefDefinition
{
HasTemplateTypeParameter = HasTemplateTypeParameter,
IsConst = IsConst,
IsIncomplete = IsIncomplete,
Name = Name,
Referenced = Referenced != null?Referenced.CopyTemplated(templateParams) : null,
TemplateParams = TemplateParams?.Select(p => p.CopyTemplated(templateParams)).ToList(),
Target = Target,
Kind = Kind
};
return(t);
}
protected virtual GraphicsContext.Traits CreateTraits()
{
Referenced windata = GraphicsWindowWin32.WindowData.create(this.Handle);
GraphicsContext.Traits traits = new GraphicsContext.Traits();
traits.x = 0;
traits.y = 0;
traits.width = this.Width;
traits.height = this.Height;
traits.supportsResize = true;
traits.windowDecoration = false;
traits.doubleBuffer = true;
//traits.sharedContext = new GraphicsContextObserver();
traits.inheritedWindowData = new ReferencedRef(windata);
//traits.setInheritedWindowPixelFormat = true;
traits.setInheritedWindowPixelFormat = false;
traits.stencil = stencil;
traits.depth = depth;
traits.red = red;
traits.green = green;
traits.blue = blue;
traits.alpha = alpha;
traits.samples = (uint)numSamples; // to make anti-aliased
traits.sampleBuffers = (uint)((numSamples > 0) ? 1 : 0);
// disable vertical sync.
traits.vsync = this.EnableVSync;
traits.windowName = this.Name;
//traits.useMultiThreadedOpenGLEngine
traits.swapMethod = swapMethod;
//traits.glContextVersion = version;
return(traits);
}
public bool IsReferenced(BonsaiNode node)
{
return(Referenced.Contains(node.Behaviour));
}
public async Task can_use_keywords_in_include()
{
using (var store = GetDocumentStore())
{
var referencedDocs = new List <string>();
using (var session = store.OpenAsyncSession())
{
var expando = new ExpandoObject();
var dict = (IDictionary <string, object>)expando;
foreach (var keyword in QueryToken.RqlKeywords)
{
var referenced = new Referenced
{
Name = keyword
};
await session.StoreAsync(referenced, keyword);
dict[keyword] = referenced.Id;
referencedDocs.Add(referenced.Id);
}
var metadata = new ExpandoObject();
((IDictionary <string, object>)metadata)[Constants.Documents.Metadata.Collection] = "Users";
dict[Constants.Documents.Metadata.Key] = metadata;
await session.StoreAsync(expando);
await session.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession())
{
var query = session.Query <User>()
.Customize(x => x.WaitForNonStaleResults());
var expected = "from 'Users' include ";
var first = true;
foreach (var keyword in QueryToken.RqlKeywords)
{
query = query.Include(keyword);
if (first == false)
{
expected += ",";
}
first = false;
expected += $"'{keyword}'";
}
var queryString = query.ToString();
Assert.Equal(expected, queryString);
var result = await query.ToListAsync();
Assert.Equal(1, result.Count);
foreach (var docId in referencedDocs)
{
var doc = await session.LoadAsync <Referenced>(docId);
Assert.NotNull(doc);
Assert.Equal(doc.Id, doc.Name);
}
Assert.Equal(1, session.Advanced.NumberOfRequests);
}
}
}
