Esempio n. 1
0
 protected virtual void CustomizeFieldDescriptor(SimplTypesScope metadataTScope, MetadataFieldDescriptorProxy fieldDescriptorProxy)
 {
     fieldDescriptorProxy.SetTagName(Tag ?? Name);
 }
 protected override void CustomizeFieldDescriptor(SimplTypesScope metadataTScope, MetadataFieldDescriptorProxy fdProxy)
 {
     base.CustomizeFieldDescriptor(metadataTScope, fdProxy);
     fdProxy.SetCollectionOrMapTagName(ChildTag);
     fdProxy.SetWrapped(!NoWrap);
 }
Esempio n. 3
0
        public MetadataFieldDescriptor BindMetadataFieldDescriptor(SimplTypesScope metadataTScope, MetadataClassDescriptor metadataCd)
        {
            MetadataFieldDescriptor metadataFd = MetadataFieldDescriptor;

            if (metadataFd == null)
            {
                metadataFd = MetadataFieldDescriptor;
                String fieldName = this.GetFieldName(false);
                if (metadataFd == null)
                {
                    FieldDescriptor fd = metadataCd.GetFieldDescriptorByFieldName(fieldName);
                    metadataFd = (MetadataFieldDescriptor)fd;
                    if (metadataFd != null)
                    {
                        // FIXME is the following "if" statement still useful? I never see the condition is
                        // true. can we remove it? -- yin 7/26/2011
                        // if we don't have a field, then this is a wrapped collection, so we need to get the
                        // wrapped field descriptor
                        if (metadataFd.Field == null)
                        {
                            FieldDescriptor wfd = metadataFd.WrappedFd;
                            metadataFd = (MetadataFieldDescriptor)wfd;
                        }

                        MetadataFieldDescriptor = metadataFd;

                        if (MetadataFieldDescriptor != null)
                        {
                            // it is possible that the fieldescriptor in the fieldDescriptor proxy has been removed during clone.
                            // if so, make a new fieldDescriptorProxy.
                            if (!_fieldDescriptorProxy.FieldDescriptorExists())
                            {
                                _fieldDescriptorProxy = new MetadataFieldDescriptorProxy(this);
                            }
                            CustomizeFieldDescriptor(metadataTScope, _fieldDescriptorProxy);
                        }
                        if (MetadataFieldDescriptor != metadataFd)
                        {
                            // the field descriptor has been modified in customizeFieldDescriptor()!
                            // we need to update it in the class descriptor so that deserialization of metadata
                            // objects can work correctly, e.g. using the right classDescriptor for a composite
                            // field or a right elementClassDescriptor for a collection field.

                            CustomizeFieldDescriptorInClass(metadataTScope, metadataCd);
                            //String tagName = this.metadataFieldDescriptor.TagName;
                            //int fieldType = this.metadataFieldDescriptor.FdType;
                            //if (fieldType == FieldTypes.CollectionElement || fieldType == FieldTypes.MapElement)
                            //    tagName = this.metadataFieldDescriptor.CollectionOrMapTagName;
                            //metadataClassDescriptor.AllFieldDescriptorsByTagNames.Put(tagName,
                            //                                                          this.metadataFieldDescriptor);
                        }
                    }
                }
                else
                {
                    Debug.WriteLine("Ignoring <" + fieldName +
                                    "> because no corresponding MetadataFieldDescriptor can be found.");
                }
            }
            return(metadataFieldDescriptor);
        }
Esempio n. 4
0
 public MetaMetadataField()
 {
     _fieldDescriptorProxy = new MetadataFieldDescriptorProxy(this);
 }
        protected override void CustomizeFieldDescriptor(SimplTypesScope metadataTScope, MetadataFieldDescriptorProxy fdProxy)
        {
            base.CustomizeFieldDescriptor(metadataTScope, fdProxy);

            MetaMetadata thisMmd = TypeMmd;
            if (thisMmd == null)
                return;

            MetaMetadataNestedField inheritedField = (MetaMetadataNestedField) SuperField;
            if (inheritedField != null)
            {
                MetaMetadata superMmd = inheritedField.TypeMmd;
                if (thisMmd == superMmd || thisMmd.IsDerivedFrom(superMmd))
                {
                    MetadataClassDescriptor elementMetadataCD = thisMmd.GetMetadataClassDescriptor(metadataTScope);
                    if (elementMetadataCD != null)
                        fdProxy.SetElementClassDescriptor(elementMetadataCD);
                    else
                    {
                        Debug.WriteLine("can't bind FieldDescriptor because metadata class does not exist for: " + thisMmd.ToString());
                    }
                }
                else
                {
                    throw new MetaMetadataException("incompatible types: " + inheritedField + " => " + this);
                }
            }
        }
Esempio n. 6
0
 protected override void CustomizeFieldDescriptor(SimplTypesScope metadataTScope, MetadataFieldDescriptorProxy fdProxy)
 {
     base.CustomizeFieldDescriptor(metadataTScope, fdProxy);
     fdProxy.SetCollectionOrMapTagName(ChildTag);
     fdProxy.SetWrapped(!NoWrap);
 }
        protected override void CustomizeFieldDescriptor(SimplTypesScope metadataTScope, MetadataFieldDescriptorProxy fdProxy)
        {
            base.CustomizeFieldDescriptor(metadataTScope, fdProxy);

            MetaMetadata thisMmd = TypeMmd;

            if (thisMmd == null)
            {
                return;
            }

            MetaMetadataNestedField inheritedField = (MetaMetadataNestedField)SuperField;

            if (inheritedField != null)
            {
                MetaMetadata superMmd = inheritedField.TypeMmd;
                if (thisMmd == superMmd || thisMmd.IsDerivedFrom(superMmd))
                {
                    MetadataClassDescriptor elementMetadataCD = thisMmd.GetMetadataClassDescriptor(metadataTScope);
                    if (elementMetadataCD != null)
                    {
                        fdProxy.SetElementClassDescriptor(elementMetadataCD);
                    }
                    else
                    {
                        Debug.WriteLineIf(BigSemanticsSettings.DebugLevel > 5, "can't bind FieldDescriptor because metadata class does not exist for: " + thisMmd.ToString());
                    }
                }
                else
                {
                    throw new MetaMetadataException("incompatible types: " + inheritedField + " => " + this);
                }
            }
        }