netlist.h

/*
 * Copyright 2016 Ophidian
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
 */

#ifndef SRC_NETLIST_NETLIST_H_
#define SRC_NETLIST_NETLIST_H_

#include "../standard_cell/standard_cells.h"
#include "../entity_system/entity_system.h"
#include <boost/bimap.hpp>
#include "cells.h"
#include "pins.h"
#include "nets.h"

#include  <iostream>
#include <unordered_map>

namespace ophidian {
namespace netlist {

class netlist {

    standard_cell::standard_cells * m_std_cells;

    std::string m_module_name;

    entity_system::entity_system m_cells_system;
    entity_system::entity_system m_pins_system;
    entity_system::entity_system m_nets_system;

    cells m_cells;
    pins m_pins;
    nets m_nets;

    using entity2index_map = typename boost::bimap< entity_system::entity, std::size_t >;
    entity2index_map m_PI_mapping;
    entity2index_map m_PO_mapping;

    std::vector<entity_system::entity> m_PI;
    std::vector<entity_system::entity> m_PO;

    std::unordered_map<std::string, entity_system::entity> m_name2cell;
    std::unordered_map<std::string, entity_system::entity> m_name2pin;
    std::unordered_map<std::string, entity_system::entity> m_name2net;

public:

    void cell_preallocate(std::size_t qnt);
    void pin_preallocate(std::size_t qnt);
    void net_preallocate(std::size_t qnt);


    netlist(standard_cell::standard_cells * std_cells);

    virtual ~netlist();


    void register_cell_property(entity_system::property * property);

    void register_pin_property(entity_system::property * property);

    void register_net_property(entity_system::property * property);

    void module_name(std::string name) {
        m_module_name = name;
    }
    std::string module_name() const {
        return m_module_name;
    }


    const standard_cell::standard_cells & std_cells() const {
        return *m_std_cells;
    }

    // cell

    entity_system::entity cell_find(std::string name) const;

    entity_system::entity cell_insert(std::string name, std::string type);

    void cell_remove(entity_system::entity cell);


    std::size_t cell_count() const {
        return m_cells_system.size();
    }

    std::string cell_name(entity_system::entity cell) const {
        return m_cells.name(cell);
    }

    const std::vector<entity_system::entity> & cell_pins(entity_system::entity cell) const {
        return m_cells.pins(cell);
    }

    entity_system::entity cell_std_cell(entity_system::entity cell) const {
        return m_cells.standard_cell(cell);
    }

    bool cell_std_cell(entity_system::entity cell, std::string type);

    bool cell_std_cell(entity_system::entity cell, entity_system::entity std_cell);

    const entity_system::entity_system & cell_system() const {
        return m_cells_system;
    }

    const cells & cells_properties() const {
        return m_cells;
    }

    // pin

    entity_system::entity pin_insert(entity_system::entity cell, std::string name);

    std::size_t pin_count() const {
        return m_pins_system.size();
    }

    std::string pin_name(entity_system::entity pin) const {
        auto owner = m_pins.owner(pin);
        std::string the_name;
        if (!(owner == entity_system::invalid_entity))
        {
            the_name = m_cells.name(owner) + ":";
            std::string std_cell_pin_name = m_std_cells->pin_name(m_pins.standard_cell_pin(pin));
            std_cell_pin_name = std_cell_pin_name.substr(std_cell_pin_name.find_last_of(':')+1);
            the_name += std_cell_pin_name;
        } else
            the_name = m_std_cells->pin_name(m_pins.standard_cell_pin(pin));
        return the_name;
    }

    entity_system::entity pin_owner(entity_system::entity pin) const {
        return m_pins.owner(pin);
    }

    entity_system::entity pin_net(entity_system::entity pin) const {
        return m_pins.net(pin);
    }

    entity_system::entity pin_std_cell(entity_system::entity pin) const {
        return m_pins.standard_cell_pin(pin);
    }

    entity_system::entity pin_by_name(std::string name) const {
        return m_name2pin.at(name);
    }

    const entity_system::entity_system & pin_system() const {
        return m_pins_system;
    }

    const pins & pins_properties() const {
        return m_pins;
    }

    // net

    entity_system::entity net_insert(std::string name);

    entity_system::entity net_insert(std::string name, std::size_t pin_count);

    void net_remove(entity_system::entity net);

    std::size_t net_count() const {
        return m_nets_system.size();
    }

    std::string net_name(entity_system::entity net) const {
        return m_nets.name(net);
    }

    const std::vector<entity_system::entity> & net_pins(entity_system::entity net) const {
        return m_nets.pins(net);
    }


    std::pair<std::vector<std::string>::const_iterator,
    std::vector<std::string>::const_iterator> net_names() const {
        return m_nets.names();
    }

    const entity_system::entity_system & net_system() const {
        return m_nets_system;
    }

    entity_system::entity net_by_name(std::string name) const {
        return m_name2net.at(name);
    }

    const nets & nets_properties() const {
        return m_nets;
    }


    void connect(entity_system::entity net, entity_system::entity pin);

    void disconnect(entity_system::entity pin);

    // PI

    entity_system::entity PI_insert(std::string name);

    void PI_remove(entity_system::entity PI);

    std::size_t PI_count() const {
        return m_PI.size();
    }

    std::vector<entity_system::entity>::const_iterator PI_begin() const {
        return m_PI.begin();
    }

    std::vector<entity_system::entity>::const_iterator PI_end() const {
        return m_PI.end();
    }

    // PO

    entity_system::entity PO_insert(std::string name);

    void PO_remove(entity_system::entity PO);

    std::size_t PO_count() const {
        return m_PO.size();
    }

    std::vector<entity_system::entity>::const_iterator PO_begin() const {
        return m_PO.begin();
    }

    std::vector<entity_system::entity>::const_iterator PO_end() const {
        return m_PO.end();
    }

};

} /* namespace netlist */
} /* namespace ophidian */

#endif /* SRC_NETLIST_NETLIST_H_ */