Add new attribute for the tiny object modeled

 @param [Symbol] name the attribute name
 @param [Class] type the class type

 @private
329498
def new_attribute(name, type)
      attributes[name] = type
      define_attr_reader(name)
      define_attr_writer(name, type)
      name
    end
1236018
def write_attribute(name, value)
      name = name.to_s
      modify(name, @attributes[name], value)
    end
478630
public void addNewArray(String name, TypeMirror type, int size) throws IOException
    {
        if (type.getKind() != TypeKind.ARRAY)
        {
            throw new IllegalArgumentException(type+" is not array");
        }
        ArrayType at = (ArrayType) type;
        addVariable(name, at);
        newarray(type, size);
        if (!Typ.isPrimitive(at.getComponentType()))
        {
            checkcast(at);
        }
        tstore(name);
    }
919353
def add_attr(self, name, value):
        """"""
        setattr(self, name, value)
        self.attrs.append(name)
1308282
function (name, type, opts) {
            opts = opts || {};
            this.operations.push(merge({op:"setColumnType", name:name, type:type}, opts));
        }
890806
public Attribute addAttribute(QuotedID id, int type, String typeName, boolean canNull) {
		Attribute att = new Attribute(this, new QualifiedAttributeID(getID(), id),
				attributes.size() + 1, type, typeName, canNull,
				typeMapper.getTermType(type, typeName));
		
		//check for duplicate names (put returns the previous value)
		Attribute prev = attributeMap.put(id, att);
		if (prev != null) 
			throw new IllegalArgumentException("Duplicate attribute names");
		
		attributes.add(att);
		return att;
	}
1310916
def add_attribute(self, name, value):
        

        self.attributes.append(Attribute(name, value))
272141
function addClass(node, name) {
        if (hasClass(node, name)) {
            return;
        }
        if (node.classList) {
            node.classList.add(name);
        } else {
            node.className += " " + name;
        }
    }
466986
function addType(typeName, type) {
	if (types[typeName]) {
		throw new Error("Type already registered '" + typeName + "'");
	}
	types[typeName] = type;
}
982722
def _add_standard_attributes(cls):
        
        setattr(
            cls.context.new_class,
            cls.context.new_meta['state_attribute_name'],
            cls.context.state_value)
        setattr(
            cls.context.new_class,
            cls.context.state_name,
            utils.state_property)

        setattr(cls.context.new_class, 'is_', utils.is_)
        setattr(cls.context.new_class, 'can_be_', utils.can_be_)
        setattr(cls.context.new_class, 'set_', utils.set_)
151936
def add_attribute(self, attribute_type, attribute_value):
        
        if not self.can_update():
            self._tcex.handle_error(910, [self.type])

        return self.tc_requests.add_attribute(
            self.api_type,
            self.api_sub_type,
            self.unique_id,
            attribute_type,
            attribute_value,
            owner=self.owner,
        )
879868
def attribute(*args)
      if args.first.is_a?(Hash)
        args.first.each_pair do |key, name|
          @attributes.add(name: name, attr: key)
        end
      else
        options = args.extract_options!
        args.each do |name|
          key = options[:as] || name
          @attributes.add(name: name, attr: key)
        end
      end
    end
775257
def add(self, parent, obj_type, **attributes):
        

        return self.ixn.add(parent.obj_ref(), obj_type, *self._get_args_list(**attributes))
1065266
function addAttribute(name,value) {
    // Make sure there isn't already an attribute with this name
    // If there is, ignore this one.
    for(var i = 0; i < attributes.length; i++) {
      if (attributes[i][0] === name) return;
    }

    if (value !== undefined) {
      attributes.push([name, value]);
    }
    else {
      attributes.push([name]);
    }
  }
314932
def _attribute_typecaster(attribute_name)
      type = _attribute_type(attribute_name)
      self.class.attributes[attribute_name][:typecaster] || typecaster_for(type) or raise UnknownTypecasterError, "Unable to cast to type #{type}"
    end
393945
def add_attribute(self, tag, name, value):
        
        self.add_tag(tag)
        d = self._tags[tag]
        d[name] = value
338726
def add_attributes(self, data, type):
        
        for attr, ancestry in type.attributes():
            name = '_%s' % attr.name
            value = attr.get_default()
            setattr(data, name, value)