self.data.appendleft(x)

    def append(self, x):

        self.data.append(x)

    def extend(self, o):

        self.data.extend(o)

    def __getitem__(self, i):

        return self.data[i]

    '''

    Processor class wrapping handling of subprocess IO.

    In a way, this is a "communicate()" replacement with a twist.

    - We are multithreaded. Writing in and reading out, err are all sep threads.

    - We support concurrent (in and out) stream processing.

    - The output is not a stream. It's a queue of read string (bytes, not unicode)

      chunks. The object behaves as an iterable. You can "for chunk in obj:" us.

    - We are non-blocking in more respects than communicate()

      (reading from subprocess out pauses when internal buffer is full, but

       does not block the parent calling code. On the flip side, reading from

    #            buffer_size = 65536,

    #            chunk_size = 4096

    #            )

    #    except (EnvironmentError) as e:

    #        print str(e)

    #        raise e

    #

    #    return answer

    '''

    def __init__(self, cmd, inputstream=None, buffer_size=65536,

        '''

        Initializes SubprocessIOChunker

        @param cmd A Subprocess.Popen style "cmd". Can be string or array of strings

        @param inputstream (Default: None) A file-like, string, or file pointer.

        @param buffer_size (Default: 65536) A size of total buffer per stream in bytes.

        @param chunk_size (Default: 4096) A max size of a chunk. Actual chunk may be smaller.

        @param starting_values (Default: []) An array of strings to put in front of output que.

        '''

        if inputstream:

            input_streamer = StreamFeeder(inputstream)

            input_streamer.start()

            inputstream = input_streamer.output

        _p = subprocess.Popen(cmd,

            bufsize=-1,

            shell=True,

            stdin=inputstream,

            stdout=subprocess.PIPE,

            )

        bg_out = BufferedGenerator(_p.stdout, buffer_size, chunk_size, starting_values)

        bg_err = BufferedGenerator(_p.stderr, 16000, 1, bottomless=True)

        while not bg_out.done_reading and not bg_out.reading_paused and not bg_err.length:

            # doing this until we reach either end of file, or end of buffer.

            bg_out.data_added_event.wait(1)

            bg_out.data_added_event.clear()

        # at this point it's still ambiguous if we are done reading or just full buffer.

        # Either way, if error (returned by ended process, or implied based on