private RealmSchema() { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); }
/// <summary> /// Finds the definition of a class in this schema. /// </summary> /// <param name="name">A valid class name which may be in this schema.</param> /// <exception cref="ArgumentException">Thrown if a name is not supplied.</exception> /// <returns>An <see cref="ObjectSchema"/> or <c>null</c> to indicate not found.</returns> public ObjectSchema Find(string name) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); return(null); }
/// <summary> /// Creates <see cref="Credentials"/> based on a Facebook login. /// </summary> /// <param name="facebookToken">A Facebook authentication token, obtained by logging into Facebook.</param> /// <returns>An instance of <see cref="Credentials"/> that can be used in <see cref="User.LoginAsync"/></returns> public static Credentials Facebook(string facebookToken) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); return(null); }
/// <summary> /// Creates <see cref="Credentials"/> based on a Google login. /// </summary> /// <param name="googleToken">A Google authentication token, obtained by logging into Google.</param> /// <returns>An instance of <see cref="Credentials"/> that can be used in <see cref="User.LoginAsync"/></returns> public static Credentials Google(string googleToken) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); return(null); }
/// <summary> /// Gets an <see cref="IObservable{T}"/> that can be used to track upload or download progress. /// </summary> /// <remarks> /// To start receiving notifications, you should call <see cref="IObservable{T}.Subscribe"/> on the returned object. /// The token returned from <see cref="IObservable{T}.Subscribe"/> should be retained as long as progress /// notifications are desired. To stop receiving notifications, call <see cref="IDisposable.Dispose"/> /// on the token. /// You don't need to keep a reference to the observable itself. /// The progress callback will always be called once immediately upon subscribing in order to provide /// the latest available status information. /// </remarks> /// <returns>An observable that you can subscribe to and receive progress updates.</returns> /// <param name="direction">The transfer direction (upload or download) to track in the subscription callback.</param> /// <param name="mode">The desired behavior of this progress notification block.</param> /// <example> /// <code> /// class ProgressNotifyingViewModel /// { /// private IDisposable notificationToken; /// /// public void ShowProgress() /// { /// var observable = session.GetProgressObservable(ProgressDirection.Upload, ProgressMode.ReportIndefinitely); /// notificationToken = observable.Subscribe(progress => /// { /// // Update relevant properties by accessing /// // progress.TransferredBytes and progress.TransferableBytes /// }); /// } /// /// public void HideProgress() /// { /// notificationToken?.Dispose(); /// notificationToken = null; /// } /// } /// </code> /// In this example we're using <see href="https://msdn.microsoft.com/en-us/library/ff402849(v=vs.103).aspx">ObservableExtensions.Subscribe</see> /// found in the <see href="https://github.com/Reactive-Extensions/Rx.NET">Reactive Extensions</see> class library. /// If you prefer not to take a dependency on it, you can create a class that implements <see cref="IObserver{T}"/> /// and use it to subscribe instead. /// </example> public IObservable <SyncProgress> GetProgressObservable(ProgressDirection direction, ProgressMode mode) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); return(null); }
/// <summary> /// Creates an instance of <see cref="Credentials"/> to be used during development. Not enabled for Realm Object Server configured for production. /// </summary> /// <returns>An instance of <see cref="Credentials"/> that can be used in <see cref="User.LoginAsync"/></returns> public static Credentials Debug() { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); return(null); }
/// <summary> /// Creates <see cref="Credentials"/> based on a login with a nickname. If multiple users try to login /// with the same nickname, they'll get the same underlying sync user. /// </summary> /// <param name="value">The nickname of the user.</param> /// <param name="isAdmin">An optional parameter controlling whether the user is admin.</param> /// <returns> /// An instance of <see cref="Credentials"/> that can be used in <see cref="User.LoginAsync"/> /// </returns> public static Credentials Nickname(string value, bool isAdmin) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); return(null); }
public static Task <IQueryable <T> > SubscribeToObjectsAsync <T>(this Realm realm, string query) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); return(null); }
/// <summary> /// Initializes a new instance of the <see cref="SyncConfiguration"/> class. /// </summary> /// <param name="user">A valid <see cref="User"/>.</param> /// <param name="serverUri">A unique <see cref="Uri"/> that identifies the Realm. In URIs, <c>~</c> can be used as a placeholder for a user Id.</param> /// <param name="optionalPath">Path to the realm, must be a valid full path for the current platform, relative subdirectory, or just filename.</param> public SyncConfiguration(User user, Uri serverUri, string optionalPath = null) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); }
/// <summary> /// Creates <see cref="Credentials"/> based on a login with a username and a password. /// </summary> /// <param name="username">The username of the user.</param> /// <param name="password">The user's password.</param> /// <param name="createUser"><c>true</c> if the user should be created, <c>false</c> otherwise. It is not possible to create a user twice when logging in, so this flag should only be set to true the first time a user logs in.</param> /// <returns>An instance of <see cref="Credentials"/> that can be used in <see cref="User.LoginAsync"/></returns> public static Credentials UsernamePassword(string username, string password, bool createUser) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); return(null); }
/// <summary> /// Sets the feature token, associated with your edition. You only need to call it if you're using a professional /// or higher edition and only on platforms where features are disabled for lower editions. /// </summary> /// <param name="token">The feature token provided to you by the Realm team.</param> /// <seealso href="https://realm.io/docs/realm-object-server/pe-ee/#enabling-professional-and-enterprise-apis"> /// See more details on Enabling Professional and Enterprise APIs in the documentation. /// </seealso> public static void SetFeatureToken(string token) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); }
/// <summary> /// Simulates a progress update. /// </summary> /// <param name="session">Session which will report progress.</param> /// <param name="downloadedBytes">Downloaded bytes.</param> /// <param name="downloadableBytes">Downloadable bytes.</param> /// <param name="uploadedBytes">Uploaded bytes.</param> /// <param name="uploadableBytes">Uploadable bytes.</param> /// <remarks> /// Use this method to test your progress handling code without connecting to a Realm Object Server. /// Some throttling may occur at a native level, so it is recommended to use <c>Task.Delay()</c> between invocations. /// </remarks> public static void SimulateProgress(this Session session, ulong downloadedBytes, ulong downloadableBytes, ulong uploadedBytes, ulong uploadableBytes) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); }
/// <summary> /// Simulates a session error. /// </summary> /// <param name="session">The session where the simulated error will occur.</param> /// <param name="errorCode">Error code.</param> /// <param name="message">Error message.</param> /// <param name="isFatal">If set to <c>true</c> the error will be marked as fatal.</param> /// <remarks> /// Use this method to test your error handling code without connecting to a Realm Object Server. /// Some error codes, such as <see cref="ErrorCode.OtherSessionError"/> will be ignored and will not be reported /// to <see cref="Session.Error"/> subscribers. /// </remarks> public static void SimulateError(this Session session, ErrorCode errorCode, string message, bool isFatal = false) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); }
/// <inheritdoc/> public IEnumerator <ObjectSchema> GetEnumerator() { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); return(null); }
/// <summary> /// Creates <see cref="Credentials"/> based on an Active Directory login. /// </summary> /// <param name="adToken">An access token, obtained by logging into Azure Active Directory.</param> /// <returns>An instance of <see cref="Credentials"/> that can be used in <see cref="User.LoginAsync"/></returns> public static Credentials AzureAD(string adToken) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); return(null); }
/// <summary> /// Gets the <see cref="Session"/> for the realm file behind this <see cref="Realm"/>. /// </summary> /// <returns>The <see cref="Session"/> that is responsible for synchronizing with a Realm Object Server instance.</returns> /// <param name="realm">An instance of the <see cref="Realm"/> class created with a <see cref="SyncConfiguration"/> object.</param> /// <exception cref="ArgumentNullException">Thrown if <c>realm</c> is <c>null</c>.</exception> /// <exception cref="ArgumentException">Thrown if <c>realm</c> was not created with a <see cref="SyncConfiguration"/> object.</exception> public static Session GetSession(this Realm realm) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); return(null); }
/// <summary> /// Creates an instance of <see cref="Credentials"/> with a custom provider and user identifier. /// </summary> /// <param name="identityProvider">Provider used to verify the credentials.</param> /// <param name="userIdentifier">String identifying the user. Usually a username of id.</param> /// <param name="userInfo">Data describing the user further or null if the user does not have any extra data. The data will be serialized to JSON, so all values must be mappable to a valid JSON data type.</param> /// <returns>An instance of <see cref="Credentials"/> that can be used in <see cref="User.LoginAsync"/></returns> public static Credentials Custom(string identityProvider, string userIdentifier, IDictionary <string, object> userInfo) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); return(null); }
internal static string GetMappedOrOriginalName(this MemberInfo member) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); return(null); }
public SyncConfiguration(User user, Uri serverUri) { RealmPCLHelpers.ThrowProxyShouldNeverBeUsed(); }