//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldContainFedRelationshipUpdate() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldContainFedRelationshipUpdate()
{
OnlineIndexUpdates onlineIndexUpdates = new OnlineIndexUpdates(_nodeStore, _relationshipStore, _indexingService, _propertyPhysicalToLogicalConverter);
long relId = 0;
RelationshipRecord inUse = GetRelationship(relId, true, ENTITY_TOKEN);
Value propertyValue = Values.of("hej");
long propertyId = CreateRelationshipProperty(inUse, propertyValue, 1);
RelationshipRecord notInUse = GetRelationship(relId, false, ENTITY_TOKEN);
_relationshipStore.updateRecord(inUse);
Command.RelationshipCommand relationshipCommand = new Command.RelationshipCommand(inUse, notInUse);
PropertyRecord propertyBlocks = new PropertyRecord(propertyId);
propertyBlocks.RelId = relId;
Command.PropertyCommand propertyCommand = new Command.PropertyCommand(_recordAccess.getIfLoaded(propertyId).forReadingData(), propertyBlocks);
StoreIndexDescriptor indexDescriptor = forSchema(multiToken(_entityTokens, RELATIONSHIP, 1, 4, 6), EMPTY.ProviderDescriptor).withId(0);
_indexingService.createIndexes(indexDescriptor);
_indexingService.getIndexProxy(indexDescriptor.Schema()).awaitStoreScanCompleted(0, MILLISECONDS);
onlineIndexUpdates.Feed(NodeGroup(null), RelationshipGroup(relationshipCommand, propertyCommand));
assertTrue(onlineIndexUpdates.HasUpdates());
IEnumerator <IndexEntryUpdate <SchemaDescriptor> > iterator = onlineIndexUpdates.GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
assertEquals(iterator.next(), IndexEntryUpdate.remove(relId, indexDescriptor, propertyValue, null, null));
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
assertFalse(iterator.hasNext());
}
private void CheckProperty(NodeRecord record, CheckerEngine <NodeRecord, Org.Neo4j.Consistency.report.ConsistencyReport_NodeConsistencyReport> engine, ICollection <PropertyRecord> props)
{
if (!Record.NO_NEXT_PROPERTY.@is(record.NextProp))
{
PropertyRecord firstProp = props.GetEnumerator().next();
if (!Record.NO_PREVIOUS_PROPERTY.@is(firstProp.PrevProp))
{
engine.Report().propertyNotFirstInChain(firstProp);
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.set.primitive.MutableIntSet keys = new org.eclipse.collections.impl.set.mutable.primitive.IntHashSet();
MutableIntSet keys = new IntHashSet();
foreach (PropertyRecord property in props)
{
if (!property.InUse())
{
engine.Report().propertyNotInUse(property);
}
else
{
foreach (int key in ChainCheck.keys(property))
{
if (!keys.add(key))
{
engine.Report().propertyKeyNotUniqueInChain();
}
}
}
}
}
}
private void UpdateLayoutProperties(string typeName, LayoutRecord layoutRecord, IEnumerable <string> properties)
{
layoutRecord.Properties.Clear();
if (properties == null)
{
return;
}
string category = typeName + "ContentFields";
const string settingName = "CoeveryTextFieldSettings.IsDispalyField";
var allFields = _contentDefinitionManager.GetPartDefinition(typeName).Fields.ToList();
foreach (var property in properties)
{
var field = allFields.FirstOrDefault(c => c.Name == property);
if (field == null)
{
continue;
}
var propertyRecord = new PropertyRecord {
Category = category,
Type = string.Format("{0}.{1}.", typeName, property),
Description = field.DisplayName,
Position = layoutRecord.Properties.Count,
LinkToContent = field.Settings.ContainsKey(settingName) && bool.Parse(field.Settings[settingName])
};
layoutRecord.Properties.Add(propertyRecord);
}
}
public bool Purge(bool purgeAll)
{
bool foundDirt = false;
if (!purgeAll)
{
// copy the keys into a separate array, so that later on
// we can change the dictionary while iterating over the keys
ICollection ic = _dict.Keys;
String[] keys = new String[ic.Count];
ic.CopyTo(keys, 0);
for (int i = keys.Length - 1; i >= 0; --i)
{
if (keys[i] == AllListenersKey)
{
continue; // ignore the special entry for now
}
// for each key, remove dead entries in its list
PropertyRecord pr = (PropertyRecord)_dict[keys[i]];
if (pr.Purge())
{
foundDirt = true;
}
// if there are no more entries, remove the key
if (pr.IsEmpty)
{
pr.StopListening(_type);
_dict.Remove(keys[i]);
}
}
if (foundDirt)
{
// if any entries were purged, invalidate the special entry
_dict.Remove(AllListenersKey);
_proposedAllListenersList = null;
}
if (IsEmpty)
{
StopListening();
}
}
else
{
// stop listening. List cleanup is handled by Purge()
foundDirt = true;
StopListening();
foreach (DictionaryEntry de in _dict)
{
PropertyRecord pr = (PropertyRecord)de.Value;
pr.StopListening(_type);
}
}
return(foundDirt);
}
private bool MakeDtoLine(string currentLine, string searchType)
{
string padding = " ";
currentLine = currentLine.Replace(@"?", "questionmark");
searchType = searchType.Replace(@"?", "questionmark");
if (currentLine.Contains("public " + searchType + " "))
{
Regex regex = new Regex(@"(?<=\bpublic " + searchType + @" )(\w+)");
Match match = regex.Match(currentLine);
if (match.Success)
{
PropertyRecord.Add(match.Value);
var neLine = padding + @"public " + searchType + " " + match.Value +
" { get => _current." + match.Value +
"; set { _current." + match.Value + " = value; OnPropertyChanged(); } }";
neLine = neLine.Replace("questionmark", @"?");
searchType = searchType.Replace("questionmark", @"?");
CloneLines.Add(padding + padding + match.Value + " = this." + match.Value + ",");
return(true);
}
}
return(false);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldIterateOverBlocks()
public virtual void ShouldIterateOverBlocks()
{
// GIVEN
PropertyRecord record = new PropertyRecord(0);
PropertyBlock[] blocks = new PropertyBlock[3];
for (int i = 0; i < blocks.Length; i++)
{
blocks[i] = new PropertyBlock();
record.AddPropertyBlock(blocks[i]);
}
// WHEN
IEnumerator <PropertyBlock> iterator = record.GetEnumerator();
// THEN
foreach (PropertyBlock block in blocks)
{
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
assertTrue(iterator.hasNext());
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
assertEquals(block, iterator.next());
}
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
assertFalse(iterator.hasNext());
}
public BAMLConverterMemberReference(BAMLAnalyzer.XmlNsContext xmlnsCtx, TypeSig sig, IDnlibDef member, PropertyRecord rec)
{
this.xmlnsCtx = xmlnsCtx;
this.sig = sig;
this.member = member;
this.rec = rec;
}
private bool PropertyFitsInside(int newBlockSizeInBytes, PropertyRecord propRecord)
{
int propSize = propRecord.Size();
Debug.Assert(propSize >= 0, propRecord);
return(propSize + newBlockSizeInBytes <= PropertyType.PayloadSize);
}
private void UpdateLayoutProperties(string entityName, ref LayoutRecord layout, string category, string settingName, IEnumerable <string> pickedFileds)
{
var allFields = _contentDefinitionManager.GetPartDefinition(entityName).Fields.ToList();
const string fieldTypeFormat = "{0}.{1}.";
foreach (var property in pickedFileds)
{
var names = property.Split('.');
var propertyMatch = string.Format(fieldTypeFormat, names[0], names[1]);
var field = allFields.FirstOrDefault(c =>
string.Format(fieldTypeFormat, entityName, c.Name) == propertyMatch);
if (field == null)
{
continue;
}
var fieldStateProvider = _fieldToPropertyStateProviders.FirstOrDefault(provider => provider.CanHandle(field.FieldDefinition.Name));
if (fieldStateProvider == null)
{
throw new NotSupportedException("The field type \"" + field.FieldDefinition.Name + "\" is not supported!");
}
var propertyRecord = new PropertyRecord {
Category = category,
Type = property,
Description = field.DisplayName,
Position = layout.Properties.Count,
State = fieldStateProvider.GetPropertyState(field.FieldDefinition.Name, property, field.Settings),
LinkToContent = field.Settings.ContainsKey(settingName) && bool.Parse(field.Settings[settingName])
};
layout.Properties.Add(propertyRecord);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private boolean visitPropertyRecordChain(long firstPropertyRecordId, org.neo4j.helpers.collection.Visitor<org.neo4j.kernel.impl.store.record.PropertyRecord,RuntimeException> visitor) throws CircularPropertyRecordChainException
private bool VisitPropertyRecordChain(long firstPropertyRecordId, Visitor <PropertyRecord, Exception> visitor)
{
if (Record.NO_NEXT_PROPERTY.@is(firstPropertyRecordId))
{
return(false);
}
MutableLongSet visitedPropertyRecordIds = new LongHashSet(8);
visitedPropertyRecordIds.add(firstPropertyRecordId);
long nextProp = firstPropertyRecordId;
while (!Record.NO_NEXT_PROPERTY.@is(nextProp))
{
PropertyRecord propRecord = _propertyStore.getRecord(nextProp, _propertyStore.newRecord(), FORCE);
nextProp = propRecord.NextProp;
if (!Record.NO_NEXT_PROPERTY.@is(nextProp) && !visitedPropertyRecordIds.add(nextProp))
{
throw new CircularPropertyRecordChainException(propRecord);
}
if (visitor.Visit(propRecord))
{
return(true);
}
}
return(false);
}
void DisassembleRecord(BamlContext ctx, PropertyRecord record)
{
WriteText("AttributeId=");
WriteAttributeId(ctx, record.AttributeId);
WriteText(", Value=");
WriteString(record.Value);
}
private bool MakePropertyLine(string currentLine, string searchToken, string defaultValue)
{
string padding = " ";
currentLine = currentLine.Replace(@"?", "questionmark");
searchToken = searchToken.Replace(@"?", "questionmark");
if (currentLine.Contains("public " + searchToken + " "))
{
Regex regex = new Regex(@"(?<=\bpublic " + searchToken + @" )(\w+)");
Match match = regex.Match(currentLine);
if (match.Success)
{
PropertyRecord.Add(match.Value);
var neLine = padding + @"public Property<" + searchToken + "> " + match.Value +
" { get; set; } = new Property<" + searchToken +
">(){" + defaultValue + "};";
neLine = neLine.Replace("questionmark", @"?");
searchToken = searchToken.Replace("questionmark", @"?");
TargetLines.Add(neLine);
//this.ID = Property<int>.Make(test.ID);
var makeLine = padding + @"this." + match.Value + " = Property<" + searchToken + ">.Make(test." + match.Value + ");";
MakeLines.Add(makeLine);
//ConvertToDtoLines
var convertLine = padding + "returnVal." + match.Value + " = " + match.Value + ".Value;";
ConvertToDtoLines.Add(convertLine);
var cloneLines = padding + "" + match.Value + " = this." + match.Value + ";";
CloneLines.Add(cloneLines);
var resetLine = padding + "" + match.Value + ".Revert();";
ResetLines.Add(resetLine);
return(true);
}
}
return(false);
}
private static void AddBlock(PropertyRecord record, int key, int value)
{
PropertyBlock block = new PropertyBlock();
PropertyStore.EncodeValue(block, key, Values.of(value), null, null, true);
foreach (long valueBlock in block.ValueBlocks)
{
record.AddLoadedBlock(valueBlock);
}
}
public NodeImporter(BatchingNeoStores stores, IdMapper idMapper, Monitor monitor) : base(stores, monitor)
{
this._labelTokenRepository = stores.LabelRepository;
this._idMapper = idMapper;
this._nodeStore = stores.NodeStore;
this._nodeRecord = _nodeStore.newRecord();
this._nodeIds = new BatchingIdGetter(_nodeStore);
this._idPropertyStore = stores.TemporaryPropertyStore;
this._idPropertyRecord = _idPropertyStore.newRecord();
_nodeRecord.InUse = true;
}
private void RemoveProperty(PrimitiveRecord primitive, PropertyRecord host, PropertyBlock block)
{
host.RemovePropertyBlock(block.KeyIndexId);
host.Changed = primitive;
foreach (DynamicRecord record in block.ValueRecords)
{
Debug.Assert(record.InUse());
record.SetInUse(false, block.Type.intValue());
host.AddDeletedRecord(record);
}
}
// Rebuilds the propertyRecords and missingParameters collections.
private void RefreshPropertyRecords(EditorEventRef eventRef)
{
propertyRecords.Clear();
foreach (SerializedObject serializedTarget in serializedTargets)
{
SerializedProperty paramsProperty = serializedTarget.FindProperty("Params");
foreach (SerializedProperty parameterProperty in paramsProperty)
{
string name = parameterProperty.FindPropertyRelative("Name").stringValue;
SerializedProperty valueProperty = parameterProperty.FindPropertyRelative("Value");
PropertyRecord record = propertyRecords.Find(r => r.name == name);
if (record != null)
{
record.valueProperties.Add(valueProperty);
}
else
{
EditorParamRef paramRef = eventRef.LocalParameters.Find(p => p.Name == name);
if (paramRef != null)
{
propertyRecords.Add(
new PropertyRecord()
{
paramRef = paramRef,
valueProperties = new List <SerializedProperty>()
{
valueProperty
},
});
}
}
}
}
// Only sort if there is a multi-selection. If there is only one object selected,
// the user can revert to prefab, and the behaviour depends on the array order,
// so it's helpful to show the true order.
if (serializedTargets.Count > 1)
{
propertyRecords.Sort((a, b) => EditorUtility.NaturalCompare(a.name, b.name));
}
missingParameters.Clear();
missingParameters.AddRange(eventRef.LocalParameters.Where(
p => {
PropertyRecord record = propertyRecords.Find(r => r.name == p.Name);
return(record == null || record.valueProperties.Count < serializedTargets.Count);
}));
}
public virtual void GetPropertyChain(long nextProp, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords, Listener <PropertyBlock> collector)
{
while (nextProp != Record.NO_NEXT_PROPERTY.intValue())
{
PropertyRecord propRecord = propertyRecords.GetOrLoad(nextProp, null).forReadingData();
foreach (PropertyBlock propBlock in propRecord)
{
collector.Receive(propBlock);
}
nextProp = propRecord.NextProp;
}
}
private static PropertyRecord[] ExtractPropertyRecords(RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecordAccess, long nextProp)
{
IList <PropertyRecord> result = new List <PropertyRecord>();
while (!Record.NULL_REFERENCE.@is(nextProp))
{
PropertyRecord record = propertyRecordAccess.GetIfLoaded(nextProp).forReadingLinkage();
result.Add(record);
nextProp = record.NextProp;
}
return(result.ToArray());
}
protected internal EntityImporter(BatchingNeoStores stores, Monitor monitor)
{
this._propertyStore = stores.PropertyStore;
this._propertyKeyTokenRepository = stores.PropertyKeyRepository;
this.Monitor = monitor;
for (int i = 0; i < _propertyBlocks.Length; i++)
{
_propertyBlocks[i] = new PropertyBlock();
}
this._propertyRecord = _propertyStore.newRecord();
this._propertyIds = new BatchingIdGetter(_propertyStore);
this._dynamicStringRecordAllocator = new StandardDynamicRecordAllocator(new BatchingIdGetter(_propertyStore.StringStore, _propertyStore.StringStore.RecordsPerPage), _propertyStore.StringStore.RecordDataSize);
this._dynamicArrayRecordAllocator = new StandardDynamicRecordAllocator(new BatchingIdGetter(_propertyStore.ArrayStore, _propertyStore.ArrayStore.RecordsPerPage), _propertyStore.StringStore.RecordDataSize);
}
private bool MakeListLine(string currentLine, string searchType)
{
string padding = " ";
currentLine = currentLine.Replace(@"?", "questionmark");
searchType = searchType.Replace(@"?", "questionmark");
if (currentLine.Contains("public " + searchType + " "))
{
Regex regex = new Regex(@"(?<=\bpublic " + searchType + @" )(\w+)");
Match match = regex.Match(currentLine);
if (match.Success)
{
PropertyRecord.Add(match.Value);
var neLine = padding + @"public " + searchType + " " + match.Value +
" { get => _current." + match.Value +
"; set { _current." + match.Value + " = value; OnPropertyChanged(); } }";
neLine = neLine.Replace("questionmark", @"?");
searchType = searchType.Replace("questionmark", @"?");
TargetLines.Add(neLine);
//public bool Completed { get => _current.Completed; set { _current.Completed = value; OnPropertyChanged(); } }
MakeLines.Add(padding + @"_original." + match.Value + " = test." + match.Value + ";");
MakeLines.Add(padding + @"_current." + match.Value + " = test." + match.Value + ";");
var convertLine = padding + "returnVal." + match.Value + " = this." + match.Value + ";";
ConvertToDtoLines.Add(convertLine);
var cloneLines = padding + "" + match.Value + " = this." + match.Value + ";";
var resetLine = padding + "" + match.Value + ".Revert();";
CloneLines.Add(cloneLines);
return(true);
}
}
return(false);
}
public static void DeletePropertyRecordIncludingValueRecords(PropertyRecord record)
{
foreach (PropertyBlock block in record)
{
foreach (DynamicRecord valueRecord in block.ValueRecords)
{
Debug.Assert(valueRecord.InUse());
valueRecord.InUse = false;
record.AddDeletedRecord(valueRecord);
}
}
record.ClearPropertyBlocks();
record.InUse = false;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void addLoadedBlock()
public virtual void AddLoadedBlock()
{
PropertyRecord record = new PropertyRecord(42);
AddBlock(record, 1, 2);
AddBlock(record, 3, 4);
IList <PropertyBlock> blocks = Iterables.asList(record);
assertEquals(2, blocks.Count);
assertEquals(1, blocks[0].KeyIndexId);
assertEquals(2, blocks[0].SingleValueInt);
assertEquals(3, blocks[1].KeyIndexId);
assertEquals(4, blocks[1].SingleValueInt);
}
public static string GetFiledName(this PropertyRecord property)
{
string type = property.Type;
var pattern = @"[^\.]*\.(.*)\.[^\.]*";
var regex = new Regex(pattern, RegexOptions.Compiled);
foreach (Match myMatch in regex.Matches(type))
{
if (myMatch.Success)
{
return(myMatch.Groups[1].Value);
}
}
return(type);
}
private void AddProperty(PropertyInfo info, SpecialPropertyAttribute attr)
{
PropertyRecord record = new PropertyRecord()
{
Info = info,
Attr = attr,
};
if (attr.Converter != null && attr.Converter.IsSubclassOf(typeof(PropertyConverter)))
{
record.Converter = Activator.CreateInstance(attr.Converter) as PropertyConverter;
}
_records[attr.Name ?? info.Name] = record;
}
public virtual void Create(PropertyRecord property)
{
property.SetCreated();
PropertyRecord before = new PropertyRecord(property.Id);
if (property.NodeSet)
{
before.NodeId = property.NodeId;
}
if (property.RelSet)
{
before.RelId = property.RelId;
}
Update(before, property);
}
public override void CheckReference(RECORD record, PropertyRecord property, CheckerEngine <RECORD, REPORT> engine, RecordAccess records)
{
if (!property.InUse())
{
engine.Report().propertyNotInUse(property);
}
else
{
if (!Record.NO_PREVIOUS_PROPERTY.@is(property.PrevProp))
{
engine.Report().propertyNotFirstInChain(property);
}
(new ChainCheck <RECORD, REPORT>()).CheckReference(record, property, engine, records);
}
}
public virtual void DeletePropertyChain(PrimitiveRecord primitive, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords)
{
long nextProp = primitive.NextProp;
while (nextProp != Record.NO_NEXT_PROPERTY.intValue())
{
RecordAccess_RecordProxy <PropertyRecord, PrimitiveRecord> propertyChange = propertyRecords.GetOrLoad(nextProp, primitive);
// TODO forChanging/forReading piggy-backing
PropertyRecord propRecord = propertyChange.ForChangingData();
DeletePropertyRecordIncludingValueRecords(propRecord);
nextProp = propRecord.NextProp;
propRecord.Changed = primitive;
}
primitive.NextProp = Record.NO_NEXT_PROPERTY.intValue();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldDifferentiateNodesAndRelationships() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldDifferentiateNodesAndRelationships()
{
OnlineIndexUpdates onlineIndexUpdates = new OnlineIndexUpdates(_nodeStore, _relationshipStore, _indexingService, _propertyPhysicalToLogicalConverter);
int nodeId = 0;
NodeRecord inUseNode = GetNode(nodeId, true);
Value nodePropertyValue = Values.of("hej");
long nodePropertyId = CreateNodeProperty(inUseNode, nodePropertyValue, 1);
NodeRecord notInUseNode = GetNode(nodeId, false);
_nodeStore.updateRecord(inUseNode);
Command.NodeCommand nodeCommand = new Command.NodeCommand(inUseNode, notInUseNode);
PropertyRecord nodePropertyBlocks = new PropertyRecord(nodePropertyId);
nodePropertyBlocks.NodeId = nodeId;
Command.PropertyCommand nodePropertyCommand = new Command.PropertyCommand(_recordAccess.getIfLoaded(nodePropertyId).forReadingData(), nodePropertyBlocks);
StoreIndexDescriptor nodeIndexDescriptor = forSchema(multiToken(_entityTokens, NODE, 1, 4, 6), EMPTY.ProviderDescriptor).withId(0);
_indexingService.createIndexes(nodeIndexDescriptor);
_indexingService.getIndexProxy(nodeIndexDescriptor.Schema()).awaitStoreScanCompleted(0, MILLISECONDS);
long relId = 0;
RelationshipRecord inUse = GetRelationship(relId, true, ENTITY_TOKEN);
Value relationshipPropertyValue = Values.of("da");
long propertyId = CreateRelationshipProperty(inUse, relationshipPropertyValue, 1);
RelationshipRecord notInUse = GetRelationship(relId, false, ENTITY_TOKEN);
_relationshipStore.updateRecord(inUse);
Command.RelationshipCommand relationshipCommand = new Command.RelationshipCommand(inUse, notInUse);
PropertyRecord relationshipPropertyBlocks = new PropertyRecord(propertyId);
relationshipPropertyBlocks.RelId = relId;
Command.PropertyCommand relationshipPropertyCommand = new Command.PropertyCommand(_recordAccess.getIfLoaded(propertyId).forReadingData(), relationshipPropertyBlocks);
StoreIndexDescriptor relationshipIndexDescriptor = forSchema(multiToken(_entityTokens, RELATIONSHIP, 1, 4, 6), EMPTY.ProviderDescriptor).withId(1);
_indexingService.createIndexes(relationshipIndexDescriptor);
_indexingService.getIndexProxy(relationshipIndexDescriptor.Schema()).awaitStoreScanCompleted(0, MILLISECONDS);
onlineIndexUpdates.Feed(NodeGroup(nodeCommand, nodePropertyCommand), RelationshipGroup(relationshipCommand, relationshipPropertyCommand));
assertTrue(onlineIndexUpdates.HasUpdates());
assertThat(onlineIndexUpdates, containsInAnyOrder(IndexEntryUpdate.remove(relId, relationshipIndexDescriptor, relationshipPropertyValue, null, null), IndexEntryUpdate.remove(nodeId, nodeIndexDescriptor, nodePropertyValue, null, null)));
}
private IList <Pair <string, object> > GetPropertiesFromRecord(long recordId)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.store.record.PropertyRecord record = propertyStore().getRecord(recordId, propertyStore().newRecord(), org.neo4j.kernel.impl.store.record.RecordLoad.FORCE);
PropertyRecord record = PropertyStore().getRecord(recordId, PropertyStore().newRecord(), RecordLoad.FORCE);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.List<org.eclipse.collections.api.tuple.Pair<String, Object>> props = new java.util.ArrayList<>();
IList <Pair <string, object> > props = new List <Pair <string, object> >();
record.forEach(block =>
{
object value = PropertyStore().getValue(block).asObject();
string name = PropertyStore().PropertyKeyTokenStore.getToken(block.KeyIndexId).name();
props.Add(pair(name, value));
});
return(props);
}
public void RemoveHandler(EventHandler <PropertyChangedEventArgs> handler, string propertyName)
{
PropertyRecord pr = (PropertyRecord)_dict[propertyName];
if (pr != null)
{
pr.RemoveHandler(handler);
if (pr.IsEmpty)
{
_dict.Remove(propertyName);
}
// invalidate list of all listeners
_dict.Remove(AllListenersKey);
_proposedAllListenersList = null;
}
}
public void StoreAllListenersList(ListenerList<PropertyChangedEventArgs> list)
{
// test again, in case another thread changed _proposedAllListersList.
if (_proposedAllListenersList == list)
{
_dict[AllListenersKey] = new PropertyRecord(AllListenersKey, this, list);
_proposedAllListenersList = null;
}
// Another thread could have changed _proposedAllListersList
// since we set it (earlier in this method), either
// because it calculated a new one while handling a PropertyChanged(""),
// or because it added/removed/purged a listener.
// In that case, we will simply abandon our proposed list and we'll
// have to compute it again the next time. But that only happens
// if there's thread contention. It's not worth doing something
// more complicated just for that case.
}
public BamlPropertyReference(PropertyRecord propRec)
{
this.propRec = propRec;
}
public void AddHandler(EventHandler<PropertyChangedEventArgs> handler, string propertyName)
{
PropertyRecord pr = (PropertyRecord)_dict[propertyName];
if (pr == null)
{
// no entry in the dictionary - add a new one
pr = new PropertyRecord(propertyName, this);
_dict[propertyName] = pr;
pr.StartListening(_type);
}
pr.AddHandler(handler);
// invalidate list of all listeners
_dict.Remove(AllListenersKey);
_proposedAllListenersList = null;
// schedule a cleanup pass
_manager.ScheduleCleanup();
}