Creating a boolean flag

4 minute read

In order to create a boolean flag, you need two things:

  • A container class for your flags

  • A defined flag inside the container class

Creating a container class and defining a feature flag

In the examples below, a container class is defined along with a Boolean flag. The flag name, videoChat, is derived from the flag variable name. This flag is false by default.

Swift
Objective-c
Android
React Native
JavaScript
Node.js
JavaScript SSR
JVM
Kotlin
.NET
Python
Go
Ruby
PHP
C
C Client Side
C++
C++ Client Side
import Foundation
import ROX
public class Flags: RoxContainer{
  public let videoChat = RoxFlag();
}
#import <ROXCore/ROXCore.h>

@interface Flags : ROXBaseContainer

@property (nonatomic) ROXFlag* videoChat;

@end


#import "Flags.h"

@implementation Flags

- (instancetype)init {
  self = [super init];
  if (self) {
    self.videoChat = [[ROXFlag alloc] init];
  }
  return self;
}

@end
public class Flags implements RoxContainer{
  public RoxFlag videoChat = new RoxFlag();
}
const flags = {
  videoChat: new Rox.Flag()
};
const flags = {
  videoChat: new Rox.Flag()
};
const flags = {
  videoChat: new Rox.Flag()
};
import {Flag} from 'rox-ssr';

const flags = {
  videoChat: new Flag()
};
public class Flags implements RoxContainer{
  public RoxFlag videoChat = new RoxFlag();
}
import kotlin.jvm.JvmField

class Flags: RoxContainer {
    @JvmField
  val videoChat = RoxFlag()
}
public class Flags : IRoxContainer
{
  public RoxFlag videoChat = new RoxFlag();
}
from rox.server.flags.rox_flag import RoxFlag

class MyContainer:
     def __init__(self):
        self.video_chat = RoxFlag()
import (
     "github.com/rollout/rox-go/server"
)

type Container struct {
     EnableTutorial server.RoxFlag
}

var flags = &Container {
     // Default value must be specified with go
   EnableTutorial: server.NewRoxFlag(false),
}
require 'rox/server/rox_server'

class Container
    attr_accessor :video_chat

  def initialize
    @video_chat = Rox::Server::RoxFlag.new
  end
end
use Rox\Server\Rox;
use Rox\Server\Flags\RoxFlag;
require __DIR__ . '/vendor/autoload.php';

class Container
{
    public $video_chat;

    public function __construct()
    {
        $this->video_chat = new RoxFlag(false);
    }
}
RoxStringBase *videoChat = rox_add_flag("demo.video_chat", false);
RoxStringBase *videoChat = rox_add_flag_with_freeze("demo.video_chat", false, RoxFreezeUntilLaunch);
auto videoChat = Rox::Flag::Create("demo.video_chat", false);
auto videoChat = Rox::Client::Flag::Create("demo.video_chat", false, RoxFreezeUntilLaunch);

Registering the container class

Once you have the container class, you need to register its instance to the CloudBees Feature Management SDK. This is done with the Rox.register() SDK function.

The namespace parameter is a logical separation between containers, and can be used to find flags on the dashboard.

Important notes

  • A namespace can only be registered once.

In the examples below, the Rox.register() SDK function is called to register the class instance:

Swift
Objective-C
Android
React Native
JavaScript
Node.js
JavaScript SSR
JVM
.NET
Python
Go
Ruby
PHP
C
C Client Side
C++
C++ Client Side
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {

  ROX.register("<namespace>", container: Flags())
  ROX.setup(withKey: ROLLOUT_KEY)
  return true
}
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    [ROX register:[[Flags alloc] init]];
    [ROX setupWithKey:@<ROLLOUT_KEY>];

    return YES;
}
public class App extends Application {

  @Override
  public void onCreate() {
    super.onCreate();

    Flags flags = new Flags();
    Rox.register("<namespace>", flags);

    Rox.setup(this);

    // This can also be done in the MainActivity if your app doesn't extends the Application class
  }
}
const flags = {
  // define Rox entities here
}
Rox.register('<namespace>', flags);
await Rox.setup('<ROLLOUT_KEY>');
const flags = {
  // define Rox entities here
}
Rox.register('<namespace>', flags);
Rox.setup('<ROLLOUT_KEY>');
const flags = {
  // define Rox entities here
}
Rox.register('<namespace>', flags);
await Rox.setup('<ROLLOUT_KEY>');
import {Rox} from 'rox-ssr';

const flags = {
  // define Rox entities here
}
Rox.register('<namespace>', flags);
Rox.setup('<ROLLOUT_KEY>');
Flags flags = new Flags();
Rox.register("<namespace>", flags);
Rox.setup(ROLLOUT_KEY);
Container flags = new Container();
Rox.Register("<namespace>", flags);
await Rox.Setup(<ROLLOUT_KEY>);
from rox.server.rox_server import Rox

