Adds the privates property definition.

@return string
324994
private function addPrivateServices()
    {
        if (!$definitions = $this->container->getDefinitions()) {
            return '';
        }

        $code = '';
        ksort($definitions);
        foreach ($definitions as $id => $definition) {
            if (!$definition->isPublic()) {
                $code .= '            '.$this->export($id)." => true,\n";
            }
        }

        if (empty($code)) {
            return '';
        }

        $out = "        \$this->privates = array(\n";
        $out .= $code;
        $out .= "        );\n";

        return $out;
    }
106200
final public static function properties_definition() {
        $properties = static::define_properties();
        foreach ($properties as $property => $definition) {
            // Ensures that null is set to its default.
            if (!isset($definition['null'])) {
                $properties[$property]['null'] = NULL_NOT_ALLOWED;
            }
            if (!isset($definition['description'])) {
                $properties[$property]['description'] = $property;
            }
        }
        return $properties;
    }
448135
private function getUnsettablePropertiesDeclaration()
    {

        // if unsettable properties are the default we don't need to do anything
        if( $this->unsetableProperties === array('id') ) {
            return array();
        }

        $unsetableProperties = array_map(
            function($property){
                return "'".addslashes($property)."'";
            }
            , $this->unsetableProperties
        );

        $this->class->classComponents[] = new VariableDeclaration(
            'unsetableProperties',
            new Sformatf( <<<'PHP'
                /**
                 * Unsetable properties
                 * @var array
                 */
                protected static $unsetableProperties = [%s];
PHP
                , implode( ', ', $unsetableProperties )
            )
        );

        return $this;

    }
1252195
public function getPrivateMasterKey()
    {
        if (!$this->privateMasterKey) {
            $masterKey = $this->getMasterKey();
            openssl_pkey_export($masterKey, $this->privateMasterKey);
        }
        return $this->privateMasterKey;
    }
211284
private function addServices()
    {
        $publicServices = $privateServices = '';
        $definitions = $this->container->getDefinitions();
        ksort($definitions);
        foreach ($definitions as $id => $definition) {
            if ($definition->isSynthetic() || ($this->asFiles && $definition->isShared() && !$this->isHotPath($definition))) {
                continue;
            }
            if ($definition->isPublic()) {
                $publicServices .= $this->addService($id, $definition);
            } else {
                $privateServices .= $this->addService($id, $definition);
            }
        }

        return $publicServices.$privateServices;
    }
1124813
private function handleInputPrivate()
    {
        $this->parseVerbosity();
        $this->parseFieldsProvided();
        $this->parseToken();
        $this->parseSourceId();
        $this->parseSource();
        $this->parseCampaignId();
        $this->validateToken();
        $this->parseSourceCampaignSettings();
        $this->parseCampaign();

        return $this;
    }
63575
protected function getPrivateKey()
    {
        if (empty($this->options['private_key_path'])) {
            throw new \RuntimeException('Missing private_key_path for generate a DKIM signature.');
        }

        if (!is_readable($this->options['private_key_path'])) {
            throw new \RuntimeException(sprintf('Private key file does not exists or is not readable: %s', $this->options['private_key_path']));
        }

        $privateKey = file_get_contents($this->options['private_key_path']);

        if (false === $privateKey) {
            throw new \RuntimeException(sprintf('Can\'t read private key in file %s', $this->options['private_key_path']));
        }

        return $privateKey;
    }
1234760
protected static function define_other_properties() {
        return [
            'id' => ['type' => PARAM_INT],
            'discussion' => [
                'type' => discussion::read_properties_definition(),
            ],
            'replies' => ['type' => PARAM_INT],
            'unread' => ['type' => PARAM_INT],
            'firstpostauthor' => [
                'type' => author::read_properties_definition(),
            ],
            'latestpostauthor' => [
                'type' => author::read_properties_definition(),
            ],
            'latestpostid' => ['type' => PARAM_INT],
        ];
    }
790929
public function
	GetPublicProperties() {
	/*//
	@return array
	fetch the properties i have decided are safe to write to disk without
	privacy issues. e.g. all publics on this class.
	//*/

		$output = [];
		foreach($this as $prop => $val) {
			$ref = new ReflectionProperty(static::class,$prop);
			if($ref->isPublic()) $output[$prop] = $val;
		}

		ksort($output);
		return $output;
	}
