summaryrefslogtreecommitdiff
path: root/cpp/src/IceGrid/LocatorI.h
blob: 6ef0b5f1c584df6977c1ed3f6c760e46beb66a09 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
//
// Copyright (c) ZeroC, Inc. All rights reserved.
//

#ifndef ICE_GRID_LOCATOR_I_H
#define ICE_GRID_LOCATOR_I_H

#include <IceGrid/Internal.h>
#include <IceGrid/Registry.h>

#include <set>

namespace IceGrid
{

class Database;
class LocatorI;
class TraceLevels;
class WellKnownObjectsManager;

struct LocatorAdapterInfo;
typedef std::vector<LocatorAdapterInfo> LocatorAdapterInfoSeq;

class LocatorI : public Locator, public std::enable_shared_from_this<LocatorI>
{
public:

    class Request : public std::enable_shared_from_this<Request>
    {
    public:
        virtual void execute() = 0;
        virtual void activating(const std::string&) = 0;
        virtual void response(const std::string&, const std::shared_ptr<Ice::ObjectPrx>&) = 0;
        virtual void exception(const std::string&, std::exception_ptr) = 0;
    };

    LocatorI(const std::shared_ptr<Ice::Communicator>&, const std::shared_ptr<Database>&,
             const std::shared_ptr<WellKnownObjectsManager>&, const std::shared_ptr<RegistryPrx>&,
             const std::shared_ptr<QueryPrx>&);

    void findObjectByIdAsync(Ice::Identity,
                            std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>,
                            std::function<void(std::exception_ptr)>,
                            const Ice::Current&) const override;

    void findAdapterByIdAsync(std::string,
                              std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>,
                              std::function<void(std::exception_ptr)>,
                              const Ice::Current&) const override;

    std::shared_ptr<Ice::LocatorRegistryPrx> getRegistry(const Ice::Current&) const override;
    std::shared_ptr<RegistryPrx> getLocalRegistry(const Ice::Current&) const override;
    std::shared_ptr<QueryPrx> getLocalQuery(const Ice::Current&) const override;

    const std::shared_ptr<Ice::Communicator>& getCommunicator() const;
    const std::shared_ptr<TraceLevels>& getTraceLevels() const;

    bool getDirectProxy(const LocatorAdapterInfo&, const std::shared_ptr<Request>&);
    void getDirectProxyResponse(const LocatorAdapterInfo&, const std::shared_ptr<Ice::ObjectPrx>&);
    void getDirectProxyException(const LocatorAdapterInfo&, std::exception_ptr);

protected:

    const std::shared_ptr<Ice::Communicator> _communicator;
    const std::shared_ptr<Database> _database;
    const std::shared_ptr<WellKnownObjectsManager> _wellKnownObjects;
    const std::shared_ptr<RegistryPrx> _localRegistry;
    const std::shared_ptr<QueryPrx> _localQuery;

    using PendingRequests = std::vector<std::shared_ptr<Request>>;
    using PendingRequestsMap = std::map<std::string, PendingRequests>;
    PendingRequestsMap _pendingRequests;
    std::set<std::string> _activating;

    std::mutex _mutex;
};

}

#endif