rubocop:disable MethodLength, LineLength
 Convert this object to a string representation
 @return [String]
343820
def to_s
      string =  "Execution ID:      #{@id}\n"
      string << "Name:              #{@name}\n"
      string << "Workflow ID:       #{@workflow_id}\n"
      string << "State:             #{@state}\n"
      string << "Start Date:        #{Time.at(@start_date / 1000)}\n"
      string << "End Date:          #{end_date.nil? ? '' : Time.at(@end_date / 1000)}\n"
      string << "Started By:        #{@started_by}\n"
      string << "Content Exception: #{@content_exception}\n" unless @content_exception.nil?
      string << "\nInput Parameters:\n"
      @input_parameters.each_value { |wf_param| string << " #{wf_param}" if wf_param.set? } if @input_parameters.size > 0
      string << "\nOutput Parameters:" << "\n"
      @output_parameters.each_value { |wf_param| string << " #{wf_param}" } if @output_parameters.size > 0
      string
    end
1058391
def lines
      @lines ||= begin
        all_lines = @buffer.source_lines
        last_token_line = tokens.any? ? tokens.last.line : all_lines.size
        result = []
        all_lines.each_with_index do |line, ix|
          break if ix >= last_token_line && line == '__END__'

          result << line
        end
        result
      end
    end
592309
def to_s

            return '' unless @hash.kind_of?( Hash )
            keys = @sorted ? @hash.keys.sort : @hash.keys
            str  = ''
            seen = {}

            keys.each do |key|
                unless seen.has_key?( key )
                    val = @hash[key]
                    val = stringify( val )  if val.kind_of?( Hash )
                    val = rotate( val )     if val.kind_of?( Array )
                    str += sprintf( ' %s="%s"', key( key ), val( val ) )
                end
                seen[key] = 1
            end

            return str
        end
1086843
def formatted_version
        stringified = @version.to_s
        return stringified unless stringified.length == 14
        stringified.insert(4, "_").insert(7, "_").insert(10, "_")
      end
1198669
def contents
      c = StringIO.new
      @lines.each do |l| 
        c.puts l if l
      end
      c.string
    end
1110369
def children_to_string(line_prefix = "", s = "")
      @children.each do |child|
        s << child.to_string(line_prefix) << $/
      end
      
      return s
    end
370181
def to_xml_string(str = '')
      [:col, :colOff, :row, :rowOff].each do |k|
        str << ('<xdr:' << k.to_s << '>' << self.send(k).to_s << '</xdr:' << k.to_s << '>')
      end
    end
823013
private String getSelfString()
    {
        String queue_string = " {" + new_line;
        if (restriction != null)
            queue_string += "  restriction: " + restriction.toString() + new_line;
        if (index != null)
            queue_string += "  index: " + index.getClass().getName() + new_line;
        if (!implementation_options.isEmpty())
            queue_string += "  implementation options: " + implementation_options.toString() + new_line;
        if (process_builder_class != null)
            queue_string += "  process builder: " + process_builder_class.getName() + new_line;
        if (process_server_class != null)
            queue_string += "  process server: " + process_server_class.getName() + new_line;
        if (default_occurence != null)
            queue_string += "  default occurrence: " + default_occurence.toString() + new_line;
        if (default_visibility != null)
            queue_string += "  default visibility: " + default_visibility.getClass().getName() + new_line;
        if (default_access != null)
            queue_string += "  default access: " + default_access.getClass().getName() + new_line;
        if (default_resilience != null)
            queue_string += "  default resilience: " + default_resilience.toString() + new_line;
        if (default_output != null)
            queue_string += "  default output: " + default_output.getClass().toString() + new_line;
        return queue_string + "}" + new_line;
    }
593462
def to_s
      str = "Polyline["
      vertices.each do |vertex|
        str += vertex.to_element_s + ", "
      end
      str.slice!(str.length - 2, 2) if(vertices.size > 0)
      str += "] "
      str += "open" if(@is_open)
      str += "closed" if(!@is_open)
      return str
    end
7284
def parse_newline
      s0 = @current_pos
      s1 = []
      s2 = parse_whitespace
      while s2 != :failed
        s1 << s2
        s2 = parse_whitespace
      end
      s2 = match_str("\n")
      if s2 == :failed
        s2 = @current_pos
        s3 = match_str("\r")
        s2 = if s3 != :failed
               s4 = match_str("\n")
               s4 = nil if s4 == :failed
               [s3, s4]
             else
               @current_pos = s2
               :failed
             end
      end
      if s2 != :failed
        [s1, s2]
      else
        @current_pos = s0
        :failed
      end
    end
786632
def to_hash
      methods = instance_variables.map { |i| i.to_s.gsub('@', '') }
      Hash[*methods.map { |m| [m, send(m.to_sym)] }.flatten]
    end
520228
def to_s
      hash = {}
      @hooks_map.each_pair do |hook_event, nested_hash|
        hash[hook_event] = {}
        nested_hash.each_pair do |name, callbacks|
          hash[hook_event][name] = callbacks
        end
      end
      hash.to_s
    end
1175211
def method_return_string(meth)
      return "" unless meth[:tags]

      return_value = meth[:tags].find { |t| t[:name] == "return" && t[:types] }
      return "" if return_value.nil?
      return "" if return_value[:types].nil?
      return "" unless return_value[:types].kind_of? Array

      unless return_value.empty?
        return "" if return_value[:types].first == "void"
        return return_value[:types].first
      end
      ""
    end
1231331
def to_hash
      stringified_params = Hash[parameters.map { |key, val| [key.to_s, val] }]
      base_hash.merge(stringified_params)
    end
64117
def string_encoder
      return string if string.valid_encoding?
      str = string
      Encoding.list.each do |e|
        begin
          str.force_encoding(e.name)
          tmp_string = str.encode('UTF-8')
          return tmp_string if tmp_string.valid_encoding?
        rescue
          Rails.logger.debug { "Rescue -> #{e.name}" } if defined?(::Rails)
        end
      end

      impossible_encoding

      string
    end
710795
def to_params
      attrs = Hash.new
      instance_variables.each do |ivar|
        name = ivar[1..-1]
        attrs[name.to_sym] = instance_variable_get(ivar) if respond_to? "#{name}="
      end
      attrs
    end
886715
def _to_string(self):
        
        parts = []
        if self.library:  # pylint: disable=no-member
            parts.extend([self.org, self.library])  # pylint: disable=no-member
            if self.branch:  # pylint: disable=no-member
                parts.append(u"{prefix}@{branch}".format(prefix=self.BRANCH_PREFIX, branch=self.branch))  # pylint: disable=no-member
        if self.version_guid:  # pylint: disable=no-member
            parts.append(u"{prefix}@{guid}".format(prefix=self.VERSION_PREFIX, guid=self.version_guid))  # pylint: disable=no-member
        return u"+".join(parts)