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); }