127 lines
2.8 KiB
C++
127 lines
2.8 KiB
C++
// Copyright (c) 2013 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "tools/gn/value.h"
|
|
|
|
#include "base/strings/string_number_conversions.h"
|
|
|
|
Value::Value()
|
|
: type_(NONE),
|
|
int_value_(0),
|
|
origin_(NULL) {
|
|
}
|
|
|
|
Value::Value(const ParseNode* origin, Type t)
|
|
: type_(t),
|
|
int_value_(0),
|
|
origin_(origin) {
|
|
}
|
|
|
|
Value::Value(const ParseNode* origin, int64 int_val)
|
|
: type_(INTEGER),
|
|
int_value_(int_val),
|
|
origin_(origin) {
|
|
}
|
|
|
|
Value::Value(const ParseNode* origin, const base::StringPiece& str_val)
|
|
: type_(STRING),
|
|
string_value_(str_val.as_string()),
|
|
int_value_(0),
|
|
origin_(origin) {
|
|
}
|
|
|
|
Value::~Value() {
|
|
}
|
|
|
|
// static
|
|
const char* Value::DescribeType(Type t) {
|
|
switch (t) {
|
|
case NONE:
|
|
return "none";
|
|
case INTEGER:
|
|
return "integer";
|
|
case STRING:
|
|
return "string";
|
|
case LIST:
|
|
return "list";
|
|
default:
|
|
NOTREACHED();
|
|
return "UNKNOWN";
|
|
}
|
|
}
|
|
|
|
int64 Value::InterpretAsInt() const {
|
|
switch (type_) {
|
|
case NONE:
|
|
return 0;
|
|
case INTEGER:
|
|
return int_value_;
|
|
case STRING:
|
|
return string_value_.empty() ? 0 : 1;
|
|
case LIST:
|
|
return list_value_.empty() ? 0 : 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
std::string Value::ToString() const {
|
|
switch (type_) {
|
|
case NONE:
|
|
return "<void>";
|
|
case INTEGER:
|
|
return base::Int64ToString(int_value_);
|
|
case STRING:
|
|
return string_value_;
|
|
case LIST: {
|
|
std::string result = "[";
|
|
for (size_t i = 0; i < list_value_.size(); i++) {
|
|
if (i > 0)
|
|
result += ", ";
|
|
// TODO(brettw) maybe also want to escape quotes in the string.
|
|
if (list_value_[i].type() == STRING)
|
|
result += std::string("\"") + list_value_[i].ToString() + "\"";
|
|
else
|
|
result += list_value_[i].ToString();
|
|
}
|
|
result.push_back(']');
|
|
return result;
|
|
}
|
|
}
|
|
return std::string();
|
|
}
|
|
|
|
bool Value::VerifyTypeIs(Type t, Err* err) const {
|
|
if (type_ == t)
|
|
return true;
|
|
|
|
*err = Err(origin(), std::string("This is not a ") + DescribeType(t) + ".");
|
|
return false;
|
|
}
|
|
|
|
bool Value::operator==(const Value& other) const {
|
|
if (type_ != other.type_)
|
|
return false;
|
|
|
|
switch (type_) {
|
|
case Value::INTEGER:
|
|
return int_value() == other.int_value();
|
|
case Value::STRING:
|
|
return string_value() == other.string_value();
|
|
case Value::LIST:
|
|
if (list_value().size() != other.list_value().size())
|
|
return false;
|
|
for (size_t i = 0; i < list_value().size(); i++) {
|
|
if (list_value()[i] != other.list_value()[i])
|
|
return false;
|
|
}
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool Value::operator!=(const Value& other) const {
|
|
return !operator==(other);
|
|
}
|