@param value [ActiveTriples::Resource]

 @return [ActiveTriples::Resource] returns the node after running `#uniq`
   against the provided labels of an nodes.
171998
def deduplicate_resource(value)
      value.class.properties.values.map(&:term).map do |property|
        unique = value.send(property).uniq { |v| providedLabel_or_value(v) }
        value.send("#{property}=".to_sym, unique)
      end
    end
393514
def value
			return @unnormalized if @unnormalized
			doctype = nil
			if @element
				doc = @element.document
				doctype = doc.doctype if doc
			end
			@unnormalized = Text::unnormalize( @normalized, doctype )
			@normalized = nil
      @unnormalized
		end
175763
def enrich_value(value)
      return value unless value.is_a? ActiveTriples::Resource
      deduplicate_resource(value)
      value
    end
1106534
public Optional<Tree<T>> getChild(T value) {
    return children.stream().filter(its(n -> n.value, isEquals(value))).findFirst();
  }
524842
@JRubyMethod(name = "value=")
    public static IRubyObject value_set(IRubyObject self, IRubyObject val) {
        org.yecht.Node node = (org.yecht.Node)self.dataGetStructChecked();
        Ruby runtime = self.getRuntime();
        Data.Str ds = (Data.Str)node.data;
            
        val = val.convertToString();
        ByteList bl = ((RubyString)val).getByteList();
        byte[] bss = new byte[bl.realSize];
        System.arraycopy(bl.bytes, bl.begin, bss, 0, bss.length);
        ds.ptr = Pointer.create(bss, 0);
        ds.len = bss.length;
        ds.style = ScalarStyle.None;
        ((RubyObject)self).fastSetInstanceVariable("@value", val);
        return val;
    }
164516
def value(args = {})
      r = self.raw_value

      case datatype
      when RubyXL::DataType::SHARED_STRING then workbook.shared_strings_container[r.to_i].to_s
      when RubyXL::DataType::INLINE_STRING then is.to_s
      when RubyXL::DataType::RAW_STRING    then raw_value
      else
        if is_date? then workbook.num_to_date(r.to_f)
        elsif r.is_a?(String) && (r =~ NUMBER_REGEXP) then # Numeric
          if $1 != '' then r.to_f
          else r.to_i
          end
        else r
        end
      end
    end
1305377
def next_value(val)
      index = index_of(val)
      return nil unless index
      return nil if index == (get_length - 1)
      return get(index + 1)
    end
760835
protected final int getNodeType( Object value )
    {   	
        if (value instanceof String)
            return SelectorNodeType.STRING;
            
        if (value instanceof Boolean)
            return SelectorNodeType.BOOLEAN;
        
        return SelectorNodeType.NUMBER;
    }
964247
public Node<T> getNext(int value) {
    	if (value == last.value) return null;
    	if (value == root.value) {
    		if (root.right == null) return null;
    		Node<T> n = root.right;
    		while (n.left != null) n = n.left;
    		return n;
    	}
    	if (value > root.value) {
    		if (root.right == null) return null;
    		return getNext(root.right, value);
    	}
    	if (root.left == null) return null;
    	return getNext(root, root.left, value);
    }
790986
public static Node getChildNode(Node parentNode, String name, String value){
                List<Node> matchingChildren = getChildren(parentNode, name, value);
                return (matchingChildren.size() > 0) ? matchingChildren.get(0) : null;
        }
405308
def unwrap(self, value, session=None):
        ''' 
        '''
        self.validate_unwrap(value)
        ret = {}
        for k, v in value.items():
            ret[k] = self.value_type.unwrap(v, session=session)
        return ret
109933
def get(resource_uri)
      result = connection.get("resource") do |request|
        request.query[:uri] = resource_uri.to_s
        request.query.delete(:graph)
      end
      MaybeGraphResult.new(result).value
    end
452383
def to_xml(value, options = {})
      if value.is_a?(Exchanger::Element)
        value.tag_name = tag_name
        value.to_xml(options)
      else
        doc = Nokogiri::XML::Document.new
        root = doc.create_element(tag_name)
        case value
        when Array
          value.each do |sub_value|
            root << sub_field.to_xml(sub_value, options)
          end
        when Boolean
          root << doc.create_text_node(value == true)
        when Time
          root << doc.create_text_node(value.xmlschema)
        else # String, Integer, etc
          root << doc.create_text_node(value.to_s)
        end
        root
      end
    end
1283712
def enrich_value(value)
      set_label(value) if value.is_a?(DPLA::MAP::TimeSpan) && 
                          value.prefLabel.empty?
      value
    end
666305
def distinct_on(self, value):
        
        if isinstance(value, str):
            value = [value]
        self._distinct_on[:] = value
390393
def get(cls, resource_id, include_deactivated=False):
        
        if include_deactivated:
            resource = yield cls.view.first(key=resource_id, include_docs=True)
        else:
            resource = yield cls.active_view.first(key=resource_id, include_docs=True)
        parent = cls.parent_resource(**resource['doc'])

        raise Return(cls(parent=parent, **resource['value']))
1035352
def value
      val = self.lazy_proc?(@value) ? self.coerce(@value.call) : @value
      val.respond_to?(:returned_value) ? val.returned_value : val
    end