You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@qpid.apache.org by rh...@apache.org on 2012/10/02 14:54:45 UTC

svn commit: r1392896 - in /qpid/proton/trunk: examples/ruby/ proton-c/bindings/php/ proton-c/bindings/python/ proton-c/bindings/ruby/ proton-c/include/proton/ proton-c/src/ proton-c/src/engine/ proton-j/src/main/scripts/ tests/proton_tests/

Author: rhs
Date: Tue Oct  2 12:54:44 2012
New Revision: 1392896

URL: http://svn.apache.org/viewvc?rev=1392896&view=rev
Log:
renamed older C functions to match current naming conventions; tweaked naming of delivery API

Modified:
    qpid/proton/trunk/examples/ruby/fetch.rb
    qpid/proton/trunk/examples/ruby/mailserver.rb
    qpid/proton/trunk/examples/ruby/post.rb
    qpid/proton/trunk/proton-c/bindings/php/php.i
    qpid/proton/trunk/proton-c/bindings/python/proton.py
    qpid/proton/trunk/proton-c/bindings/python/python.i
    qpid/proton/trunk/proton-c/bindings/ruby/ruby.i
    qpid/proton/trunk/proton-c/include/proton/cproton.i
    qpid/proton/trunk/proton-c/include/proton/engine.h
    qpid/proton/trunk/proton-c/src/driver.c
    qpid/proton/trunk/proton-c/src/engine/engine.c
    qpid/proton/trunk/proton-c/src/messenger.c
    qpid/proton/trunk/proton-c/src/proton.c
    qpid/proton/trunk/proton-j/src/main/scripts/proton.py
    qpid/proton/trunk/tests/proton_tests/engine.py

Modified: qpid/proton/trunk/examples/ruby/fetch.rb
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/examples/ruby/fetch.rb?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/examples/ruby/fetch.rb (original)
+++ qpid/proton/trunk/examples/ruby/fetch.rb Tue Oct  2 12:54:44 2012
@@ -101,7 +101,7 @@ class FetchClient
     log "Fetching from the mailbox = #{@mailbox}"
     @ssn = Cproton::pn_session @conn
     @link = Cproton::pn_receiver @ssn, "receiver"
-    Cproton::pn_set_source @link, @mailbox
+    Cproton::pn_link_set_source @link, @mailbox
 
     # now open all the engine endpoints
     Cproton::pn_connection_open @conn
@@ -120,10 +120,10 @@ class FetchClient
   def settle
     # locally settle any remotely settled deliveries
     d = Cproton::pn_unsettled_head @link
-    while d && !Cproton::pn_readable(d)
+    while d && !Cproton::pn_delivery_readable(d)
       # delivery that has not yet been read
       _next = Cproton::pn_unsettled_next d
-      Cproton::pn_settle(d) if Cproton::pn_remote_settled(d)
+      Cproton::pn_delivery_settle(d) if Cproton::pn_remote_settled(d)
       d = _next
     end
   end
@@ -152,18 +152,18 @@ if __FILE__ == $PROGRAM_NAME
   end
 
   # check if the server recognizes the mailbox, fail if it does not
-  if Cproton::pn_remote_source(receiver.link) != $options[:mailbox]
+  if Cproton::pn_link_remote_source(receiver.link) != $options[:mailbox]
     log "ERROR: mailbox #{$options[:mailbox]} does not exist!", -2
   end
 
   # Allow the server to send the expected number of messages to the receiver
   # by setting the credit to the expected count
-  Cproton::pn_flow(receiver.link, $options[:count])
+  Cproton::pn_link_flow(receiver.link, $options[:count])
 
   # main loop: continue fetching messages until all the expected number of
   # messages have been retrieved
 
-  while Cproton::pn_credit(receiver.link) > 0
+  while Cproton::pn_link_credit(receiver.link) > 0
     # wait for some messages to arrive
     receiver.wait if Cproton::pn_queued(receiver.link).zero?
 
@@ -172,7 +172,7 @@ if __FILE__ == $PROGRAM_NAME
       delivery = Cproton::pn_current(receiver.link)
 
       # read all bytes of message
-      (rc, msg) = Cproton::pn_recv(receiver.link, Cproton::pn_pending(delivery))
+      (rc, msg) = Cproton::pn_link_recv(receiver.link, Cproton::pn_pending(delivery))
       log "Received count/status=#{rc}"
 
       log("ERROR: Receive failed (#{rc}), exiting...", -3) if rc < 0
@@ -180,17 +180,17 @@ if __FILE__ == $PROGRAM_NAME
       puts "#{msg}"
 
       # let the server know we accept the message
-      Cproton::pn_disposition(delivery, Cproton::PN_ACCEPTED)
+      Cproton::pn_delivery_update(delivery, Cproton::PN_ACCEPTED)
 
       # go to the next deliverable
-      Cproton::pn_advance(receiver.link)
+      Cproton::pn_link_advance(receiver.link)
     end
 
     receiver.settle
   end
 
   # block until any leftover deliveries are settled
-  while Cproton::pn_unsettled(receiver.link) > 0
+  while Cproton::pn_link_unsettled(receiver.link) > 0
     receiver.wait
     receiver.settle
   end

Modified: qpid/proton/trunk/examples/ruby/mailserver.rb
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/examples/ruby/mailserver.rb?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/examples/ruby/mailserver.rb (original)
+++ qpid/proton/trunk/examples/ruby/mailserver.rb Tue Oct  2 12:54:44 2012
@@ -185,15 +185,15 @@ class MailServer
     delivery = Cproton::pn_work_head conn
     while delivery
       log "Process delivery #{Cproton::pn_delivery_tag delivery}"
-      if Cproton::pn_readable delivery
+      if Cproton::pn_delivery_readable delivery
         process_receive delivery
-      elsif Cproton::pn_writable delivery
+      elsif Cproton::pn_delivery_writable delivery
         send_message delivery
       end
 
-      if Cproton::pn_updated delivery
-        log "Remote disposition for #{Cproton::pn_delivery_tag delivery}: #{Cproton::pn_remote_disposition delivery}"
-        Cproton::pn_settle(delivery) if Cproton::pn_remote_disposition delivery
+      if Cproton::pn_delivery_updated delivery
+        log "Remote disposition for #{Cproton::pn_delivery_tag delivery}: #{Cproton::pn_delivery_remote_state delivery}"
+        Cproton::pn_delivery_settle(delivery) if Cproton::pn_delivery_remote_state delivery
       end
 
       delivery = Cproton::pn_work_next delivery
@@ -221,9 +221,9 @@ class MailServer
   end
 
   def process_receive(delivery)
-    link = Cproton::pn_link delivery
-    mbox = Cproton::pn_remote_target link
-    (rc, msg) = Cproton::pn_recv link, 1024
+    link = Cproton::pn_delivery_link delivery
+    mbox = Cproton::pn_link_remote_target link
+    (rc, msg) = Cproton::pn_link_recv link, 1024
 
     log "Message received #{rc}"
 
@@ -235,21 +235,21 @@ class MailServer
         log "Mailbox #{mbox} contains: #{@mailboxes[mbox].size}"
       end
 
-      (rc, msg) = Cproton::pn_recv link, 1024
+      (rc, msg) = Cproton::pn_link_recv link, 1024
     end
 
     log "Messages accepted."
 
-    Cproton::pn_disposition delivery, Cproton::PN_ACCEPTED
-    Cproton::pn_settle delivery
-    Cproton::pn_advance link
+    Cproton::pn_delivery_update delivery, Cproton::PN_ACCEPTED
+    Cproton::pn_delivery_settle delivery
+    Cproton::pn_link_advance link
 
-    Cproton::pn_flow(link, 1) if Cproton::pn_credit(link).zero?
+    Cproton::pn_link_flow(link, 1) if Cproton::pn_link_credit(link).zero?
   end
 
   def send_message(delivery)
-    link = Cproton::pn_link delivery
-    mbox = Cproton::pn_remote_source link
+    link = Cproton::pn_delivery_link delivery
+    mbox = Cproton::pn_link_remote_source link
     log "Request for Mailbox=#{mbox}"
 
     if @mailboxes.include?(mbox) && !@mailboxes[mbox].empty?
@@ -261,20 +261,20 @@ class MailServer
       msg = ""
     end
 
-    sent = Cproton::pn_send link, msg
+    sent = Cproton::pn_link_send link, msg
     log "Message sent: #{sent}"
 
-    if Cproton::pn_advance link
+    if Cproton::pn_link_advance link
       Cproton::pn_delivery link, "server-delivery-#{@counter}"
       @counter += 1
     end
   end
 
   def setup_link(link)
-    r_tgt = Cproton::pn_remote_target link
-    r_src = Cproton::pn_remote_source link
+    r_tgt = Cproton::pn_link_remote_target link
+    r_src = Cproton::pn_link_remote_source link
 
-    if Cproton::pn_is_sender link
+    if Cproton::pn_link_is_sender link
       log "Opening link to read from mailbox: #{r_src}"
 
       unless @mailboxes.include? r_src
@@ -287,14 +287,14 @@ class MailServer
       @mailboxes[r_tgt] = [] unless @mailboxes.include? r_tgt
     end
 
-    Cproton::pn_set_target link, r_tgt
-    Cproton::pn_set_source link, r_src
+    Cproton::pn_link_set_target link, r_tgt
+    Cproton::pn_link_set_source link, r_src
 
-    if Cproton::pn_is_sender link
+    if Cproton::pn_link_is_sender link
       Cproton::pn_delivery link, "server-delivery-#{@counter}"
       @counter += 1
     else
-      Cproton::pn_flow link, 1
+      Cproton::pn_link_flow link, 1
     end
 
     Cproton::pn_link_open link

Modified: qpid/proton/trunk/examples/ruby/post.rb
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/examples/ruby/post.rb?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/examples/ruby/post.rb (original)
+++ qpid/proton/trunk/examples/ruby/post.rb Tue Oct  2 12:54:44 2012
@@ -103,7 +103,7 @@ class PostClient
     log "Posting to mailbox = #{@mailbox}"
     @ssn = Cproton::pn_session @conn
     @link = Cproton::pn_sender @ssn, "sender"
-    Cproton::pn_set_target @link, @mailbox
+    Cproton::pn_link_set_target @link, @mailbox
 
     # now open all the engien end points
     Cproton::pn_connection_open @conn
@@ -123,14 +123,14 @@ class PostClient
     d = Cproton::pn_unsettled_head @link
     while d
       _next = Cproton::pn_unsettled_next d
-      disp = Cproton::pn_remote_disposition d
+      disp = Cproton::pn_delivery_remote_state d
 
       if disp.nonzero? && disp != Cproton::PN_ACCEPTED
         log "Warning: message was not accepted by the remote!"
       end
 
       if disp || Cproton::pn_remote_settled(disp)
