The next step in implementing the server is to define methods, specialized on the implementation classes, for each of the protocol functions corresponding to an IDL attribute or operation.
Implementing a protocol function boils down to defining a concrete method for that function that specializes on the implementation class of its target object. Recall that the target object of a protocol function is the first parameter to that function.
We can now present the implementations of the protocol functions. The
op:name
method corresponding to the
name
attribute is automatically generated by the IDL compiler to reference a slot
op:name
in the class that takes the
initarg :name
to initialize it. The same rules apply to
op:balance
.
The
op:credit
method on an
Account
increments the record's balance field by executing a database update statement:
(corba:define-method op:credit ((self account-implementation) amount)
(with-slots (op:name bank op:balance) self
(with-slots (connection) bank
(let ((old-balance (lookup-row-value op:name
connection :balance)))
(update-database-row op:name connection
:balance (setf op:balance
(+ old-balance amount)))))))
The
op:debit
method on an
Account
executes a database update statement that decrements the record's
balance
field, provided the balance exceeds the desired amount:
(corba:define-method op:debit ((self account-implementation) amount)
(with-slots (op:name bank op:balance) self
(with-slots (connection) bank
(let ((old-balance op:balance))
(if (< old-balance amount)
(error 'BankingDemo:Account/Refusal
:reason (format nil
"Can't debit ~A because the
balance is ~A."
amount old-balance))
(update-database-row
op:name connection
:balance (setf op:balance (-
old-balance amount))))))))
The
op:limit
method is automatically generated, as it is also an attribute.
Because we defined
checkingAccount
-servant to inherit from
account-servant
, there is no need to re-implement the
op:credit
method for this implementation class. However, we do want to define a specialized
op:debit
method on
checkingAccount
, to reflect that a checking account can be overdrawn up to its limit:
(corba:define-method op:debit (
(self checkingAccount-implementation) amount)
(with-slots (op:name bank op:balance) self
(with-slots (connection) bank
(let ((old-balance (lookup-row-value op:name
connection :balance))
(limit (lookup-row-value op:name connection :limit)))
(if (< (+ old-balance limit) amount)
(error 'BankingDemo:Account/Refusal
:reason (format nil "Can't debit ~A because the
balance is ~A (limit is ~A)."
amount old-balance limit))
(update-database-row op:name connection
:balance (setf op:balance (-
old-balance amount))))))))
The
BankingDemo
bank
op:name
method returns the value of the bank's
op:name
slot and is automatically generated.
The
op:openAccount
method on
Bank
illustrates the raising of CORBA user exceptions:
(corba:define-method op:openAccount ((self bank-implementation)
name)
(with-slots (connection poa account-impls) self
(when (find-database-row name connection)
(error 'Bankingdemo:Bank/Duplicateaccount))
(create-database-row name connection)
(update-database-row name connection :balance 0)
(let ((new-account (make-instance 'account-implementation
:name name
:bank self
:balance 0)))
(push new-account account-impls)
(op:narrow 'BankingDemo:Account
(op:servant_to_reference poa new-account)))))
If the
(find-database-row name connection)
test succeeds, the call to
(error 'Bankingdemo:Bank/Duplicateaccount)
raises a Common Lisp condition. (We omit the definition of
find-database-row
, which can be found in the source.) Recall that the condition class
BankingDemo:bank/duplicateAccount
corresponds to the IDL
duplicateAccount
exception. The POA that invoked this method in response to a client's request will catch the condition and send the
duplicateAccount
exception back to the client. If there is no existing account for the supplied name, the
op:openAccount
method creates a new record in the database.
Finally, the method makes a new
servant
of class
account-implementation
, registers it with the bank's POA with a call to
op:servant_to_reference
, and narrows the resulting object reference to the more specific class
BankingDemo:account
, the class of object references to
account
objects.
The
op:openCheckingAccount
method is similar, except that it initializes the
op:limit
field of the new account record with the desired overdraft limit and registers a new servant of class
checkingAccount-implementation
, returning an object reference of class
BankingDemo:checkingAccount
:
(corba:define-method op:openCheckingAccount (
(self bank-implementation) name limit)
(with-slots (connection poa account-impls) self
(when (find-database-row name connection)
(error 'Bankingdemo:Bank/Duplicateaccount))
(create-database-row name connection)
(update-database-row name connection :balance 0 :limit limit)
(let ((new-account (make-instance
'checkingaccount-implementation
:name name
:bank self
:balance 0
:limit limit)))
(push new-account account-impls)
(op:narrow 'Bankingdemo:Checkingaccount
(op:servant_to_reference poa new-account)))))
The
op:retrieveAccount
method uses the
name
parameter to find a database row of the given name. If the query returns nil, indicating that there is no record with that name, the method raises the CORBA user exception
nonExistentAccount
by signalling the corresponding Common Lisp error.
Otherwise, the method uses the value of the
op:limit
field to distinguish whether the account is an account or a current account, creating a new servant of the appropriate class:
(corba:define-method op:retrieveAccount ((self
bank-implementation) name)
(with-slots (connection poa account-impls) self
(unless (find-database-row name connection)
(error 'Bankingdemo:Bank/NonExistentAccount))
(let ((limit (lookup-row-value name connection :limit))
(balance (lookup-row-value name connection :balance)))
(if (not limit)
(let ((account (make-instance 'account-implementation
:name name :bank self :balance balance)))
(push account account-impls)
(op:narrow 'BankingDemo:Account
(op:servant_to_reference
poa
account)))
(let ((account (make-instance
'checkingaccount-implementation
:name name
:bank self
:balance balance
:limit limit)))
(push account account-impls)
(op:narrow 'Bankingdemo:Checkingaccount
(op:servant_to_reference
poa
account)))))))
Finally, the
closeAccount
removes the record of an account from the database by executing
delete-database-row
call:
(corba:define-method op:closeaccount
((self bank-implementation) account)
(with-slots (connection poa account-impls) self
(let ((servant (op:reference_to_servant poa account)))
(op:deactivate_object poa (op:reference_to_id poa account))
(removef account-impls servant)
(with-slots (op:name) servant
(delete-database-row op:name connection))))
Note that we need to de-reference the object reference account that is passed in as the parameter of the
op:closeAccount
operation, using a call to the
op:reference_to_servant
operation of the POA.
Here, we make implicit use of our knowledge that, in our application, the server only encounters object references registered with its local POA. This assumption is not true in general.