Migrate from std::string to tensorflow::tstring.

Googler · copybara-github · commit e75021255487 · 2019-11-18T15:11:49.000-08:00
Note that during the transition period tstring is typedef'ed to std::string. See: tensorflow/community#91 PiperOrigin-RevId: 281163678 Change-Id: I20ac40a58b48113c76103011c5061283d434558b
diff --git a/tensorflow_compression/cc/kernels/range_coder.cc b/tensorflow_compression/cc/kernels/range_coder.cc
@@ -30,13 +30,13 @@ limitations under the License.
 
 namespace tensorflow_compression {
 using tensorflow::int32;
-using tensorflow::string;
+using tensorflow::tstring;
 using tensorflow::uint32;
 using tensorflow::uint64;
 using tensorflow::uint8;
 
 void RangeEncoder::Encode(int32 lower, int32 upper, int precision,
-                          string* sink) {
+                          tstring* sink) {
   // Input requirement: 0 < precision < 16.
   DCHECK_GT(precision, 0);
   DCHECK_LE(precision, 16);
@@ -265,7 +265,7 @@ void RangeEncoder::Encode(int32 lower, int32 upper, int precision,
   }
 }
 
-void RangeEncoder::Finalize(string* sink) {
+void RangeEncoder::Finalize(tstring* sink) {
   // Finalize the encode by writing out any number in the interval
   // [base, base + size).
   //
@@ -300,7 +300,7 @@ void RangeEncoder::Finalize(string* sink) {
   delay_ = 0;
 }
 
-RangeDecoder::RangeDecoder(const string& source)
+RangeDecoder::RangeDecoder(const tstring& source)
     : current_(source.begin()), end_(source.end()) {
   Read16BitValue();
   Read16BitValue();
diff --git a/tensorflow_compression/cc/kernels/range_coder.h b/tensorflow_compression/cc/kernels/range_coder.h
@@ -45,12 +45,12 @@ class RangeEncoder {
   // REQUIRES: 0 <= lower < upper <= 2^precision.
   // REQUIRES: 0 < precision <= 16.
   void Encode(tensorflow::int32 lower, tensorflow::int32 upper, int precision,
-              tensorflow::string* sink);
+              tensorflow::tstring* sink);
 
   // The encode may contain some under-determined values from previous encoding.
   // After Encode() calls, Finalize() must be called. Otherwise the encoded
   // string may not be decoded.
-  void Finalize(tensorflow::string* sink);
+  void Finalize(tensorflow::tstring* sink);
 
  private:
   tensorflow::uint32 base_ = 0;
@@ -63,7 +63,7 @@ class RangeDecoder {
  public:
   // Holds a reference to `source`. The caller has to make sure that `source`
   // outlives the decoder object.
-  explicit RangeDecoder(const tensorflow::string& source);
+  explicit RangeDecoder(const tensorflow::tstring& source);
 
   // Decodes a character from `source` using CDF. The size of `cdf` should be
   // one more than the number of the character in the alphabet.
@@ -96,8 +96,8 @@ class RangeDecoder {
       std::numeric_limits<tensorflow::uint32>::max();
   tensorflow::uint32 value_ = 0;
 
-  tensorflow::string::const_iterator current_;
-  const tensorflow::string::const_iterator end_;
+  tensorflow::tstring::const_iterator current_;
+  const tensorflow::tstring::const_iterator end_;
 };
 
 }  // namespace tensorflow_compression
diff --git a/tensorflow_compression/cc/kernels/range_coder_test.cc b/tensorflow_compression/cc/kernels/range_coder_test.cc
@@ -68,7 +68,7 @@ void RangeEncodeDecodeTest(int precision, random::SimplePhilox* gen) {
   }
 
   RangeEncoder encoder;
-  string encoded;
+  tensorflow::tstring encoded;
   double ideal_length = 0.0;
   for (uint8 x : data) {
     encoder.Encode(cdf[x], cdf[x + 1], precision, &encoded);
@@ -109,7 +109,7 @@ TEST(RangeCoderTest, Precision12To16) {
 TEST(RangeCoderTest, FinalizeState0) {
   constexpr int kPrecision = 2;
 
-  string output;
+  tensorflow::tstring output;
   RangeEncoder encoder;
   encoder.Encode(0, 2, kPrecision, &output);
   encoder.Finalize(&output);
diff --git a/tensorflow_compression/cc/kernels/range_coding_kernels.cc b/tensorflow_compression/cc/kernels/range_coding_kernels.cc
@@ -49,6 +49,7 @@ using tensorflow::string;
 using tensorflow::Tensor;
 using tensorflow::TensorShape;
 using tensorflow::TensorShapeUtils;
+using tensorflow::tstring;
 using tensorflow::TTypes;
 using tensorflow::uint32;
 using tensorflow::uint64;
@@ -204,7 +205,7 @@ class RangeEncodeOp : public OpKernel {
     Tensor* output_tensor;
     OP_REQUIRES_OK(context,
                    context->allocate_output(0, TensorShape{}, &output_tensor));
-    string* output = &output_tensor->scalar<string>()();
+    tstring* output = &output_tensor->scalar<tstring>()();
 
     switch (data_shape.size()) {
 #define RANGE_ENCODE_CASE(dims)                                           \
@@ -235,7 +236,7 @@ class RangeEncodeOp : public OpKernel {
                                      absl::Span<const int64> data_shape,
                                      TTypes<int32>::ConstMatrix cdf,
                                      absl::Span<const int64> cdf_shape,
-                                     string* output) const {
+                                     tstring* output) const {
     const int64 data_size = data.size();
     const int64 cdf_size = cdf.size();
     const int64 chip_size = cdf.dimension(1);
@@ -313,7 +314,7 @@ class RangeDecodeOp : public OpKernel {
     OP_REQUIRES_OK(
         context, MergeAxes(output_shape, cdf.shape(), &data_shape, &cdf_shape));
 
-    const string& encoded = encoded_tensor.scalar<string>()();
+    const tstring& encoded = encoded_tensor.scalar<tstring>()();
 
     Tensor* output;
     OP_REQUIRES_OK(context, context->allocate_output(0, output_shape, &output));
@@ -347,7 +348,7 @@ class RangeDecodeOp : public OpKernel {
                                      absl::Span<const int64> output_shape,
                                      TTypes<int32>::ConstMatrix cdf,
                                      absl::Span<const int64> cdf_shape,
-                                     const string& encoded) const {
+                                     const tstring& encoded) const {
     BroadcastRange<int16, int32, N> view{output.data(), output_shape,
                                          cdf.data(), cdf_shape};
 
diff --git a/tensorflow_compression/cc/kernels/range_coding_kernels_test.cc b/tensorflow_compression/cc/kernels/range_coding_kernels_test.cc
@@ -58,6 +58,7 @@ using tensorflow::Status;
 using tensorflow::Tensor;
 using tensorflow::TensorShape;
 using tensorflow::TensorShapeUtils;
+using tensorflow::tstring;
 using tensorflow::TTypes;
 
 int LogUniform(random::SimplePhilox* gen, uint32 n) {
@@ -470,12 +471,12 @@ TEST_F(RangeCoderOpsTest, EncoderDebug) {
 TEST_F(RangeCoderOpsTest, DecoderDebug) {
   RangeEncoder encoder;
 
-  string encoded_string;
+  tstring encoded_string;
   encoder.Encode(16, 18, 5, &encoded_string);
   encoder.Finalize(&encoded_string);
 
   Tensor encoded(DT_STRING, {});
-  encoded.scalar<string>()().swap(encoded_string);
+  encoded.scalar<tstring>()() = std::move(encoded_string);
 
   Tensor shape(DT_INT32, {0});
 
diff --git a/tensorflow_compression/cc/kernels/unbounded_index_range_coding_kernels.cc b/tensorflow_compression/cc/kernels/unbounded_index_range_coding_kernels.cc
@@ -49,6 +49,7 @@ using tensorflow::string;
 using tensorflow::Tensor;
 using tensorflow::TensorShape;
 using tensorflow::TensorShapeUtils;
+using tensorflow::tstring;
 using tensorflow::TTypes;
 using tensorflow::uint32;
 using tensorflow::uint64;
@@ -181,15 +182,15 @@ class UnboundedIndexRangeEncodeOp : public OpKernel {
 
     RangeEncodeImpl(data.flat<int32>(), index.flat<int32>(),
                     cdf.matrix<int32>(), cdf_size.vec<int32>(),
-                    offset.vec<int32>(), &output->flat<string>()(0));
+                    offset.vec<int32>(), &output->flat<tstring>()(0));
   }
 
  private:
   void RangeEncodeImpl(TTypes<int32>::ConstFlat data,
                        TTypes<int32>::ConstFlat index,
                        TTypes<int32>::ConstMatrix cdf,
                        TTypes<int32>::ConstVec cdf_size,
-                       TTypes<int32>::ConstVec offset, string* output) const {
+                       TTypes<int32>::ConstVec offset, tstring* output) const {
     RangeEncoder encoder;
 
     DCHECK_GE(cdf.dimension(1), 2);
@@ -300,7 +301,7 @@ class UnboundedIndexRangeDecodeOp : public OpKernel {
     OP_REQUIRES_OK(
         context, RangeDecodeImpl(output->flat<int32>(), index.flat<int32>(),
                                  cdf.matrix<int32>(), cdf_size.vec<int32>(),
-                                 offset.vec<int32>(), encoded.flat<string>()));
+                                 offset.vec<int32>(), encoded.flat<tstring>()));
   }
 
  private:
@@ -309,7 +310,7 @@ class UnboundedIndexRangeDecodeOp : public OpKernel {
                                      TTypes<int32>::ConstMatrix cdf,
                                      TTypes<int32>::ConstVec cdf_size,
                                      TTypes<int32>::ConstVec offset,
-                                     TTypes<string>::ConstFlat encoded) const {
+                                     TTypes<tstring>::ConstFlat encoded) const {
     RangeDecoder decoder(encoded(0));
 
     DCHECK_GE(cdf.dimension(1), 2);
