/usr/src/suites/os/smf/tests/include/create_piece.pm

#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#

#
# Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
#
#

use strict;
use warnings;

use lib "$ENV{STF_SUITE}/tests/include";
use Class::Struct;

use piece_types;
use write_piece;

struct value => { reverse qw{
	$ leftside
	$ rightside
	$ middle
}};

struct piece => { reverse qw{
	$ type
	$ ident
	$ write
	$ close
	@ values
	@ associations
}};

our $template_piece;
our $pieces;
our $p;
our $v;

#
# A number of functions to create each of the different pieces
# that will make up a manifest.
#

#
# Create a service_bundle piece
#
sub SERVICEBUNDLE() {
	my $values = shift;

	if (!defined($pieces) || $pieces eq "uninitialized") {
		our $pieces = piece->new();
	}

	$p = $pieces;

	$p->type($piece_types::SERVICEBUNDLE);
	$p->write(\&write_service_bundle);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}
}

#
# Create a service piece
#
sub SERVICE() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::SERVICE);
	$p->write(\&write_service);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}
	
#
# Create a exec_method piece
#
sub EXECMETHOD() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::EXECMETHOD);
	$p->write(\&write_exec_method);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}



#
# Create a property group piece
#
sub PROPERTYGROUP() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::PROPERTYGROUP);
	$p->write(\&write_property_group);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a createdefaultinstance piece
#
sub CREATEDEFAULTINSTANCE() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::CREATEDEFAULTINSTANCE);
	$p->write(\&write_create_default_instance);
	@{$p->associations} = ();

	my $setident = 0;
	if ($values ne "true" && $values ne "false") {
		return();
	}

	$v = value->new();
	$v->leftside($values);
	push(@{$p->values}, $v);

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a single_instance piece
#
sub SINGLEINSTANCE() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::SINGLEINSTANCE);
	$p->write(\&write_single_instance);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a restarter piece
#
sub RESTARTER() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::RESTARTER);
	$p->write(\&write_restarter);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a dependency piece
#
sub DEPENDENCY() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::DEPENDENCY);
	$p->write(\&write_dependency);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a dependent piece
#
sub DEPENDENT() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::DEPENDENT);
	$p->write(\&write_dependent);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a method_context piece
#
sub METHODCONTEXT() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::METHODCONTEXT);
	$p->write(\&write_method_context);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a instance piece
#
sub INSTANCE() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::INSTANCE);
	$p->write(\&write_instance);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a stability piece
#
sub STABILITY() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::STABILITY);
	$p->write(\&write_stability);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a template piece
#
sub TEMPLATE() {
	my $association = shift;
	my $values = shift;

	$template_piece = 1;
	$p = piece->new();
	$p->type($piece_types::TEMPLATE);
	$p->write(\&write_template);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	if ($setident != 1) {
		$p->ident("DEFAULT");
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a common_name piece
#
sub COMMONNAME() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::COMMONNAME);
	$p->write(\&write_common_name);
	@{$p->associations} = ();

	my $setident = 0;
	my $cname;
	my $lang;
	while ($values) {
		($lang, $cname, $values) = split(/,/, $values, 3);
		$v = value->new();
		$v->leftside("lang");
		$v->rightside($lang);

		push(@{$p->values}, $v);

		$v = value->new();
		$v->leftside("${lang}_cname");
		$v->rightside($cname);

		push(@{$p->values}, $v);
	}

	$p->ident("$cname");

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a description piece
#
sub DESCRIPTION() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::DESCRIPTION);
	$p->write(\&write_description);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a documentation piece
#
sub DOCUMENTATION() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::DOCUMENTATION);
	$p->write(\&write_documentation);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a pg_pattern piece
#
sub PGPATTERN() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::PGPATTERN);
	$p->write(\&write_pg_pattern);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a prop_pattern piece
#
sub PROPPATTERN() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::PROPPATTERN);
	$p->write(\&write_prop_pattern);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a units piece
#
sub UNITS() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::UNITS);
	$p->write(\&write_units);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a visibility piece
#
sub VISIBILITY() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::VISIBILITY);
	$p->write(\&write_visibility);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a cardinality piece
#
sub CARDINALITY() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::CARDINALITY);
	$p->write(\&write_cardinality);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a internal_separator piece
#
sub INTERNALSEPARATORS() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::INTERNALSEPARATORS);
	$p->write(\&write_internal_separators);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a values piece
