Registers the built-in message types.
693
def register_builtin_message_types():
    """"""
    from .plain import PlainTextMessage
    from .email import EmailTextMessage, EmailHtmlMessage
    register_message_types(PlainTextMessage, EmailTextMessage, EmailHtmlMessage)
1160903
public function register( $post_types = [] ) {
		foreach ( $post_types as $post_type => $callback ) {
			$this->post_types[ $post_type ] = [
				'callback' => $callback,
			];
		}
	}
1052379
def _register_parser(cls):
    ''''''
    assert cls.cls_msg_type is not None
    assert cls.cls_msg_type not in _MSG_PARSERS
    _MSG_PARSERS[cls.cls_msg_type] = cls.parser
    return cls
321529
def load_message_classes():
    """"""
    for message in pkg_resources.iter_entry_points("fedora.messages"):
        cls = message.load()
        _log.info(
            "Registering the '%s' key as the '%r' class in the Message "
            "class registry",
            message.name,
            cls,
        )
        _schema_name_to_class[message.name] = cls
        _class_to_schema_name[cls] = message.name
    global _registry_loaded
    _registry_loaded = True
614465
protected function registerSigHandlers()
    {
        pcntl_signal(SIGTERM, array($this, 'signalHandler'));
        pcntl_signal(SIGINT, array($this, 'signalHandler'));;
        pcntl_signal(SIGUSR1, array($this, 'signalHandler'));
        pcntl_signal(SIGUSR2, array($this, 'signalHandler'));
        //pcntl_signal(SIGQUIT, array($this, 'signalHandler'));
        //pcntl_signal(SIGCONT, array($this, 'signalHandler'));
        //pcntl_signal(SIGPIPE, array($this, 'signalHandler'));
        //pcntl_signal(SIGCHLD, array($this, 'signalHandler'));
    }
33249
private function SetMessageType() {
    if(count($this->attachment) < 1 && strlen($this->AltBody) < 1) {
      $this->message_type = 'plain';
    } else {
      if(count($this->attachment) > 0) {
        $this->message_type = 'attachments';
      }
      if(strlen($this->AltBody) > 0 && count($this->attachment) < 1) {
        $this->message_type = 'alt';
      }
      if(strlen($this->AltBody) > 0 && count($this->attachment) > 0) {
        $this->message_type = 'alt_attachments';
      }
    }
  }
1188702
def add_messages(self, validation):
        
        if not isinstance(validation, Validation):
            raise TypeError("Argument must be of type Validation")

        self.messages.extend(validation.messages)
614499
protected function setMessageType()
    {
        $this->message_type = array();
        if ($this->alternativeExists()) {
            $this->message_type[] = 'alt';
        }
        if ($this->inlineImageExists()) {
            $this->message_type[] = 'inline';
        }
        if ($this->attachmentExists()) {
            $this->message_type[] = 'attach';
        }
        $this->message_type = implode('_', $this->message_type);
        if ($this->message_type == '') {
            $this->message_type = 'plain';
        }
    }
803752
public static function register()
    {
        $postType = static::getPostType();
        $config = static::getPostTypeConfig();

        if (empty($postType) || $postType === 'post') {
            throw new PostTypeRegistrationException('Post type not set');
        }

        if (empty($config)) {
            throw new PostTypeRegistrationException('Config not set');
        }

        register_post_type($postType, $config);
    }
1042978
public function register()
    {
        if ($this->types !== null) {
            return;
        }

        $types = &Objects::getPropertyValue(Type::class, '_typeObjects', Type::class);

        if ($types instanceof self) {
            $this->types = $types->types;
        } else {
            $this->types = [];

            foreach ($types as $name => $type) {
                $this->addType($type);
            }
        }

        $types = $this;
    }
1049165
private void register(Class<? extends YamlNode> type, Represent represent) {
        this.representers.put(type, represent);
        this.multiRepresenters.put(type, represent);
    }
402838
public function addMessageType(\BisonLab\SakonninBundle\Entity\MessageType $message_types)
    {
        $this->message_types[] = $message_types;

        return $this;
    }
334011
protected function resetMessageTypes()
    {
        foreach (array_keys($this->config('types')) as $type) {
            $_SESSION[$this->alias][$type] = [];
        }
    }
866905
def register_signals(self):
        """"""
        for index in self.indexes:
            if index.object_type:
                self._connect_signal(index)
1078990
public <TMessage> void register(final Class<TMessage> msgMetaClass) {
    final String classId = getClassId(msgMetaClass);
    LOG.log(Level.INFO, "Registering message: {0}", classId);
    this.nameToSerializerMap.put(classId, SerializationFactory.createSerializer(msgMetaClass));
    this.nameToDeserializerMap.put(classId, SerializationFactory.createDeserializer(msgMetaClass));
  }
694564
protected void registerJavaTimeDatatypes() {

    // prevent compile-time dependencies and GWT availability problems
    registerStandardDatatype("java.time.LocalTime");
    registerStandardDatatype("java.time.LocalDate");
    registerStandardDatatype("java.time.LocalDateTime");
    registerStandardDatatype("java.time.MonthDay");
    registerStandardDatatype("java.time.Year");
    registerStandardDatatype("java.time.YearMonth");
    registerStandardDatatype("java.time.Instant");
    registerStandardDatatype("java.time.Duration");
    registerStandardDatatype("java.time.Period");
    registerStandardDatatype("java.time.OffsetTime");
    registerStandardDatatype("java.time.OffsetDate");
    registerStandardDatatype("java.time.OffsetDateTime");
    registerStandardDatatype("java.time.ZoneId");
    registerStandardDatatype("java.time.ZonedDateTime");
    registerStandardDatatype("java.time.ZoneOffset");
    registerStandardDatatype("java.time.ZoneRegion");
  }
789158
@Override
    public void registerForMessageEvents(SIMPMessage msg)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "registerForMessageEvents", msg);

        registerForEvents(msg);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "registerForMessageEvents");
    }