path: root/api/franca/navigation/src-gen/org/genivi/navigation/poiservice/POIServiceTypes.cpp

/*
* This file was generated by the CommonAPI Generators.
* Used org.genivi.commonapi.core 2.1.6.v20140519.
* Used org.franca.core 0.8.11.201401091023.
*
* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
* If a copy of the MPL was not distributed with this file, You can obtain one at
* http://mozilla.org/MPL/2.0/.
*/
#include "POIServiceTypes.h"


namespace org {
namespace genivi {
namespace navigation {
namespace poiservice {
namespace POIServiceTypes {













Details::Details(const std::vector<CategoryID>& parentsIdValue, const Icon& iconsValue, const std::string& nameValue, const std::string& shortDescValue, const Media& mediaValue):
        parentsId(parentsIdValue),
        icons(iconsValue),
        name(nameValue),
        shortDesc(shortDescValue),
        media(mediaValue)
{
}


bool operator==(const Details& lhs, const Details& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.parentsId == rhs.parentsId &&
        lhs.icons == rhs.icons &&
        lhs.name == rhs.name &&
        lhs.shortDesc == rhs.shortDesc &&
        lhs.media == rhs.media
    ;
}

void Details::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> parentsId;
    inputStream >> icons;
    inputStream >> name;
    inputStream >> shortDesc;
    inputStream >> media;
}

void Details::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << parentsId;
    outputStream << icons;
    outputStream << name;
    outputStream << shortDesc;
    outputStream << media;
}

Operator::Operator(const OperatorType& typeValue, const std::string& nameValue, const AttributeValue& valueValue):
        type(typeValue),
        name(nameValue),
        value(valueValue)
{
}


bool operator==(const Operator& lhs, const Operator& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.type == rhs.type &&
        lhs.name == rhs.name &&
        lhs.value == rhs.value
    ;
}

void Operator::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> type;
    inputStream >> name;
    inputStream >> value;
}

void Operator::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << type;
    outputStream << name;
    outputStream << value;
}

CategoryAttribute::CategoryAttribute(const AttributeID& idValue, const std::string& nameValue, const AttributeType& typeValue, const std::vector<Operator>& operatorsValue):
        id(idValue),
        name(nameValue),
        type(typeValue),
        operators(operatorsValue)
{
}


bool operator==(const CategoryAttribute& lhs, const CategoryAttribute& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.id == rhs.id &&
        lhs.name == rhs.name &&
        lhs.type == rhs.type &&
        lhs.operators == rhs.operators
    ;
}

void CategoryAttribute::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> id;
    inputStream >> name;
    inputStream >> type;
    inputStream >> operators;
}

void CategoryAttribute::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << id;
    outputStream << name;
    outputStream << type;
    outputStream << operators;
}

CategorySortOption::CategorySortOption(const CategoryID& idValue, const std::string& nameValue):
        id(idValue),
        name(nameValue)
{
}


bool operator==(const CategorySortOption& lhs, const CategorySortOption& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.id == rhs.id &&
        lhs.name == rhs.name
    ;
}

void CategorySortOption::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> id;
    inputStream >> name;
}

void CategorySortOption::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << id;
    outputStream << name;
}

CAMCategory::CAMCategory(const Details& detailsValue, const std::vector<CategoryAttribute>& attributesValue, const std::vector<CategorySortOption>& sortOptionsValue):
        details(detailsValue),
        attributes(attributesValue),
        sortOptions(sortOptionsValue)
{
}


bool operator==(const CAMCategory& lhs, const CAMCategory& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.details == rhs.details &&
        lhs.attributes == rhs.attributes &&
        lhs.sortOptions == rhs.sortOptions
    ;
}

void CAMCategory::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> details;
    inputStream >> attributes;
    inputStream >> sortOptions;
}

void CAMCategory::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << details;
    outputStream << attributes;
    outputStream << sortOptions;
}

