path: root/src/FSclAddress.cpp

//
// Copyright (c) 2012 Samsung Electronics Co., Ltd.
//
// Licensed 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.
//
/**
 * @file		FSclAddress.cpp
 * @brief		This is the implementation for Address class.
 *
 * This file contains definitions of @e Address class.
 */

#include <FBaseString.h>
#include <FSclAddress.h>
#include <FApp_AppInfo.h>
#include <FBaseSysLog.h>
#include "FScl_AddressImpl.h"

using namespace Tizen::App;
using namespace Tizen::Base;

namespace Tizen { namespace Social
{

static const int _MAX_ADDR_COUNTRY_LENGTH_2_0 = 100;

Address::Address(void)
{
	__pAddressImpl = new (std::nothrow) _AddressImpl();
	SysTryReturnVoidResult(NID_SCL, __pAddressImpl != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
}

Address::Address(const Address& rhs)
{
	__pAddressImpl = new (std::nothrow) _AddressImpl(*rhs.__pAddressImpl);
	SysTryReturnVoidResult(NID_SCL, __pAddressImpl != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));

}

Address::~Address(void)
{
	delete __pAddressImpl;
}

Address&
Address::operator =(const Address& rhs)
{
	if (this == &rhs)
	{
		return *this;
	}

	*__pAddressImpl = *rhs.__pAddressImpl;

	return *this;
}

bool
Address::operator ==(const Address& rhs) const
{
	return *__pAddressImpl == *rhs.__pAddressImpl;
}

bool
Address::operator !=(const Address& rhs) const
{
	return !(*this == rhs);
}

bool
Address::Equals(const Object& rhs) const
{
	const Address* pAddress = dynamic_cast<const Address*>(&rhs);

	if (pAddress == null)
	{
		return false;
	}

	return __pAddressImpl->Equals(*pAddress->__pAddressImpl);
}

int
Address::GetHashCode(void) const
{
	return __pAddressImpl->GetHashCode();
}

AddressType
Address::GetType(void) const
{
	AddressType type =  __pAddressImpl->GetType();

	if (type == ADDRESS_TYPE_CUSTOM && (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
	{
		type =  ADDRESS_TYPE_OTHER;
	}

	return type;
}

String
Address::GetExtended(void) const
{
	String extended =  __pAddressImpl->GetExtended();

	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		if (extended.GetLength() > MAX_ADDR_EXTENDED_LENGTH)
		{
			extended.SetLength(MAX_ADDR_EXTENDED_LENGTH);
		}
	}

	return extended;
}

String
Address::GetStreet(void) const
{
	String street =  __pAddressImpl->GetStreet();

	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		if (street.GetLength() > MAX_ADDR_STREET_LENGTH)
		{
			street.SetLength(MAX_ADDR_STREET_LENGTH);
		}
	}

	return street;
}

String
Address::GetCity(void) const
{
	String city =  __pAddressImpl->GetCity();

	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		if (city.GetLength() > MAX_ADDR_CITY_LENGTH)
		{
			city.SetLength(MAX_ADDR_CITY_LENGTH);
		}
	}

	return city;
}

String
Address::GetState(void) const
{
	String state =  __pAddressImpl->GetState();

	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		if (state.GetLength() > MAX_ADDR_STATE_LENGTH)
		{
			state.SetLength(MAX_ADDR_STATE_LENGTH);
		}
	}

	return state;
}

String
Address::GetPostalCode(void) const
{
	String postalCode =  __pAddressImpl->GetPostalCode();

	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		if (postalCode.GetLength() > MAX_ADDR_POSTAL_CODE_LENGTH)
		{
			postalCode.SetLength(MAX_ADDR_POSTAL_CODE_LENGTH);
		}
	}

	return postalCode;
}

String
Address::GetCountry(void) const
{
	String country =  __pAddressImpl->GetCountry();

	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		if (country.GetLength() > _MAX_ADDR_COUNTRY_LENGTH_2_0)
		{
			country.SetLength(_MAX_ADDR_COUNTRY_LENGTH_2_0);
		}
	}

	return country;
}