#
sub VALUES() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::VALUES);
	$p->write(\&write_values);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "ident") {
			$setident = 1;
			$p->ident($r);
		}
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a constraints piece
#
sub CONSTRAINTS() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::CONSTRAINTS);
	$p->write(\&write_constraints);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "ident") {
			$setident = 1;
			$p->ident($r);
		}
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a value piece
#
sub VALUE() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::VALUE);
	$p->write(\&write_value);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a range piece
#
sub RANGE() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::RANGE);
	$p->write(\&write_range);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a value_set piece
#
sub VALUESET() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::VALUESET);
	$p->write(\&write_valueset);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a all_values piece
#
sub ALLVALUES() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::ALLVALUES);
	$p->write(\&write_allvalues);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a doclink piece
#
sub DOCLINK() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::DOCLINK);
	$p->write(\&write_doclink);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a manpage piece
#
sub MANPAGE() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::MANPAGE);
	$p->write(\&write_manpage);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a service_fmri piece
#
sub SERVICEFMRI() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::SERVICEFMRI);
	$p->write(\&write_service_fmri);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a method_profile piece
#
sub METHODPROFILE() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::METHODPROFILE);
	$p->write(\&write_method_profile);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a method_credential piece
#
sub METHODCREDENTIAL() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::METHODCREDENTIAL);
	$p->write(\&write_method_credential);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a method_environment piece
#
sub METHODENVIRONMENT() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::METHODENVIRONMENT);
	$p->write(\&write_method_environment);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a prop_val piece
#
sub PROPVAL() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::PROPVAL);
	$p->write(\&write_propval);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a property piece
#
sub PROPERTY() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::PROPERTY);
	$p->write(\&write_property);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		my ($l, $r) = split(/=/, $val);

		if ($l eq "name") {
			$setident = 1;
			$p->ident($r);
		}

		$v = value->new();
		$v->leftside($l);
		$v->rightside($r);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a count_list piece
#
sub COUNTLIST() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::COUNTLIST);
	$p->write(\&write_count_list);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		$v = value->new();
		$v->rightside($val);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a interger_list piece
#
sub INTEGERLIST() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::INTEGERLIST);
	$p->write(\&write_integer_list);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		$v = value->new();
		$v->rightside($val);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a opaque_list piece
#
sub OPAQUELIST() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::OPAQUELIST);
	$p->write(\&write_opaque_list);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		$v = value->new();
		$v->rightside($val);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a host_list piece
#
sub HOSTLIST() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::HOSTLIST);
	$p->write(\&write_host_list);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		$v = value->new();
		$v->rightside($val);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a hostname_list piece
#
sub HOSTNAMELIST() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::HOSTNAMELIST);
	$p->write(\&write_host_name_list);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		$v = value->new();
		$v->rightside($val);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a netaddress4_list piece
#
sub NETADDRESSV4LIST() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::NETADDRESSV4LIST);
	$p->write(\&write_net_address_v4_list);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		$v = value->new();
		$v->rightside($val);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a netaddressv6_list piece
#
sub NETADDRESSV6LIST() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::NETADDRESSV6LIST);
	$p->write(\&write_net_address_v6_list);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		$v = value->new();
		$v->rightside($val);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a time_list piece
#
sub TIMELIST() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::TIMELIST);
	$p->write(\&write_time_list);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		$v = value->new();
		$v->rightside($val);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a astring_list piece
#
sub ASTRINGLIST() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::ASTRINGLIST);
	$p->write(\&write_astring_list);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		$v = value->new();
		$v->rightside($val);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a ustring_list piece
#
sub USTRINGLIST() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::USTRINGLIST);
	$p->write(\&write_ustring_list);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		$v = value->new();
		$v->rightside($val);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a boolean_list piece
#
sub BOOLEANLIST() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::BOOLEANLIST);
	$p->write(\&write_boolean_list);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		$v = value->new();
		$v->rightside($val);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a fmri_list piece
#
sub FMRILIST() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::FMRILIST);
	$p->write(\&write_fmri_list);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		$v = value->new();
		$v->rightside($val);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}

#
# Create a uri_list piece
#
sub URILIST() {
	my $association = shift;
	my $values = shift;

	$p = piece->new();
	$p->type($piece_types::URILIST);
	$p->write(\&write_uri_list);
	@{$p->associations} = ();

	my $setident = 0;
	my @vals = split(/,/, $values);
	foreach my $val (@vals) {
		$v = value->new();
		$v->rightside($val);

		push(@{$p->values}, $v);
	}

	my ($asstype, $assname) = split(/:/, $association);
	&associate_piece($asstype, $assname, $p);
}
return (1);