
/*** <<< INCLUDES [Attribute] >>> ***/

#include <RELATIVE-OID.h>
#include <IA5String.h>
#include <constr_SEQUENCE.h>

/*** <<< TYPE-DECLS [Attribute] >>> ***/

typedef struct Attribute {
	RELATIVE_OID_t	 identifier;
	IA5String_t	 siAttributeValue;
	
	/* Context for parsing across buffer boundaries */
	asn_struct_ctx_t _asn_ctx;
} Attribute_t;

/*** <<< FUNC-DECLS [Attribute] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_Attribute;

/*** <<< CODE [Attribute] >>> ***/

static int
memb_identifier_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
			asn_app_consume_bytes_f *app_errlog, void *app_key) {
	
	if(!sptr) {
		_ASN_ERRLOG(app_errlog, app_key,
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
	if(1 /* No applicable constraints whatsoever */) {
		/* Nothing is here. See below */
	}
	
	return td->check_constraints(td, sptr, app_errlog, app_key);
}


/*** <<< STAT-DEFS [Attribute] >>> ***/

static asn_TYPE_member_t asn_MBR_Attribute_1[] = {
	{ ATF_NOFLAGS, 0, offsetof(struct Attribute, identifier),
		.tag = (ASN_TAG_CLASS_UNIVERSAL | (13 << 2)),
		.tag_mode = 0,
		.type = &asn_DEF_RELATIVE_OID,
		.memb_constraints = memb_identifier_constraint_1,
		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
		.default_value = 0,
		.name = "identifier"
		},
	{ ATF_NOFLAGS, 0, offsetof(struct Attribute, siAttributeValue),
		.tag = (ASN_TAG_CLASS_UNIVERSAL | (22 << 2)),
		.tag_mode = 0,
		.type = &asn_DEF_IA5String,
		.memb_constraints = 0,	/* Defer constraints checking to the member type */
		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
		.default_value = 0,
		.name = "siAttributeValue"
		},
};
static ber_tlv_tag_t asn_DEF_Attribute_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
static asn_TYPE_tag2member_t asn_MAP_Attribute_tag2el_1[] = {
    { (ASN_TAG_CLASS_UNIVERSAL | (13 << 2)), 0, 0, 0 }, /* identifier at 19 */
    { (ASN_TAG_CLASS_UNIVERSAL | (22 << 2)), 1, 0, 0 } /* siAttributeValue at 20 */
};
static asn_SEQUENCE_specifics_t asn_SPC_Attribute_specs_1 = {
	sizeof(struct Attribute),
	offsetof(struct Attribute, _asn_ctx),
	asn_MAP_Attribute_tag2el_1,
	2,	/* Count of tags in the map */
	0, 0, 0,	/* Optional elements (not needed) */
	-1,	/* Start extensions */
	-1	/* Stop extensions */
};
asn_TYPE_descriptor_t asn_DEF_Attribute = {
	"Attribute",
	"Attribute",
	SEQUENCE_free,
	SEQUENCE_print,
	SEQUENCE_constraint,
	SEQUENCE_decode_ber,
	SEQUENCE_encode_der,
	SEQUENCE_decode_xer,
	SEQUENCE_encode_xer,
	0,	/* No PER decoder, -gen-PER to enable */
	0,	/* Use generic outmost tag fetcher */
	asn_DEF_Attribute_tags_1,
	sizeof(asn_DEF_Attribute_tags_1)
		/sizeof(asn_DEF_Attribute_tags_1[0]), /* 1 */
	asn_DEF_Attribute_tags_1,	/* Same as above */
	sizeof(asn_DEF_Attribute_tags_1)
		/sizeof(asn_DEF_Attribute_tags_1[0]), /* 1 */
	0,	/* No PER visible constraints */
	asn_MBR_Attribute_1,
	2,	/* Elements count */
	&asn_SPC_Attribute_specs_1	/* Additional specs */
};

