← Back to branch summary

~ubuntu-branches/ubuntu/maverick/evolution-data-server/maverick-proposed

« back to all changes in this revision

Viewing changes to libdb/rpc_server/java/RpcDbc.java

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2010-05-17 17:02:06 UTC
  • mfrom: (1.1.79 upstream) (1.6.12 experimental)
  • Revision ID: james.westby@ubuntu.com-20100517170206-4ufr52vwrhh26yh0
Tags: 2.30.1-1ubuntu1
https://launchpad.net/bugs/42199
https://launchpad.net/bugs/229669
https://launchpad.net/bugs/173703
https://launchpad.net/bugs/360344
https://launchpad.net/bugs/508494
* Merge from debian experimental. Remaining change:
  (LP: #42199, #229669, #173703, #360344, #508494)
  + debian/control:
    - add Vcs-Bzr tag
    - don't use libgnome
    - Use Breaks instead of Conflicts against evolution 2.25 and earlier.
  + debian/evolution-data-server.install,
    debian/patches/45_libcamel_providers_version.patch:
    - use the upstream versioning, not a Debian-specific one 
  + debian/libedata-book1.2-dev.install, debian/libebackend-1.2-dev.install,
    debian/libcamel1.2-dev.install, debian/libedataserverui1.2-dev.install:
    - install html documentation
  + debian/rules:
    - don't build documentation it's shipped with the tarball

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdb/rpc_server/java/RpcDbc.java
1
 
/*-
2
 
 * See the file LICENSE for redistribution information.
3
 
 *
4
 
 * Copyright (c) 2001-2002
5
 
 *      Sleepycat Software.  All rights reserved.
6
 
 *
7
 
 * $Id$
8
 
 */
9
 
 
10
 
package com.sleepycat.db.rpcserver;
11
 
 
12
 
import com.sleepycat.db.*;
13
 
import java.io.IOException;
14
 
import java.io.*;
15
 
import java.util.*;
16
 
 
17
 
/**
18
 
 * RPC wrapper around a dbc object for the Java RPC server.
19
 
 */
20
 
public class RpcDbc extends Timer
21
 
{
22
 
        static final byte[] empty = new byte[0];
23
 
        RpcDbEnv rdbenv;
24
 
        RpcDb rdb;
25
 
        Dbc dbc;
26
 
        Timer orig_timer;
27
 
        boolean isJoin;
28
 
 
29
 
        public RpcDbc(RpcDb rdb, Dbc dbc, boolean isJoin)
30
 
        {
31
 
                this.rdb = rdb;
32
 
                this.rdbenv = rdb.rdbenv;
33
 
                this.dbc = dbc;
34
 
                this.isJoin = isJoin;
35
 
        }
36
 
 
37
 
        void dispose()
38
 
        {
39
 
                if (dbc != null) {
40
 
                        try {
41
 
                                dbc.close();
42
 
                        } catch(DbException e) {
43
 
                                e.printStackTrace(DbServer.err);
44
 
                        }
45
 
                        dbc = null;
46
 
                }
47
 
        }
48
 
 
49
 
        public  void close(DbDispatcher server,
50
 
                __dbc_close_msg args, __dbc_close_reply reply)
51
 
        {
52
 
                try {
53
 
                        dbc.close();
54
 
                        dbc = null;
55
 
 
56
 
                        if (isJoin)
57
 
                                for(LocalIterator i = ((DbServer)server).cursor_list.iterator(); i.hasNext(); ) {
58
 
                                        RpcDbc rdbc = (RpcDbc)i.next();
59
 
                                        // Unjoin cursors that were joined to create this
60
 
                                        if (rdbc != null && rdbc.timer == this)
61
 
                                                rdbc.timer = rdbc.orig_timer;
62
 
                                }
63
 
 
64
 
                        reply.status = 0;
65
 
                } catch(DbException e) {
66
 
                        e.printStackTrace(DbServer.err);
67
 
                        reply.status = e.get_errno();
68
 
                } finally {
69
 
                        server.delCursor(this);
70
 
                }
71
 
        }
72
 
 
73
 
        public  void count(DbDispatcher server,
74
 
                __dbc_count_msg args, __dbc_count_reply reply)
75
 
        {
76
 
                try {
77
 
                        reply.dupcount = dbc.count(args.flags);
78
 
                        reply.status = 0;
79
 
                } catch(DbException e) {
80
 
                        e.printStackTrace(DbServer.err);
81
 
                        reply.status = e.get_errno();
82
 
                }
83
 
        }
84
 
 
85
 
        public  void del(DbDispatcher server,
86
 
                __dbc_del_msg args, __dbc_del_reply reply)
87
 
        {
88
 
                try {
89
 
                        reply.status = dbc.del(args.flags);
90
 
                } catch(DbException e) {
91
 
                        e.printStackTrace(DbServer.err);
92
 
                        reply.status = e.get_errno();
93
 
                }
94
 
        }
95
 
 
96
 
        public  void dup(DbDispatcher server,
97
 
                __dbc_dup_msg args, __dbc_dup_reply reply)
98
 
        {
99
 
                try {
100
 
                        Dbc newdbc = dbc.dup(args.flags);
101
 
                        RpcDbc rdbc = new RpcDbc(rdb, newdbc, false);
102
 
                        /* If this cursor has a parent txn, we need to use it too. */
103
 
                        if (timer != this)
104
 
                                rdbc.timer = timer;
105
 
                        reply.dbcidcl_id = server.addCursor(rdbc);
106
 
                        reply.status = 0;
107
 
                } catch(DbException e) {
108
 
                        e.printStackTrace(DbServer.err);
109
 
                        reply.status = e.get_errno();
110
 
                }
111
 
        }
112
 
 
113
 
        public  void get(DbDispatcher server,
114
 
                __dbc_get_msg args, __dbc_get_reply reply)
115
 
        {
116
 
                try {
117
 
                        Dbt key = new Dbt(args.keydata);
118
 
                        key.set_dlen(args.keydlen);
119
 
                        key.set_ulen(args.keyulen);
120
 
                        key.set_doff(args.keydoff);
121
 
                        key.set_flags(Db.DB_DBT_MALLOC |
122
 
                            (args.keyflags & Db.DB_DBT_PARTIAL));
123
 
 
124
 
                        Dbt data = new Dbt(args.datadata);
125
 
                        data.set_dlen(args.datadlen);
126
 
                        data.set_ulen(args.dataulen);
127
 
                        data.set_doff(args.datadoff);
128
 
                        if ((args.flags & Db.DB_MULTIPLE) != 0 ||
129
 
                            (args.flags & Db.DB_MULTIPLE_KEY) != 0) {
130
 
                                if (data.get_data().length == 0)
131
 
                                        data.set_data(new byte[data.get_ulen()]);
132
 
                                data.set_flags(Db.DB_DBT_USERMEM |
133
 
                                    (args.dataflags & Db.DB_DBT_PARTIAL));
134
 
                        } else
135
 
                                data.set_flags(Db.DB_DBT_MALLOC |
136
 
                                    (args.dataflags & Db.DB_DBT_PARTIAL));
137
 
 
138
 
                        reply.status = dbc.get(key, data, args.flags);
139
 
 
140
 
                        if (key.get_data() == args.keydata) {
141
 
                                reply.keydata = new byte[key.get_size()];
142
 
                                System.arraycopy(key.get_data(), 0, reply.keydata, 0, key.get_size());
143
 
                        } else
144
 
                                reply.keydata = key.get_data();
145
 
 
146
 
                        if (data.get_data() == args.datadata) {
147
 
                                reply.datadata = new byte[data.get_size()];
148
 
                                System.arraycopy(data.get_data(), 0, reply.datadata, 0, data.get_size());
149
 
                        } else
150
 
                                reply.datadata = data.get_data();
151
 
                } catch(DbException e) {
152
 
                        e.printStackTrace(DbServer.err);
153
 
                        reply.status = e.get_errno();
154
 
                        reply.keydata = reply.datadata = empty;
155
 
                }
156
 
        }
157
 
 
158
 
        public  void pget(DbDispatcher server,
159
 
                __dbc_pget_msg args, __dbc_pget_reply reply)
160
 
        {
161
 
                try {
162
 
                        Dbt skey = new Dbt(args.skeydata);
163
 
                        skey.set_dlen(args.skeydlen);
164
 
                        skey.set_doff(args.skeydoff);
165
 
                        skey.set_ulen(args.skeyulen);
166
 
                        skey.set_flags(Db.DB_DBT_MALLOC |
167
 
                            (args.skeyflags & Db.DB_DBT_PARTIAL));
168
 
 
169
 
                        Dbt pkey = new Dbt(args.pkeydata);
170
 
                        pkey.set_dlen(args.pkeydlen);
171
 
                        pkey.set_doff(args.pkeydoff);
172
 
                        pkey.set_ulen(args.pkeyulen);
173
 
                        pkey.set_flags(Db.DB_DBT_MALLOC |
174
 
                            (args.pkeyflags & Db.DB_DBT_PARTIAL));
175
 
 
176
 
                        Dbt data = new Dbt(args.datadata);
177
 
                        data.set_dlen(args.datadlen);
178
 
                        data.set_doff(args.datadoff);
179
 
                        data.set_ulen(args.dataulen);
180
 
                        data.set_flags(Db.DB_DBT_MALLOC |
181
 
                            (args.dataflags & Db.DB_DBT_PARTIAL));
182
 
 
183
 
                        reply.status = dbc.pget(skey, pkey, data, args.flags);
184
 
 
185
 
                        if (skey.get_data() == args.skeydata) {
186
 
                                reply.skeydata = new byte[skey.get_size()];
187
 
                                System.arraycopy(skey.get_data(), 0, reply.skeydata, 0, skey.get_size());
188
 
                        } else
189
 
                                reply.skeydata = skey.get_data();
190
 
 
191
 
                        if (pkey.get_data() == args.pkeydata) {
192
 
                                reply.pkeydata = new byte[pkey.get_size()];
193
 
                                System.arraycopy(pkey.get_data(), 0, reply.pkeydata, 0, pkey.get_size());
194
 
                        } else
195
 
                                reply.pkeydata = pkey.get_data();
196
 
 
197
 
                        if (data.get_data() == args.datadata) {
198
 
                                reply.datadata = new byte[data.get_size()];
199
 
                                System.arraycopy(data.get_data(), 0, reply.datadata, 0, data.get_size());
200
 
                        } else
201
 
                                reply.datadata = data.get_data();
202
 
                } catch(DbException e) {
203
 
                        e.printStackTrace(DbServer.err);
204
 
                        reply.status = e.get_errno();
205
 
                }
206
 
        }
207
 
 
208
 
        public  void put(DbDispatcher server,
209
 
                __dbc_put_msg args, __dbc_put_reply reply)
210
 
        {
211
 
                try {
212
 
                        Dbt key = new Dbt(args.keydata);
213
 
                        key.set_dlen(args.keydlen);
214
 
                        key.set_ulen(args.keyulen);
215
 
                        key.set_doff(args.keydoff);
216
 
                        key.set_flags(args.keyflags & Db.DB_DBT_PARTIAL);
217
 
 
218
 
                        Dbt data = new Dbt(args.datadata);
219
 
                        data.set_dlen(args.datadlen);
220
 
                        data.set_ulen(args.dataulen);
221
 
                        data.set_doff(args.datadoff);
222
 
                        data.set_flags(args.dataflags);
223
 
 
224
 
                        reply.status = dbc.put(key, data, args.flags);
225
 
 
226
 
                        if (reply.status == 0 &&
227
 
                            (args.flags == Db.DB_AFTER || args.flags == Db.DB_BEFORE) &&
228
 
                            rdb.db.get_type() == Db.DB_RECNO)
229
 
                                reply.keydata = key.get_data();
230
 
                        else
231
 
                                reply.keydata = empty;
232
 
                } catch(DbException e) {
233
 
                        e.printStackTrace(DbServer.err);
234
 
                        reply.status = e.get_errno();
235
 
                        reply.keydata = empty;
236
 
                }
237
 
        }
238
 
}