standard_cells.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_STANDARD_CELL_STANDARD_CELLS_H_
#define SRC_STANDARD_CELL_STANDARD_CELLS_H_

#include "../entity_system/entity_system.h"
#include "../standard_cell/cells.h"
#include "../standard_cell/pins.h"
#include <unordered_map>

namespace ophidian {
namespace standard_cell {


class standard_cells {

        entity_system::entity_system m_cell_system;
        entity_system::entity_system m_pin_system;

    cells m_cells;
    pins m_pins;

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

    standard_cells();
    virtual ~standard_cells();


        void register_cell_property(entity_system::property* property);

        void register_pin_property(entity_system::property* property);


        const entity_system::vector_property<std::string> & cell_names() const {
        return m_cells.names();
    }

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

        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);
    }

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

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

    void  cell_sequential(entity_system::entity cell, bool sequential);

    bool cell_sequential(entity_system::entity cell) const {
        return m_cells.sequential(cell);
    }


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

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

        std::string pin_name(entity_system::entity pin) const {
        std::string the_name;
                entity_system::entity owner{m_pins.owner(pin)};
                if(!(owner == entity_system::invalid_entity))
            the_name = m_cells.name(owner) + ":";
        the_name += m_pins.name(pin);
        return the_name;
    }

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

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

        pin_directions pin_direction(entity_system::entity pin) const {
        return m_pins.direction(pin);
    }

    bool pin_clock_input(entity_system::entity pin) const {
        return m_pins.clock_input(pin);
    }

    void pin_clock_input(entity_system::entity pin, bool clock_input);

        void pin_direction(entity_system::entity pin, pin_directions direction);


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



};

} /* namespace standard_cell */
} /* namespace ophidian */

#endif /* SRC_STANDARD_CELL_STANDARD_CELLS_H_ */