public void Select(Entity entity)
{
DeselectAll();
_selectedEntities.Add(entity);
entity.Select();
SendToSelected(_actorTaskProvider);
}
// --------------- Canvas Methods --------------- //
public void CanvasMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
var image = e.Source as Image;
if (image != null && mainWindowCanvas.CaptureMouse())
{
mousePosition = e.GetPosition(mainWindowCanvas);
canvasDraggedImage = image;
draggedEntity = entitiesController.FindCanvasEntityByStringId(canvasDraggedImage.Name);
Console.WriteLine("find: " + canvasDraggedImage.Name);
if (draggedEntity != null && !draggedEntity.Selected() && bMultiSelect == false)
{
entitiesController.UnselectAll();
ContextMenuController.GetInstance().ClearMenu();
}
draggedEntity.Select();
ContextMenuController.GetInstance().ClearMenu();
ContextMenuController.GetInstance().SelectEntity(draggedEntity);
}
else
{
entitiesController.UnselectAll();
ContextMenuController.GetInstance().ClearMenu();
}
if (canvasDraggedImage == null)
{
selectBoxAnchor = e.GetPosition(mainWindowCanvas);
bIsDragging = true;
}
}
private void CreateCameraTrack()
{
// Create the camera track points.
var cameraMinX = 0;
var cameraMinZ = 0;
var cameraMaxX = _floorWidth;
var cameraMaxZ = _floorLength;
var cameraY = _sphereHeight;
var trackPoints = new Entity[] {
CameraTrackPointPrefab.Instantiate().First(),
CameraTrackPointPrefab.Instantiate().First(),
CameraTrackPointPrefab.Instantiate().First(),
CameraTrackPointPrefab.Instantiate().First()
};
SceneSystem.SceneInstance.RootScene.Entities.AddRange(trackPoints);
trackPoints[0].Transform.Position = new Vector3(cameraMinX, cameraY, cameraMinZ);
trackPoints[1].Transform.Position = new Vector3(cameraMaxX, cameraY, cameraMinZ);
trackPoints[2].Transform.Position = new Vector3(cameraMaxX, cameraY, cameraMaxZ);
trackPoints[3].Transform.Position = new Vector3(cameraMinX, cameraY, cameraMaxZ);
CameraTrack.CameraTrackPoints.AddRange(trackPoints.Select(e => e.Transform));
// Set the camera focal point.
var focalPoint = new Vector3(
(cameraMaxX - cameraMinX) / 2,
cameraY / 2,
(cameraMaxZ - cameraMinZ) / 2
);
CameraTrack.CameraFocalPoint.Position = focalPoint;
}
public void Add(Entity entity)
{
entities.Add(entity);
if (entities.Count == 1)
{
//gameObject.SetActive(true);
entityIndex = entities.IndexOf(entity);
entity.Select();
transform.position = entity.Position + positionOffset;
}
}
public List <ImageRecord> GetUnusedImages()
{
if (!_isDbLoaded)
{
Load();
}
return(_images.Select(kvp => kvp.Value)
.Where(i => Boolean.Parse(i["HasBeenUsed"]) == false)
.Cast <ImageRecord>()
.ToList());
}
public void OnClick(Entity entity)
{
if (m_selectedEntity != null)
{
m_selectedEntity.Select(false);
}
m_selectedEntity = entity;
if (m_selectedEntity != null)
{
m_selectedEntity.Click();
}
}
// ===============================================================
// Entities
// ===============================================================
private void SelectEntity(Entity entity)
{
Entity[] entities = FindObjectsOfType <Entity>();
foreach (Entity ent in entities)
{
ent.Deselect();
}
entity.Select();
selectedEntity = entity;
//SelectGameTool(GameTools.NONE);
}
private void SelectEntity(Entity entity)
{
SelectedEntities.Add(entity);
SelectionMarker selectionMarker = entity.GetComponentInChildren <SelectionMarker>(true);
if (selectionMarker != null)
{
selectionMarker.ToggleRendering(true);
}
entity.Select();
}
public void TestUpdate()
{
var mockComponentActorFactory = new Mock <IComponentActorFactory>();
mockComponentActorFactory.Setup(f => f.GetOrCreateActorForComponent(It.IsAny <EntityComponent>())).Returns(
(EntityComponent component) =>
{
return(Sys.ActorOf(Props.Create(() => new EntityTestActor(component.Id)), $"{component.Id}"));
}
);
var entity = new Entity
{
new Utils.TestComponent(),
new Utils.TestComponent(),
new Utils.TestComponent()
};
IActorRef entityActor = Sys.ActorOf(EntityActor.Props(entity, mockComponentActorFactory.Object));
entityActor.Tell(new Update(new GameTime()));
ExpectMsgAllOf(entity.Select(c => c.Id).ToArray());
ExpectNoMsg(500);
}
private Feature DrawnSketchOnFace(ModelDoc2 swModel, double[] mousePoint, List <Edge> thisFaceEdgeList, Entity swSelFaceEntity, out string sketchName)
{
swModel.SketchManager.InsertSketch(true);
//通过两条相邻边来标注 创建点的位置
//1。 计算鼠标选中点到面的各边的距离。
List <FaceEdgeInfos> faceEdgeInfor = new List <FaceEdgeInfos>();
//Dictionary<Edge, double> pointToEdgeDim = new Dictionary<Edge, double>();
var selMousePt = (double[])TransformPoint(swModel.IGetActiveSketch2(), mousePoint[0], mousePoint[1], mousePoint[2]);
foreach (var item in thisFaceEdgeList)
{
var tStart = (Vertex)item.GetStartVertex();
var pstart = (double[])tStart.GetPoint();
var tEnd = (Vertex)item.GetEndVertex();
var pend = (double[])tEnd.GetPoint();
pstart = (double[])TransformPoint(swModel.IGetActiveSketch2(), pstart[0], pstart[1], pstart[2]);
pend = (double[])TransformPoint(swModel.IGetActiveSketch2(), pend[0], pend[1], pend[2]);
var angleOfLine = Math.Atan2((pend[1] - pstart[1]), (pend[0] - pstart[0])) * 180 / Math.PI;
double tempChuizuX = 0;
double tempChuizuY = 0;
//垂足的坐标位置
var tempchuizu = Geometry2D.GetPerpendicular(selMousePt[0], selMousePt[1], pend[0], pend[1], pstart[0], pstart[1]);
tempChuizuX = tempchuizu[0];
tempChuizuY = tempchuizu[1];
faceEdgeInfor.Add(new FaceEdgeInfos(item, Geometry2D.pointToLine(pstart[0], pstart[1], pend[0], pend[1], selMousePt[0], selMousePt[1]), angleOfLine, Geometry2D.lineSpace(pstart[0], pstart[1], pend[0], pend[1]), tempChuizuX, tempChuizuY));
//pointToEdgeDim.Add(item, pointToLine(pstart[0], pstart[1], pend[0], pend[1], mousePoint[0], mousePoint[1]));
}
//把所有的边按距离排序
var EdgeInfosOrderByDim = faceEdgeInfor.OrderBy(x => x.dim).ToList();
//最近的一条边
var minEdgeObject = EdgeInfosOrderByDim[0];
//下一条相临的边
FaceEdgeInfos nextMinEdga = null;
for (int i = 1; i < EdgeInfosOrderByDim.Count; i++)
{
if (Math.Abs(EdgeInfosOrderByDim[i].Angle) != 180 - Math.Abs(minEdgeObject.Angle) && EdgeInfosOrderByDim[i].Angle != minEdgeObject.Angle)
{
nextMinEdga = EdgeInfosOrderByDim[i];
break;
}
}
// var eNextEdge = faceEdgeInfoses.Find(x => ((Vertex)x.edge.GetStartVertex()).GetPoint() == ((Vertex)minEdgeObject.GetEndVertex()).GetPoint());
var minEdge = (Entity)minEdgeObject.edge;
var nextminEdge = (Entity)nextMinEdga.edge;
swModel.ClearSelection();
//MessageBox.Show("done");
swSelFaceEntity.Select(false);
// var actSketch = swModel.SketchManager.ActiveSketch;
////把鼠标点坐标转换到草图中
//var selMousePt = (double[])TransformPoint(swModel.IGetActiveSketch2(), mousePoint[0], mousePoint[1], mousePoint[2]);
swModel.SketchManager.CreateCenterRectangle(selMousePt[0], selMousePt[1], selMousePt[2], selMousePt[0] + 0.03, selMousePt[1] + 0.03, selMousePt[2]);
swModel.ClearSelection2(true);
swModel.Extension.SelectByID2("Point1", "SKETCHPOINT", 0, 0, 0, false, 0, null, 0);
minEdge.Select(true);
// var thisDim = (DisplayDimension)swModel.AddDimension2(selMousePt[0], selMousePt[1], selMousePt[2]);
var thisDim = (DisplayDimension)swModel.AddDimension2(minEdgeObject.chuizuPoint_X, minEdgeObject.chuizuPoint_Y, 0);
thisDim.GetDimension2(0).SystemValue = Math.Round(minEdgeObject.dim * 1000, 0) / 1000;
//第二个方向尺寸
swModel.ClearSelection2(true);
swModel.Extension.SelectByID2("Point1", "SKETCHPOINT", 0, 0, 0, false, 0, null, 0);
nextminEdge.Select(true);
//var nextthisDim = (DisplayDimension)swModel.AddDimension2(selMousePt[0], selMousePt[1], selMousePt[2]);
var nextthisDim = (DisplayDimension)swModel.AddDimension2(nextMinEdga.chuizuPoint_X, nextMinEdga.chuizuPoint_Y, 0);
nextthisDim.GetDimension2(0).SystemValue = Math.Round(nextMinEdga.dim * 1000, 0) / 1000;
string featName = null;
string featType = null;
var skFeature = (Feature)swModel.IGetActiveSketch2();
featName = skFeature.GetNameForSelection(out featType);
sketchName = featName;
swModel.SketchManager.InsertSketch(true);
swModel.Extension.SelectByID2(sketchName, "SKETCH", 0, 0, 0, false, 1, null, 0);
var boolstatus = swModel.InsertPlanarRefSurface();
ISelectionMgr swSelMgr = (ISelectionMgr)swModel.SelectionManager;
skFeature = (Feature)swSelMgr.GetSelectedObject6(1, 0);// swModel.FeatureByPositionReverse(0);
return(skFeature);
}
private static void DrawDottedLine(ModelDoc2 swModel, Entity ent1, Entity ent2)
{
swModel.SetAddToDB(true);
if (ent1 != null && ent2 != null)
{
swModel.SketchManager.CreateCenterLine(1, 1, 0, 1.1, 1.1, 0);
var objPoints = (object[])swModel.SketchManager.ActiveSketch.GetSketchPoints();
SketchPoint swPoint1 = null, swPoint2 = null;
foreach (var objPoint in objPoints)
{
var swPoint = (SketchPoint)objPoint;
double x1 = 1 - swPoint.X;
double x2 = 1.1 - swPoint.X;
double y1 = 1 - swPoint.Y;
double y2 = 1.1 - swPoint.Y;
if (x1 < 0)
x1 = -x1;
if (x2 < 0)
x2 = -x2;
if (y1 < 0)
y1 = -y1;
if (y2 < 0)
y2 = -y2;
if (x1 < 0.0001 && y1 < 0.0001)
{
swPoint1 = swPoint;
}
if (x2 < 0.0001 && y2 < 0.0001)
{
swPoint2 = swPoint;
}
}
if (swPoint1 != null && swPoint2 != null)
{
if (swPoint1.Select(false) && ent1.Select(true))
{
swModel.SketchAddConstraints("sgCONCENTRIC");
}
if (swPoint2.Select(false) && ent2.Select(true))
{
swModel.SketchAddConstraints("sgCONCENTRIC");
}
}
}
swModel.SetAddToDB(false);
swModel.GraphicsRedraw2();
swModel.ClearSelection();
//swModel.ClearUndoList();
}
// ===============================================================
// Entities
// ===============================================================
private void SelectEntity(Entity entity)
{
Entity[] entities = FindObjectsOfType<Entity>();
foreach(Entity ent in entities) {
ent.Deselect();
}
entity.Select();
selectedEntity = entity;
//SelectGameTool(GameTools.NONE);
}
private string FormatValue(Entity valueProvider, formatTemplate template)
{
Entity original = CheckTarget();
IEnumerable <string> values = GetValues();
IEnumerable <string> formattedValues = values.Select(Format);
string formattedValue = string.Join(template.seperator, formattedValues);
return(ApplyPrefixSuffix(formattedValue, true));
Entity CheckTarget()
{
Entity result = valueProvider;
while (result.Owner != null && result.Owner.Type == EntityKeys.FormatKey)
{
result = result.Owner.Owner;
}
if (!string.IsNullOrEmpty(template.target) &&
!template.target.Equals(result.Type, StringComparison.OrdinalIgnoreCase))
{
throw new FormatTargetMismatchException(template, result.Type);
}
return(result);
}
IEnumerable <string> GetValues()
{
return(template.multiplicity == multiplicity.OneOrMore
? (template.Split?.Any() == true
? valueProvider.Value <string>().Split(template.Split.Select(Resolve).ToArray(), StringSplitOptions.None)
: valueProvider.Select(e => e.Value <string>()))
: new[] { valueProvider.Value <string>() });
string Resolve(string split)
{
return(resolver.Resolve(split, original));
}
}
string ApplyPrefixSuffix(string mainString, bool onlyAggregated)
{
prefixSuffixFormat perValuePrefix = template.Prefix?.FirstOrDefault(p => p.onlyaggregated == onlyAggregated);
string prefix = perValuePrefix != null
? resolver.Resolve(perValuePrefix.value, valueProvider.Empty)
: string.Empty;
prefixSuffixFormat perValueSuffix = template.Suffix?.FirstOrDefault(p => p.onlyaggregated == onlyAggregated);
string suffix = perValueSuffix != null
? resolver.Resolve(perValueSuffix.value, valueProvider.Empty)
: string.Empty;
return(prefix + mainString + suffix);
}
string Format(string value)
{
string result = ApplyPatterns();
return(ApplyPrefixSuffix(result, false));
string ApplyPatterns()
{
foreach (conditionalConversionFormat format in template.ConditionalConversion ?? Enumerable.Empty <conditionalConversionFormat>())
{
if (bool.TryParse(resolver.Resolve(format.condition, original), out bool applies) &&
applies)
{
using (original.AddTemporaryDataSource(new FormatValueAccess(value)))
{
return(resolver.Resolve(format.template, original));
}
}
}
foreach (regexConversionFormat format in template.RegexConversion ?? Enumerable.Empty <regexConversionFormat>())
{
Match match = CreateMatch(format.pattern, format.ignorecase, out Regex regex);
if (match.Success)
{
return(resolver.Resolve(format.converted, valueProvider.Create("regex", match, regex)));
}
}
foreach (templateConversionFormat format in template.TemplateConversion ?? Enumerable.Empty <templateConversionFormat>())
{
Match match = CreateMatch(format.pattern, format.ignorecase, out Regex _);
if (match.Success)
{
using (original.AddTemporaryDataSource(new FormatValueAccess(value)))
{
return(resolver.Resolve(format.template, original));
}
}
}
return(value);
Match CreateMatch(string pattern, bool ignorecase, out Regex regex)
{
if (!pattern.StartsWith("^", StringComparison.Ordinal))
{
pattern = $"^{pattern}";
}
if (!pattern.EndsWith("$", StringComparison.Ordinal))
{
pattern += "$";
}
RegexOptions options = ignorecase ? RegexOptions.IgnoreCase : RegexOptions.None;
regex = new Regex(pattern, options);
return(regex.Match(value));
}
}
}
}
public override Entity Resolve(Entity owner, string key, bool fallback = false)
{
TemplateEntity ownerTemplateEntity = TemplateEntity.Decorate(owner);
if (key == EntityKeys.FieldArpDataTypeKey && owner.Type == EntityKeys.FormatKey)
{
return(ResolveArpDataType());
}
if (key == EntityKeys.TypeMetaDataFormatKey && owner.Type == EntityKeys.FormatKey)
{
return(ResolveTypeMetaDataFormat());
}
if (key == EntityKeys.ExpandHiddenTypesFormatKey)
{
return(ExpandHiddenTypes());
}
if (key == EntityKeys.FilterHiddenTypesFormatKey)
{
return(FilterHiddenTypes());
}
if (key == EntityKeys.IsFieldKey)
{
return(owner.Create(key, CodeEntity.Decorate(owner).AsField != null));
}
if (key == EntityKeys.IsTypeKey)
{
return(owner.Create(key, CodeEntity.Decorate(owner).AsType != null));
}
if (key == EntityKeys.BigDataProjectKey)
{
return(GetBigDataProjectEntity());
}
if (key == EntityKeys.NormalProjectKey)
{
return(GetNormalProjectEntity());
}
ISymbol symbol = owner.Value <ISymbol>();
if (symbol != null)
{
Entity result = owner.PropertyValueEntity(key, symbol);
if (result != null)
{
return(result);
}
throw new ContentProviderException(key, owner);
}
if (key == EntityKeys.BaseDirectoryKey && HasBaseDirectory(owner, out string baseDirectory))
{
return(owner.Create(key, baseDirectory));
}
IType type = owner.Value <IType>();
if (type != null)
{
return(ResolveType());
}
IField field = owner.Value <IField>();
if (field != null)
{
return(ResolveField());
}
IDataType dataType = owner.Value <IDataType>();
if (dataType != null)
{
return(ResolveDataType());
}
ICodeModel codeModel = owner.Value <ICodeModel>();
if (codeModel != null)
{
return(ResolveCodeModel());
}
throw new ContentProviderException(key, owner);
IEnumerable <CodeEntity> GetPortEnums()
{
return(GetAllPorts().Concat(GetPortStructures().SelectMany(p => p.Fields))
.Select(f => f.ResolvedType)
.Where(t => t.AsEnum != null)
.Distinct());
}
IEnumerable <CodeEntity> GetAllPorts()
{
bool IsPort(CodeEntity fieldEntity)
{
return(fieldEntity.AsField != null &&
fieldEntity.AsField.HasAttributeWithoutValue(EntityKeys.PortAttributeKey));
}
return(TemplateEntity.Decorate(owner).EntityHierarchy
.Select(CodeEntity.Decorate)
.SelectMany(c => c.Fields)
.Where(IsPort));
}
IEnumerable <CodeEntity> GetPortStructures()
{
HashSet <CodeEntity> structures = new HashSet <CodeEntity>(GetAllPorts()
.Select(f => f.ResolvedType)
.Where(t => t.AsType != null &&
t.AsEnum == null),
new FullNameCodeEntityComparer());
HashSet <CodeEntity> visited = new HashSet <CodeEntity>(new FullNameCodeEntityComparer());
while (structures.Except(visited).Any())
{
foreach (CodeEntity structure in structures.Except(visited).ToArray())
{
foreach (CodeEntity structureField in structure.Fields)
{
CodeEntity structureDataType = structureField.ResolvedType;
if (structureDataType.AsType != null && structureDataType.AsEnum == null)
{
structures.Add(structureDataType);
}
}
visited.Add(structure);
}
}
return(structures);
}
Entity FilterHiddenTypes()
{
IEnumerable <IType> types = owner.Select(CodeEntity.Decorate)
.Where(c => !c.IsHidden())
.Select(c => c.AsType)
.ToArray();
string name = owner.FirstOrDefault()?.Name ?? string.Empty;
return(owner.Create(key, types.Select(t => owner.Create(name, t.FullName, t))));
}
Entity ExpandHiddenTypes()
{
IEnumerable <CodeEntity> dataSourceFields = owner.Select(CodeEntity.Decorate);
dataSourceFields = ExpandHiddenStructureFields(dataSourceFields);
string name = owner.FirstOrDefault()?.Name ?? string.Empty;
return(owner.Create(key, dataSourceFields.Select(e => e.AsField)
.Select(f => owner.Create(name, f.Name, f))));
IEnumerable <CodeEntity> ExpandHiddenStructureFields(IEnumerable <CodeEntity> fields)
{
foreach (CodeEntity hiddenField in fields)
{
CodeEntity hiddenType = hiddenField.ResolvedType;
if (hiddenType == null || !hiddenType.IsHidden())
{
yield return(hiddenField);
continue;
}
foreach (CodeEntity hiddenTypeField in ExpandHiddenStructureFields(hiddenType.Fields))
{
yield return(hiddenTypeField);
}
}
}
}
T ChooseMetaDataTemplate <T>(IEnumerable <(T template, string name, string context)> templates)
{
return(templates.OrderByDescending(t => ContextComplexity(t.context ?? string.Empty))
.FirstOrDefault(Matches)
.template);
bool Matches((T template, string name, string context) template)
{
if (!key.Equals(template.name, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
if (string.IsNullOrEmpty(template.context))
{
return(true);
}
string[] contextPath = template.context.Split(new [] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries)
.Reverse().ToArray();
Entity current = owner;
foreach (string part in contextPath)
{
current = current?.Owner;
if (current?[$"is{part}"].Value <bool>() != true)
{
return(false);
}
}
return(true);
}
int ContextComplexity(string context)
{
return(context.Count(c => c == '/' || c == '\\'));
}
}
Entity ResolveType()
{
switch (key)
{
case EntityKeys.PathKey:
{
return(owner.Create(key, type.GetFile(owner).Parent.FullName));
}
case EntityKeys.FieldsKey:
{
return(owner.Create(key, type.Fields.Select(f => owner.Create(key.Singular(), f.Name, f))));
}
case EntityKeys.FileKey:
{
VirtualFile file = owner.Root.Value <ICodeModel>()
.Types[type];
return(owner.Create(key, file.Name, file));
}
case EntityKeys.BaseTypeKey:
{
IDataType baseType = type.BaseTypes.FirstOrDefault();
return(owner.Create(key, baseType));
}
default:
{
if (TryResolveTypeTemplate(out Entity result))
{
return(result);
}
if (TryResolveProperty(out result))
{
return(result);
}
if (TryResolveFields(out result))
{
return(result);
}
if (TryResolveRelationship(out result))
{
return(result);
}
throw new ContentProviderException(key, owner);
}
}
bool TryResolveTypeTemplate(out Entity result)
{
Templates.Type.metaDataTemplate typeMetaDataTemplate = ChooseMetaDataTemplate(templateRepository.TypeTemplates
.Select(t => (t, t.name, t.context)));
if (typeMetaDataTemplate != null)
{
result = GetTypeTemplateEntity(typeMetaDataTemplate);
return(true);
}
result = null;
return(false);
Entity GetTypeTemplateEntity(Templates.Type.metaDataTemplate metaDataTemplate)
{
if (!metaDataTemplate.hasvalue)
{
bool hasAttribute = type.HasAttributeWithoutValue(metaDataTemplate.name);
return(owner.Create(key, new Func <string>(hasAttribute.ToString), hasAttribute));
}
(string[] values, CodePosition position) = GetTypeTemplateValue();
IEnumerable <string> formattedValues = VerifyValues().ToArray();
return(metaDataTemplate.multiplicity == Templates.Type.multiplicity.OneOrMore
? owner.Create(key, formattedValues.Select(v => owner.Create(key.Singular(), v)))
: owner.Create(key, formattedValues.First()));
IEnumerable <string> VerifyValues()
{
return(values.Select(VerifyValue));
string VerifyValue(string arg)
{
(bool success, string message, string newValue) = metaDataTemplate.ValueRestriction.Verify(arg);
if (!success)
{
owner.AddCodeException(new FieldAttributeRestrictionException(metaDataTemplate.name, arg, message, position, type.GetFile(owner)));
}
return(newValue);
}
}
(string[], CodePosition) GetTypeTemplateValue()
{
IAttribute attribute = type.Attributes.LastOrDefault(a => a.Name.Equals(metaDataTemplate.name,
StringComparison.OrdinalIgnoreCase));
string value = attribute?.Values.FirstOrDefault() ??
resolver.Resolve(metaDataTemplate.defaultvalue, owner);
return(metaDataTemplate.multiplicity == Templates.Type.multiplicity.OneOrMore
? value.Split(new[] { metaDataTemplate.split }, StringSplitOptions.RemoveEmptyEntries)
: new[] { value },
attribute?.Position ?? new CodePosition(0, 0));
}
}
}
bool TryResolveProperty(out Entity result)
{
result = owner.PropertyValueEntity(key, type);
return(result != null);
}
bool TryResolveFields(out Entity result)
{
metaDataTemplate metaDataTemplate = templateRepository.FieldTemplates
.FirstOrDefault(t => t.name.Plural().Equals(key,
StringComparison
.OrdinalIgnoreCase));
if (metaDataTemplate != null)
{
IEnumerable <IField> fields = type.Fields
.Where(f => f.Attributes
.Any(a => a.Name
.Equals(metaDataTemplate.name,
StringComparison.OrdinalIgnoreCase)));
result = owner.Create(key, fields.Select(f => owner.Create(metaDataTemplate.name, f.Name, f)));
return(true);
}
result = null;
return(false);
}
bool TryResolveRelationship(out Entity result)
{
templateRelationship[] relationships = owner.Template().Relationship;
templateRelationship relationship = relationships?.FirstOrDefault(r => r.name.Equals(key, StringComparison.OrdinalIgnoreCase))
?? relationships?.FirstOrDefault(r => r.name.Equals(key.Singular(), StringComparison.OrdinalIgnoreCase));
TemplateDescription relationshipDescription = relationship != null?templateRepository.Template(relationship.type) : null;
if (relationshipDescription != null)
{
IEnumerable <string> names = type.Attributes
.Where(a => a.Name.Equals(relationship.name,
StringComparison.OrdinalIgnoreCase))
.SelectMany(a => a.Values);
result = relationship.GetRelationship(relationshipDescription, owner, names.ToArray());
return(true);
}
result = null;
return(false);
}
}
Entity ResolveField()
{
switch (key)
{
case EntityKeys.FieldNameKey:
{
return(owner.Create(key, field.Name));
}
case EntityKeys.DataTypeKey:
{
IDataType fieldDataType = GetRealFieldDataType();
return(owner.Create(key, fieldDataType.Name, fieldDataType));
}
case EntityKeys.ResolvedTypeKey:
{
ICodeModel model = owner.Root.Value <ICodeModel>();
IDataType fieldDataType = field.DataType;
IType realType = fieldDataType.PotentialFullNames
.Select(model.Type)
.FirstOrDefault(t => t != null);
return(owner.Create(key, realType?.Name, realType));
}
case EntityKeys.MultiplicityKey:
{
return(owner.Create(key, field.Multiplicity.Select(m => owner.Create(key, new Func <string>(m.ToString), m))));
}
default:
{
metaDataTemplate metaDataTemplate = templateRepository.FieldTemplates
.FirstOrDefault(t => t.name.Equals(key,
StringComparison.OrdinalIgnoreCase));
if (metaDataTemplate != null)
{
return(GetFieldTemplateEntity(metaDataTemplate));
}
throw new ContentProviderException(key, owner);
}
}
IDataType GetRealFieldDataType()
{
ICodeModel rootCodeModel = owner.Root.Value <ICodeModel>();
IEnum @enum = field.DataType.PotentialFullNames.Select(n => rootCodeModel.GetEnum(n)).FirstOrDefault(e => e != null);
if (@enum != null)
{
(IDataType enumBaseType, _) = GetEnumBaseType(@enum);
return(enumBaseType);
}
return(field.DataType);
}
Entity GetFieldTemplateEntity(metaDataTemplate metaDataTemplate)
{
if (!metaDataTemplate.hasvalue)
{
bool hasAttribute = field.HasAttributeWithoutValue(metaDataTemplate.name);
return(owner.Create(key, new Func <string>(hasAttribute.ToString), hasAttribute));
}
(string[] values, CodePosition position) = GetFieldTemplateValue();
IEnumerable <string> formattedValues = VerifyValues().ToArray();
return(metaDataTemplate.multiplicity == multiplicity.OneOrMore
? owner.Create(key, formattedValues.Select(v => owner.Create(key.Singular(), v)))
: owner.Create(key, formattedValues.First()));
IEnumerable <string> VerifyValues()
{
return(values.Select(VerifyValue));
string VerifyValue(string arg)
{
(bool success, string message, string newValue) = metaDataTemplate.ValueRestriction.Verify(arg);
if (!success)
{
owner.AddCodeException(new FieldAttributeRestrictionException(metaDataTemplate.name, arg, message, position, field.GetFile(owner)));
}
return(newValue);
}
}
(string[], CodePosition) GetFieldTemplateValue()
{
IAttribute attribute = field.Attributes.LastOrDefault(a => a.Name.Equals(metaDataTemplate.name,
StringComparison.OrdinalIgnoreCase));
string value = string.IsNullOrEmpty(attribute?.Values.FirstOrDefault())
? resolver.Resolve(metaDataTemplate.defaultvalue, owner)
: attribute.Values.First();
return(metaDataTemplate.multiplicity == multiplicity.OneOrMore
? value.Split(new[] { metaDataTemplate.split }, StringSplitOptions.RemoveEmptyEntries)
: new[] { value },
attribute?.Position ?? new CodePosition(0, 0));
}
}
}
Entity ResolveCodeModel()
{
switch (key)
{
case EntityKeys.PortStructsKey:
{
return(owner.Create(key, GetPortStructures().Select(c => c.Base)));
}
case EntityKeys.PortEnumsKey:
{
return(owner.Create(key, GetPortEnums().Select(c => c.Base)));
}
case EntityKeys.NamespaceKey:
{
bool prior206Target = CheckProjectTargets();
IEnumerable <string> relevantTypes = TemplateEntity.Decorate(owner).EntityHierarchy
.Select(CodeEntity.Decorate)
.Where(c => !c.IsRoot())
.Select(c => c.FullName);
string ns = prior206Target
? codeModel.RootNamespaceForOldTarget(
relevantTypes.ToArray(), GetPortStructures().Concat(GetPortEnums())
.Select(c => c.FullName)
.ToArray())
: codeModel.RootNamespace(relevantTypes.ToArray());
if (string.IsNullOrEmpty(ns))
{
ns = owner.Name;
}
return(owner.Create(key, ns));
}
default:
throw new ContentProviderException(key, owner);
}
bool CheckProjectTargets()
{
IEnumerable <TargetEntity> targets = ProjectEntity.Decorate(owner).Targets.Select(t => TargetEntity.Decorate(t));
return(targets.Any(t => t.Version < new Version(20, 6)));
}
}
Entity ResolveDataType()
{
switch (key)
{
case EntityKeys.NameKey:
return(owner.Create(key, dataType.Name));
case EntityKeys.FullNameKey:
string fullName = GetDataTypeFullName();
return(owner.Create(key, fullName));
default:
throw new ContentProviderException(key, owner);
}
string GetDataTypeFullName()
{
ICodeModel rootCodeModel = owner.Root.Value <ICodeModel>();
return(dataType.PotentialFullNames.FirstOrDefault(fn => rootCodeModel.Type(fn) != null)
?? dataType.Name);
}
}
Entity ResolveTypeMetaDataFormat()
{
IEntityBase dataSource = ownerTemplateEntity.FormatOrigin;
IDataType dataSourceDataType = dataSource.HasValue <IDataType>()
? dataSource.Value <IDataType>()
: dataSource.Value <IField>().DataType;
ICodeModel rootCodeModel = dataSource.Root.Value <ICodeModel>();
string dataTypeName = string.Empty;
if (dataSourceDataType != null)
{
dataTypeName = dataSourceDataType.PotentialFullNames
.Select(n => rootCodeModel.Type(n))
.FirstOrDefault(t => t != null)
?.Name
?? datatypeConversion.Convert(dataSourceDataType);
}
return(owner.Create(key, dataTypeName));
}
Entity ResolveArpDataType()
{
IEntityBase dataSource = ownerTemplateEntity.FormatOrigin;
IField dataSourceField = dataSource.Value <IField>();
if (dataSourceField == null)
{
throw new FormatTargetMismatchException("arpDataType", "field|port", dataSource.Type);
}
ICodeModel rootCodeModel = dataSource.Root.Value <ICodeModel>();
bool isStruct = dataSourceField.DataType.PotentialFullNames.Any(n => rootCodeModel.GetClass(n) != null || rootCodeModel.GetStructure(n) != null);
IEnum @enum = dataSourceField.DataType.PotentialFullNames.Select(n => rootCodeModel.GetEnum(n)).FirstOrDefault(e => e != null);
bool isArray = dataSourceField.Multiplicity.Any();
string arpName = "DataType::" + GetArpDataType(dataSourceField.DataType.Name);
return(owner.Create(key, arpName));
string GetArpDataType(string dataTypeName)
{
string postfix = isArray ? " | DataType::Array" : string.Empty;
if (isStruct)
{
return("Struct" + postfix);
}
if (@enum != null)
{
(IDataType enumBaseType, string formattedBaseType) = GetEnumBaseType(@enum);
return($"Enum | DataType::{formattedBaseType}" + postfix);
}
(bool success, string value) = FormatDataType(dataTypeName);
if (!success)
{
throw new UnknownDataTypeException(value);
}
return(value + postfix);
}
}
(bool success, string value) FormatDataType(string unformattedValue)
{
if (unformattedValue.Contains('<'))
{
unformattedValue = unformattedValue.Substring(0, unformattedValue.IndexOf('<'));
}
string result = owner.Create("temporaryCtnFormatContainer", unformattedValue).Format()["knownDataTypes"].Value <string>();
Match unkownMatch = UnkownDataTypeRegex.Match(result);
if (unkownMatch.Success)
{
return(false, unkownMatch.Groups["dataType"].Value);
}
return(true, result);
}
(IDataType, string) GetEnumBaseType(IEnum @enum)
{
IDataType enumDataType = @enum.BaseTypes.FirstOrDefault();
string enumBaseType = enumDataType?.Name;
if (string.IsNullOrEmpty(enumBaseType))
{
throw new MissingEnumDataTypeException(@enum);
}
(bool formatted, string formattedBaseType) = FormatDataType(enumBaseType);
if (!formatted)
{
throw new UnkownEnumDataTypeException(formattedBaseType, @enum);
}
return(enumDataType, formattedBaseType);
}
Entity GetBigDataProjectEntity()
{
if (HasMoreThan1000Fields())
{
return(owner.Create(key, "true", true));
}
return(owner.Create(key, "false", false));
}
Entity GetNormalProjectEntity()
{
if (HasMoreThan1000Fields())
{
return(owner.Create(key, "false", false));
}
return(owner.Create(key, "true", true));
}
bool HasMoreThan1000Fields()
{
ICodeModel model = owner.Value <ICodeModel>();
if (model == null ||
GetAllPorts().Concat(GetPortStructures().SelectMany(s => s.Fields)).Count() <= 1000)
{
return(false);
}
return(true);
}
}
