type_base.cc

Go to the documentation of this file.

/*!
 *
 * Copyright (C) 2015 Technical University of Liberec.  All rights reserved.
 * 
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License version 3 as published by the
 * Free Software Foundation. (http://www.gnu.org/licenses/gpl-3.0.en.html)
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 *
 * 
 * @file    type_base.cc
 * @brief   
 */

#include <limits>
#include <ios>
#include <map>
#include <vector>
#include <string>
#include <iomanip>

#include "system/system.hh"

#include <type_traits>
#include <boost/tokenizer.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/functional/hash.hpp>
#include <boost/pointer_cast.hpp>


#include "input_type.hh"
#include "type_output.hh"
#include "type_repository.hh"
#include "attribute_lib.hh"
#include "json_spirit/json_spirit.h"

#include <stdint.h>                                          // for int64_t
#include <boost/algorithm/string.hpp>
//

#include <boost/functional/hash/hash.hpp>                    // for hash_com...

#include <memory>                                            // for shared_ptr
#include <ostream>                                           // for operator<<
#include <typeinfo>                                          // for type_info
#include <utility>                                           // for make_pair
#include "input/json_spirit/json_spirit_error_position.h"    // for Error_po...
#include "input/json_spirit/json_spirit_reader.h"            // for read_or_...
#include "input/json_spirit/json_spirit_value.h"             // for mValue
#include "input/type_base.hh"                                // for TypeBase
#include "input/type_generic.hh"                             // for ExcGener...
#include "system/asserts.hh"                                 // for Assert
#include "system/exceptions.hh"                              // for ExcGener...
#include "system/file_path.hh"                               // for FilePath
namespace Input { namespace Type { class Abstract; } }
namespace Input { namespace Type { class Record; } }
namespace Input { namespace Type { class Selection; } }
namespace Input { namespace Type { class Tuple; } }



namespace Input {
namespace Type {

using namespace std;



/*******************************************************************
 * implementation of TypeBase
 */



TypeBase::TypeBase()
: attributes_( std::make_shared<attribute_map>() ), root_of_generic_subtree_(false),
  generic_type_hash_(TypeBase::none_hash) {}



TypeBase::TypeBase(const TypeBase& other)
: attributes_(other.attributes_), root_of_generic_subtree_(other.root_of_generic_subtree_),
  generic_type_hash_(other.generic_type_hash_), parameter_map_(other.parameter_map_) {}



TypeBase::~TypeBase() {}


bool TypeBase::is_valid_identifier(const string& key) {
  namespace ba = boost::algorithm;
  return ba::all( key, ba::is_lower() || ba::is_digit() || ba::is_any_of("_") );
}


string TypeBase::desc() const {
    stringstream ss;
    ss << OutputText(this);
    return ss.str();
}



void TypeBase::delete_unfinished_types() {
    // mark unfinished types as deleted
    Input::TypeRepository<Instance>::get_instance().finish(FinishStatus::delete_);
    Input::TypeRepository<Abstract>::get_instance().finish(FinishStatus::delete_);
    Input::TypeRepository<Record>::get_instance().finish(FinishStatus::delete_);
    Input::TypeRepository<Tuple>::get_instance().finish(FinishStatus::delete_);
    Input::TypeRepository<Selection>::get_instance().finish(FinishStatus::delete_);

    // check and remove deleted types
    Input::TypeRepository<Instance>::get_instance().reset_deleted_types();
    Input::TypeRepository<Abstract>::get_instance().reset_deleted_types();
    Input::TypeRepository<Record>::get_instance().reset_deleted_types();
    Input::TypeRepository<Tuple>::get_instance().reset_deleted_types();
    Input::TypeRepository<Selection>::get_instance().reset_deleted_types();
}



