Reset a charging station.

@param id   the charging station's id.
@param type the type of reset (i.e. soft or hard).
@return true if the charging station has reset, false if it hasn't.
558871
private boolean reset(ChargingStationId id, ResetType type) {
        ChargePointService chargePointService = this.createChargingStationService(id);

        ResetRequest request = new ResetRequest();
        request.setType(type);

        ResetResponse response = chargePointService.reset(request, id.getId());

        boolean hasReset;

        switch (response.getStatus()) {
            case ACCEPTED:
                LOG.info("Reset was accepted");
                hasReset = true;
                break;
            case REJECTED:
                LOG.info("Reset was rejected");
                hasReset = false;
                break;
            default:
                throw new AssertionError("Unknown ResetStatus: " + response.getStatus());
        }

        return hasReset;
    }
904230
public void setAutoResetToZero(final boolean AUTO_RESET_TO_ZERO) {
        model.setAutoResetToZero(AUTO_RESET_TO_ZERO);

        if (model.isAutoResetToZero()) {
            setThresholdVisible(false);
            setLedVisible(false);
        }
    }
988972
public function has(string $type, string $id): bool
    {
        return array_key_exists($this->buildArrayKey($type, $id), $this->collection);
    }
66082
public int setContentType(final int type) {
		this.type = type;
		// If the new type has Application, but there is no application fw, remove this type bit
		if ((type & DfuBaseService.TYPE_APPLICATION) > 0 && applicationBytes == null)
			this.type &= ~DfuBaseService.TYPE_APPLICATION;
		// If the new type has SD+BL
		if ((type & (DfuBaseService.TYPE_SOFT_DEVICE | DfuBaseService.TYPE_BOOTLOADER)) == (DfuBaseService.TYPE_SOFT_DEVICE | DfuBaseService.TYPE_BOOTLOADER)) {
			// but there is no SD, remove the softdevice type bit
			if (softDeviceBytes == null && softDeviceAndBootloaderBytes == null)
				this.type &= ~DfuBaseService.TYPE_SOFT_DEVICE;
			// or there is no BL, remove the bootloader type bit
			if (bootloaderBytes == null && softDeviceAndBootloaderBytes == null)
				this.type &= ~DfuBaseService.TYPE_SOFT_DEVICE;
		} else {
			// If at least one of SD or B: bit is cleared, but the SD+BL file is set, remove both bits.
			if (softDeviceAndBootloaderBytes != null)
				this.type &= ~(DfuBaseService.TYPE_SOFT_DEVICE | DfuBaseService.TYPE_BOOTLOADER);
		}

		if ((type & (DfuBaseService.TYPE_SOFT_DEVICE | DfuBaseService.TYPE_BOOTLOADER)) > 0 && softDeviceAndBootloaderBytes != null)
			currentSource = softDeviceAndBootloaderBytes;
		else if ((type & DfuBaseService.TYPE_SOFT_DEVICE) > 0)
			currentSource = softDeviceBytes;
		else if ((type & DfuBaseService.TYPE_BOOTLOADER) > 0)
			currentSource = bootloaderBytes;
		else if ((type & DfuBaseService.TYPE_APPLICATION) > 0)
			currentSource = applicationBytes;
		bytesReadFromCurrentSource = 0;
		mark(0);
		reset();
		return this.type;
	}
589165
@Override
    public void reset()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "reset");

        if (_isCorruptOrIndoubt)
        {
            _toBeIgnored = true;

            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                SibTr.debug(
                            tc, "Destination " + getName() + " on bus " + getBus() +
                                " set to be ignored on restart");
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "reset");
    }
719094
private void doResume(long id) {
    if (paused) {
      log.debug(String.format("%s - Resumed connection to %s", this, context.target()));
      paused = false;
      checkDrain();
    }
  }
