G3D::Any::Data Class Reference

Classes
union	Value

Static Public Member Functions
static Data *	create (const Data *d)
static Data *	create (Type t, const char *b=NULL, char s= '\0')
static void	destroy (Data *d)

Public Attributes
Type	type
Value	value
std::string	comment
std::string	name
std::string	includeLine
AtomicInt32	referenceCount
Source	source
const char *	bracket
char	separator

Private Member Functions
	Data (Type t, const char *b, char s)
	~Data ()

Constructor & Destructor Documentation

G3D::Any::Data::Data ( Type  t, const char *  b, char  s  )

inlineprivate

Called by create()

: type(t), referenceCount(1), bracket(b), separator(s) {}

G3D::Any::Data::~Data ( )

private

Called by destroy

 {
 debugAssertM(referenceCount.value() <= 0, "Deleted while still referenced.");

 // Destruct but do not deallocate children
 switch (type) {
 case STRING:
 debugAssert(value.s != NULL);
 value.s->~basic_string();
 break;

 case ARRAY:
 debugAssert(value.a != NULL);
 value.a->~Array();
 break;

 case TABLE:
 debugAssert(value.t != NULL);
 value.t->~Table();
 break;

 default:
 // All other types should have a NULL value pointer (i.e., they were used just for name and comment fields)
 debugAssertM(value.s == NULL, "Corrupt Any::Data::Value");
 }

 value.s = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

Any::Data * G3D::Any::Data::create ( const Data *  d )

static

Clones the argument

 {
 Data* p = create(d->type);

 p->includeLine = d->includeLine;
 p->bracket = d->bracket;
 p->separator = d->separator;
 p->comment = d->comment;
 p->name = d->name;
 p->source = d->source;

 switch (d->type) {
 case NIL:
 case BOOLEAN:
 case NUMBER:
 case EMPTY_CONTAINER:
 // No clone needed
 break;

 case STRING:
 *(p->value.s) = *(d->value.s);
 break;

 case ARRAY:
 *(p->value.a) = *(d->value.a);
 break;

 case TABLE:
 *(p->value.t) = *(d->value.t);
 // Note that placeholders may be copied; that is ok--they are still
 // just placeholders.
 break;
 }

 return p;
}

Here is the caller graph for this function:

Any::Data * G3D::Any::Data::create ( Any::Type  t, const char *  b = NULL, char  s = '\0'  )

static

 {
 size_t s = sizeof(Data);

 switch (t) {
 case NIL:
 case BOOLEAN:
 case NUMBER:
 // No extra space needed
 break;

 case STRING:
 s += sizeof(std::string);
 break;

 case EMPTY_CONTAINER:
 // We need to allocate space for the worst-case
 s += max(sizeof(AnyArray), sizeof(AnyTable));
 // If no separator and brackets were provided, substitute defaults
 if (b == NULL) { b = PAREN; }
 if (sep == '\0') { sep = ','; }
 break;

 case ARRAY:
 s += sizeof(AnyArray);
 // If no separator and brackets were provided, substitute defaults
 if (b == NULL) { b = PAREN; }
 if (sep == '\0') { sep = ','; }
 break;

 case TABLE:
 s += sizeof(AnyTable);
 // If no separator and brackets were provided, substitute defaults
 if (b == NULL) { b = BRACE; }
 if (sep == '\0') { sep = ';'; }
 break;
 }

 // Allocate the data object
 Data* p = new (MemoryManager::create()->alloc(s)) Data(t, b, sep);

 // Create the (empty) value object at the end of the Data object
 switch (t) {
 case NIL:
 case BOOLEAN:
 case NUMBER:
 case EMPTY_CONTAINER:
 // No value
 break;

 case STRING:
 p->value.s = new (p + 1) std::string();
 break;

 case ARRAY:
 p->value.a = new (p + 1) AnyArray();
 break;

 case TABLE:
 p->value.t = new (p + 1) AnyTable();
 break;
 }

 if (isContainerType(p->type)) debugAssert(p->separator != '\0');

 return p;
}

Here is the call graph for this function:

void G3D::Any::Data::destroy ( Data *  d )

static

Free d, invoking its destructor and freeing the memory for the value.

 {
 if (d != NULL) {
 d->~Data();
 MemoryManager::create()->free(d);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

const char* G3D::Any::Data::bracket

Two-character string of "{}", "[]", or "()"; to be used when unparsing.

std::string G3D::Any::Data::comment

std::string G3D::Any::Data::includeLine

If this Any was created by parsing an #include expression and has not been modified since, this is the original comment and include statement, as it originally appeared in the file (e.g., it may contain a relative filename). If this is non-empty, then when serialized, this Any will turn into an #include expression instead of unparsing its contents of the any.

std::string G3D::Any::Data::name

AtomicInt32 G3D::Any::Data::referenceCount

For STRING, ARRAY and TABLE types, m_value is shared between multiple instances. Mutation is allowed only if the reference count is exactly 1, otherwise the mutating instance must copy the value. This is not used for other types.

char G3D::Any::Data::separator

';' or ',' separator to be used when unparsing

Source G3D::Any::Data::source

Type G3D::Any::Data::type

Value G3D::Any::Data::value

Always points to memory that is allocated with the Data, so the destructor does not delete this.

---

The documentation for this class was generated from the following files:

• dep/g3dlite/include/G3D/Any.h
• dep/g3dlite/source/Any.cpp