flags = MyContainer()
Rox.register(<namespace>, flags)
cancel_event = Rox.setup('<ROLLOUT_KEY>').result()
package main
import "github.com/rollout/rox-go/server"

type Container struct {
     EnableTutorial server.RoxFlag
}

var flags = &Container {
     // Default value must be specified with go
   EnableTutorial: server.NewRoxFlag(false),
}
var rox *server.Rox

func main() {
  options := server.NewRoxOptions(server.RoxOptionsBuilder {})

  rox = server.NewRox()
  rox.Register("<namespace>", flags)
    <-rox.Setup("<ROLLOUT_KEY>", options)
}
require 'rox/server/rox_server'

class Container
end

flags = Container.new

Rox::Server::RoxServer.register(<namespace>, flags)
Rox::Server::RoxServer.setup(<ROLLOUT_KEY>).join
use Rox\Server\Flags\RoxFlag;
use Rox\Server\Rox;

class Container
{
    public $video_chat;

    public function __construct()
    {
        $this->video_chat = new RoxFlag();
    }
}

$container = new Container();
Rox::register(<namespace>, $container);
Rox::setup(<ROLLOUT_KEY>);
#include <rox/server.h>

#define DEFAULT_API_KEY "ROLLOUT_KEY"

int main(int argc, char **argv) {
    RoxStringBase *videoChat = rox_add_flag("demo.video_chat", false);
    rox_setup(DEFAULT_API_KEY, NULL);
    rox_shutdown();
}
#include <rox/client.h>

#define DEFAULT_API_KEY "ROLLOUT_KEY"

int main(int argc, char **argv) {
    RoxStringBase *videoChat = rox_add_flag_with_freeze("demo.video_chat", false, RoxFreezeUntilLaunch);
    rox_setup(DEFAULT_API_KEY, NULL);
    rox_shutdown();
}
#include <roxx/server.h>

#define DEFAULT_API_KEY "ROLLOUT_KEY"

using namespace Rox;

int main(int argc, char **argv) {
    auto videoChat = Rox::Flag::Create("demo.video_chat", false);
    Rox::Setup(DEFAULT_API_KEY, NULL);
    Rox::Shutdown();
}
#include <roxx/client.h>

#define DEFAULT_API_KEY "ROLLOUT_KEY"

using namespace Rox::Client;

int main(int argc, char **argv) {
    auto videoChat = Rox::Client::Flag::Create("demo.video_chat", false, RoxFreezeUntilLaunch);
    Rox::Setup(DEFAULT_API_KEY, NULL);
    Rox::Shutdown();
}

Using the flag

The last two things you need to do in the SDK is to use the flag. You can use the flag by checking the value of the flag.

The examples below show how the flag is used:

Swift
Objective-C
Android
React Native
JavaScript
Node.js
JavaScript SSR
JVM
.NET
Python
Go
Ruby
PHP
C
C++
flags.videoChat.enabled {
  print("VideoChat Feature is Enabled")
}
[myContainer.videoChat enabled:^{
  NSLog(@"VideoChat Feature is Enabled");
} disabled:^{
  // skip the tutorial
}];
if (flags.videoChat.isEnabled()) {
  Log.i(tag, "VideoChat Feature is Enabled");
}
if (flags.videoChat.isEnabled()) {
  console.log('videoChat is enabled');
}
if (flags.videoChat.isEnabled()) {
  console.log('videoChat is enabled');
}
if (flags.videoChat.isEnabled()) {
  console.log('videoChat is enabled');
}
if (flags.videoChat.isEnabled()) {
  console.log('videoChat is enabled');
}
if (flags.videoChat.isEnabled()) {
  Logger.info(tag, "VideoChat Feature is Enabled");
}
if (flags.videoChat.isEnabled() == true)
{
  // videoChat is enabled
}
if my_container.video_chat.is_enabled():
    print('video_chat is enabled')
if (flags.VideoChat.IsEnabled(nil)) {
  // start the tutorial
}
if container.video_chat.enabled?
  puts "video_chat is enabled"
end
if ($container->video_chat->isEnabled()) {
    echo 'video_chat is enabled';
}
if (rox_is_enabled(videoChat)) {
    // ...
}
if (videoChat->IsEnabled()) {
    // ...
}

Default flag values

A boolean flag is false by default. To override the value, pass the desired value to the flag.

Flag freeze level

Flag freeze is available on client side SDKs by default.

  • SDK version 4.x the default is set to untilForeground

  • SDK version 5.0 or later the default is set to none

See Understanding a flag freeze for more information.