Clifford Yapp
0c81351efd
Construct SELECT, enumeration, and aggregate values from descriptors so compact output needs no generated type classes or factories. Preserve enumeration elements and renamed schema items in the packed image. Make each public schema header independently includable through the small SchemaModule interface. Keep runtime and model declarations internal. AP242e4 output falls from 865 to 10 files and clean compile/link time falls from 18.71 to 1.21 seconds. The schema DSO falls from 3,503,352 to 2,178,296 bytes, with ELF relocations falling from 9,620 to 49.
363 lines
11 KiB
C++
363 lines
11 KiB
C++
#ifndef SCHEMAINIT_H
|
|
#define SCHEMAINIT_H
|
|
|
|
#include <stddef.h>
|
|
|
|
#include "sc_export.h"
|
|
#include "clstepcore/attrDescriptor.h"
|
|
#include "clstepcore/aggrTypeDescriptor.h"
|
|
#include "clstepcore/dictSchema.h"
|
|
#include "clstepcore/entityDescriptor.h"
|
|
#include "clstepcore/enumTypeDescriptor.h"
|
|
#include "clstepcore/selectTypeDescriptor.h"
|
|
#include "clstepcore/schemaModule.h"
|
|
|
|
class Derived_attribute;
|
|
class Inverse_attribute;
|
|
class ComplexCollect;
|
|
class Registry;
|
|
|
|
/** Compact records used by API v2 generated schema initialization. */
|
|
struct SC_CORE_EXPORT SchemaInitRecord {
|
|
Schema ** slot;
|
|
const char * name;
|
|
ModelContentsCreator modelContentsCreator;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT EntityDescriptorInitRecord {
|
|
EntityDescriptor ** slot;
|
|
const char * name;
|
|
Schema ** schemaSlot;
|
|
Logical abstractEntity;
|
|
Logical externalMapping;
|
|
Creator creator;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT EntitySupertypeInitRecord {
|
|
EntityDescriptor * supertype;
|
|
};
|
|
|
|
enum TypeDescriptorInitKind {
|
|
TypeDescriptorInit_Base,
|
|
TypeDescriptorInit_Enum,
|
|
TypeDescriptorInit_Select,
|
|
TypeDescriptorInit_Aggregate,
|
|
TypeDescriptorInit_Array,
|
|
TypeDescriptorInit_List,
|
|
TypeDescriptorInit_Set,
|
|
TypeDescriptorInit_Bag
|
|
};
|
|
|
|
struct SC_CORE_EXPORT TypeDescriptorInitRecord {
|
|
void * slot;
|
|
TypeDescriptorInitKind kind;
|
|
const char * name;
|
|
PrimitiveType fundamentalType;
|
|
Schema ** schemaSlot;
|
|
const char * description;
|
|
int uniqueElements;
|
|
SelectCreator selectCreator;
|
|
EnumCreator enumCreator;
|
|
AggregateCreator aggregateCreator;
|
|
|
|
TypeDescriptorInitRecord( TypeDescriptor ** descriptorSlot,
|
|
const char * typeName, PrimitiveType type,
|
|
Schema ** schema, const char * typeDescription );
|
|
TypeDescriptorInitRecord( EnumTypeDescriptor ** descriptorSlot,
|
|
const char * typeName, PrimitiveType type,
|
|
Schema ** schema, const char * typeDescription,
|
|
EnumCreator creator );
|
|
TypeDescriptorInitRecord( SelectTypeDescriptor ** descriptorSlot,
|
|
int unique, const char * typeName,
|
|
PrimitiveType type, Schema ** schema,
|
|
const char * typeDescription,
|
|
SelectCreator creator );
|
|
TypeDescriptorInitRecord( AggrTypeDescriptor ** descriptorSlot,
|
|
const char * typeName, PrimitiveType type,
|
|
Schema ** schema, const char * typeDescription,
|
|
AggregateCreator creator );
|
|
TypeDescriptorInitRecord( ArrayTypeDescriptor ** descriptorSlot,
|
|
const char * typeName, PrimitiveType type,
|
|
Schema ** schema, const char * typeDescription,
|
|
AggregateCreator creator );
|
|
TypeDescriptorInitRecord( ListTypeDescriptor ** descriptorSlot,
|
|
const char * typeName, PrimitiveType type,
|
|
Schema ** schema, const char * typeDescription,
|
|
AggregateCreator creator );
|
|
TypeDescriptorInitRecord( SetTypeDescriptor ** descriptorSlot,
|
|
const char * typeName, PrimitiveType type,
|
|
Schema ** schema, const char * typeDescription,
|
|
AggregateCreator creator );
|
|
TypeDescriptorInitRecord( BagTypeDescriptor ** descriptorSlot,
|
|
const char * typeName, PrimitiveType type,
|
|
Schema ** schema, const char * typeDescription,
|
|
AggregateCreator creator );
|
|
};
|
|
|
|
/**
|
|
* Attribute descriptor record. The overloaded constructors preserve the
|
|
* concrete type of generated descriptor slots without templates or casts in
|
|
* generated translation units.
|
|
*/
|
|
struct SC_CORE_EXPORT AttributeInitRecord {
|
|
AttrDescriptor ** attributeSlot;
|
|
Derived_attribute ** derivedSlot;
|
|
Inverse_attribute ** inverseSlot;
|
|
const char * name;
|
|
const TypeDescriptor * domain;
|
|
Logical optional;
|
|
Logical unique;
|
|
AttrType_Enum attrType;
|
|
const char * initializer;
|
|
const char * invertedAttribute;
|
|
const char * invertedEntity;
|
|
|
|
AttributeInitRecord( AttrDescriptor ** slot, const char * attrName,
|
|
const TypeDescriptor * domainType, Logical isOptional,
|
|
Logical isUnique, AttrType_Enum type,
|
|
const char * init = 0 );
|
|
AttributeInitRecord( Derived_attribute ** slot, const char * attrName,
|
|
const TypeDescriptor * domainType, Logical isOptional,
|
|
Logical isUnique, AttrType_Enum type,
|
|
const char * init = 0 );
|
|
AttributeInitRecord( Inverse_attribute ** slot, const char * attrName,
|
|
const TypeDescriptor * domainType, Logical isOptional,
|
|
Logical isUnique, const char * invertedAttr,
|
|
const char * invertedEnt );
|
|
};
|
|
|
|
enum ComplexNodeInitKind {
|
|
ComplexNodeInit_Simple,
|
|
ComplexNodeInit_And,
|
|
ComplexNodeInit_Or,
|
|
ComplexNodeInit_AndOr
|
|
};
|
|
|
|
struct SC_CORE_EXPORT ComplexNodeInitRecord {
|
|
ComplexNodeInitKind kind;
|
|
const char * name;
|
|
size_t firstChild;
|
|
size_t nextSibling;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT ComplexListInitRecord {
|
|
size_t rootNode;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT GlobalRuleInitRecord {
|
|
const char * name;
|
|
const char * text;
|
|
};
|
|
|
|
enum SchemaImageDescriptorRefKind {
|
|
SchemaImageRef_None,
|
|
SchemaImageRef_Entity,
|
|
SchemaImageRef_Type,
|
|
SchemaImageRef_Builtin,
|
|
SchemaImageRef_Aggregate
|
|
};
|
|
|
|
struct SC_CORE_EXPORT SchemaImageDescriptorRef {
|
|
uint32_t kind;
|
|
uint32_t schema;
|
|
uint32_t index;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT SchemaImageSchemaRecord {
|
|
uint32_t name;
|
|
uint32_t firstEntity;
|
|
uint32_t entityCount;
|
|
uint32_t firstType;
|
|
uint32_t typeCount;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT SchemaImageEntityRecord {
|
|
uint32_t schema;
|
|
uint32_t name;
|
|
uint32_t flags;
|
|
uint32_t supertypeStatement;
|
|
uint32_t firstSupertype;
|
|
uint32_t supertypeCount;
|
|
uint32_t firstAttribute;
|
|
uint32_t attributeCount;
|
|
uint32_t firstWhereRule;
|
|
uint32_t whereRuleCount;
|
|
uint32_t firstUniqueRule;
|
|
uint32_t uniqueRuleCount;
|
|
};
|
|
|
|
enum SchemaImageEntityFlags {
|
|
SchemaImageEntity_Abstract = 1u << 0,
|
|
SchemaImageEntity_ExternalMapping = 1u << 1
|
|
};
|
|
|
|
struct SC_CORE_EXPORT SchemaImageTypeRecord {
|
|
uint32_t schema;
|
|
uint32_t name;
|
|
uint32_t description;
|
|
uint32_t fundamentalType;
|
|
uint32_t descriptorKind;
|
|
int32_t uniqueElements;
|
|
SchemaImageDescriptorRef referent;
|
|
uint32_t aggregate;
|
|
uint32_t firstSelectElement;
|
|
uint32_t selectElementCount;
|
|
uint32_t firstWhereRule;
|
|
uint32_t whereRuleCount;
|
|
uint32_t firstEnumElement;
|
|
uint32_t enumElementCount;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT SchemaImageAttributeRecord {
|
|
uint32_t name;
|
|
SchemaImageDescriptorRef domain;
|
|
uint32_t optional;
|
|
uint32_t unique;
|
|
uint32_t attrType;
|
|
uint32_t initializer;
|
|
uint32_t invertedAttribute;
|
|
uint32_t invertedEntity;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT SchemaImageAggregateRecord {
|
|
uint32_t schema;
|
|
uint32_t description;
|
|
uint32_t fundamentalType;
|
|
SchemaImageDescriptorRef referent;
|
|
uint32_t bound1Type;
|
|
int32_t bound1;
|
|
uint32_t bound1Text;
|
|
uint32_t bound2Type;
|
|
int32_t bound2;
|
|
uint32_t bound2Text;
|
|
uint32_t optionalElements;
|
|
uint32_t uniqueElements;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT SchemaImageRuleRecord {
|
|
uint32_t text;
|
|
};
|
|
|
|
enum SchemaImageSchemaTextKind {
|
|
SchemaImageText_GlobalRule,
|
|
SchemaImageText_Function,
|
|
SchemaImageText_Procedure
|
|
};
|
|
|
|
struct SC_CORE_EXPORT SchemaImageSchemaTextRecord {
|
|
uint32_t schema;
|
|
uint32_t kind;
|
|
uint32_t name;
|
|
uint32_t text;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT SchemaImageRenameRecord {
|
|
SchemaImageDescriptorRef descriptor;
|
|
uint32_t schema;
|
|
uint32_t name;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT SchemaImageSchemaBinding {
|
|
Schema ** schemaSlot;
|
|
ModelContentsCreator modelContentsCreator;
|
|
SchemaModule * module;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT SchemaImageTypeBinding {
|
|
void * slot;
|
|
SelectCreator selectCreator;
|
|
EnumCreator enumCreator;
|
|
AggregateCreator aggregateCreator;
|
|
};
|
|
|
|
enum SchemaLoadError {
|
|
SchemaLoad_Ok,
|
|
SchemaLoad_UnsupportedVersion,
|
|
SchemaLoad_TruncatedImage,
|
|
SchemaLoad_InvalidOffset,
|
|
SchemaLoad_InvalidString,
|
|
SchemaLoad_InvalidReference,
|
|
SchemaLoad_CountMismatch,
|
|
SchemaLoad_MissingBinding,
|
|
SchemaLoad_ModuleFailure
|
|
};
|
|
|
|
struct SC_CORE_EXPORT SchemaLoadResult {
|
|
SchemaLoadError error;
|
|
uint32_t record;
|
|
|
|
bool Succeeded() const {
|
|
return error == SchemaLoad_Ok;
|
|
}
|
|
const char * Message() const;
|
|
};
|
|
|
|
SC_CORE_EXPORT SchemaLoadResult InitializeSchemaFromImage(
|
|
Registry & registry, const SchemaModuleImage & image,
|
|
const SchemaImageSchemaBinding * schemaBindings,
|
|
size_t schemaBindingCount,
|
|
const SchemaImageTypeBinding * typeBindings,
|
|
size_t typeBindingCount, SchemaLoadContext & context );
|
|
|
|
enum PackedComplexImageVersion {
|
|
PackedComplexImageVersion_1 = 1
|
|
};
|
|
|
|
struct SC_CORE_EXPORT PackedComplexImage {
|
|
uint32_t version;
|
|
uint32_t byteSize;
|
|
uint32_t stringOffset;
|
|
uint32_t stringBytes;
|
|
uint32_t nodeOffset;
|
|
uint32_t nodeCount;
|
|
uint32_t listOffset;
|
|
uint32_t listCount;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT PackedComplexNode {
|
|
uint32_t kind;
|
|
uint32_t name;
|
|
uint32_t firstChild;
|
|
uint32_t nextSibling;
|
|
};
|
|
|
|
struct SC_CORE_EXPORT PackedComplexList {
|
|
uint32_t rootNode;
|
|
};
|
|
|
|
SC_CORE_EXPORT ComplexCollect * InitializePackedComplexSupport(
|
|
const PackedComplexImage & image, SchemaLoadResult * result = 0 );
|
|
|
|
SC_CORE_EXPORT void InitializeSchemas( Registry & reg,
|
|
const SchemaInitRecord * records,
|
|
size_t count );
|
|
SC_CORE_EXPORT void InitializeSchemaModuleImages(
|
|
const SchemaInitRecord * records, size_t count );
|
|
SC_CORE_EXPORT void InitializeEntityDescriptors(
|
|
const EntityDescriptorInitRecord * records, size_t count );
|
|
SC_CORE_EXPORT void InitializeTypeDescriptors(
|
|
const TypeDescriptorInitRecord * records, size_t count );
|
|
SC_CORE_EXPORT void InitializeTypeMetadata(
|
|
Registry & reg, Schema & schema, TypeDescriptor & type,
|
|
const TypeDescriptor * referent,
|
|
const TypeDescriptor * const * selectElements, size_t selectElementCount );
|
|
SC_CORE_EXPORT void InitializeEntityMetadata(
|
|
Registry & reg, EntityDescriptor & entity, Schema & schema,
|
|
const EntitySupertypeInitRecord * supertypes, size_t supertypeCount,
|
|
const AttributeInitRecord * attributes, size_t attributeCount );
|
|
SC_CORE_EXPORT void InitializeWhereRules(
|
|
TypeDescriptor & owner, const char * const * rules, size_t count );
|
|
SC_CORE_EXPORT void InitializeUniquenessRules(
|
|
EntityDescriptor & owner, const char * const * rules, size_t count );
|
|
SC_CORE_EXPORT void InitializeGlobalRules(
|
|
Schema & schema, const GlobalRuleInitRecord * rules, size_t count );
|
|
SC_CORE_EXPORT void InitializeFunctions(
|
|
Schema & schema, const char * const * functions, size_t count );
|
|
SC_CORE_EXPORT void InitializeProcedures(
|
|
Schema & schema, const char * const * procedures, size_t count );
|
|
SC_CORE_EXPORT ComplexCollect * InitializeComplexSupport(
|
|
const ComplexNodeInitRecord * nodes, size_t nodeCount,
|
|
const ComplexListInitRecord * lists, size_t listCount );
|
|
|
|
#endif
|