Inheritance: MonoBehaviour
Exemplo n.º 1
0
 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;
 }
Exemplo n.º 2
0
        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);
        }
Exemplo n.º 3
0
            /// <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);
            }
Exemplo n.º 4
0
        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);
        }
Exemplo n.º 5
0
        /// <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();
        }
Exemplo n.º 6
0
        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);
        }
Exemplo n.º 8
0
        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));
        }
Exemplo n.º 9
0
        /// <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();
            }
        }
Exemplo n.º 10
0
 public bool MoveNext()
 {
     mCurrent = mResponse.NextObject();
     return (mCurrent != null);
 }
Exemplo n.º 11
0
 private IEnumerable<AstNodeViewModel> ToItems(ObjectDescriptor[] objectDescriptors)
 {
   for (int i = 0; i < objectDescriptors.Length; i++)
     yield return new ItemAstNodeViewModel(Context, objectDescriptors[i], i);
 }
Exemplo n.º 12
0
        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"]);
        }
Exemplo n.º 13
0
        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);
        }
Exemplo n.º 15
0
 UIntPtr VisitReferenceFieldsTemplateNoInline(ref ObjectDescriptor objDesc)
 {
     return(VisitReferenceFieldsTemplate(ref objDesc));
 }
Exemplo n.º 16
0
 void Filter(UIntPtr *location, ref ObjectDescriptor objDesc);
 public DynamicObjectIterator(ObjectDescriptor descriptor)
 {
     _descriptor = descriptor;
 }
Exemplo n.º 18
0
        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;
        }
Exemplo n.º 19
0
 public ItemAstNodeViewModel(AstContext context, ObjectDescriptor objectDescriptor, int index) : base(context, objectDescriptor)
 {
   Index = index;
 }
Exemplo n.º 20
0
 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);
 }
Exemplo n.º 21
0
 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;
 }
Exemplo n.º 23
0
        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);
        }
Exemplo n.º 25
0
        /// <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);
        }
Exemplo n.º 26
0
 void Filter(UIntPtr *location, ref ObjectDescriptor objDesc)
 {
     this.Visit(location);
 }
Exemplo n.º 27
0
 /// <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)
 {
 }
Exemplo n.º 28
0
        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"]);
        }
Exemplo n.º 29
0
 public ObjectAccessor(object data, ObjectDescriptor descriptor)
 {
     _data           = data;
     _descriptor     = descriptor;
     _memberAccessor = _descriptor.MemberAccessor;
 }
Exemplo n.º 30
0
 internal abstract void FieldOffset(UIntPtr offset,
                                    ref ObjectDescriptor objDesc);
Exemplo n.º 31
0
    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());
    }
Exemplo n.º 32
0
        // <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);
        }
Exemplo n.º 33
0
        void Filter(UIntPtr *location, ref ObjectDescriptor objDesc)
        {
            UIntPtr offset = ((UIntPtr)location) - objDesc.objectBase;

            this.FieldOffset(offset, ref objDesc);
        }
Exemplo n.º 34
0
            /// <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);
            }
Exemplo n.º 35
0
 public LayoutViewModel(string body, object value)
 {
     _body            = body;
     _value           = value;
     _valueDescriptor = ObjectDescriptor.Create(value);
 }
Exemplo n.º 36
0
 public ItemAstNodeViewModel(AstContext context, ObjectDescriptor objectDescriptor, int index) : base(context, objectDescriptor)
 {
     Index = index;
 }
Exemplo n.º 37
0
 // Use this for initialization
 void Start()
 {
     aSource = GetComponentInChildren<AudioSource>();
     child_script = GetComponentInChildren<ObjectDescriptor>(); // Get the
 }
Exemplo n.º 38
0
        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"]);
                }
            }
        }
Exemplo n.º 39
0
 public ObjectDescriptorEnumerator(GetObjectResponse response)
 {
     mResponse = response;
     mCurrent = null;
 }