hotspot/src/share/vm/runtime/reflectionUtils.hpp
changeset 10546 e79347eebbc5
parent 8921 14bfe81f2a9d
child 13728 882756847a04
equal deleted inserted replaced
10545:fec876499aae 10546:e79347eebbc5
   105 //    }
   105 //    }
   106 
   106 
   107 
   107 
   108 class FieldStream : public KlassStream {
   108 class FieldStream : public KlassStream {
   109  private:
   109  private:
   110   int length() const                { return fields()->length(); }
   110   int length() const                { return _klass->java_fields_count(); }
   111   constantPoolOop constants() const { return _klass->constants(); }
   111 
   112  protected:
       
   113   typeArrayOop fields() const       { return _klass->fields(); }
       
   114  public:
   112  public:
   115   FieldStream(instanceKlassHandle klass, bool local_only, bool classes_only)
   113   FieldStream(instanceKlassHandle klass, bool local_only, bool classes_only)
   116     : KlassStream(klass, local_only, classes_only) {
   114     : KlassStream(klass, local_only, classes_only) {
   117     _index = length();
   115     _index = length();
   118     next();
   116     next();
   119   }
   117   }
   120 
   118 
   121   void next() { _index -= instanceKlass::next_offset; }
   119   void next() { _index -= 1; }
   122 
   120 
   123   // Accessors for current field
   121   // Accessors for current field
   124   AccessFlags access_flags() const {
   122   AccessFlags access_flags() const {
   125     AccessFlags flags;
   123     AccessFlags flags;
   126     flags.set_flags(fields()->ushort_at(index() + instanceKlass::access_flags_offset));
   124     flags.set_flags(_klass->field_access_flags(_index));
   127     return flags;
   125     return flags;
   128   }
   126   }
   129   Symbol* name() const {
   127   Symbol* name() const {
   130     int name_index = fields()->ushort_at(index() + instanceKlass::name_index_offset);
   128     return _klass->field_name(_index);
   131     return constants()->symbol_at(name_index);
       
   132   }
   129   }
   133   Symbol* signature() const {
   130   Symbol* signature() const {
   134     int signature_index = fields()->ushort_at(index() +
   131     return _klass->field_signature(_index);
   135                                        instanceKlass::signature_index_offset);
       
   136     return constants()->symbol_at(signature_index);
       
   137   }
   132   }
   138   // missing: initval()
   133   // missing: initval()
   139   int offset() const {
   134   int offset() const {
   140     return _klass->offset_from_fields( index() );
   135     return _klass->field_offset( index() );
   141   }
   136   }
   142 };
   137 };
   143 
   138 
   144 class FilteredField {
   139 class FilteredField {
   145  private:
   140  private:
   211     : FieldStream(klass, local_only, classes_only) {
   206     : FieldStream(klass, local_only, classes_only) {
   212     _filtered_fields_count = FilteredFieldsMap::filtered_fields_count((klassOop)klass(), local_only);
   207     _filtered_fields_count = FilteredFieldsMap::filtered_fields_count((klassOop)klass(), local_only);
   213   }
   208   }
   214   int field_count();
   209   int field_count();
   215   void next() {
   210   void next() {
   216     _index -= instanceKlass::next_offset;
   211     _index -= 1;
   217     if (has_filtered_field()) {
   212     if (has_filtered_field()) {
   218       while (_index >=0 && FilteredFieldsMap::is_filtered_field((klassOop)_klass(), offset())) {
   213       while (_index >=0 && FilteredFieldsMap::is_filtered_field((klassOop)_klass(), offset())) {
   219         _index -= instanceKlass::next_offset;
   214         _index -= 1;
   220       }
   215       }
   221     }
   216     }
   222   }
   217   }
   223 };
   218 };
   224 
   219