Problem on compilation

Originally filed by user @ovr

Hey! I am using realm-js v1.1.1

Error

/Users/ovr/projects/interpals/frontend/native/node_modules/realm/src/object-store/src/object.cpp:42:20: error: no viable overloaded '='
        m_notifier = std::make_shared<_impl::ObjectNotifier>(m_row, m_realm);
        ~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /Users/ovr/projects/interpals/frontend/native/node_modules/realm/src/object-store/src/object.cpp:19:
In file included from /Users/ovr/projects/interpals/frontend/native/node_modules/realm/src/object-store/src/object.hpp:22:
/Users/ovr/projects/interpals/frontend/native/node_modules/realm/src/object-store/src/impl/collection_notifier.hpp:256:13: note: candidate function not viable: no known conversion from 'typename enable_if<!is_array<ObjectNotifier>::value, shared_ptr<ObjectNotifier> >::type' (aka 'std::__1::shared_ptr<realm::_impl::ObjectNotifier>') to 'const realm::_impl::CollectionNotifier::Handle<realm::_impl::ObjectNotifier>' for 1st argument
    Handle& operator=(const Handle& other)
            ^
/Users/ovr/projects/interpals/frontend/native/node_modules/realm/src/object-store/src/impl/collection_notifier.hpp:265:13: note: candidate function not viable: no known conversion from 'typename enable_if<!is_array<ObjectNotifier>::value, shared_ptr<ObjectNotifier> >::type' (aka 'std::__1::shared_ptr<realm::_impl::ObjectNotifier>') to 'realm::_impl::CollectionNotifier::Handle<realm::_impl::ObjectNotifier>' for 1st argument
    Handle& operator=(Handle&& other)
            ^
1 error generated.

My ENV

clang -v
clang version 4.0.0 (tags/RELEASE_400/final)
Target: x86_64-apple-darwin16.4.0
Thread model: posix
InstalledDir: /usr/local/opt/llvm/bin

Thanks

[pathikphkis]

RealmReact.mm File /<----- Chaining

//Add this code

#import “RealmReact.h” #import “RealmAnalytics.h”

#import “jsc/jsc_init.h”

#import “impl/realm_coordinator.hpp” #import “shared_realm.hpp”

#import <React/RCTBridge+Private.h> #import <React/RCTJavaScriptExecutor.h>

#import <objc/runtime.h> #import <arpa/inet.h> #import <ifaddrs.h> #import <netdb.h> #import <net/if.h>

#if DEBUG #import “GCDWebServer.h” #import “GCDWebServerDataRequest.h” #import “GCDWebServerDataResponse.h” #import “GCDWebServerErrorResponse.h” #import “rpc.hpp”

#define WEB_SERVER_PORT 8083

using namespace realm::rpc; #endif

@interface NSObject ()

• (instancetype)initWithJSContext:(JSContext *)context;
• (instancetype)initWithJSContext:(JSContext *)context onThread:(NSThread *)thread;
• (JSContext *)context; @end

// the part of the RCTCxxBridge private class we care about @interface RCTBridge (Realm_RCTCxxBridge)

• (JSGlobalContextRef)jsContextRef;
• (void *)runtime; @end

extern “C” JSGlobalContextRef RealmReactGetJSGlobalContextForExecutor(id executor, bool create) { Ivar contextIvar = class_getInstanceVariable([executor class], “_context”); if (!contextIvar) { return NULL; }

id rctJSContext = object_getIvar(executor, contextIvar);
if (!rctJSContext && create) {
    Class RCTJavaScriptContext = NSClassFromString(@"RCTJavaScriptContext");
    if ([RCTJavaScriptContext instancesRespondToSelector:@selector(initWithJSContext:onThread:)]) {
        // for RN 0.28.0+
        rctJSContext = [[RCTJavaScriptContext alloc] initWithJSContext:[JSContext new] onThread:[NSThread currentThread]];
    }
    else {
        // for RN < 0.28.0
        assert([RCTJavaScriptContext instancesRespondToSelector:@selector(initWithJSContext:)]);
        rctJSContext = [[RCTJavaScriptContext alloc] initWithJSContext:[JSContext new]];
    }
    
    object_setIvar(executor, contextIvar, rctJSContext);
}

return [rctJSContext context].JSGlobalContextRef;

}

@interface RealmReact () <RCTBridgeModule> @end

