# jRCS Client API reference
Updated: 10/23/2020, 1:48:27 PM
Created: 10/23/2020, 1:48:27 PM
Last Updated By: Mike Street
Read Time: 8 minute(s)
# Logging into a jBASE account
public void Open(string hostName, int portNumber, string userName, string password, string account);
1
Class: JConnection
Return type: void
Throws: JException;
Java:
// Log in to jBASE
jc = new JConnection();
jc.open(hostName, JConstants.JRCS_PORT, username, password, "");
1
2
3
4
2
3
4
C#:
// Log in to jBASE
JConnection jc = new JConnection
jc.Open(ipAddress, JConnection.JRCS_PORT, username, password, "");
1
2
3
4
2
3
4
# Calling jBC subroutines
public void Call(string subName, string[] parms);
public void Call(string subName);
public void Call(string subName, JDynArray[] parms);
1
2
3
2
3
Class: JConnection
Return type: void
Throws: JException;
Java:
// Call a BASIC subroutine with two arguments
JDynArray[] jargs = new JDynArray[2];
jargs[0] = new JDynArray();
jargs[1] = new JDynArray();
jc.call(“exampleSub”, jArgs);
System.out.println(jargs[0]);
System.out.println(jargs[1]);
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
C#:
// Call a BASIC subroutine with two arguments
JDynArray[] Params = new JDynArray[7];
Params[0] = new JDynArray();
Params[1] = new JDynArray();
Conn.Call("examplesub", Params);
string result = "arg1 = " + Params[0].ToString() + Environment.NewLine + "arg2 = " + Params[1].ToString();
1
2
3
4
5
6
7
2
3
4
5
6
7
# Opening a jBASE file
A jRCS Connection must have been opened prior to opening a file.
public JFile OpenFile(string fileName);
1
Class: JConnection
Return type: JFile
Throws: JException;
Java:
//Open a jBASE file
JFile testFile = jc.OpenFile("TestFile");
1
2
3
2
3
C#:
//Open jBASE file
JFile testFile = Conn.OpenFile("TestFile");
1
2
3
2
3
# jBASE files operations
A jBASE file must have been opened prior to carrying out any of these file operations.
These are some of the methods defined in interface JFile,
public JDynArray Read(string key, bool locked, bool wait);
public JDynArray Read(string key, bool locked);
public JDynArray Read(string key);
public void Write(string key, JDynArray data);
public void Write(string key, JDynArray data, bool unlock);
1
2
3
4
5
2
3
4
5
Class: JFile
Return type: JDynArray
Throws: JException
Java:
// Read a record from an opened file
JDynArray rec = testFile.read(id, false, false);
1
2
3
4
2
3
4
C#:
// Read a record from an opened file
JDynArray jDynArray = testFile.Read(RecId, false, false);
1
2
3
2
3
Class: JFile
Return type: JDynArray
Throws: JException
jRCS record locking will wait indefinitely for a lock; it is recommended to use the "wait" function only on records that are expected to be available. Alternatively, you can read without a wait, and catch the exception thrown to check for a lock.
Java:
// Read a record from an opened file with locking, wait (ReadU)
JDynArray rec = testFile.read(id, true, true);
1
2
3
2
3
C#:
// Read a record from an opened file with locking, no wait (ReadU)
JDynArray jDynArray = testFile.Read(RecId, true, false);
1
2
3
2
3
Class: JFile
Return type: void
Throws: JException;
Java:
// Write a record to a previously opened file, releasing the lock
testFile.write(id,rec);
1
2
3
2
3
C#:
// Write a record to a previously opened file, releasing the lock
testFile.Write(RecId, jDynArray, true);
1
2
3
2
3
Class: JFile
Return type: void
Throws: JException;
Java:
// Write a record to a previously opened file, preserving the lock (WriteU)
testFile.write(id,rec, false);
1
2
3
2
3
C#:
// Write a record to a previously opened file, preserving the lock (WriteU)
testFile.Write(RecId, jDynArray, false);
1
2
3
2
3
# Executing a jBASE command
public JExecuteResults Execute(string command, JExecFlags flags);
public enum JExecFlags
{
EXEC_DEFAULT = 0,
EXEC_GET_CAPTURE = 1,
EXEC_GET_RETURNSTRING = 2,
EXEC_GET_RETURNLIST = 4
}
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
Class: JConnection
Return type: JExecuteResults
Throws: JException;
Java:
// Execute a jBASE command
JExecuteResults res;
int flags = 1;
String command = "jshow -c jrcssub";
res = jc.execute(command, flags); // This is the equivalent of JExecFlags.EXEC_GET_CAPTURE
String result = res.getCaptureString();
1
2
3
4
5
6
7
2
3
4
5
6
7
C#:
// Execute a jBASE command
private const JExecFlags Flags = JExecFlags.EXEC_GET_CAPTURE | JExecFlags.EXEC_GET_RETURNLIST | JExecFlags.EXEC_GET_RETURNSTRING;
string strCommand = "jdiag -dvL";
JExecuteResults Results = Conn.Execute(strCommand, Flags);
string strTemp = Results.CaptureString;
1
2
3
4
5
6
2
3
4
5
6
# Obtaining the current jBASE internal date
public int Date { get; }
public string OConv(string source, string code);
1
2
2
Class: JConnection
Return type: int
Throws: JException;
Java:
// Obtain the date from jBASE in internal format and convert to external format
int thisDate = jc.getDate();
String currentDate = jc.oConv(String.valueOf(thisDate), "D4");
1
2
3
4
2
3
4
C#:
// Obtain the date from jBASE in internal format and convert to external format
int thisDate = jc.Date;
string currentDate = jc.OConv(thisDate.ToString(), "D4");
1
2
3
4
2
3
4
# Executing jQL queries
public JExecuteResults ExecuteAndStore(string command, JExecFlags flags);
public JExecuteResults ExecuteAndStore(string command, JExecFlags flags, JSelectList passList);
public JExecuteResults ExecuteAndStore(string command, JExecFlags flags, JSelectList passList, int blockSize);
1
2
3
2
3
Class: JConnection
Return type: JExecuteResults
Throws: JException;
Java:
// Execute a jQL query
static char esc = '\u001B';
static char AM = JConstants.AM;
static JExecuteResults res;
static JCapture cap;
int flags = 7;
String blk = null;
String pageBrk = String.format("{0}[H{0}[J", esc);
String report = "";
command = "SORT CUSTOMER BY CUS.NAME CUS.NAME CUS.CITY CUS.PHONE (N";
JSelectList jsl = null;
res = jc.executeAndStore(command, flags, jsl, blockSize);
if (res instanceof JExecuteResults)
{
cap = res.getCapture();
if (cap instanceof JCapture)
{
while (!cap.atEnd())
{
blk = cap.nextBlock();
blk = blk.replace(AM, '\n');
blk = blk.replace(pageBrk, System.lineSeparator() + System.lineSeparator());
report = report + blk;
}
}
}
System.out.println(report);
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
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
C#:
// Execute a jQL query
private const JExecFlags Flags = JExecFlags.EXEC_GET_CAPTURE | JExecFlags.EXEC_GET_RETURNLIST | JExecFlags.EXEC_GET_RETURNSTRING;
JExecuteResults Result = null;
JCapture Cap = null;
string Blk = null;
string PageBrk = string.Format("{0}[H{0}[J", (char)27);
string Report = "";
string Command = "SORT CUSTOMER BY CUS.NAME CUS.NAME CUS.CITY CUS.PHONE (N";
JSelectList Dummy = null;
Result = jc.ExecuteAndStore(Command, Flags, Dummy, 2048);
if (Result is JExecuteResults)
{
Cap = Result.Capture;
if (Cap is JCapture)
{
while (!(Cap.AtEnd))
{
Blk = Cap.NextBlock();
Blk = Blk.Replace(JDynArray.AM.ToString(), "\n");
Blk = Blk.Replace(PageBrk, Environment.NewLine + Environment.NewLine);
Report = Report + Blk;
}
}
}
Console.WriteLine(Report);
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
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
# Get the current jBASE version
public int Time { get; }
public string Locale { get; }
public JDynArray jBaseVersion { get; }
public int Date { get; }
public string CodePage { get; }
public int Port { get; }
1
2
3
4
5
6
2
3
4
5
6
Class: JConnection
Return type: various
Throws: JException;
Java:
// Get jBASE version
JDynArray jbaseVersion = jc.getjBaseVersion();
String versionNumber = jbaseVersion.extract(1) + "." + jbaseVersion.extract(2);
System.out.println("Current jBASE version is " + versionNumber + "!");
1
2
3
4
5
2
3
4
5
// Get jBASE version
JDynArray jbaseVersion = jc.jBaseVersion;
string versionNumber = jbaseVersion.Extract(1) + "." + jbaseVersion.Extract(2);
Console.WriteLine(value: "Current jBASE version is " + versionNumber + "!");
1
2
3
4
2
3
4
# jDynArray manipulation
public void Assign(JDynArray src);
public void Assign(string src);
public int Count(char delim);
public int Count(string delim);
public int DCount(string delim);
public int DCount(char delim);
public void Delete(int amc, int vmc, int svmc);
public void Delete(int amc, int vmc);
public void Delete(int amc);
public string Extract(int amc);
public string Extract(int amc, int vmc);
public string Extract(int amc, int vmc, int svmc);
public JDynArray ExtractDA(int amc, int vmc);
public JDynArray ExtractDA(int amc, int vmc, int svmc);
public JDynArray ExtractDA(int amc);
public string Field(char delim, int fieldNo);
public string Field(string delim, int fieldNo);
public void Insert(string data, int amc, int vmc);
public void Insert(string data, int amc);
public void Insert(JDynArray data, int amc);
public void Insert(JDynArray data, int amc, int vmc);
public void Insert(JDynArray data, int amc, int vmc, int svmc);
public void Insert(string data, int amc, int vmc, int svmc);
public void InsertDA(JDynArray data, int amc);
public void InsertDA(JDynArray data, int amc, int vmc, int svmc);
public void InsertDA(JDynArray data, int amc, int vmc);
public int Locate(string searchStr, int amc, int vmc, string order, int start);
public int Locate(string searchStr, int amc, string order, int start);
public int Locate(string searchStr, int amc, int vmc, string order);
public int Locate(string searchStr, int amc, string order);
public int Locate(string searchStr);
public int Locate(string searchStr, string order);
public int LocateIgnoreCase(string searchStr);
public int LocateIgnoreCase(string searchStr, string order);
public int LocateIgnoreCase(string searchStr, int amc, string order);
public int LocateIgnoreCase(string searchStr, int amc, int vmc, string order);
public int LocateIgnoreCase(string searchStr, int amc, string order, int start);
public int LocateIgnoreCase(string searchStr, int amc, int vmc, string order, int start);
public void Replace(string data, int amc);
public void Replace(string data, int amc, int vmc);
public void Replace(string data, int amc, int vmc, int svmc);
public void Replace(JDynArray data, int amc);
public void Replace(JDynArray data, int amc, int vmc);
public void Replace(JDynArray data, int amc, int vmc, int svmc);
public void ReplaceDA(JDynArray data, int amc);
public void ReplaceDA(JDynArray data, int amc, int vmc);
public void ReplaceDA(JDynArray data, int amc, int vmc, int svmc);
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
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
Class: JDynarray
Return type: various
Throws: JException;
Java:
// Sample jDynArray instructions
JDynArray dynTest = new JDynArray();
dynTest.insert("One", 1);
dynTest.replace("Two", 2);
JDynArray dynTest2 = new JDynArray("Three");
dynTest.insertDA(dynTest2, 3);
dynTest.insert("This is a long string of text", -1);
String tempTest = dynTest.extract(3);
int locVar = dynTest.locate("Three", "");
String locVarContent = dynTest.extract(locVar);
String locVarContentAgain = dynTest.field(JConstants.AM, locVar);
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
C#:
// Sample jDynArray instructions
JDynArray dynTest = new JDynArray();
dynTest.Insert("One", 1);
dynTest.Replace("Two", 2);
JDynArray dynTest2 = new JDynArray("Three");
dynTest.InsertDA(dynTest2, 3);
dynTest.Insert("This is a string of text", -1);
string tempTest = dynTest.Extract(3);
int locVar = dynTest.Locate("Three", "");
string locVarContent = dynTest.Extract(locVar);
string locVarContentAgain = dynTest.Field(JDynArray.AM, locVar);
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
# Note
The behaviour of JDynArray in jRCS and the jRCS client is not guaranteed to be the same as the behaviour of strings in BASIC.
Here is the Javadoc header for the 3-parameter Locate function:
/**
* Searches for a string in all values within a given attribute of the dynamic array.
* The values are in the specified sort order.
*
* @param searchStr String to look for
* @param amc Attribute number
* @param order Order of values, interpreted as follows:
* <p> "AL" - ascending, left-justified
* <p> "AR" - ascending, right-justified
* <p> "AN" - ascending, numeric
* <p> "DL" - descending, left-justified
* <p> "DR" - descending, right-justified
* <p> "DN" - descending, numeric
* <p> "" - no order
* @return Positive index of matching value or negative index of insertion
* point if a match is not found. If order is specified as a blank string, the
* function always returns -1 to indicate that the string was not found.
* @throws JException
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19