docs: function(instance_values){
      instance_values = instance_values || {};
      var _field_values = {};
      var fields = this.constructor._properties.schema.fields;
      var self = this;
      var default_setter = function(prop_name, new_value){
              this[prop_name] = new_value;
          },
          default_getter = function(prop_name){
              return this[prop_name];
          },
          validation_wrapper = function(setter, validation_func, prop_name, fieldtype){
              return function(value){
                  if(!self._skip_validation){
                      var validation_result = validation_func(value);
                      if( validation_result !== true )
                          throw build_error('model.set.invalidvalue', validation_result(value, prop_name, fieldtype) );
                  }
                  setter(value);
              };
          },
          generic_validator_message_func = function(value, prop_name, fieldtype){return util.format('Invalid Value: "%s" for Field: %s (Type: %s)', value, prop_name, fieldtype); };
      this._validators = {};
      this._skip_validation = false;
      var validators;
  
      for(var fields_keys = Object.keys(fields), i = 0, len = fields_keys.length; i < len; i++){
          var property_name = fields_keys[i],
              field = fields[fields_keys[i]],
              fieldtype = schemer.get_field_type(this.constructor._properties.schema,fields_keys[i]),
              fieldvalue = instance_values[fields_keys[i]];
  
  
          var type_fieldvalidator = TYPE_MAP.generic_type_validator(TYPE_MAP[fieldtype].validator);
          validators = [type_fieldvalidator];
          if( typeof field.rule != 'undefined' ){
              if( typeof field.rule === 'function'){
                  field.rule = {
                      validator : field.rule,
                      message   : generic_validator_message_func
                  };
              }else{
                  if( typeof field.rule != 'object' || typeof field.rule.validator == 'undefined' ){
                      throw 'Invalid validator';
                  }
                  if(!field.rule.message){
                      field.rule.message = generic_validator_message_func
                  }else if( typeof field.rule.message == 'string' ){
                      field.rule.message = function(message, value, prop_name, fieldtype){return util.format(message, value, prop_name, fieldtype); }.bind(null, field.rule.message);
                  }else if( typeof field.rule.message != 'function' ){
                      throw 'Invalid validator message';
                  }
              }
              validators.push(field['rule']);
          }
          this._validators[property_name] = validators;
  
          var validation_func = this.constructor._validate.bind(this.constructor, validators);
  
          var setter = validation_wrapper( default_setter.bind(_field_values, property_name ), validation_func, property_name, fieldtype),
              getter = default_getter.bind(_field_values, property_name);
  
          if(field['virtual'] && typeof field['virtual']['set'] === 'function'){
              setter = validation_wrapper(field['virtual']['set'].bind(_field_values), validation_func, property_name, fieldtype);
              //field['virtual']['set'].bind(_field_values);
          }
  
          if(field['virtual'] && typeof field['virtual']['get'] === 'function'){
              getter = field['virtual']['get'].bind(_field_values);
          }
  
  
          var descriptor = {
              enumerable: true,
              set : setter,
              get : getter
          };
  
          Object.defineProperty(this, property_name, descriptor);
          this[property_name] = instance_values[property_name];
      }
  
  }