@implementation RealmReact { NSMutableDictionary *_eventHandlers;

#if DEBUG GCDWebServer *_webServer; std::unique_ptr<RPCServer> _rpcServer; #endif }

@synthesize bridge = _bridge;

RCT_EXPORT_MODULE(Realm)

• (BOOL)requiresMainQueueSetup { return YES; }

• (void)initialize { if (self != [RealmReact class]) { return; }

  RLMSendAnalytics(); }

• (instancetype)init { self = [super init]; if (self) { _eventHandlers = [[NSMutableDictionary alloc] init]; } return self; }

• (dispatch_queue_t)methodQueue { return dispatch_get_main_queue(); }

• (NSDictionary *)constantsToExport { #if DEBUG #if TARGET_IPHONE_SIMULATOR NSArray *hosts = @[@“localhost”]; #else NSArray *hosts = [self getIPAddresses]; #endif

  return @{ @“debugHosts”: hosts, @“debugPort”: @(WEB_SERVER_PORT), }; #else return @{}; #endif }

• (void)addListenerForEvent:(NSString *)eventName handler:(RealmReactEventHandler)handler { NSMutableOrderedSet *handlers = _eventHandlers[eventName]; if (!handlers) { handlers = _eventHandlers[eventName] = [[NSMutableOrderedSet alloc] init]; } [handlers addObject:handler]; }

• (void)removeListenerForEvent:(NSString *)eventName handler:(RealmReactEventHandler)handler { NSMutableOrderedSet *handlers = _eventHandlers[eventName]; [handlers removeObject:handler]; }

RCT_REMAP_METHOD(emit, emitEvent:(NSString *)eventName withObject:(id)object) { for (RealmReactEventHandler handler in [_eventHandlers[eventName] copy]) { handler(object); } }

#if DEBUG

• (NSArray *)getIPAddresses { static const char * const wifiInterface = “en0”;

  struct ifaddrs *ifaddrs; if (getifaddrs(&ifaddrs)) { NSLog(@“Failed to get interface addresses: %s”, strerror(errno)); return @[]; }

  NSMutableArray *ipAddresses = [[NSMutableArray alloc] init]; char host[INET6_ADDRSTRLEN];

  for (struct ifaddrs *ifaddr = ifaddrs; ifaddr; ifaddr = ifaddr->ifa_next) { if ((ifaddr->ifa_flags & IFF_LOOPBACK) || !(ifaddr->ifa_flags & IFF_UP)) { // Ignore loopbacks and interfaces that aren’t up. continue; }

    struct sockaddr *addr = ifaddr->ifa_addr;
    if (addr->sa_family == AF_INET) {
        // Ignore link-local ipv4 addresses.
        in_addr_t sin_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
        if (IN_LOOPBACK(sin_addr) || IN_LINKLOCAL(sin_addr) || IN_ZERONET(sin_addr)) {
            continue;
        }
    }
    else if (addr->sa_family == AF_INET6) {
        // Ignore link-local ipv6 addresses.
        struct in6_addr *sin6_addr = &((struct sockaddr_in6 *)addr)->sin6_addr;
        if (IN6_IS_ADDR_LOOPBACK(sin6_addr) || IN6_IS_ADDR_LINKLOCAL(sin6_addr) || IN6_IS_ADDR_UNSPECIFIED(sin6_addr)) {
            continue;
        }
    }
    else {
        // Ignore addresses that are not ipv4 or ipv6.
        continue;
    }
    
    if (strcmp(ifaddr->ifa_name, wifiInterface)) {
        // Ignore non-wifi addresses.
        continue;
    }
    if (int error = getnameinfo(addr, addr->sa_len, host, sizeof(host), NULL, 0, NI_NUMERICHOST)) {
        NSLog(@"Couldn't resolve host name for address: %s", gai_strerror(error));
        continue;
    }
    
    [ipAddresses addObject:@(host)];
  

  }

  freeifaddrs(ifaddrs); return [ipAddresses copy]; }

• (void)startRPC { [GCDWebServer setLogLevel:3]; _webServer = [[GCDWebServer alloc] init]; _rpcServer = std::make_unique<RPCServer>(); __weak typeof(self) weakSelf = self;

  // Add a handler to respond to POST requests on any URL [_webServer addDefaultHandlerForMethod:@“POST” requestClass:[GCDWebServerDataRequest class] processBlock:^GCDWebServerResponse (GCDWebServerRequest request) { typeof(self) self = weakSelf; RPCServer *rpcServer = self ? self->_rpcServer.get() : nullptr; GCDWebServerResponse *response;

                              try {
                                  NSData *responseData;
                                  
                                  if (rpcServer) {
                                      json args = json::parse([[(GCDWebServerDataRequest *)request text] UTF8String]);
                                      std::string responseText = rpcServer->perform_request(request.path.UTF8String, std::move(args)).dump();
                                      
                                      responseData = [NSData dataWithBytes:responseText.c_str() length:responseText.length()];
                                  }
                                  else {
                                      // we have been deallocated
                                      responseData = [NSData data];
                                  }
                                  
                                  response = [[GCDWebServerDataResponse alloc] initWithData:responseData contentType:@"application/json"];
                              }
                              catch(std::exception &ex) {
                                  NSLog(@"Invalid RPC request - %@", [(GCDWebServerDataRequest *)request text]);
                                  response = [GCDWebServerErrorResponse responseWithClientError:kGCDWebServerHTTPStatusCode_UnprocessableEntity
                                                                                underlyingError:nil
                                                                                        message:@"Invalid RPC request"];
                              }
                              
                              [response setValue:@"http://localhost:8081" forAdditionalHeader:@"Access-Control-Allow-Origin"];
                              return response;
                          }];
  

  [_webServer startWithPort:WEB_SERVER_PORT bonjourName:nil]; return; }

• (void)shutdownRPC { [_webServer stop]; [_webServer removeAllHandlers]; _webServer = nil; _rpcServer.reset(); } #endif

• (void)invalidate { #if DEBUG // shutdown rpc if in chrome debug mode [self shutdownRPC]; #endif }

• (void)dealloc { [self performSelectorOnMainThread:@selector(invalidate) withObject:nil waitUntilDone:YES]; }

typedef JSGlobalContextRef (^JSContextRefExtractor)();

void _initializeOnJSThread(JSContextRefExtractor jsContextExtractor) { // Make sure the previous JS thread is completely finished before continuing. static __weak NSThread *s_currentJSThread; while (s_currentJSThread && !s_currentJSThread.finished) { [NSThread sleepForTimeInterval:0.1]; } s_currentJSThread = [NSThread currentThread];

// Close all cached Realms from the previous JS thread.
realm::_impl::RealmCoordinator::clear_all_caches();

RJSInitializeInContext(jsContextExtractor());

}

• (void)setBridge:(RCTBridge *)bridge { _bridge = bridge;

  static __weak RealmReact *s_currentModule = nil; [s_currentModule invalidate]; s_currentModule = self;

  if (objc_lookUpClass(“RCTWebSocketExecutor”) && [bridge executorClass] == objc_lookUpClass(“RCTWebSocketExecutor”)) { #if DEBUG [self startRPC]; #else @throw [NSException exceptionWithName:@“Invalid Executor” reason:@“Chrome debug mode not supported in Release builds” userInfo:nil]; #endif } else if ([bridge isKindOfClass:objc_lookUpClass(“RCTCxxBridge”)]) { // probe for the new C++ bridge in React Native 0.45+

    __weak __typeof__(self) weakSelf = self;
    __weak __typeof__(bridge) weakBridge = bridge;
    
    [bridge dispatchBlock:^{
        __typeof__(self) self = weakSelf;
        __typeof__(bridge) bridge = weakBridge;
        if (!self || !bridge) {
            return;
        }
        
        _initializeOnJSThread(^{
            // RN < 0.58 has a private method that returns the js context
            if ([bridge respondsToSelector:@selector(jsContextRef)]) {
                return [bridge jsContextRef];
            }
            // RN 0.58+ wraps the js context in the jsi abstraction layer,
            // which doesn't have any way to obtain the JSGlobalContextRef,
            // so engage in some undefined behavior and slurp out the
            // member variable
            struct RealmJSCRuntime {
                virtual ~RealmJSCRuntime() = 0;
                JSGlobalContextRef ctx_;
            };
            return static_cast<RealmJSCRuntime*>(bridge.runtime)->ctx_;
        });
    } queue:RCTJSThread];
  

  } else { // React Native 0.44 and older id<RCTJavaScriptExecutor> executor = [bridge valueForKey:@“javaScriptExecutor”]; __weak typeof(self) weakSelf = self; __weak typeof(executor) weakExecutor = executor;

    [executor executeBlockOnJavaScriptQueue:^{
        __typeof__(self) self = weakSelf;
        __typeof__(executor) executor = weakExecutor;
        if (!self || !executor) {
            return;
        }
        
        _initializeOnJSThread(^ {
            return RealmReactGetJSGlobalContextForExecutor(executor, true);
        });
    }];
  

  } }

@end

[blagoev]

I assume all is good. closing this one