463720
public void setType(String type) {
    if(StringUtils.isBlank(type)) {
      setType(TYPE.UNSET);
    }
    else {
      if(TYPE.NEGATIVE.toString().equalsIgnoreCase(type.trim())) {
        setType(TYPE.NEGATIVE);
      }
      if(TYPE.NEUTRAL.toString().equalsIgnoreCase(type.trim())) {
        setType(TYPE.NEUTRAL);
      }
      if(TYPE.POSITIVE.toString().equalsIgnoreCase(type.trim())) {
        setType(TYPE.POSITIVE);
      }
      if(TYPE.UNSET.toString().equalsIgnoreCase(type.trim())) {
        setType(TYPE.UNSET);
      }
    }
  }
1017759
@Override
  public final void setItsId(final SeServicePlaceId pItsId) {
    this.itsId = pItsId;
    if (this.itsId != null) {
      this.pickUpPlace = this.itsId.getPickUpPlace();
      this.item = this.itsId.getItem();
    } else {
      this.pickUpPlace = null;
      this.item = null;
    }
  }
402764
public void deleteConnector(Long chargingStationTypeId, Long evseId, Long id) {
        ChargingStationType chargingStationType = chargingStationTypeRepository.findOne(chargingStationTypeId);
        Evse evse = getEvseById(chargingStationType, evseId);

        Connector connector = getConnectorById(evse, id);
        evse.getConnectors().remove(connector);

        chargingStationTypeRepository.createOrUpdate(chargingStationType);
    }
259502
private void onBusStopChanged(BusStop stop) {
		if (stop.getContainer() == this) {
			final boolean oldValidity = !ListUtil.contains(this.invalidBusStops, INVALID_STOP_COMPARATOR, stop);
			final boolean currentValidity = stop.isValidPrimitive();
			if (oldValidity != currentValidity) {
				if (currentValidity) {
					ListUtil.remove(this.invalidBusStops, INVALID_STOP_COMPARATOR, stop);
					this.validBusStops.add(stop);
				} else {
					this.validBusStops.remove(stop);
					ListUtil.addIfAbsent(this.invalidBusStops, INVALID_STOP_COMPARATOR, stop);
				}
			}
		}
	}
962222
public synchronized void removeBootstrapContext(String id)
   {
      if (id == null || id.trim().equals(""))
         throw new IllegalArgumentException("The id of BootstrapContext is invalid: " + id);

      Integer i = refCountBootstrapContexts.get(id);
      if (i != null)
      {
         int newValue = i.intValue() - 1;
         if (newValue == 0)
         {
            CloneableBootstrapContext cbc = activeBootstrapContexts.remove(id);
            refCountBootstrapContexts.remove(id);

            cbc.shutdown();

            workManagerCoordinator.removeWorkManager(id);
         }
         else
         {
            refCountBootstrapContexts.put(id, Integer.valueOf(newValue));
         }
      }
   }
707115
private function reset() : void
    {
        $this->id = null;
        $this->data = [];
        $this->inRequest = false;
    }
846715
@Api
	public void setMapType(MapType type) {
		this.type = type;
		if (googleMap != null) {
			setMapType(googleMap, type.toString());
		}
	}
122101
function (id) {
                var res = this.idMap ? this.idMap[id] : null;
                if (res && res._type == TYPE_BEHAVIOR) {
                    return res.behavior;
                }
                return null;
            }
1073761
public void reset() {
        iZone = iDefaultZone;
        iOffset = null;
        iPivotYear = iDefaultPivotYear;
        iSavedFieldsCount = 0;
        iSavedFieldsShared = false;
        iSavedState = null;
    }
1063422
private boolean resetActivePointToTerminal() {
        if (activeEdge != null && activeEdge.getLength() == activeLength && activeEdge.isTerminating()) {
            activeNode = activeEdge.getTerminal();
            activeEdge = null;
            activeLength = 0;
            return true;
        }
        return false;

    }
1200017
public ClassReloadingStrategy reset(ClassFileLocator classFileLocator, Class<?>... type) throws IOException {
        if (type.length > 0) {
            try {
                strategy.reset(instrumentation, classFileLocator, Arrays.asList(type));
            } catch (ClassNotFoundException exception) {
                throw new IllegalArgumentException("Cannot locate types " + Arrays.toString(type), exception);
            } catch (UnmodifiableClassException exception) {
                throw new IllegalStateException("Cannot reset types " + Arrays.toString(type), exception);
            }
        }
        return this;
    }