< prev index next >

src/share/vm/oops/fieldStreams.hpp

Print this page




  90       _limit = limit;
  91     }
  92   }
  93 
  94   FieldStreamBase(Array<u2>* fields, const constantPoolHandle& constants) {
  95     _fields = fields;
  96     _constants = constants;
  97     _index = 0;
  98     _limit = init_generic_signature_start_slot();
  99   }
 100 
 101  public:
 102   FieldStreamBase(InstanceKlass* klass) {
 103     _fields = klass->fields();
 104     _constants = klass->constants();
 105     _index = 0;
 106     _limit = klass->java_fields_count();
 107     init_generic_signature_start_slot();
 108     assert(klass == field_holder(), "");
 109   }
 110   FieldStreamBase(instanceKlassHandle klass) {
 111     _fields = klass->fields();
 112     _constants = klass->constants();
 113     _index = 0;
 114     _limit = klass->java_fields_count();
 115     init_generic_signature_start_slot();
 116     assert(klass == field_holder(), "");
 117   }
 118 
 119   // accessors
 120   int index() const                 { return _index; }
 121 
 122   void next() {
 123     if (access_flags().field_has_generic_signature()) {
 124       _generic_signature_slot ++;
 125       assert(_generic_signature_slot <= _fields->length(), "");
 126     }
 127     _index += 1;
 128   }
 129   bool done() const { return _index >= _limit; }
 130 
 131   // Accessors for current field
 132   AccessFlags access_flags() const {
 133     AccessFlags flags;
 134     flags.set_flags(field()->access_flags());
 135     return flags;
 136   }
 137 


 179 
 180   bool is_contended() const {
 181     return field()->is_contended();
 182   }
 183 
 184   int contended_group() const {
 185     return field()->contended_group();
 186   }
 187 
 188   // bridge to a heavier API:
 189   fieldDescriptor& field_descriptor() const {
 190     fieldDescriptor& field = const_cast<fieldDescriptor&>(_fd_buf);
 191     field.reinitialize(field_holder(), _index);
 192     return field;
 193   }
 194 };
 195 
 196 // Iterate over only the internal fields
 197 class JavaFieldStream : public FieldStreamBase {
 198  public:
 199   JavaFieldStream(instanceKlassHandle k): FieldStreamBase(k->fields(), k->constants(), 0, k->java_fields_count()) {}
 200 
 201   int name_index() const {
 202     assert(!field()->is_internal(), "regular only");
 203     return field()->name_index();
 204   }
 205   void set_name_index(int index) {
 206     assert(!field()->is_internal(), "regular only");
 207     field()->set_name_index(index);
 208   }
 209   int signature_index() const {
 210     assert(!field()->is_internal(), "regular only");
 211     return field()->signature_index();
 212   }
 213   void set_signature_index(int index) {
 214     assert(!field()->is_internal(), "regular only");
 215     field()->set_signature_index(index);
 216   }
 217   int generic_signature_index() const {
 218     assert(!field()->is_internal(), "regular only");
 219     if (access_flags().field_has_generic_signature()) {


 228     if (access_flags().field_has_generic_signature()) {
 229       assert(_generic_signature_slot < _fields->length(), "out of bounds");
 230       _fields->at_put(_generic_signature_slot, index);
 231     }
 232   }
 233   int initval_index() const {
 234     assert(!field()->is_internal(), "regular only");
 235     return field()->initval_index();
 236   }
 237   void set_initval_index(int index) {
 238     assert(!field()->is_internal(), "regular only");
 239     return field()->set_initval_index(index);
 240   }
 241 };
 242 
 243 
 244 // Iterate over only the internal fields
 245 class InternalFieldStream : public FieldStreamBase {
 246  public:
 247   InternalFieldStream(InstanceKlass* k):      FieldStreamBase(k->fields(), k->constants(), k->java_fields_count(), 0) {}
 248   InternalFieldStream(instanceKlassHandle k): FieldStreamBase(k->fields(), k->constants(), k->java_fields_count(), 0) {}
 249 };
 250 
 251 
 252 class AllFieldStream : public FieldStreamBase {
 253  public:
 254   AllFieldStream(Array<u2>* fields, const constantPoolHandle& constants): FieldStreamBase(fields, constants) {}
 255   AllFieldStream(InstanceKlass* k):      FieldStreamBase(k->fields(), k->constants()) {}
 256   AllFieldStream(instanceKlassHandle k): FieldStreamBase(k->fields(), k->constants()) {}
 257 };
 258 
 259 #endif // SHARE_VM_OOPS_FIELDSTREAMS_HPP


  90       _limit = limit;
  91     }
  92   }
  93 
  94   FieldStreamBase(Array<u2>* fields, const constantPoolHandle& constants) {
  95     _fields = fields;
  96     _constants = constants;
  97     _index = 0;
  98     _limit = init_generic_signature_start_slot();
  99   }
 100 
 101  public:
 102   FieldStreamBase(InstanceKlass* klass) {
 103     _fields = klass->fields();
 104     _constants = klass->constants();
 105     _index = 0;
 106     _limit = klass->java_fields_count();
 107     init_generic_signature_start_slot();
 108     assert(klass == field_holder(), "");
 109   }








 110 
 111   // accessors
 112   int index() const                 { return _index; }
 113 
 114   void next() {
 115     if (access_flags().field_has_generic_signature()) {
 116       _generic_signature_slot ++;
 117       assert(_generic_signature_slot <= _fields->length(), "");
 118     }
 119     _index += 1;
 120   }
 121   bool done() const { return _index >= _limit; }
 122 
 123   // Accessors for current field
 124   AccessFlags access_flags() const {
 125     AccessFlags flags;
 126     flags.set_flags(field()->access_flags());
 127     return flags;
 128   }
 129 


 171 
 172   bool is_contended() const {
 173     return field()->is_contended();
 174   }
 175 
 176   int contended_group() const {
 177     return field()->contended_group();
 178   }
 179 
 180   // bridge to a heavier API:
 181   fieldDescriptor& field_descriptor() const {
 182     fieldDescriptor& field = const_cast<fieldDescriptor&>(_fd_buf);
 183     field.reinitialize(field_holder(), _index);
 184     return field;
 185   }
 186 };
 187 
 188 // Iterate over only the internal fields
 189 class JavaFieldStream : public FieldStreamBase {
 190  public:
 191   JavaFieldStream(const InstanceKlass* k): FieldStreamBase(k->fields(), k->constants(), 0, k->java_fields_count()) {}
 192 
 193   int name_index() const {
 194     assert(!field()->is_internal(), "regular only");
 195     return field()->name_index();
 196   }
 197   void set_name_index(int index) {
 198     assert(!field()->is_internal(), "regular only");
 199     field()->set_name_index(index);
 200   }
 201   int signature_index() const {
 202     assert(!field()->is_internal(), "regular only");
 203     return field()->signature_index();
 204   }
 205   void set_signature_index(int index) {
 206     assert(!field()->is_internal(), "regular only");
 207     field()->set_signature_index(index);
 208   }
 209   int generic_signature_index() const {
 210     assert(!field()->is_internal(), "regular only");
 211     if (access_flags().field_has_generic_signature()) {


 220     if (access_flags().field_has_generic_signature()) {
 221       assert(_generic_signature_slot < _fields->length(), "out of bounds");
 222       _fields->at_put(_generic_signature_slot, index);
 223     }
 224   }
 225   int initval_index() const {
 226     assert(!field()->is_internal(), "regular only");
 227     return field()->initval_index();
 228   }
 229   void set_initval_index(int index) {
 230     assert(!field()->is_internal(), "regular only");
 231     return field()->set_initval_index(index);
 232   }
 233 };
 234 
 235 
 236 // Iterate over only the internal fields
 237 class InternalFieldStream : public FieldStreamBase {
 238  public:
 239   InternalFieldStream(InstanceKlass* k):      FieldStreamBase(k->fields(), k->constants(), k->java_fields_count(), 0) {}

 240 };
 241 
 242 
 243 class AllFieldStream : public FieldStreamBase {
 244  public:
 245   AllFieldStream(Array<u2>* fields, const constantPoolHandle& constants): FieldStreamBase(fields, constants) {}
 246   AllFieldStream(InstanceKlass* k):      FieldStreamBase(k->fields(), k->constants()) {}

 247 };
 248 
 249 #endif // SHARE_VM_OOPS_FIELDSTREAMS_HPP
< prev index next >