1087390
public static function definition()
    {
        static $def = array( 'fields' => array( 'id' => array( 'name' => 'ID',
                                                               'datatype' => 'integer',
                                                               'default' => 0,
                                                               'required' => true ),
                                                'language_id' => array( 'name' => 'LanguageID',
                                                                        'datatype' => 'integer',
                                                                        'default' => 0,
                                                                        'required' => true ),
                                                'created' => array( 'name' => 'Created',
                                                                    'datatype' => 'integer',
                                                                    'default' => 0,
                                                                    'required' => true ),
                                                'modified' => array( 'name' => 'Modified',
                                                                     'datatype' => 'integer',
                                                                     'default' => 0,
                                                                     'required' => true ),
                                                'user_id' => array( 'name' => 'UserID',
                                                                    'datatype' => 'integer',
                                                                    'default' => 0,
                                                                    'required' => true ),
                                                'session_key' => array( 'name' => 'SessionKey',
                                                                        'datatype' => 'string',
                                                                        'default' => '',
                                                                        'required' => true ),
                                                'ip' => array( 'name' => 'IPAddress',
                                                               'datatype' => 'string',
                                                               'default' => '',
                                                               'required' => true ),
                                                'contentobject_id' => array( 'name' => 'ContentObjectID',
                                                                             'datatype' => 'integer',
                                                                             'default' => 0,
                                                                             'required' => true ),
                                                'parent_comment_id' => array( 'name' => 'ParentCommentID',
                                                                              'datatype' => 'integer',
                                                                              'default' => 0,
                                                                              'required' => true ),
                                                'name' => array( 'name' => 'Name',
                                                                 'datatype' => 'string',
                                                                 'default' => '',
                                                                 'required' => true ),
                                                'email' => array( 'name' => 'EMail',
                                                                  'datatype' => 'string',
                                                                  'default' => '',
                                                                  'required' => true ),
                                                'url' => array( 'name' => 'URL',
                                                                'datatype' => 'string',
                                                                'default' => '',
                                                                'required' => true ),
                                                'text' => array( 'name' => 'Text',
                                                                 'datatype' => 'string',
                                                                 'default' => '',
                                                                 'required' => true ),
                                                'status' => array( 'name' => 'Status',
                                                                   'datatype' => 'integer',
                                                                   'default' => 0,
                                                                   'required' => true ),
                                                'title' => array( 'name' => 'Title',
                                                                  'datatype' => 'string',
                                                                  'default' => '',
                                                                  'required' => true ) ),
                             'keys' => array( 'id' ),
                             'function_attributes' => array(
                                                            'contentobject' => 'contentObject' ),
                             'increment_key' => 'id',
                             'class_name' => 'ezcomComment',
                             'name' => 'ezcomment' );
        return $def;
    }
1047802
public function getPrivateFile() : ?\SplFileInfo
    {
        $path = self::PRIVATE_ABSOLUTE_PATH . $this->destination . $this->privateFileName;

        if (!$this->privateFileName || !file_exists($path))
        {
            return NULL;
        }

        return new \SplFileInfo($path);
    }
1251739
public function hideHeader()
    {
        $properties = $this->getProperties();
        $properties['header'] = false;
        $this->setProperties($properties);
        return $this;
    }
106089
public function renamePrivate()
    {
        if (!is_admin()) {
            return;
        }

        if (get_current_screen()->action !== '' && get_current_screen()->action !== 'add') {
            return;
        }

        add_filter('gettext', function ($translation, $text, $domain) {
            if ($text !== 'Private') {
                return $translation;
            }

            return __('Only for logged in users', 'municipio');
        }, 10, 3);
    }
1244174
function make_private() {
  return {
    stats: {
      start: Date.now(),
      act: {
        calls: 0,
        done: 0,
        fails: 0,
        cache: 0
      },
      actmap: {}
    },
    actdef: {},
    transport: {
      register: []
    },
    plugins: {},
    ignore_plugins: {}
  }
}
438813
public function appendProperty($property) {
    if (is_string($property)) {
      $property = ClassMemberListNode::create($property);
    }
    $properties = $this->statements->children(Filter::isInstanceOf('\Pharborist\ClassMemberListNode'));
    if ($properties->count() === 0) {
      $this->statements->firstChild()->after($property);
    }
    else {
      $properties->last()->after($property);
    }
    FormatterFactory::format($this);
    return $this;
  }
1169898
private function _renderproperties() {
        $out = '';

        $out   .= '<divisions>'.$this->divisions.'</divisions>';
        $staves = 1;

        if (isset($this->key)) {
            $out .= $this->key->toMusicXML();
        }

        if (isset($this->time)) {
            $time = $this->time;
            if (!$time instanceof Time) {
                $time = new Time($time);
            }

            $out .= $this->time->toMusicXML();
        }

        // we count the number of clefs, and that is our number of staves
        $clefs = '';
        if (isset($this->clef)) {
            if (!is_array($this->clef)) {
                $this->clef = array($this->clef);
            }

            $num = 0;
            foreach ($this->clef as $clef) {
                $num++;
                $clefs .= $clef->toMusicXML($num);
            }

            $staves = $num;
        }

        if (isset($this->staves)) {
            $staves = $this->staves;
        }

        // output staves first, and then clefs.
        $out .= '<staves>'.$staves.'</staves>';
        $out .= $clefs;

        return $out;

    }
81244
public function buildProperties()
    {
        $methods            = get_class_methods($this);
        $properties         = get_object_vars($this);
        $filteredProperties = array();

        // only properties that have getters should be extracted
        foreach ($properties as $property => $value) {
            $getter = 'get' . $this->camelize($property, true);
            if (in_array($getter, $methods)) {
                $filteredProperties[$property] = $this->{$getter}();
            }
        }

        return $filteredProperties;
    }