experiments/STT-tensorflow
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Removed redundant std::string -> string conversions.

Browse Source 
PiperOrigin-RevId: 211487989
This commit is contained in:
A. Unique TensorFlower 2018-09-04 11:07:59 -07:00 committed by TensorFlower Gardener
parent bc7c47ccdd
commit 0e9af928f7
19 changed files with 51 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tensorflow/core/common_runtime/bfc_allocator.cc
View File

@ -596,7 +596,7 @@ string BFCAllocator::RenderOccupancy() {
region_offset += region.memory_size(); region_offset += region.memory_size();
} }
return std::string(rendered, resolution); return string(rendered, resolution);
} }
void BFCAllocator::DumpMemoryLog(size_t num_bytes) { void BFCAllocator::DumpMemoryLog(size_t num_bytes) {

4
tensorflow/core/common_runtime/graph_runner.cc
View File

@ -56,7 +56,7 @@ class SimpleRendezvous : public Rendezvous {
} }
mutex_lock l(mu_); mutex_lock l(mu_);
string edge_name = std::string(parsed.edge_name); string edge_name(parsed.edge_name);
if (table_.count(edge_name) > 0) { if (table_.count(edge_name) > 0) {
return errors::Internal("Send of an already sent tensor"); return errors::Internal("Send of an already sent tensor");
} }
@ -69,7 +69,7 @@ class SimpleRendezvous : public Rendezvous {
Tensor tensor; Tensor tensor;
Status status = Status::OK(); Status status = Status::OK();
{ {
string key = std::string(parsed.edge_name); string key(parsed.edge_name);
mutex_lock l(mu_); mutex_lock l(mu_);
if (table_.count(key) <= 0) { if (table_.count(key) <= 0) {
status = errors::Internal("Did not find key ", key); status = errors::Internal("Did not find key ", key);

2
tensorflow/core/common_runtime/session_state.cc
View File

@ -70,7 +70,7 @@ Status TensorStore::SaveTensors(const std::vector<string>& output_names,
// Save only the tensors in output_names in the session. // Save only the tensors in output_names in the session.
for (const string& name : output_names) { for (const string& name : output_names) {
TensorId id(ParseTensorName(name)); TensorId id(ParseTensorName(name));
const string& op_name = std::string(id.first); const string op_name(id.first);
auto it = tensors_.find(op_name); auto it = tensors_.find(op_name);
if (it != tensors_.end()) { if (it != tensors_.end()) {
// Save the tensor to the session state. // Save the tensor to the session state.

6
tensorflow/core/common_runtime/step_stats_collector.cc
View File

@ -176,7 +176,7 @@ static int ExtractGpuWithStreamAll(string device_name) {
} else { } else {
// Convert the captured string into an integer. But first we need to put // Convert the captured string into an integer. But first we need to put
// the digits back in order // the digits back in order
string ordered_capture = std::string(capture); string ordered_capture(capture);
std::reverse(ordered_capture.begin(), ordered_capture.end()); std::reverse(ordered_capture.begin(), ordered_capture.end());
int gpu_id; int gpu_id;
CHECK(strings::safe_strto32(ordered_capture, &gpu_id)); CHECK(strings::safe_strto32(ordered_capture, &gpu_id));
@ -205,7 +205,7 @@ static int ExtractGpuWithoutStream(string device_name) {
} else { } else {
// Convert the captured string into an integer. But first we need to put // Convert the captured string into an integer. But first we need to put
// the digits back in order // the digits back in order
string ordered_capture = std::string(capture); string ordered_capture(capture);
std::reverse(ordered_capture.begin(), ordered_capture.end()); std::reverse(ordered_capture.begin(), ordered_capture.end());
int gpu_id; int gpu_id;
CHECK(strings::safe_strto32(ordered_capture, &gpu_id)); CHECK(strings::safe_strto32(ordered_capture, &gpu_id));
@ -252,7 +252,7 @@ void StepStatsCollector::BuildCostModel(
for (auto& itr : per_device_stats) { for (auto& itr : per_device_stats) {
const StringPiece device_name = itr.first; const StringPiece device_name = itr.first;
const int gpu_id = ExtractGpuWithoutStream(std::string(device_name)); const int gpu_id = ExtractGpuWithoutStream(string(device_name));
if (gpu_id >= 0) { if (gpu_id >= 0) {
// Reference the gpu hardware stats in addition to the regular stats // Reference the gpu hardware stats in addition to the regular stats
// for this gpu device if they're available. // for this gpu device if they're available.

3
tensorflow/core/kernels/gpu_utils.h
View File

@ -123,8 +123,7 @@ class AutoTuneMap {
string GetActionSummary(StringPiece action, const Parameters& params, string GetActionSummary(StringPiece action, const Parameters& params,
const Config& config) { const Config& config) {
return strings::Printf("autotune_map %s %s: %s -> (%s)", name_.c_str(), return strings::Printf("autotune_map %s %s: %s -> (%s)", name_.c_str(),
std::string(action).c_str(), string(action).c_str(), params.ToString().c_str(),
params.ToString().c_str(),
config.ToString().c_str()); config.ToString().c_str());
} }

4
tensorflow/core/kernels/merge_v2_checkpoints_op_test.cc
View File

@ -114,9 +114,7 @@ class MergeV2CheckpointsOpTest : public OpsTestBase {
// Exercises "delete_old_dirs". // Exercises "delete_old_dirs".
for (int i = 0; i < 2; ++i) { for (int i = 0; i < 2; ++i) {
int directory_found = int directory_found =
Env::Default() Env::Default()->IsDirectory(string(io::Dirname(prefixes[i]))).code();
->IsDirectory(std::string(io::Dirname(prefixes[i])))
.code();
if (delete_old_dirs) { if (delete_old_dirs) {
EXPECT_EQ(error::NOT_FOUND, directory_found); EXPECT_EQ(error::NOT_FOUND, directory_found);
} else { } else {

26
tensorflow/core/kernels/remote_fused_graph_execute_utils.cc
View File

@ -47,7 +47,7 @@ std::unordered_set<string> BuildNodeSetFromNodeNamesAndPorts(
std::unordered_set<string> retval; std::unordered_set<string> retval;
for (const string& node_name_and_port : node_names_and_ports) { for (const string& node_name_and_port : node_names_and_ports) {
const TensorId tid = ParseTensorName(node_name_and_port); const TensorId tid = ParseTensorName(node_name_and_port);
retval.emplace(std::string(tid.first)); retval.emplace(tid.first);
} }
return retval; return retval;
} }
@ -64,7 +64,7 @@ Node* FindMutableNodeByName(const string& name, Graph* graph) {
const NodeDef* FindNodeDefByName(const string& input, const NodeDef* FindNodeDefByName(const string& input,
const GraphDef& graph_def) { const GraphDef& graph_def) {
const TensorId tid = ParseTensorName(input); const TensorId tid = ParseTensorName(input);
const string name = std::string(tid.first); const string name = string(tid.first);
for (const NodeDef& node_def : graph_def.node()) { for (const NodeDef& node_def : graph_def.node()) {
if (node_def.name() == name) { if (node_def.name() == name) {
return &node_def; return &node_def;
@ -423,7 +423,7 @@ RemoteFusedGraphExecuteUtils::AddOutputTensorShapeTypeByTensorShapeMap(
std::vector<DataType> data_types; std::vector<DataType> data_types;
std::vector<TensorShape> shapes; std::vector<TensorShape> shapes;
const TensorId tid = ParseTensorName(name_and_port); const TensorId tid = ParseTensorName(name_and_port);
const string node_name = std::string(tid.first); const string node_name(tid.first);
const int port = tid.second; const int port = tid.second;
const NodeDef* node_def = FindNodeDefByName(node_name, graph_def); const NodeDef* node_def = FindNodeDefByName(node_name, graph_def);
CHECK_NOTNULL(node_def); CHECK_NOTNULL(node_def);
@ -522,8 +522,7 @@ RemoteFusedGraphExecuteUtils::GetTensorShapeType(
const TensorShapeMap& tensor_shape_map, const string& node_name) { const TensorShapeMap& tensor_shape_map, const string& node_name) {
if (node_name.find(':') != string::npos) { if (node_name.find(':') != string::npos) {
const TensorId tid = ParseTensorName(node_name); const TensorId tid = ParseTensorName(node_name);
return GetTensorShapeType(tensor_shape_map, std::string(tid.first), return GetTensorShapeType(tensor_shape_map, string(tid.first), tid.second);
tid.second);
} else { } else {
return GetTensorShapeType(tensor_shape_map, node_name, 0); return GetTensorShapeType(tensor_shape_map, node_name, 0);
} }
@ -570,7 +569,7 @@ RemoteFusedGraphExecuteUtils::BuildRemoteGraphInputsAndOutputsFromProto(
const TensorId tid = ParseTensorName(name); const TensorId tid = ParseTensorName(name);
CHECK_EQ(tensor_shape_map->count(name), 0); CHECK_EQ(tensor_shape_map->count(name), 0);
tensor_shape_map->emplace( tensor_shape_map->emplace(
std::string(tid.first), string(tid.first),
std::make_pair(tid.second, std::make_pair(tid.second,
std::make_pair(tensor.dtype(), tensor.shape()))); std::make_pair(tensor.dtype(), tensor.shape())));
} }
@ -692,7 +691,7 @@ RemoteFusedGraphExecuteUtils::BuildRemoteFusedGraphExecuteOpNode(
std::vector<NodeBuilder::NodeOut> node_out_list; std::vector<NodeBuilder::NodeOut> node_out_list;
for (const string& input : inputs) { for (const string& input : inputs) {
const TensorId tid = ParseTensorName(input); const TensorId tid = ParseTensorName(input);
Node* node = FindMutableNodeByName(std::string(tid.first), graph); Node* node = FindMutableNodeByName(string(tid.first), graph);
CHECK_NOTNULL(node); CHECK_NOTNULL(node);
node_out_list.emplace_back(node, tid.second); node_out_list.emplace_back(node, tid.second);
} }
@ -848,7 +847,7 @@ RemoteFusedGraphExecuteUtils::BuildRemoteFusedGraphExecuteOpNode(
for (const string& subgraph_input : std::get<1>(cluster)) { for (const string& subgraph_input : std::get<1>(cluster)) {
const TensorId tid = ParseTensorName(subgraph_input); const TensorId tid = ParseTensorName(subgraph_input);
const string subgraph_input_name = std::string(tid.first); const string subgraph_input_name(tid.first);
const int subgraph_input_port = tid.second; const int subgraph_input_port = tid.second;
const NodeDef* node_def = FindNodeDefByName(subgraph_input_name, graph_def); const NodeDef* node_def = FindNodeDefByName(subgraph_input_name, graph_def);
CHECK_NOTNULL(node_def); CHECK_NOTNULL(node_def);
@ -895,7 +894,7 @@ RemoteFusedGraphExecuteUtils::BuildRemoteFusedGraphExecuteOpNode(
std::deque<const Node*> queue; std::deque<const Node*> queue;
for (const string& output : border_outputs) { for (const string& output : border_outputs) {
const TensorId tid = ParseTensorName(output); const TensorId tid = ParseTensorName(output);
const string& output_node_name = std::string(tid.first); const string output_node_name(tid.first);
for (const Node* node : graph.nodes()) { for (const Node* node : graph.nodes()) {
if (output_node_name == node->name()) { if (output_node_name == node->name()) {
queue.push_back(node); queue.push_back(node);
@ -975,7 +974,7 @@ RemoteFusedGraphExecuteUtils::BuildRemoteFusedGraphExecuteOpNode(
for (int j = 0; j < border_outputs.size(); ++j) { for (int j = 0; j < border_outputs.size(); ++j) {
const string& output = border_outputs.at(j); const string& output = border_outputs.at(j);
const TensorId tid = ParseTensorName(output); const TensorId tid = ParseTensorName(output);
const string output_name = std::string(tid.first); const string output_name(tid.first);
Node* src_node = edge->src(); Node* src_node = edge->src();
if (src_node != nullptr && src_node->name() == output_name && if (src_node != nullptr && src_node->name() == output_name &&
edge->src_output() == tid.second) { edge->src_output() == tid.second) {
@ -995,12 +994,11 @@ RemoteFusedGraphExecuteUtils::BuildRemoteFusedGraphExecuteOpNode(
// RemoteFusedGraphExecuteOpNode // RemoteFusedGraphExecuteOpNode
for (const string& output : outputs) { for (const string& output : outputs) {
const TensorId output_tid = ParseTensorName(output); const TensorId output_tid = ParseTensorName(output);
const string output_name = std::string(output_tid.first); const string output_name(output_tid.first);
for (size_t i = 0; i < border_outputs.size(); ++i) { for (size_t i = 0; i < border_outputs.size(); ++i) {
const TensorId subgraph_output_tid = const TensorId subgraph_output_tid =
ParseTensorName(border_outputs.at(i)); ParseTensorName(border_outputs.at(i));
const string& subgraph_output_name = const string subgraph_output_name(subgraph_output_tid.first);
std::string(subgraph_output_tid.first);
if (output_name == subgraph_output_name) { if (output_name == subgraph_output_name) {
LOG(INFO) << "As graph output and subgraph output are same, " LOG(INFO) << "As graph output and subgraph output are same, "
<< "the graph output node is replaced by identity node"; << "the graph output node is replaced by identity node";
@ -1435,7 +1433,7 @@ RemoteFusedGraphExecuteUtils::BuildNodeMapFromOpsDefinitions(
GraphDef* graph_def) { GraphDef* graph_def) {
const TensorId tid = ParseTensorName(input); const TensorId tid = ParseTensorName(input);
CHECK_EQ(0, tid.second); CHECK_EQ(0, tid.second);
const string node_name = std::string(tid.first); const string node_name(tid.first);
for (NodeDef& node : *graph_def->mutable_node()) { for (NodeDef& node : *graph_def->mutable_node()) {
if (node.name() != node_name) { if (node.name() != node_name) {
continue; continue;

4
tensorflow/core/kernels/save_restore_v2_ops.cc
View File

@ -220,9 +220,9 @@ class MergeV2Checkpoints : public OpKernel {
context, tensorflow::MergeBundles(env, input_prefixes, merged_prefix)); context, tensorflow::MergeBundles(env, input_prefixes, merged_prefix));
if (delete_old_dirs_) { if (delete_old_dirs_) {
const string& merged_dir = std::string(io::Dirname(merged_prefix)); const string merged_dir(io::Dirname(merged_prefix));
for (const string& input_prefix : input_prefixes) { for (const string& input_prefix : input_prefixes) {
const string& dirname = std::string(io::Dirname(input_prefix)); const string dirname(io::Dirname(input_prefix));
if (dirname == merged_dir) continue; if (dirname == merged_dir) continue;
Status status = env->DeleteDir(dirname); Status status = env->DeleteDir(dirname);
// For sharded save, only the first delete will go through and all // For sharded save, only the first delete will go through and all

2
tensorflow/core/kernels/string_strip_op.cc
View File

@ -43,7 +43,7 @@ class StringStripOp : public OpKernel {
for (int64 i = 0; i < input.size(); ++i) { for (int64 i = 0; i < input.size(); ++i) {
StringPiece entry(input(i)); StringPiece entry(input(i));
str_util::RemoveWhitespaceContext(&entry); str_util::RemoveWhitespaceContext(&entry);
output(i) = std::string(entry); output(i) = string(entry);
} }
} }
}; };

2
tensorflow/core/kernels/tensor_array_ops.cc
View File

@ -297,7 +297,7 @@ class TensorArrayGradOp : public TensorArrayCreationOp {
resource.name()); resource.name());
} }
tensor_array_name = tensor_array_name =
std::string(StringPiece(resource.name()).substr(container.size())); string(StringPiece(resource.name()).substr(container.size()));
} }
auto output_handle = tensor_array_output_handle->flat<string>(); auto output_handle = tensor_array_output_handle->flat<string>();

2
tensorflow/core/kernels/whole_file_read_ops.cc
View File

@ -134,7 +134,7 @@ class WriteFileOp : public OpKernel {
"Contents tensor must be scalar, but had shape: ", "Contents tensor must be scalar, but had shape: ",
contents_input->shape().DebugString())); contents_input->shape().DebugString()));
const string& filename = filename_input->scalar<string>()(); const string& filename = filename_input->scalar<string>()();
const string dir = std::string(io::Dirname(filename)); const string dir(io::Dirname(filename));
if (!context->env()->FileExists(dir).ok()) { if (!context->env()->FileExists(dir).ok()) {
OP_REQUIRES_OK(context, context->env()->RecursivelyCreateDir(dir)); OP_REQUIRES_OK(context, context->env()->RecursivelyCreateDir(dir));
} }

4
tensorflow/core/platform/cloud/curl_http_request.cc
View File

@ -394,9 +394,9 @@ size_t CurlHttpRequest::HeaderCallback(const void* ptr, size_t size,
.StopCapture() .StopCapture()
.OneLiteral(": ") .OneLiteral(": ")
.GetResult(&value, &name)) { .GetResult(&value, &name)) {
string str_value = std::string(value); string str_value(value);
str_util::StripTrailingWhitespace(&str_value); str_util::StripTrailingWhitespace(&str_value);
that->response_headers_[std::string(name)] = str_value; that->response_headers_[string(name)] = str_value;
} }
return size * nmemb; return size * nmemb;
} }

14
tensorflow/core/platform/cloud/gcs_file_system.cc
View File

@ -179,13 +179,13 @@ Status ParseGcsPath(StringPiece fname, bool empty_object_ok, string* bucket,
return errors::InvalidArgument("GCS path doesn't start with 'gs://': ", return errors::InvalidArgument("GCS path doesn't start with 'gs://': ",
fname); fname);
} }
*bucket = std::string(bucketp); *bucket = string(bucketp);
if (bucket->empty() || *bucket == ".") { if (bucket->empty() || *bucket == ".") {
return errors::InvalidArgument("GCS path doesn't contain a bucket name: ", return errors::InvalidArgument("GCS path doesn't contain a bucket name: ",
fname); fname);
} }
str_util::ConsumePrefix(&objectp, "/"); str_util::ConsumePrefix(&objectp, "/");
*object = std::string(objectp); *object = string(objectp);
if (!empty_object_ok && object->empty()) { if (!empty_object_ok && object->empty()) {
return errors::InvalidArgument("GCS path doesn't contain an object name: ", return errors::InvalidArgument("GCS path doesn't contain an object name: ",
fname); fname);
@ -224,7 +224,7 @@ std::set<string> AddAllSubpaths(const std::vector<string>& paths) {
for (const string& path : paths) { for (const string& path : paths) {
StringPiece subpath = io::Dirname(path); StringPiece subpath = io::Dirname(path);
while (!subpath.empty()) { while (!subpath.empty()) {
result.emplace(std::string(subpath)); result.emplace(string(subpath));
subpath = io::Dirname(subpath); subpath = io::Dirname(subpath);
} }
} }
@ -723,7 +723,7 @@ GcsFileSystem::GcsFileSystem() {
if (!header_name.empty() && !header_value.empty()) { if (!header_name.empty() && !header_value.empty()) {
additional_header_.reset(new std::pair<const string, const string>( additional_header_.reset(new std::pair<const string, const string>(
std::string(header_name), std::string(header_value))); string(header_name), string(header_value)));
VLOG(1) << "GCS additional header ENABLED. " VLOG(1) << "GCS additional header ENABLED. "
<< "Name: " << additional_header_->first << ", " << "Name: " << additional_header_->first << ", "
@ -1229,7 +1229,7 @@ Status GcsFileSystem::GetMatchingPaths(const string& pattern,
// Find the fixed prefix by looking for the first wildcard. // Find the fixed prefix by looking for the first wildcard.
const string& fixed_prefix = const string& fixed_prefix =
pattern.substr(0, pattern.find_first_of("*?[\\")); pattern.substr(0, pattern.find_first_of("*?[\\"));
const string& dir = std::string(io::Dirname(fixed_prefix)); const string dir(io::Dirname(fixed_prefix));
if (dir.empty()) { if (dir.empty()) {
return errors::InvalidArgument( return errors::InvalidArgument(
"A GCS pattern doesn't have a bucket name: ", pattern); "A GCS pattern doesn't have a bucket name: ", pattern);
@ -1326,7 +1326,7 @@ Status GcsFileSystem::GetChildrenBounded(const string& dirname,
" doesn't match the prefix ", object_prefix)); " doesn't match the prefix ", object_prefix));
} }
if (!relative_path.empty() || include_self_directory_marker) { if (!relative_path.empty() || include_self_directory_marker) {
result->emplace_back(std::string(relative_path)); result->emplace_back(relative_path);
} }
if (++retrieved_results >= max_results) { if (++retrieved_results >= max_results) {
return Status::OK(); return Status::OK();
@ -1354,7 +1354,7 @@ Status GcsFileSystem::GetChildrenBounded(const string& dirname,
"Unexpected response: the returned folder name ", prefix_str, "Unexpected response: the returned folder name ", prefix_str,
" doesn't match the prefix ", object_prefix); " doesn't match the prefix ", object_prefix);
} }
result->emplace_back(std::string(relative_path)); result->emplace_back(relative_path);
if (++retrieved_results >= max_results) { if (++retrieved_results >= max_results) {
return Status::OK(); return Status::OK();
} }

4
tensorflow/core/platform/cloud/oauth_client.cc
View File

@ -216,7 +216,7 @@ Status OAuthClient::GetTokenFromServiceAccountJson(
// Send the request to the Google OAuth 2.0 server to get the token. // Send the request to the Google OAuth 2.0 server to get the token.
std::unique_ptr<HttpRequest> request(http_request_factory_->Create()); std::unique_ptr<HttpRequest> request(http_request_factory_->Create());
std::vector<char> response_buffer; std::vector<char> response_buffer;
request->SetUri(std::string(oauth_server_uri)); request->SetUri(string(oauth_server_uri));
request->SetPostFromBuffer(request_body.c_str(), request_body.size()); request->SetPostFromBuffer(request_body.c_str(), request_body.size());
request->SetResultBuffer(&response_buffer); request->SetResultBuffer(&response_buffer);
TF_RETURN_IF_ERROR(request->Send()); TF_RETURN_IF_ERROR(request->Send());
@ -248,7 +248,7 @@ Status OAuthClient::GetTokenFromRefreshTokenJson(
std::unique_ptr<HttpRequest> request(http_request_factory_->Create()); std::unique_ptr<HttpRequest> request(http_request_factory_->Create());
std::vector<char> response_buffer; std::vector<char> response_buffer;
request->SetUri(std::string(oauth_server_uri)); request->SetUri(string(oauth_server_uri));
request->SetPostFromBuffer(request_body.c_str(), request_body.size()); request->SetPostFromBuffer(request_body.c_str(), request_body.size());
request->SetResultBuffer(&response_buffer); request->SetResultBuffer(&response_buffer);
TF_RETURN_IF_ERROR(request->Send()); TF_RETURN_IF_ERROR(request->Send());

6
tensorflow/core/platform/cloud/oauth_client_test.cc
View File

@ -126,9 +126,9 @@ TEST(OAuthClientTest, GetTokenFromServiceAccountJson) {
EXPECT_EQ("urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer", EXPECT_EQ("urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer",
grant_type); grant_type);
int last_dot = std::string(assertion).find_last_of("."); int last_dot = assertion.rfind('.');
string header_dot_claim = std::string(assertion.substr(0, last_dot)); string header_dot_claim(assertion.substr(0, last_dot));
string signature_encoded = std::string(assertion.substr(last_dot + 1)); string signature_encoded(assertion.substr(last_dot + 1));
// Check that 'signature' signs 'header_dot_claim'. // Check that 'signature' signs 'header_dot_claim'.

2
tensorflow/tools/graph_transforms/freeze_requantization_ranges.cc
View File

@ -92,7 +92,7 @@ Status ExtractMinMaxRecords(const string& log_file_name,
if (!str_util::EndsWith(name_string, print_suffix)) { if (!str_util::EndsWith(name_string, print_suffix)) {
continue; continue;
} }
string name = std::string( string name(
name_string.substr(0, name_string.size() - print_suffix.size())); name_string.substr(0, name_string.size() - print_suffix.size()));
records->push_back({name, min, max}); records->push_back({name, min, max});
} }

4
tensorflow/tools/graph_transforms/sparsify_gather_test.cc
View File

@ -42,8 +42,8 @@ class SparsifyGatherTest : public ::testing::Test {
const std::vector<NodeDef*>& inputs, GraphDef* graph_def, const std::vector<NodeDef*>& inputs, GraphDef* graph_def,
bool control_dep = false) { bool control_dep = false) {
NodeDef* node_def = graph_def->add_node(); NodeDef* node_def = graph_def->add_node();
node_def->set_name(std::string(name)); node_def->set_name(string(name));
node_def->set_op(std::string(op)); node_def->set_op(string(op));
if (!control_dep) { if (!control_dep) {
std::for_each(inputs.begin(), inputs.end(), [&node_def](NodeDef* input) { std::for_each(inputs.begin(), inputs.end(), [&node_def](NodeDef* input) {
node_def->add_input(input->name()); node_def->add_input(input->name());

15
tensorflow/tools/graph_transforms/transform_graph.cc
View File

@ -65,19 +65,19 @@ Status ParseTransformParameters(const string& transforms_string,
.GetResult(&remaining, &transform_name); .GetResult(&remaining, &transform_name);
if (!found_transform_name) { if (!found_transform_name) {
return errors::InvalidArgument("Looking for transform name, but found ", return errors::InvalidArgument("Looking for transform name, but found ",
std::string(remaining).c_str()); string(remaining).c_str());
} }
if (Scanner(remaining).OneLiteral("(").GetResult(&remaining, &match)) { if (Scanner(remaining).OneLiteral("(").GetResult(&remaining, &match)) {
state = TRANSFORM_PARAM_NAME; state = TRANSFORM_PARAM_NAME;
} else { } else {
// Add a transform with no parameters. // Add a transform with no parameters.
params_list->push_back({std::string(transform_name), func_parameters}); params_list->push_back({string(transform_name), func_parameters});
transform_name = ""; transform_name = "";
state = TRANSFORM_NAME; state = TRANSFORM_NAME;
} }
} else if (state == TRANSFORM_PARAM_NAME) { } else if (state == TRANSFORM_PARAM_NAME) {
if (Scanner(remaining).OneLiteral(")").GetResult(&remaining, &match)) { if (Scanner(remaining).OneLiteral(")").GetResult(&remaining, &match)) {
params_list->push_back({std::string(transform_name), func_parameters}); params_list->push_back({string(transform_name), func_parameters});
transform_name = ""; transform_name = "";
state = TRANSFORM_NAME; state = TRANSFORM_NAME;
} else { } else {
@ -92,13 +92,13 @@ Status ParseTransformParameters(const string& transforms_string,
if (!found_parameter_name) { if (!found_parameter_name) {
return errors::InvalidArgument( return errors::InvalidArgument(
"Looking for parameter name, but found ", "Looking for parameter name, but found ",
std::string(remaining).c_str()); string(remaining).c_str());
} }
if (Scanner(remaining).OneLiteral("=").GetResult(&remaining, &match)) { if (Scanner(remaining).OneLiteral("=").GetResult(&remaining, &match)) {
state = TRANSFORM_PARAM_VALUE; state = TRANSFORM_PARAM_VALUE;
} else { } else {
return errors::InvalidArgument("Looking for =, but found ", return errors::InvalidArgument("Looking for =, but found ",
std::string(remaining).c_str()); string(remaining).c_str());
} }
} }
} else if (state == TRANSFORM_PARAM_VALUE) { } else if (state == TRANSFORM_PARAM_VALUE) {
@ -120,10 +120,9 @@ Status ParseTransformParameters(const string& transforms_string,
} }
if (!found_parameter_value) { if (!found_parameter_value) {
return errors::InvalidArgument("Looking for parameter name, but found ", return errors::InvalidArgument("Looking for parameter name, but found ",
std::string(remaining).c_str()); string(remaining).c_str());
} }
func_parameters[std::string(parameter_name)].push_back( func_parameters[string(parameter_name)].emplace_back(parameter_value);
std::string(parameter_value));
// Eat up any trailing quotes. // Eat up any trailing quotes.
Scanner(remaining).ZeroOrOneLiteral("\"").GetResult(&remaining, &match); Scanner(remaining).ZeroOrOneLiteral("\"").GetResult(&remaining, &match);
Scanner(remaining).ZeroOrOneLiteral("'").GetResult(&remaining, &match); Scanner(remaining).ZeroOrOneLiteral("'").GetResult(&remaining, &match);

2
tensorflow/tools/graph_transforms/transform_utils.cc
View File

@ -93,7 +93,7 @@ void NodeNamePartsFromInput(const string& input_name, string* prefix,
} else { } else {
*prefix = ""; *prefix = "";
} }
*node_name = std::string(node_name_piece); *node_name = string(node_name_piece);
} }
string NodeNameFromInput(const string& input_name) { string NodeNameFromInput(const string& input_name) {