Move DriveBit implementation to drivertools.cc

Author: RCoeurjoly

kernel/drivertools.cc

@@ -153,6 +153,392 @@ unsigned int DriveBitMultiple::hash() const
     return multiple_.hash();
 }
 
+DriveBit::DriveBit() {}
+
+DriveBit::DriveBit(DriveBit const &other)
+{
+    *this = other;
+}
+
+DriveBit::DriveBit(DriveBit &&other)
+{
+    *this = std::move(other);
+}
+
+DriveBit::DriveBit(State constant)
+{
+    *this = constant;
+}
+
+DriveBit::DriveBit(DriveBitWire const &wire)
+{
+    *this = wire;
+}
+
+DriveBit::DriveBit(DriveBitWire &&wire)
+{
+    *this = std::move(wire);
+}
+
+DriveBit::DriveBit(DriveBitPort const &port)
+{
+    *this = port;
+}
+
+DriveBit::DriveBit(DriveBitPort &&port)
+{
+    *this = std::move(port);
+}
+
+DriveBit::DriveBit(DriveBitMarker const &marker)
+{
+    *this = marker;
+}
+
+DriveBit::DriveBit(DriveBitMarker &&marker)
+{
+    *this = std::move(marker);
+}
+
+DriveBit::DriveBit(DriveBitMultiple const &multiple)
+{
+    *this = multiple;
+}
+
+DriveBit::DriveBit(DriveBitMultiple &&multiple)
+{
+    *this = std::move(multiple);
+}
+
+DriveBit::~DriveBit()
+{
+    set_none();
+}
+
+void DriveBit::set_none()
+{
+    switch (type_)
+    {
+        case DriveType::NONE:
+            break;
+        case DriveType::CONSTANT:
+            break;
+        case DriveType::WIRE:
+            wire_.~DriveBitWire();
+            break;
+        case DriveType::PORT:
+            port_.~DriveBitPort();
+            break;
+        case DriveType::MARKER:
+            marker_.~DriveBitMarker();
+            break;
+        case DriveType::MULTIPLE:
+            multiple_.~DriveBitMultiple();
+            break;
+    }
+    type_ = DriveType::NONE;
+}
+
+DriveBit &DriveBit::operator=(DriveBit const &other)
+{
+    switch (other.type_)
+    {
+        case DriveType::NONE:
+            set_none();
+            break;
+        case DriveType::CONSTANT:
+            *this = other.constant_;
+            break;
+        case DriveType::WIRE:
+            *this = other.wire_;
+            break;
+        case DriveType::PORT:
+            *this = other.port_;
+            break;
+        case DriveType::MARKER:
+            *this = other.marker_;
+            break;
+        case DriveType::MULTIPLE:
+            *this = other.multiple_;
+            break;
+    }
+    return *this;
+}
+
+DriveBit &DriveBit::operator=(DriveBit &&other)
+{
+    switch (other.type_)
+    {
+        case DriveType::NONE:
+            set_none();
+            break;
+        case DriveType::CONSTANT:
+            *this = std::move(other.constant_);
+            break;
+        case DriveType::WIRE:
+            *this = std::move(other.wire_);
+            break;
+        case DriveType::PORT:
+            *this = std::move(other.port_);
+            break;
+        case DriveType::MARKER:
+            *this = std::move(other.marker_);
+            break;
+        case DriveType::MULTIPLE:
+            *this = std::move(other.multiple_);
+            break;
+    }
+    return *this;
+}
+
+DriveBit &DriveBit::operator=(State constant)
+{
+    set_none();
+    constant_ = constant;
+    type_ = DriveType::CONSTANT;
+    return *this;
+}
+
+DriveBit &DriveBit::operator=(DriveBitWire const &wire)
+{
+    set_none();
+    new (&wire_) DriveBitWire(wire);
+    type_ = DriveType::WIRE;
+    return *this;
+}
+
+DriveBit &DriveBit::operator=(DriveBitWire &&wire)
+{
+    set_none();
+    new (&wire_) DriveBitWire(std::move(wire));
+    type_ = DriveType::WIRE;
+    return *this;
+}
+
+DriveBit &DriveBit::operator=(DriveBitPort const &port)
+{
+    set_none();
+    new (&port_) DriveBitPort(port);
+    type_ = DriveType::PORT;
+    return *this;
+}
+
+DriveBit &DriveBit::operator=(DriveBitPort &&port)
+{
+    set_none();
+    new (&port_) DriveBitPort(std::move(port));
+    type_ = DriveType::PORT;
+    return *this;
+}
+
+DriveBit &DriveBit::operator=(DriveBitMarker const &marker)
+{
+    set_none();
+    new (&marker_) DriveBitMarker(marker);
+    type_ = DriveType::MARKER;
+    return *this;
+}
+
+DriveBit &DriveBit::operator=(DriveBitMarker &&marker)
+{
+    set_none();
+    new (&marker_) DriveBitMarker(std::move(marker));
+    type_ = DriveType::MARKER;
+    return *this;
+}
+
+DriveBit &DriveBit::operator=(DriveBitMultiple const &multiple)
+{
+    set_none();
+    if (multiple.multiple().empty())
+        return *this;
+    new (&multiple_) DriveBitMultiple(multiple);
+    type_ = DriveType::MULTIPLE;
+    return *this;
+}
+
+DriveBit &DriveBit::operator=(DriveBitMultiple &&multiple)
+{
+    set_none();
+    if (multiple.multiple().empty())
+        return *this;
+    new (&multiple_) DriveBitMultiple(std::move(multiple));
+    type_ = DriveType::MULTIPLE;
+    return *this;
+}
+
+unsigned int DriveBit::hash() const
+{
+    unsigned int inner;
+    switch (type_)
+    {
+        case DriveType::NONE:
+            inner = 0;
+            break;
+        case DriveType::CONSTANT:
+            inner = constant_;
+            break;
+        case DriveType::WIRE:
+            inner = wire_.hash();
+            break;
+        case DriveType::PORT:
+            inner = port_.hash();
+            break;
+        case DriveType::MARKER:
+            inner = marker_.hash();
+            break;
+        case DriveType::MULTIPLE:
+            inner = multiple_.hash();
+            break;
+    }
+    return mkhash((unsigned int)type_, inner);
+}
+
+bool DriveBit::operator==(const DriveBit &other) const
+{
+    if (type_ != other.type_)
+        return false;
+
+    switch (type_)
+    {
+        case DriveType::NONE:
+            return true;
+        case DriveType::CONSTANT:
+            return constant_ == other.constant_;
+        case DriveType::WIRE:
+            return wire_ == other.wire_;
+        case DriveType::PORT:
+            return port_ == other.port_;
+        case DriveType::MARKER:
+            return marker_ == other.marker_;
+        case DriveType::MULTIPLE:
+            return multiple_ == other.multiple_;
+    }
+    log_assert(false);
+}
+
+bool DriveBit::operator!=(const DriveBit &other) const
+{
+    return !(*this == other);
+}
+
+bool DriveBit::operator<(const DriveBit &other) const
+{
+    if (type_ != other.type_)
+        return type_ < other.type_;
+    switch (type_)
+    {
+        case DriveType::NONE:
+            return false;
+        case DriveType::CONSTANT:
+            return constant_ < other.constant_;
+        case DriveType::WIRE:
+            return wire_ < other.wire_;
+        case DriveType::PORT:
+            return port_ < other.port_;
+        case DriveType::MARKER:
+            return marker_ < other.marker_;
+        case DriveType::MULTIPLE:
+            log_assert(!"TODO");
+    }
+    log_abort();
+}
+
+DriveType DriveBit::type() const
+{
+    return type_;
+}
+
+bool DriveBit::is_none() const
+{
+    return type_ == DriveType::NONE;
+}
+
+bool DriveBit::is_constant() const
+{
+    return type_ == DriveType::CONSTANT;
+}
+
+bool DriveBit::is_wire() const
+{
+    return type_ == DriveType::WIRE;
+}
+
+bool DriveBit::is_port() const
+{
+    return type_ == DriveType::PORT;
+}
+
+bool DriveBit::is_marker() const
+{
+    return type_ == DriveType::MARKER;
+}
+
+bool DriveBit::is_multiple() const
+{
+    return type_ == DriveType::MULTIPLE;
+}
+
+State &DriveBit::constant()
+{
+    log_assert(is_constant());
+    return constant_;
+}
+
+State const &DriveBit::constant() const
+{
+    log_assert(is_constant());
+    return constant_;
+}
+
+DriveBitWire &DriveBit::wire()
+{
+    log_assert(is_wire());
+    return wire_;
+}
+
+DriveBitWire const &DriveBit::wire() const
+{
+    log_assert(is_wire());
+    return wire_;
+}
+
+DriveBitPort &DriveBit::port()
+{
+    log_assert(is_port());
+    return port_;
+}
+
+DriveBitPort const &DriveBit::port() const
+{
+    log_assert(is_port());
+    return port_;
+}
+
+DriveBitMarker &DriveBit::marker()
+{
+    log_assert(is_marker());
+    return marker_;
+}
+
+DriveBitMarker const &DriveBit::marker() const
+{
+    log_assert(is_marker());
+    return marker_;
+}
+
+DriveBitMultiple &DriveBit::multiple()
+{
+    log_assert(is_multiple());
+    return multiple_;
+}
+
+DriveBitMultiple const &DriveBit::multiple() const
+{
+    log_assert(is_multiple());
+    return multiple_;
+}
+
 DriveBitMultiple DriveChunkMultiple::operator[](int i) const
 {
   DriveBitMultiple result;