storage.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    storage.cc
 * @brief   
 */

#include "system/global_defs.h"
#include "system/system.hh"
#include "input/storage.hh"

namespace Input {
using namespace std;

/**********************************************************************
 * Implements StorageBase
 */

std::int64_t StorageBase::get_int() const {
    THROW( ExcStorageTypeMismatch() << EI_RequestedType("int") << EI_StoredType( typeid(*this).name()) );
    return 0;
}



double StorageBase::get_double() const {
    THROW( ExcStorageTypeMismatch() << EI_RequestedType("double") << EI_StoredType( typeid(*this).name()) );
    return 0;
}



bool StorageBase::get_bool() const {
    THROW( ExcStorageTypeMismatch() << EI_RequestedType("bool") << EI_StoredType( typeid(*this).name()) );
    return false;
}



const std::string & StorageBase::get_string() const {
    THROW( ExcStorageTypeMismatch() << EI_RequestedType("string") << EI_StoredType( typeid(*this).name()) );
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wreturn-local-addr"
    return 0;   // Return reference to temporary, but we throw anyway.
#pragma GCC diagnostic pop
}



void StorageBase::set_item(unsigned int index, StorageBase* item) {
    THROW( ExcStorageTypeMismatch() << EI_RequestedType("array") << EI_StoredType( typeid(*this).name()) );
}



StorageBase * StorageBase::get_item(const unsigned int index) const {
    THROW( ExcStorageTypeMismatch() << EI_RequestedType("array") << EI_StoredType( typeid(*this).name()) );
    return 0;
}



bool StorageBase::is_null() const {
    return false;
}



unsigned int StorageBase::get_array_size() const {
    THROW( ExcStorageTypeMismatch() << EI_RequestedType("array") << EI_StoredType( typeid(*this).name()) );
    return 0;
}

StorageBase::~StorageBase()
{}

/*****************************************************************
 * Implementation of StorageArray
 */

StorageArray::StorageArray(unsigned int size)
: array_(size)
{
    for( vector<StorageBase *>::iterator it = array_.begin(); it != array_.end(); ++it)
        *it=NULL;
}

 StorageBase * StorageArray::deep_copy() const {
    StorageArray *copy = new StorageArray(this->get_array_size());

    for(unsigned int i=0; i< array_.size(); i++)
        if (array_[i] != NULL) copy->new_item(i, array_[i]->deep_copy() );

    return copy;
}

 void StorageArray::new_item(unsigned int index, StorageBase* item) {
     ASSERT_LT(index, array_.size()).error("Index is out of array.");
     ASSERT( array_[index] == NULL )(index).error("Can not replace non NULL pointer.");
     array_[index] = item;
 }


 void StorageArray::set_item(unsigned int index, StorageBase* item) {
    ASSERT_LT(index, array_.size()).error("Index is out of array.");

    if ( array_[index] != NULL ) delete array_[index];
    array_[index] = item;
 }



StorageBase * StorageArray::get_item(const unsigned int index) const {
    ASSERT_LT(index, array_.size()).error("Index is out of array.");
    ASSERT_PTR(array_[index])(index).error();
    return array_[index];
}



unsigned int StorageArray::get_array_size() const {
    return array_.size();
}



bool StorageArray::is_null() const {
    return false;
}


void StorageArray::print(ostream &stream, int pad)  const {
    stream << setw(pad) << "" << "array(" << this->get_array_size() << ")" << std::endl;
    for(unsigned int i=0;i<get_array_size();++i) get_item(i)->print(stream, pad+2);
}



StorageArray::~StorageArray() {
    for( vector<StorageBase *>::iterator it = array_.begin(); it != array_.end(); ++it)
        if (*it != NULL) delete (*it);
}

/**********************************************
 * Implementation of StorageBool
 */

StorageBool::StorageBool(bool value)
: value_(value)
{}



bool StorageBool::get_bool() const {
    return value_;
}



bool StorageBool::is_null() const {
    return false;
}



StorageBase * StorageBool::deep_copy() const {
    return new StorageBool(value_);
}

void StorageBool::print(ostream &stream, int pad) const {
    stream << setw(pad) << "" <<  "bool(" << value_ << ")"<<std::endl;
}

StorageBool::~StorageBool()
{}



/**********************************************
 * Implementation of StorageInt
 */

StorageInt::StorageInt(int value)
: value_(value)
{}



std::int64_t StorageInt::get_int() const {
    return value_;
}



bool StorageInt::is_null() const {
    return false;
}

 StorageBase * StorageInt::deep_copy() const {
    return new StorageInt(value_);
}


void StorageInt::print(ostream &stream, int pad) const {
   stream << setw(pad) << "" <<  "int(" << value_ << ")"<<std::endl;
}


StorageInt::~StorageInt()
{}



/**********************************************
 * Implementation of StorageDouble
 */

StorageDouble::StorageDouble(double value)
: value_(value)
{}



double StorageDouble::get_double() const {
    return value_;
}



bool StorageDouble::is_null() const {
    return false;
}

 StorageBase * StorageDouble::deep_copy() const {
    return new StorageDouble(value_);
}


void StorageDouble::print(ostream &stream, int pad) const {
    stream << setw(pad) << "" <<  "double(" << value_ << ")"<<std::endl;
}


StorageDouble::~StorageDouble()
{}



/**********************************************
 * Implementation of StorageString
 */

StorageString::StorageString(const string& value)
: value_(value)
{}



const string& StorageString::get_string() const {
    return value_;
}



bool StorageString::is_null() const {
    return false;
}


StorageBase * StorageString::deep_copy() const {
    return new StorageString(value_);
}


void StorageString::print(ostream &stream, int pad) const {
    stream << setw(pad) << "" << "string(" << value_ << ")"<<std::endl;
}


StorageString::~StorageString()
{}


/**********************************************
 * Implementation of StorageNull
 */


bool StorageNull::is_null() const {
    return true;
}



 StorageBase * StorageNull::deep_copy() const {
    return new StorageNull();
}



void StorageNull::print(ostream &stream, int pad) const{
    stream << setw(pad) << "" << "null()"<<std::endl;
}


StorageNull::~StorageNull()
{}


} // namespace Input