CPIXMessage message;
...
// Add elements to the message.
...

// Simply call the ToString() function to obtain a std::string of the XML
// generated from the message object.
std::string xml = message.ToString();

CPIXMessage message;

std::unique_ptr<ContentKey> key(new ContentKey);
key->set_key_id(kid_raw_bytes);
key->SetKeyValue(key_value_raw_bytes);

message.AddContentKey(std::move(key));

CPIXMessage message;

std::unique_ptr<ContentKey> key(new ContentKey);
key->set_key_id(kid_raw_bytes);
key->SetKeyValue(key_value_raw_bytes);

message.AddContentKey(std::move(key));

std::unique_ptr<Recipient> rcpt(new Recipient);
rcpt->set_delivery_key(der_formatted_X509_certificate);
message.AddRecipient(std::move(rcpt));

CPIXMessage message;

// After this function call, all content from the supplied document will be
// deserialized into |message|.
message.FromString(string_form_of_cpix_document);

CPIXMessage message;

message.FromString(string_form_of_cpix_document);

// If the supplied private key matches one of the certificates in the newly
// deserialized document, the ContentKeys will be decrypted.
message.DecryptWith(der_encoded_private_key);

CPIXMessage message;

// First ContentKey and UsageRule
std::unique_ptr<ContentKey> sd_key(new ContentKey);
sd_key->set_key_id(sd_kid_raw_bytes);
sd_key->SetKeyValue(sd_key_value_raw_bytes);

message.AddContentKey(std::move(sd_key));

std::unique_ptr<UsageRule> sd_rule(new UsageRule);

// Create structs (defined in usage_rule.h) for the filters you want.
VideoFilter sd_video_filter;
sd_video_filter.min_pixels = 0;
sd_video_filter.max_pixels = 768 * 576;

// Add filters to the rule. Any valid set of rules, however dense or sparse,
// can be added to a single UsageRule.
sd_rule->AddVideoFilter(sd_video_filter);

// Since each UsageRule maps to a single ContentKey, the |kid_| field MUST be
// populated before adding the UsageRule to a CPIXMessage. See "Adding DRMSystem
// and UsageRule without explicit Key ID" for exception.
sd_rule->set_key_id(sd_key->key_id());

message.AddUsageRule(std::move(sd_rule));

// Second ContentKey and UsageRule
std::unique_ptr<ContentKey> hd_key(new ContentKey);
hd_key->set_key_id(hd_kid_raw_bytes);
hd_key->SetKeyValue(hd_key_value_raw_bytes);

message.AddContentKey(std::move(hd_key));

std::unique_ptr<UsageRule> hd_rule(new UsageRule);

VideoFilter hd_video_filter;
hd_video_filter.min_pixels = 768 * 576 + 1;
hd_video_filter.max_pixels = 1920 * 1080;

hd_rule->AddVideoFilter(hd_video_filter);

hd_rule->set_key_id(hd_key->key_id());

message.AddUsageRule(std::move(hd_rule));

CPIXMessage message;

// First ContentKey and UsageRule
std::unique_ptr<ContentKey> sd_key(new ContentKey);
sd_key->set_key_id(sd_kid_raw_bytes);
sd_key->SetKeyValue(sd_key_value_raw_bytes);

message.AddContentKey(std::move(sd_key));

std::unique_ptr<UsageRule> sd_rule(new UsageRule);

sd_rule.AddLabelFilter("SD");

// Since each UsageRule maps to a single ContentKey, the |kid_| field MUST be
// populated before adding the UsageRule to a CPIXMessage. See "Adding DRMSystem
// and UsageRule without explicit Key ID" for exception.
sd_rule->set_key_id(sd_key->key_id());

message.AddUsageRule(std::move(sd_rule));

// Second ContentKey and UsageRule
std::unique_ptr<ContentKey> hd_key(new ContentKey);
hd_key->set_key_id(hd_kid_raw_bytes);
hd_key->SetKeyValue(hd_key_value_raw_bytes);

message.AddContentKey(std::move(hd_key));

std::unique_ptr<UsageRule> hd_rule(new UsageRule);

hd_rule->AddLabelFilter("HD");

hd_rule->set_key_id(hd_key->key_id());

message.AddUsageRule(std::move(hd_rule));

// Create a new KeyPeriodFilter and set the period by index or explicit
// time interval.
std::unique_ptr<KeyPeriod> key_period(new KeyPeriod);
key_period->SetIndex(1001);

// Set the KeyPeriod's |id| (to be referenced by a UsageRule).
key_period->set_id("key_period_1");

// Add it to some existing message.
message.AddKeyPeriod(std::move(key_period));

// Create a new UsageRule
std::unique_ptr<UsageRule> rule(new UsageRule);
//Set the Key ID
rule->set_key_id(kid_raw_bytes_of_existing_content_key);

// Add a new KeyPeriodFilter by referencing the |id| of an existing filter.
// Multiple UsageRules may reference the same KeyPeriod.
rule->AddKeyPeriodFilter("key_period_1");

// Add the UsageRule to the same existing message.
message.AddUsageRule(std::move(rule));

std::unique_ptr<DRMSystem> drm(new DRMSystem);
// System ID is a required field of DRMSystem.
drm->set_system_id(system_id_raw_bytes);

// Any or all of these data fields may be set for DRMSystem. See DRMSystem.h for
// a complete list.
drm->set_content_protection_data(content_protection_data_raw_bytes);
drm->set_hls_signaling_master(hls_signaling_master_raw_bytes);
drm->set_hls_signaling_media(hls_signaling_media_raw_bytes);

// Since each DRMSystem maps to a single ContentKey, the |kid_| field MUST be
// populated before adding the UsageRule to a CPIXMessage. See "Adding DRMSystem
// and UsageRule without explicit Key ID" for exception.
drm->set_key_id(kid_raw_bytes_of_existing_content_key);

// Add the DRMSystem to some existing message.
message.AddDRMSystem(std::move(drm));

CPIXMessage message;

std::unique_ptr<ContentKey> key(new ContentKey);
key->set_key_id(kid_raw_bytes);
key->SetKeyValue(key_value_raw_bytes);

std::unique_ptr<UsageRule> rule(new UsageRule);
...
// Add any filters.
...
// Notice we do not explicitly set the KeyID.

std::vector<std::unique_ptr<UsageRule>> rules;
rules.push_back(std::move(rule));

std::unique_ptr<DRMSystem> drm(new DRMSystem);
drm->set_system_id(system_id_raw_bytes);
...
// Add any DRM signaling information
...
// Notice we do not explicitly set the KeyID.

std::vector<std::unique_ptr<DRMSystem>> drms;
drms.push_back(std::move(drm));

// All DRMSystems and UsageRules in the two supplied vectors have their Key ID
// fields auto-populated to match the Key ID of the supplied ContentKey.
message.AddContentKey(std::move(key), std::move(drms), std::move(rules));