internal static String MarshalAndRelease(IntPtr pStr) { // TODO: figure out if this works String retVal = Marshal.PtrToStringAnsi(pStr); P4Bridge.ReleaseString(pStr); return(retVal); }
private static void RestoreP4Prefs() { P4Bridge.ReloadEnviro(); for (int i = 0; i < settings.Length; i++) { P4Server.Set(settings[i], settingValues[i]); } }
internal void SetPromptCallback() { if (PromptCallbackFn_Int == null) { // initialize on first setting PromptCallbackFn_Int = new P4CallBacks.PromptDelegate(PromptCallback_Int); pPromptCallbackFn = Marshal.GetFunctionPointerForDelegate(PromptCallbackFn_Int); P4Bridge.SetPromptCallbackFn(pServer, pPromptCallbackFn); } }
/// <summary> /// Set the callback used to return real time info output. /// </summary> internal void SetInfoResultsCallback() //InfoResultsDelegate cb ) { if (InfoResultsCallbackFn_Int == null) { // initialize on first setting InfoResultsCallbackFn_Int = new P4CallBacks.InfoResultsDelegate(InfoResultsCallback_Int); pInfoResultsCallbackFn = Marshal.GetFunctionPointerForDelegate(InfoResultsCallbackFn_Int); P4Bridge.SetInfoResultsCallbackFn(pServer, pInfoResultsCallbackFn); } }
/// <summary> /// Set the callback used to return real time binary output. /// </summary> /// <remarks> /// Far large output, the client may receive multiple callbacks. /// Simply concatenate the data to get the complete data. /// </remarks> internal void SetBinaryResultsCallback() { if (BinaryResultsCallbackFn_Int == null) { // initialize on first setting BinaryResultsCallbackFn_Int = new P4CallBacks.BinaryResultsDelegate(BinaryResultsCallback_Int); pBinaryResultsCallbackFn = Marshal.GetFunctionPointerForDelegate(BinaryResultsCallbackFn_Int); P4Bridge.SetBinaryResultsCallbackFn(pServer, pBinaryResultsCallbackFn); } }
/// <summary> /// Set the callback used to return real time Errors. /// </summary> internal void SetErrorCallback() { if (ErrorCallbackFn_Int == null) { // initialize on first setting ErrorCallbackFn_Int = new P4CallBacks.ErrorDelegate(ErrorCallback_Int); pErrorCallbackFn = Marshal.GetFunctionPointerForDelegate(ErrorCallbackFn_Int); P4Bridge.SetErrorCallbackFn(pServer, pErrorCallbackFn); } }
//We'll receive multiple calls for each StrDict object, one for each // key:value pair that will get combined into a single TaggedObject. /// <summary> /// Delegate used to send real time tagged results generated by a /// command /// </summary> /// <remarks> /// We receive multiple calls for each StrDict object, one for each /// key:value pair that will get combined into a single TaggedObject used /// to represent an 'object'. This client delegate receives a single /// TaggedObject representing the complete object. /// </remarks> internal void SetTaggedOutputCallback() { if (TaggedOutputCallbackFn_Int == null) { // initialize on first setting TaggedOutputCallbackFn_Int = new P4CallBacks.TaggedOutputDelegate(TaggedOutputCallback_Int); pTaggedOutputCallbackFn = Marshal.GetFunctionPointerForDelegate(TaggedOutputCallbackFn_Int); P4Bridge.SetTaggedOutputCallbackFn(pServer, pTaggedOutputCallbackFn); } }
/// <summary> /// Set the character set encoding used to pass parameters to a Unicode /// enabled server. /// </summary> /// <remarks> /// This is handled automatically after connecting with a P4 server. /// </remarks> /// <param name="charSet">connection characterset</param> /// <param name="FileCharSet">filename characterset</param> internal void SetCharacterSet(String charSet, String FileCharSet) { IntPtr pErrorStr = P4Bridge.SetCharacterSet(pServer, charSet, FileCharSet); if (pErrorStr == IntPtr.Zero) // no error { return; } String ErrorMsg = MarshalPtrToString(pErrorStr); P4Bridge.ReleaseString(pErrorStr); throw new P4Exception(ErrorSeverity.E_FAILED, ErrorMsg); }
/// <summary> /// Thread entry point for running more P4Servers /// </summary> private static void ParallelTransferThread(object args) { ParallelTransferArgs transferArgs = (ParallelTransferArgs)args; // make a new connection to the server and run the command // we should not need trust or fingerprint as this should initiate from a successful (trusted) session using (P4Server target = new P4Server(transferArgs.original)) { // add the server for the original P4Server lock (transferArgs.original.parallelServers) { transferArgs.original.parallelServers.Add(target); } // set the dictionary as protocol settings foreach (KeyValuePair p in transferArgs.dict) { P4Bridge.SetProtocol(target.pServer, p.Key, p.Value); } try { // Note: due to legacy (unused) cmdId code in p4bridge, cmdId < 0 will explicitly not call // the assigned callbacks. set the cmdId from the other's cmdId generator if (target.RunCommand(transferArgs.cmd, transferArgs.original.getCmdId(), true, transferArgs.args, transferArgs.args.Length)) { target.Disconnect(); return; } } catch (P4Exception e) { Debug.Trace(e.Message); } // grab the errors and inject them into the original P4Server P4ClientErrorList list = target.GetErrorResults(0); // sometimes we get here without client errors (e.g. disconnect?) if (transferArgs.original.parallelErrors != null && list != null) { // make sure the threads don't step on each other lock (transferArgs.original.parallelErrors) { foreach (P4ClientError e in list) { transferArgs.original.parallelErrors.Add(e); } } } } }
/// <summary> /// Translate a file path from on side of the mapping to the other /// </summary> /// <param name="path">The path to translate</param> /// <param name="direction">The direction to perform the translation L->R or R->L</param> /// <returns>Translated path, Null if no translation (path is not mapped)</returns> public String Translate(String path, Direction direction) { IntPtr pStr = IntPtr.Zero; if (UseUnicode) { using (PinnedByteArray pPath = MarshalStringToIntPtr(path)) { pStr = TranslateW(pMapApi, pPath, direction); } } else { pStr = TranslateA(pMapApi, path, direction); } if (pStr != IntPtr.Zero) { String translation = MarshalPtrToString(pStr); P4Bridge.ReleaseString(pStr); return(translation); } return(null); }