Defines the structure of this class.

@param ClassDefinition $class
167160
final protected function defineClass(ClassDefinition $class)
    {
        $class->property($this->object)->asObject($this->getObjectType());
        $class->property($this->dataSource)->asObject(IObjectSet::class);

        $this->defineClassStructure($class);
    }
210253
public function setupBindingDefinition(BindingDefinition $bd) {
		if ($this->mandatory) {
			$bd->val($this->propertyName, new ValNotEmpty());
		}
	}
348754
public function setClass($identifier, $class)
    {
        $identifier = (string) $identifier;

        if(parent::offsetExists($identifier))
        {
            $data = array(
                'identifier' =>  parent::offsetGet($identifier),
                'class'      =>  $class
            );

            apc_store($this->getNamespace().'-object_'.$identifier, $data);
        }

        return  parent::setClass($identifier, $class);
    }
706263
protected static function _initialize($class) {
		$self = parent::_initialize($class);
		if (!$self->_inited) {
			$self->_inited = true;
			$self->_init();
		}
		return $self;
	}
921332
protected function defineEntity(ClassDefinition $class)
    {
        $class->property($this->namespace)->asString();

        $class->property($this->name)->asString();
        
        $class->property($this->orderIndex)->asInt();

        $class->property($this->htmlContentAreas)->asType(HtmlContentArea::collectionType());

        $class->property($this->imageContentAreas)->asType(ImageContentArea::collectionType());

        $class->property($this->textContentAreas)->asType(TextContentArea::collectionType());

        $class->property($this->fileContentAreas)->asType(FileContentArea::collectionType());

        $class->property($this->metadata)->asType(ContentMetadata::collectionType());

        $class->property($this->nestedArrayContentGroups)->asType(ContentGroup::collectionType());

        $class->property($this->updatedAt)->asObject(DateTime::class);
    }
200571
public function define_columns($columns) {
        parent::define_columns($columns);
        foreach ($this->columns as $column => $column) {
            // Automatically assign classes to columns.
            $this->column_class[$column] = ' ' . $column;
        }
    }
205274
public function loadClass($class)
    {
        if (0 === strpos($class, 'Admingenerated')) {
            $filePath = $this->basePath.DIRECTORY_SEPARATOR.str_replace('\\', DIRECTORY_SEPARATOR, $class).'.php';

            if (!file_exists($filePath)) {
                $this->generateEmptyController($class);
            }

            if (file_exists($filePath)) {
                require $filePath;
            }
        }
    }
863249
protected function define(ClassDefinition $class)
    {
        $class->property($this->object)->asObject();

        $class->property($this->data)->nullable()->asObject();
    }
632553
protected function formatDefinition($class, $definition)
    {
        if (empty($definition)) {
            return ['class' => $class];
        } elseif (is_callable($definition, false) || is_object($definition)) {
            return $definition;
        } elseif (is_string($definition)) {
        	if (strpos($definition, ':') !== false) {
        		return $definition;
        	}
        	
            return ['class' => $definition];
        } elseif (is_array($definition)) {
            if (!isset($definition['class'])) {
                if (strpos($class, '\\') !== false) {
                    $definition['class'] = $class;
                } elseif (isset($definition[0]) && is_string($definition[0]) && strpos($definition[0], '\\') !== false) {
                    $definition['class'] = $definition[0];
                    unset($definition[0]);
                } else {
                    throw new InvalidConfigException("A class definition requires a \"class\" member.");
                }
            }
            return $definition;
        } else {
            throw new InvalidConfigException("Unsupported definition type for \"$class\": " . gettype($definition));
        }
    }
324865
public function addClass($class) {
        $this->setVariable(self::VIEW_MODEL_CLASS, $this->addValue($this->getVariable(self::VIEW_MODEL_CLASS), $class));
    }
253778
protected void setTTEClassDefinition(String tteClass, Identification id, Attributes attr) {
	this.tteCD = ClassDefinitionImpl.toClassDefinition(tteClass, id, attr);
    }
378618
public void setTDBTClassDefinition(String tdbtClass, Identification id, Attributes attr) {
	this.tdbtCD = ClassDefinitionImpl.toClassDefinition(tdbtClass, id, attr);
	this.tdbt = null;
    }
391305
protected function addClasses(array $classes, FileDescriptor $fileDescriptor): void
    {
        foreach ($classes as $class) {
            $classDescriptor = $this->getBuilder()->buildDescriptor($class);
            if ($classDescriptor) {
                $classDescriptor->setLocation($fileDescriptor, $class->getLocation()->getLineNumber());
                if (count($classDescriptor->getTags()->get('package', new Collection())) === 0) {
                    $classDescriptor->getTags()->set(
                        'package',
                        $fileDescriptor->getTags()->get('package', new Collection())
                    );
                }

                $fileDescriptor->getClasses()->set(
                    (string) ($classDescriptor->getFullyQualifiedStructuralElementName()),
                    $classDescriptor
                );
            }
        }
    }
1259426
protected function define(MapperDefinition $map)
    {
        $map->type($this->classType());

        $this->defineStringColumnType($map->property(StringValueObject::STRING)->to($this->columnName));
    }
560992
protected function defineEntity(ClassDefinition $class)
    {
        $class->property($this->name)->asString();

        $class->property($this->slug)->asString();

        $class->property($this->role)->asString();

        $class->property($this->bio)->asObject(Html::class);

        $class->property($this->articles)->asType(BlogArticle::collectionType());

        $this->defineMetadata($class);
    }
456829
public function afterCompile(ClassType $class) : void
    {
        $initialize = $class->methods['initialize'];
        $initialize->addBody(\Wakers\Propel\Setup\PropelSetup::class . '::setup($this);');
    }
924185
protected function createDefinition(string $class): Definition
    {
        $path = $this->basePath . DIRECTORY_SEPARATOR . str_replace('\\', '.', $class) . '.yml';

        if (! is_file($path)) {
            throw new DefinitionNotFoundException($class);
        }

        $config = $this->readConfig($path);
        $definition = new Definition($class);

        foreach ($this->processors as $processor)
        {
            $processor->process($config, $definition);
        }

        return $definition;
    }