inline void set_indexdata(const char* value);
  inline void set_indexdata(const void* value, size_t size);
  inline ::std::string* mutable_indexdata();
  
  // required int32 datasize = 3;
  inline bool has_datasize() const;
  inline void clear_datasize();
  static const int kDatasizeFieldNumber = 3;
  inline ::google::protobuf::int32 datasize() const;
  inline void set_datasize(::google::protobuf::int32 value);
  
  // @@protoc_insertion_point(class_scope:OSMPBF.BlobHeader)
 private:
  mutable int _cached_size_;
  
  ::std::string* type_;
  static const ::std::string _default_type_;
  ::std::string* indexdata_;
  static const ::std::string _default_indexdata_;
  ::google::protobuf::int32 datasize_;
  friend void  protobuf_AddDesc_fileformat_2eproto();
  friend void protobuf_AssignDesc_fileformat_2eproto();
  friend void protobuf_ShutdownFile_fileformat_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static BlobHeader* default_instance_;
};
// ===================================================================


// ===================================================================

// Blob

// optional bytes raw = 1;
inline bool Blob::has_raw() const {
  return _has_bit(0);
}
inline void Blob::clear_raw() {
  if (raw_ != &_default_raw_) {
    raw_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& Blob::raw() const {
  return *raw_;
}
inline void Blob::set_raw(const ::std::string& value) {
  _set_bit(0);
  if (raw_ == &_default_raw_) {
    raw_ = new ::std::string;
  }
  raw_->assign(value);
}
inline void Blob::set_raw(const char* value) {
  _set_bit(0);
  if (raw_ == &_default_raw_) {
    raw_ = new ::std::string;
  }
  raw_->assign(value);
}
inline void Blob::set_raw(const void* value, size_t size) {
  _set_bit(0);
  if (raw_ == &_default_raw_) {
    raw_ = new ::std::string;
  }
  raw_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Blob::mutable_raw() {
  _set_bit(0);
  if (raw_ == &_default_raw_) {
    raw_ = new ::std::string;
  }
  return raw_;
}

// optional int32 raw_size = 2;
inline bool Blob::has_raw_size() const {
  return _has_bit(1);
}
inline void Blob::clear_raw_size() {
  raw_size_ = 0;
  _clear_bit(1);
}
inline ::google::protobuf::int32 Blob::raw_size() const {
  return raw_size_;
}
inline void Blob::set_raw_size(::google::protobuf::int32 value) {
  _set_bit(1);
  raw_size_ = value;
}

// optional bytes zlib_data = 3;
inline bool Blob::has_zlib_data() const {
  return _has_bit(2);
}
inline void Blob::clear_zlib_data() {
  if (zlib_data_ != &_default_zlib_data_) {
    zlib_data_->clear();
  }
  _clear_bit(2);
}