Device detection

using (var pipeline = new DeviceDetectionPipelineBuilder(
        loggerFactory)
    .UseOnPremise(dataFile, null, false)
    .SetPerformanceProfile(PerformanceProfiles.LowMemory)
    .SetShareUsage(false)
    .SetAutoUpdate(false)
    .SetDataUpdateOnStartUp(false)
    .SetDataFileSystemWatcher(false)
    .Build())
{
    using (var data = pipeline.CreateFlowData())
    {
        data.AddEvidence(evidence);
        data.Process();
        var device = data.Get<IDeviceData>();
    }
}

The full C# on-premise example

using (var pipeline = new FiftyOnePipelineBuilder(
        loggerFactory, serviceProvider)
    .BuildFromConfiguration(pipelineOptions))
{
    using (var data = pipeline.CreateFlowData())
    {
        data.AddEvidence(evidence);
        data.Process();
        var device = data.Get<IDeviceData>();
    }
}

The full C# cloud example

System.setProperty("TestDataFile", dataFileLocation);
PipelineOptions pipelineOptions =
    PipelineOptionsFactory.getOptionsFromFile(optionsFile);
try (Pipeline pipeline = new FiftyOnePipelineBuilder()
        .buildFromConfiguration(pipelineOptions)) {
    try (FlowData data = pipeline.createFlowData()) {
        data.addEvidence(evidence);
        data.process();
        DeviceData device = data.get(DeviceData.class);
    }
}

The full Java on-premise example

try (Pipeline pipeline = new DeviceDetectionPipelineBuilder()
        .useCloud(resourceKey)
        .build()) {
    try (FlowData data = pipeline.createFlowData()) {
        data.addEvidence(evidence);
        data.process();
        DeviceData device = data.get(DeviceData.class);
    }
}

The full Java cloud example

const pipeline = new DeviceDetectionOnPremisePipelineBuilder({
  dataFile,
  performanceProfile: 'LowMemory',
  shareUsage: false,
  autoUpdate: false,
  updateOnStart: false,
  fileSystemWatcher: false
}).build();
const data = pipeline.createFlowData();
evidence.forEach((value, key, map) => {
  data.evidence.add(key, value);
});
await data.process();
const device = data.device;

The full Node.js on-premise example

const pipeline = new PipelineBuilder()
    .buildFromConfiguration(options);
const data = pipeline.createFlowData();
evidence.forEach((value, key, map) => {
  data.evidence.add(key, value);
});
await data.process();
const device = data.device;

The full Node.js cloud example

pipeline = DeviceDetectionPipelineBuilder(
    data_file_path = data_file,
    performance_profile = "MaxPerformance",
    usage_sharing = False,
    auto_update = False,
    licence_keys = "").add_logger(logger).build()
with pipeline.create_flowdata() as data:
    data.evidence.add_from_dict(evidence)
    data.process()
    device = data.device

The full Python on-premise example

pipeline = PipelineBuilder().add_logger(
    logger).build_from_configuration(config)
data = pipeline.create_flowdata()
data.evidence.add_from_dict(evidence)
data.process()
device = data.device

The full Python cloud example

$engine = new DeviceDetectionOnPremise([
    'performanceProfile' => 'LowMemory',
]);
$pipeline = (new PipelineBuilder())
    ->add($engine)
    ->addLogger($logger)
    ->build();
$data = $pipeline->createFlowData();
$data->evidence->setArray($evidence);
$data->process();
$device = $data->device;

The full PHP on-premise example

$pipeline = (new PipelineBuilder())
    ->addLogger($logger)
    ->buildFromConfig($config);
$data = $pipeline->createFlowData();
$data->evidence->setArray($evidence);
$data->process();
$device = $data->device;

The full PHP cloud example

let pipeline = DeviceDetectionPipelineBuilder::on_premise(
        &options.data_file)
    .performance_profile(options.profile)
    .share_usage(false)
    .auto_update(false)
    .build()
    .context(
    "failed to build the on-premise device-detection pipeline")?;
let mut data = pipeline.create_flow_data_with(
    Evidence::builder()
        .add_all(pairs.iter().map(|(k, v)| (*k, *v)))
        .build(),
);
data.process()
    .context("on-premise pipeline processing failed")?;
let device = data
    .get(DEVICE_DATA_KEY)
    .context(
        "the Hash engine should have produced device data")?;

The full Rust on-premise example

let mut builder =
    DeviceDetectionPipelineBuilder::cloud(options.resource_key);
if let Some(endpoint) = options.endpoint {
    builder = builder.endpoint(endpoint);
}
let pipeline = builder
    .share_usage(false)
    .build()
    .context(
        "failed to build the cloud device-detection pipeline")?;
let mut data = pipeline.create_flow_data_with(
    Evidence::builder()
        .add_all(pairs.iter().map(|(k, v)| (*k, *v)))
        .build(),
);
data.process().context("cloud pipeline processing failed")?;
match data.get(DEVICE_DATA_KEY) {
    Some(device) => {
    }
    None => {
    }
}

The full Rust cloud example

config := dd.NewConfigHash(dd.Default)
engine, err := onpremise.New(
    onpremise.WithConfigHash(config),
    onpremise.WithDataFile(params.DataFile),
    onpremise.WithAutoUpdate(false),
)
results, err := engine.Process(evidence)
propertyName := "IsMobile"
value, err := results.ValuesString(
    propertyName,
    ",")

The full Go on-premise example

StatusCode status = HashInitManagerFromFile(
    &manager,
    config,
    &properties,
    dataFilePath,
    exception);
ResultsHash *results = ResultsHashCreate(&manager, 1);
EvidenceKeyValuePairArray* evidenceArray =
    EvidenceCreate(evs->count);
for (uint32_t j = 0; j < evs->count; j++) {
    EvidenceAddString(
        evidenceArray,
        evs->items[j].prefix,
        evs->items[j].key,
        evs->items[j].value);
}
ResultsHashFromEvidence(results, evidence, exception);
ResultsHashGetValuesString(
    results,
    propertyName,
    valueBuffer,
    valueBufferLength,
    (char* const)",",
    exception);

The full C on-premise example

// The 51Degrees C library runs device detection
// inside your own program, so there is no cloud version.
// Choose On-premise for its example.

load_module %%MODULE_PATH%%modules/ngx_http_51D_module.so;
http {
    51D_file_path %%FILE_PATH%%;
    server {
        location /hash {
            51D_match_ua x-device BrowserName,PlatformName;
            51D_match_ua_client_hints x-device-hinted
                BrowserName,PlatformName;
            51D_match_all x-mobile IsMobile;
            add_header x-device $http_x_device;
            add_header x-device-hinted $http_x_device_hinted;
            add_header x-mobile $http_x_mobile;
        }
    }
}

The full NGINX on-premise example

# NGINX runs the 51Degrees C library for device detection
# inside the web server, so there is no cloud version.
# Choose On-premise for its example.

import fiftyonedegrees;
sub vcl_recv {
    set req.http.X-IsMobile = fiftyonedegrees.match_single(
        req.http.user-agent, "IsMobile");
}
sub vcl_deliver {
    set resp.http.X-IsMobile = fiftyonedegrees.match_single(
        req.http.user-agent, "IsMobile");
}
sub vcl_init {
    fiftyonedegrees.start(
        "/etc/varnish/51Degrees-LiteV4.1.hash");
}

The full Varnish on-premise example

# Varnish runs the 51Degrees C library for device detection
# inside the cache, so there is no cloud version.
# Choose On-premise for its example.