public Resolution(ApplicationModel application, LayerModel layer, ModuleModel module, ObjectDescriptor objectDescriptor, CompositeMethodModel method, FieldInfo field) { this.Application = application; this.Layer = layer; this.Module = module; this.ObjectDescriptor = objectDescriptor; this.Method = method; this.Field = field; }
private ShapeKind GetShapeKind(ObjectDescriptor objectDescriptor) { var shapeKind = ShapeKind.None; if (objectDescriptor != null) { var objectDescriptorPointsCount = objectDescriptor.Points.Count; if (objectDescriptorPointsCount > maxVerticesCount) { // 복잡한 객체는 X 기호로 표시된다. shapeKind = ShapeKind.X; } else { if (Enum.IsDefined(typeof(ShapeKind), objectDescriptorPointsCount)) { shapeKind = (ShapeKind)objectDescriptorPointsCount; } } } return(shapeKind); }
/// <summary> /// each derived class will handle the <see cref="XElement" /> according to it's logic. /// </summary> /// <param name="element">The element.</param> /// <param name="chain">The chain.</param> /// <returns></returns> protected override BaseDescriptor HandleInternal(XElement element, DescriptorRecreationChain chain) { var nameAttr = element.Attribute("name"); var typeAttr = element.Attribute("type"); var idAttr = element.Attribute("id"); var objDescriptor = new ObjectDescriptor(nameAttr.Value, typeAttr.Value, idAttr.Value); var fields = GetDescriptors(element, "fields", chain); foreach (var fieldDesciptor in fields) { objDescriptor.AddField(fieldDesciptor); } var properties = GetDescriptors(element, "properties", chain); foreach (var propDescriptor in properties) { objDescriptor.AddProperty(propDescriptor); } return(objDescriptor); }
public override ObjectDescriptor GetDescriptor() { ObjectDescriptor descriptor = new ObjectDescriptor(); descriptor.Type = NodeType.UIAControl; descriptor.Name = this.NodeName; descriptor.Description = this.Description; if (_relation != null) { descriptor.SetItem <VisualRelationPropertyItem>(_relation); } IdentifyPropertyGroup item = new IdentifyPropertyGroup(); item.Properties = _properties; item.Properties[ControlKeys.Type] = _type.ControlTypeToString(); descriptor.SetItem <IdentifyPropertyGroup>(item); CachedPropertyGroup cachedGroup = GetContext <CachedPropertyGroup>(); if (cachedGroup != null) { descriptor.SetItem <CachedPropertyGroup>(cachedGroup); } foreach (ITestObject to in Children) { ObjectDescriptor childDescriptor = to.GetDescriptor(); descriptor.Children.Add(childDescriptor); childDescriptor.Parent = descriptor; } return(descriptor); }
/// <inheritdoc/> public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value) { // If this member should contains a reference, create it now. var containerNode = (IInitializingObjectNode)GetContextNode(); var guid = Guid.NewGuid(); var content = (MemberNode)NodeFactory.CreateMemberNode(this, guid, containerNode, member, value); containerNode.AddMember(content); if (content.IsReference) { referenceContents.Add(content); } PushContextNode(content); if (content.TargetReference == null) { // For enumerable references, we visit the member to allow VisitCollection or VisitDictionary to enrich correctly the node. Visit(content.Retrieve()); } PopContextNode(); content.Seal(); }
public void SubscribeTest() { // Arrange var objectId = "objId1"; EventNotification actualNotif = null; _callbackMock.Setup(o => o.Callback(It.IsAny <INotification>())).Callback <INotification>((notif) => { actualNotif = notif as EventNotification; }); var server = new Recipient(); var request = new SubscribeRequest() { objectId = objectId, eventId = ObjectDescriptor.GetEventId <IRegisteredObject>(nameof(IRegisteredObject.NotifyOnNonDataChanged)) }; // Act server.Register(objectId, _regObjectMock.Object); var response = server.Request(request, _callbackMock.Object) as SubscribeResponse; _regObjectMock.Raise(o => o.NotifyOnNonDataChanged += null, EventArgs.Empty); // Assert _callbackMock.Verify(); _regObjectMock.Verify(); Assert.AreEqual(NotificationType.eventInvoked, actualNotif.notificationType); Assert.AreEqual(request.objectId, actualNotif.objectId); Assert.AreEqual(request.eventId, actualNotif.eventId); Assert.IsNotNull(actualNotif.eventArgs as EventArgs); Assert.AreEqual(ResponseType.subscribe, response.responseType); Assert.AreEqual(request.objectId, response.objectId); Assert.AreEqual(request.eventId, response.eventId); }
public void PropertyGetValue() { // Arrange string objectId = "obj1Id"; var proxyObj = RuntimeProxy.Create <IRegisteredObject>(objectId, _clientMock.Object); string expectedValue = "actual value"; _clientMock.Setup(o => o.Request(It.IsAny <PropertyGetRequest>())).Returns <PropertyGetRequest>(req => { return(new PropertyGetResponse() { objectId = objectId, propertyId = ObjectDescriptor.GetPropertyId <IRegisteredObject>(nameof(IRegisteredObject.StringValueProperty)), value = expectedValue }); }); // Act var actualValue = proxyObj.StringValueProperty; // Assert _clientMock.VerifyAll(); Assert.AreEqual(expectedValue, actualValue); }
public async Task QuantityOfTemplateElementsAndObjectElementsShouldMatch() { const int TemplateCode = 100; var templateDescriptor = new TemplateDescriptor { Id = TemplateId, VersionId = TemplateVersionId, Properties = new JObject(), Elements = new[] { new ElementDescriptor( ElementDescriptorType.PlainText, TemplateCode, new JObject(), new ConstraintSet(Array.Empty <ConstraintSetItem>())) } }; _objectsStorageReaderMock.Setup(m => m.IsObjectExists(It.IsAny <long>())) .ReturnsAsync(() => false); _templatesStorageReaderMock.Setup(m => m.GetTemplateDescriptor(It.IsAny <long>(), It.IsAny <string>())) .ReturnsAsync(() => templateDescriptor); var objectDescriptor = new ObjectDescriptor { Language = Language.Ru, TemplateId = TemplateId, TemplateVersionId = TemplateVersionId, Properties = new JObject(), Elements = Array.Empty <IObjectElementDescriptor>() }; await Assert.ThrowsAsync <ObjectInconsistentException>( async() => await _objectsManagementService.Create(ObjectId, AuthorInfo, objectDescriptor)); }
/// <inheritdoc/> public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value) { //bool shouldProcessReference; //nodeBuilder.NotifyNodeConstructing(containerDescriptor, member, out shouldProcessReference); var node = GetContextNode(); GraphNode child; try { child = (GraphNode)node.Children.Single(x => x.Name == member.Name); } catch (InvalidOperationException) { throw new QuantumConsistencyException("A single child node [{0}]", member.Name, "No child or multiple children [{0}]", member.Name, node); } if (!IsPrimitiveType(child.Content.Type)) { PushContextNode(child); Visit(value); PopContextNode(); } }
public bool MoveNext() { mCurrent = mResponse.NextObject(); return (mCurrent != null); }
private IEnumerable<AstNodeViewModel> ToItems(ObjectDescriptor[] objectDescriptors) { for (int i = 0; i < objectDescriptors.Length; i++) yield return new ItemAstNodeViewModel(Context, objectDescriptors[i], i); }
public async Task CorrectJsonShouldBePassedToS3PutObjectForScalableBitmapImageElementWithoutAnchor() { const int TemplateCode = 100; const Language Language = Language.Ru; var constraints = new ScalableBitmapImageElementConstraints(); var templateDescriptor = new TemplateDescriptor { Id = TemplateId, VersionId = TemplateVersionId, Properties = new JObject(), Elements = new[] { new ElementDescriptor( ElementDescriptorType.ScalableBitmapImage, TemplateCode, new JObject(), new ConstraintSet(new[] { new ConstraintSetItem(Language, constraints) })) } }; _objectsStorageReaderMock.Setup(m => m.IsObjectExists(It.IsAny <long>())) .ReturnsAsync(() => false); _templatesStorageReaderMock.Setup(m => m.GetTemplateDescriptor(It.IsAny <long>(), It.IsAny <string>())) .ReturnsAsync(() => templateDescriptor); _templatesStorageReaderMock.Setup(m => m.GetTemplateLatestVersion(It.IsAny <long>())) .ReturnsAsync(() => TemplateVersionId); _objectsStorageReaderMock.Setup(m => m.GetObjectLatestVersions(It.IsAny <long>())) .ReturnsAsync(() => new[] { new VersionedObjectDescriptor <string>( ObjectId.AsS3ObjectKey(Tokens.ObjectPostfix), ObjectVersionId, DateTime.UtcNow) }); var response = new GetObjectMetadataResponse(); var metadataWrapper = MetadataCollectionWrapper.For(response.Metadata); metadataWrapper.Write(MetadataElement.ExpiresAt, DateTime.UtcNow.AddDays(1)); _cephS3ClientMock.Setup(m => m.GetObjectMetadataAsync(It.IsAny <string>(), It.IsAny <string>())) .ReturnsAsync(() => response); var requests = new List <PutObjectRequest>(); _s3ClientMock.Setup(m => m.PutObjectAsync(It.IsAny <PutObjectRequest>())) .Callback <PutObjectRequest>(request => requests.Add(request)) .ReturnsAsync(new PutObjectResponse()); var fileKey = Guid.NewGuid().AsS3ObjectKey("key.raw"); var objectDescriptor = new ObjectDescriptor { Language = Language, TemplateId = TemplateId, TemplateVersionId = TemplateVersionId, Properties = new JObject(), Elements = new[] { new ObjectElementDescriptor { Type = ElementDescriptorType.ScalableBitmapImage, TemplateCode = TemplateCode, Constraints = new ConstraintSet(new[] { new ConstraintSetItem(Language, constraints) }), Value = new ScalableBitmapImageElementValue { Raw = fileKey } } } }; await _objectsManagementService.Create(ObjectId, AuthorInfo, objectDescriptor); var elementContent = requests[0].ContentBody; var elementJson = JObject.Parse(elementContent); var valueJson = elementJson["value"]; Assert.Equal(fileKey, valueJson["raw"]); Assert.NotNull(valueJson["filename"]); Assert.NotNull(valueJson["filesize"]); Assert.Equal(nameof(Anchor.Middle).ToLower(), valueJson["anchor"]); }
public async Task S3PutObjectShouldBeCalledWhileCreation() { const int TemplateCode = 100; const Language Language = Language.Ru; var plainTextConstraints = new PlainTextElementConstraints { MaxSymbols = 100 }; var templateDescriptor = new TemplateDescriptor { Id = TemplateId, VersionId = TemplateVersionId, Properties = new JObject(), Elements = new[] { new ElementDescriptor( ElementDescriptorType.PlainText, TemplateCode, new JObject(), new ConstraintSet(new[] { new ConstraintSetItem(Language, plainTextConstraints) })) } }; _objectsStorageReaderMock.Setup(m => m.IsObjectExists(It.IsAny <long>())) .ReturnsAsync(() => false); _templatesStorageReaderMock.Setup(m => m.GetTemplateDescriptor(It.IsAny <long>(), It.IsAny <string>())) .ReturnsAsync(() => templateDescriptor); _templatesStorageReaderMock.Setup(m => m.GetTemplateLatestVersion(It.IsAny <long>())) .ReturnsAsync(() => TemplateVersionId); _objectsStorageReaderMock.Setup(m => m.GetObjectLatestVersions(It.IsAny <long>())) .ReturnsAsync(() => new[] { new VersionedObjectDescriptor <string>( ObjectId.AsS3ObjectKey(Tokens.ObjectPostfix), ObjectVersionId, DateTime.UtcNow) }); var objectDescriptor = new ObjectDescriptor { Language = Language, TemplateId = TemplateId, TemplateVersionId = TemplateVersionId, Properties = new JObject(), Elements = new[] { new ObjectElementDescriptor { Type = ElementDescriptorType.PlainText, TemplateCode = TemplateCode, Constraints = new ConstraintSet(new[] { new ConstraintSetItem(Language, plainTextConstraints) }), Value = new TextElementValue { Raw = "Text" } } } }; await _objectsManagementService.Create(ObjectId, AuthorInfo, objectDescriptor); _s3ClientMock.Verify(m => m.PutObjectAsync(It.IsAny <PutObjectRequest>()), Times.Exactly(2)); }
private async Task <IReadOnlyCollection <ObjectVersionRecord> > GetObjectVersions(long id, string initialVersionId, bool fetchElements) { var objectDescriptors = new List <ObjectDescriptor>(); async Task <(bool IsTruncated, int NextVersionIndex, string NextVersionIdMarker)> ListVersions(int nextVersionIndex, string nextVersionIdMarker) { await _distributedLockManager.EnsureLockNotExistsAsync(id); var response = await _s3Client.ListVersionsAsync( new ListVersionsRequest { BucketName = _bucketName, Prefix = id.AsS3ObjectKey(Tokens.ObjectPostfix), VersionIdMarker = nextVersionIdMarker }); var nonDeletedVersions = response.Versions.FindAll(x => !x.IsDeleteMarker); nextVersionIndex += nonDeletedVersions.Count; var initialVersionIdReached = false; var versionInfos = nonDeletedVersions .Aggregate( new List <(string VersionId, DateTime LastModified)>(), (list, next) => { initialVersionIdReached = initialVersionIdReached || (!string.IsNullOrEmpty(initialVersionId) && initialVersionId.Equals(next.VersionId, StringComparison.OrdinalIgnoreCase)); if (!initialVersionIdReached) { list.Add((next.VersionId, next.LastModified)); } return(list); }); var descriptors = new ObjectDescriptor[versionInfos.Count]; var partitioner = Partitioner.Create(versionInfos); var tasks = partitioner.GetOrderablePartitions(_degreeOfParallelism) .Select(async partition => { while (partition.MoveNext()) { var index = partition.Current.Key; var versionInfo = partition.Current.Value; descriptors[index] = await GetObjectDescriptor(id, versionInfo.VersionId, CancellationToken.None, fetchElements); } }); await Task.WhenAll(tasks); objectDescriptors.AddRange(descriptors); return(!initialVersionIdReached && response.IsTruncated, nextVersionIndex, response.NextVersionIdMarker); } var result = await ListVersions(0, null); if (objectDescriptors.Count == 0) { if (!await IsObjectExists(id)) { throw new ObjectNotFoundException($"Object '{id}' not found."); } return(Array.Empty <ObjectVersionRecord>()); } while (result.IsTruncated) { result = await ListVersions(result.NextVersionIndex, result.NextVersionIdMarker); } var maxVersionIndex = result.NextVersionIndex; var records = new ObjectVersionRecord[objectDescriptors.Count]; for (var index = 0; index < objectDescriptors.Count; ++index) { var descriptor = objectDescriptors[index]; records[index] = new ObjectVersionRecord( descriptor.Id, descriptor.VersionId, --maxVersionIndex, descriptor.LastModified, new AuthorInfo(descriptor.Metadata.Author, descriptor.Metadata.AuthorLogin, descriptor.Metadata.AuthorName), descriptor.Properties, descriptor.Elements.Select(x => new ObjectVersionRecord.ElementRecord(x.TemplateCode, x.Value)).ToList(), descriptor.Metadata.ModifiedElements); } return(records); }
UIntPtr VisitReferenceFieldsTemplateNoInline(ref ObjectDescriptor objDesc) { return(VisitReferenceFieldsTemplate(ref objDesc)); }
void Filter(UIntPtr *location, ref ObjectDescriptor objDesc);
public DynamicObjectIterator(ObjectDescriptor descriptor) { _descriptor = descriptor; }
public override int Write(ObjectId id, Stream dataStream, long length, ObjectType objectType) { var objDescriptor = new ObjectDescriptor { Length = length, ObjectType = objectType }; var bf = new BinaryFormatter(); using (var ms = new MemoryStream()) using (var tx = _env.NewTransaction(TransactionFlags.ReadWrite)) { bf.Serialize(ms, objDescriptor); ms.Seek(0, SeekOrigin.Begin); tx.State.GetTree(tx, Index).Add(tx, id.Sha, ms); tx.State.GetTree(tx, Objects).Add(tx, id.Sha, dataStream); tx.Commit(); } return (int)ReturnCode.GIT_OK; }
public ItemAstNodeViewModel(AstContext context, ObjectDescriptor objectDescriptor, int index) : base(context, objectDescriptor) { Index = index; }
private IEnumerable<AstNodeViewModel> ToAstList(PropertyDescriptor[] propertyDescriptors, ObjectDescriptor[] objectDescriptors) { foreach (var propertyDescriptor in propertyDescriptors) yield return new PropertyAstNodeViewModel(Context, propertyDescriptor); for (int i = 0; i < objectDescriptors.Length; i++) yield return new ItemAstNodeViewModel(Context, objectDescriptors[i], i); }
public ObjectAccessor(object data, ObjectDescriptor descriptor) { _data = data; _descriptor = descriptor; }
protected AbstractPresenceNotificatonResponse(int trid, string account, string nick, ClientStatus status, NetworkId networkId, ClientCapabilities capabilities, ObjectDescriptor descriptor, PackageType packageType) : base(trid, packageType) { this.Account = account; this.NickName = nick; this.Status = status; this.NetworkId = networkId; this.Capabilities = capabilities; this.Descriptor = descriptor; }
UIntPtr VisitReferenceFieldsTemplate(ref ObjectDescriptor objDesc) { UIntPtr pointerTracking = objDesc.vtable.pointerTrackingMask; uint objectTag = (pointerTracking & 0xf); UIntPtr size; switch (objectTag) { case ObjectLayout.SPARSE_TAG: { UIntPtr *sparseObject = (UIntPtr *)objDesc.objectBase; size = ObjectLayout.ObjectSize(objDesc.vtable); pointerTracking >>= 4; while (pointerTracking != 0) { uint index = pointerTracking & 0xf; pointerTracking >>= 4; // The cast to int prevents C# from taking the // index * sizeof(UIntPtr) to long: UIntPtr *loc = sparseObject + (int)index; this.Filter(loc, ref objDesc); } break; } case ObjectLayout.DENSE_TAG: { // skip vtable int postHeaderSize = PostHeader.Size; UIntPtr *denseObject = (UIntPtr *) (objDesc.objectBase + postHeaderSize); size = ObjectLayout.ObjectSize(objDesc.vtable); pointerTracking >>= 4; while (pointerTracking != 0) { if ((pointerTracking & ((UIntPtr)0x1)) != 0) { this.Filter(denseObject, ref objDesc); } pointerTracking >>= 1; denseObject++; } break; } case ObjectLayout.PTR_VECTOR_TAG: { int postHeaderSize = PostHeader.Size; uint length = *(uint *)(objDesc.objectBase + postHeaderSize); size = ObjectLayout.ArraySize(objDesc.vtable, length); int preHeaderSize = PreHeader.Size; UIntPtr *elementAddress = (UIntPtr *) (objDesc.objectBase + objDesc.vtable.baseLength - preHeaderSize); for (uint i = 0; i < length; i++, elementAddress++) { this.Filter(elementAddress, ref objDesc); } break; } case ObjectLayout.OTHER_VECTOR_TAG: { int postHeaderSize = PostHeader.Size; uint length = *(uint *)(objDesc.objectBase + postHeaderSize); size = ObjectLayout.ArraySize(objDesc.vtable, length); if (objDesc.vtable.arrayOf == StructuralType.Struct) { // pretend the struct is boxed and account for the // presence of the vtable field VTable elementVTable = objDesc.vtable.arrayElementClass; UIntPtr elementMask = elementVTable.pointerTrackingMask; // A structure with no references will have a SPARSE // descriptor with no offset values. if (elementMask != (UIntPtr)ObjectLayout.SPARSE_TAG) { int preHeaderSize = PreHeader.Size; UIntPtr elementAddress = (objDesc.objectBase + objDesc.vtable.baseLength - preHeaderSize - postHeaderSize); int elementSize = objDesc.vtable.arrayElementSize; objDesc.vtable = elementVTable; for (uint i = 0; i < length; i++) { objDesc.objectBase = elementAddress; this.VisitReferenceFieldsTemplateNoInline(ref objDesc); elementAddress += elementSize; } } } break; } case ObjectLayout.PTR_ARRAY_TAG: { int postHeaderSize = PostHeader.Size; uint length = *(uint *)(objDesc.objectBase + postHeaderSize + sizeof(uint)); size = ObjectLayout.ArraySize(objDesc.vtable, length); int preHeaderSize = PreHeader.Size; UIntPtr *elementAddress = (UIntPtr *) (objDesc.objectBase + objDesc.vtable.baseLength - preHeaderSize); for (uint i = 0; i < length; i++, elementAddress++) { this.Filter(elementAddress, ref objDesc); } break; } case ObjectLayout.OTHER_ARRAY_TAG: { int postHeaderSize = PostHeader.Size; uint length = *(uint *)(objDesc.objectBase + postHeaderSize + sizeof(uint)); size = ObjectLayout.ArraySize(objDesc.vtable, length); if (objDesc.vtable.arrayOf == StructuralType.Struct) { // pretend the struct is boxed and account for the // presence of the PostHeader VTable elementVTable = objDesc.vtable.arrayElementClass; UIntPtr elementMask = elementVTable.pointerTrackingMask; // A structure with no references will have a SPARSE // descriptor with no offset values. if (elementMask != (UIntPtr)ObjectLayout.SPARSE_TAG) { int preHeaderSize = PreHeader.Size; int elementSize = objDesc.vtable.arrayElementSize; UIntPtr elementAddress = objDesc.objectBase + objDesc.vtable.baseLength - preHeaderSize - postHeaderSize; objDesc.vtable = elementVTable; for (uint i = 0; i < length; i++) { objDesc.objectBase = elementAddress; this.VisitReferenceFieldsTemplateNoInline(ref objDesc); elementAddress += elementSize; } } } break; } case ObjectLayout.STRING_TAG: { int postHeaderSize = PostHeader.Size; uint arrayLength = *(uint *)(objDesc.objectBase + postHeaderSize); size = ObjectLayout.StringSize(objDesc.vtable, arrayLength); break; } default: { // escape case VTable.Assert((objectTag & 0x1) == 0, "ReferenceVisitor: (objectTag & 0x1) == 0"); UIntPtr *largeObject = (UIntPtr *)objDesc.objectBase; size = ObjectLayout.ObjectSize(objDesc.vtable); int *pointerDescription = (int *)pointerTracking; int count = *pointerDescription; for (int i = 1; i <= count; i++) { UIntPtr *loc = largeObject + *(pointerDescription + i); this.Filter(loc, ref objDesc); } break; } } return(size); }
private async Task <ObjectDescriptor> GetObjectDescriptor(long id, string versionId, CancellationToken cancellationToken, bool fetchElements) { string objectVersionId; if (string.IsNullOrEmpty(versionId)) { var objectVersions = await GetObjectLatestVersions(id); objectVersionId = objectVersions.Where(x => x.Id.EndsWith(Tokens.ObjectPostfix)) .Select(x => x.VersionId) .SingleOrDefault(); if (objectVersionId == null) { throw new ObjectNotFoundException($"Object '{id}' not found."); } } else { objectVersionId = versionId; } var(persistenceDescriptor, objectAuthorInfo, objectLastModified, modifiedElements) = await GetObjectFromS3 <ObjectPersistenceDescriptor>(id.AsS3ObjectKey(Tokens.ObjectPostfix), objectVersionId, cancellationToken); var elements = Array.Empty <ObjectElementDescriptor>(); if (fetchElements) { var tasks = persistenceDescriptor.Elements .Select(async x => { var(elementPersistenceDescriptor, _, elementLastModified, _) = await GetObjectFromS3 <ObjectElementPersistenceDescriptor>(x.Id, x.VersionId, cancellationToken); SetCdnUris(id, objectVersionId, elementPersistenceDescriptor); return(new ObjectElementDescriptor { Id = x.Id.AsSubObjectId(), VersionId = x.VersionId, LastModified = elementLastModified, Type = elementPersistenceDescriptor.Type, TemplateCode = elementPersistenceDescriptor.TemplateCode, Properties = elementPersistenceDescriptor.Properties, Constraints = elementPersistenceDescriptor.Constraints, Value = elementPersistenceDescriptor.Value }); }) .ToList(); elements = await Task.WhenAll(tasks); } var descriptor = new ObjectDescriptor { Id = id, VersionId = objectVersionId, LastModified = objectLastModified, TemplateId = persistenceDescriptor.TemplateId, TemplateVersionId = persistenceDescriptor.TemplateVersionId, Language = persistenceDescriptor.Language, Properties = persistenceDescriptor.Properties, Elements = elements, Metadata = new ObjectDescriptor.ObjectMetadata { Author = objectAuthorInfo.Author, AuthorLogin = objectAuthorInfo.AuthorLogin, AuthorName = objectAuthorInfo.AuthorName, ModifiedElements = modifiedElements } }; return(descriptor); }
/// <summary> /// Generates new object identifier. For objects owned directly by schema, generates /// variation of "schema.{object type}¹". For nested objects returns variation of /// "{parent ID}.{object type}¹". /// </summary> /// <param name="hierarchy">Server explorer facade object to be used for Server Explorer hierarchy interaction.</param> /// <param name="item">Item identifier.</param> /// <param name="typeName">Object type name.</param> /// <returns>Returns array with multipart identifier for the object.</returns> protected override object[] GetObjectID(ServerExplorerFacade hierarchy, string typeName, int item) { if (hierarchy == null) { throw new ArgumentNullException("hierarchy"); } if (item < 0) { throw new ArgumentOutOfRangeException("item"); } if (typeName == null) { throw new ArgumentNullException("typeName"); } // Get identifier length int idLength = ObjectDescriptor.GetIdentifierLength(typeName); if (idLength <= 0) { throw new NotSupportedException(String.Format( CultureInfo.CurrentCulture, Resources.Error_ObjectTypeNotSupported, typeName)); } // Create object ID template object[] id; // Get parent object identifier object[] parentID = hierarchy.GetObjectIdentifier(item); // For embedded objects ID is ID of owner object with one additional slot. if (parentID != null && parentID.Length == idLength - 1) { // Initialize object identifier template id = new object[idLength]; // Copy parent object identifier to the template parentID.CopyTo(id, 0); } // For root objects (objects owned directly by schema) ID has three slots with // schema name in the middle else { id = CreateNewIDBase(hierarchy, typeName); if (id == null || id.Length != idLength) { throw new NotSupportedException(String.Format( CultureInfo.CurrentCulture, Resources.Error_ObjectTypeNotSupported, typeName)); } } // Extract template for the new name string template = GetTemplate(typeName, id); if (template == null) { template = typeName; } // Generate object name (fill the last slot) CompleteNewObjectID(hierarchy, typeName, ref id, template); // Return result return(id); }
void Filter(UIntPtr *location, ref ObjectDescriptor objDesc) { this.Visit(location); }
/// <summary> /// Initializes a new instance of the <see cref="DataVisitObject" /> class. /// </summary> /// <param name="instance">The instance.</param> /// <param name="instanceDescriptor">The instance descriptor.</param> /// <exception cref="System.ArgumentNullException">instance /// or /// instanceDescriptor</exception> public DataVisitObject(object instance, ObjectDescriptor instanceDescriptor) : base(instance, instanceDescriptor) { }
public async Task CorrectJsonShouldBePassedToS3PutObjectForTextElement() { const int TemplateCode = 100; const Language Language = Language.Ru; var plainTextConstraints = new PlainTextElementConstraints { MaxSymbols = 100 }; var templateDescriptor = new TemplateDescriptor { Id = TemplateId, VersionId = TemplateVersionId, Properties = new JObject(), Elements = new[] { new ElementDescriptor( ElementDescriptorType.PlainText, TemplateCode, new JObject(), new ConstraintSet(new[] { new ConstraintSetItem(Language, plainTextConstraints) })) } }; _objectsStorageReaderMock.Setup(m => m.IsObjectExists(It.IsAny <long>())) .ReturnsAsync(() => false); _templatesStorageReaderMock.Setup(m => m.GetTemplateDescriptor(It.IsAny <long>(), It.IsAny <string>())) .ReturnsAsync(() => templateDescriptor); _templatesStorageReaderMock.Setup(m => m.GetTemplateLatestVersion(It.IsAny <long>())) .ReturnsAsync(() => TemplateVersionId); _objectsStorageReaderMock.Setup(m => m.GetObjectLatestVersions(It.IsAny <long>())) .ReturnsAsync(() => new[] { new VersionedObjectDescriptor <string>( ObjectId.AsS3ObjectKey(Tokens.ObjectPostfix), ObjectVersionId, DateTime.UtcNow) }); var requests = new List <PutObjectRequest>(); _s3ClientMock.Setup(m => m.PutObjectAsync(It.IsAny <PutObjectRequest>())) .Callback <PutObjectRequest>(request => requests.Add(request)) .ReturnsAsync(new PutObjectResponse()); var objectDescriptor = new ObjectDescriptor { Language = Language, TemplateId = TemplateId, TemplateVersionId = TemplateVersionId, Properties = new JObject(), Elements = new[] { new ObjectElementDescriptor { Type = ElementDescriptorType.PlainText, TemplateCode = TemplateCode, Constraints = new ConstraintSet(new[] { new ConstraintSetItem(Language, plainTextConstraints) }), Value = new TextElementValue { Raw = "Text" } } } }; await _objectsManagementService.Create(ObjectId, AuthorInfo, objectDescriptor); var elementContent = requests[0].ContentBody; var elementJson = JObject.Parse(elementContent); Assert.Equal("Text", elementJson["value"]["raw"]); }
public ObjectAccessor(object data, ObjectDescriptor descriptor) { _data = data; _descriptor = descriptor; _memberAccessor = _descriptor.MemberAccessor; }
internal abstract void FieldOffset(UIntPtr offset, ref ObjectDescriptor objDesc);
public AstNodeViewModel(AstContext context, ObjectDescriptor objectDescriptor) { Context = context; _objectDescriptor = objectDescriptor; Items = new ReactiveList<AstNodeViewModel>(); if (objectDescriptor.IsObject || objectDescriptor.IsSeq && objectDescriptor.Count > 0) { NeedLoadContent = true; Items.Add(null); } this.WhenAnyValue(vm => vm.IsExpanded) .Where(isExpanded => isExpanded && NeedLoadContent) .Subscribe(_ => LoadItems()); }
// <summary> // Returns a wrapper for the specified EFObject. The wrapper is the type descriptor // that describes the properties that should be displayed for the EFObject. // The returned wrapper should be handed to a property window control // </summary> public static ObjectDescriptor GetObjectDescriptor(EFObject obj, EditingContext editingContext, bool runningInVS) { if (obj != null) { Type objectDescriptorType; if (ObjectDescriptorTypes.TryGetValue(obj.GetType(), out objectDescriptorType)) { // create the descriptor wrapper for the EFObject object var descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, objectDescriptorType, null, null); descriptor.Initialize(obj, editingContext, runningInVS); return(descriptor); } else { // special case for Property var property = obj as Property; if (property != null) { ObjectDescriptor descriptor = null; if (property is ComplexConceptualProperty) { descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFComplexPropertyDescriptor), null, null); } else if (property.EntityModel.IsCSDL) { descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFPropertyDescriptor), null, null); } else { descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFSPropertyDescriptor), null, null); } descriptor.Initialize(obj, editingContext, runningInVS); return(descriptor); } // special case for Parameter var parameter = obj as Parameter; if (parameter != null) { ObjectDescriptor descriptor = null; if (parameter.Parent is FunctionImport) { descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFParameterDescriptor), null, null); descriptor.Initialize(obj, editingContext, runningInVS); return(descriptor); } else if (parameter.Parent is Function) { //Stored procedure parameter descriptor (EFSParameterDescriptor) descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFSParameterDescriptor), null, null); descriptor.Initialize(obj, editingContext, runningInVS); return(descriptor); } } } } return(null); }
void Filter(UIntPtr *location, ref ObjectDescriptor objDesc) { UIntPtr offset = ((UIntPtr)location) - objDesc.objectBase; this.FieldOffset(offset, ref objDesc); }
/// <summary> /// Parses the descriptor recursively. /// </summary> /// <param name="instance">The instance.</param> /// <param name="sourceName">Name of the source.</param> /// <param name="objType">Type of the object.</param> /// <param name="memberFilter"></param> /// <returns></returns> /// <exception cref="System.Runtime.Serialization.SerializationException">Cannot serialize non public type</exception> public BaseDescriptor ParseDescriptor(object instance, string sourceName, Type objType) { if (instance == null) { return(new NullDescriptor(sourceName)); } bool dummyRequiredOutputValue; long objId = IdGen.GetId(instance, out dummyRequiredOutputValue); int hashCode = instance.GetHashCode(); string typeRefId = objId + ID_CODE_TOKEN + objType.Name + ID_CODE_TOKEN + hashCode; if (IdTracker.Contains(typeRefId)) { return(new CopyReferenceDescriptor(sourceName, objType.AssemblyQualifiedName, typeRefId)); } if (objType.IsPrimitive || Type.GetTypeCode(objType) == TypeCode.String) { return(new PrimitiveDescriptor(sourceName, objType.AssemblyQualifiedName, instance.ToString())); } if (!objType.IsVisible) { throw new SerializationException("Cannot serialize non public type"); } IdTracker.Add(typeRefId); //Todo - add a collection support //if (objType.IsGenericType || objType.IsGenericTypeDefinition) //{ // Type collectionType = typeof(ICollection<>).MakeGenericType(objType.GetGenericArguments()); // if (collectionType.IsAssignableFrom(objType)) // { // var collectionDescriptor = new CollectionDescriptor(sourceName, objType.AssemblyQualifiedName, typeRefId); // IEnumerable collection = (IEnumerable)instance; // foreach (var item in collection) // { // Type itemType = item.GetType(); // BaseDescriptor descriptor = ParseDescriptor(item, itemType.Name, itemType); // collectionDescriptor.Values.Add(descriptor); // } // return collectionDescriptor; // } //} var objectDescriptor = new ObjectDescriptor(sourceName, objType.AssemblyQualifiedName, typeRefId); var bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance; ReadFields(objectDescriptor, instance, objType, bindingFlags); ReadProperties(objectDescriptor, instance, objType, bindingFlags); return(objectDescriptor); }
public LayoutViewModel(string body, object value) { _body = body; _value = value; _valueDescriptor = ObjectDescriptor.Create(value); }
// Use this for initialization void Start() { aSource = GetComponentInChildren<AudioSource>(); child_script = GetComponentInChildren<ObjectDescriptor>(); // Get the }
public async Task TestObjectSerialization() { var descriptor = new ObjectDescriptor { Id = 100500L, VersionId = "QWERTYasdf_123456", Language = Language.Es, LastModified = DateTime.UtcNow, TemplateId = 123456L, TemplateVersionId = "TEMPLATE_VERSION+123)(*&^%", Properties = JObject.FromObject(new { MyProp = 369, SecondProp = "best_string" }), Metadata = new ObjectDescriptor.ObjectMetadata { Author = "id", AuthorLogin = "******", AuthorName = "name", ModifiedElements = Array.Empty <int>() }, Elements = new[] { new ObjectElementDescriptor { Id = 100L, TemplateCode = 1, Type = ElementDescriptorType.FasComment, Value = new FasElementValue { Raw = "alcohol", Text = "Danger!" }, Properties = JObject.FromObject(new { Name = "First element" }), Constraints = new ConstraintSet(new[] { new ConstraintSetItem(Language.Unspecified, new PlainTextElementConstraints { MaxLines = 1, MaxSymbols = 440, MaxSymbolsPerWord = null }) }) }, new ObjectElementDescriptor { Id = 101L, TemplateCode = 2, Type = ElementDescriptorType.FormattedText, Value = new TextElementValue { Raw = "<b>Bold</b> text" }, Properties = JObject.FromObject(new { Name = "Second element", AdditionalProp = 123 }), Constraints = new ConstraintSet(new[] { new ConstraintSetItem(Language.Unspecified, new FormattedTextElementConstraints { MaxLines = 3, MaxSymbols = 80, MaxSymbolsPerWord = 10 }) }) } } }; _mockObjectsStorageReader.Setup(x => x.GetObjectDescriptor(It.IsAny <long>(), It.IsAny <string>(), It.IsAny <CancellationToken>())) .ReturnsAsync(descriptor); using (var response = await _client.GetAsync($"/api/1.0/objects/{descriptor.Id}/{descriptor.VersionId}")) { Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(descriptor.VersionId, response.Headers.ETag.Tag.Trim('\"')); _mockObjectsStorageReader.Verify(x => x.GetObjectDescriptor(descriptor.Id, descriptor.VersionId, It.IsAny <CancellationToken>()), Times.Exactly(1)); var json = JObject.Parse(await response.Content.ReadAsStringAsync()); Assert.Equal(descriptor.Id, json["id"]); Assert.Equal(descriptor.VersionId, json["versionId"]); Assert.Equal(descriptor.Language.ToString().ToLowerInvariant(), json["language"]); Assert.Equal(descriptor.LastModified, json["lastModified"]); Assert.Equal(descriptor.TemplateId, json["templateId"]); Assert.Equal(descriptor.TemplateVersionId, json["templateVersionId"]); Assert.Equal(descriptor.Properties, json["properties"], JTokenEqualityComparer); Assert.Null(json["modifiedElements"]); Assert.Equal(descriptor.Metadata.Author, json["author"]); Assert.Equal(descriptor.Metadata.AuthorLogin, json["authorLogin"]); Assert.Equal(descriptor.Metadata.AuthorName, json["authorName"]); Assert.Equal(descriptor.Elements.Count, json["elements"].Children().Count()); foreach (var(expected, actual) in descriptor.Elements.Zip(json["elements"], (a, b) => (Expected: a, Actual: b))) { Assert.Equal(expected.Id, actual["id"]); Assert.Equal(expected.TemplateCode, actual["templateCode"]); Assert.Equal(expected.Type.ToString(), actual["type"].ToString(), StringComparer.OrdinalIgnoreCase); Assert.Equal(expected.Properties, actual["properties"], JTokenEqualityComparer); Assert.Equal(((IObjectElementRawValue)expected.Value).Raw, actual["value"]["raw"]); } } }
public ObjectDescriptorEnumerator(GetObjectResponse response) { mResponse = response; mCurrent = null; }