void Any::verifySize(int s) const {
beforeRead();
verifyType(ARRAY, TABLE);
if (size() != s) {
verify(false, format("Size must be %d", s));
}
}
Any& Any::operator[](int i) {
beforeRead();
verifyType(ARRAY);
debugAssert(m_data != NULL);
Array<Any>& array = *(m_data->value.a);
return array[i];
}
void Any::verifySize(int low, int high) const {
beforeRead();
verifyType(ARRAY, TABLE);
if (size() < low || size() > high) {
verify(false, format("Size must be between %d and %d", low, high));
}
}
std::string Any::unparse() const {
beforeRead();
TextOutput::Settings settings;
TextOutput to(settings);
serialize(to);
return to.commitString();
}
void Any::append(const Any& x0, const Any& x1, const Any& x2, const Any& x3) {
beforeRead();
append(x0);
append(x1);
append(x2);
append(x3);
}
Any& Any::next() {
beforeRead();
verifyType(ARRAY);
int n = size();
resize(n + 1);
return (*this)[n];
}
void Any::deserialize(TextInput& ti) {
beforeRead();
Token token = ti.read();
deserialize(ti, token);
// Restore the last token
ti.push(token);
}
void Any::load(const std::string& filename) {
beforeRead();
TextInput::Settings settings;
getDeserializeSettings(settings);
TextInput ti(filename, settings);
deserialize(ti);
}
void Any::parse(const std::string& src) {
beforeRead();
TextInput::Settings settings;
getDeserializeSettings(settings);
TextInput ti(TextInput::FROM_STRING, src, settings);
deserialize(ti);
}
void Any::set(const std::string& k, const Any& v) {
beforeRead();
v.beforeRead();
verifyType(TABLE);
debugAssert(m_data != NULL);
Table<std::string, Any>& table = *(m_data->value.t);
table.set(k, v);
}
const std::string& Any::name() const {
beforeRead();
static const std::string blank;
if (m_data != NULL) {
return m_data->name;
} else {
return blank;
}
}
const Any& Any::get(const std::string& x, const Any& defaultVal) const {
beforeRead();
defaultVal.beforeRead();
try {
return operator[](x);
} catch(KeyNotFound) {
return defaultVal;
}
}
bool Any::containsKey(const std::string& x) const {
beforeRead();
verifyType(TABLE);
Any* a = m_data->value.t->getPointer(x);
// Don't return true for placeholder objects
return (a != NULL) && (!a->isPlaceholder());
}
void Any::save(const std::string& filename) const {
beforeRead();
TextOutput::Settings settings;
settings.wordWrap = TextOutput::Settings::WRAP_NONE;
TextOutput to(filename, settings);
serialize(to);
to.commit();
}
const std::string& Any::comment() const {
beforeRead();
static const std::string blank;
if (m_data != NULL) {
return m_data->comment;
} else {
return blank;
}
}
int Any::size() const {
beforeRead();
verifyType(ARRAY, TABLE);
switch (m_type) {
case TABLE:
return m_data->value.t->size();
case ARRAY:
return m_data->value.a->size();
default:;
return 0;
} // switch (m_type)
}
void Any::clear() {
beforeRead();
verifyType(ARRAY, TABLE);
switch (m_type) {
case ARRAY:
m_data->value.a->clear();
break;
case TABLE:
m_data->value.t->clear();
break;
default:;
}
}
const Any& Any::operator[](const std::string& x) const {
beforeRead();
verifyType(TABLE);
debugAssert(m_data != NULL);
const Table<std::string, Any>& table = *(m_data->value.t);
Any* value = table.getPointer(x);
if (value == NULL) {
KeyNotFound e;
if (m_data) {
e.filename = m_data->source.filename;
e.line = m_data->source.line;
e.character = m_data->source.character;
}
e.key = x;
throw e;
}
return *value;
}
Any& Any::operator[](const std::string& key) {
beforeRead();
verifyType(TABLE);
bool created = false;
Any& value = m_data->value.t->getCreate(key, created);
if (created) {
// The entry was created by this method; do not allow it to be
// read before it is written.
value.m_placeholderName = key;
// Write source data for the value
value.ensureData();
value.m_data->source = source();
}
return value;
}
void Any::verify(bool value, const std::string& message) const {
beforeRead();
if (! value) {
ParseError p;
if (m_data) {
p.filename = m_data->source.filename;
p.line = m_data->source.line;
p.character = m_data->source.character;
}
if (name().empty()) {
p.message = "Parse error";
} else {
p.message = "Parse error while reading the contents of " + name();
}
if (! message.empty()) {
p.message = p.message + ": " + message;
}
throw p;
}
}
void Any::append(const Any& x0) {
beforeRead();
verifyType(ARRAY);
debugAssert(m_data != NULL);
m_data->value.a->append(x0);
}
void Any::setName(const std::string& n) {
beforeRead();
ensureData();
m_data->name = n;
}
// TODO: if the output will fit on one line, compress tables and arrays into a single line
void Any::serialize(TextOutput& to) const {
beforeRead();
if (m_data && !m_data->comment.empty()) {
to.printf("\n/* %s */\n", m_data->comment.c_str());
}
switch (m_type) {
case NONE:
to.writeSymbol("NONE");
break;
case BOOLEAN:
to.writeBoolean(m_simpleValue.b);
break;
case NUMBER:
to.writeNumber(m_simpleValue.n);
break;
case STRING:
debugAssert(m_data != NULL);
to.writeString(*(m_data->value.s));
break;
case TABLE: {
debugAssert(m_data != NULL);
if (!m_data->name.empty()) {
if (needsQuotes(m_data->name)) {
to.writeString(m_data->name);
}
else {
to.writeSymbol(m_data->name);
}
}
to.writeSymbol("{");
to.writeNewline();
to.pushIndent();
AnyTable& table = *(m_data->value.t);
Array<std::string> keys;
table.getKeys(keys);
keys.sort();
for (int i = 0; i < keys.size(); ++i) {
to.writeSymbol(keys[i]);
to.writeSymbol("=");
table[keys[i]].serialize(to);
if (i < keys.size() - 1) {
to.writeSymbol(",");
}
to.writeNewline();
// Skip a line between table entries
to.writeNewline();
}
to.popIndent();
to.writeSymbol("}");
break;
}
case ARRAY: {
debugAssert(m_data != NULL);
if (!m_data->name.empty()) {
// For arrays, leave no trailing space between the name and the paren
to.writeSymbol(format("%s(", m_data->name.c_str()));
}
else {
to.writeSymbol("(");
}
to.writeNewline();
to.pushIndent();
Array<Any>& array = *(m_data->value.a);
for (int ii = 0; ii < size(); ++ii) {
array[ii].serialize(to);
if (ii < size() - 1) {
to.writeSymbol(",");
to.writeNewline();
}
// Put the close paren on an array right behind the last element
}
to.popIndent();
to.writeSymbol(")");
break;
}
}
}
void Any::resize(int n) {
beforeRead();
alwaysAssertM(n >= 0, "Cannot resize less than 0.");
verifyType(ARRAY);
m_data->value.a->resize(n);
}
int Any::length() const {
beforeRead();
return size();
}
const Array<Any>& Any::array() const {
beforeRead();
verifyType(ARRAY);
debugAssert(m_data != NULL);
return *(m_data->value.a);
}
bool Any::operator!=(const Any& x) const {
beforeRead();
x.beforeRead();
return !operator==(x);
}
bool Any::operator==(const Any& x) const {
beforeRead();
x.beforeRead();
if (m_type != x.m_type) {
return false;
}
switch (m_type) {
case NONE:
return true;
case BOOLEAN:
return (m_simpleValue.b == x.m_simpleValue.b);
case NUMBER:
return (m_simpleValue.n == x.m_simpleValue.n);
case STRING:
debugAssert(m_data != NULL);
return (*(m_data->value.s) == *(x.m_data->value.s));
case TABLE: {
if (size() != x.size()) {
return false;
}
debugAssert(m_data != NULL);
if (m_data->name != x.m_data->name) {
return false;
}
Table<std::string, Any>& cmptable = *(m_data->value.t);
Table<std::string, Any>& xcmptable = *(x.m_data->value.t);
for (Table<std::string, Any>::Iterator it1 = cmptable.begin(), it2 = xcmptable.begin();
it1 != cmptable.end() && it2 != xcmptable.end();
++it1, ++it2) {
if (*it1 != *it2) {
return false;
}
}
return true;
}
case ARRAY: {
if (size() != x.size()) {
return false;
}
debugAssert(m_data != NULL);
if (m_data->name != x.m_data->name) {
return false;
}
Array<Any>& cmparray = *(m_data->value.a);
Array<Any>& xcmparray = *(x.m_data->value.a);
for (int ii = 0; ii < size(); ++ii) {
if (cmparray[ii] != xcmparray[ii]) {
return false;
}
}
return true;
}
default:
alwaysAssertM(false, "Unknown type.");
return false;
} // switch (m_type)
}
void Any::append(const Any& x0, const Any& x1) {
beforeRead();
append(x0);
append(x1);
}
const Table<std::string, Any>& Any::table() const {
beforeRead();
verifyType(TABLE);
debugAssert(m_data != NULL);
return *(m_data->value.t);
}
