Serializes the options to a string.
324107
public function toString($default=true)
    {
        $options = array();
        $binder = new Database\Binder();

        foreach ($this as $key=>$value) {
            $options[] = ($value === $default)
                ? $key
                : sprintf("%s=%s", $key, urlencode($value))
                ;
        }

        return implode(' ', $options);
    }
789001
def dumps(self):
        """"""

        ret_str = self.path_type

        if self.options is not None:
            ret_str += self.options.dumps()

        return ret_str
760037
def to_string(self):
        
        return '%s   %s %s %s %s' % (
            self.trait, self.start_position, self.peak_start_position,
            self.peak_stop_position, self.stop_position)
712311
def _build_option_string(self, options):
        
        option_string = ""
        if options is not None:
            for key in options:
                option_string += "/%s-%s" % (key, options[key])
        return self._quote_url(option_string)
130887
def serialize(obj, **options):
    '''
    
    '''

    try:
        if 'file_out' in options:
            return toml.dump(obj, options['file_out'], **options)
        else:
            return toml.dumps(obj, **options)
    except Exception as error:
        raise SerializationError(error)
1307461
private function OptionsString()
    {
        if (!$this->radio->Exists())
        {
            return '';
        }
        $list = new RadioListProvider($this->radio);
        $options = $list->ToArray();
        $lines = array();
        foreach ($options as $key=>$value)
        {
            $lines[] = $key . ':' . $value;
        }
        return join("\r\n", $lines);
    }
281626
def _to_xml_string(line_prefix, options)
      eol = options[:eol]

      s = ""
      s << line_prefix << ?<
      s << "#{namespace}:" unless namespace.empty?
      s << name

      # output namespace declarations
      uri_by_namespace = options[:uri_by_namespace]
      if uri_by_namespace
        uri_by_namespace.each_pair do |namespace, uri|
          if namespace
            s << " xmlns:#{namespace}=\"#{uri}\""
          else
            s << " xmlns=\"#{uri}\""
          end
        end
      end
      
      # output values
      unless @values.empty?
        i = 0
        @values.each do |value|
          s << " _val" << i.to_s << "=\"" << SDL4R.format(value, false) << "\""
          i += 1
        end
      end
      
      # output attributes
      if has_attribute?
        omit_null_attributes = options[:omit_null_attributes]
        attributes do |attribute_namespace, attribute_name, attribute_value|
          unless omit_null_attributes and attribute_value.nil?
            s << " "
            s << "#{attribute_namespace}:" unless attribute_namespace.empty?
            s << attribute_name << "=\"" << SDL4R.format(attribute_value, false) << ?"
          end
        end
      end
  
      if @children.empty?
        s << "/>"
      else
        s << ">" << eol
        @children.each do |child|
          s << child._to_xml_string(line_prefix + options[:indent], options) << eol
        end
        
        s << line_prefix << "</"
        s << "#{namespace}:" unless namespace.empty?
        s << name << ?>
      end
  
      return s
    end
666593
def optional_namestring(self):
        
        opt_names = list(self.optional_names())
        if opt_names:
            return '[, {}]'.format(', '.join(opt_names))
        else:
            return ''
840941
def to_string(self):
        """"""
        suffix = '%s %s' % (self.type, self.name)
        if self.initial_value:
            suffix += ' = ' + self.initial_value
        return suffix
1310664
protected String resource_to_string(nitro_service service, options option)
	{
		String onerror = service.get_onerror();
		return service.get_payload_formatter().resource_to_string(this, option, onerror);
	}
434578
def to_string(s, encoding=None, errors='strict'):
    """"""
    encoding = encoding or 'utf-8'
    if isinstance(s, bytes):
        return s.decode(encoding, errors)
    if not is_string(s):
        s = string_type(s)
    return s
1162085
def to_str(self):
        """"""
        val = c_backend.pystring_get_str(self._ptr)
        delattr(self, '_ptr')
        setattr(self, 'to_str', _dangling_pointer)
        return val.decode("utf-8")
340109
def __toString(self, values):
		
		for key in values:
			if not values[key] is str:
				values[key] = str(values[key])
		return values
160655
function(items) {
            var str = [];
            for(var i=0; i<items.length; i++) {
                str.push('<option value="'+items[i][0]+'">'+items[i][1]+'</option>');                
            }
            return str.join("\n");
        }
423594
function optionsFromStrings(options) {
	var intOptions = ["width", "height", "textMargin", "fontSize", "margin", "marginTop", "marginBottom", "marginLeft", "marginRight"];

	for (var intOption in intOptions) {
		if (intOptions.hasOwnProperty(intOption)) {
			intOption = intOptions[intOption];
			if (typeof options[intOption] === "string") {
				options[intOption] = parseInt(options[intOption], 10);
			}
		}
	}

	if (typeof options["displayValue"] === "string") {
		options["displayValue"] = options["displayValue"] != "false";
	}

	return options;
}
409647
protected String serializeElementToString(){
		StringBuilder buf=new StringBuilder();
		buf.append("[");
		LazyNode pointer=root.child;
		boolean first=true;
		while(pointer!=null){
			if(first){
				first=false;
			}else{
				buf.append(",");
			}
			if(pointer.type==LazyNode.OBJECT){
				buf.append(new LazyObject(pointer).toString());
			}else if(pointer.type==LazyNode.ARRAY){
				buf.append(new LazyArray(pointer).toString());
			}else if(pointer.type==LazyNode.VALUE_STRING){
				buf.append("\"");
				buf.append(pointer.getStringValue());
				buf.append("\"");
			}else if (pointer.type==LazyNode.VALUE_ESTRING){
				buf.append("\"");
				buf.append(pointer.getRawStringValue());
				buf.append("\"");
			}else if(pointer.type==LazyNode.VALUE_TRUE){
				buf.append("true");
			}else if(pointer.type==LazyNode.VALUE_FALSE){
				buf.append("false");
			}else if(pointer.type==LazyNode.VALUE_NULL){
				buf.append("null");
			}else{
				buf.append(pointer.getStringValue());
			}
			pointer=pointer.next;
		}
		buf.append("]");
		return buf.toString();
	}
630845
def _to_string(val):
    """"""
    if isinstance(val, binary_type):
        return val.decode('utf-8')
    assert isinstance(val, text_type)
    return val