← Back to branch summary

~evarlast/ubuntu/utopic/mongodb/upstart-workaround-debian-bug-718702

« back to all changes in this revision

Viewing changes to src/mongo/scripting/v8_wrapper.cpp

  • Committer: Package Import Robot
  • Author(s): James Page, James Page, Robie Basak
  • Date: 2013-05-29 17:44:42 UTC
  • mfrom: (44.1.7 sid)
  • Revision ID: package-import@ubuntu.com-20130529174442-z0a4qmoww4y0t458
Tags: 1:2.4.3-1ubuntu1
[ James Page ]
* Merge from Debian unstable, remaining changes:
  - Enable SSL support:
    + d/control: Add libssl-dev to BD's.
    + d/rules: Enabled --ssl option.
    + d/mongodb.conf: Add example SSL configuration options.
  - d/mongodb-server.mongodb.upstart: Add upstart configuration.
  - d/rules: Don't strip binaries during scons build for Ubuntu.
  - d/control: Add armhf to target archs.
  - d/p/SConscript.client.patch: fixup install of client libraries.
  - d/p/0010-install-libs-to-usr-lib-not-usr-lib64-Closes-588557.patch:
    Install libraries to lib not lib64.
* Dropped changes:
  - d/p/arm-support.patch: Included in Debian.
  - d/p/double-alignment.patch: Included in Debian.
  - d/rules,control: Debian also builds with avaliable system libraries
    now.
* Fix FTBFS due to gcc and boost upgrades in saucy:
  - d/p/0008-ignore-unused-local-typedefs.patch: Add -Wno-unused-typedefs
    to unbreak building with g++-4.8.
  - d/p/0009-boost-1.53.patch: Fixup signed/unsigned casting issue.

[ Robie Basak ]
* d/p/0011-Use-a-signed-char-to-store-BSONType-enumerations.patch: Fixup
  build failure on ARM due to missing signed'ness of char cast.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mongo/scripting/v8_wrapper.cpp
1
 
// v8_wrapper.cpp
2
 
 
3
 
/*    Copyright 2009 10gen Inc.
4
 
 *
5
 
 *    Licensed under the Apache License, Version 2.0 (the "License");
6
 
 *    you may not use this file except in compliance with the License.
7
 
 *    You may obtain a copy of the License at
8
 
 *
9
 
 *    http://www.apache.org/licenses/LICENSE-2.0
10
 
 *
11
 
 *    Unless required by applicable law or agreed to in writing, software
12
 
 *    distributed under the License is distributed on an "AS IS" BASIS,
13
 
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
 
 *    See the License for the specific language governing permissions and
15
 
 *    limitations under the License.
16
 
 */
17
 
 
18
 
#include "v8_wrapper.h"
19
 
#include "v8_utils.h"
20
 
#include "v8_db.h"
21
 
#include "engine_v8.h"
22
 
 
23
 
#include <iostream>
24
 
 
25
 
using namespace std;
26
 
using namespace v8;
27
 
 
28
 
namespace mongo {
29
 
 
30
 
#define DDD(x)
31
 
 
32
 
    // --- object wrapper ---
33
 
 
34
 
    class WrapperHolder {
35
 
    public:
36
 
        WrapperHolder( V8Scope* scope, const BSONObj * o , bool readOnly , bool iDelete )
37
 
            : _scope(scope), _o(o), _readOnly( readOnly ), _iDelete( iDelete ) {
38
 
        }
39
 
 
40
 
        ~WrapperHolder() {
41
 
            if ( _o && _iDelete ) {
42
 
                delete _o;
43
 
            }
44
 
            _o = 0;
45
 
        }
46
 
 
47
 
        v8::Handle<v8::Value> get( v8::Local<v8::String> name ) {
48
 
            const string& s = toSTLString( name );
49
 
            const BSONElement& e = _o->getField( s );
50
 
            return _scope->mongoToV8Element(e);
51
 
        }
52
 
 
53
 
        V8Scope* _scope;
54
 
        const BSONObj * _o;
55
 
        bool _readOnly;
56
 
        bool _iDelete;
57
 
    };
58
 
 
59
 
    WrapperHolder * createWrapperHolder( V8Scope* scope, const BSONObj * o , bool readOnly , bool iDelete ) {
60
 
        return new WrapperHolder( scope, o , readOnly , iDelete );
61
 
    }
62
 
 
63
 
    WrapperHolder * getWrapper( v8::Handle<v8::Object> o ) {
64
 
        Handle<v8::Value> t = o->GetRealNamedProperty( v8::String::New( "_wrapper" ) );
65
 
        verify( t->IsExternal() );
66
 
        Local<External> c = External::Cast( *t );
67
 
        WrapperHolder * w = (WrapperHolder*)(c->Value());
68
 
        verify( w );
69
 
        return w;
70
 
    }
71
 
 
72
 
 
73
 
    Handle<Value> wrapperCons(V8Scope* scope, const Arguments& args) {
74
 
        if ( ! ( args.Length() == 1 && args[0]->IsExternal() ) )
75
 
            return v8::ThrowException( v8::String::New( "wrapperCons needs 1 External arg" ) );
76
 
 
77
 
        args.This()->Set( v8::String::New( "_wrapper" ) , args[0] );
78
 
 
79
 
        return v8::Undefined();
80
 
    }
81
 
 
82
 
    v8::Handle<v8::Value> wrapperGetHandler( v8::Local<v8::String> name, const v8::AccessorInfo &info) {
83
 
        return getWrapper( info.This() )->get( name );
84
 
    }
85
 
 
86
 
    v8::Handle<v8::FunctionTemplate> getObjectWrapperTemplate(V8Scope* scope) {
87
 
        v8::Handle<v8::FunctionTemplate> t = scope->createV8Function(wrapperCons);
88
 
        t->InstanceTemplate()->SetNamedPropertyHandler( wrapperGetHandler );
89
 
        return t;
90
 
    }
91
 
}