CAMCategoryUpdate::CAMCategoryUpdate(const CategoryID& idValue, const std::vector<CategoryAttribute>& attributesValue, const std::vector<CategorySortOption>& sortOptionsValue):
        id(idValue),
        attributes(attributesValue),
        sortOptions(sortOptionsValue)
{
}


bool operator==(const CAMCategoryUpdate& lhs, const CAMCategoryUpdate& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.id == rhs.id &&
        lhs.attributes == rhs.attributes &&
        lhs.sortOptions == rhs.sortOptions
    ;
}

void CAMCategoryUpdate::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> id;
    inputStream >> attributes;
    inputStream >> sortOptions;
}

void CAMCategoryUpdate::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << id;
    outputStream << attributes;
    outputStream << sortOptions;
}

PoiAttribute::PoiAttribute(const AttributeID& idValue, const AttributeType& typeValue, const AttributeValue& valueValue):
        id(idValue),
        type(typeValue),
        value(valueValue)
{
}


bool operator==(const PoiAttribute& lhs, const PoiAttribute& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.id == rhs.id &&
        lhs.type == rhs.type &&
        lhs.value == rhs.value
    ;
}

void PoiAttribute::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> id;
    inputStream >> type;
    inputStream >> value;
}

void PoiAttribute::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << id;
    outputStream << type;
    outputStream << value;
}

CategoryAndRadius::CategoryAndRadius(const CategoryID& idValue, const uint32_t& radiusValue):
        id(idValue),
        radius(radiusValue)
{
}


bool operator==(const CategoryAndRadius& lhs, const CategoryAndRadius& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.id == rhs.id &&
        lhs.radius == rhs.radius
    ;
}

void CategoryAndRadius::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> id;
    inputStream >> radius;
}

void CategoryAndRadius::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << id;
    outputStream << radius;
}

PoiDetails::PoiDetails(const POI_ID& idValue, const std::string& nameValue, const NavigationTypes::Coordinate3D& locationValue):
        id(idValue),
        name(nameValue),
        location(locationValue)
{
}


bool operator==(const PoiDetails& lhs, const PoiDetails& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.id == rhs.id &&
        lhs.name == rhs.name &&
        lhs.location == rhs.location
    ;
}

void PoiDetails::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> id;
    inputStream >> name;
    inputStream >> location;
}

void PoiDetails::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << id;
    outputStream << name;
    outputStream << location;
}

SearchResultDetails::SearchResultDetails(const PoiDetails& detailsValue, const std::vector<CategoryID>& categoriesValue, const std::vector<PoiAttribute>& attributesValue):
        details(detailsValue),
        categories(categoriesValue),
        attributes(attributesValue)
{
}


bool operator==(const SearchResultDetails& lhs, const SearchResultDetails& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.details == rhs.details &&
        lhs.categories == rhs.categories &&
        lhs.attributes == rhs.attributes
    ;
}

void SearchResultDetails::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> details;
    inputStream >> categories;
    inputStream >> attributes;
}

void SearchResultDetails::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << details;
    outputStream << categories;
    outputStream << attributes;
}

SearchResult::SearchResult(const POI_ID& idValue, const uint32_t& distanceValue, const uint16_t& routeStatusValue, const std::vector<PoiAttribute>& attributesValue):
        id(idValue),
        distance(distanceValue),
        routeStatus(routeStatusValue),
        attributes(attributesValue)
{
}


bool operator==(const SearchResult& lhs, const SearchResult& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.id == rhs.id &&
        lhs.distance == rhs.distance &&
        lhs.routeStatus == rhs.routeStatus &&
        lhs.attributes == rhs.attributes
    ;
}

void SearchResult::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> id;
    inputStream >> distance;
    inputStream >> routeStatus;
    inputStream >> attributes;
}

void SearchResult::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << id;
    outputStream << distance;
    outputStream << routeStatus;
    outputStream << attributes;
}

