Setter for **self.__comment_marker** attribute.

        :param value: Attribute value.
        :type value: unicode
187877
def comment_marker(self, value):
        

        if value is not None:
            assert type(value) is unicode, "'{0}' attribute: '{1}' type is not 'unicode'!".format(
                "comment_marker", value)
            assert not re.search(r"\w", value), "'{0}' attribute: '{1}' is an alphanumeric character!".format(
                "comment_marker", value)
        self.__comment_marker = value
1368230
def set_message_ref(self, value):
        
        if value is None:
            self.__message_ref = value
        if not isinstance(value, str):
            raise TypeError("MessageRef must be set to a String")
        else:
            self.__message_ref = value
1011713
def set(self, value):
        

        if not isinstance(value, str_cls):
            raise TypeError(unwrap(
                '''
                %s value must be a unicode string, not %s
                ''',
                type_name(self),
                type_name(value)
            ))

        if value.startswith('.'):
            encoded_value = b'.' + value[1:].encode(self._encoding)
        else:
            encoded_value = value.encode(self._encoding)

        self._unicode = value
        self.contents = encoded_value
        self._header = None
        if self._trailer != b'':
            self._trailer = b''
120814
public void setStringValue(String value) {

        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(value)) {
            try {
                m_editValue = CmsLocationValue.parse(value);
                m_currentValue = m_editValue.cloneValue();
                displayValue();
                if ((m_popup != null) && m_popup.isVisible()) {
                    m_popupContent.displayValues(m_editValue);
                    updateMarkerPosition();
                }
            } catch (Exception e) {
                CmsLog.log(e.getLocalizedMessage() + "\n" + CmsClientStringUtil.getStackTrace(e, "\n"));
            }
        } else {
            m_currentValue = null;
            displayValue();
        }
    }
84220
def category(self, value):
        

        if value is not None:
            assert type(value) is unicode, "'{0}' attribute: '{1}' type is not 'unicode'!".format(
                "category", value)
        self.__category = value
1014692
def set_annotation(self):
        """"""
        assert self.pending_symbol is not None
        assert not self.value
        annotations = (_as_symbol(self.pending_symbol, is_symbol_value=False),)  # pending_symbol becomes an annotation
        self.annotations = annotations if not self.annotations else self.annotations + annotations
        self.ion_type = None
        self.pending_symbol = None  # reset pending symbol
        self.quoted_text = False
        self.line_comment = False
        self.is_self_delimiting = False
        return self
360055
def set_target_ref(self, value):
        
        if value is None or not isinstance(value, str):
            raise TypeError("TargetRef is required and must be set to a String")
        else:
            self.__target_ref = value
897006
def indent_marker(self, value):
        

        if value is not None:
            assert type(value) is unicode, "'{0}' attribute: '{1}' type is not 'unicode'!".format(
                "indent_marker", value)
            assert re.search(r"\s", value), "'{0}' attribute: '{1}' is not a whitespace character!".format(
                "indent_marker", value)
        self.__indent_marker = value
1176929
def editor(self, value):
        

        if value is not None:
            assert type(value) is Editor, "'{0}' attribute: '{1}' type is not 'Editor'!".format("editor", value)
        self.__editor = value
173517
def set_pending_symbol(self, pending_symbol=None):
        
        if pending_symbol is None:
            pending_symbol = CodePointArray()
        self.value = bytearray()  # reset value
        self.pending_symbol = pending_symbol
        self.line_comment = False
        return self
554394
def to_comment(value):
  
  if value is None:
    return
  if len(value.split('\n')) == 1:
    return "* " + value
  else:
    return '\n'.join([' * ' + l for l in value.split('\n')[:-1]])
724989
protected static function highlightComment($value)
    {
        if (self::is_cli()) {
            return self::$cli_comment . $value . "\x1b[0m";
        } else {
            return '<span ' . self::$comment_attributes . '>' . $value . '</span>';
        }
    }
596447
def url(self, value):
        

        if value is not None:
            assert type(value) is unicode, "'{0}' attribute: '{1}' type is not 'unicode'!".format(
                "url", value)
        self.__url = value
87215
public void setComment(final boolean comment) throws IllegalArgumentException {
        // Cannot have children
        if (this.children.size() > 0) {
            throw new IllegalArgumentException("Cannot mark a " + Node.class.getSimpleName()
                + " with children as a comment");
        }

        // Set
        this.comment = comment;
    }
300655
def author(self, value):
        

        if value is not None:
            assert type(value) is unicode, "'{0}' attribute: '{1}' type is not 'unicode'!".format(
                "author", value)
        self.__author = value
1304834
def set(self, value):
        

        if not isinstance(value, str_cls):
            raise TypeError(unwrap(
                '''
                %s value must be a unicode string, not %s
                ''',
                type_name(self),
                type_name(value)
            ))

        if value.find('@') != -1:
            mailbox, hostname = value.rsplit('@', 1)
            encoded_value = mailbox.encode('ascii') + b'@' + hostname.encode('idna')
        else:
            encoded_value = value.encode('ascii')

        self._normalized = True
        self._unicode = value
        self.contents = encoded_value
        self._header = None
        if self._trailer != b'':
            self._trailer = b''
109498
def find_comment_markers(cellsource):
    
    found = {}
    for line in cellsource.splitlines():
        line = line.strip()
        if line.startswith('#'):
            # print("Found comment in '{}'".format(line))
            comment = line.lstrip('#').strip()
            if comment in comment_markers:
                # print("Found marker {}".format(comment))
                marker = comment_markers[comment]
                if not isinstance(marker, tuple):
                    # If not an explicit tuple ('option', True/False),
                    # imply ('option', True)
                    marker = (marker, True)
                marker_type = marker[0]
                if marker_type in found:
                    warnings.warn(
                        "Conflicting comment markers found, using the latest: "
                        " %s VS %s" %
                        (found[marker_type], comment))
                found[marker_type] = comment
                yield marker