Min/Max

		Sets or gets the minimum and/or maximum values for the Node. For
		getting, returns {"minimum":mixed,"maximum":mixed}

		Arguments:
			minimum {mixed} -- The minimum value
			maximum {mixed} -- The maximum value

		Raises:
			TypeError, ValueError

		Returns:
			None | dict

def minmax(self, minimum=None, maximum=None):
		"""Min/Max

		Sets or gets the minimum and/or maximum values for the Node. For
		getting, returns {"minimum":mixed,"maximum":mixed}

		Arguments:
			minimum {mixed} -- The minimum value
			maximum {mixed} -- The maximum value

		Raises:
			TypeError, ValueError

		Returns:
			None | dict
		"""

		# If neither min or max is set, this is a getter
		if minimum is None and maximum is None:
			return {"minimum": self._minimum, "maximum": self._maximum};

		# If the minimum is set
		if minimum != None:

			# If the current type is a date, datetime, ip, or time
			if self._type in ['base64', 'date', 'datetime', 'ip', 'time']:

				# Make sure the value is valid for the type
				if not isinstance(minimum, basestring) \
					or not _typeToRegex[self._type].match(minimum):
					raise ValueError('__minimum__')

			# Else if the type is an int (unsigned, timestamp), or a string in
			# 	which the min/max are lengths
			elif self._type in ['int', 'string', 'timestamp', 'uint']:

				# If the value is not a valid int or long
				if not isinstance(minimum, (int, long)):

					# If it's a valid representation of an integer
					if isinstance(minimum, basestring) \
						and _typeToRegex['int'].match(minimum):

						# Convert it
						minimum = int(minimum, 0)

					# Else, raise an error
					else:
						raise ValueError('__minimum__')

					# If the type is meant to be unsigned
					if self._type in ['base64', 'string', 'timestamp', 'uint']:

						# And it's below zero
						if minimum < 0:
							raise ValueError('__minimum__')

			# Else if the type is decimal
			elif self._type == 'decimal':

				# Store it if it's valid, else throw a ValueError
				try:
					minimum = Decimal(minimum)
				except ValueError:
					raise ValueError('__minimum__')

			# Else if the type is float
			elif self._type == 'float':

				# Store it if it's valid, else throw a ValueError
				try:
					minimum = float(minimum)
				except ValueError:
					raise ValueError('__minimum__')

			# Else if the type is price
			elif self._type == 'price':

				# If it's not a valid representation of a price
				if not isinstance(minimum, basestring) or not _typeToRegex['price'].match(minimum):
					raise ValueError('__minimum__')

				# Store it as a Decimal
				minimum = Decimal(minimum)

			# Else we can't have a minimum
			else:
				raise TypeError('can not set __minimum__ for ' + self._type)

			# Store the minimum
			self._minimum = minimum

		# If the maximum is set
		if maximum != None:

			# If the current type is a date, datetime, ip, or time
			if self._type in ['date', 'datetime', 'ip', 'time']:

				# Make sure the value is valid for the type
				if not isinstance(maximum, basestring) \
					or not _typeToRegex[self._type].match(maximum):
					raise ValueError('__maximum__')

			# Else if the type is an int (unsigned, timestamp), or a string in
			# 	which the min/max are lengths
			elif self._type in ['int', 'string', 'timestamp', 'uint']:

				# If the value is not a valid int or long
				if not isinstance(maximum, (int, long)):

					# If it's a valid representation of an integer
					if isinstance(maximum, basestring) \
						and _typeToRegex['int'].match(maximum):

						# Convert it
						maximum = int(maximum, 0)

					# Else, raise an error
					else:
						raise ValueError('__minimum__')

					# If the type is meant to be unsigned
					if self._type in ['string', 'timestamp', 'uint']:

						# And it's below zero
						if maximum < 0:
							raise ValueError('__maximum__')

			# Else if the type is decimal
			elif self._type == 'decimal':

				# Store it if it's valid, else throw a ValueError
				try:
					maximum = Decimal(maximum)
				except ValueError:
					raise ValueError('__maximum__')

			# Else if the type is float
			elif self._type == 'float':

				# Store it if it's valid, else throw a ValueError
				try:
					minimum = float(minimum)
				except ValueError:
					raise ValueError('__maximum__')

			# Else if the type is price
			elif self._type == 'price':

				# If it's not a valid representation of a price
				if not isinstance(maximum, basestring) or not _typeToRegex['price'].match(maximum):
					raise ValueError('__maximum__')

				# Store it as a Decimal
				maximum = Decimal(maximum)

			# Else we can't have a maximum
			else:
				raise TypeError('can not set __maximum__ for ' + self._type)

			# If we also have a minimum
			if self._minimum is not None:

				# If the type is an IP
				if self._type == 'ip':

					# If the min is above the max, we have a problem
					if self.__compare_ips(self._minimum, maximum) == 1:
						raise ValueError('__maximum__')

				# Else any other data type
				else:

					# If the min is above the max, we have a problem
					if self._minimum > maximum:
						raise ValueError('__maximum__')

			# Store the maximum
			self._maximum = maximum