 std::string TypeBase::hash_str(TypeHash hash) {
    stringstream ss;
    ss << "\"" << std::hex << hash << "\"";
    return ss.str();
}




void TypeBase::add_attribute_(std::string name, json_string val) {
    ASSERT(validate_json(val))(name)(val).error("Invalid JSON format of attribute");
    (*attributes_)[name] = val;
}


bool TypeBase::validate_json(json_string str) const {
    try {
        json_spirit::mValue node;
        json_spirit::read_or_throw( str, node);
        return true;
    } catch (json_spirit::Error_position &e ) {
        return false;
    }
}


TypeBase::json_string TypeBase::print_parameter_map_to_json(ParameterMap parameter_map) const {
    std::stringstream ss;
    ss << "{";
    for (ParameterMap::iterator it=parameter_map.begin(); it!=parameter_map.end(); it++) {
        if (it != parameter_map.begin()) ss << "," << endl;
        ss << "\"" << (*it).first << "\" : " << TypeBase::hash_str( (*it).second );
    }
    ss << "}";
    return ss.str();
}

TypeBase::json_string TypeBase::print_parameter_map_keys_to_json(ParameterMap parameter_map) const {
    stringstream ss;
    ss << "[ ";
    for (ParameterMap::iterator it=parameter_map.begin(); it!=parameter_map.end(); it++) {
        if (it != parameter_map.begin()) ss << ", ";
        ss << "\"" << it->first << "\"";
    }
    ss << " ]";
    return ss.str();
}

void TypeBase::set_generic_attributes(ParameterMap parameter_map) {
    // check if the type is really generic (it may be non-generic even if part of a generic subtree)
    if (parameter_map.size() > 0)
        add_attribute_(Attribute::generic_parameters(), print_parameter_map_keys_to_json(parameter_map));
    if (is_root_of_generic_subtree())
        add_attribute_(Attribute::root_of_generic_subtree(), "true");
}


void TypeBase::copy_attributes(attribute_map other_attributes) {
    attributes_->clear();
    for(auto &item : other_attributes) {
        if (item.first[0] != '_') // not internal attribute
            attributes_->insert(item);
    }
}


FinishStatus TypeBase::finish_status() const {
    return FinishStatus::regular_;
}


bool TypeBase::is_finished() const {
    return true;
}


bool TypeBase::is_closed() const {
    return true;
}


string TypeBase::type_name() const {
    return "TypeBase";
}


string TypeBase::class_name() const {
    return "TypeBase";
}


FinishStatus TypeBase::finish(FinishStatus finish_type) {
    ASSERT((finish_type != FinishStatus::none_) && (finish_type != FinishStatus::in_perform_)).error();
    return finish_type;
}


bool TypeBase::operator==(const TypeBase &other) const {
    return typeid(*this) == typeid(other);
}

bool TypeBase::operator!=(const TypeBase & other) const {
    return ! (*this == other);
}










std::ostream& operator<<(std::ostream& stream, const TypeBase& type) {
    return ( stream << OutputText(&type) );
}



/**********************************************************************************
 * implementation of Type::Array
 */

TypeBase::TypeHash Array::content_hash() const
{
    TypeHash seed=0;
    boost::hash_combine(seed, type_name());
    boost::hash_combine(seed, data_->lower_bound_);
    boost::hash_combine(seed, data_->upper_bound_);
    boost::hash_combine(seed, data_->type_of_values_->content_hash() );
    return seed;
}


FinishStatus Array::finish(FinishStatus finish_type) {
    return data_->finish(finish_type);
}



Array::ArrayData::ArrayData(unsigned int min_size, unsigned int max_size)
: lower_bound_(min_size), upper_bound_(max_size), finish_status(FinishStatus::none_)
{}


FinishStatus Array::ArrayData::finish(FinishStatus finish_type)
{
    ASSERT(finish_type != FinishStatus::none_).error();
    ASSERT(finish_type != FinishStatus::in_perform_).error();
    ASSERT(finish_status != FinishStatus::in_perform_).error("Recursion in the IST element: array_of_" + type_of_values_->type_name());

    if (finish_status != FinishStatus::none_) return finish_status;


    finish_status = FinishStatus::in_perform_;

    if (typeid( *(type_of_values_.get()) ) == typeid(Instance)) {
        type_of_values_->finish(FinishStatus::generic_); // finish Instance object
        type_of_values_ = type_of_values_->make_instance().first;
    }
    if ((finish_type != FinishStatus::generic_) && type_of_values_->is_root_of_generic_subtree())
        THROW( ExcGenericWithoutInstance() << EI_Object(type_of_values_->type_name()) );

    type_of_values_->finish(finish_type);
    ASSERT(type_of_values_->is_finished()).error();
    if (finish_type == FinishStatus::delete_) type_of_values_.reset();
    finish_status = finish_type;
    return (finish_status);
}



string Array::type_name() const {
    return "array_of_" + data_->type_of_values_->type_name();
}



string Array::class_name() const {
    return "Array";
}



bool Array::operator==(const TypeBase &other) const    {
    return  typeid(*this) == typeid(other) &&
              (*data_->type_of_values_ == static_cast<const Array *>(&other)->get_sub_type() );
}



TypeBase::MakeInstanceReturnType Array::make_instance(std::vector<ParameterPair> vec)  {
    // Create copy of array, we can't set type from parameter vector directly (it's TypeBase that is not allowed)
    Array arr = this->deep_copy();
    // Replace parameter stored in type_of_values_
    MakeInstanceReturnType inst = arr.data_->type_of_values_->make_instance(vec);
    arr.data_->type_of_values_ = inst.first;
    ParameterMap parameter_map = inst.second;
    // Copy attributes
    arr.copy_attributes(*attributes_);

    // Set parameters as attribute
    json_string val = this->print_parameter_map_to_json(parameter_map);
    ASSERT(this->validate_json(val))(val).error("Invalid JSON format of attribute 'parameters'.");
    arr.parameter_map_ = parameter_map;
    arr.generic_type_hash_ = this->content_hash();

    return std::make_pair( std::make_shared<Array>(arr), parameter_map );
}


Array Array::deep_copy() const {
    Array arr = Array(Integer()); // Type integer will be overwritten
    arr.data_ = std::make_shared<Array::ArrayData>(*this->data_);
    arr.data_->finish_status = FinishStatus::none_;
    return arr;
}


Array::Array(std::shared_ptr<TypeBase> type, unsigned int min_size, unsigned int max_size)
: data_(std::make_shared<ArrayData>(min_size, max_size))
{
    ASSERT_LE(min_size, max_size).error("Wrong limits for size of Input::Type::Array");
    ASSERT(type->is_closed()).error();

    data_->type_of_values_ = type;
}


/// Override @p Type::TypeBase::finish_status.
FinishStatus Array::finish_status() const {
    return data_->finish_status; }


bool Array::is_finished() const {
    return (data_->finish_status != FinishStatus::none_) && (data_->finish_status != FinishStatus::in_perform_);
}


/**********************************************************************************
 * implementation and explicit instantiation of Array constructor template
 */

template <class ValueType>
Array::Array(const ValueType &type, unsigned int min_size, unsigned int max_size)
: Array(std::static_pointer_cast<TypeBase>( std::make_shared<ValueType>(type) ), min_size, max_size)
{
    static_assert(std::is_base_of<TypeBase, ValueType >::value, "The type of declared keys has to be a class derived from TypeBase.");
}

// explicit instantiation

#define ARRAY_CONSTRUCT(TYPE) \
template Array::Array(const TYPE &type, unsigned int min_size, unsigned int max_size)

ARRAY_CONSTRUCT(String);
ARRAY_CONSTRUCT(Integer);
ARRAY_CONSTRUCT(Double);
ARRAY_CONSTRUCT(Bool);
ARRAY_CONSTRUCT(FileName);
ARRAY_CONSTRUCT(Selection);
ARRAY_CONSTRUCT(Array);
ARRAY_CONSTRUCT(Record);
ARRAY_CONSTRUCT(Tuple);
ARRAY_CONSTRUCT(Abstract);
ARRAY_CONSTRUCT(Parameter);
ARRAY_CONSTRUCT(Instance);


/**********************************************************************************
 * implementation of Type::Scalar ... and descendants.
 */

/**********************************************************************************
 * implementation of Type::Bool
 */


TypeBase::TypeHash Bool::content_hash() const
{
    TypeHash seed=0;
    boost::hash_combine(seed, type_name());
    return seed;
}


string Bool::type_name() const {
    return "Bool";
}


string Bool::class_name() const {
    return "Bool";
}


TypeBase::MakeInstanceReturnType Bool::make_instance(FMT_UNUSED std::vector<ParameterPair> vec)  {
    return std::make_pair( std::make_shared<Bool>(*this), ParameterMap() );
}

/**********************************************************************************
 * implementation of Type::Integer
 */

Integer::Integer(int lower_bound, int upper_bound)
: lower_bound_(lower_bound), upper_bound_(upper_bound)
{}



TypeBase::TypeHash Integer::content_hash() const
{
    TypeHash seed=0;
    boost::hash_combine(seed, type_name());
    boost::hash_combine(seed, lower_bound_);
    boost::hash_combine(seed, upper_bound_);
    return seed;
}



bool Integer::match(std::int64_t value) const {
    return ( value >=lower_bound_ && value <= upper_bound_);
}



string Integer::type_name() const {
    return "Integer";
}


string Integer::class_name() const {
    return "Integer";
}


TypeBase::MakeInstanceReturnType Integer::make_instance(FMT_UNUSED std::vector<ParameterPair> vec) {
    return std::make_pair( std::make_shared<Integer>(*this), ParameterMap() );
}


/**********************************************************************************
 * implementation of Type::Double
 */


Double::Double(double lower_bound, double upper_bound)
: lower_bound_(lower_bound), upper_bound_(upper_bound)
{}


TypeBase::TypeHash Double::content_hash() const
{
    TypeHash seed=0;
    boost::hash_combine(seed, type_name());
    boost::hash_combine(seed, lower_bound_);
    boost::hash_combine(seed, upper_bound_);
    return seed;
}



bool Double::match(double value) const {
    return ( value >=lower_bound_ && value <= upper_bound_);
}



string Double::type_name() const {
    return "Double";
}


string Double::class_name() const {
    return "Double";
}


TypeBase::MakeInstanceReturnType Double::make_instance(FMT_UNUSED std::vector<ParameterPair> vec) {
    return std::make_pair( std::make_shared<Double>(*this), ParameterMap() );
}


/**********************************************************************************
 * implementation of Type::FileName
 */

FileName::FileName() {}



FileName::FileName(enum ::FilePath::FileType type)
: type_(type)
{}



FileName FileName::input()
{
    return FileName(::FilePath::input_file);
}



FileName FileName::output()
{
    return FileName(::FilePath::output_file);
}



TypeBase::TypeHash FileName::content_hash() const
{
    TypeHash seed=0;
    boost::hash_combine(seed, type_name());
    boost::hash_combine(seed, type_);
    return seed;
}





string FileName::type_name() const {
    switch (type_) {
    case ::FilePath::input_file:
        return "FileName_input";
    case ::FilePath::output_file:
        return "FileName_output";
    default:
        return "FileName";
    }
}


string FileName::class_name() const {
    return "FileName";
}



bool FileName::match(const string &str) const {
    return (type_ == ::FilePath::input_file) || (str[0] != DIR_DELIMITER); // output files can not be absolute
}



TypeBase::MakeInstanceReturnType FileName::make_instance(FMT_UNUSED std::vector<ParameterPair> vec)  {
    return std::make_pair( std::make_shared<FileName>(*this), ParameterMap() );
}



::FilePath::FileType FileName::get_file_type() const {
    return type_;
}




bool FileName::operator==(const TypeBase &other) const
{
    return typeid(*this) == typeid(other) &&
                 (type_== static_cast<const FileName *>(&other)->get_file_type() );
}


/**********************************************************************************
 * implementation of Type::String
 */


TypeBase::TypeHash String::content_hash() const
{
    TypeHash seed=0;
    boost::hash_combine(seed, type_name());
    return seed;
}



string String::type_name() const {
    return "String";
}



string String::class_name() const {
    return "String";
}



bool String::match(FMT_UNUSED const string &str) const {
    return true;
}



TypeBase::MakeInstanceReturnType String::make_instance(FMT_UNUSED std::vector<ParameterPair> vec) {
    return std::make_pair( std::make_shared<String>(*this), ParameterMap() );
}



} // closing namespace Type
} // closing namespace Input