String
Address::GetPostOfficeBoxNumber(void) const
{
	String postOfficeBoxNumber = __pAddressImpl->GetPostOfficeBoxNumber();

	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		if (postOfficeBoxNumber.GetLength() > MAX_ADDR_POBOXNUM_LENGTH)
		{
			postOfficeBoxNumber.SetLength(MAX_ADDR_POBOXNUM_LENGTH);
		}
	}

	return postOfficeBoxNumber;
}

void
Address::SetType(AddressType type)
{
	return __pAddressImpl->SetType(type);
}

result
Address::SetExtended(const String& extended)
{
	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		SysTryReturn(NID_SCL, extended.GetLength() <= MAX_ADDR_EXTENDED_LENGTH,
				E_INVALID_ARG, E_INVALID_ARG, "[%s] Invalid argument is used. The length of the value exceeds MAX_ADDR_EXTENDED_LENGTH.", GetErrorMessage(E_INVALID_ARG));
	}

	__pAddressImpl->SetExtended(extended);

	return E_SUCCESS;
}

result
Address::SetStreet(const String& street)
{
	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		SysTryReturn(NID_SCL, street.GetLength() <= MAX_ADDR_STREET_LENGTH,
				E_INVALID_ARG, E_INVALID_ARG, "[%s] Invalid argument is used. The length of the value exceeds MAX_ADDR_STREET_LENGTH.", GetErrorMessage(E_INVALID_ARG));
	}

	__pAddressImpl->SetStreet(street);

	return E_SUCCESS;
}

result
Address::SetCity(const String& city)
{
	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		SysTryReturn(NID_SCL, city.GetLength() <= MAX_ADDR_CITY_LENGTH,
				E_INVALID_ARG, E_INVALID_ARG, "[%s] Invalid argument is used. The length of the value exceeds MAX_ADDR_CITY_LENGTH.", GetErrorMessage(E_INVALID_ARG));
	}

	__pAddressImpl->SetCity(city);

	return E_SUCCESS;
}

result
Address::SetState(const String& state)
{
	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		SysTryReturn(NID_SCL, state.GetLength() <= MAX_ADDR_STATE_LENGTH,
				E_INVALID_ARG, E_INVALID_ARG, "[%s] Invalid argument is used. The length of the value exceeds MAX_ADDR_STATE_LENGTH.", GetErrorMessage(E_INVALID_ARG));
	}

	__pAddressImpl->SetState(state);

	return E_SUCCESS;
}

result
Address::SetPostalCode(const String& postalCode)
{
	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		SysTryReturn(NID_SCL, postalCode.GetLength() <= MAX_ADDR_POSTAL_CODE_LENGTH,
				E_INVALID_ARG, E_INVALID_ARG, "[%s] Invalid argument is used. The length of the value exceeds MAX_ADDR_POSTAL_CODE_LENGTH.", GetErrorMessage(E_INVALID_ARG));
	}

	__pAddressImpl->SetPostalCode(postalCode);

	return E_SUCCESS;
}

result
Address::SetCountry(const String& country)
{
	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		SysTryReturn(NID_SCL, country.GetLength() <= _MAX_ADDR_COUNTRY_LENGTH_2_0,
				E_INVALID_ARG, E_INVALID_ARG, "[%s] Invalid argument is used. The length of country exceeds the maximum length.", GetErrorMessage(E_INVALID_ARG));
	}

	__pAddressImpl->SetCountry(country);

	return E_SUCCESS;
}

result
Address::SetPostOfficeBoxNumber(const String& postOfficeBoxNumber)
{
	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		SysTryReturn(NID_SCL, postOfficeBoxNumber.GetLength() <= MAX_ADDR_POBOXNUM_LENGTH,
				E_INVALID_ARG, E_INVALID_ARG, "[%s] Invalid argument is used. The length of the value exceeds MAX_ADDR_POBOXNUM_LENGTH.", GetErrorMessage(E_INVALID_ARG));
	}

	__pAddressImpl->SetPostOfficeBoxNumber(postOfficeBoxNumber);

	return E_SUCCESS;
}

String
Address::GetLabel(void) const
{
	return __pAddressImpl->GetLabel();
}

void
Address::SetLabel(const String& label)
{
	__pAddressImpl->SetLabel(label);
}


}} //Tizen::Social