public virtual IEnumerator Iterator()
{
return(Iterators.Iterate(_data));
}
public virtual IEnumerator Pointers()
{
return(Iterators.Concat(Iterators.Map(_ranges, new _IFunction4_77())));
}
private IList SlotsFor(IList ids)
{
return(new SlotCollector(_config.prefetchDepth, new StandardReferenceCollector(_transaction
), new StandardSlotAccessor(_transaction)).Collect(Iterators.Take(_config.prefetchCount
, Iterators.Iterator(ids))));
}
public virtual IEnumerator CustomFields()
{
return(Iterators.Filter(_fields, new _IPredicate4_109()));
}
/// <exception cref="System.Exception"></exception>
private IEnumerator MigrationTestSuite(Type clazz, Db4oLibrary[] libraries)
{
return(Iterators.Map(libraries, new _IFunction4_51(this, clazz)));
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public java.util.Iterator<org.neo4j.internal.kernel.api.schema.constraints.ConstraintDescriptor> constraintsForRelationshipType(final int relTypeId)
public virtual IEnumerator <ConstraintDescriptor> ConstraintsForRelationshipType(int relTypeId)
{
return(Iterators.filter(SchemaDescriptorPredicates.hasRelType(relTypeId), Constraints()));
}
private IEnumerable UniqueValuesOf(Type keyType)
{
return(Iterators.Unique(ValuesOf(keyType)));
}
private IEnumerator MapPersistentFields(object obj, IFunction4 function)
{
return(Iterators.Map(IteratePersistentFields(obj), function));
}
private IEnumerator IteratePersistentFields(object obj)
{
return(Iterators.Filter(DeclaredFields(obj), new _IPredicate4_266()));
}
private ITest NextTest(IEnumerator tests)
{
return((ITest)Iterators.Next(tests));
}
public virtual IEnumerator IterateGraphStringFields(object obj)
{
return(Iterators.Concat(Iterators.Map(IterateGraph(obj), new _IFunction4_146(this
))));
}
protected internal override ResourceIterator <Relationship> createNestedIterator(Node node)
{
_outerInstance.lastPath.EndNode = node;
return(Iterators.asResourceIterator(_outerInstance.expander.expand(_outerInstance.lastPath, BranchState.NO_STATE).GetEnumerator()));
}
private string First(IEnumerator iterator)
{
return((string)Iterators.Next(iterator));
}
public virtual IEnumerator Buffers()
{
var slots = ReadSlots();
return(Iterators.Map(ReadRootIds(), new _IFunction4_28(slots)));
}
private void AssertMessages(IList actualMessages, IMessage[] expectedMessages)
{
Iterator4Assert.AreEqual(expectedMessages, Iterators.Iterator(actualMessages));
}
private void StoreAll(IInternalObjectContainer internalObjectContainer)
{
internalObjectContainer.StoreAll(Trans(), Iterators.Iterate(new[] { item1, item2 }));
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public java.util.Iterator<org.neo4j.internal.kernel.api.schema.constraints.ConstraintDescriptor> constraintsForLabel(final int label)
public virtual IEnumerator <ConstraintDescriptor> ConstraintsForLabel(int label)
{
return(Iterators.filter(SchemaDescriptorPredicates.hasLabel(label), Constraints()));
}
private string ToString(IEnumerable buffer)
{
return(Iterators.ToString(buffer));
}
public virtual IEnumerator <ConstraintDescriptor> ConstraintsForSchema(SchemaDescriptor descriptor)
{
return(Iterators.filter(SchemaDescriptor.equalTo(descriptor), Constraints()));
}
/// <summary>
/// Generates an array that can be used with
/// <see cref="MethodCallRecorder.Verify(db4ounit.mocking.MethodCall[])">MethodCallRecorder.Verify(db4ounit.mocking.MethodCall[])
/// </see>
/// .
/// Example:
/// MethodCallRecorder recorder = new MethodCallRecorder();
/// runTest(recorder);
/// System.out.println(CodeGenerator.generateMethodCallArray(recorder))
/// </summary>
/// <param name="calls">MethodCall generator</param>
/// <returns>array string</returns>
public static string GenerateMethodCallArray(IEnumerable calls)
{
IEnumerable callStrings = Iterators.Map(calls, new _IFunction4_23());
return(Iterators.Join(callStrings.GetEnumerator(), "," + TestPlatform.NewLine));
}
public virtual IEnumerator GetEnumerator()
{
return(Iterators.SingletonIterator(Environments.NewConventionBasedEnvironment()));
}
internal static object Next(System.Collections.IEnumerator iterator)
{
return(Iterators.Next(iterator));
}
internal PredictableChunkedInput(ByteBufChunkHandlerTest outerInstance, params int[] sizes)
{
this._outerInstance = outerInstance;
this.Sizes = Iterators.asIterator(sizes);
}
private static bool HasEventHandler(IReflectMethod[] methods)
{
return(Iterators.Any(Iterators.Iterate(methods), new _IPredicate4_118()));
}
private void AssertCollectedIds(CollectIdContext context, object[] expectedReferences
)
{
Iterator4Assert.SameContent(Iterators.Map(expectedReferences, new _IFunction4_66(
this)), new TreeKeyIterator(context.Ids()));
}
private IEnumerator AsIterator(List4 lastElement)
{
return(Iterators.Revert(Iterators.Map(Iterators.Iterate(lastElement), new _IFunction4_198
())));
}
public virtual IEnumerator Keys()
{
return(Iterators.Concat(Iterators.Map(_ranges, new _IFunction4_85())));
}
public virtual IEnumerator GetEnumerator()
{
if (false)
{
return(new DrsTestSuiteBuilder(new Db4oDrsFixture("db4o-a"), new Db4oDrsFixture("db4o-b"
), typeof(Db4oDrsTestSuite)).GetEnumerator());
}
if (false)
{
return(new DrsTestSuiteBuilder(new Db4oClientServerDrsFixture("db4o-cs-a", unchecked (
(int)(0xdb40))), new Db4oClientServerDrsFixture("db4o-cs-b", 4455), typeof(Db4oDrsTestSuite
)).GetEnumerator());
}
return(Iterators.Concat(Iterators.Concat(new DrsTestSuiteBuilder(new Db4oDrsFixture
("db4o-a"), new Db4oDrsFixture("db4o-b"), typeof(Db4oDrsTestSuite)).GetEnumerator
(), new DrsTestSuiteBuilder(new Db4oClientServerDrsFixture("db4o-cs-a", unchecked (
(int)(0xdb40))), new Db4oClientServerDrsFixture("db4o-cs-b", 4455), typeof(Db4oDrsTestSuite
)).GetEnumerator()), Iterators.Concat(new DrsTestSuiteBuilder(new Db4oDrsFixture
("db4o-a"), new Db4oClientServerDrsFixture("db4o-cs-b", 4455), typeof(Db4oDrsTestSuite
)).GetEnumerator(), new DrsTestSuiteBuilder(new Db4oClientServerDrsFixture("db4o-cs-a"
, 4455), new Db4oDrsFixture("db4o-b"), typeof(Db4oDrsTestSuite)).GetEnumerator()
)));
}
public IEnumerable <CodeMemberProperty> RenderTemplateProperty(object instance, KeyValuePair <PropertyInfo, GenerateProperty> templateProperty)
{
CurrentAttribute = templateProperty.Value;
var attributes = templateProperty.Key.GetCustomAttributes(typeof(TemplateAttribute), true).OfType <TemplateAttribute>().OrderBy(p => p.Priority);
bool success = true;
foreach (var attribute in attributes)
{
if (!attribute.CanGenerate(instance, templateProperty.Key, this))
{
success = false;
}
}
if (!success)
{
yield break;
}
// Default to designer file only
if (!attributes.OfType <Inside>().Any())
{
if (!IsDesignerFile)
{
yield break;
}
}
if (Iterators.ContainsKey(templateProperty.Key.Name))
{
var iterator = Iterators[templateProperty.Key.Name];
var items = iterator(Data).OfType <IDiagramNodeItem>();
foreach (var item in items)
{
if (ItemFilter != null && !ItemFilter(item))
{
continue;
}
Item = item;
var domObject = RenderProperty(instance, templateProperty);
foreach (var attribute in attributes)
{
attribute.Modify(instance, templateProperty.Key, this);
}
CurrentDeclaration.Members.Add(domObject);
yield return(domObject);
InvertApplication.SignalEvent <ICodeTemplateEvents>(_ => _.PropertyAdded(instance, this, domObject));
}
Item = null;
}
else
{
Item = Data as IDiagramNodeItem;
if (ItemFilter != null && !ItemFilter(Item))
{
yield break;
}
var domObject = RenderProperty(instance, templateProperty);
foreach (var attribute in attributes)
{
attribute.Modify(instance, templateProperty.Key, this);
}
CurrentDeclaration.Members.Add(domObject);
yield return(domObject);
InvertApplication.SignalEvent <ICodeTemplateEvents>(_ => _.PropertyAdded(instance, this, domObject));
Item = null;
}
}
private static void ProcessBlocks(string outputPath, Dictionary <CoordinateInt, Block> rawBlocks)
{
/* We need to identify any bricks that are hidden from vision. */
Console.WriteLine("Identifying invisible blocks.");
HashSet <CoordinateInt> invisibleBricks = new HashSet <CoordinateInt>();
foreach (KeyValuePair <CoordinateInt, Block> pair in rawBlocks)
{
if (IsInvisible(pair.Key, rawBlocks))
{
invisibleBricks.Add(pair.Key);
}
}
foreach (CoordinateInt coord in invisibleBricks)
{
rawBlocks.Remove(coord);
}
Console.WriteLine("Identified {0} invisible bricks.", invisibleBricks.Count);
/* Before we can start expanding cubes, we need to organize by block type. */
Console.WriteLine("Extracting largest volumes.");
Dictionary <Block, List <Volume> > volumizedWorld = new Dictionary <Block, List <Volume> >();
foreach (KeyValuePair <Block, HashSet <CoordinateInt> > pair in OrganizeRawBlocks(rawBlocks))
{
volumizedWorld.Add(pair.Key, new List <Volume>(new LargestVolumeExtractor(pair.Value, invisibleBricks)));
}
/* Scan for interior faces that we can remove. */
HiddenFaces.totalHiddenFaces = 0;
Console.WriteLine("Identifying interior faces.");
Dictionary <Block, List <FacedVolume> > facedVolumizedWorld = HiddenFaces.DetectHiddenFaces(volumizedWorld, rawBlocks);
Console.WriteLine("Identified {0} interior faces.", HiddenFaces.totalHiddenFaces);
/* Storage for the actual 3D geometry. */
List <CoordinateDecimal> vertices = new List <CoordinateDecimal>();
Dictionary <string, List <FaceVertices> > collisionBoxes = new Dictionary <string, List <FaceVertices> >();
Dictionary <BlockFaceTexture, List <TexturedFace> > texturedFaces = new Dictionary <BlockFaceTexture, List <TexturedFace> >();
TextureCoordinateDictionary textureCoordinates = new TextureCoordinateDictionary();
/* Build the textured faces from the volumes. */
foreach (KeyValuePair <Block, List <FacedVolume> > pair in facedVolumizedWorld)
{
List <FacedVolume> volumes = pair.Value;
for (int idx = 0; idx < volumes.Count; idx++)
{
FacedVolume facedVolume = volumes[idx];
Iterators.FacesInVolume(vertices.Count, facedVolume.excludedFaces, (Face face, FaceVertices faceVertices) =>
{ AppendTexturedFaces(texturedFaces, textureCoordinates, pair.Key, facedVolume.volume, face, faceVertices); });
Iterators.VerticesInVolume(volumes[idx].volume,
(CoordinateDecimal a) => { vertices.Add(a); });
}
}
Console.WriteLine(textureCoordinates.mappingList.Count + " unique texture coordinates.");
/* Delete duplicate vertices before adding collision UBXs because the UBX vertices will all be unique. */
Console.WriteLine("Detecting duplicate vertices.");
int duplicatesRemoved = DuplicateVertices.DetectAndErase(vertices, texturedFaces);
Console.WriteLine(duplicatesRemoved + " duplicate vertices removed.");
Console.WriteLine("Generate UBX collision volumes.");
foreach (KeyValuePair <Block, List <FacedVolume> > pair in facedVolumizedWorld)
{
List <FacedVolume> volumes = pair.Value;
for (int idx = 0; idx < volumes.Count; idx++)
#warning Potential for collision meshes to be far from visual mesh!
{
MakeCollisionUBX("UBX_" + pair.Key.ToString() + string.Format("_{0:00}", idx), volumes[idx].volume, vertices, collisionBoxes);
}
}
/* Export the geometry to Wavefront's OBJ format. */
WavefrontObj objFile = new WavefrontObj(vertices, collisionBoxes, texturedFaces, textureCoordinates, facedVolumizedWorld);
/* Save the OBJ file to the specified destination. */
File.WriteAllText(outputPath, objFile.ToString());
}