PoiCAMDetails::PoiCAMDetails(const POI_ID& sourceIdValue, const std::string& nameValue, const CategoryID& categoryValue, const NavigationTypes::Coordinate3D& locationValue, const uint16_t& distanceValue, const std::vector<PoiAttribute>& attributesValue):
        sourceId(sourceIdValue),
        name(nameValue),
        category(categoryValue),
        location(locationValue),
        distance(distanceValue),
        attributes(attributesValue)
{
}


bool operator==(const PoiCAMDetails& lhs, const PoiCAMDetails& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.sourceId == rhs.sourceId &&
        lhs.name == rhs.name &&
        lhs.category == rhs.category &&
        lhs.location == rhs.location &&
        lhs.distance == rhs.distance &&
        lhs.attributes == rhs.attributes
    ;
}

void PoiCAMDetails::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> sourceId;
    inputStream >> name;
    inputStream >> category;
    inputStream >> location;
    inputStream >> distance;
    inputStream >> attributes;
}

void PoiCAMDetails::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << sourceId;
    outputStream << name;
    outputStream << category;
    outputStream << location;
    outputStream << distance;
    outputStream << attributes;
}

AttributeDetails::AttributeDetails(const AttributeID& idValue, const CategoryID& categoryIdValue, const AttributeType& typeValue, const AttributeValue& valueValue, const OperatorType& operValue, const bool& mandatoryValue):
        id(idValue),
        categoryId(categoryIdValue),
        type(typeValue),
        value(valueValue),
        oper(operValue),
        mandatory(mandatoryValue)
{
}


bool operator==(const AttributeDetails& lhs, const AttributeDetails& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.id == rhs.id &&
        lhs.categoryId == rhs.categoryId &&
        lhs.type == rhs.type &&
        lhs.value == rhs.value &&
        lhs.oper == rhs.oper &&
        lhs.mandatory == rhs.mandatory
    ;
}

void AttributeDetails::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> id;
    inputStream >> categoryId;
    inputStream >> type;
    inputStream >> value;
    inputStream >> oper;
    inputStream >> mandatory;
}

void AttributeDetails::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << id;
    outputStream << categoryId;
    outputStream << type;
    outputStream << value;
    outputStream << oper;
    outputStream << mandatory;
}

CategoryDetails::CategoryDetails(const CategoryID& uniqueIdValue, const std::vector<CategoryID>& parentsIdValue, const Icon& iconsValue, const std::string& nameValue, const bool& topLevelValue, const std::string& descriptionValue, const Media& mediaValue):
        uniqueId(uniqueIdValue),
        parentsId(parentsIdValue),
        icons(iconsValue),
        name(nameValue),
        topLevel(topLevelValue),
        description(descriptionValue),
        media(mediaValue)
{
}


bool operator==(const CategoryDetails& lhs, const CategoryDetails& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.uniqueId == rhs.uniqueId &&
        lhs.parentsId == rhs.parentsId &&
        lhs.icons == rhs.icons &&
        lhs.name == rhs.name &&
        lhs.topLevel == rhs.topLevel &&
        lhs.description == rhs.description &&
        lhs.media == rhs.media
    ;
}

void CategoryDetails::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> uniqueId;
    inputStream >> parentsId;
    inputStream >> icons;
    inputStream >> name;
    inputStream >> topLevel;
    inputStream >> description;
    inputStream >> media;
}

void CategoryDetails::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << uniqueId;
    outputStream << parentsId;
    outputStream << icons;
    outputStream << name;
    outputStream << topLevel;
    outputStream << description;
    outputStream << media;
}

Category::Category(const CategoryDetails& detailsValue, const std::vector<CategoryAttribute>& attributesValue, const std::vector<CategorySortOption>& sortOptionsValue):
        details(detailsValue),
        attributes(attributesValue),
        sortOptions(sortOptionsValue)
{
}


bool operator==(const Category& lhs, const Category& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.details == rhs.details &&
        lhs.attributes == rhs.attributes &&
        lhs.sortOptions == rhs.sortOptions
    ;
}

void Category::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> details;
    inputStream >> attributes;
    inputStream >> sortOptions;
}

void Category::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << details;
    outputStream << attributes;
    outputStream << sortOptions;
}