-        Cproton::pn_settle(d)
+        Cproton::pn_delivery_settle(d)
       end
 
       d = _next
@@ -153,29 +153,29 @@ if __FILE__ == $PROGRAM_NAME
 
   while !$options[:messages].empty? do
 
-    while Cproton::pn_credit(sender.link).zero?
+    while Cproton::pn_link_credit(sender.link).zero?
       log "Waiting for credit"
       sender.wait
     end
 
-    while Cproton::pn_credit(sender.link) > 0
+    while Cproton::pn_link_credit(sender.link) > 0
       msg = $options[:messages].first
       $options[:messages].delete_at 0
       log "Sending #{msg}"
       d = Cproton::pn_delivery sender.link, "post-deliver-#{$options[:messages].length}"
-      rc = Cproton::pn_send(sender.link, msg)
+      rc = Cproton::pn_link_send(sender.link, msg)
 
       abort "Error: sending message: #{msg}" if rc < 0
 
       fail unless rc == msg.length
 
-      Cproton::pn_advance sender.link
+      Cproton::pn_link_advance sender.link
     end
 
     sender.settle
   end
 
-  while Cproton::pn_unsettled(sender.link) > 0
+  while Cproton::pn_link_unsettled(sender.link) > 0
     log "Settling things with the server..."
     sender.wait
     sender.settle

Modified: qpid/proton/trunk/proton-c/bindings/php/php.i
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/proton-c/bindings/php/php.i?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/proton-c/bindings/php/php.i (original)
+++ qpid/proton/trunk/proton-c/bindings/php/php.i Tue Oct  2 12:54:44 2012
@@ -60,11 +60,11 @@
 // embedded \0's).
 //
 
-// allow pn_send/pn_input's input buffer to be binary safe
-ssize_t pn_send(pn_link_t *transport, char *STRING, size_t LENGTH);
-%ignore pn_send;
-ssize_t pn_input(pn_transport_t *transport, char *STRING, size_t LENGTH);
-%ignore pn_input;
+// allow pn_link_send/pn_input's input buffer to be binary safe
+ssize_t pn_link_send(pn_link_t *transport, char *STRING, size_t LENGTH);
+%ignore pn_link_send;
+ssize_t pn_transport_input(pn_transport_t *transport, char *STRING, size_t LENGTH);
+%ignore pn_transport_input;
 
 ssize_t pn_sasl_send(pn_sasl_t *sasl, char *STRING, size_t LENGTH);
 %ignore pn_sasl_send;
