Examples

// tolower.cpp - Take one string from the command line and make it lowercase.
 
#include <RC/RC.h>
 
// This provides using namespace for RC and std.
// It is recommended to use it for fast prototyping, but only in cpp files.
RC_USE
 
// This wraps argc and argv as RC::Data1D<RC::RStr> args.
RC_MAIN {
  if (args.size() < 2) {
    cerr << args[0] << " <string>\n";
    return -1;
  }
 
  RC::RStr str = args[1];
 
  // For each character
  for (char &c : str) {
    // If it's between 'A' and 'Z' inclusive
    if ('A' <= Betw(c) <= 'Z') {
      // Make it lowercase.
      c += 'a' - 'A';
    }
  }
 
  cout << str << endl;
 
  return 0;
}
 

---

// battery.cpp - Determine the battery state from the Linux power_supply files.
 
#include "RC/RC.h"
 
RC_USE
 
const RStr dir_base = "/sys/class/power_supply/";
 
// Read a line from a file.
RStr GetFile(const RStr& filename) {
  // Concatenate the strings.
  RStr pathname = dir_base + filename;
 
  // Open the file for reading.
  FileRead br(pathname);
 
  // Get one line as an RStr
  RStr retval;
  br.Get(retval);
 
  return retval;
}
 
RC_MAIN {
  // Output whether or not the AC is plugged in.
  // The RC::RStr::Get_bool checks for true, T, or a non-zero number.
  cout << "AC is " << (GetFile("AC/online").Get_bool() ? "on" : "off") << endl;
 
  // Read the current, full, and design-peak energy levels.
  // Unsigned integers are extracted from the RStr.
  u64 current = GetFile("BAT0/energy_now").Get_u64();
  u64 lastfull = GetFile("BAT0/energy_full").Get_u64();
  u64 designfull = GetFile("BAT0/energy_full_design").Get_u64();
 
  // Calculate the percent full the battery is.
  u32 perc = 100 * current / (f64) lastfull + 0.5;
  // Calculate how close to ideal the battery is.
  f64 quality = lastfull / (f64) designfull;
 
  cout << "Battery:  " << perc << "%" << endl;
  cout << "Quality:  " << RStr(quality,FIXED,2) << endl;
 
  return 0;
}

---

// randomize_lines.cpp - Shuffle the lines from stdin.
 
#include <RC/RC.h>
 
RC_USE
 
RC_MAIN {
  size_t max_lines_out = -1;  // Max size_t
 
  // If there are more arguments than the program name.
  if (args.size() > 1) {
    // Check to see if a number was given.
    if (args[1].Is_u64()) {
      // If so, get it.
      max_lines_out = args[1].Get_u64();
    }
    else {
      // If the argument was not a number, print the help.
      cerr << args[0] << " [max_lines_out]\n";
      return -1;
    }
  }
 
  // Open stdin as a FileRead
  FileRead fr(stdin, false);
 
  // Get all the lines until end-of-file.
  Data1D<RStr> lines;
  fr.GetAll(lines);
 
  // Randomize the order of the lines.
  lines.Shuffle();
 
  // Shrink the array if we should output fewer lines.
  // Note this does not reallocate.
  if (lines.size() > max_lines_out) {
    lines.Resize(max_lines_out);
  }
 
  // Output the remaining lines.
  for (RStr line : lines) {
    cout << line << endl;
  }
 
  return 0;
}
 

---

// parse_and_sum.cpp - Parse and process some comma-separated values.
 
#include <RC/RC.h>
 
RC_USE
 
RC_MAIN {
  RStr numstr = "3.14, 5.7, 8, 12";
 
  // Split the comma-separated values into an array.
  Data1D<RStr> str_arr = numstr.SplitCSV();
 
  // Sum the array of numbers
  f64 sum = 0;
  for (RStr x : str_arr) {
    sum += x.Get_f64();  // Convert to a 64-bit float.
  }
 
  // Outputs "3.14 + 5.7 + 8 + 12 = 28.84"
  cout << RStr::Join(str_arr, " + ") << " = " << sum << endl;
 
  return 0;
}

---

// random_average.cpp - Generate and average 5000 numbers.
 
#include <RC/RC.h>
 
RC_USE
 
RC_MAIN {
  // Seeds the random number generator with the high precision clock.
  RND rng;
  // Initializes the timer.
  Time timer;
 
  // Appends 5000 random 64-bit floats from [0,1) to vals.
  Data1D<f64> vals;
  for (u64 r=0; r<5000; r++) {
    vals += rng.Get_f64();;
  }
 
  // Calculates the average.
  f64 avg=0;
  for (size_t i=0; i<vals.size(); i++) {
    avg += vals[i];
  }
  avg /= vals.size();
 
  // Reports how long it took, to a fraction of a second.
  cout << "It took " << timer.SinceStart() << " seconds.\n";
 
  // A flushed stderr printout of "random_average.cpp:30, avg = 0.496605"
  RC_DEBOUT(avg);
 
  // Reports if the avg was in an acceptable range.
  cout << "The average was " << (0.48 < Betw(avg) < 0.52 ? "good\n" : "bad\n");
 
  return 0;
}

---

// callback.cpp - Processes a callback with a Caller, and returns a Tuple.
 
#include <RC/RC.h>
 
RC_USE
 
class Doer {
  public:
 
  Tuple<u16, RStr> DoStuff(Caller<void, f32> callback) {
    RND rng;
    f32 val = rng.Get_f32();
 
    // Because of what was passed in, this will call w.CallBack, even
    // though it knows nothing of the Waiter class.
    callback(val);
 
    // Implicitly returns a Tuple.
    return {rng.Get_u16(), "apples"};
  }
};
 
 
class Waiter {
  public:
 
  void CallIt(Doer &d) {
    // Pass a Caller<void, f32> to DoStuff, and receive a Tuple back.
    auto tup = d.DoStuff(MakeCaller(this, &Waiter::CallBack));
 
    // Alternatively one can construct the Caller like this.
    auto tup2 = d.DoStuff({this, &Waiter::CallBack});
 
    // Prints a value like "It returned 51813 apples"
    cout << "It returned " << tup.Get<0>() << " " << tup.Get<1>() << endl;
  }
 
  // Receives a call back from DoStuff
  void CallBack(f32 x) {
    cout << "I got x == " << x << endl;
  }
};
 
 
RC_MAIN {
  Doer d;
  Waiter w;
 
  w.CallIt(d);
 
  return 0;
}