CategoryAndLevel::CategoryAndLevel(const CategoryID& uniqueIdValue, const bool& topLevelValue):
        uniqueId(uniqueIdValue),
        topLevel(topLevelValue)
{
}


bool operator==(const CategoryAndLevel& lhs, const CategoryAndLevel& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.uniqueId == rhs.uniqueId &&
        lhs.topLevel == rhs.topLevel
    ;
}

void CategoryAndLevel::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> uniqueId;
    inputStream >> topLevel;
}

void CategoryAndLevel::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << uniqueId;
    outputStream << topLevel;
}

CategoryAndName::CategoryAndName(const CategoryID& uniqueIdValue, const std::string& nameValue, const bool& topLevelValue):
        uniqueId(uniqueIdValue),
        name(nameValue),
        topLevel(topLevelValue)
{
}


bool operator==(const CategoryAndName& lhs, const CategoryAndName& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.uniqueId == rhs.uniqueId &&
        lhs.name == rhs.name &&
        lhs.topLevel == rhs.topLevel
    ;
}

void CategoryAndName::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> uniqueId;
    inputStream >> name;
    inputStream >> topLevel;
}

void CategoryAndName::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << uniqueId;
    outputStream << name;
    outputStream << topLevel;
}

CategoryAndReason::CategoryAndReason(const CategoryID& unique_idValue, const uint16_t& reasonValue):
        unique_id(unique_idValue),
        reason(reasonValue)
{
}


bool operator==(const CategoryAndReason& lhs, const CategoryAndReason& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.unique_id == rhs.unique_id &&
        lhs.reason == rhs.reason
    ;
}

void CategoryAndReason::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> unique_id;
    inputStream >> reason;
}

void CategoryAndReason::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << unique_id;
    outputStream << reason;
}

CategoryAndStatus::CategoryAndStatus(const CategoryID& uniqueIdValue, const bool& statusValue):
        uniqueId(uniqueIdValue),
        status(statusValue)
{
}


bool operator==(const CategoryAndStatus& lhs, const CategoryAndStatus& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.uniqueId == rhs.uniqueId &&
        lhs.status == rhs.status
    ;
}

void CategoryAndStatus::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> uniqueId;
    inputStream >> status;
}

void CategoryAndStatus::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << uniqueId;
    outputStream << status;
}

PoiAddedDetails::PoiAddedDetails(const std::string& nameValue, const NavigationTypes::Coordinate3D& locationValue, const std::vector<PoiAttribute>& attributesValue):
        name(nameValue),
        location(locationValue),
        attributes(attributesValue)
{
}


bool operator==(const PoiAddedDetails& lhs, const PoiAddedDetails& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.name == rhs.name &&
        lhs.location == rhs.location &&
        lhs.attributes == rhs.attributes
    ;
}

void PoiAddedDetails::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> name;
    inputStream >> location;
    inputStream >> attributes;
}

void PoiAddedDetails::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << name;
    outputStream << location;
    outputStream << attributes;
}

Locales::Locales(const std::string& languageCodeValue, const std::string& countryCodeValue, const std::string& scriptCodeValue):
        languageCode(languageCodeValue),
        countryCode(countryCodeValue),
        scriptCode(scriptCodeValue)
{
}


bool operator==(const Locales& lhs, const Locales& rhs) {
    if (&lhs == &rhs)
        return true;

    return
        lhs.languageCode == rhs.languageCode &&
        lhs.countryCode == rhs.countryCode &&
        lhs.scriptCode == rhs.scriptCode
    ;
}

void Locales::readFromInputStream(CommonAPI::InputStream& inputStream) {
    inputStream >> languageCode;
    inputStream >> countryCode;
    inputStream >> scriptCode;
}

void Locales::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
    outputStream << languageCode;
    outputStream << countryCode;
    outputStream << scriptCode;
}

} // namespace POIServiceTypes
} // namespace poiservice
} // namespace navigation
} // namespace genivi
} // namespace org