@@ -73,17 +73,17 @@ ssize_t pn_sasl_send(pn_sasl_t *sasl, ch
 // Use the OUTPUT_BUFFER,OUTPUT_LEN typemap to allow these functions to return
 // variable length binary data.
 
-%rename(pn_recv) wrap_pn_recv;
-// in PHP:   array = pn_recv(link, MAXLEN);
+%rename(pn_link_recv) wrap_pn_link_recv;
+// in PHP:   array = pn_link_recv(link, MAXLEN);
 //           array[0] = size || error code
 //           array[1] = native string containing binary data
 %inline %{
-    void wrap_pn_recv(pn_link_t *link, size_t maxCount, char **OUTPUT_BUFFER, ssize_t *OUTPUT_LEN) {
+    void wrap_pn_link_recv(pn_link_t *link, size_t maxCount, char **OUTPUT_BUFFER, ssize_t *OUTPUT_LEN) {
         *OUTPUT_BUFFER = emalloc(sizeof(char) * maxCount);
-        *OUTPUT_LEN = pn_recv(link, *OUTPUT_BUFFER, maxCount );
+        *OUTPUT_LEN = pn_link_recv(link, *OUTPUT_BUFFER, maxCount );
     }
 %}
-%ignore pn_recv;
+%ignore pn_link_recv;
 
 %rename(pn_sasl_recv) wrap_pn_sasl_recv;
 // in PHP:   array = pn_sasl_recv(sasl, MAXLEN);
@@ -97,17 +97,17 @@ ssize_t pn_sasl_send(pn_sasl_t *sasl, ch
 %}
 %ignore pn_sasl_recv;
 
-%rename(pn_output) wrap_pn_output;
+%rename(pn_transport_output) wrap_pn_transport_output;
 // in PHP:   array = pn_output(transport, MAXLEN);
 //           array[0] = size || error code
 //           array[1] = native string containing binary data
 %inline %{
-    void wrap_pn_output(pn_transport_t *transport, size_t maxCount, char **OUTPUT_BUFFER, ssize_t *OUTPUT_LEN) {
+    void wrap_pn_transport_output(pn_transport_t *transport, size_t maxCount, char **OUTPUT_BUFFER, ssize_t *OUTPUT_LEN) {
         *OUTPUT_BUFFER = emalloc(sizeof(char) * maxCount);
         *OUTPUT_LEN = pn_output(transport, *OUTPUT_BUFFER, maxCount);
     }
 %}
-%ignore pn_output;
+%ignore pn_transport_output;
 
 %rename(pn_message_data) wrap_pn_message_data;
 // in PHP:  array = pn_message_data("binary message data", MAXLEN);

Modified: qpid/proton/trunk/proton-c/bindings/python/proton.py
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/proton-c/bindings/python/proton.py?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/proton-c/bindings/python/proton.py (original)
+++ qpid/proton/trunk/proton-c/bindings/python/proton.py Tue Oct  2 12:54:44 2012
@@ -1179,7 +1179,7 @@ class Endpoint(object):
 
 def wrap_connection(conn):
   if not conn: return None
-  ctx = pn_connection_context(conn)
+  ctx = pn_connection_get_context(conn)
   if ctx: return ctx
   wrapper = Connection(_conn=conn)
   return wrapper
@@ -1206,14 +1206,14 @@ class Connection(Endpoint):
       return err
 
   def _get_container(self):
-    return pn_connection_container(self._conn)
+    return pn_connection_get_container(self._conn)
   def _set_container(self, name):
     return pn_connection_set_container(self._conn, name)
 
   container = property(_get_container, _set_container)
 
   def _get_hostname(self):
-    return pn_connection_hostname(self._conn)
+    return pn_connection_get_hostname(self._conn)
   def _set_hostname(self, name):
     return pn_connection_set_hostname(self._conn, name)
 
@@ -1255,7 +1255,7 @@ class SessionException(ProtonException):
 
 def wrap_session(ssn):
   if ssn is None: return None
-  ctx = pn_session_context(ssn)
+  ctx = pn_session_get_context(ssn)
   if ctx:
     return ctx
   else:
@@ -1285,7 +1285,7 @@ class Session(Endpoint):
 
   @property
   def connection(self):
-    return wrap_connection(pn_get_connection(self._ssn))
+    return wrap_connection(pn_session_connection(self._ssn))
 
   def sender(self, name):
     return wrap_link(pn_sender(self._ssn, name))
@@ -1298,11 +1298,11 @@ class LinkException(ProtonException):
 
 def wrap_link(link):
   if link is None: return None
-  ctx = pn_link_context(link)
+  ctx = pn_link_get_context(link)
   if ctx:
     return ctx
   else:
-    if pn_is_sender(link):
+    if pn_link_is_sender(link):
       wrapper = Sender(link)
     else:
       wrapper = Receiver(link)
@@ -1322,7 +1322,7 @@ class Link(Endpoint):
   def _check(self, err):
     if err < 0:
       exc = EXCEPTIONS.get(err, LinkException)
-      raise exc("[%s]: %s" % (err, pn_connection_error(self._conn)))
+      raise exc("[%s]: %s" % (err, pn_link_error(self._link)))
     else:
       return err
 
@@ -1338,29 +1338,29 @@ class Link(Endpoint):
 
   @property
   def session(self):
-    return wrap_session(pn_get_session(self._link))
+    return wrap_session(pn_link_session(self._link))
 
   def delivery(self, tag):
     return wrap_delivery(pn_delivery(self._link, tag))
 
   @property
   def current(self):
-    return wrap_delivery(pn_current(self._link))
+    return wrap_delivery(pn_link_current(self._link))
 
   def advance(self):
-    return pn_advance(self._link)
+    return pn_link_advance(self._link)
 
   @property
   def unsettled(self):
-    return pn_unsettled(self._link)
+    return pn_link_unsettled(self._link)
 
   @property
   def credit(self):
-    return pn_credit(self._link)
+    return pn_link_credit(self._link)
 
   @property
   def queued(self):
-    return pn_queued(self._link)
+    return pn_link_queued(self._link)
 
   def next(self, mask):
     return wrap_link(pn_link_next(self._link, mask))
@@ -1368,18 +1368,18 @@ class Link(Endpoint):
 class Sender(Link):
 
   def send(self, bytes):
-    return self._check(pn_send(self._link, bytes))
+    return self._check(pn_link_send(self._link, bytes))
 
   def drained(self):
-    pn_drained(self._link)
+    pn_link_drained(self._link)
 
 class Receiver(Link):
 
   def flow(self, n):
-    pn_flow(self._link, n)
+    pn_link_flow(self._link, n)
 
   def recv(self, limit):
-    n, bytes = pn_recv(self._link, limit)
+    n, bytes = pn_link_recv(self._link, limit)
     if n == PN_EOS:
       return None
     else:
@@ -1387,11 +1387,11 @@ class Receiver(Link):
       return bytes
 
   def drain(self, n):
-    pn_drain(self._link, n)
+    pn_link_drain(self._link, n)
 
 def wrap_delivery(dlv):
   if not dlv: return None
-  ctx = pn_delivery_context(dlv)
+  ctx = pn_delivery_get_context(dlv)
   if ctx: return ctx
   wrapper = Delivery(dlv)
   pn_delivery_set_context(dlv, wrapper)
@@ -1410,33 +1410,33 @@ class Delivery(object):
 
   @property
   def writable(self):
-    return pn_writable(self._dlv)
+    return pn_delivery_writable(self._dlv)
 
   @property
   def readable(self):
-    return pn_readable(self._dlv)
+    return pn_delivery_readable(self._dlv)
 
   @property
   def updated(self):
-    return pn_updated(self._dlv)
+    return pn_delivery_updated(self._dlv)
 
-  def disposition(self, disp):
-    pn_disposition(self._dlv, disp)
+  def update(self, state):
+    pn_delivery_update(self._dlv, state)
 
   @property
-  def local_disposition(self):
-    return pn_local_disposition(self._dlv)
+  def local_state(self):
+    return pn_delivery_local_state(self._dlv)
 
   @property
-  def remote_disposition(self):
-    return pn_remote_disposition(self._dlv)
+  def remote_state(self):
+    return pn_delivery_remote_state(self._dlv)
 
   @property
-  def remote_settled(self):
-    return pn_remote_settled(self._dlv)
+  def settled(self):
+    return pn_delivery_settled(self._dlv)
 
   def settle(self):
-    pn_settle(self._dlv)
+    pn_delivery_settle(self._dlv)
 
   @property
   def work_next(self):
@@ -1470,13 +1470,13 @@ class Transport(object):
     self._check(pn_transport_bind(self._trans, connection._conn))
 
   def trace(self, n):
-    pn_trace(self._trans, n)
+    pn_transport_trace(self._trans, n)
 
   def tick(self, now):
-    return pn_tick(self._trans, now)
+    return pn_transport_tick(self._trans, now)
 
   def output(self, n):
-    cd, out = pn_output(self._trans, n)
+    cd, out = pn_transport_output(self._trans, n)
     if cd == PN_EOS:
       return None
     else:
@@ -1484,7 +1484,7 @@ class Transport(object):
       return out
 
   def input(self, binary):
-    n = pn_input(self._trans, binary)
+    n = pn_transport_input(self._trans, binary)
     if n == PN_EOS:
       return None
     else:

Modified: qpid/proton/trunk/proton-c/bindings/python/python.i
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/proton-c/bindings/python/python.i?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/proton-c/bindings/python/python.i (original)
+++ qpid/proton/trunk/proton-c/bindings/python/python.i Tue Oct  2 12:54:44 2012
@@ -79,13 +79,13 @@ int pn_message_save_amqp(pn_message_t *m
 int pn_message_save_json(pn_message_t *msg, char *OUTPUT, size_t *OUTPUT_SIZE);
 %ignore pn_message_save_json;
 
-ssize_t pn_send(pn_link_t *transport, char *STRING, size_t LENGTH);
-%ignore pn_send;
+ssize_t pn_link_send(pn_link_t *transport, char *STRING, size_t LENGTH);
+%ignore pn_link_send;
 
-%rename(pn_recv) wrap_pn_recv;
+%rename(pn_link_recv) wrap_pn_link_recv;
 %inline %{
-  int wrap_pn_recv(pn_link_t *link, char *OUTPUT, size_t *OUTPUT_SIZE) {
-    ssize_t sz = pn_recv(link, OUTPUT, *OUTPUT_SIZE);
+  int wrap_pn_link_recv(pn_link_t *link, char *OUTPUT, size_t *OUTPUT_SIZE) {
+    ssize_t sz = pn_link_recv(link, OUTPUT, *OUTPUT_SIZE);
     if (sz >= 0) {
       *OUTPUT_SIZE = sz;
     } else {
@@ -94,15 +94,15 @@ ssize_t pn_send(pn_link_t *transport, ch
     return sz;
   }
 %}
-%ignore pn_recv;
+%ignore pn_link_recv;
 
-ssize_t pn_input(pn_transport_t *transport, char *STRING, size_t LENGTH);
-%ignore pn_input;
+ssize_t pn_transport_input(pn_transport_t *transport, char *STRING, size_t LENGTH);
+%ignore pn_transport_input;
 
-%rename(pn_output) wrap_pn_output;
+%rename(pn_transport_output) wrap_pn_transport_output;
 %inline %{
-  int wrap_pn_output(pn_transport_t *transport, char *OUTPUT, size_t *OUTPUT_SIZE) {
-    ssize_t sz = pn_output(transport, OUTPUT, *OUTPUT_SIZE);
+  int wrap_pn_transport_output(pn_transport_t *transport, char *OUTPUT, size_t *OUTPUT_SIZE) {
+    ssize_t sz = pn_transport_output(transport, OUTPUT, *OUTPUT_SIZE);
     if (sz >= 0) {
       *OUTPUT_SIZE = sz;
     } else {
@@ -111,7 +111,7 @@ ssize_t pn_input(pn_transport_t *transpo
     return sz;
   }
 %}
-%ignore pn_output;
+%ignore pn_transport_output;
 
 %rename(pn_delivery) wrap_pn_delivery;
 %inline %{
@@ -222,10 +222,10 @@ ssize_t pn_input(pn_transport_t *transpo
 %}
 %ignore pn_connector_free;
 
-%rename(pn_connection_context) wrap_pn_connection_context;
+%rename(pn_connection_get_context) wrap_pn_connection_get_context;
 %inline {
-  PyObject *wrap_pn_connection_context(pn_connection_t *c) {
-    PyObject *result = pn_connection_context(c);
+  PyObject *wrap_pn_connection_get_context(pn_connection_t *c) {
+    PyObject *result = pn_connection_get_context(c);
     if (result) {
       Py_INCREF(result);
       return result;
@@ -234,12 +234,12 @@ ssize_t pn_input(pn_transport_t *transpo
     }
   }
 }
-%ignore pn_connection_context;
+%ignore pn_connection_get_context;
 
 %rename(pn_connection_set_context) wrap_pn_connection_set_context;
 %inline {
   void wrap_pn_connection_set_context(pn_connection_t *c, PyObject *context) {
-    Py_XDECREF(pn_connection_context(c));
+    Py_XDECREF(pn_connection_get_context(c));
     Py_XINCREF(context);
     pn_connection_set_context(c, context);
   }
@@ -249,17 +249,17 @@ ssize_t pn_input(pn_transport_t *transpo
 %rename(pn_connection_free) wrap_pn_connection_free;
 %inline %{
   void wrap_pn_connection_free(pn_connection_t *c) {
-    PyObject *obj = pn_connection_context(c);
+    PyObject *obj = pn_connection_get_context(c);
     Py_XDECREF(obj);
     pn_connection_free(c);
   }
 %}
 %ignore pn_connection_free;
 
-%rename(pn_session_context) wrap_pn_session_context;
+%rename(pn_session_get_context) wrap_pn_session_get_context;
 %inline {
-  PyObject *wrap_pn_session_context(pn_session_t *s) {
-    PyObject *result = pn_session_context(s);
+  PyObject *wrap_pn_session_get_context(pn_session_t *s) {
+    PyObject *result = pn_session_get_context(s);
     if (result) {
       Py_INCREF(result);
       return result;
@@ -268,12 +268,12 @@ ssize_t pn_input(pn_transport_t *transpo
     }
   }
 }
-%ignore pn_session_context;
+%ignore pn_session_get_context;
 
 %rename(pn_session_set_context) wrap_pn_session_set_context;
 %inline {
   void wrap_pn_session_set_context(pn_session_t *s, PyObject *context) {
-    Py_XDECREF(pn_session_context(s));
+    Py_XDECREF(pn_session_get_context(s));
     Py_XINCREF(context);
     pn_session_set_context(s, context);
   }
@@ -283,17 +283,17 @@ ssize_t pn_input(pn_transport_t *transpo
 %rename(pn_session_free) wrap_pn_session_free;
 %inline %{
   void wrap_pn_session_free(pn_session_t *s) {
-    PyObject *obj = pn_session_context(s);
+    PyObject *obj = pn_session_get_context(s);
     Py_XDECREF(obj);
     pn_session_free(s);
   }
 %}
 %ignore pn_session_free;
 
-%rename(pn_link_context) wrap_pn_link_context;
+%rename(pn_link_get_context) wrap_pn_link_get_context;
 %inline {
-  PyObject *wrap_pn_link_context(pn_link_t *l) {
-    PyObject *result = pn_link_context(l);
+  PyObject *wrap_pn_link_get_context(pn_link_t *l) {
+    PyObject *result = pn_link_get_context(l);
     if (result) {
       Py_INCREF(result);
       return result;
@@ -302,12 +302,12 @@ ssize_t pn_input(pn_transport_t *transpo
     }
   }
 }
-%ignore pn_link_context;
+%ignore pn_link_get_context;
 
 %rename(pn_link_set_context) wrap_pn_link_set_context;
 %inline {
   void wrap_pn_link_set_context(pn_link_t *l, PyObject *context) {
-    Py_XDECREF(pn_link_context(l));
+    Py_XDECREF(pn_link_get_context(l));
     Py_XINCREF(context);
     pn_link_set_context(l, context);
   }
@@ -317,17 +317,17 @@ ssize_t pn_input(pn_transport_t *transpo
 %rename(pn_link_free) wrap_pn_link_free;
 %inline %{
   void wrap_pn_link_free(pn_link_t *l) {
-    PyObject *obj = pn_link_context(l);
+    PyObject *obj = pn_link_get_context(l);
     Py_XDECREF(obj);
     pn_link_free(l);
   }
 %}
 %ignore pn_link_free;
 
-%rename(pn_delivery_context) wrap_pn_delivery_context;
+%rename(pn_delivery_get_context) wrap_pn_delivery_get_context;
 %inline {
-  PyObject *wrap_pn_delivery_context(pn_delivery_t *d) {
-    PyObject *result = pn_delivery_context(d);
+  PyObject *wrap_pn_delivery_get_context(pn_delivery_t *d) {
+    PyObject *result = pn_delivery_get_context(d);
     if (result) {
       Py_INCREF(result);
       return result;
@@ -336,27 +336,27 @@ ssize_t pn_input(pn_transport_t *transpo
     }
   }
 }
-%ignore pn_delivery_context;
+%ignore pn_delivery_get_context;
 
 %rename(pn_delivery_set_context) wrap_pn_delivery_set_context;
 %inline {
   void wrap_pn_delivery_set_context(pn_delivery_t *d, PyObject *context) {
-    Py_XDECREF(pn_delivery_context(d));
+    Py_XDECREF(pn_delivery_get_context(d));
     Py_XINCREF(context);
     pn_delivery_set_context(d, context);
   }
 }
 %ignore pn_delivery_set_context;
 
-%rename(pn_settle) wrap_pn_settle;
+%rename(pn_delivery_settle) wrap_pn_delivery_settle;
 %inline %{
-  void wrap_pn_settle(pn_delivery_t *d) {
-    PyObject *obj = pn_delivery_context(d);
+  void wrap_pn_delivery_settle(pn_delivery_t *d) {
+    PyObject *obj = pn_delivery_get_context(d);
     Py_XDECREF(obj);
-    pn_settle(d);
+    pn_delivery_settle(d);
   }
 %}
-%ignore pn_settle;
+%ignore pn_delivery_settle;
 
 ssize_t pn_data_decode(pn_data_t *data, char *STRING, size_t LENGTH);
 %ignore pn_data_decode;

Modified: qpid/proton/trunk/proton-c/bindings/ruby/ruby.i
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/proton-c/bindings/ruby/ruby.i?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/proton-c/bindings/ruby/ruby.i (original)
+++ qpid/proton/trunk/proton-c/bindings/ruby/ruby.i Tue Oct  2 12:54:44 2012
@@ -88,13 +88,13 @@ int pn_message_save_amqp(pn_message_t *m
 int pn_message_save_json(pn_message_t *msg, char *OUTPUT, size_t *OUTPUT_SIZE);
 %ignore pn_message_save_json;
 
-ssize_t pn_send(pn_link_t *transport, char *STRING, size_t LENGTH);
-%ignore pn_send;
+ssize_t pn_link_send(pn_link_t *transport, char *STRING, size_t LENGTH);
+%ignore pn_link_send;
 
-%rename(pn_recv) wrap_pn_recv;
+%rename(pn_link_recv) wrap_pn_link_recv;
 %inline %{
-  int wrap_pn_recv(pn_link_t *link, char *OUTPUT, size_t *OUTPUT_SIZE) {
-    ssize_t sz = pn_recv(link, OUTPUT, *OUTPUT_SIZE);
+  int wrap_pn_link_recv(pn_link_t *link, char *OUTPUT, size_t *OUTPUT_SIZE) {
+    ssize_t sz = pn_link_recv(link, OUTPUT, *OUTPUT_SIZE);
     if (sz >= 0) {
       *OUTPUT_SIZE = sz;
     } else {
@@ -103,15 +103,15 @@ ssize_t pn_send(pn_link_t *transport, ch
     return sz;
   }
 %}
-%ignore pn_recv;
+%ignore pn_link_recv;
 
-ssize_t pn_input(pn_transport_t *transport, char *STRING, size_t LENGTH);
-%ignore pn_input;
+ssize_t pn_transport_input(pn_transport_t *transport, char *STRING, size_t LENGTH);
+%ignore pn_transport_input;
 
-%rename(pn_output) wrap_pn_output;
+%rename(pn_transport_output) wrap_pn_transport_output;
 %inline %{
-  int wrap_pn_output(pn_transport_t *transport, char *OUTPUT, size_t *OUTPUT_SIZE) {
-    ssize_t sz = pn_output(transport, OUTPUT, *OUTPUT_SIZE);
+  int wrap_pn_transport_output(pn_transport_t *transport, char *OUTPUT, size_t *OUTPUT_SIZE) {
+    ssize_t sz = pn_transport_output(transport, OUTPUT, *OUTPUT_SIZE);
     if (sz >= 0) {
       *OUTPUT_SIZE = sz;
     } else {
@@ -120,7 +120,7 @@ ssize_t pn_input(pn_transport_t *transpo
     return sz;
   }
 %}
-%ignore pn_output;
+%ignore pn_transport_output;
 
 %rename(pn_delivery) wrap_pn_delivery;
 %inline %{

Modified: qpid/proton/trunk/proton-c/include/proton/cproton.i
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/proton-c/include/proton/cproton.i?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/proton-c/include/proton/cproton.i (original)
+++ qpid/proton/trunk/proton-c/include/proton/cproton.i Tue Oct  2 12:54:44 2012
@@ -105,7 +105,7 @@
   connection != NULL;
 }
 
-%contract pn_connection_container(pn_connection_t *connection)
+%contract pn_connection_get_container(pn_connection_t *connection)
 {
  require:
   connection != NULL;
@@ -117,7 +117,7 @@
   connection != NULL;
 }
 
-%contract pn_connection_hostname(pn_connection_t *connection)
+%contract pn_connection_get_hostname(pn_connection_t *connection)
 {
  require:
   connection != NULL;
@@ -217,24 +217,24 @@
   transport != NULL;
 }
 
-%contract pn_input(pn_transport_t *transport, char *bytes, size_t available)
+%contract pn_transport_input(pn_transport_t *transport, char *bytes, size_t available)
 {
  require:
   transport != NULL;
 }
 
-%contract pn_output(pn_transport_t *transport, char *bytes, size_t size)
+%contract pn_transport_output(pn_transport_t *transport, char *bytes, size_t size)
 {
  require:
   transport != NULL;
 }
 
-#%contract pn_tick(pn_transport_t *transport, time_t now)
+#%contract pn_transport_tick(pn_transport_t *transport, time_t now)
 #{
 #  # this method currently always returns 0
 #}
 
-%contract pn_trace(pn_transport_t *transport, pn_trace_t trace)
+%contract pn_transport_trace(pn_transport_t *transport, pn_trace_t trace)
 {
  require:
   transport != NULL;
@@ -274,12 +274,12 @@
   pn_receiver != NULL;
 }
 
-%contract pn_get_connection(pn_session_t *session)
+%contract pn_session_connection(pn_session_t *session)
 {
  require:
   session != NULL;
  ensure:
-  pn_get_connection != NULL;
+  pn_session_connection != NULL;
 }
 
 %contract pn_session_open(pn_session_t *session)
@@ -306,13 +306,13 @@
   link != NULL;
 }
 
-%contract pn_is_sender(pn_link_t *link)
+%contract pn_link_is_sender(pn_link_t *link)
 {
  require:
   link != NULL;
 }
 
-%contract pn_is_receiver(pn_link_t *link)
+%contract pn_link_is_receiver(pn_link_t *link)
 {
  require:
   link != NULL;
@@ -330,45 +330,45 @@
   link != NULL;
 }
 
-%contract pn_get_session(pn_link_t *link)
+%contract pn_link_session(pn_link_t *link)
 {
  require:
   link != NULL;
  ensure:
-  pn_get_session != NULL;
+  pn_link_session != NULL;
 }
 
-%contract pn_target(pn_link_t *link)
+%contract pn_link_get_target(pn_link_t *link)
 {
  require:
   link != NULL;
 }
 
-%contract pn_source(pn_link_t *link)
+%contract pn_link_get_source(pn_link_t *link)
 {
  require:
   link != NULL;
 }
 
-%contract pn_set_source(pn_link_t *link, const char *source)
+%contract pn_link_set_source(pn_link_t *link, const char *source)
 {
  require:
   link != NULL;
 }
 
-%contract pn_set_target(pn_link_t *link, const char *target)
+%contract pn_link_set_target(pn_link_t *link, const char *target)
 {
  require:
   link != NULL;
 }
 
-%contract pn_remote_source(pn_link_t *link)
+%contract pn_link_remote_source(pn_link_t *link)
 {
  require:
   link != NULL;
 }
 
-%contract pn_remote_target(pn_link_t *link)
+%contract pn_link_remote_target(pn_link_t *link)
 {
  require:
   link != NULL;
@@ -382,31 +382,31 @@
   pn_delivery != NULL;
 }
 
-%contract pn_current(pn_link_t *link)
+%contract pn_link_current(pn_link_t *link)
 {
  require:
   link != NULL;
 }
 
-%contract pn_advance(pn_link_t *link)
+%contract pn_link_advance(pn_link_t *link)
 {
  require:
   link != NULL;
 }
 
-%contract pn_credit(pn_link_t *link)
+%contract pn_link_credit(pn_link_t *link)
 {
  require:
   link != NULL;
 }
 
-%contract pn_queued(pn_link_t *link)
+%contract pn_link_queued(pn_link_t *link)
 {
  require:
   link != NULL;
 }
 
-%contract pn_unsettled(pn_link_t *link)
+%contract pn_link_unsettled(pn_link_t *link)
 {
  require:
   link != NULL;
@@ -442,31 +442,31 @@
   sender != NULL;
 }
 
-%contract pn_send(pn_link_t *sender, const char *bytes, size_t n)
+%contract pn_link_send(pn_link_t *sender, const char *bytes, size_t n)
 {
  require:
   sender != NULL;
 }
 
-%contract pn_drained(pn_link_t *sender)
+%contract pn_link_drained(pn_link_t *sender)
 {
  require:
   sender != NULL;
 }
 
-%contract pn_flow(pn_link_t *receiver, int credit)
+%contract pn_link_flow(pn_link_t *receiver, int credit)
 {
  require:
   receiver != NULL;
 }
 
-%contract pn_drain(pn_link_t *receiver, int credit)
+%contract pn_link_drain(pn_link_t *receiver, int credit)
 {
  require:
   receiver != NULL;
 }
 
-%contract pn_recv(pn_link_t *receiver, char *bytes, size_t n)
+%contract pn_link_recv(pn_link_t *receiver, char *bytes, size_t n)
 {
  require:
   receiver != NULL;
@@ -478,68 +478,68 @@
   delivery != NULL;
 }
 
-%contract pn_link(pn_delivery_t *delivery)
+%contract pn_delivery_link(pn_delivery_t *delivery)
 {
  require:
   delivery != NULL;
 }
 
-%contract pn_local_disposition(pn_delivery_t *delivery)
+%contract pn_delivery_local_state(pn_delivery_t *delivery)
 {
  require:
   delivery != NULL;
 }
 
-%contract pn_remote_disposition(pn_delivery_t *delivery)
+%contract pn_delivery_remote_state(pn_delivery_t *delivery)
 {
  require:
   delivery != NULL;
 }
 
-%contract pn_remote_settled(pn_delivery_t *delivery)
+%contract pn_delivery_settled(pn_delivery_t *delivery)
 {
  require:
   delivery != NULL;
 }
 
-%contract pn_pending(pn_delivery_t *delivery)
+%contract pn_delivery_pending(pn_delivery_t *delivery)
 {
  require:
   delivery != NULL;
 }
 
-%contract pn_writable(pn_delivery_t *delivery)
+%contract pn_delivery_writable(pn_delivery_t *delivery)
 {
  require:
   delivery != NULL;
 }
 
-%contract pn_readable(pn_delivery_t *delivery)
+%contract pn_delivery_readable(pn_delivery_t *delivery)
 {
  require:
   delivery != NULL;
 }
 
-%contract pn_updated(pn_delivery_t *delivery)
+%contract pn_delivery_updated(pn_delivery_t *delivery)
 {
  require:
   delivery != NULL;
 }
 
-%contract pn_clear(pn_delivery_t *delivery)
+%contract pn_delivery_clear(pn_delivery_t *delivery)
 {
  require:
   delivery != NULL;
 }
 
-%contract pn_disposition(pn_delivery_t *delivery, pn_disposition_t disposition)
+%contract pn_delivery_update(pn_delivery_t *delivery, pn_disposition_t disposition)
 {
  require:
   delivery != NULL;
   check_disposition(disposition);
 }
 
-%contract pn_settle(pn_delivery_t *delivery)
+%contract pn_delivery_settle(pn_delivery_t *delivery)
 {
  require:
   delivery != NULL;

Modified: qpid/proton/trunk/proton-c/include/proton/engine.h
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/proton-c/include/proton/engine.h?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/proton-c/include/proton/engine.h (original)
+++ qpid/proton/trunk/proton-c/include/proton/engine.h Tue Oct  2 12:54:44 2012
@@ -101,11 +101,11 @@ pn_state_t pn_connection_state(pn_connec
 /** @todo: needs documentation */
 pn_error_t *pn_connection_error(pn_connection_t *connection);
 /** @todo: needs documentation */
-const char *pn_connection_container(pn_connection_t *connection);
+const char *pn_connection_get_container(pn_connection_t *connection);
 /** @todo: needs documentation */
 void pn_connection_set_container(pn_connection_t *connection, const char *container);
 /** @todo: needs documentation */
-const char *pn_connection_hostname(pn_connection_t *connection);
+const char *pn_connection_get_hostname(pn_connection_t *connection);
 /** @todo: needs documentation */
 void pn_connection_set_hostname(pn_connection_t *connection, const char *hostname);
 const char *pn_connection_remote_container(pn_connection_t *connection);
@@ -236,7 +236,7 @@ void pn_connection_free(pn_connection_t 
  *
  * @return the application context that was passed to pn_connection_set_context()
  */
-void *pn_connection_context(pn_connection_t *connection);
+void *pn_connection_get_context(pn_connection_t *connection);
 
 /** Assign a new application context to the connection.
  *
@@ -249,81 +249,81 @@ void pn_connection_set_context(pn_connec
 
 // transport
 pn_error_t *pn_transport_error(pn_transport_t *transport);
-ssize_t pn_input(pn_transport_t *transport, char *bytes, size_t available);
-ssize_t pn_output(pn_transport_t *transport, char *bytes, size_t size);
-time_t pn_tick(pn_transport_t *transport, time_t now);
-void pn_trace(pn_transport_t *transport, pn_trace_t trace);
+ssize_t pn_transport_input(pn_transport_t *transport, char *bytes, size_t available);
+ssize_t pn_transport_output(pn_transport_t *transport, char *bytes, size_t size);
+time_t pn_transport_tick(pn_transport_t *transport, time_t now);
+void pn_transport_trace(pn_transport_t *transport, pn_trace_t trace);
 void pn_transport_free(pn_transport_t *transport);
 
 // session
 pn_state_t pn_session_state(pn_session_t *session);
 pn_error_t *pn_session_error(pn_session_t *session);
-pn_link_t *pn_sender(pn_session_t *session, const char *name);
-pn_link_t *pn_receiver(pn_session_t *session, const char *name);
-pn_connection_t *pn_get_connection(pn_session_t *session);
+pn_connection_t *pn_session_connection(pn_session_t *session);
 void pn_session_open(pn_session_t *session);
 void pn_session_close(pn_session_t *session);
 void pn_session_free(pn_session_t *session);
-void *pn_session_context(pn_session_t *session);
+void *pn_session_get_context(pn_session_t *session);
 void pn_session_set_context(pn_session_t *session, void *context);
 
 // link
+pn_link_t *pn_sender(pn_session_t *session, const char *name);
+pn_link_t *pn_receiver(pn_session_t *session, const char *name);
 const char *pn_link_name(pn_link_t *link);
-bool pn_is_sender(pn_link_t *link);
-bool pn_is_receiver(pn_link_t *link);
+bool pn_link_is_sender(pn_link_t *link);
+bool pn_link_is_receiver(pn_link_t *link);
 pn_state_t pn_link_state(pn_link_t *link);
 pn_error_t *pn_link_error(pn_link_t *link);
-pn_session_t *pn_get_session(pn_link_t *link);
-const char *pn_target(pn_link_t *link);
-const char *pn_source(pn_link_t *link);
-void pn_set_source(pn_link_t *link, const char *source);
-void pn_set_target(pn_link_t *link, const char *target);
-const char *pn_remote_source(pn_link_t *link);
-const char *pn_remote_target(pn_link_t *link);
-pn_delivery_t *pn_delivery(pn_link_t *link, pn_delivery_tag_t tag);
-pn_delivery_t *pn_current(pn_link_t *link);
-bool pn_advance(pn_link_t *link);
-int pn_credit(pn_link_t *link);
-int pn_queued(pn_link_t *link);
+pn_session_t *pn_link_session(pn_link_t *link);
+const char *pn_link_get_target(pn_link_t *link);
+const char *pn_link_get_source(pn_link_t *link);
+void pn_link_set_source(pn_link_t *link, const char *source);
+void pn_link_set_target(pn_link_t *link, const char *target);
+const char *pn_link_remote_source(pn_link_t *link);
+const char *pn_link_remote_target(pn_link_t *link);
+pn_delivery_t *pn_link_current(pn_link_t *link);
+bool pn_link_advance(pn_link_t *link);
+int pn_link_credit(pn_link_t *link);
+int pn_link_queued(pn_link_t *link);
 
-int pn_unsettled(pn_link_t *link);
+int pn_link_unsettled(pn_link_t *link);
 pn_delivery_t *pn_unsettled_head(pn_link_t *link);
 pn_delivery_t *pn_unsettled_next(pn_delivery_t *delivery);
 
 void pn_link_open(pn_link_t *sender);
 void pn_link_close(pn_link_t *sender);
 void pn_link_free(pn_link_t *sender);
-void *pn_link_context(pn_link_t *link);
+void *pn_link_get_context(pn_link_t *link);
 void pn_link_set_context(pn_link_t *link, void *context);
 
 // sender
-//void pn_offer(pn_sender_t *sender, int credits);
-ssize_t pn_send(pn_link_t *sender, const char *bytes, size_t n);
-void pn_drained(pn_link_t *sender);
-//void pn_abort(pn_sender_t *sender);
+//void pn_link_offer(pn_sender_t *sender, int credits);
+ssize_t pn_link_send(pn_link_t *sender, const char *bytes, size_t n);
+void pn_link_drained(pn_link_t *sender);
+//void pn_link_abort(pn_sender_t *sender);
 
 // receiver
-void pn_flow(pn_link_t *receiver, int credit);
-void pn_drain(pn_link_t *receiver, int credit);
-ssize_t pn_recv(pn_link_t *receiver, char *bytes, size_t n);
+void pn_link_flow(pn_link_t *receiver, int credit);
+void pn_link_drain(pn_link_t *receiver, int credit);
+ssize_t pn_link_recv(pn_link_t *receiver, char *bytes, size_t n);
 
 // delivery
+pn_delivery_t *pn_delivery(pn_link_t *link, pn_delivery_tag_t tag);
 pn_delivery_tag_t pn_delivery_tag(pn_delivery_t *delivery);
-pn_link_t *pn_link(pn_delivery_t *delivery);
+pn_link_t *pn_delivery_link(pn_delivery_t *delivery);
 // how do we do delivery state?
-int pn_local_disposition(pn_delivery_t *delivery);
-int pn_remote_disposition(pn_delivery_t *delivery);
-bool pn_remote_settled(pn_delivery_t *delivery);
-size_t pn_pending(pn_delivery_t *delivery);
-bool pn_writable(pn_delivery_t *delivery);
-bool pn_readable(pn_delivery_t *delivery);
-bool pn_updated(pn_delivery_t *delivery);
-void pn_clear(pn_delivery_t *delivery);
-void pn_disposition(pn_delivery_t *delivery, pn_disposition_t disposition);
-//int pn_format(pn_delivery_t *delivery);
-void pn_settle(pn_delivery_t *delivery);
+pn_disposition_t pn_delivery_local_state(pn_delivery_t *delivery);
+pn_disposition_t pn_delivery_remote_state(pn_delivery_t *delivery);
+bool pn_delivery_settled(pn_delivery_t *delivery);
+size_t pn_delivery_pending(pn_delivery_t *delivery);
+bool pn_delivery_writable(pn_delivery_t *delivery);
+bool pn_delivery_readable(pn_delivery_t *delivery);
+bool pn_delivery_updated(pn_delivery_t *delivery);
+void pn_delivery_update(pn_delivery_t *delivery, pn_disposition_t disposition);
+void pn_delivery_clear(pn_delivery_t *delivery);
+//int pn_delivery_format(pn_delivery_t *delivery);
+void pn_delivery_settle(pn_delivery_t *delivery);
 void pn_delivery_dump(pn_delivery_t *delivery);
-void *pn_delivery_context(pn_delivery_t *delivery);
+void *pn_delivery_get_context(pn_delivery_t *delivery);
 void pn_delivery_set_context(pn_delivery_t *delivery, void *context);
 
 #ifdef __cplusplus

Modified: qpid/proton/trunk/proton-c/src/driver.c
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/proton-c/src/driver.c?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/proton-c/src/driver.c (original)
+++ qpid/proton/trunk/proton-c/src/driver.c Tue Oct  2 12:54:44 2012
@@ -384,7 +384,7 @@ void pn_connector_trace(pn_connector_t *
 {
   if (!ctor) return;
   ctor->trace = trace;
-  if (ctor->transport) pn_trace(ctor->transport, trace);
+  if (ctor->transport) pn_transport_trace(ctor->transport, trace);
 }
 
 pn_sasl_t *pn_connector_sasl(pn_connector_t *ctor)
@@ -402,7 +402,7 @@ void pn_connector_set_connection(pn_conn
   if (!ctor) return;
   ctor->connection = connection;
   pn_transport_bind(ctor->transport, connection);
-  if (ctor->transport) pn_trace(ctor->transport, ctor->trace);
+  if (ctor->transport) pn_transport_trace(ctor->transport, ctor->trace);
 }
 
 pn_connection_t *pn_connector_connection(pn_connector_t *ctor)
@@ -477,7 +477,7 @@ static void pn_connector_process_input(p
   pn_transport_t *transport = ctor->transport;
   if (!ctor->input_done) {
     if (ctor->input_size > 0 || ctor->input_eos) {
-      ssize_t n = pn_input(transport, ctor->input, ctor->input_size);
+      ssize_t n = pn_transport_input(transport, ctor->input, ctor->input_size);
       if (n >= 0) {
         pn_connector_consume(ctor, n);
       } else {
@@ -502,7 +502,8 @@ static void pn_connector_process_output(
 {
   pn_transport_t *transport = ctor->transport;
   if (!ctor->output_done) {
-    ssize_t n = pn_output(transport, pn_connector_output(ctor), pn_connector_available(ctor));
+    ssize_t n = pn_transport_output(transport, pn_connector_output(ctor),
+                                    pn_connector_available(ctor));
     if (n >= 0) {
       ctor->output_size += n;
     } else {
@@ -538,7 +539,7 @@ static time_t pn_connector_tick(pn_conne
 {
   if (!ctor->transport) return 0;
   // XXX: should probably have a function pointer for this and switch it with different layers
-  time_t result = pn_tick(ctor->transport, now);
+  time_t result = pn_transport_tick(ctor->transport, now);
   pn_connector_process_input(ctor);
   pn_connector_process_output(ctor);
   return result;

Modified: qpid/proton/trunk/proton-c/src/engine/engine.c
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/proton-c/src/engine/engine.c?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/proton-c/src/engine/engine.c (original)
+++ qpid/proton/trunk/proton-c/src/engine/engine.c Tue Oct  2 12:54:44 2012
@@ -205,7 +205,7 @@ void pn_connection_free(pn_connection_t 
   free(connection);
 }
 
-void *pn_connection_context(pn_connection_t *conn)
+void *pn_connection_get_context(pn_connection_t *conn)
 {
     return conn ? conn->context : 0;
 }
@@ -269,7 +269,7 @@ void pn_remove_session(pn_connection_t *
   ssn->connection = NULL;
 }
 
-pn_connection_t *pn_get_connection(pn_session_t *session)
+pn_connection_t *pn_session_connection(pn_session_t *session)
 {
   return session ? session->connection : NULL;
 }
@@ -297,7 +297,7 @@ void pn_session_free(pn_session_t *sessi
   free(session);
 }
 
-void *pn_session_context(pn_session_t *session)
+void *pn_session_get_context(pn_session_t *session)
 {
     return session ? session->context : 0;
 }
@@ -374,7 +374,7 @@ void pn_link_free(pn_link_t *link)
   free(link);
 }
 
-void *pn_link_context(pn_link_t *link)
+void *pn_link_get_context(pn_link_t *link)
 {
     return link ? link->context : 0;
 }
@@ -439,7 +439,7 @@ pn_error_t *pn_connection_error(pn_conne
   return connection ? connection->endpoint.error : NULL;
 }
 
-const char *pn_connection_container(pn_connection_t *connection)
+const char *pn_connection_get_container(pn_connection_t *connection)
 {
   return connection ? connection->container : NULL;
 }
@@ -451,7 +451,7 @@ void pn_connection_set_container(pn_conn
   connection->container = pn_strdup(container);
 }
 
-const char *pn_connection_hostname(pn_connection_t *connection)
+const char *pn_connection_get_hostname(pn_connection_t *connection)
 {
   return connection ? connection->hostname : NULL;
 }
@@ -511,13 +511,13 @@ void pn_clear_work(pn_connection_t *conn
 
 void pn_work_update(pn_connection_t *connection, pn_delivery_t *delivery)
 {
-  pn_link_t *link = pn_link(delivery);
-  pn_delivery_t *current = pn_current(link);
+  pn_link_t *link = pn_delivery_link(delivery);
+  pn_delivery_t *current = pn_link_current(link);
   if (delivery->updated && !delivery->local_settled) {
     pn_add_work(connection, delivery);
   } else if (delivery == current) {
     if (link->endpoint.type == SENDER) {
-      if (pn_credit(link) > 0) {
+      if (pn_link_credit(link) > 0) {
         pn_add_work(connection, delivery);
       } else {
         pn_clear_work(connection, delivery);
@@ -821,36 +821,36 @@ void pn_link_init(pn_link_t *link, int t
   link->context = 0;
 }
 
-const char *pn_source(pn_link_t *link)
+const char *pn_link_get_source(pn_link_t *link)
 {
   return link ? link->local_source : NULL;
 }
 
-const char *pn_target(pn_link_t *link)
+const char *pn_link_get_target(pn_link_t *link)
 {
   return link ? link->local_target : NULL;
 }
 
-void pn_set_source(pn_link_t *link, const char *source)
+void pn_link_set_source(pn_link_t *link, const char *source)
 {
   if (!link) return;
   if (link->local_source) free(link->local_source);
   link->local_source = pn_strdup(source);
 }
 
-void pn_set_target(pn_link_t *link, const char *target)
+void pn_link_set_target(pn_link_t *link, const char *target)
 {
   if (!link) return;
   if (link->local_target) free(link->local_target);
   link->local_target = pn_strdup(target);
 }
 
-const char *pn_remote_source(pn_link_t *link)
+const char *pn_link_remote_source(pn_link_t *link)
 {
   return link ? link->remote_source : NULL;
 }
 
-const char *pn_remote_target(pn_link_t *link)
+const char *pn_link_remote_target(pn_link_t *link)
 {
   return link ? link->remote_target : NULL;
 }
@@ -915,17 +915,17 @@ const char *pn_link_name(pn_link_t *link
   return link ? link->name : NULL;
 }
 
-bool pn_is_sender(pn_link_t *link)
+bool pn_link_is_sender(pn_link_t *link)
 {
   return link->endpoint.type == SENDER;
 }
 
-bool pn_is_receiver(pn_link_t *link)
+bool pn_link_is_receiver(pn_link_t *link)
 {
   return link->endpoint.type == RECEIVER;
 }
 
-pn_session_t *pn_get_session(pn_link_t *link)
+pn_session_t *pn_link_session(pn_link_t *link)
 {
   return link->session;
 }
@@ -972,7 +972,7 @@ pn_delivery_t *pn_delivery(pn_link_t *li
   return delivery;
 }
 
-int pn_unsettled(pn_link_t *link)
+int pn_link_unsettled(pn_link_t *link)
 {
   return link->unsettled_count;
 }
@@ -990,7 +990,7 @@ pn_delivery_t *pn_unsettled_next(pn_deli
 bool pn_is_current(pn_delivery_t *delivery)
 {
   pn_link_t *link = delivery->link;
-  return pn_current(link) == delivery;
+  return pn_link_current(link) == delivery;
 }
 
 void pn_delivery_dump(pn_delivery_t *d)
@@ -1002,11 +1002,11 @@ void pn_delivery_dump(pn_delivery_t *d)
          "remote_settled=%u, updated=%u, current=%u, writable=%u, readable=%u, "
          "work=%u}",
          tag, d->local_state, d->remote_state, d->local_settled,
-         d->remote_settled, d->updated, pn_is_current(d), pn_writable(d),
-         pn_readable(d), d->work);
+         d->remote_settled, d->updated, pn_is_current(d),
+         pn_delivery_writable(d), pn_delivery_readable(d), d->work);
 }
 
-void *pn_delivery_context(pn_delivery_t *delivery)
+void *pn_delivery_get_context(pn_delivery_t *delivery)
 {
     return delivery ? delivery->context : NULL;
 }
@@ -1027,7 +1027,7 @@ pn_delivery_tag_t pn_delivery_tag(pn_del
   }
 }
 
-pn_delivery_t *pn_current(pn_link_t *link)
+pn_delivery_t *pn_link_current(pn_link_t *link)
 {
   if (!link) return NULL;
   return link->current;
@@ -1049,7 +1049,7 @@ void pn_advance_receiver(pn_link_t *link
   link->current = link->current->unsettled_next;
 }
 
-bool pn_advance(pn_link_t *link)
+bool pn_link_advance(pn_link_t *link)
 {
   if (link && link->current) {
     pn_delivery_t *prev = link->current;
@@ -1067,12 +1067,12 @@ bool pn_advance(pn_link_t *link)
   }
 }
 
-int pn_credit(pn_link_t *link)
+int pn_link_credit(pn_link_t *link)
 {
   return link ? link->credit : 0;
 }
 
-int pn_queued(pn_link_t *link)
+int pn_link_queued(pn_link_t *link)
 {
   return link ? link->queued : 0;
 }
@@ -1098,13 +1098,13 @@ void pn_full_settle(pn_delivery_buffer_t
   pn_clear_tpwork(delivery);
 }
 
-void pn_settle(pn_delivery_t *delivery)
+void pn_delivery_settle(pn_delivery_t *delivery)
 {
   if (!delivery) return;
 
   pn_link_t *link = delivery->link;
   if (pn_is_current(delivery)) {
-    pn_advance(link);
+    pn_link_advance(link);
   }
 
   link->unsettled_count--;
@@ -1348,7 +1348,7 @@ int pn_do_flow(pn_dispatcher_t *disp)
       link_state->link_credit = receiver_count + link_credit - link_state->delivery_count;
       link->credit += link_state->link_credit - old;
       link->drain = drain;
-      pn_delivery_t *delivery = pn_current(link);
+      pn_delivery_t *delivery = pn_link_current(link);
       if (delivery) pn_work_update(transport->connection, delivery);
     } else {
       pn_sequence_t delta = delivery_count - link_state->delivery_count;
@@ -1461,7 +1461,7 @@ int pn_do_close(pn_dispatcher_t *disp)
   return 0;
 }
 
-ssize_t pn_input(pn_transport_t *transport, char *bytes, size_t available)
+ssize_t pn_transport_input(pn_transport_t *transport, char *bytes, size_t available)
 {
   if (!transport) return PN_ARG_ERR;
 
@@ -1577,7 +1577,7 @@ static ssize_t pn_input_read_amqp(pn_tra
 bool pn_delivery_buffered(pn_delivery_t *delivery)
 {
   if (delivery->settled) return false;
-  if (pn_is_sender(delivery->link)) {
+  if (pn_link_is_sender(delivery->link)) {
     pn_delivery_state_t *state = delivery->transport_context;
     if (state) {
       return (delivery->done && !state->sent) || pn_buffer_size(delivery->bytes) > 0;
@@ -1797,7 +1797,7 @@ int pn_process_tpwork(pn_transport_t *tr
     while (delivery)
     {
       pn_link_t *link = delivery->link;
-      if (pn_is_sender(link)) {
+      if (pn_link_is_sender(link)) {
         int err = pn_process_tpwork_sender(transport, delivery);
         if (err) return err;
       } else {
@@ -1849,7 +1849,7 @@ int pn_process_link_teardown(pn_transpor
     pn_link_state_t *state = pn_link_get_state(ssn_state, link);
     if (endpoint->state & PN_LOCAL_CLOSED && (int32_t) state->local_handle >= 0 &&
         (int16_t) ssn_state->local_channel >= 0 && !transport->close_sent) {
-      if (pn_is_sender(link) && pn_queued(link) &&
+      if (pn_link_is_sender(link) && pn_link_queued(link) &&
           (int32_t) state->remote_handle != -2 &&
           (int16_t) ssn_state->remote_channel != -2 &&
           !transport->close_rcvd) return 0;
@@ -1873,7 +1873,7 @@ bool pn_pointful_buffering(pn_transport_
   pn_connection_t *conn = transport->connection;
   pn_link_t *link = pn_link_head(conn, 0);
   while (link) {
-    if (pn_is_sender(link) && pn_queued(link) > 0) {
+    if (pn_link_is_sender(link) && pn_link_queued(link) > 0) {
       pn_session_t *ssn = link->session;
       if (session && session == ssn) {
         pn_session_state_t *ssn_state = pn_session_get_state(transport, session);
@@ -2028,7 +2028,7 @@ static ssize_t pn_output_write_amqp(pn_t
   return pn_dispatcher_output(transport->disp, bytes, size);
 }
 
-ssize_t pn_output(pn_transport_t *transport, char *bytes, size_t size)
+ssize_t pn_transport_output(pn_transport_t *transport, char *bytes, size_t size)
 {
   if (!transport) return PN_ARG_ERR;
 
@@ -2065,23 +2065,23 @@ ssize_t pn_output(pn_transport_t *transp
   return total;
 }
 
-void pn_trace(pn_transport_t *transport, pn_trace_t trace)
+void pn_transport_trace(pn_transport_t *transport, pn_trace_t trace)
 {
   if (transport->sasl) pn_sasl_trace(transport->sasl, trace);
   if (transport->ssl) pn_ssl_trace(transport->ssl, trace);
   transport->disp->trace = trace;
 }
 
-ssize_t pn_send(pn_link_t *sender, const char *bytes, size_t n)
+ssize_t pn_link_send(pn_link_t *sender, const char *bytes, size_t n)
 {
-  pn_delivery_t *current = pn_current(sender);
+  pn_delivery_t *current = pn_link_current(sender);
   if (!current) return PN_EOS;
   pn_buffer_append(current->bytes, bytes, n);
   pn_add_tpwork(current);
   return n;
 }
 
-void pn_drained(pn_link_t *sender)
+void pn_link_drained(pn_link_t *sender)
 {
   if (sender && sender->drain && sender->credit > 0) {
     sender->credit = 0;
@@ -2090,7 +2090,7 @@ void pn_drained(pn_link_t *sender)
   }
 }
 
-ssize_t pn_recv(pn_link_t *receiver, char *bytes, size_t n)
+ssize_t pn_link_recv(pn_link_t *receiver, char *bytes, size_t n)
 {
   if (!receiver) return PN_ARG_ERR;
 
@@ -2108,86 +2108,86 @@ ssize_t pn_recv(pn_link_t *receiver, cha
   }
 }
 
-void pn_flow(pn_link_t *receiver, int credit)
+void pn_link_flow(pn_link_t *receiver, int credit)
 {
-  if (receiver && pn_is_receiver(receiver)) {
+  if (receiver && pn_link_is_receiver(receiver)) {
     receiver->credit += credit;
     receiver->drain = false;
     pn_modified(receiver->session->connection, &receiver->endpoint);
   }
 }
 
-void pn_drain(pn_link_t *receiver, int credit)
+void pn_link_drain(pn_link_t *receiver, int credit)
 {
-  if (receiver && pn_is_receiver(receiver)) {
-    pn_flow(receiver, credit);
+  if (receiver && pn_link_is_receiver(receiver)) {
+    pn_link_flow(receiver, credit);
     receiver->drain = true;
   }
 }
 
-time_t pn_tick(pn_transport_t *engine, time_t now)
+time_t pn_transport_tick(pn_transport_t *engine, time_t now)
 {
   return 0;
 }
 
-pn_link_t *pn_link(pn_delivery_t *delivery)
+pn_link_t *pn_delivery_link(pn_delivery_t *delivery)
 {
   if (!delivery) return NULL;
   return delivery->link;
 }
 
-int pn_local_disposition(pn_delivery_t *delivery)
+pn_disposition_t pn_delivery_local_state(pn_delivery_t *delivery)
 {
   return delivery->local_state;
 }
 
-int pn_remote_disposition(pn_delivery_t *delivery)
+pn_disposition_t pn_delivery_remote_state(pn_delivery_t *delivery)
 {
   return delivery->remote_state;
 }
 
-bool pn_remote_settled(pn_delivery_t *delivery)
+bool pn_delivery_settled(pn_delivery_t *delivery)
 {
   return delivery ? delivery->remote_settled : false;
 }
 
-bool pn_updated(pn_delivery_t *delivery)
+bool pn_delivery_updated(pn_delivery_t *delivery)
 {
   return delivery ? delivery->updated : false;
 }
 
-void pn_clear(pn_delivery_t *delivery)
+void pn_delivery_clear(pn_delivery_t *delivery)
 {
   delivery->updated = false;
   pn_work_update(delivery->link->session->connection, delivery);
 }
 
-void pn_disposition(pn_delivery_t *delivery, pn_disposition_t disposition)
+void pn_delivery_update(pn_delivery_t *delivery, pn_disposition_t disposition)
 {
   if (!delivery) return;
   delivery->local_state = disposition;
   pn_add_tpwork(delivery);
 }
 
-bool pn_writable(pn_delivery_t *delivery)
+bool pn_delivery_writable(pn_delivery_t *delivery)
 {
   if (!delivery) return false;
 
   pn_link_t *link = delivery->link;
-  return pn_is_sender(link) && pn_is_current(delivery) && pn_credit(link) > 0;
+  return pn_link_is_sender(link) && pn_is_current(delivery) && pn_link_credit(link) > 0;
 }
 
-bool pn_readable(pn_delivery_t *delivery)
+bool pn_delivery_readable(pn_delivery_t *delivery)
 {
   if (delivery) {
     pn_link_t *link = delivery->link;
-    return pn_is_receiver(link) && pn_is_current(delivery);
+    return pn_link_is_receiver(link) && pn_is_current(delivery);
   } else {
     return false;
   }
 }
 
-size_t pn_pending(pn_delivery_t *delivery)
+size_t pn_delivery_pending(pn_delivery_t *delivery)
 {
   return pn_buffer_size(delivery->bytes);
 }

Modified: qpid/proton/trunk/proton-c/src/messenger.c
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/proton-c/src/messenger.c?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/proton-c/src/messenger.c (original)
+++ qpid/proton/trunk/proton-c/src/messenger.c Tue Oct  2 12:54:44 2012
@@ -182,8 +182,8 @@ void pn_messenger_flow(pn_messenger_t *m
 
       pn_link_t *link = pn_link_head(conn, PN_LOCAL_ACTIVE);
       while (link && messenger->credit > 0) {
-        if (pn_is_receiver(link)) {
-          pn_flow(link, 1);
+        if (pn_link_is_receiver(link)) {
+          pn_link_flow(link, 1);
           messenger->credit--;
         }
         link = pn_link_next(link, PN_LOCAL_ACTIVE);
@@ -209,8 +209,8 @@ void pn_messenger_endpoints(pn_messenger
 
   pn_link_t *link = pn_link_head(conn, PN_LOCAL_UNINIT);
   while (link) {
-    pn_set_source(link, pn_remote_source(link));
-    pn_set_target(link, pn_remote_target(link));
+    pn_link_set_source(link, pn_link_remote_source(link));
+    pn_link_set_target(link, pn_link_remote_target(link));
     pn_link_open(link);
     link = pn_link_next(link, PN_LOCAL_UNINIT);
   }
@@ -238,8 +238,8 @@ void pn_messenger_reclaim(pn_messenger_t
 {
   pn_link_t *link = pn_link_head(conn, 0);
   while (link) {
-    if (pn_is_receiver(link) && pn_credit(link) > 0) {
-      messenger->credit += pn_credit(link);
+    if (pn_link_is_receiver(link) && pn_link_credit(link) > 0) {
+      messenger->credit += pn_link_credit(link);
     }
     link = pn_link_next(link, 0);
   }
@@ -394,7 +394,7 @@ pn_connection_t *pn_messenger_resolve(pn
   while (ctor) {
     pn_connection_t *connection = pn_connector_connection(ctor);
     const char *container = pn_connection_remote_container(connection);
-    const char *hostname = pn_connection_hostname(connection);
+    const char *hostname = pn_connection_get_hostname(connection);
     if (pn_streq(container, domain) || pn_streq(hostname, domain))
       return connection;
     ctor = pn_connector_next(ctor);
@@ -449,8 +449,9 @@ pn_link_t *pn_messenger_link(pn_messenge
 
   pn_link_t *link = pn_link_head(connection, PN_LOCAL_ACTIVE);
   while (link) {
-    if (pn_is_sender(link) == sender) {
-      const char *terminus = pn_is_sender(link) ? pn_target(link) : pn_source(link);
+    if (pn_link_is_sender(link) == sender) {
+      const char *terminus = pn_link_is_sender(link) ?
+        pn_link_get_target(link) : pn_link_get_source(link);
       if (pn_streq(name, terminus))
         return link;
     }
@@ -462,11 +463,11 @@ pn_link_t *pn_messenger_link(pn_messenge
   link = sender ? pn_sender(ssn, "sender-xxx") : pn_receiver(ssn, "receiver-xxx");
   // XXX
   if (sender) {
-    pn_set_target(link, name);
-    pn_set_source(link, name);
+    pn_link_set_target(link, name);
+    pn_link_set_source(link, name);
   } else {
-    pn_set_target(link, name);
-    pn_set_source(link, name);
+    pn_link_set_target(link, name);
+    pn_link_set_source(link, name);
   }
   pn_link_open(link);
   return link;
@@ -563,11 +564,11 @@ int pn_messenger_put(pn_messenger_t *mes
     } else if (err) {
       return err;
     } else {
-      ssize_t n = pn_send(sender, encoded, size);
+      ssize_t n = pn_link_send(sender, encoded, size);
       if (n < 0) {
         return n;
       } else {
-        pn_advance(sender);
+        pn_link_advance(sender);
         pn_messenger_tsync(messenger, false_pred, 0);
         return 0;
       }
@@ -585,11 +586,11 @@ bool pn_messenger_sent(pn_messenger_t *m
 
     pn_link_t *link = pn_link_head(conn, PN_LOCAL_ACTIVE);
     while (link) {
-      if (pn_is_sender(link)) {
+      if (pn_link_is_sender(link)) {
         pn_delivery_t *d = pn_unsettled_head(link);
         while (d) {
-          if (pn_remote_disposition(d) || pn_remote_settled(d)) {
-            pn_settle(d);
+          if (pn_delivery_remote_state(d) || pn_delivery_settled(d)) {
+            pn_delivery_settle(d);
           } else {
             return false;
           }
@@ -613,7 +614,7 @@ bool pn_messenger_rcvd(pn_messenger_t *m
 
     pn_delivery_t *d = pn_work_head(conn);
     while (d) {
-      if (pn_readable(d)) {
+      if (pn_delivery_readable(d)) {
         return true;
       }
       d = pn_work_next(d);
@@ -649,12 +650,12 @@ int pn_messenger_get(pn_messenger_t *mes
 
     pn_delivery_t *d = pn_work_head(conn);
     while (d) {
-      if (pn_readable(d)) {
+      if (pn_delivery_readable(d)) {
         // XXX: buf size, eof, etc
         char buf[1024];
-        pn_link_t *l = pn_link(d);
-        ssize_t n = pn_recv(l, buf, 1024);
-        pn_settle(d);
+        pn_link_t *l = pn_delivery_link(d);
+        ssize_t n = pn_link_recv(l, buf, 1024);
+        pn_delivery_settle(d);
         if (n == PN_EOS) n = 0;
         if (n < 0) return n;
         if (msg) {
@@ -692,12 +693,12 @@ int pn_messenger_queued(pn_messenger_t *
 
     pn_link_t *link = pn_link_head(conn, PN_LOCAL_ACTIVE);
     while (link) {
-      if (pn_is_sender(link)) {
+      if (pn_link_is_sender(link)) {
         if (sender) {
-          result += pn_queued(link);
+          result += pn_link_queued(link);
         }
       } else if (!sender) {
-        result += pn_queued(link);
+        result += pn_link_queued(link);
       }
       link = pn_link_next(link, PN_LOCAL_ACTIVE);
     }

Modified: qpid/proton/trunk/proton-c/src/proton.c
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/proton-c/src/proton.c?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/proton-c/src/proton.c (original)
+++ qpid/proton/trunk/proton-c/src/proton.c Tue Oct  2 12:54:44 2012
@@ -147,12 +147,13 @@ void server_callback(pn_connector_t *cto
 
   pn_link_t *link = pn_link_head(conn, PN_LOCAL_UNINIT | PN_REMOTE_ACTIVE);
   while (link) {
-    printf("%s, %s\n", pn_remote_source(link), pn_remote_target(link));
-    pn_set_source(link, pn_remote_source(link));
-    pn_set_target(link, pn_remote_target(link));
+    printf("%s, %s\n", pn_link_remote_source(link),
+           pn_link_remote_target(link));
+    pn_link_set_source(link, pn_link_remote_source(link));
+    pn_link_set_target(link, pn_link_remote_target(link));
     pn_link_open(link);
-    if (pn_is_receiver(link)) {
-      pn_flow(link, 100);
+    if (pn_link_is_receiver(link)) {
+      pn_link_flow(link, 100);
     } else {
       pn_delivery(link, pn_dtag("blah", 4));
     }
@@ -165,27 +166,27 @@ void server_callback(pn_connector_t *cto
   {
     pn_delivery_tag_t tag = pn_delivery_tag(delivery);
     pn_quote_data(tagstr, 1024, tag.bytes, tag.size);
-    pn_link_t *link = pn_link(delivery);
-    if (pn_readable(delivery)) {
+    pn_link_t *link = pn_delivery_link(delivery);
+    if (pn_delivery_readable(delivery)) {
       if (!ctx->quiet) {
         printf("received delivery: %s\n", tagstr);
         printf("  payload = \"");
       }
       while (true) {
-        ssize_t n = pn_recv(link, msg, 1024);
+        ssize_t n = pn_link_recv(link, msg, 1024);
         if (n == PN_EOS) {
-          pn_advance(link);
-          pn_disposition(delivery, PN_ACCEPTED);
+          pn_link_advance(link);
+          pn_delivery_update(delivery, PN_ACCEPTED);
           break;
         } else if (!ctx->quiet) {
           pn_print_data(msg, n);
         }
       }
       if (!ctx->quiet) printf("\"\n");
-      if (pn_credit(link) < 50) pn_flow(link, 100);
-    } else if (pn_writable(delivery)) {
-      pn_send(link, data, ndata);
-      if (pn_advance(link)) {
+      if (pn_link_credit(link) < 50) pn_link_flow(link, 100);
+    } else if (pn_delivery_writable(delivery)) {
+      pn_link_send(link, data, ndata);
+      if (pn_link_advance(link)) {
         if (!ctx->quiet) printf("sent delivery: %s\n", tagstr);
         char tagbuf[16];
         sprintf(tagbuf, "%i", ctx->count++);
@@ -193,9 +194,9 @@ void server_callback(pn_connector_t *cto
       }
     }
 
-    if (pn_updated(delivery)) {
-      if (!ctx->quiet) printf("disposition for %s: %u\n", tagstr, pn_remote_disposition(delivery));
-      pn_settle(delivery);
+    if (pn_delivery_updated(delivery)) {
+      if (!ctx->quiet) printf("disposition for %s: %u\n", tagstr, pn_delivery_remote_state(delivery));
+      pn_delivery_settle(delivery);
     }
 
     delivery = pn_work_next(delivery);
@@ -296,7 +297,7 @@ void client_callback(pn_connector_t *cto
 
     if (ctx->send_count) {
       pn_link_t *snd = pn_sender(ssn, "sender");
-      pn_set_target(snd, ctx->address);
+      pn_link_set_target(snd, ctx->address);
       pn_link_open(snd);
 
       char buf[16];
@@ -308,9 +309,9 @@ void client_callback(pn_connector_t *cto
 
     if (ctx->recv_count) {
       pn_link_t *rcv = pn_receiver(ssn, "receiver");
-      pn_set_source(rcv, ctx->address);
+      pn_link_set_source(rcv, ctx->address);
       pn_link_open(rcv);
-      pn_flow(rcv, ctx->recv_count < ctx->high ? ctx->recv_count : ctx->high);
+      pn_link_flow(rcv, ctx->recv_count < ctx->high ? ctx->recv_count : ctx->high);
     }
   }
 
@@ -319,23 +320,23 @@ void client_callback(pn_connector_t *cto
   {
     pn_delivery_tag_t tag = pn_delivery_tag(delivery);
     pn_quote_data(tagstr, 1024, tag.bytes, tag.size);
-    pn_link_t *link = pn_link(delivery);
-    if (pn_writable(delivery)) {
-      pn_send(link, data, ndata);
-      if (pn_advance(link)) {
+    pn_link_t *link = pn_delivery_link(delivery);
+    if (pn_delivery_writable(delivery)) {
+      pn_link_send(link, data, ndata);
+      if (pn_link_advance(link)) {
         if (!ctx->quiet) printf("sent delivery: %s\n", tagstr);
       }
-    } else if (pn_readable(delivery)) {
+    } else if (pn_delivery_readable(delivery)) {
       if (!ctx->quiet) {
         printf("received delivery: %s\n", tagstr);
         printf("  payload = \"");
       }
       while (true) {
-        size_t n = pn_recv(link, msg, 1024);
+        size_t n = pn_link_recv(link, msg, 1024);
         if (n == PN_EOS) {
-          pn_advance(link);
-          pn_disposition(delivery, PN_ACCEPTED);
-          pn_settle(delivery);
+          pn_link_advance(link);
+          pn_delivery_update(delivery, PN_ACCEPTED);
+          pn_delivery_settle(delivery);
           if (!--ctx->recv_count) {
             pn_link_close(link);
           }
@@ -346,15 +347,16 @@ void client_callback(pn_connector_t *cto
       }
       if (!ctx->quiet) printf("\"\n");
 
-      if (pn_credit(link) < ctx->low && pn_credit(link) < ctx->recv_count) {
-        pn_flow(link, (ctx->recv_count < ctx->high ? ctx->recv_count : ctx->high) - pn_credit(link));
+      if (pn_link_credit(link) < ctx->low && pn_link_credit(link) < ctx->recv_count) {
+        pn_link_flow(link, (ctx->recv_count < ctx->high ? ctx->recv_count : ctx->high)
+                     - pn_link_credit(link));
       }
     }
 
-    if (pn_updated(delivery)) {
-      if (!ctx->quiet) printf("disposition for %s: %u\n", tagstr, pn_remote_disposition(delivery));
-      pn_clear(delivery);
-      pn_settle(delivery);
+    if (pn_delivery_updated(delivery)) {
+      if (!ctx->quiet) printf("disposition for %s: %u\n", tagstr, pn_delivery_remote_state(delivery));
+      pn_delivery_clear(delivery);
+      pn_delivery_settle(delivery);
       if (!--ctx->send_count) {
         pn_link_close(link);
       }

Modified: qpid/proton/trunk/proton-j/src/main/scripts/proton.py
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/proton-j/src/main/scripts/proton.py?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/proton-j/src/main/scripts/proton.py (original)
+++ qpid/proton/trunk/proton-j/src/main/scripts/proton.py Tue Oct  2 12:54:44 2012
@@ -255,14 +255,14 @@ class Delivery(object):
   def updated(self):
     return self.impl.isUpdated()
 
-  def disposition(self, disp):
+  def update(self, disp):
     if disp == self.ACCEPTED:
       self.impl.disposition(Accepted.getInstance())
     else:
       raise Exception("xxx: %s" % disp)
 
   @property
-  def remote_disposition(self):
+  def remote_state(self):
     rd = self.impl.getRemoteState()
     if(rd == Accepted.getInstance()):
       return self.ACCEPTED
@@ -270,7 +270,7 @@ class Delivery(object):
       raise Exception("xxx: %s" % rd)
 
   @property
-  def local_disposition(self):
+  def local_state(self):
     ld = self.impl.getLocalState()
     if(ld == Accepted.getInstance()):
       return self.ACCEPTED
@@ -281,7 +281,7 @@ class Delivery(object):
     self.impl.settle()
 
   @property
-  def remote_settled(self):
+  def settled(self):
     return self.impl.remotelySettled()
 
   @property

Modified: qpid/proton/trunk/tests/proton_tests/engine.py
URL: http://svn.apache.org/viewvc/qpid/proton/trunk/tests/proton_tests/engine.py?rev=1392896&r1=1392895&r2=1392896&view=diff
==============================================================================
--- qpid/proton/trunk/tests/proton_tests/engine.py (original)
+++ qpid/proton/trunk/tests/proton_tests/engine.py Tue Oct  2 12:54:44 2012
@@ -438,21 +438,21 @@ class TransferTest(Test):
     assert rd.tag == sd.tag
     rmsg = self.rcv.recv(1024)
     assert rmsg == msg
-    rd.disposition(Delivery.ACCEPTED)
+    rd.update(Delivery.ACCEPTED)
 
     self.pump()
 
-    rdisp = sd.remote_disposition
-    ldisp = rd.local_disposition
+    rdisp = sd.remote_state
+    ldisp = rd.local_state
     assert rdisp == ldisp == Delivery.ACCEPTED, (rdisp, ldisp)
     assert sd.updated
 
-    sd.disposition(Delivery.ACCEPTED)
+    sd.update(Delivery.ACCEPTED)
     sd.settle()
 
     self.pump()
 
-    assert sd.local_disposition == rd.remote_disposition == Delivery.ACCEPTED
+    assert sd.local_state == rd.remote_state == Delivery.ACCEPTED
 
 class CreditTest(Test):
 
@@ -790,12 +790,12 @@ class SettlementTest(Test):
     c = self.rcv.current
     assert c
     assert c.tag == "tag", c.tag
-    assert c.remote_settled
+    assert c.settled
     c.settle()
     c = self.rcv.current
     assert c
     assert c.tag == "tag2", c.tag
-    assert c.remote_settled
+    assert c.settled
     c.settle()
     c = self.rcv.current
     assert not c



---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org