text stringlengths 9 39.2M | dir stringlengths 26 295 | lang stringclasses 185
values | created_date timestamp[us] | updated_date timestamp[us] | repo_name stringlengths 1 97 | repo_full_name stringlengths 7 106 | star int64 1k 183k | len_tokens int64 1 13.8M |
|---|---|---|---|---|---|---|---|---|
```objective-c
#import <Foundation/Foundation.h>
@interface PodsDummy_Reusable_iOS : NSObject
@end
@implementation PodsDummy_Reusable_iOS
@end
``` | /content/code_sandbox/Example/Pods/Target Support Files/Reusable-iOS/Reusable-iOS-dummy.m | objective-c | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 27 |
```objective-c
#ifdef __OBJC__
#import <UIKit/UIKit.h>
#else
#ifndef FOUNDATION_EXPORT
#if defined(__cplusplus)
#define FOUNDATION_EXPORT extern "C"
#else
#define FOUNDATION_EXPORT extern
#endif
#endif
#endif
FOUNDATION_EXPORT double Pods_ReusableDemo_tvOSVersionNumber;
FOUNDATION_EXPORT const unsigned char Pods_ReusableDemo_tvOSVersionString[];
``` | /content/code_sandbox/Example/Pods/Target Support Files/Pods-ReusableDemo tvOS/Pods-ReusableDemo tvOS-umbrella.h | objective-c | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 72 |
```objective-c
#import <Foundation/Foundation.h>
@interface PodsDummy_Pods_ReusableDemo_tvOS : NSObject
@end
@implementation PodsDummy_Pods_ReusableDemo_tvOS
@end
``` | /content/code_sandbox/Example/Pods/Target Support Files/Pods-ReusableDemo tvOS/Pods-ReusableDemo tvOS-dummy.m | objective-c | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 31 |
```shell
#!/bin/sh
set -e
set -u
set -o pipefail
if [ -z ${UNLOCALIZED_RESOURCES_FOLDER_PATH+x} ]; then
# If UNLOCALIZED_RESOURCES_FOLDER_PATH is not set, then there's nowhere for us to copy
# resources to, so exit 0 (signalling the script phase was successful).
exit 0
fi
mkdir -p "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
RESOURCES_TO_COPY=${PODS_ROOT}/resources-to-copy-${TARGETNAME}.txt
> "$RESOURCES_TO_COPY"
XCASSET_FILES=()
# This protects against multiple targets copying the same framework dependency at the same time. The solution
# was originally proposed here: path_to_url
RSYNC_PROTECT_TMP_FILES=(--filter "P .*.??????")
case "${TARGETED_DEVICE_FAMILY:-}" in
1,2)
TARGET_DEVICE_ARGS="--target-device ipad --target-device iphone"
;;
1)
TARGET_DEVICE_ARGS="--target-device iphone"
;;
2)
TARGET_DEVICE_ARGS="--target-device ipad"
;;
3)
TARGET_DEVICE_ARGS="--target-device tv"
;;
4)
TARGET_DEVICE_ARGS="--target-device watch"
;;
*)
TARGET_DEVICE_ARGS="--target-device mac"
;;
esac
install_resource()
{
if [[ "$1" = /* ]] ; then
RESOURCE_PATH="$1"
else
RESOURCE_PATH="${PODS_ROOT}/$1"
fi
if [[ ! -e "$RESOURCE_PATH" ]] ; then
cat << EOM
error: Resource "$RESOURCE_PATH" not found. Run 'pod install' to update the copy resources script.
EOM
exit 1
fi
case $RESOURCE_PATH in
*.storyboard)
echo "ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile ${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \"$RESOURCE_PATH\" .storyboard`.storyboardc $RESOURCE_PATH --sdk ${SDKROOT} ${TARGET_DEVICE_ARGS}" || true
ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \"$RESOURCE_PATH\" .storyboard`.storyboardc" "$RESOURCE_PATH" --sdk "${SDKROOT}" ${TARGET_DEVICE_ARGS}
;;
*.xib)
echo "ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile ${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \"$RESOURCE_PATH\" .xib`.nib $RESOURCE_PATH --sdk ${SDKROOT} ${TARGET_DEVICE_ARGS}" || true
ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \"$RESOURCE_PATH\" .xib`.nib" "$RESOURCE_PATH" --sdk "${SDKROOT}" ${TARGET_DEVICE_ARGS}
;;
*.framework)
echo "mkdir -p ${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}" || true
mkdir -p "${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" $RESOURCE_PATH ${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}" || true
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" "$RESOURCE_PATH" "${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
;;
*.xcdatamodel)
echo "xcrun momc \"$RESOURCE_PATH\" \"${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename "$RESOURCE_PATH"`.mom\"" || true
xcrun momc "$RESOURCE_PATH" "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename "$RESOURCE_PATH" .xcdatamodel`.mom"
;;
*.xcdatamodeld)
echo "xcrun momc \"$RESOURCE_PATH\" \"${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename "$RESOURCE_PATH" .xcdatamodeld`.momd\"" || true
xcrun momc "$RESOURCE_PATH" "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename "$RESOURCE_PATH" .xcdatamodeld`.momd"
;;
*.xcmappingmodel)
echo "xcrun mapc \"$RESOURCE_PATH\" \"${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename "$RESOURCE_PATH" .xcmappingmodel`.cdm\"" || true
xcrun mapc "$RESOURCE_PATH" "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename "$RESOURCE_PATH" .xcmappingmodel`.cdm"
;;
*.xcassets)
ABSOLUTE_XCASSET_FILE="$RESOURCE_PATH"
XCASSET_FILES+=("$ABSOLUTE_XCASSET_FILE")
;;
*)
echo "$RESOURCE_PATH" || true
echo "$RESOURCE_PATH" >> "$RESOURCES_TO_COPY"
;;
esac
}
mkdir -p "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
rsync -avr --copy-links --no-relative --exclude '*/.svn/*' --files-from="$RESOURCES_TO_COPY" / "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
if [[ "${ACTION}" == "install" ]] && [[ "${SKIP_INSTALL}" == "NO" ]]; then
mkdir -p "${INSTALL_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
rsync -avr --copy-links --no-relative --exclude '*/.svn/*' --files-from="$RESOURCES_TO_COPY" / "${INSTALL_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
fi
rm -f "$RESOURCES_TO_COPY"
if [[ -n "${WRAPPER_EXTENSION}" ]] && [ "`xcrun --find actool`" ] && [ -n "${XCASSET_FILES:-}" ]
then
# Find all other xcassets (this unfortunately includes those of path pods and other targets).
OTHER_XCASSETS=$(find "$PWD" -iname "*.xcassets" -type d)
while read line; do
if [[ $line != "${PODS_ROOT}*" ]]; then
XCASSET_FILES+=("$line")
fi
done <<<"$OTHER_XCASSETS"
if [ -z ${ASSETCATALOG_COMPILER_APPICON_NAME+x} ]; then
printf "%s\0" "${XCASSET_FILES[@]}" | xargs -0 xcrun actool --output-format human-readable-text --notices --warnings --platform "${PLATFORM_NAME}" --minimum-deployment-target "${!DEPLOYMENT_TARGET_SETTING_NAME}" ${TARGET_DEVICE_ARGS} --compress-pngs --compile "${BUILT_PRODUCTS_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
else
printf "%s\0" "${XCASSET_FILES[@]}" | xargs -0 xcrun actool --output-format human-readable-text --notices --warnings --platform "${PLATFORM_NAME}" --minimum-deployment-target "${!DEPLOYMENT_TARGET_SETTING_NAME}" ${TARGET_DEVICE_ARGS} --compress-pngs --compile "${BUILT_PRODUCTS_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}" --app-icon "${ASSETCATALOG_COMPILER_APPICON_NAME}" --output-partial-info-plist "${TARGET_TEMP_DIR}/assetcatalog_generated_info_cocoapods.plist"
fi
fi
``` | /content/code_sandbox/Example/Pods/Target Support Files/Pods-ReusableDemo tvOS/Pods-ReusableDemo tvOS-resources.sh | shell | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 1,630 |
```shell
#!/bin/sh
set -e
set -u
set -o pipefail
function on_error {
echo "$(realpath -mq "${0}"):$1: error: Unexpected failure"
}
trap 'on_error $LINENO' ERR
if [ -z ${FRAMEWORKS_FOLDER_PATH+x} ]; then
# If FRAMEWORKS_FOLDER_PATH is not set, then there's nowhere for us to copy
# frameworks to, so exit 0 (signalling the script phase was successful).
exit 0
fi
echo "mkdir -p ${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
mkdir -p "${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
COCOAPODS_PARALLEL_CODE_SIGN="${COCOAPODS_PARALLEL_CODE_SIGN:-false}"
SWIFT_STDLIB_PATH="${DT_TOOLCHAIN_DIR}/usr/lib/swift/${PLATFORM_NAME}"
BCSYMBOLMAP_DIR="BCSymbolMaps"
# This protects against multiple targets copying the same framework dependency at the same time. The solution
# was originally proposed here: path_to_url
RSYNC_PROTECT_TMP_FILES=(--filter "P .*.??????")
# Copies and strips a vendored framework
install_framework()
{
if [ -r "${BUILT_PRODUCTS_DIR}/$1" ]; then
local source="${BUILT_PRODUCTS_DIR}/$1"
elif [ -r "${BUILT_PRODUCTS_DIR}/$(basename "$1")" ]; then
local source="${BUILT_PRODUCTS_DIR}/$(basename "$1")"
elif [ -r "$1" ]; then
local source="$1"
fi
local destination="${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
if [ -L "${source}" ]; then
echo "Symlinked..."
source="$(readlink "${source}")"
fi
if [ -d "${source}/${BCSYMBOLMAP_DIR}" ]; then
# Locate and install any .bcsymbolmaps if present, and remove them from the .framework before the framework is copied
find "${source}/${BCSYMBOLMAP_DIR}" -name "*.bcsymbolmap"|while read f; do
echo "Installing $f"
install_bcsymbolmap "$f" "$destination"
rm "$f"
done
rmdir "${source}/${BCSYMBOLMAP_DIR}"
fi
# Use filter instead of exclude so missing patterns don't throw errors.
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${source}\" \"${destination}\""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${source}" "${destination}"
local basename
basename="$(basename -s .framework "$1")"
binary="${destination}/${basename}.framework/${basename}"
if ! [ -r "$binary" ]; then
binary="${destination}/${basename}"
elif [ -L "${binary}" ]; then
echo "Destination binary is symlinked..."
dirname="$(dirname "${binary}")"
binary="${dirname}/$(readlink "${binary}")"
fi
# Strip invalid architectures so "fat" simulator / device frameworks work on device
if [[ "$(file "$binary")" == *"dynamically linked shared library"* ]]; then
strip_invalid_archs "$binary"
fi
# Resign the code if required by the build settings to avoid unstable apps
code_sign_if_enabled "${destination}/$(basename "$1")"
# Embed linked Swift runtime libraries. No longer necessary as of Xcode 7.
if [ "${XCODE_VERSION_MAJOR}" -lt 7 ]; then
local swift_runtime_libs
swift_runtime_libs=$(xcrun otool -LX "$binary" | grep --color=never @rpath/libswift | sed -E s/@rpath\\/\(.+dylib\).*/\\1/g | uniq -u)
for lib in $swift_runtime_libs; do
echo "rsync -auv \"${SWIFT_STDLIB_PATH}/${lib}\" \"${destination}\""
rsync -auv "${SWIFT_STDLIB_PATH}/${lib}" "${destination}"
code_sign_if_enabled "${destination}/${lib}"
done
fi
}
# Copies and strips a vendored dSYM
install_dsym() {
local source="$1"
warn_missing_arch=${2:-true}
if [ -r "$source" ]; then
# Copy the dSYM into the targets temp dir.
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${source}\" \"${DERIVED_FILES_DIR}\""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${source}" "${DERIVED_FILES_DIR}"
local basename
basename="$(basename -s .dSYM "$source")"
binary_name="$(ls "$source/Contents/Resources/DWARF")"
binary="${DERIVED_FILES_DIR}/${basename}.dSYM/Contents/Resources/DWARF/${binary_name}"
# Strip invalid architectures from the dSYM.
if [[ "$(file "$binary")" == *"Mach-O "*"dSYM companion"* ]]; then
strip_invalid_archs "$binary" "$warn_missing_arch"
fi
if [[ $STRIP_BINARY_RETVAL == 0 ]]; then
# Move the stripped file into its final destination.
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${DERIVED_FILES_DIR}/${basename}.framework.dSYM\" \"${DWARF_DSYM_FOLDER_PATH}\""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${DERIVED_FILES_DIR}/${basename}.dSYM" "${DWARF_DSYM_FOLDER_PATH}"
else
# The dSYM was not stripped at all, in this case touch a fake folder so the input/output paths from Xcode do not reexecute this script because the file is missing.
mkdir -p "${DWARF_DSYM_FOLDER_PATH}"
touch "${DWARF_DSYM_FOLDER_PATH}/${basename}.dSYM"
fi
fi
}
# Used as a return value for each invocation of `strip_invalid_archs` function.
STRIP_BINARY_RETVAL=0
# Strip invalid architectures
strip_invalid_archs() {
binary="$1"
warn_missing_arch=${2:-true}
# Get architectures for current target binary
binary_archs="$(lipo -info "$binary" | rev | cut -d ':' -f1 | awk '{$1=$1;print}' | rev)"
# Intersect them with the architectures we are building for
intersected_archs="$(echo ${ARCHS[@]} ${binary_archs[@]} | tr ' ' '\n' | sort | uniq -d)"
# If there are no archs supported by this binary then warn the user
if [[ -z "$intersected_archs" ]]; then
if [[ "$warn_missing_arch" == "true" ]]; then
echo "warning: [CP] Vendored binary '$binary' contains architectures ($binary_archs) none of which match the current build architectures ($ARCHS)."
fi
STRIP_BINARY_RETVAL=1
return
fi
stripped=""
for arch in $binary_archs; do
if ! [[ "${ARCHS}" == *"$arch"* ]]; then
# Strip non-valid architectures in-place
lipo -remove "$arch" -output "$binary" "$binary"
stripped="$stripped $arch"
fi
done
if [[ "$stripped" ]]; then
echo "Stripped $binary of architectures:$stripped"
fi
STRIP_BINARY_RETVAL=0
}
# Copies the bcsymbolmap files of a vendored framework
install_bcsymbolmap() {
local bcsymbolmap_path="$1"
local destination="${BUILT_PRODUCTS_DIR}"
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${bcsymbolmap_path}" "${destination}""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${bcsymbolmap_path}" "${destination}"
}
# Signs a framework with the provided identity
code_sign_if_enabled() {
if [ -n "${EXPANDED_CODE_SIGN_IDENTITY:-}" -a "${CODE_SIGNING_REQUIRED:-}" != "NO" -a "${CODE_SIGNING_ALLOWED}" != "NO" ]; then
# Use the current code_sign_identity
echo "Code Signing $1 with Identity ${EXPANDED_CODE_SIGN_IDENTITY_NAME}"
local code_sign_cmd="/usr/bin/codesign --force --sign ${EXPANDED_CODE_SIGN_IDENTITY} ${OTHER_CODE_SIGN_FLAGS:-} --preserve-metadata=identifier,entitlements '$1'"
if [ "${COCOAPODS_PARALLEL_CODE_SIGN}" == "true" ]; then
code_sign_cmd="$code_sign_cmd &"
fi
echo "$code_sign_cmd"
eval "$code_sign_cmd"
fi
}
if [[ "$CONFIGURATION" == "Debug" ]]; then
install_framework "${BUILT_PRODUCTS_DIR}/Reusable-tvOS/Reusable.framework"
fi
if [[ "$CONFIGURATION" == "Release" ]]; then
install_framework "${BUILT_PRODUCTS_DIR}/Reusable-tvOS/Reusable.framework"
fi
if [ "${COCOAPODS_PARALLEL_CODE_SIGN}" == "true" ]; then
wait
fi
``` | /content/code_sandbox/Example/Pods/Target Support Files/Pods-ReusableDemo tvOS/Pods-ReusableDemo tvOS-frameworks.sh | shell | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 2,346 |
```markdown
# Acknowledgements
This application makes use of the following third party libraries:
## Reusable
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Generated by CocoaPods - path_to_url
``` | /content/code_sandbox/Example/Pods/Target Support Files/Pods-ReusableDemo tvOS/Pods-ReusableDemo tvOS-acknowledgements.markdown | markdown | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 237 |
```objective-c
#import <Foundation/Foundation.h>
@interface PodsDummy_Pods_ReusableDemo_iOS : NSObject
@end
@implementation PodsDummy_Pods_ReusableDemo_iOS
@end
``` | /content/code_sandbox/Example/Pods/Target Support Files/Pods-ReusableDemo iOS/Pods-ReusableDemo iOS-dummy.m | objective-c | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 31 |
```objective-c
#ifdef __OBJC__
#import <UIKit/UIKit.h>
#else
#ifndef FOUNDATION_EXPORT
#if defined(__cplusplus)
#define FOUNDATION_EXPORT extern "C"
#else
#define FOUNDATION_EXPORT extern
#endif
#endif
#endif
FOUNDATION_EXPORT double Pods_ReusableDemo_iOSVersionNumber;
FOUNDATION_EXPORT const unsigned char Pods_ReusableDemo_iOSVersionString[];
``` | /content/code_sandbox/Example/Pods/Target Support Files/Pods-ReusableDemo iOS/Pods-ReusableDemo iOS-umbrella.h | objective-c | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 72 |
```shell
#!/bin/sh
set -e
set -u
set -o pipefail
function on_error {
echo "$(realpath -mq "${0}"):$1: error: Unexpected failure"
}
trap 'on_error $LINENO' ERR
if [ -z ${FRAMEWORKS_FOLDER_PATH+x} ]; then
# If FRAMEWORKS_FOLDER_PATH is not set, then there's nowhere for us to copy
# frameworks to, so exit 0 (signalling the script phase was successful).
exit 0
fi
echo "mkdir -p ${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
mkdir -p "${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
COCOAPODS_PARALLEL_CODE_SIGN="${COCOAPODS_PARALLEL_CODE_SIGN:-false}"
SWIFT_STDLIB_PATH="${DT_TOOLCHAIN_DIR}/usr/lib/swift/${PLATFORM_NAME}"
BCSYMBOLMAP_DIR="BCSymbolMaps"
# This protects against multiple targets copying the same framework dependency at the same time. The solution
# was originally proposed here: path_to_url
RSYNC_PROTECT_TMP_FILES=(--filter "P .*.??????")
# Copies and strips a vendored framework
install_framework()
{
if [ -r "${BUILT_PRODUCTS_DIR}/$1" ]; then
local source="${BUILT_PRODUCTS_DIR}/$1"
elif [ -r "${BUILT_PRODUCTS_DIR}/$(basename "$1")" ]; then
local source="${BUILT_PRODUCTS_DIR}/$(basename "$1")"
elif [ -r "$1" ]; then
local source="$1"
fi
local destination="${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
if [ -L "${source}" ]; then
echo "Symlinked..."
source="$(readlink "${source}")"
fi
if [ -d "${source}/${BCSYMBOLMAP_DIR}" ]; then
# Locate and install any .bcsymbolmaps if present, and remove them from the .framework before the framework is copied
find "${source}/${BCSYMBOLMAP_DIR}" -name "*.bcsymbolmap"|while read f; do
echo "Installing $f"
install_bcsymbolmap "$f" "$destination"
rm "$f"
done
rmdir "${source}/${BCSYMBOLMAP_DIR}"
fi
# Use filter instead of exclude so missing patterns don't throw errors.
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${source}\" \"${destination}\""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${source}" "${destination}"
local basename
basename="$(basename -s .framework "$1")"
binary="${destination}/${basename}.framework/${basename}"
if ! [ -r "$binary" ]; then
binary="${destination}/${basename}"
elif [ -L "${binary}" ]; then
echo "Destination binary is symlinked..."
dirname="$(dirname "${binary}")"
binary="${dirname}/$(readlink "${binary}")"
fi
# Strip invalid architectures so "fat" simulator / device frameworks work on device
if [[ "$(file "$binary")" == *"dynamically linked shared library"* ]]; then
strip_invalid_archs "$binary"
fi
# Resign the code if required by the build settings to avoid unstable apps
code_sign_if_enabled "${destination}/$(basename "$1")"
# Embed linked Swift runtime libraries. No longer necessary as of Xcode 7.
if [ "${XCODE_VERSION_MAJOR}" -lt 7 ]; then
local swift_runtime_libs
swift_runtime_libs=$(xcrun otool -LX "$binary" | grep --color=never @rpath/libswift | sed -E s/@rpath\\/\(.+dylib\).*/\\1/g | uniq -u)
for lib in $swift_runtime_libs; do
echo "rsync -auv \"${SWIFT_STDLIB_PATH}/${lib}\" \"${destination}\""
rsync -auv "${SWIFT_STDLIB_PATH}/${lib}" "${destination}"
code_sign_if_enabled "${destination}/${lib}"
done
fi
}
# Copies and strips a vendored dSYM
install_dsym() {
local source="$1"
warn_missing_arch=${2:-true}
if [ -r "$source" ]; then
# Copy the dSYM into the targets temp dir.
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${source}\" \"${DERIVED_FILES_DIR}\""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${source}" "${DERIVED_FILES_DIR}"
local basename
basename="$(basename -s .dSYM "$source")"
binary_name="$(ls "$source/Contents/Resources/DWARF")"
binary="${DERIVED_FILES_DIR}/${basename}.dSYM/Contents/Resources/DWARF/${binary_name}"
# Strip invalid architectures from the dSYM.
if [[ "$(file "$binary")" == *"Mach-O "*"dSYM companion"* ]]; then
strip_invalid_archs "$binary" "$warn_missing_arch"
fi
if [[ $STRIP_BINARY_RETVAL == 0 ]]; then
# Move the stripped file into its final destination.
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${DERIVED_FILES_DIR}/${basename}.framework.dSYM\" \"${DWARF_DSYM_FOLDER_PATH}\""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${DERIVED_FILES_DIR}/${basename}.dSYM" "${DWARF_DSYM_FOLDER_PATH}"
else
# The dSYM was not stripped at all, in this case touch a fake folder so the input/output paths from Xcode do not reexecute this script because the file is missing.
mkdir -p "${DWARF_DSYM_FOLDER_PATH}"
touch "${DWARF_DSYM_FOLDER_PATH}/${basename}.dSYM"
fi
fi
}
# Used as a return value for each invocation of `strip_invalid_archs` function.
STRIP_BINARY_RETVAL=0
# Strip invalid architectures
strip_invalid_archs() {
binary="$1"
warn_missing_arch=${2:-true}
# Get architectures for current target binary
binary_archs="$(lipo -info "$binary" | rev | cut -d ':' -f1 | awk '{$1=$1;print}' | rev)"
# Intersect them with the architectures we are building for
intersected_archs="$(echo ${ARCHS[@]} ${binary_archs[@]} | tr ' ' '\n' | sort | uniq -d)"
# If there are no archs supported by this binary then warn the user
if [[ -z "$intersected_archs" ]]; then
if [[ "$warn_missing_arch" == "true" ]]; then
echo "warning: [CP] Vendored binary '$binary' contains architectures ($binary_archs) none of which match the current build architectures ($ARCHS)."
fi
STRIP_BINARY_RETVAL=1
return
fi
stripped=""
for arch in $binary_archs; do
if ! [[ "${ARCHS}" == *"$arch"* ]]; then
# Strip non-valid architectures in-place
lipo -remove "$arch" -output "$binary" "$binary"
stripped="$stripped $arch"
fi
done
if [[ "$stripped" ]]; then
echo "Stripped $binary of architectures:$stripped"
fi
STRIP_BINARY_RETVAL=0
}
# Copies the bcsymbolmap files of a vendored framework
install_bcsymbolmap() {
local bcsymbolmap_path="$1"
local destination="${BUILT_PRODUCTS_DIR}"
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${bcsymbolmap_path}" "${destination}""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${bcsymbolmap_path}" "${destination}"
}
# Signs a framework with the provided identity
code_sign_if_enabled() {
if [ -n "${EXPANDED_CODE_SIGN_IDENTITY:-}" -a "${CODE_SIGNING_REQUIRED:-}" != "NO" -a "${CODE_SIGNING_ALLOWED}" != "NO" ]; then
# Use the current code_sign_identity
echo "Code Signing $1 with Identity ${EXPANDED_CODE_SIGN_IDENTITY_NAME}"
local code_sign_cmd="/usr/bin/codesign --force --sign ${EXPANDED_CODE_SIGN_IDENTITY} ${OTHER_CODE_SIGN_FLAGS:-} --preserve-metadata=identifier,entitlements '$1'"
if [ "${COCOAPODS_PARALLEL_CODE_SIGN}" == "true" ]; then
code_sign_cmd="$code_sign_cmd &"
fi
echo "$code_sign_cmd"
eval "$code_sign_cmd"
fi
}
if [[ "$CONFIGURATION" == "Debug" ]]; then
install_framework "${BUILT_PRODUCTS_DIR}/Reusable-iOS/Reusable.framework"
fi
if [[ "$CONFIGURATION" == "Release" ]]; then
install_framework "${BUILT_PRODUCTS_DIR}/Reusable-iOS/Reusable.framework"
fi
if [ "${COCOAPODS_PARALLEL_CODE_SIGN}" == "true" ]; then
wait
fi
``` | /content/code_sandbox/Example/Pods/Target Support Files/Pods-ReusableDemo iOS/Pods-ReusableDemo iOS-frameworks.sh | shell | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 2,344 |
```swift
//
// AppDelegate.swift
// ReusableDemo
//
// Created by Olivier Halligon on 19/01/2016.
//
import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
func application(_ application: UIApplication,
didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
// Override point for customization after application launch.
return true
}
}
// Swift < 4.2 support
#if !(swift(>=4.2))
extension UIApplication {
typealias LaunchOptionsKey = UIApplicationLaunchOptionsKey
}
#endif
``` | /content/code_sandbox/Example/ReusableDemo iOS/AppDelegate.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 132 |
```swift
//
// CollectionViewController.swift
// ReusableDemo
//
// Created by Olivier Halligon on 19/01/2016.
//
import UIKit
final class CollectionViewController: UICollectionViewController {
override func viewDidLoad() {
super.viewDidLoad()
guard let collectionView = self.collectionView else { return }
// Register cell classes
collectionView.register(cellType: MyColorSquareCell.self)
collectionView.register(cellType: MyXIBIndexSquaceCell.self)
// No need to register this one, the UIStoryboard already auto-register its cells
// self.collectionView.registerReusableCell(MyStoryBoardIndexPathCell)
collectionView.register(supplementaryViewType: CollectionHeaderView.self,
ofKind: UICollectionView.elementKindSectionHeader)
if let flowLayout = self.collectionView?.collectionViewLayout as? UICollectionViewFlowLayout {
flowLayout.headerReferenceSize = CGSize(width: collectionView.bounds.size.width, height: 60)
}
}
// MARK: UICollectionViewDataSource
override func numberOfSections(in collectionView: UICollectionView) -> Int {
return 3
}
override func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
return 5
}
override func collectionView(_ collectionView: UICollectionView,
viewForSupplementaryElementOfKind kind: String,
at indexPath: IndexPath) -> UICollectionReusableView {
let header = collectionView.dequeueReusableSupplementaryView(ofKind: kind, for: indexPath) as CollectionHeaderView
header.title = "Section \(indexPath.section)"
return header
}
override func collectionView(_ collectionView: UICollectionView,
cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
switch indexPath.section {
case 0:
let cell = collectionView.dequeueReusableCell(for: indexPath) as MyColorSquareCell
let red = CGFloat(indexPath.row) / CGFloat(collectionView.numberOfItems(inSection: indexPath.section))
cell.fill(UIColor(red: red, green: 0.0, blue: 1.0-red, alpha: 1.0))
return cell
case 1:
let cell = collectionView.dequeueReusableCell(for: indexPath) as MyStoryboardTextSquareCell
cell.fill("Item #\(indexPath.row)")
return cell
case 2:
let cell = collectionView.dequeueReusableCell(for: indexPath) as MyXIBIndexSquaceCell
cell.fill(indexPath)
return cell
default:
fatalError("Out of bounds, should not happen")
}
}
}
// Swift < 4.2 support
#if !(swift(>=4.2))
private extension UICollectionView {
static let elementKindSectionHeader = UICollectionElementKindSectionHeader
}
#endif
``` | /content/code_sandbox/Example/ReusableDemo iOS/CollectionViewController.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 548 |
```swift
//
// ViewController.swift
// ReusableDemo
//
// Created by Olivier Halligon on 19/01/2016.
//
import UIKit
final class TableViewController: UITableViewController {
var boolValues = [false, false]
override func viewDidLoad() {
super.viewDidLoad()
tableView.register(cellType: MySimpleColorCell.self)
tableView.register(cellType: MyXIBTextCell.self)
tableView.register(cellType: MyXIBInfoCell.self)
/* No need to register this one, the UIStoryboard already auto-register its cells */
// tableView.registerReusableCell(MyStoryBoardIndexPathCell)
}
override func tableView(_ tableView: UITableView, heightForHeaderInSection section: Int) -> CGFloat {
return MyHeaderTableView.height
}
override func tableView(_ tableView: UITableView, viewForHeaderInSection section: Int) -> UIView? {
let frame = CGRect(
x: 0,
y: 0,
width: tableView.bounds.size.width,
height: self.tableView(tableView, heightForHeaderInSection: section)
)
// See the overridden `MyHeaderTableView.init(frame:)` initializer, which
// automatically loads the view content from its nib using loadNibContent()
let view = MyHeaderTableView(frame: frame)
view.fillForSection(section)
return view
}
override func numberOfSections(in tableView: UITableView) -> Int {
return 4
}
override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return 2
}
override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
switch indexPath.section {
case 0:
let colorCell = tableView.dequeueReusableCell(for: indexPath) as MySimpleColorCell
let redComp: CGFloat = indexPath.row == 0 ? 1.0 : 0.0
colorCell.fill(UIColor(red: redComp, green: 0.0, blue: 1-redComp, alpha: 1.0))
return colorCell
case 1:
let textCell = tableView.dequeueReusableCell(for: indexPath) as MyXIBTextCell
textCell.fill("{section \(indexPath.section), row \(indexPath.row)}")
return textCell
case 2:
let infoCell = tableView.dequeueReusableCell(for: indexPath) as MyXIBInfoCell
infoCell.fill("InfoCell #\(indexPath.row)", info: "Info #\(indexPath.row)", details: "Details #\(indexPath.row)")
return infoCell
case 3:
let pathCell = tableView.dequeueReusableCell(for: indexPath) as MyStoryBoardIndexPathCell
pathCell.fill(indexPath)
return pathCell
default:
fatalError("Out of bounds, should not happen")
}
}
}
``` | /content/code_sandbox/Example/ReusableDemo iOS/TableViewController.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 576 |
```swift
//
// MyCustomWidget.swift
// ReusableDemo
//
// Created by Olivier HALLIGON on 18/08/2016.
//
import UIKit
import Reusable
class MyCustomWidget: UIView, NibOwnerLoadable {
@IBInspectable var rectColor: UIColor? {
didSet {
self.rectView.backgroundColor = self.rectColor
}
}
@IBInspectable var text: String? {
didSet {
self.textLabel.text = self.text
}
}
@IBOutlet private var rectView: UIView!
@IBOutlet private var textLabel: UILabel!
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
self.loadNibContent()
}
}
``` | /content/code_sandbox/Example/ReusableDemo iOS/CustomViews/MyCustomWidget.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 154 |
```swift
//
// InfoDetailViewController.swift
// ReusableDemo
//
// Created by Olivier Halligon on 10/07/2016.
//
import UIKit
import Reusable
final class InfoDetailViewController: UIViewController, StoryboardSceneBased {
static let sceneStoryboard = UIStoryboard(name: "InfoViewController", bundle: nil)
@IBOutlet private weak var detailsLabel: UILabel!
private var detailsText: String?
func setDetails(_ text: String) {
detailsText = text
detailsLabel?.text = text
}
override func viewDidLoad() {
super.viewDidLoad()
detailsLabel.text = detailsText
}
@IBAction func closeAction(_ sender: UIButton) {
self.presentingViewController?.dismiss(animated: true, completion: nil)
}
}
``` | /content/code_sandbox/Example/ReusableDemo iOS/Storyboards/InfoDetailViewController.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 165 |
```swift
//
// InfoViewController.swift
// ReusableDemo
//
// Created by Olivier Halligon on 10/07/2016.
//
import UIKit
import Reusable
final class InfoViewController: UIViewController, StoryboardBased {
@IBOutlet private weak var infoLabel: UILabel!
private var infoText: String?
func setInfo(_ text: String) {
infoText = text
infoLabel?.text = text
}
override func viewDidLoad() {
super.viewDidLoad()
infoLabel.text = infoText
}
@IBAction func closeAction(_ sender: UIButton) {
self.presentingViewController?.dismiss(animated: true, completion: nil)
}
}
``` | /content/code_sandbox/Example/ReusableDemo iOS/Storyboards/InfoViewController.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 145 |
```swift
//
// CollectionHeaderView.swift
// ReusableDemo
//
// Created by Olivier Halligon on 20/01/2016.
//
import UIKit
import Reusable
/**
* This view is loaded from a NIB, and is the XIB file's
* root view (and not the File's Owner). => it is `NibLoadable`
*
* It is also reusable and has a `reuseIdentifier` (as it's a CollectionViewCell
* and it uses the CollectionView recycling mechanism) => it is `Reusable`
*
* That's why it's annotated with the `NibReusable` protocol,
* Which in fact is just a convenience typealias that combines
* `NibLoadable` & `Reusable` protocols.
*/
final class CollectionHeaderView: UICollectionReusableView, NibReusable {
@IBOutlet private weak var titleLabel: UILabel! {
didSet { update() }
}
var title: String? {
didSet { update() }
}
private func update() {
titleLabel?.text = title
}
}
``` | /content/code_sandbox/Example/ReusableDemo iOS/CollectionViewCells/CollectionHeaderView.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 221 |
```swift
//
// MyColorSquareCell.swift
// ReusableDemo
//
// Created by Olivier Halligon on 19/01/2016.
//
import UIKit
import Reusable
/**
* This view is reusable and has a `reuseIdentifier` (as it's a CollectionViewCell
* and it uses the Collectioniew recycling mechanism).
*
* That's why it's annotated with the `Reusable` protocol.
*
* This view is NOT loaded from a NIB (but defined entierly by code),
* that's why it's not annotated as `NibLoadable` but only `Reusable`
*/
final class MyColorSquareCell: UICollectionViewCell, Reusable {
private lazy var colorView: UIView = {
let colorView = UIView()
colorView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
colorView.frame = self.contentView.bounds.insetBy(dx: 10, dy: 10)
self.contentView.addSubview(colorView)
return colorView
}()
func fill(_ color: UIColor) {
self.colorView.backgroundColor = color
}
}
``` | /content/code_sandbox/Example/ReusableDemo iOS/CollectionViewCells/MyColorSquareCell.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 230 |
```swift
//
// MyStoryboardTextSquareCell.swift
// ReusableDemo
//
// Created by Olivier Halligon on 19/01/2016.
//
import UIKit
import Reusable
/**
* This one can be either `NibReusable` or just `Reusable` it doesn't really matter,
* as we will never have to explicitly call `collectionView.register()` to register it:
* The `Main.storyboard` already auto-registers its cells without the need for additional code
*
* The only difference in marking a view `NibReusable` vs. `Reusable` is the way
* `registerCell` is implemented, and as we won't need to call that method anyway
* because the storyboard will register the cell for us, this makes no difference here.
*/
final class MyStoryboardTextSquareCell: UICollectionViewCell, Reusable {
@IBOutlet private weak var titleLabel: UILabel!
func fill(_ text: String) {
titleLabel.text = text
}
}
``` | /content/code_sandbox/Example/ReusableDemo iOS/CollectionViewCells/MyStoryboardTextSquareCell.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 202 |
```swift
//
// MyXIBIndexSquaceCell.swift
// ReusableDemo
//
// Created by Olivier Halligon on 19/01/2016.
//
import UIKit
import Reusable
/**
* This view is loaded from a NIB, and is the XIB file's
* root view (and not the File's Owner). => it is `NibLoadable`
*
* It is also reusable and has a `reuseIdentifier` (as it's a CollectionViewCell
* and it uses the CollectionView recycling mechanism) => it is `Reusable`
*
* That's why it's annotated with the `NibReusable` protocol,
* Which in fact is just a typealias that combines
* `NibLoadable` & `Reusable` protocols.
*/
final class MyXIBIndexSquaceCell: UICollectionViewCell, NibReusable {
@IBOutlet private weak var sectionLabel: UILabel!
@IBOutlet private weak var rowLabel: UILabel!
func fill(_ indexPath: IndexPath) {
sectionLabel.text = String(indexPath.section)
rowLabel.text = String(indexPath.row)
}
}
``` | /content/code_sandbox/Example/ReusableDemo iOS/CollectionViewCells/MyXIBIndexSquaceCell.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 230 |
```swift
//
// MyXIBSwitchCell.swift
// ReusableDemo
//
// Created by Olivier Halligon on 19/01/2016.
//
import UIKit
import Reusable
/**
* This view is loaded from a NIB, and is the XIB file's
* root view (and not the File's Owner). => it is `NibLoadable`
*
* It is also reusable and has a `reuseIdentifier` (as it's a TableViewCell
* and it uses the TableView recycling mechanism) => it is `Reusable`
*
* That's why it's annotated with the `NibReusable` typealias,
* Which in fact is just a convenience typealias that combines
* `NibLoadable` & `Reusable` protocols.
*/
final class MyXIBInfoCell: UITableViewCell, NibReusable {
@IBOutlet private weak var titleLabel: UILabel!
private var info: String = "<Info?>"
private var details: String = "<Details?>"
func fill(_ title: String, info: String, details: String) {
self.titleLabel.text = title
self.info = info
self.details = details
}
@IBAction func infoAction(_ sender: UIButton) {
let infoVC = InfoViewController.instantiate()
infoVC.setInfo(self.info)
self.window?.rootViewController?.present(infoVC, animated: true, completion: nil)
}
@IBAction func detailsAction(_ sender: UIButton) {
let detailsVC = InfoDetailViewController.instantiate()
detailsVC.setDetails(self.details)
self.window?.rootViewController?.present(detailsVC, animated: true, completion: nil)
}
}
``` | /content/code_sandbox/Example/ReusableDemo iOS/TableViewCells/MyXIBInfoCell.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 345 |
```swift
//
// MySimpleColorCell.swift
// ReusableDemo
//
// Created by Olivier Halligon on 19/01/2016.
//
import UIKit
import Reusable
/**
* This view is reusable and has a `reuseIdentifier` (as it's a TableViewCell
* and it uses the TableView recycling mechanism).
*
* That's why it's annotated with the `Reusable` protocol.
*
* This view is NOT loaded from a NIB (but defined entierly by code),
* that's why it's not annotated as `NibLoadable` but only `Reusable`
*/
final class MySimpleColorCell: UITableViewCell, Reusable {
private lazy var colorView: UIView = {
let colorView = UIView()
colorView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
colorView.frame = self.contentView.bounds.insetBy(dx: 50, dy: 5)
self.contentView.addSubview(colorView)
return colorView
}()
func fill(_ color: UIColor) {
self.colorView.backgroundColor = color
}
}
``` | /content/code_sandbox/Example/ReusableDemo iOS/TableViewCells/MySimpleColorCell.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 228 |
```swift
//
// MyXIBTextCell.swift
// ReusableDemo
//
// Created by Olivier Halligon on 19/01/2016.
//
import UIKit
import Reusable
/**
* This view is loaded from a NIB, and is the XIB file's
* root view (and not the File's Owner). => it is `NibLoadable`
*
* It is also reusable and has a `reuseIdentifier` (as it's a TableViewCell
* and it uses the TableView recycling mechanism) => it is `Reusable`
*
* That's why it's annotated with the `NibReusable` typealias,
* Which in fact is just a convenience typealias that combines
* `NibLoadable` & `Reusable` protocols.
*/
final class MyXIBTextCell: UITableViewCell, NibReusable {
@IBOutlet private weak var titleLabel: UILabel!
func fill(_ text: String) {
titleLabel.text = text
}
}
``` | /content/code_sandbox/Example/ReusableDemo iOS/TableViewCells/MyXIBTextCell.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 199 |
```swift
//
// MyStoryBoardIndexPathCell.swift
// ReusableDemo
//
// Created by Olivier Halligon on 19/01/2016.
//
import UIKit
import Reusable
// This one can be either `NibReusable` or just `Reusable` it doesn't matter actually
// As we will never have to explicitly call `tableView.register()` to register it:
// The Main.storyboard already auto-registers its cells without the need for additional code
final class MyStoryBoardIndexPathCell: UITableViewCell, Reusable {
@IBOutlet private weak var sectionLabel: UILabel!
@IBOutlet private weak var rowLabel: UILabel!
func fill(_ indexPath: IndexPath) {
sectionLabel.text = String(indexPath.section)
rowLabel.text = String(indexPath.row)
}
}
``` | /content/code_sandbox/Example/ReusableDemo iOS/TableViewCells/MyStoryBoardIndexPathCell.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 163 |
```swift
//
// MyHeaderTableViex.swift
// ReusableDemo
//
// Created by Allan Vialatte on 29/05/16.
//
import UIKit
import Reusable
/**
* This view is loaded from a NIB, and is used as the File's Owner
* of the XIB file (and not set as the XIB's root view)
*
* That's why it's annotated with the `NibOwnerLoadable` protocol.
*/
final class MyHeaderTableView: UIView, NibOwnerLoadable {
@IBOutlet private weak var titleLabel: UILabel!
static let height: CGFloat = 55
override init(frame: CGRect) {
super.init(frame: frame)
self.loadNibContent()
}
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
}
func fillForSection(_ section: Int) {
self.titleLabel.text = "Header Section #\(section)"
}
}
``` | /content/code_sandbox/Example/ReusableDemo iOS/TableViewCells/MyHeaderTableView.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 201 |
```swift
//
// AppDelegate.swift
// ReusableDemo tvOS
//
// Created by Olivier HALLIGON on 16/02/2017.
//
import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
func application(_ application: UIApplication,
didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
// Override point for customization after application launch.
return true
}
}
// Swift < 4.2 support
#if !(swift(>=4.2))
extension UIApplication {
typealias LaunchOptionsKey = UIApplicationLaunchOptionsKey
}
#endif
``` | /content/code_sandbox/Example/ReusableDemo tvOS/AppDelegate.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 136 |
```swift
//
// MyCustomWidget.swift
// ReusableDemo
//
// Created by Olivier HALLIGON on 16/02/2017.
//
import UIKit
import Reusable
class MyCustomWidget: UIView, NibOwnerLoadable {
@IBInspectable var rectColor: UIColor? {
didSet {
self.rectView.backgroundColor = self.rectColor
}
}
@IBInspectable var text: String? {
didSet {
self.textLabel.text = self.text
}
}
@IBOutlet private var rectView: UIView!
@IBOutlet private var textLabel: UILabel!
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
self.loadNibContent()
}
}
``` | /content/code_sandbox/Example/ReusableDemo tvOS/MyCustomWidget.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 154 |
```swift
/*********************************************
*
*
*
*********************************************/
#if canImport(UIKit)
import UIKit
// MARK: Reusable support for UITableView
public extension UITableView {
/**
Register a NIB-Based `UITableViewCell` subclass (conforming to `Reusable` & `NibLoadable`)
- parameter cellType: the `UITableViewCell` (`Reusable` & `NibLoadable`-conforming) subclass to register
- seealso: `register(_:,forCellReuseIdentifier:)`
*/
final func register<T: UITableViewCell>(cellType: T.Type)
where T: Reusable & NibLoadable {
self.register(cellType.nib, forCellReuseIdentifier: cellType.reuseIdentifier)
}
/**
Register a Class-Based `UITableViewCell` subclass (conforming to `Reusable`)
- parameter cellType: the `UITableViewCell` (`Reusable`-conforming) subclass to register
- seealso: `register(_:,forCellReuseIdentifier:)`
*/
final func register<T: UITableViewCell>(cellType: T.Type)
where T: Reusable {
self.register(cellType.self, forCellReuseIdentifier: cellType.reuseIdentifier)
}
/**
Returns a reusable `UITableViewCell` object for the class inferred by the return-type
- parameter indexPath: The index path specifying the location of the cell.
- parameter cellType: The cell class to dequeue
- returns: A `Reusable`, `UITableViewCell` instance
- note: The `cellType` parameter can generally be omitted and infered by the return type,
except when your type is in a variable and cannot be determined at compile time.
- seealso: `dequeueReusableCell(withIdentifier:,for:)`
*/
final func dequeueReusableCell<T: UITableViewCell>(for indexPath: IndexPath, cellType: T.Type = T.self) -> T
where T: Reusable {
guard let cell = self.dequeueReusableCell(withIdentifier: cellType.reuseIdentifier, for: indexPath) as? T else {
fatalError(
"Failed to dequeue a cell with identifier \(cellType.reuseIdentifier) matching type \(cellType.self). "
+ "Check that the reuseIdentifier is set properly in your XIB/Storyboard "
+ "and that you registered the cell beforehand"
)
}
return cell
}
/**
Register a NIB-Based `UITableViewHeaderFooterView` subclass (conforming to `Reusable` & `NibLoadable`)
- parameter headerFooterViewType: the `UITableViewHeaderFooterView` (`Reusable` & `NibLoadable`-conforming)
subclass to register
- seealso: `register(_:,forHeaderFooterViewReuseIdentifier:)`
*/
final func register<T: UITableViewHeaderFooterView>(headerFooterViewType: T.Type)
where T: Reusable & NibLoadable {
self.register(headerFooterViewType.nib, forHeaderFooterViewReuseIdentifier: headerFooterViewType.reuseIdentifier)
}
/**
Register a Class-Based `UITableViewHeaderFooterView` subclass (conforming to `Reusable`)
- parameter headerFooterViewType: the `UITableViewHeaderFooterView` (`Reusable`-confirming) subclass to register
- seealso: `register(_:,forHeaderFooterViewReuseIdentifier:)`
*/
final func register<T: UITableViewHeaderFooterView>(headerFooterViewType: T.Type)
where T: Reusable {
self.register(headerFooterViewType.self, forHeaderFooterViewReuseIdentifier: headerFooterViewType.reuseIdentifier)
}
/**
Returns a reusable `UITableViewHeaderFooterView` object for the class inferred by the return-type
- parameter viewType: The view class to dequeue
- returns: A `Reusable`, `UITableViewHeaderFooterView` instance
- note: The `viewType` parameter can generally be omitted and infered by the return type,
except when your type is in a variable and cannot be determined at compile time.
- seealso: `dequeueReusableHeaderFooterView(withIdentifier:)`
*/
final func dequeueReusableHeaderFooterView<T: UITableViewHeaderFooterView>(_ viewType: T.Type = T.self) -> T?
where T: Reusable {
guard let view = self.dequeueReusableHeaderFooterView(withIdentifier: viewType.reuseIdentifier) as? T? else {
fatalError(
"Failed to dequeue a header/footer with identifier \(viewType.reuseIdentifier) "
+ "matching type \(viewType.self). "
+ "Check that the reuseIdentifier is set properly in your XIB/Storyboard "
+ "and that you registered the header/footer beforehand"
)
}
return view
}
}
#endif
``` | /content/code_sandbox/Sources/View/UITableView+Reusable.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 961 |
```swift
/*********************************************
*
*
*
*********************************************/
#if canImport(UIKit)
import UIKit
// MARK: Protocol definition
/// Make your `UITableViewCell` and `UICollectionViewCell` subclasses
/// conform to this protocol when they are *not* NIB-based but only code-based
/// to be able to dequeue them in a type-safe manner
public protocol Reusable: AnyObject {
/// The reuse identifier to use when registering and later dequeuing a reusable cell
static var reuseIdentifier: String { get }
}
/// Make your `UITableViewCell` and `UICollectionViewCell` subclasses
/// conform to this typealias when they *are* NIB-based
/// to be able to dequeue them in a type-safe manner
public typealias NibReusable = Reusable & NibLoadable
// MARK: - Default implementation
public extension Reusable {
/// By default, use the name of the class as String for its reuseIdentifier
static var reuseIdentifier: String {
return String(describing: self)
}
}
#endif
``` | /content/code_sandbox/Sources/View/Reusable.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 205 |
```swift
/*********************************************
*
*
*
*********************************************/
#if canImport(UIKit)
import UIKit
// MARK: Reusable support for UICollectionView
public extension UICollectionView {
/**
Register a NIB-Based `UICollectionViewCell` subclass (conforming to `Reusable` & `NibLoadable`)
- parameter cellType: the `UICollectionViewCell` (`Reusable` & `NibLoadable`-conforming) subclass to register
- seealso: `register(_:,forCellWithReuseIdentifier:)`
*/
final func register<T: UICollectionViewCell>(cellType: T.Type)
where T: Reusable & NibLoadable {
self.register(cellType.nib, forCellWithReuseIdentifier: cellType.reuseIdentifier)
}
/**
Register a Class-Based `UICollectionViewCell` subclass (conforming to `Reusable`)
- parameter cellType: the `UICollectionViewCell` (`Reusable`-conforming) subclass to register
- seealso: `register(_:,forCellWithReuseIdentifier:)`
*/
final func register<T: UICollectionViewCell>(cellType: T.Type)
where T: Reusable {
self.register(cellType.self, forCellWithReuseIdentifier: cellType.reuseIdentifier)
}
/**
Returns a reusable `UICollectionViewCell` object for the class inferred by the return-type
- parameter indexPath: The index path specifying the location of the cell.
- parameter cellType: The cell class to dequeue
- returns: A `Reusable`, `UICollectionViewCell` instance
- note: The `cellType` parameter can generally be omitted and infered by the return type,
except when your type is in a variable and cannot be determined at compile time.
- seealso: `dequeueReusableCell(withReuseIdentifier:,for:)`
*/
final func dequeueReusableCell<T: UICollectionViewCell>(for indexPath: IndexPath, cellType: T.Type = T.self) -> T
where T: Reusable {
let bareCell = self.dequeueReusableCell(withReuseIdentifier: cellType.reuseIdentifier, for: indexPath)
guard let cell = bareCell as? T else {
fatalError(
"Failed to dequeue a cell with identifier \(cellType.reuseIdentifier) matching type \(cellType.self). "
+ "Check that the reuseIdentifier is set properly in your XIB/Storyboard "
+ "and that you registered the cell beforehand"
)
}
return cell
}
/**
Register a NIB-Based `UICollectionReusableView` subclass (conforming to `Reusable` & `NibLoadable`)
as a Supplementary View
- parameter supplementaryViewType: the `UIView` (`Reusable` & `NibLoadable`-conforming) subclass
to register as Supplementary View
- parameter elementKind: The kind of supplementary view to create.
- seealso: `register(_:,forSupplementaryViewOfKind:,withReuseIdentifier:)`
*/
final func register<T: UICollectionReusableView>(supplementaryViewType: T.Type, ofKind elementKind: String)
where T: Reusable & NibLoadable {
self.register(
supplementaryViewType.nib,
forSupplementaryViewOfKind: elementKind,
withReuseIdentifier: supplementaryViewType.reuseIdentifier
)
}
/**
Register a Class-Based `UICollectionReusableView` subclass (conforming to `Reusable`) as a Supplementary View
- parameter supplementaryViewType: the `UIView` (`Reusable`-conforming) subclass to register as Supplementary View
- parameter elementKind: The kind of supplementary view to create.
- seealso: `register(_:,forSupplementaryViewOfKind:,withReuseIdentifier:)`
*/
final func register<T: UICollectionReusableView>(supplementaryViewType: T.Type, ofKind elementKind: String)
where T: Reusable {
self.register(
supplementaryViewType.self,
forSupplementaryViewOfKind: elementKind,
withReuseIdentifier: supplementaryViewType.reuseIdentifier
)
}
/**
Returns a reusable `UICollectionReusableView` object for the class inferred by the return-type
- parameter elementKind: The kind of supplementary view to retrieve.
- parameter indexPath: The index path specifying the location of the cell.
- parameter viewType: The view class to dequeue
- returns: A `Reusable`, `UICollectionReusableView` instance
- note: The `viewType` parameter can generally be omitted and infered by the return type,
except when your type is in a variable and cannot be determined at compile time.
- seealso: `dequeueReusableSupplementaryView(ofKind:,withReuseIdentifier:,for:)`
*/
final func dequeueReusableSupplementaryView<T: UICollectionReusableView>
(ofKind elementKind: String, for indexPath: IndexPath, viewType: T.Type = T.self) -> T
where T: Reusable {
let view = self.dequeueReusableSupplementaryView(
ofKind: elementKind,
withReuseIdentifier: viewType.reuseIdentifier,
for: indexPath
)
guard let typedView = view as? T else {
fatalError(
"Failed to dequeue a supplementary view with identifier \(viewType.reuseIdentifier) "
+ "matching type \(viewType.self). "
+ "Check that the reuseIdentifier is set properly in your XIB/Storyboard "
+ "and that you registered the supplementary view beforehand"
)
}
return typedView
}
}
#endif
``` | /content/code_sandbox/Sources/View/UICollectionView+Reusable.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 1,142 |
```swift
/*********************************************
*
*
*
*********************************************/
#if canImport(UIKit)
import UIKit
// MARK: Protocol Definition
///Make your UIView subclasses conform to this protocol when:
/// * they *are* NIB-based, and
/// * this class is used as the XIB's root view
///
/// to be able to instantiate them from the NIB in a type-safe manner
public protocol NibLoadable: AnyObject {
/// The nib file to use to load a new instance of the View designed in a XIB
static var nib: UINib { get }
}
// MARK: Default implementation
public extension NibLoadable {
/// By default, use the nib which have the same name as the name of the class,
/// and located in the bundle of that class
static var nib: UINib {
return UINib(nibName: String(describing: self), bundle: Bundle(for: self))
}
}
// MARK: Support for instantiation from NIB
public extension NibLoadable where Self: UIView {
/**
Returns a `UIView` object instantiated from nib
- returns: A `NibLoadable`, `UIView` instance
*/
static func loadFromNib() -> Self {
guard let view = nib.instantiate(withOwner: nil, options: nil).first as? Self else {
fatalError("The nib \(nib) expected its root view to be of type \(self)")
}
return view
}
}
#endif
``` | /content/code_sandbox/Sources/View/NibLoadable.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 313 |
```swift
/*********************************************
*
*
*
*********************************************/
#if canImport(UIKit)
import UIKit
// MARK: Protocol Definition
///Make your UIView subclasses conform to this protocol when:
/// * they *are* NIB-based, and
/// * this class is used as the XIB's File's Owner
///
/// to be able to instantiate them from the NIB in a type-safe manner
public protocol NibOwnerLoadable: AnyObject {
/// The nib file to use to load a new instance of the View designed in a XIB
static var nib: UINib { get }
}
// MARK: Default implementation
public extension NibOwnerLoadable {
/// By default, use the nib which have the same name as the name of the class,
/// and located in the bundle of that class
static var nib: UINib {
return UINib(nibName: String(describing: self), bundle: Bundle(for: self))
}
}
// MARK: Support for instantiation from NIB
public extension NibOwnerLoadable where Self: UIView {
/**
Adds content loaded from the nib to the end of the receiver's list of subviews and adds constraints automatically.
*/
func loadNibContent() {
let layoutAttributes: [NSLayoutConstraint.Attribute] = [.top, .leading, .bottom, .trailing]
for case let view as UIView in type(of: self).nib.instantiate(withOwner: self, options: nil) {
view.translatesAutoresizingMaskIntoConstraints = false
self.addSubview(view)
NSLayoutConstraint.activate(layoutAttributes.map { attribute in
NSLayoutConstraint(
item: view, attribute: attribute,
relatedBy: .equal,
toItem: self, attribute: attribute,
multiplier: 1, constant: 0.0
)
})
}
}
}
#endif
/// Swift < 4.2 support
#if !(swift(>=4.2))
private extension NSLayoutConstraint {
typealias Attribute = NSLayoutAttribute
}
#endif
``` | /content/code_sandbox/Sources/View/NibOwnerLoadable.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 415 |
```swift
/*********************************************
*
*
*
*********************************************/
#if canImport(UIKit)
import UIKit
// MARK: Protocol Definition
///Make your UIViewController subclasses conform to this protocol when:
/// * they *are* Storyboard-based, and
/// * this ViewController is not the initialViewController of your Storyboard, but a different scene
///
/// to be able to instantiate them from the Storyboard in a type-safe manner.
///
/// You need to implement `sceneStoryboard` yourself to indicate the UIStoryboard this scene is from.
public protocol StoryboardSceneBased: AnyObject {
/// The UIStoryboard to use when we want to instantiate this ViewController
static var sceneStoryboard: UIStoryboard { get }
/// The scene identifier to use when we want to instantiate this ViewController from its associated Storyboard
static var sceneIdentifier: String { get }
}
// MARK: Default Implementation
public extension StoryboardSceneBased {
/// By default, use the `sceneIdentifier` with the same name as the class
static var sceneIdentifier: String {
return String(describing: self)
}
}
// MARK: Support for instantiation from Storyboard
public extension StoryboardSceneBased where Self: UIViewController {
/**
Create an instance of the ViewController from its associated Storyboard and the
Scene with identifier `sceneIdentifier`
- returns: instance of the conforming ViewController
*/
static func instantiate() -> Self {
let storyboard = Self.sceneStoryboard
let viewController = storyboard.instantiateViewController(withIdentifier: self.sceneIdentifier)
guard let typedViewController = viewController as? Self else {
fatalError("The viewController '\(self.sceneIdentifier)' of '\(storyboard)' is not of class '\(self)'")
}
return typedViewController
}
}
#endif
``` | /content/code_sandbox/Sources/Storyboard/StoryboardSceneBased.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 358 |
```swift
/*********************************************
*
*
*
*********************************************/
#if canImport(UIKit)
import UIKit
// MARK: Protocol Definition
///Make your UIViewController subclasses conform to this protocol when:
/// * they *are* Storyboard-based, and
/// * this ViewController is the initialViewController of your Storyboard
///
/// to be able to instantiate them from the Storyboard in a type-safe manner
public protocol StoryboardBased: AnyObject {
/// The UIStoryboard to use when we want to instantiate this ViewController
static var sceneStoryboard: UIStoryboard { get }
}
// MARK: Default Implementation
public extension StoryboardBased {
/// By default, use the storybaord with the same name as the class
static var sceneStoryboard: UIStoryboard {
return UIStoryboard(name: String(describing: self), bundle: Bundle(for: self))
}
}
// MARK: Support for instantiation from Storyboard
public extension StoryboardBased where Self: UIViewController {
/**
Create an instance of the ViewController from its associated Storyboard's initialViewController
- returns: instance of the conforming ViewController
*/
static func instantiate() -> Self {
let viewController = sceneStoryboard.instantiateInitialViewController()
guard let typedViewController = viewController as? Self else {
fatalError("The initialViewController of '\(sceneStoryboard)' is not of class '\(self)'")
}
return typedViewController
}
}
#endif
``` | /content/code_sandbox/Sources/Storyboard/StoryboardBased.swift | swift | 2016-01-19T19:49:55 | 2024-08-10T21:10:40 | Reusable | AliSoftware/Reusable | 2,999 | 286 |
```yaml
version: 2.0.1{build}
branches:
only:
- master
image:
- Visual Studio 2015
- Visual Studio 2017
configuration:
- Release
build:
parallel: true
project: MSVC\MyTinySTL_VS2015.sln
test_script:
- cmd: cd .\MSVC\x64\Release\
- cmd: MyTinySTL.exe
``` | /content/code_sandbox/appveyor.yml | yaml | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 98 |
```objective-c
#ifndef MYTINYSTL_HEAP_ALGO_H_
#define MYTINYSTL_HEAP_ALGO_H_
// heap : push_heap, pop_heap, sort_heap, make_heap
#include "iterator.h"
namespace mystl
{
/*****************************************************************************************/
// push_heap
// heap heap
/*****************************************************************************************/
template <class RandomIter, class Distance, class T>
void push_heap_aux(RandomIter first, Distance holeIndex, Distance topIndex, T value)
{
auto parent = (holeIndex - 1) / 2;
while (holeIndex > topIndex && *(first + parent) < value)
{
// operator< heap max-heap
*(first + holeIndex) = *(first + parent);
holeIndex = parent;
parent = (holeIndex - 1) / 2;
}
*(first + holeIndex) = value;
}
template <class RandomIter, class Distance>
void push_heap_d(RandomIter first, RandomIter last, Distance*)
{
mystl::push_heap_aux(first, (last - first) - 1, static_cast<Distance>(0), *(last - 1));
}
template <class RandomIter>
void push_heap(RandomIter first, RandomIter last)
{ //
mystl::push_heap_d(first, last, distance_type(first));
}
// comp
template <class RandomIter, class Distance, class T, class Compared>
void push_heap_aux(RandomIter first, Distance holeIndex, Distance topIndex, T value,
Compared comp)
{
auto parent = (holeIndex - 1) / 2;
while (holeIndex > topIndex && comp(*(first + parent), value))
{
*(first + holeIndex) = *(first + parent);
holeIndex = parent;
parent = (holeIndex - 1) / 2;
}
*(first + holeIndex) = value;
}
template <class RandomIter, class Compared, class Distance>
void push_heap_d(RandomIter first, RandomIter last, Distance*, Compared comp)
{
mystl::push_heap_aux(first, (last - first) - 1, static_cast<Distance>(0),
*(last - 1), comp);
}
template <class RandomIter, class Compared>
void push_heap(RandomIter first, RandomIter last, Compared comp)
{
mystl::push_heap_d(first, last, distance_type(first), comp);
}
/*****************************************************************************************/
// pop_heap
// heap heap heap
/*****************************************************************************************/
template <class RandomIter, class T, class Distance>
void adjust_heap(RandomIter first, Distance holeIndex, Distance len, T value)
{
// (percolate down)
auto topIndex = holeIndex;
auto rchild = 2 * holeIndex + 2;
while (rchild < len)
{
if (*(first + rchild) < *(first + rchild - 1))
--rchild;
*(first + holeIndex) = *(first + rchild);
holeIndex = rchild;
rchild = 2 * (rchild + 1);
}
if (rchild == len)
{ //
*(first + holeIndex) = *(first + (rchild - 1));
holeIndex = rchild - 1;
}
// (percolate up)
mystl::push_heap_aux(first, holeIndex, topIndex, value);
}
template <class RandomIter, class T, class Distance>
void pop_heap_aux(RandomIter first, RandomIter last, RandomIter result, T value,
Distance*)
{
// [first, last - 1) max-heap
*result = *first;
mystl::adjust_heap(first, static_cast<Distance>(0), last - first, value);
}
template <class RandomIter>
void pop_heap(RandomIter first, RandomIter last)
{
mystl::pop_heap_aux(first, last - 1, last - 1, *(last - 1), distance_type(first));
}
// comp
template <class RandomIter, class T, class Distance, class Compared>
void adjust_heap(RandomIter first, Distance holeIndex, Distance len, T value,
Compared comp)
{
// (percolate down)
auto topIndex = holeIndex;
auto rchild = 2 * holeIndex + 2;
while (rchild < len)
{
if (comp(*(first + rchild), *(first + rchild - 1))) --rchild;
*(first + holeIndex) = *(first + rchild);
holeIndex = rchild;
rchild = 2 * (rchild + 1);
}
if (rchild == len)
{
*(first + holeIndex) = *(first + (rchild - 1));
holeIndex = rchild - 1;
}
// (percolate up)
mystl::push_heap_aux(first, holeIndex, topIndex, value, comp);
}
template <class RandomIter, class T, class Distance, class Compared>
void pop_heap_aux(RandomIter first, RandomIter last, RandomIter result,
T value, Distance*, Compared comp)
{
*result = *first; //
mystl::adjust_heap(first, static_cast<Distance>(0), last - first, value, comp);
}
template <class RandomIter, class Compared>
void pop_heap(RandomIter first, RandomIter last, Compared comp)
{
mystl::pop_heap_aux(first, last - 1, last - 1, *(last - 1),
distance_type(first), comp);
}
/*****************************************************************************************/
// sort_heap
// heap pop_heap 1
/*****************************************************************************************/
template <class RandomIter>
void sort_heap(RandomIter first, RandomIter last)
{
// pop_heap
while (last - first > 1)
{
mystl::pop_heap(first, last--);
}
}
// comp
template <class RandomIter, class Compared>
void sort_heap(RandomIter first, RandomIter last, Compared comp)
{
while (last - first > 1)
{
mystl::pop_heap(first, last--, comp);
}
}
/*****************************************************************************************/
// make_heap
// heap heap
/*****************************************************************************************/
template <class RandomIter, class Distance>
void make_heap_aux(RandomIter first, RandomIter last, Distance*)
{
if (last - first < 2)
return;
auto len = last - first;
auto holeIndex = (len - 2) / 2;
while (true)
{
// holeIndex
mystl::adjust_heap(first, holeIndex, len, *(first + holeIndex));
if (holeIndex == 0)
return;
holeIndex--;
}
}
template <class RandomIter>
void make_heap(RandomIter first, RandomIter last)
{
mystl::make_heap_aux(first, last, distance_type(first));;
}
// comp
template <class RandomIter, class Distance, class Compared>
void make_heap_aux(RandomIter first, RandomIter last, Distance*, Compared comp)
{
if (last - first < 2)
return;
auto len = last - first;
auto holeIndex = (len - 2) / 2;
while (true)
{
// holeIndex
mystl::adjust_heap(first, holeIndex, len, *(first + holeIndex), comp);
if (holeIndex == 0)
return;
holeIndex--;
}
}
template <class RandomIter, class Compared>
void make_heap(RandomIter first, RandomIter last, Compared comp)
{
mystl::make_heap_aux(first, last, distance_type(first), comp);
}
} // namespace mystl
#endif // !MYTINYSTL_HEAP_ALGO_H_
``` | /content/code_sandbox/MyTinySTL/heap_algo.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 1,667 |
```objective-c
#ifndef MYTINYSTL_UTIL_H_
#define MYTINYSTL_UTIL_H_
// move, forward, swap pair
#include <cstddef>
#include "type_traits.h"
namespace mystl
{
// move
template <class T>
typename std::remove_reference<T>::type&& move(T&& arg) noexcept
{
return static_cast<typename std::remove_reference<T>::type&&>(arg);
}
// forward
template <class T>
T&& forward(typename std::remove_reference<T>::type& arg) noexcept
{
return static_cast<T&&>(arg);
}
template <class T>
T&& forward(typename std::remove_reference<T>::type&& arg) noexcept
{
static_assert(!std::is_lvalue_reference<T>::value, "bad forward");
return static_cast<T&&>(arg);
}
// swap
template <class Tp>
void swap(Tp& lhs, Tp& rhs)
{
auto tmp(mystl::move(lhs));
lhs = mystl::move(rhs);
rhs = mystl::move(tmp);
}
template <class ForwardIter1, class ForwardIter2>
ForwardIter2 swap_range(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2)
{
for (; first1 != last1; ++first1, (void) ++first2)
mystl::swap(*first1, *first2);
return first2;
}
template <class Tp, size_t N>
void swap(Tp(&a)[N], Tp(&b)[N])
{
mystl::swap_range(a, a + N, b);
}
// your_sha256_hash----------------------
// pair
// : pair
//
// first second
template <class Ty1, class Ty2>
struct pair
{
typedef Ty1 first_type;
typedef Ty2 second_type;
first_type first; //
second_type second; //
// default constructiable
template <class Other1 = Ty1, class Other2 = Ty2,
typename = typename std::enable_if<
std::is_default_constructible<Other1>::value &&
std::is_default_constructible<Other2>::value, void>::type>
constexpr pair()
: first(), second()
{
}
// implicit constructiable for this type
template <class U1 = Ty1, class U2 = Ty2,
typename std::enable_if<
std::is_copy_constructible<U1>::value &&
std::is_copy_constructible<U2>::value &&
std::is_convertible<const U1&, Ty1>::value &&
std::is_convertible<const U2&, Ty2>::value, int>::type = 0>
constexpr pair(const Ty1& a, const Ty2& b)
: first(a), second(b)
{
}
// explicit constructible for this type
template <class U1 = Ty1, class U2 = Ty2,
typename std::enable_if<
std::is_copy_constructible<U1>::value &&
std::is_copy_constructible<U2>::value &&
(!std::is_convertible<const U1&, Ty1>::value ||
!std::is_convertible<const U2&, Ty2>::value), int>::type = 0>
explicit constexpr pair(const Ty1& a, const Ty2& b)
: first(a), second(b)
{
}
pair(const pair& rhs) = default;
pair(pair&& rhs) = default;
// implicit constructiable for other type
template <class Other1, class Other2,
typename std::enable_if<
std::is_constructible<Ty1, Other1>::value &&
std::is_constructible<Ty2, Other2>::value &&
std::is_convertible<Other1&&, Ty1>::value &&
std::is_convertible<Other2&&, Ty2>::value, int>::type = 0>
constexpr pair(Other1&& a, Other2&& b)
: first(mystl::forward<Other1>(a)),
second(mystl::forward<Other2>(b))
{
}
// explicit constructiable for other type
template <class Other1, class Other2,
typename std::enable_if<
std::is_constructible<Ty1, Other1>::value &&
std::is_constructible<Ty2, Other2>::value &&
(!std::is_convertible<Other1, Ty1>::value ||
!std::is_convertible<Other2, Ty2>::value), int>::type = 0>
explicit constexpr pair(Other1&& a, Other2&& b)
: first(mystl::forward<Other1>(a)),
second(mystl::forward<Other2>(b))
{
}
// implicit constructiable for other pair
template <class Other1, class Other2,
typename std::enable_if<
std::is_constructible<Ty1, const Other1&>::value &&
std::is_constructible<Ty2, const Other2&>::value &&
std::is_convertible<const Other1&, Ty1>::value &&
std::is_convertible<const Other2&, Ty2>::value, int>::type = 0>
constexpr pair(const pair<Other1, Other2>& other)
: first(other.first),
second(other.second)
{
}
// explicit constructiable for other pair
template <class Other1, class Other2,
typename std::enable_if<
std::is_constructible<Ty1, const Other1&>::value &&
std::is_constructible<Ty2, const Other2&>::value &&
(!std::is_convertible<const Other1&, Ty1>::value ||
!std::is_convertible<const Other2&, Ty2>::value), int>::type = 0>
explicit constexpr pair(const pair<Other1, Other2>& other)
: first(other.first),
second(other.second)
{
}
// implicit constructiable for other pair
template <class Other1, class Other2,
typename std::enable_if<
std::is_constructible<Ty1, Other1>::value &&
std::is_constructible<Ty2, Other2>::value &&
std::is_convertible<Other1, Ty1>::value &&
std::is_convertible<Other2, Ty2>::value, int>::type = 0>
constexpr pair(pair<Other1, Other2>&& other)
: first(mystl::forward<Other1>(other.first)),
second(mystl::forward<Other2>(other.second))
{
}
// explicit constructiable for other pair
template <class Other1, class Other2,
typename std::enable_if<
std::is_constructible<Ty1, Other1>::value &&
std::is_constructible<Ty2, Other2>::value &&
(!std::is_convertible<Other1, Ty1>::value ||
!std::is_convertible<Other2, Ty2>::value), int>::type = 0>
explicit constexpr pair(pair<Other1, Other2>&& other)
: first(mystl::forward<Other1>(other.first)),
second(mystl::forward<Other2>(other.second))
{
}
// copy assign for this pair
pair& operator=(const pair& rhs)
{
if (this != &rhs)
{
first = rhs.first;
second = rhs.second;
}
return *this;
}
// move assign for this pair
pair& operator=(pair&& rhs)
{
if (this != &rhs)
{
first = mystl::move(rhs.first);
second = mystl::move(rhs.second);
}
return *this;
}
// copy assign for other pair
template <class Other1, class Other2>
pair& operator=(const pair<Other1, Other2>& other)
{
first = other.first;
second = other.second;
return *this;
}
// move assign for other pair
template <class Other1, class Other2>
pair& operator=(pair<Other1, Other2>&& other)
{
first = mystl::forward<Other1>(other.first);
second = mystl::forward<Other2>(other.second);
return *this;
}
~pair() = default;
void swap(pair& other)
{
if (this != &other)
{
mystl::swap(first, other.first);
mystl::swap(second, other.second);
}
}
};
//
template <class Ty1, class Ty2>
bool operator==(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)
{
return lhs.first == rhs.first && lhs.second == rhs.second;
}
template <class Ty1, class Ty2>
bool operator<(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)
{
return lhs.first < rhs.first || (lhs.first == rhs.first && lhs.second < rhs.second);
}
template <class Ty1, class Ty2>
bool operator!=(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)
{
return !(lhs == rhs);
}
template <class Ty1, class Ty2>
bool operator>(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)
{
return rhs < lhs;
}
template <class Ty1, class Ty2>
bool operator<=(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)
{
return !(rhs < lhs);
}
template <class Ty1, class Ty2>
bool operator>=(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)
{
return !(lhs < rhs);
}
// mystl swap
template <class Ty1, class Ty2>
void swap(pair<Ty1, Ty2>& lhs, pair<Ty1, Ty2>& rhs)
{
lhs.swap(rhs);
}
// pair
template <class Ty1, class Ty2>
pair<Ty1, Ty2> make_pair(Ty1&& first, Ty2&& second)
{
return pair<Ty1, Ty2>(mystl::forward<Ty1>(first), mystl::forward<Ty2>(second));
}
}
#endif // !MYTINYSTL_UTIL_H_
``` | /content/code_sandbox/MyTinySTL/util.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 2,278 |
```objective-c
#ifndef MYTINYSTL_MAP_H_
#define MYTINYSTL_MAP_H_
// map multimap
// map :
// multimap :
// notes:
//
//
// mystl::map<Key, T> / mystl::multimap<Key, T>
// * emplace
// * emplace_hint
// * insert
#include "rb_tree.h"
namespace mystl
{
// map
// mystl::less
template <class Key, class T, class Compare = mystl::less<Key>>
class map
{
public:
// map
typedef Key key_type;
typedef T mapped_type;
typedef mystl::pair<const Key, T> value_type;
typedef Compare key_compare;
// functor
class value_compare : public binary_function <value_type, value_type, bool>
{
friend class map<Key, T, Compare>;
private:
Compare comp;
value_compare(Compare c) : comp(c) {}
public:
bool operator()(const value_type& lhs, const value_type& rhs) const
{
return comp(lhs.first, rhs.first); //
}
};
private:
// mystl::rb_tree
typedef mystl::rb_tree<value_type, key_compare> base_type;
base_type tree_;
public:
// rb_tree
typedef typename base_type::node_type node_type;
typedef typename base_type::pointer pointer;
typedef typename base_type::const_pointer const_pointer;
typedef typename base_type::reference reference;
typedef typename base_type::const_reference const_reference;
typedef typename base_type::iterator iterator;
typedef typename base_type::const_iterator const_iterator;
typedef typename base_type::reverse_iterator reverse_iterator;
typedef typename base_type::const_reverse_iterator const_reverse_iterator;
typedef typename base_type::size_type size_type;
typedef typename base_type::difference_type difference_type;
typedef typename base_type::allocator_type allocator_type;
public:
//
map() = default;
template <class InputIterator>
map(InputIterator first, InputIterator last)
:tree_()
{ tree_.insert_unique(first, last); }
map(std::initializer_list<value_type> ilist)
:tree_()
{ tree_.insert_unique(ilist.begin(), ilist.end()); }
map(const map& rhs)
:tree_(rhs.tree_)
{
}
map(map&& rhs) noexcept
:tree_(mystl::move(rhs.tree_))
{
}
map& operator=(const map& rhs)
{
tree_ = rhs.tree_;
return *this;
}
map& operator=(map&& rhs)
{
tree_ = mystl::move(rhs.tree_);
return *this;
}
map& operator=(std::initializer_list<value_type> ilist)
{
tree_.clear();
tree_.insert_unique(ilist.begin(), ilist.end());
return *this;
}
//
key_compare key_comp() const { return tree_.key_comp(); }
value_compare value_comp() const { return value_compare(tree_.key_comp()); }
allocator_type get_allocator() const { return tree_.get_allocator(); }
//
iterator begin() noexcept
{ return tree_.begin(); }
const_iterator begin() const noexcept
{ return tree_.begin(); }
iterator end() noexcept
{ return tree_.end(); }
const_iterator end() const noexcept
{ return tree_.end(); }
reverse_iterator rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator cbegin() const noexcept
{ return begin(); }
const_iterator cend() const noexcept
{ return end(); }
const_reverse_iterator crbegin() const noexcept
{ return rbegin(); }
const_reverse_iterator crend() const noexcept
{ return rend(); }
//
bool empty() const noexcept { return tree_.empty(); }
size_type size() const noexcept { return tree_.size(); }
size_type max_size() const noexcept { return tree_.max_size(); }
//
// at
mapped_type& at(const key_type& key)
{
iterator it = lower_bound(key);
// it->first >= key
THROW_OUT_OF_RANGE_IF(it == end() || key_comp()(it->first, key),
"map<Key, T> no such element exists");
return it->second;
}
const mapped_type& at(const key_type& key) const
{
const_iterator it = lower_bound(key);
// it->first >= key
THROW_OUT_OF_RANGE_IF(it == end() || key_comp()(it->first, key),
"map<Key, T> no such element exists");
return it->second;
}
mapped_type& operator[](const key_type& key)
{
iterator it = lower_bound(key);
// it->first >= key
if (it == end() || key_comp()(key, it->first))
it = emplace_hint(it, key, T{});
return it->second;
}
mapped_type& operator[](key_type&& key)
{
iterator it = lower_bound(key);
// it->first >= key
if (it == end() || key_comp()(key, it->first))
it = emplace_hint(it, mystl::move(key), T{});
return it->second;
}
//
template <class ...Args>
pair<iterator, bool> emplace(Args&& ...args)
{
return tree_.emplace_unique(mystl::forward<Args>(args)...);
}
template <class ...Args>
iterator emplace_hint(iterator hint, Args&& ...args)
{
return tree_.emplace_unique_use_hint(hint, mystl::forward<Args>(args)...);
}
pair<iterator, bool> insert(const value_type& value)
{
return tree_.insert_unique(value);
}
pair<iterator, bool> insert(value_type&& value)
{
return tree_.insert_unique(mystl::move(value));
}
iterator insert(iterator hint, const value_type& value)
{
return tree_.insert_unique(hint, value);
}
iterator insert(iterator hint, value_type&& value)
{
return tree_.insert_unique(hint, mystl::move(value));
}
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{
tree_.insert_unique(first, last);
}
void erase(iterator position) { tree_.erase(position); }
size_type erase(const key_type& key) { return tree_.erase_unique(key); }
void erase(iterator first, iterator last) { tree_.erase(first, last); }
void clear() { tree_.clear(); }
// map
iterator find(const key_type& key) { return tree_.find(key); }
const_iterator find(const key_type& key) const { return tree_.find(key); }
size_type count(const key_type& key) const { return tree_.count_unique(key); }
iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); }
const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); }
iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); }
const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); }
pair<iterator, iterator>
equal_range(const key_type& key)
{ return tree_.equal_range_unique(key); }
pair<const_iterator, const_iterator>
equal_range(const key_type& key) const
{ return tree_.equal_range_unique(key); }
void swap(map& rhs) noexcept
{ tree_.swap(rhs.tree_); }
public:
friend bool operator==(const map& lhs, const map& rhs) { return lhs.tree_ == rhs.tree_; }
friend bool operator< (const map& lhs, const map& rhs) { return lhs.tree_ < rhs.tree_; }
};
//
template <class Key, class T, class Compare>
bool operator==(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{
return lhs == rhs;
}
template <class Key, class T, class Compare>
bool operator<(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{
return lhs < rhs;
}
template <class Key, class T, class Compare>
bool operator!=(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{
return !(lhs == rhs);
}
template <class Key, class T, class Compare>
bool operator>(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{
return rhs < lhs;
}
template <class Key, class T, class Compare>
bool operator<=(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{
return !(rhs < lhs);
}
template <class Key, class T, class Compare>
bool operator>=(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{
return !(lhs < rhs);
}
// mystl swap
template <class Key, class T, class Compare>
void swap(map<Key, T, Compare>& lhs, map<Key, T, Compare>& rhs) noexcept
{
lhs.swap(rhs);
}
/*****************************************************************************************/
// multimap
// mystl::less
template <class Key, class T, class Compare = mystl::less<Key>>
class multimap
{
public:
// multimap
typedef Key key_type;
typedef T mapped_type;
typedef mystl::pair<const Key, T> value_type;
typedef Compare key_compare;
// functor
class value_compare : public binary_function <value_type, value_type, bool>
{
friend class multimap<Key, T, Compare>;
private:
Compare comp;
value_compare(Compare c) : comp(c) {}
public:
bool operator()(const value_type& lhs, const value_type& rhs) const
{
return comp(lhs.first, rhs.first);
}
};
private:
// mystl::rb_tree
typedef mystl::rb_tree<value_type, key_compare> base_type;
base_type tree_;
public:
// rb_tree
typedef typename base_type::node_type node_type;
typedef typename base_type::pointer pointer;
typedef typename base_type::const_pointer const_pointer;
typedef typename base_type::reference reference;
typedef typename base_type::const_reference const_reference;
typedef typename base_type::iterator iterator;
typedef typename base_type::const_iterator const_iterator;
typedef typename base_type::reverse_iterator reverse_iterator;
typedef typename base_type::const_reverse_iterator const_reverse_iterator;
typedef typename base_type::size_type size_type;
typedef typename base_type::difference_type difference_type;
typedef typename base_type::allocator_type allocator_type;
public:
//
multimap() = default;
template <class InputIterator>
multimap(InputIterator first, InputIterator last)
:tree_()
{ tree_.insert_multi(first, last); }
multimap(std::initializer_list<value_type> ilist)
:tree_()
{ tree_.insert_multi(ilist.begin(), ilist.end()); }
multimap(const multimap& rhs)
:tree_(rhs.tree_)
{
}
multimap(multimap&& rhs) noexcept
:tree_(mystl::move(rhs.tree_))
{
}
multimap& operator=(const multimap& rhs)
{
tree_ = rhs.tree_;
return *this;
}
multimap& operator=(multimap&& rhs)
{
tree_ = mystl::move(rhs.tree_);
return *this;
}
multimap& operator=(std::initializer_list<value_type> ilist)
{
tree_.clear();
tree_.insert_multi(ilist.begin(), ilist.end());
return *this;
}
//
key_compare key_comp() const { return tree_.key_comp(); }
value_compare value_comp() const { return value_compare(tree_.key_comp()); }
allocator_type get_allocator() const { return tree_.get_allocator(); }
//
iterator begin() noexcept
{ return tree_.begin(); }
const_iterator begin() const noexcept
{ return tree_.begin(); }
iterator end() noexcept
{ return tree_.end(); }
const_iterator end() const noexcept
{ return tree_.end(); }
reverse_iterator rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator cbegin() const noexcept
{ return begin(); }
const_iterator cend() const noexcept
{ return end(); }
const_reverse_iterator crbegin() const noexcept
{ return rbegin(); }
const_reverse_iterator crend() const noexcept
{ return rend(); }
//
bool empty() const noexcept { return tree_.empty(); }
size_type size() const noexcept { return tree_.size(); }
size_type max_size() const noexcept { return tree_.max_size(); }
//
template <class ...Args>
iterator emplace(Args&& ...args)
{
return tree_.emplace_multi(mystl::forward<Args>(args)...);
}
template <class ...Args>
iterator emplace_hint(iterator hint, Args&& ...args)
{
return tree_.emplace_multi_use_hint(hint, mystl::forward<Args>(args)...);
}
iterator insert(const value_type& value)
{
return tree_.insert_multi(value);
}
iterator insert(value_type&& value)
{
return tree_.insert_multi(mystl::move(value));
}
iterator insert(iterator hint, const value_type& value)
{
return tree_.insert_multi(hint, value);
}
iterator insert(iterator hint, value_type&& value)
{
return tree_.insert_multi(hint, mystl::move(value));
}
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{
tree_.insert_multi(first, last);
}
void erase(iterator position) { tree_.erase(position); }
size_type erase(const key_type& key) { return tree_.erase_multi(key); }
void erase(iterator first, iterator last) { tree_.erase(first, last); }
void clear() { tree_.clear(); }
// multimap
iterator find(const key_type& key) { return tree_.find(key); }
const_iterator find(const key_type& key) const { return tree_.find(key); }
size_type count(const key_type& key) const { return tree_.count_multi(key); }
iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); }
const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); }
iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); }
const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); }
pair<iterator, iterator>
equal_range(const key_type& key)
{ return tree_.equal_range_multi(key); }
pair<const_iterator, const_iterator>
equal_range(const key_type& key) const
{ return tree_.equal_range_multi(key); }
void swap(multimap& rhs) noexcept
{ tree_.swap(rhs.tree_); }
public:
friend bool operator==(const multimap& lhs, const multimap& rhs) { return lhs.tree_ == rhs.tree_; }
friend bool operator< (const multimap& lhs, const multimap& rhs) { return lhs.tree_ < rhs.tree_; }
};
//
template <class Key, class T, class Compare>
bool operator==(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs)
{
return lhs == rhs;
}
template <class Key, class T, class Compare>
bool operator<(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs)
{
return lhs < rhs;
}
template <class Key, class T, class Compare>
bool operator!=(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs)
{
return !(lhs == rhs);
}
template <class Key, class T, class Compare>
bool operator>(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs)
{
return rhs < lhs;
}
template <class Key, class T, class Compare>
bool operator<=(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs)
{
return !(rhs < lhs);
}
template <class Key, class T, class Compare>
bool operator>=(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs)
{
return !(lhs < rhs);
}
// mystl swap
template <class Key, class T, class Compare>
void swap(multimap<Key, T, Compare>& lhs, multimap<Key, T, Compare>& rhs) noexcept
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_MAP_H_
``` | /content/code_sandbox/MyTinySTL/map.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 3,978 |
```objective-c
#ifndef MYTINYSTL_UNORDERED_MAP_H_
#define MYTINYSTL_UNORDERED_MAP_H_
// unordered_map unordered_multimap
// map multimap hashtable
// notes:
//
//
// mystl::unordered_map<Key, T> / mystl::unordered_multimap<Key, T>
// * emplace
// * emplace_hint
// * insert
#include "hashtable.h"
namespace mystl
{
// unordered_map
// mystl::hash
// mystl::equal_to
template <class Key, class T, class Hash = mystl::hash<Key>, class KeyEqual = mystl::equal_to<Key>>
class unordered_map
{
private:
// hashtable
typedef hashtable<mystl::pair<const Key, T>, Hash, KeyEqual> base_type;
base_type ht_;
public:
// hashtable
typedef typename base_type::allocator_type allocator_type;
typedef typename base_type::key_type key_type;
typedef typename base_type::mapped_type mapped_type;
typedef typename base_type::value_type value_type;
typedef typename base_type::hasher hasher;
typedef typename base_type::key_equal key_equal;
typedef typename base_type::size_type size_type;
typedef typename base_type::difference_type difference_type;
typedef typename base_type::pointer pointer;
typedef typename base_type::const_pointer const_pointer;
typedef typename base_type::reference reference;
typedef typename base_type::const_reference const_reference;
typedef typename base_type::iterator iterator;
typedef typename base_type::const_iterator const_iterator;
typedef typename base_type::local_iterator local_iterator;
typedef typename base_type::const_local_iterator const_local_iterator;
allocator_type get_allocator() const { return ht_.get_allocator(); }
public:
//
unordered_map()
:ht_(100, Hash(), KeyEqual())
{
}
explicit unordered_map(size_type bucket_count,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(bucket_count, hash, equal)
{
}
template <class InputIterator>
unordered_map(InputIterator first, InputIterator last,
const size_type bucket_count = 100,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
: ht_(mystl::max(bucket_count, static_cast<size_type>(mystl::distance(first, last))), hash, equal)
{
for (; first != last; ++first)
ht_.insert_unique_noresize(*first);
}
unordered_map(std::initializer_list<value_type> ilist,
const size_type bucket_count = 100,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(mystl::max(bucket_count, static_cast<size_type>(ilist.size())), hash, equal)
{
for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
ht_.insert_unique_noresize(*first);
}
unordered_map(const unordered_map& rhs)
:ht_(rhs.ht_)
{
}
unordered_map(unordered_map&& rhs) noexcept
:ht_(mystl::move(rhs.ht_))
{
}
unordered_map& operator=(const unordered_map& rhs)
{
ht_ = rhs.ht_;
return *this;
}
unordered_map& operator=(unordered_map&& rhs)
{
ht_ = mystl::move(rhs.ht_);
return *this;
}
unordered_map& operator=(std::initializer_list<value_type> ilist)
{
ht_.clear();
ht_.reserve(ilist.size());
for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
ht_.insert_unique_noresize(*first);
return *this;
}
~unordered_map() = default;
//
iterator begin() noexcept
{ return ht_.begin(); }
const_iterator begin() const noexcept
{ return ht_.begin(); }
iterator end() noexcept
{ return ht_.end(); }
const_iterator end() const noexcept
{ return ht_.end(); }
const_iterator cbegin() const noexcept
{ return ht_.cbegin(); }
const_iterator cend() const noexcept
{ return ht_.cend(); }
//
bool empty() const noexcept { return ht_.empty(); }
size_type size() const noexcept { return ht_.size(); }
size_type max_size() const noexcept { return ht_.max_size(); }
//
// empalce / empalce_hint
template <class ...Args>
pair<iterator, bool> emplace(Args&& ...args)
{ return ht_.emplace_unique(mystl::forward<Args>(args)...); }
template <class ...Args>
iterator emplace_hint(const_iterator hint, Args&& ...args)
{ return ht_.emplace_unique_use_hint(hint, mystl::forward<Args>(args)...); }
// insert
pair<iterator, bool> insert(const value_type& value)
{ return ht_.insert_unique(value); }
pair<iterator, bool> insert(value_type&& value)
{ return ht_.emplace_unique(mystl::move(value)); }
iterator insert(const_iterator hint, const value_type& value)
{ return ht_.insert_unique_use_hint(hint, value); }
iterator insert(const_iterator hint, value_type&& value)
{ return ht_.emplace_unique_use_hint(hint, mystl::move(value)); }
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{ ht_.insert_unique(first, last); }
// erase / clear
void erase(iterator it)
{ ht_.erase(it); }
void erase(iterator first, iterator last)
{ ht_.erase(first, last); }
size_type erase(const key_type& key)
{ return ht_.erase_unique(key); }
void clear()
{ ht_.clear(); }
void swap(unordered_map& other) noexcept
{ ht_.swap(other.ht_); }
//
mapped_type& at(const key_type& key)
{
iterator it = ht_.find(key);
THROW_OUT_OF_RANGE_IF(it.node == nullptr, "unordered_map<Key, T> no such element exists");
return it->second;
}
const mapped_type& at(const key_type& key) const
{
iterator it = ht_.find(key);
THROW_OUT_OF_RANGE_IF(it.node == nullptr, "unordered_map<Key, T> no such element exists");
return it->second;
}
mapped_type& operator[](const key_type& key)
{
iterator it = ht_.find(key);
if (it.node == nullptr)
it = ht_.emplace_unique(key, T{}).first;
return it->second;
}
mapped_type& operator[](key_type&& key)
{
iterator it = ht_.find(key);
if (it.node == nullptr)
it = ht_.emplace_unique(mystl::move(key), T{}).first;
return it->second;
}
size_type count(const key_type& key) const
{ return ht_.count(key); }
iterator find(const key_type& key)
{ return ht_.find(key); }
const_iterator find(const key_type& key) const
{ return ht_.find(key); }
pair<iterator, iterator> equal_range(const key_type& key)
{ return ht_.equal_range_unique(key); }
pair<const_iterator, const_iterator> equal_range(const key_type& key) const
{ return ht_.equal_range_unique(key); }
// bucket interface
local_iterator begin(size_type n) noexcept
{ return ht_.begin(n); }
const_local_iterator begin(size_type n) const noexcept
{ return ht_.begin(n); }
const_local_iterator cbegin(size_type n) const noexcept
{ return ht_.cbegin(n); }
local_iterator end(size_type n) noexcept
{ return ht_.end(n); }
const_local_iterator end(size_type n) const noexcept
{ return ht_.end(n); }
const_local_iterator cend(size_type n) const noexcept
{ return ht_.cend(n); }
size_type bucket_count() const noexcept
{ return ht_.bucket_count(); }
size_type max_bucket_count() const noexcept
{ return ht_.max_bucket_count(); }
size_type bucket_size(size_type n) const noexcept
{ return ht_.bucket_size(n); }
size_type bucket(const key_type& key) const
{ return ht_.bucket(key); }
// hash policy
float load_factor() const noexcept { return ht_.load_factor(); }
float max_load_factor() const noexcept { return ht_.max_load_factor(); }
void max_load_factor(float ml) { ht_.max_load_factor(ml); }
void rehash(size_type count) { ht_.rehash(count); }
void reserve(size_type count) { ht_.reserve(count); }
hasher hash_fcn() const { return ht_.hash_fcn(); }
key_equal key_eq() const { return ht_.key_eq(); }
public:
friend bool operator==(const unordered_map& lhs, const unordered_map& rhs)
{
return lhs.ht_.equal_range_unique(rhs.ht_);
}
friend bool operator!=(const unordered_map& lhs, const unordered_map& rhs)
{
return !lhs.ht_.equal_range_unique(rhs.ht_);
}
};
//
template <class Key, class T, class Hash, class KeyEqual>
bool operator==(const unordered_map<Key, T, Hash, KeyEqual>& lhs,
const unordered_map<Key, T, Hash, KeyEqual>& rhs)
{
return lhs == rhs;
}
template <class Key, class T, class Hash, class KeyEqual>
bool operator!=(const unordered_map<Key, T, Hash, KeyEqual>& lhs,
const unordered_map<Key, T, Hash, KeyEqual>& rhs)
{
return lhs != rhs;
}
// mystl swap
template <class Key, class T, class Hash, class KeyEqual>
void swap(unordered_map<Key, T, Hash, KeyEqual>& lhs,
unordered_map<Key, T, Hash, KeyEqual>& rhs)
{
lhs.swap(rhs);
}
/*****************************************************************************************/
// unordered_multimap
// mystl::hash
// mystl::equal_to
template <class Key, class T, class Hash = mystl::hash<Key>, class KeyEqual = mystl::equal_to<Key>>
class unordered_multimap
{
private:
// hashtable
typedef hashtable<pair<const Key, T>, Hash, KeyEqual> base_type;
base_type ht_;
public:
// hashtable
typedef typename base_type::allocator_type allocator_type;
typedef typename base_type::key_type key_type;
typedef typename base_type::mapped_type mapped_type;
typedef typename base_type::value_type value_type;
typedef typename base_type::hasher hasher;
typedef typename base_type::key_equal key_equal;
typedef typename base_type::size_type size_type;
typedef typename base_type::difference_type difference_type;
typedef typename base_type::pointer pointer;
typedef typename base_type::const_pointer const_pointer;
typedef typename base_type::reference reference;
typedef typename base_type::const_reference const_reference;
typedef typename base_type::iterator iterator;
typedef typename base_type::const_iterator const_iterator;
typedef typename base_type::local_iterator local_iterator;
typedef typename base_type::const_local_iterator const_local_iterator;
allocator_type get_allocator() const { return ht_.get_allocator(); }
public:
//
unordered_multimap()
:ht_(100, Hash(), KeyEqual())
{
}
explicit unordered_multimap(size_type bucket_count,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(bucket_count, hash, equal)
{
}
template <class InputIterator>
unordered_multimap(InputIterator first, InputIterator last,
const size_type bucket_count = 100,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(mystl::max(bucket_count, static_cast<size_type>(mystl::distance(first, last))), hash, equal)
{
for (; first != last; ++first)
ht_.insert_multi_noresize(*first);
}
unordered_multimap(std::initializer_list<value_type> ilist,
const size_type bucket_count = 100,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(mystl::max(bucket_count, static_cast<size_type>(ilist.size())), hash, equal)
{
for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
ht_.insert_multi_noresize(*first);
}
unordered_multimap(const unordered_multimap& rhs)
:ht_(rhs.ht_)
{
}
unordered_multimap(unordered_multimap&& rhs) noexcept
:ht_(mystl::move(rhs.ht_))
{
}
unordered_multimap& operator=(const unordered_multimap& rhs)
{
ht_ = rhs.ht_;
return *this;
}
unordered_multimap& operator=(unordered_multimap&& rhs)
{
ht_ = mystl::move(rhs.ht_);
return *this;
}
unordered_multimap& operator=(std::initializer_list<value_type> ilist)
{
ht_.clear();
ht_.reserve(ilist.size());
for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
ht_.insert_multi_noresize(*first);
return *this;
}
~unordered_multimap() = default;
//
iterator begin() noexcept
{ return ht_.begin(); }
const_iterator begin() const noexcept
{ return ht_.begin(); }
iterator end() noexcept
{ return ht_.end(); }
const_iterator end() const noexcept
{ return ht_.end(); }
const_iterator cbegin() const noexcept
{ return ht_.cbegin(); }
const_iterator cend() const noexcept
{ return ht_.cend(); }
//
bool empty() const noexcept { return ht_.empty(); }
size_type size() const noexcept { return ht_.size(); }
size_type max_size() const noexcept { return ht_.max_size(); }
//
// emplace / emplace_hint
template <class ...Args>
iterator emplace(Args&& ...args)
{ return ht_.emplace_multi(mystl::forward<Args>(args)...); }
template <class ...Args>
iterator emplace_hint(const_iterator hint, Args&& ...args)
{ return ht_.emplace_multi_use_hint(hint, mystl::forward<Args>(args)...); }
// insert
iterator insert(const value_type& value)
{ return ht_.insert_multi(value); }
iterator insert(value_type&& value)
{ return ht_.emplace_multi(mystl::move(value)); }
iterator insert(const_iterator hint, const value_type& value)
{ return ht_.insert_multi_use_hint(hint, value); }
iterator insert(const_iterator hint, value_type&& value)
{ return ht_.emplace_multi_use_hint(hint, mystl::move(value)); }
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{ ht_.insert_multi(first, last); }
// erase / clear
void erase(iterator it)
{ ht_.erase(it); }
void erase(iterator first, iterator last)
{ ht_.erase(first, last); }
size_type erase(const key_type& key)
{ return ht_.erase_multi(key); }
void clear()
{ ht_.clear(); }
void swap(unordered_multimap& other) noexcept
{ ht_.swap(other.ht_); }
//
size_type count(const key_type& key) const
{ return ht_.count(key); }
iterator find(const key_type& key)
{ return ht_.find(key); }
const_iterator find(const key_type& key) const
{ return ht_.find(key); }
pair<iterator, iterator> equal_range(const key_type& key)
{ return ht_.equal_range_multi(key); }
pair<const_iterator, const_iterator> equal_range(const key_type& key) const
{ return ht_.equal_range_multi(key); }
// bucket interface
local_iterator begin(size_type n) noexcept
{ return ht_.begin(n); }
const_local_iterator begin(size_type n) const noexcept
{ return ht_.begin(n); }
const_local_iterator cbegin(size_type n) const noexcept
{ return ht_.cbegin(n); }
local_iterator end(size_type n) noexcept
{ return ht_.end(n); }
const_local_iterator end(size_type n) const noexcept
{ return ht_.end(n); }
const_local_iterator cend(size_type n) const noexcept
{ return ht_.cend(n); }
size_type bucket_count() const noexcept
{ return ht_.bucket_count(); }
size_type max_bucket_count() const noexcept
{ return ht_.max_bucket_count(); }
size_type bucket_size(size_type n) const noexcept
{ return ht_.bucket_size(n); }
size_type bucket(const key_type& key) const
{ return ht_.bucket(key); }
// hash policy
float load_factor() const noexcept { return ht_.load_factor(); }
float max_load_factor() const noexcept { return ht_.max_load_factor(); }
void max_load_factor(float ml) { ht_.max_load_factor(ml); }
void rehash(size_type count) { ht_.rehash(count); }
void reserve(size_type count) { ht_.reserve(count); }
hasher hash_fcn() const { return ht_.hash_fcn(); }
key_equal key_eq() const { return ht_.key_eq(); }
public:
friend bool operator==(const unordered_multimap& lhs, const unordered_multimap& rhs)
{
return lhs.ht_.equal_range_multi(rhs.ht_);
}
friend bool operator!=(const unordered_multimap& lhs, const unordered_multimap& rhs)
{
return !lhs.ht_.equal_range_multi(rhs.ht_);
}
};
//
template <class Key, class T, class Hash, class KeyEqual>
bool operator==(const unordered_multimap<Key, T, Hash, KeyEqual>& lhs,
const unordered_multimap<Key, T, Hash, KeyEqual>& rhs)
{
return lhs == rhs;
}
template <class Key, class T, class Hash, class KeyEqual>
bool operator!=(const unordered_multimap<Key, T, Hash, KeyEqual>& lhs,
const unordered_multimap<Key, T, Hash, KeyEqual>& rhs)
{
return lhs != rhs;
}
// mystl swap
template <class Key, class T, class Hash, class KeyEqual>
void swap(unordered_multimap<Key, T, Hash, KeyEqual>& lhs,
unordered_multimap<Key, T, Hash, KeyEqual>& rhs)
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_UNORDERED_MAP_H_
``` | /content/code_sandbox/MyTinySTL/unordered_map.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 4,293 |
```objective-c
#ifndef MYTINYSTL_BASIC_STRING_H_
#define MYTINYSTL_BASIC_STRING_H_
// basic_string
//
#include <iostream>
#include "iterator.h"
#include "memory.h"
#include "functional.h"
#include "exceptdef.h"
namespace mystl
{
// char_traits
template <class CharType>
struct char_traits
{
typedef CharType char_type;
static size_t length(const char_type* str)
{
size_t len = 0;
for (; *str != char_type(0); ++str)
++len;
return len;
}
static int compare(const char_type* s1, const char_type* s2, size_t n)
{
for (; n != 0; --n, ++s1, ++s2)
{
if (*s1 < *s2)
return -1;
if (*s2 < *s1)
return 1;
}
return 0;
}
static char_type* copy(char_type* dst, const char_type* src, size_t n)
{
MYSTL_DEBUG(src + n <= dst || dst + n <= src);
char_type* r = dst;
for (; n != 0; --n, ++dst, ++src)
*dst = *src;
return r;
}
static char_type* move(char_type* dst, const char_type* src, size_t n)
{
char_type* r = dst;
if (dst < src)
{
for (; n != 0; --n, ++dst, ++src)
*dst = *src;
}
else if (src < dst)
{
dst += n;
src += n;
for (; n != 0; --n)
*--dst = *--src;
}
return r;
}
static char_type* fill(char_type* dst, char_type ch, size_t count)
{
char_type* r = dst;
for (; count > 0; --count, ++dst)
*dst = ch;
return r;
}
};
// Partialized. char_traits<char>
template <>
struct char_traits<char>
{
typedef char char_type;
static size_t length(const char_type* str) noexcept
{ return std::strlen(str); }
static int compare(const char_type* s1, const char_type* s2, size_t n) noexcept
{ return std::memcmp(s1, s2, n); }
static char_type* copy(char_type* dst, const char_type* src, size_t n) noexcept
{
MYSTL_DEBUG(src + n <= dst || dst + n <= src);
return static_cast<char_type*>(std::memcpy(dst, src, n));
}
static char_type* move(char_type* dst, const char_type* src, size_t n) noexcept
{
return static_cast<char_type*>(std::memmove(dst, src, n));
}
static char_type* fill(char_type* dst, char_type ch, size_t count) noexcept
{
return static_cast<char_type*>(std::memset(dst, ch, count));
}
};
// Partialized. char_traits<wchar_t>
template <>
struct char_traits<wchar_t>
{
typedef wchar_t char_type;
static size_t length(const char_type* str) noexcept
{
return std::wcslen(str);
}
static int compare(const char_type* s1, const char_type* s2, size_t n) noexcept
{
return std::wmemcmp(s1, s2, n);
}
static char_type* copy(char_type* dst, const char_type* src, size_t n) noexcept
{
MYSTL_DEBUG(src + n <= dst || dst + n <= src);
return static_cast<char_type*>(std::wmemcpy(dst, src, n));
}
static char_type* move(char_type* dst, const char_type* src, size_t n) noexcept
{
return static_cast<char_type*>(std::wmemmove(dst, src, n));
}
static char_type* fill(char_type* dst, char_type ch, size_t count) noexcept
{
return static_cast<char_type*>(std::wmemset(dst, ch, count));
}
};
// Partialized. char_traits<char16_t>
template <>
struct char_traits<char16_t>
{
typedef char16_t char_type;
static size_t length(const char_type* str) noexcept
{
size_t len = 0;
for (; *str != char_type(0); ++str)
++len;
return len;
}
static int compare(const char_type* s1, const char_type* s2, size_t n) noexcept
{
for (; n != 0; --n, ++s1, ++s2)
{
if (*s1 < *s2)
return -1;
if (*s2 < *s1)
return 1;
}
return 0;
}
static char_type* copy(char_type* dst, const char_type* src, size_t n) noexcept
{
MYSTL_DEBUG(src + n <= dst || dst + n <= src);
char_type* r = dst;
for (; n != 0; --n, ++dst, ++src)
*dst = *src;
return r;
}
static char_type* move(char_type* dst, const char_type* src, size_t n) noexcept
{
char_type* r = dst;
if (dst < src)
{
for (; n != 0; --n, ++dst, ++src)
*dst = *src;
}
else if (src < dst)
{
dst += n;
src += n;
for (; n != 0; --n)
*--dst = *--src;
}
return r;
}
static char_type* fill(char_type* dst, char_type ch, size_t count) noexcept
{
char_type* r = dst;
for (; count > 0; --count, ++dst)
*dst = ch;
return r;
}
};
// Partialized. char_traits<char32_t>
template <>
struct char_traits<char32_t>
{
typedef char32_t char_type;
static size_t length(const char_type* str) noexcept
{
size_t len = 0;
for (; *str != char_type(0); ++str)
++len;
return len;
}
static int compare(const char_type* s1, const char_type* s2, size_t n) noexcept
{
for (; n != 0; --n, ++s1, ++s2)
{
if (*s1 < *s2)
return -1;
if (*s2 < *s1)
return 1;
}
return 0;
}
static char_type* copy(char_type* dst, const char_type* src, size_t n) noexcept
{
MYSTL_DEBUG(src + n <= dst || dst + n <= src);
char_type* r = dst;
for (; n != 0; --n, ++dst, ++src)
*dst = *src;
return r;
}
static char_type* move(char_type* dst, const char_type* src, size_t n) noexcept
{
char_type* r = dst;
if (dst < src)
{
for (; n != 0; --n, ++dst, ++src)
*dst = *src;
}
else if (src < dst)
{
dst += n;
src += n;
for (; n != 0; --n)
*--dst = *--src;
}
return r;
}
static char_type* fill(char_type* dst, char_type ch, size_t count) noexcept
{
char_type* r = dst;
for (; count > 0; --count, ++dst)
*dst = ch;
return r;
}
};
// basic_string buffer
#define STRING_INIT_SIZE 32
// basic_string
// mystl::char_traits
template <class CharType, class CharTraits = mystl::char_traits<CharType>>
class basic_string
{
public:
typedef CharTraits traits_type;
typedef CharTraits char_traits;
typedef mystl::allocator<CharType> allocator_type;
typedef mystl::allocator<CharType> data_allocator;
typedef typename allocator_type::value_type value_type;
typedef typename allocator_type::pointer pointer;
typedef typename allocator_type::const_pointer const_pointer;
typedef typename allocator_type::reference reference;
typedef typename allocator_type::const_reference const_reference;
typedef typename allocator_type::size_type size_type;
typedef typename allocator_type::difference_type difference_type;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef mystl::reverse_iterator<iterator> reverse_iterator;
typedef mystl::reverse_iterator<const_iterator> const_reverse_iterator;
allocator_type get_allocator() { return allocator_type(); }
static_assert(std::is_pod<CharType>::value, "Character type of basic_string must be a POD");
static_assert(std::is_same<CharType, typename traits_type::char_type>::value,
"CharType must be same as traits_type::char_type");
public:
// :
// if (str.find('a') != string::npos) { /* do something */ }
static constexpr size_type npos = static_cast<size_type>(-1);
private:
iterator buffer_; //
size_type size_; //
size_type cap_; //
public:
//
basic_string() noexcept
{ try_init(); }
basic_string(size_type n, value_type ch)
:buffer_(nullptr), size_(0), cap_(0)
{
fill_init(n, ch);
}
basic_string(const basic_string& other, size_type pos)
:buffer_(nullptr), size_(0), cap_(0)
{
init_from(other.buffer_, pos, other.size_ - pos);
}
basic_string(const basic_string& other, size_type pos, size_type count)
:buffer_(nullptr), size_(0), cap_(0)
{
init_from(other.buffer_, pos, count);
}
basic_string(const_pointer str)
:buffer_(nullptr), size_(0), cap_(0)
{
init_from(str, 0, char_traits::length(str));
}
basic_string(const_pointer str, size_type count)
:buffer_(nullptr), size_(0), cap_(0)
{
init_from(str, 0, count);
}
template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::value, int>::type = 0>
basic_string(Iter first, Iter last)
{ copy_init(first, last, iterator_category(first)); }
basic_string(const basic_string& rhs)
:buffer_(nullptr), size_(0), cap_(0)
{
init_from(rhs.buffer_, 0, rhs.size_);
}
basic_string(basic_string&& rhs) noexcept
:buffer_(rhs.buffer_), size_(rhs.size_), cap_(rhs.cap_)
{
rhs.buffer_ = nullptr;
rhs.size_ = 0;
rhs.cap_ = 0;
}
basic_string& operator=(const basic_string& rhs);
basic_string& operator=(basic_string&& rhs) noexcept;
basic_string& operator=(const_pointer str);
basic_string& operator=(value_type ch);
~basic_string() { destroy_buffer(); }
public:
//
iterator begin() noexcept
{ return buffer_; }
const_iterator begin() const noexcept
{ return buffer_; }
iterator end() noexcept
{ return buffer_ + size_; }
const_iterator end() const noexcept
{ return buffer_ + size_; }
reverse_iterator rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator cbegin() const noexcept
{ return begin(); }
const_iterator cend() const noexcept
{ return end(); }
const_reverse_iterator crbegin() const noexcept
{ return rbegin(); }
const_reverse_iterator crend() const noexcept
{ return rend(); }
//
bool empty() const noexcept
{ return size_ == 0; }
size_type size() const noexcept
{ return size_; }
size_type length() const noexcept
{ return size_; }
size_type capacity() const noexcept
{ return cap_; }
size_type max_size() const noexcept
{ return static_cast<size_type>(-1); }
void reserve(size_type n);
void shrink_to_fit();
//
reference operator[](size_type n)
{
MYSTL_DEBUG(n <= size_);
if (n == size_)
*(buffer_ + n) = value_type();
return *(buffer_ + n);
}
const_reference operator[](size_type n) const
{
MYSTL_DEBUG(n <= size_);
if (n == size_)
*(buffer_ + n) = value_type();
return *(buffer_ + n);
}
reference at(size_type n)
{
THROW_OUT_OF_RANGE_IF(n >= size_, "basic_string<Char, Traits>::at()"
"subscript out of range");
return (*this)[n];
}
const_reference at(size_type n) const
{
THROW_OUT_OF_RANGE_IF(n >= size_, "basic_string<Char, Traits>::at()"
"subscript out of range");
return (*this)[n];
}
reference front()
{
MYSTL_DEBUG(!empty());
return *begin();
}
const_reference front() const
{
MYSTL_DEBUG(!empty());
return *begin();
}
reference back()
{
MYSTL_DEBUG(!empty());
return *(end() - 1);
}
const_reference back() const
{
MYSTL_DEBUG(!empty());
return *(end() - 1);
}
const_pointer data() const noexcept
{ return to_raw_pointer(); }
const_pointer c_str() const noexcept
{ return to_raw_pointer(); }
//
// insert
iterator insert(const_iterator pos, value_type ch);
iterator insert(const_iterator pos, size_type count, value_type ch);
template <class Iter>
iterator insert(const_iterator pos, Iter first, Iter last);
// push_back / pop_back
void push_back(value_type ch)
{ append(1, ch); }
void pop_back()
{
MYSTL_DEBUG(!empty());
--size_;
}
// append
basic_string& append(size_type count, value_type ch);
basic_string& append(const basic_string& str)
{ return append(str, 0, str.size_); }
basic_string& append(const basic_string& str, size_type pos)
{ return append(str, pos, str.size_ - pos); }
basic_string& append(const basic_string& str, size_type pos, size_type count);
basic_string& append(const_pointer s)
{ return append(s, char_traits::length(s)); }
basic_string& append(const_pointer s, size_type count);
template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::value, int>::type = 0>
basic_string& append(Iter first, Iter last)
{ return append_range(first, last); }
// erase /clear
iterator erase(const_iterator pos);
iterator erase(const_iterator first, const_iterator last);
// resize
void resize(size_type count)
{ resize(count, value_type()); }
void resize(size_type count, value_type ch);
void clear() noexcept
{ size_ = 0; }
// basic_string
// compare
int compare(const basic_string& other) const;
int compare(size_type pos1, size_type count1, const basic_string& other) const;
int compare(size_type pos1, size_type count1, const basic_string& other,
size_type pos2, size_type count2 = npos) const;
int compare(const_pointer s) const;
int compare(size_type pos1, size_type count1, const_pointer s) const;
int compare(size_type pos1, size_type count1, const_pointer s, size_type count2) const;
// substr
basic_string substr(size_type index, size_type count = npos)
{
count = mystl::min(count, size_ - index);
return basic_string(buffer_ + index, buffer_ + index + count);
}
// replace
basic_string& replace(size_type pos, size_type count, const basic_string& str)
{
THROW_OUT_OF_RANGE_IF(pos > size_, "basic_string<Char, Traits>::replace's pos out of range");
return replace_cstr(buffer_ + pos, count, str.buffer_, str.size_);
}
basic_string& replace(const_iterator first, const_iterator last, const basic_string& str)
{
MYSTL_DEBUG(begin() <= first && last <= end() && first <= last);
return replace_cstr(first, static_cast<size_type>(last - first), str.buffer_, str.size_);
}
basic_string& replace(size_type pos, size_type count, const_pointer str)
{
THROW_OUT_OF_RANGE_IF(pos > size_, "basic_string<Char, Traits>::replace's pos out of range");
return replace_cstr(buffer_ + pos, count, str, char_traits::length(str));
}
basic_string& replace(const_iterator first, const_iterator last, const_pointer str)
{
MYSTL_DEBUG(begin() <= first && last <= end() && first <= last);
return replace_cstr(first, static_cast<size_type>(last - first), str, char_traits::length(str));
}
basic_string& replace(size_type pos, size_type count, const_pointer str, size_type count2)
{
THROW_OUT_OF_RANGE_IF(pos > size_, "basic_string<Char, Traits>::replace's pos out of range");
return replace_cstr(buffer_ + pos, count, str, count2);
}
basic_string& replace(const_iterator first, const_iterator last, const_pointer str, size_type count)
{
MYSTL_DEBUG(begin() <= first && last <= end() && first <= last);
return replace_cstr(first, static_cast<size_type>(last - first), str, count);
}
basic_string& replace(size_type pos, size_type count, size_type count2, value_type ch)
{
THROW_OUT_OF_RANGE_IF(pos > size_, "basic_string<Char, Traits>::replace's pos out of range");
return replace_fill(buffer_ + pos, count, count2, ch);
}
basic_string& replace(const_iterator first, const_iterator last, size_type count, value_type ch)
{
MYSTL_DEBUG(begin() <= first && last <= end() && first <= last);
return replace_fill(first, static_cast<size_type>(last - first), count, ch);
}
basic_string& replace(size_type pos1, size_type count1, const basic_string& str,
size_type pos2, size_type count2 = npos)
{
THROW_OUT_OF_RANGE_IF(pos1 > size_ || pos2 > str.size_,
"basic_string<Char, Traits>::replace's pos out of range");
return replace_cstr(buffer_ + pos1, count1, str.buffer_ + pos2, count2);
}
template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::value, int>::type = 0>
basic_string& replace(const_iterator first, const_iterator last, Iter first2, Iter last2)
{
MYSTL_DEBUG(begin() <= first && last <= end() && first <= last);
return replace_copy(first, last, first2, last2);
}
// reverse
void reverse() noexcept;
// swap
void swap(basic_string& rhs) noexcept;
//
// find
size_type find(value_type ch, size_type pos = 0) const noexcept;
size_type find(const_pointer str, size_type pos = 0) const noexcept;
size_type find(const_pointer str, size_type pos, size_type count) const noexcept;
size_type find(const basic_string& str, size_type pos = 0) const noexcept;
// rfind
size_type rfind(value_type ch, size_type pos = npos) const noexcept;
size_type rfind(const_pointer str, size_type pos = npos) const noexcept;
size_type rfind(const_pointer str, size_type pos, size_type count) const noexcept;
size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
// find_first_of
size_type find_first_of(value_type ch, size_type pos = 0) const noexcept;
size_type find_first_of(const_pointer s, size_type pos = 0) const noexcept;
size_type find_first_of(const_pointer s, size_type pos, size_type count) const noexcept;
size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
// find_first_not_of
size_type find_first_not_of(value_type ch, size_type pos = 0) const noexcept;
size_type find_first_not_of(const_pointer s, size_type pos = 0) const noexcept;
size_type find_first_not_of(const_pointer s, size_type pos, size_type count) const noexcept;
size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept;
// find_last_of
size_type find_last_of(value_type ch, size_type pos = 0) const noexcept;
size_type find_last_of(const_pointer s, size_type pos = 0) const noexcept;
size_type find_last_of(const_pointer s, size_type pos, size_type count) const noexcept;
size_type find_last_of(const basic_string& str, size_type pos = 0) const noexcept;
// find_last_not_of
size_type find_last_not_of(value_type ch, size_type pos = 0) const noexcept;
size_type find_last_not_of(const_pointer s, size_type pos = 0) const noexcept;
size_type find_last_not_of(const_pointer s, size_type pos, size_type count) const noexcept;
size_type find_last_not_of(const basic_string& str, size_type pos = 0) const noexcept;
// count
size_type count(value_type ch, size_type pos = 0) const noexcept;
public:
// operator+=
basic_string& operator+=(const basic_string& str)
{ return append(str); }
basic_string& operator+=(value_type ch)
{ return append(1, ch); }
basic_string& operator+=(const_pointer str)
{ return append(str, str + char_traits::length(str)); }
// operator >> / operatror <<
friend std::istream& operator >> (std::istream& is, basic_string& str)
{
value_type* buf = new value_type[4096];
is >> buf;
basic_string tmp(buf);
str = std::move(tmp);
delete[]buf;
return is;
}
friend std::ostream& operator << (std::ostream& os, const basic_string& str)
{
for (size_type i = 0; i < str.size_; ++i)
os << *(str.buffer_ + i);
return os;
}
private:
// helper functions
// init / destroy
void try_init() noexcept;
void fill_init(size_type n, value_type ch);
template <class Iter>
void copy_init(Iter first, Iter last, mystl::input_iterator_tag);
template <class Iter>
void copy_init(Iter first, Iter last, mystl::forward_iterator_tag);
void init_from(const_pointer src, size_type pos, size_type n);
void destroy_buffer();
// get raw pointer
const_pointer to_raw_pointer() const;
// shrink_to_fit
void reinsert(size_type size);
// append
template <class Iter>
basic_string& append_range(Iter first, Iter last);
// compare
int compare_cstr(const_pointer s1, size_type n1, const_pointer s2, size_type n2) const;
// replace
basic_string& replace_cstr(const_iterator first, size_type count1, const_pointer str, size_type count2);
basic_string& replace_fill(const_iterator first, size_type count1, size_type count2, value_type ch);
template <class Iter>
basic_string& replace_copy(const_iterator first, const_iterator last, Iter first2, Iter last2);
// reallocate
void reallocate(size_type need);
iterator reallocate_and_fill(iterator pos, size_type n, value_type ch);
iterator reallocate_and_copy(iterator pos, const_iterator first, const_iterator last);
};
/*****************************************************************************************/
//
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>&
basic_string<CharType, CharTraits>::
operator=(const basic_string& rhs)
{
if (this != &rhs)
{
basic_string tmp(rhs);
swap(tmp);
}
return *this;
}
//
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>&
basic_string<CharType, CharTraits>::
operator=(basic_string&& rhs) noexcept
{
destroy_buffer();
buffer_ = rhs.buffer_;
size_ = rhs.size_;
cap_ = rhs.cap_;
rhs.buffer_ = nullptr;
rhs.size_ = 0;
rhs.cap_ = 0;
return *this;
}
//
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>&
basic_string<CharType, CharTraits>::
operator=(const_pointer str)
{
const size_type len = char_traits::length(str);
if (cap_ < len)
{
auto new_buffer = data_allocator::allocate(len + 1);
data_allocator::deallocate(buffer_);
buffer_ = new_buffer;
cap_ = len + 1;
}
char_traits::copy(buffer_, str, len);
size_ = len;
return *this;
}
//
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>&
basic_string<CharType, CharTraits>::
operator=(value_type ch)
{
if (cap_ < 1)
{
auto new_buffer = data_allocator::allocate(2);
data_allocator::deallocate(buffer_);
buffer_ = new_buffer;
cap_ = 2;
}
*buffer_ = ch;
size_ = 1;
return *this;
}
//
template <class CharType, class CharTraits>
void basic_string<CharType, CharTraits>::
reserve(size_type n)
{
if (cap_ < n)
{
THROW_LENGTH_ERROR_IF(n > max_size(), "n can not larger than max_size()"
"in basic_string<Char,Traits>::reserve(n)");
auto new_buffer = data_allocator::allocate(n);
char_traits::move(new_buffer, buffer_, size_);
buffer_ = new_buffer;
cap_ = n;
}
}
//
template <class CharType, class CharTraits>
void basic_string<CharType, CharTraits>::
shrink_to_fit()
{
if (size_ != cap_)
{
reinsert(size_);
}
}
// pos
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::iterator
basic_string<CharType, CharTraits>::
insert(const_iterator pos, value_type ch)
{
iterator r = const_cast<iterator>(pos);
if (size_ == cap_)
{
return reallocate_and_fill(r, 1, ch);
}
char_traits::move(r + 1, r, end() - r);
++size_;
*r = ch;
return r;
}
// pos n
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::iterator
basic_string<CharType, CharTraits>::
insert(const_iterator pos, size_type count, value_type ch)
{
iterator r = const_cast<iterator>(pos);
if (count == 0)
return r;
if (cap_ - size_ < count)
{
return reallocate_and_fill(r, count, ch);
}
if (pos == end())
{
char_traits::fill(end(), ch, count);
size_ += count;
return r;
}
char_traits::move(r + count, r, count);
char_traits::fill(r, ch, count);
size_ += count;
return r;
}
// pos [first, last)
template <class CharType, class CharTraits>
template <class Iter>
typename basic_string<CharType, CharTraits>::iterator
basic_string<CharType, CharTraits>::
insert(const_iterator pos, Iter first, Iter last)
{
iterator r = const_cast<iterator>(pos);
const size_type len = mystl::distance(first, last);
if (len == 0)
return r;
if (cap_ - size_ < len)
{
return reallocate_and_copy(r, first, last);
}
if (pos == end())
{
mystl::uninitialized_copy(first, last, end());
size_ += len;
return r;
}
char_traits::move(r + len, r, len);
mystl::uninitialized_copy(first, last, r);
size_ += len;
return r;
}
// count ch
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>&
basic_string<CharType, CharTraits>::
append(size_type count, value_type ch)
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - count,
"basic_string<Char, Tratis>'s size too big");
if (cap_ - size_ < count)
{
reallocate(count);
}
char_traits::fill(buffer_ + size_, ch, count);
size_ += count;
return *this;
}
// [str[pos] str[pos+count])
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>&
basic_string<CharType, CharTraits>::
append(const basic_string& str, size_type pos, size_type count)
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - count,
"basic_string<Char, Tratis>'s size too big");
if (count == 0)
return *this;
if (cap_ - size_ < count)
{
reallocate(count);
}
char_traits::copy(buffer_ + size_, str.buffer_ + pos, count);
size_ += count;
return *this;
}
// [s, s+count)
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>&
basic_string<CharType, CharTraits>::
append(const_pointer s, size_type count)
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - count,
"basic_string<Char, Tratis>'s size too big");
if (cap_ - size_ < count)
{
reallocate(count);
}
char_traits::copy(buffer_ + size_, s, count);
size_ += count;
return *this;
}
// pos
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::iterator
basic_string<CharType, CharTraits>::
erase(const_iterator pos)
{
MYSTL_DEBUG(pos != end());
iterator r = const_cast<iterator>(pos);
char_traits::move(r, pos + 1, end() - pos - 1);
--size_;
return r;
}
// [first, last)
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::iterator
basic_string<CharType, CharTraits>::
erase(const_iterator first, const_iterator last)
{
if (first == begin() && last == end())
{
clear();
return end();
}
const size_type n = end() - last;
iterator r = const_cast<iterator>(first);
char_traits::move(r, last, n);
size_ -= (last - first);
return r;
}
//
template <class CharType, class CharTraits>
void basic_string<CharType, CharTraits>::
resize(size_type count, value_type ch)
{
if (count < size_)
{
erase(buffer_ + count, buffer_ + size_);
}
else
{
append(count - size_, ch);
}
}
// basic_string -1 1 0
template <class CharType, class CharTraits>
int basic_string<CharType, CharTraits>::
compare(const basic_string& other) const
{
return compare_cstr(buffer_, size_, other.buffer_, other.size_);
}
// pos1 count1 basic_string
template <class CharType, class CharTraits>
int basic_string<CharType, CharTraits>::
compare(size_type pos1, size_type count1, const basic_string& other) const
{
auto n1 = mystl::min(count1, size_ - pos1);
return compare_cstr(buffer_ + pos1, n1, other.buffer_, other.size_);
}
// pos1 count1 basic_string pos2 count2
template <class CharType, class CharTraits>
int basic_string<CharType, CharTraits>::
compare(size_type pos1, size_type count1, const basic_string& other,
size_type pos2, size_type count2) const
{
auto n1 = mystl::min(count1, size_ - pos1);
auto n2 = mystl::min(count2, other.size_ - pos2);
return compare_cstr(buffer_, n1, other.buffer_, n2);
}
//
template <class CharType, class CharTraits>
int basic_string<CharType, CharTraits>::
compare(const_pointer s) const
{
auto n2 = char_traits::length(s);
return compare_cstr(buffer_, size_, s, n2);
}
// pos1 count1
template <class CharType, class CharTraits>
int basic_string<CharType, CharTraits>::
compare(size_type pos1, size_type count1, const_pointer s) const
{
auto n1 = mystl::min(count1, size_ - pos1);
auto n2 = char_traits::length(s);
return compare_cstr(buffer_, n1, s, n2);
}
// pos1 count1 count2
template <class CharType, class CharTraits>
int basic_string<CharType, CharTraits>::
compare(size_type pos1, size_type count1, const_pointer s, size_type count2) const
{
auto n1 = mystl::min(count1, size_ - pos1);
return compare_cstr(buffer_, n1, s, count2);
}
// basic_string
template <class CharType, class CharTraits>
void basic_string<CharType, CharTraits>::
reverse() noexcept
{
for (auto i = begin(), j = end(); i < j;)
{
mystl::iter_swap(i++, --j);
}
}
// basic_string
template <class CharType, class CharTraits>
void basic_string<CharType, CharTraits>::
swap(basic_string& rhs) noexcept
{
if (this != &rhs)
{
mystl::swap(buffer_, rhs.buffer_);
mystl::swap(size_, rhs.size_);
mystl::swap(cap_, rhs.cap_);
}
}
// pos ch npos
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find(value_type ch, size_type pos) const noexcept
{
for (auto i = pos; i < size_; ++i)
{
if (*(buffer_ + i) == ch)
return i;
}
return npos;
}
// pos str npos
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find(const_pointer str, size_type pos) const noexcept
{
const auto len = char_traits::length(str);
if (len == 0)
return pos;
if (size_ - pos < len)
return npos;
const auto left = size_ - len;
for (auto i = pos; i <= left; ++i)
{
if (*(buffer_ + i) == *str)
{
size_type j = 1;
for (; j < len; ++j)
{
if (*(buffer_ + i + j) != *(str + j))
break;
}
if (j == len)
return i;
}
}
return npos;
}
// pos str count npos
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find(const_pointer str, size_type pos, size_type count) const noexcept
{
if (count == 0)
return pos;
if (size_ - pos < count)
return npos;
const auto left = size_ - count;
for (auto i = pos; i <= left; ++i)
{
if (*(buffer_ + i) == *str)
{
size_type j = 1;
for (; j < count; ++j)
{
if (*(buffer_ + i + j) != *(str + j))
break;
}
if (j == count)
return i;
}
}
return npos;
}
// pos str npos
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find(const basic_string& str, size_type pos) const noexcept
{
const size_type count = str.size_;
if (count == 0)
return pos;
if (size_ - pos < count)
return npos;
const auto left = size_ - count;
for (auto i = pos; i <= left; ++i)
{
if (*(buffer_ + i) == str.front())
{
size_type j = 1;
for (; j < count; ++j)
{
if (*(buffer_ + i + j) != str[j])
break;
}
if (j == count)
return i;
}
}
return npos;
}
// pos ch find
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
rfind(value_type ch, size_type pos) const noexcept
{
if (pos >= size_)
pos = size_ - 1;
for (auto i = pos; i != 0; --i)
{
if (*(buffer_ + i) == ch)
return i;
}
return front() == ch ? 0 : npos;
}
// pos str find
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
rfind(const_pointer str, size_type pos) const noexcept
{
if (pos >= size_)
pos = size_ - 1;
const size_type len = char_traits::length(str);
switch (len)
{
case 0:
return pos;
case 1:
{
for (auto i = pos; i != 0; --i)
{
if (*(buffer_ + i) == *str)
return i;
}
return front() == *str ? 0 : npos;
}
default:
{ // len >= 2
for (auto i = pos; i >= len - 1; --i)
{
if (*(buffer_ + i) == *(str + len - 1))
{
size_type j = 1;
for (; j < len; ++j)
{
if (*(buffer_ + i - j) != *(str + len - j - 1))
break;
}
if (j == len)
return i - len + 1;
}
}
break;
}
}
return npos;
}
// pos str count find
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
rfind(const_pointer str, size_type pos, size_type count) const noexcept
{
if (count == 0)
return pos;
if (pos >= size_)
pos = size_ - 1;
if (pos < count - 1)
return npos;
for (auto i = pos; i >= count - 1; --i)
{
if (*(buffer_ + i) == *(str + count - 1))
{
size_type j = 1;
for (; j < count; ++j)
{
if (*(buffer_ + i - j) != *(str + count - j - 1))
break;
}
if (j == count)
return i - count + 1;
}
}
return npos;
}
// pos str find
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
rfind(const basic_string& str, size_type pos) const noexcept
{
const size_type count = str.size_;
if (pos >= size_)
pos = size_ - 1;
if (count == 0)
return pos;
if (pos < count - 1)
return npos;
for (auto i = pos; i >= count - 1; --i)
{
if (*(buffer_ + i) == str[count - 1])
{
size_type j = 1;
for (; j < count; ++j)
{
if (*(buffer_ + i - j) != str[count - j - 1])
break;
}
if (j == count)
return i - count + 1;
}
}
return npos;
}
// pos ch
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_first_of(value_type ch, size_type pos) const noexcept
{
for (auto i = pos; i < size_; ++i)
{
if (*(buffer_ + i) == ch)
return i;
}
return npos;
}
// pos s
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_first_of(const_pointer s, size_type pos) const noexcept
{
const size_type len = char_traits::length(s);
for (auto i = pos; i < size_; ++i)
{
value_type ch = *(buffer_ + i);
for (size_type j = 0; j < len; ++j)
{
if (ch == *(s + j))
return i;
}
}
return npos;
}
// pos s
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_first_of(const_pointer s, size_type pos, size_type count) const noexcept
{
for (auto i = pos; i < size_; ++i)
{
value_type ch = *(buffer_ + i);
for (size_type j = 0; j < count; ++j)
{
if (ch == *(s + j))
return i;
}
}
return npos;
}
// pos str
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_first_of(const basic_string& str, size_type pos) const noexcept
{
for (auto i = pos; i < size_; ++i)
{
value_type ch = *(buffer_ + i);
for (size_type j = 0; j < str.size_; ++j)
{
if (ch == str[j])
return i;
}
}
return npos;
}
// pos ch
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_first_not_of(value_type ch, size_type pos) const noexcept
{
for (auto i = pos; i < size_; ++i)
{
if (*(buffer_ + i) != ch)
return i;
}
return npos;
}
// pos s
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_first_not_of(const_pointer s, size_type pos) const noexcept
{
const size_type len = char_traits::length(s);
for (auto i = pos; i < size_; ++i)
{
value_type ch = *(buffer_ + i);
for (size_type j = 0; j < len; ++j)
{
if (ch != *(s + j))
return i;
}
}
return npos;
}
// pos s count
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_first_not_of(const_pointer s, size_type pos, size_type count) const noexcept
{
for (auto i = pos; i < size_; ++i)
{
value_type ch = *(buffer_ + i);
for (size_type j = 0; j < count; ++j)
{
if (ch != *(s + j))
return i;
}
}
return npos;
}
// pos str
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_first_not_of(const basic_string& str, size_type pos) const noexcept
{
for (auto i = pos; i < size_; ++i)
{
value_type ch = *(buffer_ + i);
for (size_type j = 0; j < str.size_; ++j)
{
if (ch != str[j])
return i;
}
}
return npos;
}
// pos ch
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_last_of(value_type ch, size_type pos) const noexcept
{
for (auto i = size_ - 1; i >= pos; --i)
{
if (*(buffer_ + i) == ch)
return i;
}
return npos;
}
// pos s
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_last_of(const_pointer s, size_type pos) const noexcept
{
const size_type len = char_traits::length(s);
for (auto i = size_ - 1; i >= pos; --i)
{
value_type ch = *(buffer_ + i);
for (size_type j = 0; j < len; ++j)
{
if (ch == *(s + j))
return i;
}
}
return npos;
}
// pos s count
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_last_of(const_pointer s, size_type pos, size_type count) const noexcept
{
for (auto i = size_ - 1; i >= pos; --i)
{
value_type ch = *(buffer_ + i);
for (size_type j = 0; j < count; ++j)
{
if (ch == *(s + j))
return i;
}
}
return npos;
}
// pos str
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_last_of(const basic_string& str, size_type pos) const noexcept
{
for (auto i = size_ - 1; i >= pos; --i)
{
value_type ch = *(buffer_ + i);
for (size_type j = 0; j < str.size_; ++j)
{
if (ch == str[j])
return i;
}
}
return npos;
}
// pos ch
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_last_not_of(value_type ch, size_type pos) const noexcept
{
for (auto i = size_ - 1; i >= pos; --i)
{
if (*(buffer_ + i) != ch)
return i;
}
return npos;
}
// pos s
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_last_not_of(const_pointer s, size_type pos) const noexcept
{
const size_type len = char_traits::length(s);
for (auto i = size_ - 1; i >= pos; --i)
{
value_type ch = *(buffer_ + i);
for (size_type j = 0; j < len; ++j)
{
if (ch != *(s + j))
return i;
}
}
return npos;
}
// pos s count
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_last_not_of(const_pointer s, size_type pos, size_type count) const noexcept
{
for (auto i = size_ - 1; i >= pos; --i)
{
value_type ch = *(buffer_ + i);
for (size_type j = 0; j < count; ++j)
{
if (ch != *(s + j))
return i;
}
}
return npos;
}
// pos str
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
find_last_not_of(const basic_string& str, size_type pos) const noexcept
{
for (auto i = size_ - 1; i >= pos; --i)
{
value_type ch = *(buffer_ + i);
for (size_type j = 0; j < str.size_; ++j)
{
if (ch != str[j])
return i;
}
}
return npos;
}
// pos ch
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::size_type
basic_string<CharType, CharTraits>::
count(value_type ch, size_type pos) const noexcept
{
size_type n = 0;
for (auto i = pos; i < size_; ++i)
{
if (*(buffer_ + i) == ch)
++n;
}
return n;
}
/*****************************************************************************************/
// helper function
// buffer
template <class CharType, class CharTraits>
void basic_string<CharType, CharTraits>::
try_init() noexcept
{
try
{
buffer_ = data_allocator::allocate(static_cast<size_type>(STRING_INIT_SIZE));
size_ = 0;
cap_ = 0;
}
catch (...)
{
buffer_ = nullptr;
size_ = 0;
cap_ = 0;
// no throw
}
}
// fill_init
template <class CharType, class CharTraits>
void basic_string<CharType, CharTraits>::
fill_init(size_type n, value_type ch)
{
const auto init_size = mystl::max(static_cast<size_type>(STRING_INIT_SIZE), n + 1);
buffer_ = data_allocator::allocate(init_size);
char_traits::fill(buffer_, ch, n);
size_ = n;
cap_ = init_size;
}
// copy_init
template <class CharType, class CharTraits>
template <class Iter>
void basic_string<CharType, CharTraits>::
copy_init(Iter first, Iter last, mystl::input_iterator_tag)
{
size_type n = mystl::distance(first, last);
const auto init_size = mystl::max(static_cast<size_type>(STRING_INIT_SIZE), n + 1);
try
{
buffer_ = data_allocator::allocate(init_size);
size_ = n;
cap_ = init_size;
}
catch (...)
{
buffer_ = nullptr;
size_ = 0;
cap_ = 0;
throw;
}
for (; n > 0; --n, ++first)
append(*first);
}
template <class CharType, class CharTraits>
template <class Iter>
void basic_string<CharType, CharTraits>::
copy_init(Iter first, Iter last, mystl::forward_iterator_tag)
{
const size_type n = mystl::distance(first, last);
const auto init_size = mystl::max(static_cast<size_type>(STRING_INIT_SIZE), n + 1);
try
{
buffer_ = data_allocator::allocate(init_size);
size_ = n;
cap_ = init_size;
mystl::uninitialized_copy(first, last, buffer_);
}
catch (...)
{
buffer_ = nullptr;
size_ = 0;
cap_ = 0;
throw;
}
}
// init_from
template <class CharType, class CharTraits>
void basic_string<CharType, CharTraits>::
init_from(const_pointer src, size_type pos, size_type count)
{
const auto init_size = mystl::max(static_cast<size_type>(STRING_INIT_SIZE), count + 1);
buffer_ = data_allocator::allocate(init_size);
char_traits::copy(buffer_, src + pos, count);
size_ = count;
cap_ = init_size;
}
// destroy_buffer
template <class CharType, class CharTraits>
void basic_string<CharType, CharTraits>::
destroy_buffer()
{
if (buffer_ != nullptr)
{
data_allocator::deallocate(buffer_, cap_);
buffer_ = nullptr;
size_ = 0;
cap_ = 0;
}
}
// to_raw_pointer
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::const_pointer
basic_string<CharType, CharTraits>::
to_raw_pointer() const
{
*(buffer_ + size_) = value_type();
return buffer_;
}
// reinsert
template <class CharType, class CharTraits>
void basic_string<CharType, CharTraits>::
reinsert(size_type size)
{
auto new_buffer = data_allocator::allocate(size);
try
{
char_traits::move(new_buffer, buffer_, size);
}
catch (...)
{
data_allocator::deallocate(new_buffer);
}
buffer_ = new_buffer;
size_ = size;
cap_ = size;
}
// append_range [first, last)
template <class CharType, class CharTraits>
template <class Iter>
basic_string<CharType, CharTraits>&
basic_string<CharType, CharTraits>::
append_range(Iter first, Iter last)
{
const size_type n = mystl::distance(first, last);
THROW_LENGTH_ERROR_IF(size_ > max_size() - n,
"basic_string<Char, Tratis>'s size too big");
if (cap_ - size_ < n)
{
reallocate(n);
}
mystl::uninitialized_copy_n(first, n, buffer_ + size_);
size_ += n;
return *this;
}
template <class CharType, class CharTraits>
int basic_string<CharType, CharTraits>::
compare_cstr(const_pointer s1, size_type n1, const_pointer s2, size_type n2) const
{
auto rlen = mystl::min(n1, n2);
auto res = char_traits::compare(s1, s2, rlen);
if (res != 0) return res;
if (n1 < n2) return -1;
if (n1 > n2) return 1;
return 0;
}
// first count1 str count2
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>&
basic_string<CharType, CharTraits>::
replace_cstr(const_iterator first, size_type count1, const_pointer str, size_type count2)
{
if (static_cast<size_type>(cend() - first) < count1)
{
count1 = cend() - first;
}
if (count1 < count2)
{
const size_type add = count2 - count1;
THROW_LENGTH_ERROR_IF(size_ > max_size() - add,
"basic_string<Char, Traits>'s size too big");
if (size_ > cap_ - add)
{
reallocate(add);
}
pointer r = const_cast<pointer>(first);
char_traits::move(r + count2, first + count1, end() - (first + count1));
char_traits::copy(r, str, count2);
size_ += add;
}
else
{
pointer r = const_cast<pointer>(first);
char_traits::move(r + count2, first + count1, end() - (first + count1));
char_traits::copy(r, str, count2);
size_ -= (count1 - count2);
}
return *this;
}
// first count1 count2 ch
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>&
basic_string<CharType, CharTraits>::
replace_fill(const_iterator first, size_type count1, size_type count2, value_type ch)
{
if (static_cast<size_type>(cend() - first) < count1)
{
count1 = cend() - first;
}
if (count1 < count2)
{
const size_type add = count2 - count1;
THROW_LENGTH_ERROR_IF(size_ > max_size() - add,
"basic_string<Char, Traits>'s size too big");
if (size_ > cap_ - add)
{
reallocate(add);
}
pointer r = const_cast<pointer>(first);
char_traits::move(r + count2, first + count1, end() - (first + count1));
char_traits::fill(r, ch, count2);
size_ += add;
}
else
{
pointer r = const_cast<pointer>(first);
char_traits::move(r + count2, first + count1, end() - (first + count1));
char_traits::fill(r, ch, count2);
size_ -= (count1 - count2);
}
return *this;
}
// [first, last) [first2, last2)
template <class CharType, class CharTraits>
template <class Iter>
basic_string<CharType, CharTraits>&
basic_string<CharType, CharTraits>::
replace_copy(const_iterator first, const_iterator last, Iter first2, Iter last2)
{
size_type len1 = last - first;
size_type len2 = last2 - first2;
if (len1 < len2)
{
const size_type add = len2 - len1;
THROW_LENGTH_ERROR_IF(size_ > max_size() - add,
"basic_string<Char, Traits>'s size too big");
if (size_ > cap_ - add)
{
reallocate(add);
}
pointer r = const_cast<pointer>(first);
char_traits::move(r + len2, first + len1, end() - (first + len1));
char_traits::copy(r, first2, len2);
size_ += add;
}
else
{
pointer r = const_cast<pointer>(first);
char_traits::move(r + len2, first + len1, end() - (first + len1));
char_traits::copy(r, first2, len2);
size_ -= (len1 - len2);
}
return *this;
}
// reallocate
template <class CharType, class CharTraits>
void basic_string<CharType, CharTraits>::
reallocate(size_type need)
{
const auto new_cap = mystl::max(cap_ + need, cap_ + (cap_ >> 1));
auto new_buffer = data_allocator::allocate(new_cap);
char_traits::move(new_buffer, buffer_, size_);
data_allocator::deallocate(buffer_);
buffer_ = new_buffer;
cap_ = new_cap;
}
// reallocate_and_fill
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::iterator
basic_string<CharType, CharTraits>::
reallocate_and_fill(iterator pos, size_type n, value_type ch)
{
const auto r = pos - buffer_;
const auto old_cap = cap_;
const auto new_cap = mystl::max(old_cap + n, old_cap + (old_cap >> 1));
auto new_buffer = data_allocator::allocate(new_cap);
auto e1 = char_traits::move(new_buffer, buffer_, r) + r;
auto e2 = char_traits::fill(e1, ch, n) + n;
char_traits::move(e2, buffer_ + r, size_ - r);
data_allocator::deallocate(buffer_, old_cap);
buffer_ = new_buffer;
size_ += n;
cap_ = new_cap;
return buffer_ + r;
}
// reallocate_and_copy
template <class CharType, class CharTraits>
typename basic_string<CharType, CharTraits>::iterator
basic_string<CharType, CharTraits>::
reallocate_and_copy(iterator pos, const_iterator first, const_iterator last)
{
const auto r = pos - buffer_;
const auto old_cap = cap_;
const size_type n = mystl::distance(first, last);
const auto new_cap = mystl::max(old_cap + n, old_cap + (old_cap >> 1));
auto new_buffer = data_allocator::allocate(new_cap);
auto e1 = char_traits::move(new_buffer, buffer_, r) + r;
auto e2 = mystl::uninitialized_copy_n(first, n, e1) + n;
char_traits::move(e2, buffer_ + r, size_ - r);
data_allocator::deallocate(buffer_, old_cap);
buffer_ = new_buffer;
size_ += n;
cap_ = new_cap;
return buffer_ + r;
}
/*****************************************************************************************/
//
// operator+
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>
operator+(const basic_string<CharType, CharTraits>& lhs,
const basic_string<CharType, CharTraits>& rhs)
{
basic_string<CharType, CharTraits> tmp(lhs);
tmp.append(rhs);
return tmp;
}
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>
operator+(const CharType* lhs, const basic_string<CharType, CharTraits>& rhs)
{
basic_string<CharType, CharTraits> tmp(lhs);
tmp.append(rhs);
return tmp;
}
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>
operator+(CharType ch, const basic_string<CharType, CharTraits>& rhs)
{
basic_string<CharType, CharTraits> tmp(1, ch);
tmp.append(rhs);
return tmp;
}
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>
operator+(const basic_string<CharType, CharTraits>& lhs, const CharType* rhs)
{
basic_string<CharType, CharTraits> tmp(lhs);
tmp.append(rhs);
return tmp;
}
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>
operator+(const basic_string<CharType, CharTraits>& lhs, CharType ch)
{
basic_string<CharType, CharTraits> tmp(lhs);
tmp.append(1, ch);
return tmp;
}
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>
operator+(basic_string<CharType, CharTraits>&& lhs,
const basic_string<CharType, CharTraits>& rhs)
{
basic_string<CharType, CharTraits> tmp(mystl::move(lhs));
tmp.append(rhs);
return tmp;
}
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>
operator+(const basic_string<CharType, CharTraits>& lhs,
basic_string<CharType, CharTraits>&& rhs)
{
basic_string<CharType, CharTraits> tmp(mystl::move(rhs));
tmp.insert(tmp.begin(), lhs.begin(), lhs.end());
return tmp;
}
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>
operator+(basic_string<CharType, CharTraits>&& lhs,
basic_string<CharType, CharTraits>&& rhs)
{
basic_string<CharType, CharTraits> tmp(mystl::move(lhs));
tmp.append(rhs);
return tmp;
}
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>
operator+(const CharType* lhs, basic_string<CharType, CharTraits>&& rhs)
{
basic_string<CharType, CharTraits> tmp(mystl::move(rhs));
tmp.insert(tmp.begin(), lhs, lhs + char_traits<CharType>::length(lhs));
return tmp;
}
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>
operator+(CharType ch, basic_string<CharType, CharTraits>&& rhs)
{
basic_string<CharType, CharTraits> tmp(mystl::move(rhs));
tmp.insert(tmp.begin(), ch);
return tmp;
}
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>
operator+(basic_string<CharType, CharTraits>&& lhs, const CharType* rhs)
{
basic_string<CharType, CharTraits> tmp(mystl::move(lhs));
tmp.append(rhs);
return tmp;
}
template <class CharType, class CharTraits>
basic_string<CharType, CharTraits>
operator+(basic_string<CharType, CharTraits>&& lhs, CharType ch)
{
basic_string<CharType, CharTraits> tmp(mystl::move(lhs));
tmp.append(1, ch);
return tmp;
}
//
template <class CharType, class CharTraits>
bool operator==(const basic_string<CharType, CharTraits>& lhs,
const basic_string<CharType, CharTraits>& rhs)
{
return lhs.size() == rhs.size() && lhs.compare(rhs) == 0;
}
template <class CharType, class CharTraits>
bool operator!=(const basic_string<CharType, CharTraits>& lhs,
const basic_string<CharType, CharTraits>& rhs)
{
return lhs.size() != rhs.size() || lhs.compare(rhs) != 0;
}
template <class CharType, class CharTraits>
bool operator<(const basic_string<CharType, CharTraits>& lhs,
const basic_string<CharType, CharTraits>& rhs)
{
return lhs.compare(rhs) < 0;
}
template <class CharType, class CharTraits>
bool operator<=(const basic_string<CharType, CharTraits>& lhs,
const basic_string<CharType, CharTraits>& rhs)
{
return lhs.compare(rhs) <= 0;
}
template <class CharType, class CharTraits>
bool operator>(const basic_string<CharType, CharTraits>& lhs,
const basic_string<CharType, CharTraits>& rhs)
{
return lhs.compare(rhs) > 0;
}
template <class CharType, class CharTraits>
bool operator>=(const basic_string<CharType, CharTraits>& lhs,
const basic_string<CharType, CharTraits>& rhs)
{
return lhs.compare(rhs) >= 0;
}
// mystl swap
template <class CharType, class CharTraits>
void swap(basic_string<CharType, CharTraits>& lhs,
basic_string<CharType, CharTraits>& rhs) noexcept
{
lhs.swap(rhs);
}
// mystl::hash
template <class CharType, class CharTraits>
struct hash<basic_string<CharType, CharTraits>>
{
size_t operator()(const basic_string<CharType, CharTraits>& str)
{
return bitwise_hash((const unsigned char*)str.c_str(),
str.size() * sizeof(CharType));
}
};
} // namespace mystl
#endif // !MYTINYSTL_BASIC_STRING_H_
``` | /content/code_sandbox/MyTinySTL/basic_string.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 15,400 |
```objective-c
#ifndef MYTINYSTL_ALLOC_H_
#define MYTINYSTL_ALLOC_H_
// alloc
//
// v2.0.0
//
//
//
// issuefree_list
//
// C++
//
#include <new>
#include <cstddef>
#include <cstdio>
namespace mystl
{
// : FreeList
// <=4K
union FreeList
{
union FreeList* next; //
char data[1]; //
};
//
enum
{
EAlign128 = 8,
EAlign256 = 16,
EAlign512 = 32,
EAlign1024 = 64,
EAlign2048 = 128,
EAlign4096 = 256
};
//
enum { ESmallObjectBytes = 4096 };
// free lists
enum { EFreeListsNumber = 56 };
// alloc
// 4096 bytes std::malloc, std::free
//
class alloc
{
private:
static char* start_free; //
static char* end_free; //
static size_t heap_size; // heap
static FreeList* free_list[EFreeListsNumber]; //
public:
static void* allocate(size_t n);
static void deallocate(void* p, size_t n);
static void* reallocate(void* p, size_t old_size, size_t new_size);
private:
static size_t M_align(size_t bytes);
static size_t M_round_up(size_t bytes);
static size_t M_freelist_index(size_t bytes);
static void* M_refill(size_t n);
static char* M_chunk_alloc(size_t size, size_t &nobj);
};
//
char* alloc::start_free = nullptr;
char* alloc::end_free = nullptr;
size_t alloc::heap_size = 0;
FreeList* alloc::free_list[EFreeListsNumber] = {
nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,
nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,
nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,
nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,
nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,
nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,
nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr
};
// n n > 0
inline void* alloc::allocate(size_t n)
{
FreeList* my_free_list;
FreeList* result;
if (n > static_cast<size_t>(ESmallObjectBytes))
return std::malloc(n);
my_free_list = free_list[M_freelist_index(n)];
result = my_free_list;
if (result == nullptr)
{
void* r = M_refill(M_round_up(n));
return r;
}
my_free_list = result->next;
return result;
}
// p n , p 0
inline void alloc::deallocate(void* p, size_t n)
{
if (n > static_cast<size_t>(ESmallObjectBytes))
{
std::free(p);
return;
}
FreeList* q = reinterpret_cast<FreeList*>(p);
FreeList* my_free_list;
my_free_list = free_list[M_freelist_index(n)];
q->next = my_free_list;
my_free_list = q;
}
//
inline void* alloc::reallocate(void* p, size_t old_size, size_t new_size)
{
deallocate(p, old_size);
p = allocate(new_size);
return p;
}
// bytes
inline size_t alloc::M_align(size_t bytes)
{
if (bytes <= 512)
{
return bytes <= 256
? bytes <= 128 ? EAlign128 : EAlign256
: EAlign512;
}
return bytes <= 2048
? bytes <= 1024 ? EAlign1024 : EAlign2048
: EAlign4096;
}
// bytes
inline size_t alloc::M_round_up(size_t bytes)
{
return ((bytes + M_align(bytes) - 1) & ~(M_align(bytes) - 1));
}
// n free lists
inline size_t alloc::M_freelist_index(size_t bytes)
{
if (bytes <= 512)
{
return bytes <= 256
? bytes <= 128
? ((bytes + EAlign128 - 1) / EAlign128 - 1)
: (15 + (bytes + EAlign256 - 129) / EAlign256)
: (23 + (bytes + EAlign512 - 257) / EAlign512);
}
return bytes <= 2048
? bytes <= 1024
? (31 + (bytes + EAlign1024 - 513) / EAlign1024)
: (39 + (bytes + EAlign2048 - 1025) / EAlign2048)
: (47 + (bytes + EAlign4096 - 2049) / EAlign4096);
}
// free list
void* alloc::M_refill(size_t n)
{
size_t nblock = 10;
char* c = M_chunk_alloc(n, nblock);
FreeList* my_free_list;
FreeList* result, *cur, *next;
// free list
if (nblock == 1)
return c;
// free list
my_free_list = free_list[M_freelist_index(n)];
result = (FreeList*)c;
my_free_list = next = (FreeList*)(c + n);
for (size_t i = 1; ; ++i)
{
cur = next;
next = (FreeList*)((char*)next + n);
if (nblock - 1 == i)
{
cur->next = nullptr;
break;
}
else
{
cur->next = next;
}
}
return result;
}
// free list nblock
char* alloc::M_chunk_alloc(size_t size, size_t& nblock)
{
char* result;
size_t need_bytes = size * nblock;
size_t pool_bytes = end_free - start_free;
//
if (pool_bytes >= need_bytes)
{
result = start_free;
start_free += need_bytes;
return result;
}
//
else if (pool_bytes >= size)
{
nblock = pool_bytes / size;
need_bytes = size * nblock;
result = start_free;
start_free += need_bytes;
return result;
}
//
else
{
if (pool_bytes > 0)
{ // free list
FreeList* my_free_list = free_list[M_freelist_index(pool_bytes)];
((FreeList*)start_free)->next = my_free_list;
my_free_list = (FreeList*)start_free;
}
// heap
size_t bytes_to_get = (need_bytes << 1) + M_round_up(heap_size >> 4);
start_free = (char*)std::malloc(bytes_to_get);
if (!start_free)
{ // heap
FreeList* my_free_list, *p;
// free list
for (size_t i = size; i <= ESmallObjectBytes; i += M_align(i))
{
my_free_list = free_list[M_freelist_index(i)];
p = my_free_list;
if (p)
{
my_free_list = p->next;
start_free = (char*)p;
end_free = start_free + i;
return M_chunk_alloc(size, nblock);
}
}
std::printf("out of memory");
end_free = nullptr;
throw std::bad_alloc();
}
end_free = start_free + bytes_to_get;
heap_size += bytes_to_get;
return M_chunk_alloc(size, nblock);
}
}
} // namespace mystl
#endif // !MYTINYSTL_ALLOC_H_
``` | /content/code_sandbox/MyTinySTL/alloc.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 1,777 |
```objective-c
#ifndef MYTINYSTL_MEMORY_H_
#define MYTINYSTL_MEMORY_H_
//
// auto_ptr
#include <cstddef>
#include <cstdlib>
#include <climits>
#include "algobase.h"
#include "allocator.h"
#include "construct.h"
#include "uninitialized.h"
namespace mystl
{
//
template <class Tp>
constexpr Tp* address_of(Tp& value) noexcept
{
return &value;
}
// /
template <class T>
pair<T*, ptrdiff_t> get_buffer_helper(ptrdiff_t len, T*)
{
if (len > static_cast<ptrdiff_t>(INT_MAX / sizeof(T)))
len = INT_MAX / sizeof(T);
while (len > 0)
{
T* tmp = static_cast<T*>(malloc(static_cast<size_t>(len) * sizeof(T)));
if (tmp)
return pair<T*, ptrdiff_t>(tmp, len);
len /= 2; // len
}
return pair<T*, ptrdiff_t>(nullptr, 0);
}
template <class T>
pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t len)
{
return get_buffer_helper(len, static_cast<T*>(0));
}
template <class T>
pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t len, T*)
{
return get_buffer_helper(len, static_cast<T*>(0));
}
template <class T>
void release_temporary_buffer(T* ptr)
{
free(ptr);
}
// your_sha256_hash----------------------
// : temporary_buffer
//
template <class ForwardIterator, class T>
class temporary_buffer
{
private:
ptrdiff_t original_len; //
ptrdiff_t len; //
T* buffer; //
public:
//
temporary_buffer(ForwardIterator first, ForwardIterator last);
~temporary_buffer()
{
mystl::destroy(buffer, buffer + len);
free(buffer);
}
public:
ptrdiff_t size() const noexcept { return len; }
ptrdiff_t requested_size() const noexcept { return original_len; }
T* begin() noexcept { return buffer; }
T* end() noexcept { return buffer + len; }
private:
void allocate_buffer();
void initialize_buffer(const T&, std::true_type) {}
void initialize_buffer(const T& value, std::false_type)
{ mystl::uninitialized_fill_n(buffer, len, value); }
private:
temporary_buffer(const temporary_buffer&);
void operator=(const temporary_buffer&);
};
//
template <class ForwardIterator, class T>
temporary_buffer<ForwardIterator, T>::
temporary_buffer(ForwardIterator first, ForwardIterator last)
{
try
{
len = mystl::distance(first, last);
allocate_buffer();
if (len > 0)
{
initialize_buffer(*first, std::is_trivially_default_constructible<T>());
}
}
catch (...)
{
free(buffer);
buffer = nullptr;
len = 0;
}
}
// allocate_buffer
template <class ForwardIterator, class T>
void temporary_buffer<ForwardIterator, T>::allocate_buffer()
{
original_len = len;
if (len > static_cast<ptrdiff_t>(INT_MAX / sizeof(T)))
len = INT_MAX / sizeof(T);
while (len > 0)
{
buffer = static_cast<T*>(malloc(len * sizeof(T)));
if (buffer)
break;
len /= 2; //
}
}
// your_sha256_hash----------------------
// : auto_ptr
//
template <class T>
class auto_ptr
{
public:
typedef T elem_type;
private:
T* m_ptr; //
public:
//
explicit auto_ptr(T* p = nullptr) :m_ptr(p) {}
auto_ptr(auto_ptr& rhs) :m_ptr(rhs.release()) {}
template <class U>
auto_ptr(auto_ptr<U>& rhs) : m_ptr(rhs.release()) {}
auto_ptr& operator=(auto_ptr& rhs)
{
if (this != &rhs)
{
delete m_ptr;
m_ptr = rhs.release();
}
return *this;
}
template <class U>
auto_ptr& operator=(auto_ptr<U>& rhs)
{
if (this->get() != rhs.get())
{
delete m_ptr;
m_ptr = rhs.release();
}
return *this;
}
~auto_ptr() { delete m_ptr; }
public:
// operator* operator->
T& operator*() const { return *m_ptr; }
T* operator->() const { return m_ptr; }
//
T* get() const { return m_ptr; }
//
T* release()
{
T* tmp = m_ptr;
m_ptr = nullptr;
return tmp;
}
//
void reset(T* p = nullptr)
{
if (m_ptr != p)
{
delete m_ptr;
m_ptr = p;
}
}
};
} // namespace mystl
#endif // !MYTINYSTL_MEMORY_H_
``` | /content/code_sandbox/MyTinySTL/memory.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 1,106 |
```objective-c
#ifndef MYTINYSTL_VECTOR_H_
#define MYTINYSTL_VECTOR_H_
// vector
// vector :
// notes:
//
//
// mystl::vecotr<T>
// * emplace
// * emplace_back
// * push_back
// std::is_nothrow_move_assignable<T>::value == true
// * reserve
// * resize
// * insert
#include <initializer_list>
#include "iterator.h"
#include "memory.h"
#include "util.h"
#include "exceptdef.h"
#include "algo.h"
namespace mystl
{
#ifdef max
#pragma message("#undefing marco max")
#undef max
#endif // max
#ifdef min
#pragma message("#undefing marco min")
#undef min
#endif // min
// : vector
// T
template <class T>
class vector
{
static_assert(!std::is_same<bool, T>::value, "vector<bool> is abandoned in mystl");
public:
// vector
typedef mystl::allocator<T> allocator_type;
typedef mystl::allocator<T> data_allocator;
typedef typename allocator_type::value_type value_type;
typedef typename allocator_type::pointer pointer;
typedef typename allocator_type::const_pointer const_pointer;
typedef typename allocator_type::reference reference;
typedef typename allocator_type::const_reference const_reference;
typedef typename allocator_type::size_type size_type;
typedef typename allocator_type::difference_type difference_type;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef mystl::reverse_iterator<iterator> reverse_iterator;
typedef mystl::reverse_iterator<const_iterator> const_reverse_iterator;
allocator_type get_allocator() { return data_allocator(); }
private:
iterator begin_; //
iterator end_; //
iterator cap_; //
public:
//
vector() noexcept
{ try_init(); }
explicit vector(size_type n)
{ fill_init(n, value_type()); }
vector(size_type n, const value_type& value)
{ fill_init(n, value); }
template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::value, int>::type = 0>
vector(Iter first, Iter last)
{
MYSTL_DEBUG(!(last < first));
range_init(first, last);
}
vector(const vector& rhs)
{
range_init(rhs.begin_, rhs.end_);
}
vector(vector&& rhs) noexcept
:begin_(rhs.begin_),
end_(rhs.end_),
cap_(rhs.cap_)
{
rhs.begin_ = nullptr;
rhs.end_ = nullptr;
rhs.cap_ = nullptr;
}
vector(std::initializer_list<value_type> ilist)
{
range_init(ilist.begin(), ilist.end());
}
vector& operator=(const vector& rhs);
vector& operator=(vector&& rhs) noexcept;
vector& operator=(std::initializer_list<value_type> ilist)
{
vector tmp(ilist.begin(), ilist.end());
swap(tmp);
return *this;
}
~vector()
{
destroy_and_recover(begin_, end_, cap_ - begin_);
begin_ = end_ = cap_ = nullptr;
}
public:
//
iterator begin() noexcept
{ return begin_; }
const_iterator begin() const noexcept
{ return begin_; }
iterator end() noexcept
{ return end_; }
const_iterator end() const noexcept
{ return end_; }
reverse_iterator rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator cbegin() const noexcept
{ return begin(); }
const_iterator cend() const noexcept
{ return end(); }
const_reverse_iterator crbegin() const noexcept
{ return rbegin(); }
const_reverse_iterator crend() const noexcept
{ return rend(); }
//
bool empty() const noexcept
{ return begin_ == end_; }
size_type size() const noexcept
{ return static_cast<size_type>(end_ - begin_); }
size_type max_size() const noexcept
{ return static_cast<size_type>(-1) / sizeof(T); }
size_type capacity() const noexcept
{ return static_cast<size_type>(cap_ - begin_); }
void reserve(size_type n);
void shrink_to_fit();
//
reference operator[](size_type n)
{
MYSTL_DEBUG(n < size());
return *(begin_ + n);
}
const_reference operator[](size_type n) const
{
MYSTL_DEBUG(n < size());
return *(begin_ + n);
}
reference at(size_type n)
{
THROW_OUT_OF_RANGE_IF(!(n < size()), "vector<T>::at() subscript out of range");
return (*this)[n];
}
const_reference at(size_type n) const
{
THROW_OUT_OF_RANGE_IF(!(n < size()), "vector<T>::at() subscript out of range");
return (*this)[n];
}
reference front()
{
MYSTL_DEBUG(!empty());
return *begin_;
}
const_reference front() const
{
MYSTL_DEBUG(!empty());
return *begin_;
}
reference back()
{
MYSTL_DEBUG(!empty());
return *(end_ - 1);
}
const_reference back() const
{
MYSTL_DEBUG(!empty());
return *(end_ - 1);
}
pointer data() noexcept { return begin_; }
const_pointer data() const noexcept { return begin_; }
//
// assign
void assign(size_type n, const value_type& value)
{ fill_assign(n, value); }
template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::value, int>::type = 0>
void assign(Iter first, Iter last)
{
MYSTL_DEBUG(!(last < first));
copy_assign(first, last, iterator_category(first));
}
void assign(std::initializer_list<value_type> il)
{ copy_assign(il.begin(), il.end(), mystl::forward_iterator_tag{}); }
// emplace / emplace_back
template <class... Args>
iterator emplace(const_iterator pos, Args&& ...args);
template <class... Args>
void emplace_back(Args&& ...args);
// push_back / pop_back
void push_back(const value_type& value);
void push_back(value_type&& value)
{ emplace_back(mystl::move(value)); }
void pop_back();
// insert
iterator insert(const_iterator pos, const value_type& value);
iterator insert(const_iterator pos, value_type&& value)
{ return emplace(pos, mystl::move(value)); }
iterator insert(const_iterator pos, size_type n, const value_type& value)
{
MYSTL_DEBUG(pos >= begin() && pos <= end());
return fill_insert(const_cast<iterator>(pos), n, value);
}
template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::value, int>::type = 0>
void insert(const_iterator pos, Iter first, Iter last)
{
MYSTL_DEBUG(pos >= begin() && pos <= end() && !(last < first));
copy_insert(const_cast<iterator>(pos), first, last);
}
// erase / clear
iterator erase(const_iterator pos);
iterator erase(const_iterator first, const_iterator last);
void clear() { erase(begin(), end()); }
// resize / reverse
void resize(size_type new_size) { return resize(new_size, value_type()); }
void resize(size_type new_size, const value_type& value);
void reverse() { mystl::reverse(begin(), end()); }
// swap
void swap(vector& rhs) noexcept;
private:
// helper functions
// initialize / destroy
void try_init() noexcept;
void init_space(size_type size, size_type cap);
void fill_init(size_type n, const value_type& value);
template <class Iter>
void range_init(Iter first, Iter last);
void destroy_and_recover(iterator first, iterator last, size_type n);
// calculate the growth size
size_type get_new_cap(size_type add_size);
// assign
void fill_assign(size_type n, const value_type& value);
template <class IIter>
void copy_assign(IIter first, IIter last, input_iterator_tag);
template <class FIter>
void copy_assign(FIter first, FIter last, forward_iterator_tag);
// reallocate
template <class... Args>
void reallocate_emplace(iterator pos, Args&& ...args);
void reallocate_insert(iterator pos, const value_type& value);
// insert
iterator fill_insert(iterator pos, size_type n, const value_type& value);
template <class IIter>
void copy_insert(iterator pos, IIter first, IIter last);
// shrink_to_fit
void reinsert(size_type size);
};
/*****************************************************************************************/
//
template <class T>
vector<T>& vector<T>::operator=(const vector& rhs)
{
if (this != &rhs)
{
const auto len = rhs.size();
if (len > capacity())
{
vector tmp(rhs.begin(), rhs.end());
swap(tmp);
}
else if (size() >= len)
{
auto i = mystl::copy(rhs.begin(), rhs.end(), begin());
data_allocator::destroy(i, end_);
end_ = begin_ + len;
}
else
{
mystl::copy(rhs.begin(), rhs.begin() + size(), begin_);
mystl::uninitialized_copy(rhs.begin() + size(), rhs.end(), end_);
cap_ = end_ = begin_ + len;
}
}
return *this;
}
//
template <class T>
vector<T>& vector<T>::operator=(vector&& rhs) noexcept
{
destroy_and_recover(begin_, end_, cap_ - begin_);
begin_ = rhs.begin_;
end_ = rhs.end_;
cap_ = rhs.cap_;
rhs.begin_ = nullptr;
rhs.end_ = nullptr;
rhs.cap_ = nullptr;
return *this;
}
//
template <class T>
void vector<T>::reserve(size_type n)
{
if (capacity() < n)
{
THROW_LENGTH_ERROR_IF(n > max_size(),
"n can not larger than max_size() in vector<T>::reserve(n)");
const auto old_size = size();
auto tmp = data_allocator::allocate(n);
mystl::uninitialized_move(begin_, end_, tmp);
data_allocator::deallocate(begin_, cap_ - begin_);
begin_ = tmp;
end_ = tmp + old_size;
cap_ = begin_ + n;
}
}
//
template <class T>
void vector<T>::shrink_to_fit()
{
if (end_ < cap_)
{
reinsert(size());
}
}
// pos
template <class T>
template <class ...Args>
typename vector<T>::iterator
vector<T>::emplace(const_iterator pos, Args&& ...args)
{
MYSTL_DEBUG(pos >= begin() && pos <= end());
iterator xpos = const_cast<iterator>(pos);
const size_type n = xpos - begin_;
if (end_ != cap_ && xpos == end_)
{
data_allocator::construct(mystl::address_of(*end_), mystl::forward<Args>(args)...);
++end_;
}
else if (end_ != cap_)
{
auto new_end = end_;
data_allocator::construct(mystl::address_of(*end_), *(end_ - 1));
++new_end;
mystl::copy_backward(xpos, end_ - 1, end_);
*xpos = value_type(mystl::forward<Args>(args)...);
end_ = new_end;
}
else
{
reallocate_emplace(xpos, mystl::forward<Args>(args)...);
}
return begin() + n;
}
//
template <class T>
template <class ...Args>
void vector<T>::emplace_back(Args&& ...args)
{
if (end_ < cap_)
{
data_allocator::construct(mystl::address_of(*end_), mystl::forward<Args>(args)...);
++end_;
}
else
{
reallocate_emplace(end_, mystl::forward<Args>(args)...);
}
}
//
template <class T>
void vector<T>::push_back(const value_type& value)
{
if (end_ != cap_)
{
data_allocator::construct(mystl::address_of(*end_), value);
++end_;
}
else
{
reallocate_insert(end_, value);
}
}
//
template <class T>
void vector<T>::pop_back()
{
MYSTL_DEBUG(!empty());
data_allocator::destroy(end_ - 1);
--end_;
}
// pos
template <class T>
typename vector<T>::iterator
vector<T>::insert(const_iterator pos, const value_type& value)
{
MYSTL_DEBUG(pos >= begin() && pos <= end());
iterator xpos = const_cast<iterator>(pos);
const size_type n = pos - begin_;
if (end_ != cap_ && xpos == end_)
{
data_allocator::construct(mystl::address_of(*end_), value);
++end_;
}
else if (end_ != cap_)
{
auto new_end = end_;
data_allocator::construct(mystl::address_of(*end_), *(end_ - 1));
++new_end;
auto value_copy = value; //
mystl::copy_backward(xpos, end_ - 1, end_);
*xpos = mystl::move(value_copy);
end_ = new_end;
}
else
{
reallocate_insert(xpos, value);
}
return begin_ + n;
}
// pos
template <class T>
typename vector<T>::iterator
vector<T>::erase(const_iterator pos)
{
MYSTL_DEBUG(pos >= begin() && pos < end());
iterator xpos = begin_ + (pos - begin());
mystl::move(xpos + 1, end_, xpos);
data_allocator::destroy(end_ - 1);
--end_;
return xpos;
}
// [first, last)
template <class T>
typename vector<T>::iterator
vector<T>::erase(const_iterator first, const_iterator last)
{
MYSTL_DEBUG(first >= begin() && last <= end() && !(last < first));
const auto n = first - begin();
iterator r = begin_ + (first - begin());
data_allocator::destroy(mystl::move(r + (last - first), end_, r), end_);
end_ = end_ - (last - first);
return begin_ + n;
}
//
template <class T>
void vector<T>::resize(size_type new_size, const value_type& value)
{
if (new_size < size())
{
erase(begin() + new_size, end());
}
else
{
insert(end(), new_size - size(), value);
}
}
// vector
template <class T>
void vector<T>::swap(vector<T>& rhs) noexcept
{
if (this != &rhs)
{
mystl::swap(begin_, rhs.begin_);
mystl::swap(end_, rhs.end_);
mystl::swap(cap_, rhs.cap_);
}
}
/*****************************************************************************************/
// helper function
// try_init
template <class T>
void vector<T>::try_init() noexcept
{
try
{
begin_ = data_allocator::allocate(16);
end_ = begin_;
cap_ = begin_ + 16;
}
catch (...)
{
begin_ = nullptr;
end_ = nullptr;
cap_ = nullptr;
}
}
// init_space
template <class T>
void vector<T>::init_space(size_type size, size_type cap)
{
try
{
begin_ = data_allocator::allocate(cap);
end_ = begin_ + size;
cap_ = begin_ + cap;
}
catch (...)
{
begin_ = nullptr;
end_ = nullptr;
cap_ = nullptr;
throw;
}
}
// fill_init
template <class T>
void vector<T>::
fill_init(size_type n, const value_type& value)
{
const size_type init_size = mystl::max(static_cast<size_type>(16), n);
init_space(n, init_size);
mystl::uninitialized_fill_n(begin_, n, value);
}
// range_init
template <class T>
template <class Iter>
void vector<T>::
range_init(Iter first, Iter last)
{
const size_type len = mystl::distance(first, last);
const size_type init_size = mystl::max(len, static_cast<size_type>(16));
init_space(len, init_size);
mystl::uninitialized_copy(first, last, begin_);
}
// destroy_and_recover
template <class T>
void vector<T>::
destroy_and_recover(iterator first, iterator last, size_type n)
{
data_allocator::destroy(first, last);
data_allocator::deallocate(first, n);
}
// get_new_cap
template <class T>
typename vector<T>::size_type
vector<T>::
get_new_cap(size_type add_size)
{
const auto old_size = capacity();
THROW_LENGTH_ERROR_IF(old_size > max_size() - add_size,
"vector<T>'s size too big");
if (old_size > max_size() - old_size / 2)
{
return old_size + add_size > max_size() - 16
? old_size + add_size : old_size + add_size + 16;
}
const size_type new_size = old_size == 0
? mystl::max(add_size, static_cast<size_type>(16))
: mystl::max(old_size + old_size / 2, old_size + add_size);
return new_size;
}
// fill_assign
template <class T>
void vector<T>::
fill_assign(size_type n, const value_type& value)
{
if (n > capacity())
{
vector tmp(n, value);
swap(tmp);
}
else if (n > size())
{
mystl::fill(begin(), end(), value);
end_ = mystl::uninitialized_fill_n(end_, n - size(), value);
}
else
{
erase(mystl::fill_n(begin_, n, value), end_);
}
}
// copy_assign
template <class T>
template <class IIter>
void vector<T>::
copy_assign(IIter first, IIter last, input_iterator_tag)
{
auto cur = begin_;
for (; first != last && cur != end_; ++first, ++cur)
{
*cur = *first;
}
if (first == last)
{
erase(cur, end_);
}
else
{
insert(end_, first, last);
}
}
// [first, last)
template <class T>
template <class FIter>
void vector<T>::
copy_assign(FIter first, FIter last, forward_iterator_tag)
{
const size_type len = mystl::distance(first, last);
if (len > capacity())
{
vector tmp(first, last);
swap(tmp);
}
else if (size() >= len)
{
auto new_end = mystl::copy(first, last, begin_);
data_allocator::destroy(new_end, end_);
end_ = new_end;
}
else
{
auto mid = first;
mystl::advance(mid, size());
mystl::copy(first, mid, begin_);
auto new_end = mystl::uninitialized_copy(mid, last, end_);
end_ = new_end;
}
}
// pos
template <class T>
template <class ...Args>
void vector<T>::
reallocate_emplace(iterator pos, Args&& ...args)
{
const auto new_size = get_new_cap(1);
auto new_begin = data_allocator::allocate(new_size);
auto new_end = new_begin;
try
{
new_end = mystl::uninitialized_move(begin_, pos, new_begin);
data_allocator::construct(mystl::address_of(*new_end), mystl::forward<Args>(args)...);
++new_end;
new_end = mystl::uninitialized_move(pos, end_, new_end);
}
catch (...)
{
data_allocator::deallocate(new_begin, new_size);
throw;
}
destroy_and_recover(begin_, end_, cap_ - begin_);
begin_ = new_begin;
end_ = new_end;
cap_ = new_begin + new_size;
}
// pos
template <class T>
void vector<T>::reallocate_insert(iterator pos, const value_type& value)
{
const auto new_size = get_new_cap(1);
auto new_begin = data_allocator::allocate(new_size);
auto new_end = new_begin;
const value_type& value_copy = value;
try
{
new_end = mystl::uninitialized_move(begin_, pos, new_begin);
data_allocator::construct(mystl::address_of(*new_end), value_copy);
++new_end;
new_end = mystl::uninitialized_move(pos, end_, new_end);
}
catch (...)
{
data_allocator::deallocate(new_begin, new_size);
throw;
}
destroy_and_recover(begin_, end_, cap_ - begin_);
begin_ = new_begin;
end_ = new_end;
cap_ = new_begin + new_size;
}
// fill_insert
template <class T>
typename vector<T>::iterator
vector<T>::
fill_insert(iterator pos, size_type n, const value_type& value)
{
if (n == 0)
return pos;
const size_type xpos = pos - begin_;
const value_type value_copy = value; //
if (static_cast<size_type>(cap_ - end_) >= n)
{ //
const size_type after_elems = end_ - pos;
auto old_end = end_;
if (after_elems > n)
{
mystl::uninitialized_copy(end_ - n, end_, end_);
end_ += n;
mystl::move_backward(pos, old_end - n, old_end);
mystl::uninitialized_fill_n(pos, n, value_copy);
}
else
{
end_ = mystl::uninitialized_fill_n(end_, n - after_elems, value_copy);
end_ = mystl::uninitialized_move(pos, old_end, end_);
mystl::uninitialized_fill_n(pos, after_elems, value_copy);
}
}
else
{ //
const auto new_size = get_new_cap(n);
auto new_begin = data_allocator::allocate(new_size);
auto new_end = new_begin;
try
{
new_end = mystl::uninitialized_move(begin_, pos, new_begin);
new_end = mystl::uninitialized_fill_n(new_end, n, value);
new_end = mystl::uninitialized_move(pos, end_, new_end);
}
catch (...)
{
destroy_and_recover(new_begin, new_end, new_size);
throw;
}
data_allocator::deallocate(begin_, cap_ - begin_);
begin_ = new_begin;
end_ = new_end;
cap_ = begin_ + new_size;
}
return begin_ + xpos;
}
// copy_insert
template <class T>
template <class IIter>
void vector<T>::
copy_insert(iterator pos, IIter first, IIter last)
{
if (first == last)
return;
const auto n = mystl::distance(first, last);
if ((cap_ - end_) >= n)
{ //
const auto after_elems = end_ - pos;
auto old_end = end_;
if (after_elems > n)
{
end_ = mystl::uninitialized_copy(end_ - n, end_, end_);
mystl::move_backward(pos, old_end - n, old_end);
mystl::uninitialized_copy(first, last, pos);
}
else
{
auto mid = first;
mystl::advance(mid, after_elems);
end_ = mystl::uninitialized_copy(mid, last, end_);
end_ = mystl::uninitialized_move(pos, old_end, end_);
mystl::uninitialized_copy(first, mid, pos);
}
}
else
{ //
const auto new_size = get_new_cap(n);
auto new_begin = data_allocator::allocate(new_size);
auto new_end = new_begin;
try
{
new_end = mystl::uninitialized_move(begin_, pos, new_begin);
new_end = mystl::uninitialized_copy(first, last, new_end);
new_end = mystl::uninitialized_move(pos, end_, new_end);
}
catch (...)
{
destroy_and_recover(new_begin, new_end, new_size);
throw;
}
data_allocator::deallocate(begin_, cap_ - begin_);
begin_ = new_begin;
end_ = new_end;
cap_ = begin_ + new_size;
}
}
// reinsert
template <class T>
void vector<T>::reinsert(size_type size)
{
auto new_begin = data_allocator::allocate(size);
try
{
mystl::uninitialized_move(begin_, end_, new_begin);
}
catch (...)
{
data_allocator::deallocate(new_begin, size);
throw;
}
data_allocator::deallocate(begin_, cap_ - begin_);
begin_ = new_begin;
end_ = begin_ + size;
cap_ = begin_ + size;
}
/*****************************************************************************************/
//
template <class T>
bool operator==(const vector<T>& lhs, const vector<T>& rhs)
{
return lhs.size() == rhs.size() &&
mystl::equal(lhs.begin(), lhs.end(), rhs.begin());
}
template <class T>
bool operator<(const vector<T>& lhs, const vector<T>& rhs)
{
return mystl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
template <class T>
bool operator!=(const vector<T>& lhs, const vector<T>& rhs)
{
return !(lhs == rhs);
}
template <class T>
bool operator>(const vector<T>& lhs, const vector<T>& rhs)
{
return rhs < lhs;
}
template <class T>
bool operator<=(const vector<T>& lhs, const vector<T>& rhs)
{
return !(rhs < lhs);
}
template <class T>
bool operator>=(const vector<T>& lhs, const vector<T>& rhs)
{
return !(lhs < rhs);
}
// mystl swap
template <class T>
void swap(vector<T>& lhs, vector<T>& rhs)
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_VECTOR_H_
``` | /content/code_sandbox/MyTinySTL/vector.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 5,967 |
```objective-c
#ifndef MYTINYSTL_UNINITIALIZED_H_
#define MYTINYSTL_UNINITIALIZED_H_
//
#include "algobase.h"
#include "construct.h"
#include "iterator.h"
#include "type_traits.h"
#include "util.h"
namespace mystl
{
/*****************************************************************************************/
// uninitialized_copy
// [first, last) result
/*****************************************************************************************/
template <class InputIter, class ForwardIter>
ForwardIter
unchecked_uninit_copy(InputIter first, InputIter last, ForwardIter result, std::true_type)
{
return mystl::copy(first, last, result);
}
template <class InputIter, class ForwardIter>
ForwardIter
unchecked_uninit_copy(InputIter first, InputIter last, ForwardIter result, std::false_type)
{
auto cur = result;
try
{
for (; first != last; ++first, ++cur)
{
mystl::construct(&*cur, *first);
}
}
catch (...)
{
for (; result != cur; --cur)
mystl::destroy(&*cur);
}
return cur;
}
template <class InputIter, class ForwardIter>
ForwardIter uninitialized_copy(InputIter first, InputIter last, ForwardIter result)
{
return mystl::unchecked_uninit_copy(first, last, result,
std::is_trivially_copy_assignable<
typename iterator_traits<ForwardIter>::
value_type>{});
}
/*****************************************************************************************/
// uninitialized_copy_n
// [first, first + n) result
/*****************************************************************************************/
template <class InputIter, class Size, class ForwardIter>
ForwardIter
unchecked_uninit_copy_n(InputIter first, Size n, ForwardIter result, std::true_type)
{
return mystl::copy_n(first, n, result).second;
}
template <class InputIter, class Size, class ForwardIter>
ForwardIter
unchecked_uninit_copy_n(InputIter first, Size n, ForwardIter result, std::false_type)
{
auto cur = result;
try
{
for (; n > 0; --n, ++cur, ++first)
{
mystl::construct(&*cur, *first);
}
}
catch (...)
{
for (; result != cur; --cur)
mystl::destroy(&*cur);
}
return cur;
}
template <class InputIter, class Size, class ForwardIter>
ForwardIter uninitialized_copy_n(InputIter first, Size n, ForwardIter result)
{
return mystl::unchecked_uninit_copy_n(first, n, result,
std::is_trivially_copy_assignable<
typename iterator_traits<InputIter>::
value_type>{});
}
/*****************************************************************************************/
// uninitialized_fill
// [first, last)
/*****************************************************************************************/
template <class ForwardIter, class T>
void
unchecked_uninit_fill(ForwardIter first, ForwardIter last, const T& value, std::true_type)
{
mystl::fill(first, last, value);
}
template <class ForwardIter, class T>
void
unchecked_uninit_fill(ForwardIter first, ForwardIter last, const T& value, std::false_type)
{
auto cur = first;
try
{
for (; cur != last; ++cur)
{
mystl::construct(&*cur, value);
}
}
catch (...)
{
for (;first != cur; ++first)
mystl::destroy(&*first);
}
}
template <class ForwardIter, class T>
void uninitialized_fill(ForwardIter first, ForwardIter last, const T& value)
{
mystl::unchecked_uninit_fill(first, last, value,
std::is_trivially_copy_assignable<
typename iterator_traits<ForwardIter>::
value_type>{});
}
/*****************************************************************************************/
// uninitialized_fill_n
// first n
/*****************************************************************************************/
template <class ForwardIter, class Size, class T>
ForwardIter
unchecked_uninit_fill_n(ForwardIter first, Size n, const T& value, std::true_type)
{
return mystl::fill_n(first, n, value);
}
template <class ForwardIter, class Size, class T>
ForwardIter
unchecked_uninit_fill_n(ForwardIter first, Size n, const T& value, std::false_type)
{
auto cur = first;
try
{
for (; n > 0; --n, ++cur)
{
mystl::construct(&*cur, value);
}
}
catch (...)
{
for (; first != cur; ++first)
mystl::destroy(&*first);
}
return cur;
}
template <class ForwardIter, class Size, class T>
ForwardIter uninitialized_fill_n(ForwardIter first, Size n, const T& value)
{
return mystl::unchecked_uninit_fill_n(first, n, value,
std::is_trivially_copy_assignable<
typename iterator_traits<ForwardIter>::
value_type>{});
}
/*****************************************************************************************/
// uninitialized_move
// [first, last) result
/*****************************************************************************************/
template <class InputIter, class ForwardIter>
ForwardIter
unchecked_uninit_move(InputIter first, InputIter last, ForwardIter result, std::true_type)
{
return mystl::move(first, last, result);
}
template <class InputIter, class ForwardIter>
ForwardIter
unchecked_uninit_move(InputIter first, InputIter last, ForwardIter result, std::false_type)
{
ForwardIter cur = result;
try
{
for (; first != last; ++first, ++cur)
{
mystl::construct(&*cur, mystl::move(*first));
}
}
catch (...)
{
mystl::destroy(result, cur);
}
return cur;
}
template <class InputIter, class ForwardIter>
ForwardIter uninitialized_move(InputIter first, InputIter last, ForwardIter result)
{
return mystl::unchecked_uninit_move(first, last, result,
std::is_trivially_move_assignable<
typename iterator_traits<InputIter>::
value_type>{});
}
/*****************************************************************************************/
// uninitialized_move_n
// [first, first + n) result
/*****************************************************************************************/
template <class InputIter, class Size, class ForwardIter>
ForwardIter
unchecked_uninit_move_n(InputIter first, Size n, ForwardIter result, std::true_type)
{
return mystl::move(first, first + n, result);
}
template <class InputIter, class Size, class ForwardIter>
ForwardIter
unchecked_uninit_move_n(InputIter first, Size n, ForwardIter result, std::false_type)
{
auto cur = result;
try
{
for (; n > 0; --n, ++first, ++cur)
{
mystl::construct(&*cur, mystl::move(*first));
}
}
catch (...)
{
for (; result != cur; ++result)
mystl::destroy(&*result);
throw;
}
return cur;
}
template <class InputIter, class Size, class ForwardIter>
ForwardIter uninitialized_move_n(InputIter first, Size n, ForwardIter result)
{
return mystl::unchecked_uninit_move_n(first, n, result,
std::is_trivially_move_assignable<
typename iterator_traits<InputIter>::
value_type>{});
}
} // namespace mystl
#endif // !MYTINYSTL_UNINITIALIZED_H_
``` | /content/code_sandbox/MyTinySTL/uninitialized.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 1,584 |
```objective-c
#ifndef MYTINYSTL_ALLOCATOR_H_
#define MYTINYSTL_ALLOCATOR_H_
// allocator
#include "construct.h"
#include "util.h"
namespace mystl
{
// allocator
//
template <class T>
class allocator
{
public:
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
public:
static T* allocate();
static T* allocate(size_type n);
static void deallocate(T* ptr);
static void deallocate(T* ptr, size_type n);
static void construct(T* ptr);
static void construct(T* ptr, const T& value);
static void construct(T* ptr, T&& value);
template <class... Args>
static void construct(T* ptr, Args&& ...args);
static void destroy(T* ptr);
static void destroy(T* first, T* last);
};
template <class T>
T* allocator<T>::allocate()
{
return static_cast<T*>(::operator new(sizeof(T)));
}
template <class T>
T* allocator<T>::allocate(size_type n)
{
if (n == 0)
return nullptr;
return static_cast<T*>(::operator new(n * sizeof(T)));
}
template <class T>
void allocator<T>::deallocate(T* ptr)
{
if (ptr == nullptr)
return;
::operator delete(ptr);
}
template <class T>
void allocator<T>::deallocate(T* ptr, size_type /*size*/)
{
if (ptr == nullptr)
return;
::operator delete(ptr);
}
template <class T>
void allocator<T>::construct(T* ptr)
{
mystl::construct(ptr);
}
template <class T>
void allocator<T>::construct(T* ptr, const T& value)
{
mystl::construct(ptr, value);
}
template <class T>
void allocator<T>::construct(T* ptr, T&& value)
{
mystl::construct(ptr, mystl::move(value));
}
template <class T>
template <class ...Args>
void allocator<T>::construct(T* ptr, Args&& ...args)
{
mystl::construct(ptr, mystl::forward<Args>(args)...);
}
template <class T>
void allocator<T>::destroy(T* ptr)
{
mystl::destroy(ptr);
}
template <class T>
void allocator<T>::destroy(T* first, T* last)
{
mystl::destroy(first, last);
}
} // namespace mystl
#endif // !MYTINYSTL_ALLOCATOR_H_
``` | /content/code_sandbox/MyTinySTL/allocator.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 567 |
```objective-c
#ifndef MYTINYSTL_STACK_H_
#define MYTINYSTL_STACK_H_
// stack
// stack :
#include "deque.h"
namespace mystl
{
// stack
// mystl::deque
template <class T, class Container = mystl::deque<T>>
class stack
{
public:
typedef Container container_type;
//
typedef typename Container::value_type value_type;
typedef typename Container::size_type size_type;
typedef typename Container::reference reference;
typedef typename Container::const_reference const_reference;
static_assert(std::is_same<T, value_type>::value,
"the value_type of Container should be same with T");
private:
container_type c_; // stack
public:
//
stack() = default;
explicit stack(size_type n)
:c_(n)
{
}
stack(size_type n, const value_type& value)
:c_(n, value)
{
}
template <class IIter>
stack(IIter first, IIter last)
: c_(first, last)
{
}
stack(std::initializer_list<T> ilist)
:c_(ilist.begin(), ilist.end())
{
}
stack(const Container& c)
:c_(c)
{
}
stack(Container&& c) noexcept(std::is_nothrow_move_constructible<Container>::value)
:c_(mystl::move(c))
{
}
stack(const stack& rhs)
:c_(rhs.c_)
{
}
stack(stack&& rhs) noexcept(std::is_nothrow_move_constructible<Container>::value)
:c_(mystl::move(rhs.c_))
{
}
stack& operator=(const stack& rhs)
{
c_ = rhs.c_;
return *this;
}
stack& operator=(stack&& rhs) noexcept(std::is_nothrow_move_assignable<Container>::value)
{
c_ = mystl::move(rhs.c_);
return *this;
}
stack& operator=(std::initializer_list<T> ilist)
{
c_ = ilist;
return *this;
}
~stack() = default;
//
reference top() { return c_.back(); }
const_reference top() const { return c_.back(); }
//
bool empty() const noexcept { return c_.empty(); }
size_type size() const noexcept { return c_.size(); }
//
template <class... Args>
void emplace(Args&& ...args)
{ c_.emplace_back(mystl::forward<Args>(args)...); }
void push(const value_type& value)
{ c_.push_back(value); }
void push(value_type&& value)
{ c_.push_back(mystl::move(value)); }
void pop()
{ c_.pop_back(); }
void clear()
{
while (!empty())
pop();
}
void swap(stack& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_)))
{ mystl::swap(c_, rhs.c_); }
public:
friend bool operator==(const stack& lhs, const stack& rhs) { return lhs.c_ == rhs.c_; }
friend bool operator< (const stack& lhs, const stack& rhs) { return lhs.c_ < rhs.c_; }
};
//
template <class T, class Container>
bool operator==(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return lhs == rhs;
}
template <class T, class Container>
bool operator<(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return lhs < rhs;
}
template <class T, class Container>
bool operator!=(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return !(lhs == rhs);
}
template <class T, class Container>
bool operator>(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return rhs < lhs;
}
template <class T, class Container>
bool operator<=(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return !(rhs < lhs);
}
template <class T, class Container>
bool operator>=(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return !(lhs < rhs);
}
// mystl swap
template <class T, class Container>
void swap(stack<T, Container>& lhs, stack<T, Container>& rhs) noexcept(noexcept(lhs.swap(rhs)))
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_STACK_H_
``` | /content/code_sandbox/MyTinySTL/stack.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 1,029 |
```objective-c
#ifndef MYTINYSTL_EXCEPTDEF_H_
#define MYTINYSTL_EXCEPTDEF_H_
#include <stdexcept>
#include <cassert>
namespace mystl
{
#define MYSTL_DEBUG(expr) \
assert(expr)
#define THROW_LENGTH_ERROR_IF(expr, what) \
if ((expr)) throw std::length_error(what)
#define THROW_OUT_OF_RANGE_IF(expr, what) \
if ((expr)) throw std::out_of_range(what)
#define THROW_RUNTIME_ERROR_IF(expr, what) \
if ((expr)) throw std::runtime_error(what)
} // namepsace mystl
#endif // !MYTINYSTL_EXCEPTDEF_H_
``` | /content/code_sandbox/MyTinySTL/exceptdef.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 141 |
```objective-c
#ifndef MYTINYSTL_ITERATOR_H_
#define MYTINYSTL_ITERATOR_H_
//
#include <cstddef>
#include "type_traits.h"
namespace mystl
{
//
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag : public input_iterator_tag {};
struct bidirectional_iterator_tag : public forward_iterator_tag {};
struct random_access_iterator_tag : public bidirectional_iterator_tag {};
// iterator
template <class Category, class T, class Distance = ptrdiff_t,
class Pointer = T*, class Reference = T&>
struct iterator
{
typedef Category iterator_category;
typedef T value_type;
typedef Pointer pointer;
typedef Reference reference;
typedef Distance difference_type;
};
// iterator traits
template <class T>
struct has_iterator_cat
{
private:
struct two { char a; char b; };
template <class U> static two test(...);
template <class U> static char test(typename U::iterator_category* = 0);
public:
static const bool value = sizeof(test<T>(0)) == sizeof(char);
};
template <class Iterator, bool>
struct iterator_traits_impl {};
template <class Iterator>
struct iterator_traits_impl<Iterator, true>
{
typedef typename Iterator::iterator_category iterator_category;
typedef typename Iterator::value_type value_type;
typedef typename Iterator::pointer pointer;
typedef typename Iterator::reference reference;
typedef typename Iterator::difference_type difference_type;
};
template <class Iterator, bool>
struct iterator_traits_helper {};
template <class Iterator>
struct iterator_traits_helper<Iterator, true>
: public iterator_traits_impl<Iterator,
std::is_convertible<typename Iterator::iterator_category, input_iterator_tag>::value ||
std::is_convertible<typename Iterator::iterator_category, output_iterator_tag>::value>
{
};
//
template <class Iterator>
struct iterator_traits
: public iterator_traits_helper<Iterator, has_iterator_cat<Iterator>::value> {};
//
template <class T>
struct iterator_traits<T*>
{
typedef random_access_iterator_tag iterator_category;
typedef T value_type;
typedef T* pointer;
typedef T& reference;
typedef ptrdiff_t difference_type;
};
template <class T>
struct iterator_traits<const T*>
{
typedef random_access_iterator_tag iterator_category;
typedef T value_type;
typedef const T* pointer;
typedef const T& reference;
typedef ptrdiff_t difference_type;
};
template <class T, class U, bool = has_iterator_cat<iterator_traits<T>>::value>
struct has_iterator_cat_of
: public m_bool_constant<std::is_convertible<
typename iterator_traits<T>::iterator_category, U>::value>
{
};
//
template <class T, class U>
struct has_iterator_cat_of<T, U, false> : public m_false_type {};
template <class Iter>
struct is_input_iterator : public has_iterator_cat_of<Iter, input_iterator_tag> {};
template <class Iter>
struct is_output_iterator : public has_iterator_cat_of<Iter, output_iterator_tag> {};
template <class Iter>
struct is_forward_iterator : public has_iterator_cat_of<Iter, forward_iterator_tag> {};
template <class Iter>
struct is_bidirectional_iterator : public has_iterator_cat_of<Iter, bidirectional_iterator_tag> {};
template <class Iter>
struct is_random_access_iterator : public has_iterator_cat_of<Iter, random_access_iterator_tag> {};
template <class Iterator>
struct is_iterator :
public m_bool_constant<is_input_iterator<Iterator>::value ||
is_output_iterator<Iterator>::value>
{
};
// category
template <class Iterator>
typename iterator_traits<Iterator>::iterator_category
iterator_category(const Iterator&)
{
typedef typename iterator_traits<Iterator>::iterator_category Category;
return Category();
}
// distance_type
template <class Iterator>
typename iterator_traits<Iterator>::difference_type*
distance_type(const Iterator&)
{
return static_cast<typename iterator_traits<Iterator>::difference_type*>(0);
}
// value_type
template <class Iterator>
typename iterator_traits<Iterator>::value_type*
value_type(const Iterator&)
{
return static_cast<typename iterator_traits<Iterator>::value_type*>(0);
}
//
// distance input_iterator_tag
template <class InputIterator>
typename iterator_traits<InputIterator>::difference_type
distance_dispatch(InputIterator first, InputIterator last, input_iterator_tag)
{
typename iterator_traits<InputIterator>::difference_type n = 0;
while (first != last)
{
++first;
++n;
}
return n;
}
// distance random_access_iterator_tag
template <class RandomIter>
typename iterator_traits<RandomIter>::difference_type
distance_dispatch(RandomIter first, RandomIter last,
random_access_iterator_tag)
{
return last - first;
}
template <class InputIterator>
typename iterator_traits<InputIterator>::difference_type
distance(InputIterator first, InputIterator last)
{
return distance_dispatch(first, last, iterator_category(first));
}
// n
// advance input_iterator_tag
template <class InputIterator, class Distance>
void advance_dispatch(InputIterator& i, Distance n, input_iterator_tag)
{
while (n--)
++i;
}
// advance bidirectional_iterator_tag
template <class BidirectionalIterator, class Distance>
void advance_dispatch(BidirectionalIterator& i, Distance n, bidirectional_iterator_tag)
{
if (n >= 0)
while (n--) ++i;
else
while (n++) --i;
}
// advance random_access_iterator_tag
template <class RandomIter, class Distance>
void advance_dispatch(RandomIter& i, Distance n, random_access_iterator_tag)
{
i += n;
}
template <class InputIterator, class Distance>
void advance(InputIterator& i, Distance n)
{
advance_dispatch(i, n, iterator_category(i));
}
/*****************************************************************************************/
// : reverse_iterator
//
template <class Iterator>
class reverse_iterator
{
private:
Iterator current; //
public:
//
typedef typename iterator_traits<Iterator>::iterator_category iterator_category;
typedef typename iterator_traits<Iterator>::value_type value_type;
typedef typename iterator_traits<Iterator>::difference_type difference_type;
typedef typename iterator_traits<Iterator>::pointer pointer;
typedef typename iterator_traits<Iterator>::reference reference;
typedef Iterator iterator_type;
typedef reverse_iterator<Iterator> self;
public:
//
reverse_iterator() {}
explicit reverse_iterator(iterator_type i) :current(i) {}
reverse_iterator(const self& rhs) :current(rhs.current) {}
public:
//
iterator_type base() const
{ return current; }
//
reference operator*() const
{ //
auto tmp = current;
return *--tmp;
}
pointer operator->() const
{
return &(operator*());
}
// (++)(--)
self& operator++()
{
--current;
return *this;
}
self operator++(int)
{
self tmp = *this;
--current;
return tmp;
}
// (--)(++)
self& operator--()
{
++current;
return *this;
}
self operator--(int)
{
self tmp = *this;
++current;
return tmp;
}
self& operator+=(difference_type n)
{
current -= n;
return *this;
}
self operator+(difference_type n) const
{
return self(current - n);
}
self& operator-=(difference_type n)
{
current += n;
return *this;
}
self operator-(difference_type n) const
{
return self(current + n);
}
reference operator[](difference_type n) const
{
return *(*this + n);
}
};
// operator-
template <class Iterator>
typename reverse_iterator<Iterator>::difference_type
operator-(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return rhs.base() - lhs.base();
}
//
template <class Iterator>
bool operator==(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return lhs.base() == rhs.base();
}
template <class Iterator>
bool operator<(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return rhs.base() < lhs.base();
}
template <class Iterator>
bool operator!=(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return !(lhs == rhs);
}
template <class Iterator>
bool operator>(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return rhs < lhs;
}
template <class Iterator>
bool operator<=(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return !(rhs < lhs);
}
template <class Iterator>
bool operator>=(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return !(lhs < rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_ITERATOR_H_
``` | /content/code_sandbox/MyTinySTL/iterator.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 1,931 |
```objective-c
#ifndef MYTINYSTL_TYPE_TRAITS_H_
#define MYTINYSTL_TYPE_TRAITS_H_
//
// use standard header for type_traits
#include <type_traits>
namespace mystl
{
// helper struct
template <class T, T v>
struct m_integral_constant
{
static constexpr T value = v;
};
template <bool b>
using m_bool_constant = m_integral_constant<bool, b>;
typedef m_bool_constant<true> m_true_type;
typedef m_bool_constant<false> m_false_type;
/*****************************************************************************************/
// type traits
// is_pair
// --- forward declaration begin
template <class T1, class T2>
struct pair;
// --- forward declaration end
template <class T>
struct is_pair : mystl::m_false_type {};
template <class T1, class T2>
struct is_pair<mystl::pair<T1, T2>> : mystl::m_true_type {};
} // namespace mystl
#endif // !MYTINYSTL_TYPE_TRAITS_H_
``` | /content/code_sandbox/MyTinySTL/type_traits.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 213 |
```objective-c
#ifndef MYTINYSTL_RB_TREE_H_
#define MYTINYSTL_RB_TREE_H_
// rb_tree
// rb_tree :
#include <initializer_list>
#include <cassert>
#include "functional.h"
#include "iterator.h"
#include "memory.h"
#include "type_traits.h"
#include "exceptdef.h"
namespace mystl
{
// rb tree
typedef bool rb_tree_color_type;
static constexpr rb_tree_color_type rb_tree_red = false;
static constexpr rb_tree_color_type rb_tree_black = true;
// forward declaration
template <class T> struct rb_tree_node_base;
template <class T> struct rb_tree_node;
template <class T> struct rb_tree_iterator;
template <class T> struct rb_tree_const_iterator;
// rb tree value traits
template <class T, bool>
struct rb_tree_value_traits_imp
{
typedef T key_type;
typedef T mapped_type;
typedef T value_type;
template <class Ty>
static const key_type& get_key(const Ty& value)
{
return value;
}
template <class Ty>
static const value_type& get_value(const Ty& value)
{
return value;
}
};
template <class T>
struct rb_tree_value_traits_imp<T, true>
{
typedef typename std::remove_cv<typename T::first_type>::type key_type;
typedef typename T::second_type mapped_type;
typedef T value_type;
template <class Ty>
static const key_type& get_key(const Ty& value)
{
return value.first;
}
template <class Ty>
static const value_type& get_value(const Ty& value)
{
return value;
}
};
template <class T>
struct rb_tree_value_traits
{
static constexpr bool is_map = mystl::is_pair<T>::value;
typedef rb_tree_value_traits_imp<T, is_map> value_traits_type;
typedef typename value_traits_type::key_type key_type;
typedef typename value_traits_type::mapped_type mapped_type;
typedef typename value_traits_type::value_type value_type;
template <class Ty>
static const key_type& get_key(const Ty& value)
{
return value_traits_type::get_key(value);
}
template <class Ty>
static const value_type& get_value(const Ty& value)
{
return value_traits_type::get_value(value);
}
};
// rb tree node traits
template <class T>
struct rb_tree_node_traits
{
typedef rb_tree_color_type color_type;
typedef rb_tree_value_traits<T> value_traits;
typedef typename value_traits::key_type key_type;
typedef typename value_traits::mapped_type mapped_type;
typedef typename value_traits::value_type value_type;
typedef rb_tree_node_base<T>* base_ptr;
typedef rb_tree_node<T>* node_ptr;
};
// rb tree
template <class T>
struct rb_tree_node_base
{
typedef rb_tree_color_type color_type;
typedef rb_tree_node_base<T>* base_ptr;
typedef rb_tree_node<T>* node_ptr;
base_ptr parent; //
base_ptr left; //
base_ptr right; //
color_type color; //
base_ptr get_base_ptr()
{
return &*this;
}
node_ptr get_node_ptr()
{
return reinterpret_cast<node_ptr>(&*this);
}
node_ptr& get_node_ref()
{
return reinterpret_cast<node_ptr&>(*this);
}
};
template <class T>
struct rb_tree_node :public rb_tree_node_base<T>
{
typedef rb_tree_node_base<T>* base_ptr;
typedef rb_tree_node<T>* node_ptr;
T value; //
base_ptr get_base_ptr()
{
return static_cast<base_ptr>(&*this);
}
node_ptr get_node_ptr()
{
return &*this;
}
};
// rb tree traits
template <class T>
struct rb_tree_traits
{
typedef rb_tree_value_traits<T> value_traits;
typedef typename value_traits::key_type key_type;
typedef typename value_traits::mapped_type mapped_type;
typedef typename value_traits::value_type value_type;
typedef value_type* pointer;
typedef value_type& reference;
typedef const value_type* const_pointer;
typedef const value_type& const_reference;
typedef rb_tree_node_base<T> base_type;
typedef rb_tree_node<T> node_type;
typedef base_type* base_ptr;
typedef node_type* node_ptr;
};
// rb tree
template <class T>
struct rb_tree_iterator_base :public mystl::iterator<mystl::bidirectional_iterator_tag, T>
{
typedef typename rb_tree_traits<T>::base_ptr base_ptr;
base_ptr node; //
rb_tree_iterator_base() :node(nullptr) {}
//
void inc()
{
if (node->right != nullptr)
{
node = rb_tree_min(node->right);
}
else
{ //
auto y = node->parent;
while (y->right == node)
{
node = y;
y = y->parent;
}
if (node->right != y) //
node = y;
}
}
//
void dec()
{
if (node->parent->parent == node && rb_tree_is_red(node))
{ // node header
node = node->right; // max
}
else if (node->left != nullptr)
{
node = rb_tree_max(node->left);
}
else
{ // header
auto y = node->parent;
while (node == y->left)
{
node = y;
y = y->parent;
}
node = y;
}
}
bool operator==(const rb_tree_iterator_base& rhs) { return node == rhs.node; }
bool operator!=(const rb_tree_iterator_base& rhs) { return node != rhs.node; }
};
template <class T>
struct rb_tree_iterator :public rb_tree_iterator_base<T>
{
typedef rb_tree_traits<T> tree_traits;
typedef typename tree_traits::value_type value_type;
typedef typename tree_traits::pointer pointer;
typedef typename tree_traits::reference reference;
typedef typename tree_traits::base_ptr base_ptr;
typedef typename tree_traits::node_ptr node_ptr;
typedef rb_tree_iterator<T> iterator;
typedef rb_tree_const_iterator<T> const_iterator;
typedef iterator self;
using rb_tree_iterator_base<T>::node;
//
rb_tree_iterator() {}
rb_tree_iterator(base_ptr x) { node = x; }
rb_tree_iterator(node_ptr x) { node = x; }
rb_tree_iterator(const iterator& rhs) { node = rhs.node; }
rb_tree_iterator(const const_iterator& rhs) { node = rhs.node; }
//
reference operator*() const { return node->get_node_ptr()->value; }
pointer operator->() const { return &(operator*()); }
self& operator++()
{
this->inc();
return *this;
}
self operator++(int)
{
self tmp(*this);
this->inc();
return tmp;
}
self& operator--()
{
this->dec();
return *this;
}
self operator--(int)
{
self tmp(*this);
this->dec();
return tmp;
}
};
template <class T>
struct rb_tree_const_iterator :public rb_tree_iterator_base<T>
{
typedef rb_tree_traits<T> tree_traits;
typedef typename tree_traits::value_type value_type;
typedef typename tree_traits::const_pointer pointer;
typedef typename tree_traits::const_reference reference;
typedef typename tree_traits::base_ptr base_ptr;
typedef typename tree_traits::node_ptr node_ptr;
typedef rb_tree_iterator<T> iterator;
typedef rb_tree_const_iterator<T> const_iterator;
typedef const_iterator self;
using rb_tree_iterator_base<T>::node;
//
rb_tree_const_iterator() {}
rb_tree_const_iterator(base_ptr x) { node = x; }
rb_tree_const_iterator(node_ptr x) { node = x; }
rb_tree_const_iterator(const iterator& rhs) { node = rhs.node; }
rb_tree_const_iterator(const const_iterator& rhs) { node = rhs.node; }
//
reference operator*() const { return node->get_node_ptr()->value; }
pointer operator->() const { return &(operator*()); }
self& operator++()
{
this->inc();
return *this;
}
self operator++(int)
{
self tmp(*this);
this->inc();
return tmp;
}
self& operator--()
{
this->dec();
return *this;
}
self operator--(int)
{
self tmp(*this);
this->dec();
return tmp;
}
};
// tree algorithm
template <class NodePtr>
NodePtr rb_tree_min(NodePtr x) noexcept
{
while (x->left != nullptr)
x = x->left;
return x;
}
template <class NodePtr>
NodePtr rb_tree_max(NodePtr x) noexcept
{
while (x->right != nullptr)
x = x->right;
return x;
}
template <class NodePtr>
bool rb_tree_is_lchild(NodePtr node) noexcept
{
return node == node->parent->left;
}
template <class NodePtr>
bool rb_tree_is_red(NodePtr node) noexcept
{
return node->color == rb_tree_red;
}
template <class NodePtr>
void rb_tree_set_black(NodePtr& node) noexcept
{
node->color = rb_tree_black;
}
template <class NodePtr>
void rb_tree_set_red(NodePtr& node) noexcept
{
node->color = rb_tree_red;
}
template <class NodePtr>
NodePtr rb_tree_next(NodePtr node) noexcept
{
if (node->right != nullptr)
return rb_tree_min(node->right);
while (!rb_tree_is_lchild(node))
node = node->parent;
return node->parent;
}
/*---------------------------------------*\
| p p |
| / \ / \ |
| x d rotate left y d |
| / \ ===========> / \ |
| a y x c |
| / \ / \ |
| b c a b |
\*---------------------------------------*/
//
template <class NodePtr>
void rb_tree_rotate_left(NodePtr x, NodePtr& root) noexcept
{
auto y = x->right; // y x
x->right = y->left;
if (y->left != nullptr)
y->left->parent = x;
y->parent = x->parent;
if (x == root)
{ // x y x
root = y;
}
else if (rb_tree_is_lchild(x))
{ // x
x->parent->left = y;
}
else
{ // x
x->parent->right = y;
}
// x y
y->left = x;
x->parent = y;
}
/*----------------------------------------*\
| p p |
| / \ / \ |
| d x rotate right d y |
| / \ ===========> / \ |
| y a b x |
| / \ / \ |
| b c c a |
\*----------------------------------------*/
//
template <class NodePtr>
void rb_tree_rotate_right(NodePtr x, NodePtr& root) noexcept
{
auto y = x->left;
x->left = y->right;
if (y->right)
y->right->parent = x;
y->parent = x->parent;
if (x == root)
{ // x y x
root = y;
}
else if (rb_tree_is_lchild(x))
{ // x
x->parent->left = y;
}
else
{ // x
x->parent->right = y;
}
// x y
y->right = x;
x->parent = y;
}
// rb tree
//
// case 1:
// case 2:
// case 3:
//
// case 4: NIL
//
// case 5: NIL
//
//
// : path_to_url
// path_to_url
template <class NodePtr>
void rb_tree_insert_rebalance(NodePtr x, NodePtr& root) noexcept
{
rb_tree_set_red(x); //
while (x != root && rb_tree_is_red(x->parent))
{
if (rb_tree_is_lchild(x->parent))
{ //
auto uncle = x->parent->parent->right;
if (uncle != nullptr && rb_tree_is_red(uncle))
{ // case 3:
rb_tree_set_black(x->parent);
rb_tree_set_black(uncle);
x = x->parent->parent;
rb_tree_set_red(x);
}
else
{ //
if (!rb_tree_is_lchild(x))
{ // case 4: x
x = x->parent;
rb_tree_rotate_left(x, root);
}
// case 5
rb_tree_set_black(x->parent);
rb_tree_set_red(x->parent->parent);
rb_tree_rotate_right(x->parent->parent, root);
break;
}
}
else //
{
auto uncle = x->parent->parent->left;
if (uncle != nullptr && rb_tree_is_red(uncle))
{ // case 3:
rb_tree_set_black(x->parent);
rb_tree_set_black(uncle);
x = x->parent->parent;
rb_tree_set_red(x);
//
}
else
{ //
if (rb_tree_is_lchild(x))
{ // case 4: x
x = x->parent;
rb_tree_rotate_right(x, root);
}
// case 5
rb_tree_set_black(x->parent);
rb_tree_set_red(x->parent->parent);
rb_tree_rotate_left(x->parent->parent, root);
break;
}
}
}
rb_tree_set_black(root); //
}
// rb tree
//
// : path_to_url
// path_to_url
template <class NodePtr>
NodePtr rb_tree_erase_rebalance(NodePtr z, NodePtr& root, NodePtr& leftmost, NodePtr& rightmost)
{
// y
auto y = (z->left == nullptr || z->right == nullptr) ? z : rb_tree_next(z);
// x y NIL
auto x = y->left != nullptr ? y->left : y->right;
// xp x
NodePtr xp = nullptr;
// y != z z y z x y
// y z x y y z
if (y != z)
{
z->left->parent = y;
y->left = z->left;
// y z z
if (y != z->right)
{ // x y
xp = y->parent;
if (x != nullptr)
x->parent = y->parent;
y->parent->left = x;
y->right = z->right;
z->right->parent = y;
}
else
{
xp = y;
}
// y z
if (root == z)
root = y;
else if (rb_tree_is_lchild(z))
z->parent->left = y;
else
z->parent->right = y;
y->parent = z->parent;
mystl::swap(y->color, z->color);
y = z;
}
// y == z z
else
{
xp = y->parent;
if (x)
x->parent = y->parent;
// x z
if (root == z)
root = x;
else if (rb_tree_is_lchild(z))
z->parent->left = x;
else
z->parent->right = x;
// z
if (leftmost == z)
leftmost = x == nullptr ? xp : rb_tree_min(x);
if (rightmost == z)
rightmost = x == nullptr ? xp : rb_tree_max(x);
}
// y x x
// x
// case 1:
// case 2: NIL
// case 3: NIL NIL
//
// case 4:
//
if (!rb_tree_is_red(y))
{ // x x
while (x != root && (x == nullptr || !rb_tree_is_red(x)))
{
if (x == xp->left)
{ // x
auto brother = xp->right;
if (rb_tree_is_red(brother))
{ // case 1
rb_tree_set_black(brother);
rb_tree_set_red(xp);
rb_tree_rotate_left(xp, root);
brother = xp->right;
}
// case 1 case 234
if ((brother->left == nullptr || !rb_tree_is_red(brother->left)) &&
(brother->right == nullptr || !rb_tree_is_red(brother->right)))
{ // case 2
rb_tree_set_red(brother);
x = xp;
xp = xp->parent;
}
else
{
if (brother->right == nullptr || !rb_tree_is_red(brother->right))
{ // case 3
if (brother->left != nullptr)
rb_tree_set_black(brother->left);
rb_tree_set_red(brother);
rb_tree_rotate_right(brother, root);
brother = xp->right;
}
// case 4
brother->color = xp->color;
rb_tree_set_black(xp);
if (brother->right != nullptr)
rb_tree_set_black(brother->right);
rb_tree_rotate_left(xp, root);
break;
}
}
else // x
{
auto brother = xp->left;
if (rb_tree_is_red(brother))
{ // case 1
rb_tree_set_black(brother);
rb_tree_set_red(xp);
rb_tree_rotate_right(xp, root);
brother = xp->left;
}
if ((brother->left == nullptr || !rb_tree_is_red(brother->left)) &&
(brother->right == nullptr || !rb_tree_is_red(brother->right)))
{ // case 2
rb_tree_set_red(brother);
x = xp;
xp = xp->parent;
}
else
{
if (brother->left == nullptr || !rb_tree_is_red(brother->left))
{ // case 3
if (brother->right != nullptr)
rb_tree_set_black(brother->right);
rb_tree_set_red(brother);
rb_tree_rotate_left(brother, root);
brother = xp->left;
}
// case 4
brother->color = xp->color;
rb_tree_set_black(xp);
if (brother->left != nullptr)
rb_tree_set_black(brother->left);
rb_tree_rotate_right(xp, root);
break;
}
}
}
if (x != nullptr)
rb_tree_set_black(x);
}
return y;
}
// rb_tree
//
template <class T, class Compare>
class rb_tree
{
public:
// rb_tree
typedef rb_tree_traits<T> tree_traits;
typedef rb_tree_value_traits<T> value_traits;
typedef typename tree_traits::base_type base_type;
typedef typename tree_traits::base_ptr base_ptr;
typedef typename tree_traits::node_type node_type;
typedef typename tree_traits::node_ptr node_ptr;
typedef typename tree_traits::key_type key_type;
typedef typename tree_traits::mapped_type mapped_type;
typedef typename tree_traits::value_type value_type;
typedef Compare key_compare;
typedef mystl::allocator<T> allocator_type;
typedef mystl::allocator<T> data_allocator;
typedef mystl::allocator<base_type> base_allocator;
typedef mystl::allocator<node_type> node_allocator;
typedef typename allocator_type::pointer pointer;
typedef typename allocator_type::const_pointer const_pointer;
typedef typename allocator_type::reference reference;
typedef typename allocator_type::const_reference const_reference;
typedef typename allocator_type::size_type size_type;
typedef typename allocator_type::difference_type difference_type;
typedef rb_tree_iterator<T> iterator;
typedef rb_tree_const_iterator<T> const_iterator;
typedef mystl::reverse_iterator<iterator> reverse_iterator;
typedef mystl::reverse_iterator<const_iterator> const_reverse_iterator;
allocator_type get_allocator() const { return node_allocator(); }
key_compare key_comp() const { return key_comp_; }
private:
// rb tree
base_ptr header_; //
size_type node_count_; //
key_compare key_comp_; //
private:
//
base_ptr& root() const { return header_->parent; }
base_ptr& leftmost() const { return header_->left; }
base_ptr& rightmost() const { return header_->right; }
public:
//
rb_tree() { rb_tree_init(); }
rb_tree(const rb_tree& rhs);
rb_tree(rb_tree&& rhs) noexcept;
rb_tree& operator=(const rb_tree& rhs);
rb_tree& operator=(rb_tree&& rhs);
~rb_tree() { clear(); }
public:
//
iterator begin() noexcept
{ return leftmost(); }
const_iterator begin() const noexcept
{ return leftmost(); }
iterator end() noexcept
{ return header_; }
const_iterator end() const noexcept
{ return header_; }
reverse_iterator rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator cbegin() const noexcept
{ return begin(); }
const_iterator cend() const noexcept
{ return end(); }
const_reverse_iterator crbegin() const noexcept
{ return rbegin(); }
const_reverse_iterator crend() const noexcept
{ return rend(); }
//
bool empty() const noexcept { return node_count_ == 0; }
size_type size() const noexcept { return node_count_; }
size_type max_size() const noexcept { return static_cast<size_type>(-1); }
//
// emplace
template <class ...Args>
iterator emplace_multi(Args&& ...args);
template <class ...Args>
mystl::pair<iterator, bool> emplace_unique(Args&& ...args);
template <class ...Args>
iterator emplace_multi_use_hint(iterator hint, Args&& ...args);
template <class ...Args>
iterator emplace_unique_use_hint(iterator hint, Args&& ...args);
// insert
iterator insert_multi(const value_type& value);
iterator insert_multi(value_type&& value)
{
return emplace_multi(mystl::move(value));
}
iterator insert_multi(iterator hint, const value_type& value)
{
return emplace_multi_use_hint(hint, value);
}
iterator insert_multi(iterator hint, value_type&& value)
{
return emplace_multi_use_hint(hint, mystl::move(value));
}
template <class InputIterator>
void insert_multi(InputIterator first, InputIterator last)
{
size_type n = mystl::distance(first, last);
THROW_LENGTH_ERROR_IF(node_count_ > max_size() - n, "rb_tree<T, Comp>'s size too big");
for (; n > 0; --n, ++first)
insert_multi(end(), *first);
}
mystl::pair<iterator, bool> insert_unique(const value_type& value);
mystl::pair<iterator, bool> insert_unique(value_type&& value)
{
return emplace_unique(mystl::move(value));
}
iterator insert_unique(iterator hint, const value_type& value)
{
return emplace_unique_use_hint(hint, value);
}
iterator insert_unique(iterator hint, value_type&& value)
{
return emplace_unique_use_hint(hint, mystl::move(value));
}
template <class InputIterator>
void insert_unique(InputIterator first, InputIterator last)
{
size_type n = mystl::distance(first, last);
THROW_LENGTH_ERROR_IF(node_count_ > max_size() - n, "rb_tree<T, Comp>'s size too big");
for (; n > 0; --n, ++first)
insert_unique(end(), *first);
}
// erase
iterator erase(iterator hint);
size_type erase_multi(const key_type& key);
size_type erase_unique(const key_type& key);
void erase(iterator first, iterator last);
void clear();
// rb_tree
iterator find(const key_type& key);
const_iterator find(const key_type& key) const;
size_type count_multi(const key_type& key) const
{
auto p = equal_range_multi(key);
return static_cast<size_type>(mystl::distance(p.first, p.second));
}
size_type count_unique(const key_type& key) const
{
return find(key) != end() ? 1 : 0;
}
iterator lower_bound(const key_type& key);
const_iterator lower_bound(const key_type& key) const;
iterator upper_bound(const key_type& key);
const_iterator upper_bound(const key_type& key) const;
mystl::pair<iterator, iterator>
equal_range_multi(const key_type& key)
{
return mystl::pair<iterator, iterator>(lower_bound(key), upper_bound(key));
}
mystl::pair<const_iterator, const_iterator>
equal_range_multi(const key_type& key) const
{
return mystl::pair<const_iterator, const_iterator>(lower_bound(key), upper_bound(key));
}
mystl::pair<iterator, iterator>
equal_range_unique(const key_type& key)
{
iterator it = find(key);
auto next = it;
return it == end() ? mystl::make_pair(it, it) : mystl::make_pair(it, ++next);
}
mystl::pair<const_iterator, const_iterator>
equal_range_unique(const key_type& key) const
{
const_iterator it = find(key);
auto next = it;
return it == end() ? mystl::make_pair(it, it) : mystl::make_pair(it, ++next);
}
void swap(rb_tree& rhs) noexcept;
private:
// node related
template <class ...Args>
node_ptr create_node(Args&&... args);
node_ptr clone_node(base_ptr x);
void destroy_node(node_ptr p);
// init / reset
void rb_tree_init();
void reset();
// get insert pos
mystl::pair<base_ptr, bool>
get_insert_multi_pos(const key_type& key);
mystl::pair<mystl::pair<base_ptr, bool>, bool>
get_insert_unique_pos(const key_type& key);
// insert value / insert node
iterator insert_value_at(base_ptr x, const value_type& value, bool add_to_left);
iterator insert_node_at(base_ptr x, node_ptr node, bool add_to_left);
// insert use hint
iterator insert_multi_use_hint(iterator hint, key_type key, node_ptr node);
iterator insert_unique_use_hint(iterator hint, key_type key, node_ptr node);
// copy tree / erase tree
base_ptr copy_from(base_ptr x, base_ptr p);
void erase_since(base_ptr x);
};
/*****************************************************************************************/
//
template <class T, class Compare>
rb_tree<T, Compare>::
rb_tree(const rb_tree& rhs)
{
rb_tree_init();
if (rhs.node_count_ != 0)
{
root() = copy_from(rhs.root(), header_);
leftmost() = rb_tree_min(root());
rightmost() = rb_tree_max(root());
}
node_count_ = rhs.node_count_;
key_comp_ = rhs.key_comp_;
}
//
template <class T, class Compare>
rb_tree<T, Compare>::
rb_tree(rb_tree&& rhs) noexcept
:header_(mystl::move(rhs.header_)),
node_count_(rhs.node_count_),
key_comp_(rhs.key_comp_)
{
rhs.reset();
}
//
template <class T, class Compare>
rb_tree<T, Compare>&
rb_tree<T, Compare>::
operator=(const rb_tree& rhs)
{
if (this != &rhs)
{
clear();
if (rhs.node_count_ != 0)
{
root() = copy_from(rhs.root(), header_);
leftmost() = rb_tree_min(root());
rightmost() = rb_tree_max(root());
}
node_count_ = rhs.node_count_;
key_comp_ = rhs.key_comp_;
}
return *this;
}
//
template <class T, class Compare>
rb_tree<T, Compare>&
rb_tree<T, Compare>::
operator=(rb_tree&& rhs)
{
clear();
header_ = mystl::move(rhs.header_);
node_count_ = rhs.node_count_;
key_comp_ = rhs.key_comp_;
rhs.reset();
return *this;
}
//
template <class T, class Compare>
template <class ...Args>
typename rb_tree<T, Compare>::iterator
rb_tree<T, Compare>::
emplace_multi(Args&& ...args)
{
THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree<T, Comp>'s size too big");
node_ptr np = create_node(mystl::forward<Args>(args)...);
auto res = get_insert_multi_pos(value_traits::get_key(np->value));
return insert_node_at(res.first, np, res.second);
}
//
template <class T, class Compare>
template <class ...Args>
mystl::pair<typename rb_tree<T, Compare>::iterator, bool>
rb_tree<T, Compare>::
emplace_unique(Args&& ...args)
{
THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree<T, Comp>'s size too big");
node_ptr np = create_node(mystl::forward<Args>(args)...);
auto res = get_insert_unique_pos(value_traits::get_key(np->value));
if (res.second)
{ //
return mystl::make_pair(insert_node_at(res.first.first, np, res.first.second), true);
}
destroy_node(np);
return mystl::make_pair(iterator(res.first.first), false);
}
// hint
template <class T, class Compare>
template <class ...Args>
typename rb_tree<T, Compare>::iterator
rb_tree<T, Compare>::
emplace_multi_use_hint(iterator hint, Args&& ...args)
{
THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree<T, Comp>'s size too big");
node_ptr np = create_node(mystl::forward<Args>(args)...);
if (node_count_ == 0)
{
return insert_node_at(header_, np, true);
}
key_type key = value_traits::get_key(np->value);
if (hint == begin())
{ // begin
if (key_comp_(key, value_traits::get_key(*hint)))
{
return insert_node_at(hint.node, np, true);
}
else
{
auto pos = get_insert_multi_pos(key);
return insert_node_at(pos.first, np, pos.second);
}
}
else if (hint == end())
{ // end
if (!key_comp_(key, value_traits::get_key(rightmost()->get_node_ptr()->value)))
{
return insert_node_at(rightmost(), np, false);
}
else
{
auto pos = get_insert_multi_pos(key);
return insert_node_at(pos.first, np, pos.second);
}
}
return insert_multi_use_hint(hint, key, np);
}
// hint
template<class T, class Compare>
template<class ...Args>
typename rb_tree<T, Compare>::iterator
rb_tree<T, Compare>::
emplace_unique_use_hint(iterator hint, Args&& ...args)
{
THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree<T, Comp>'s size too big");
node_ptr np = create_node(mystl::forward<Args>(args)...);
if (node_count_ == 0)
{
return insert_node_at(header_, np, true);
}
key_type key = value_traits::get_key(np->value);
if (hint == begin())
{ // begin
if (key_comp_(key, value_traits::get_key(*hint)))
{
return insert_node_at(hint.node, np, true);
}
else
{
auto pos = get_insert_unique_pos(key);
if (!pos.second)
{
destroy_node(np);
return pos.first.first;
}
return insert_node_at(pos.first.first, np, pos.first.second);
}
}
else if (hint == end())
{ // end
if (key_comp_(value_traits::get_key(rightmost()->get_node_ptr()->value), key))
{
return insert_node_at(rightmost(), np, false);
}
else
{
auto pos = get_insert_unique_pos(key);
if (!pos.second)
{
destroy_node(np);
return pos.first.first;
}
return insert_node_at(pos.first.first, np, pos.first.second);
}
}
return insert_unique_use_hint(hint, key, np);
}
//
template <class T, class Compare>
typename rb_tree<T, Compare>::iterator
rb_tree<T, Compare>::
insert_multi(const value_type& value)
{
THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree<T, Comp>'s size too big");
auto res = get_insert_multi_pos(value_traits::get_key(value));
return insert_value_at(res.first, value, res.second);
}
// pairpair true false
template <class T, class Compare>
mystl::pair<typename rb_tree<T, Compare>::iterator, bool>
rb_tree<T, Compare>::
insert_unique(const value_type& value)
{
THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree<T, Comp>'s size too big");
auto res = get_insert_unique_pos(value_traits::get_key(value));
if (res.second)
{ //
return mystl::make_pair(insert_value_at(res.first.first, value, res.first.second), true);
}
return mystl::make_pair(res.first.first, false);
}
// hint
template <class T, class Compare>
typename rb_tree<T, Compare>::iterator
rb_tree<T, Compare>::
erase(iterator hint)
{
auto node = hint.node->get_node_ptr();
iterator next(node);
++next;
rb_tree_erase_rebalance(hint.node, root(), leftmost(), rightmost());
destroy_node(node);
--node_count_;
return next;
}
// key
template <class T, class Compare>
typename rb_tree<T, Compare>::size_type
rb_tree<T, Compare>::
erase_multi(const key_type& key)
{
auto p = equal_range_multi(key);
size_type n = mystl::distance(p.first, p.second);
erase(p.first, p.second);
return n;
}
// key
template <class T, class Compare>
typename rb_tree<T, Compare>::size_type
rb_tree<T, Compare>::
erase_unique(const key_type& key)
{
auto it = find(key);
if (it != end())
{
erase(it);
return 1;
}
return 0;
}
// [first, last)
template <class T, class Compare>
void rb_tree<T, Compare>::
erase(iterator first, iterator last)
{
if (first == begin() && last == end())
{
clear();
}
else
{
while (first != last)
erase(first++);
}
}
// rb tree
template <class T, class Compare>
void rb_tree<T, Compare>::
clear()
{
if (node_count_ != 0)
{
erase_since(root());
leftmost() = header_;
root() = nullptr;
rightmost() = header_;
node_count_ = 0;
}
}
// k
template <class T, class Compare>
typename rb_tree<T, Compare>::iterator
rb_tree<T, Compare>::
find(const key_type& key)
{
auto y = header_; // key
auto x = root();
while (x != nullptr)
{
if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key))
{ // key x
y = x, x = x->left;
}
else
{ // key x
x = x->right;
}
}
iterator j = iterator(y);
return (j == end() || key_comp_(key, value_traits::get_key(*j))) ? end() : j;
}
template <class T, class Compare>
typename rb_tree<T, Compare>::const_iterator
rb_tree<T, Compare>::
find(const key_type& key) const
{
auto y = header_; // key
auto x = root();
while (x != nullptr)
{
if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key))
{ // key x
y = x, x = x->left;
}
else
{ // key x
x = x->right;
}
}
const_iterator j = const_iterator(y);
return (j == end() || key_comp_(key, value_traits::get_key(*j))) ? end() : j;
}
// key
template <class T, class Compare>
typename rb_tree<T, Compare>::iterator
rb_tree<T, Compare>::
lower_bound(const key_type& key)
{
auto y = header_;
auto x = root();
while (x != nullptr)
{
if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key))
{ // key <= x
y = x, x = x->left;
}
else
{
x = x->right;
}
}
return iterator(y);
}
template <class T, class Compare>
typename rb_tree<T, Compare>::const_iterator
rb_tree<T, Compare>::
lower_bound(const key_type& key) const
{
auto y = header_;
auto x = root();
while (x != nullptr)
{
if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key))
{ // key <= x
y = x, x = x->left;
}
else
{
x = x->right;
}
}
return const_iterator(y);
}
// key
template <class T, class Compare>
typename rb_tree<T, Compare>::iterator
rb_tree<T, Compare>::
upper_bound(const key_type& key)
{
auto y = header_;
auto x = root();
while (x != nullptr)
{
if (key_comp_(key, value_traits::get_key(x->get_node_ptr()->value)))
{ // key < x
y = x, x = x->left;
}
else
{
x = x->right;
}
}
return iterator(y);
}
template <class T, class Compare>
typename rb_tree<T, Compare>::const_iterator
rb_tree<T, Compare>::
upper_bound(const key_type& key) const
{
auto y = header_;
auto x = root();
while (x != nullptr)
{
if (key_comp_(key, value_traits::get_key(x->get_node_ptr()->value)))
{ // key < x
y = x, x = x->left;
}
else
{
x = x->right;
}
}
return const_iterator(y);
}
// rb tree
template <class T, class Compare>
void rb_tree<T, Compare>::
swap(rb_tree& rhs) noexcept
{
if (this != &rhs)
{
mystl::swap(header_, rhs.header_);
mystl::swap(node_count_, rhs.node_count_);
mystl::swap(key_comp_, rhs.key_comp_);
}
}
/*****************************************************************************************/
// helper function
//
template <class T, class Compare>
template <class ...Args>
typename rb_tree<T, Compare>::node_ptr
rb_tree<T, Compare>::
create_node(Args&&... args)
{
auto tmp = node_allocator::allocate(1);
try
{
data_allocator::construct(mystl::address_of(tmp->value), mystl::forward<Args>(args)...);
tmp->left = nullptr;
tmp->right = nullptr;
tmp->parent = nullptr;
}
catch (...)
{
node_allocator::deallocate(tmp);
throw;
}
return tmp;
}
//
template <class T, class Compare>
typename rb_tree<T, Compare>::node_ptr
rb_tree<T, Compare>::
clone_node(base_ptr x)
{
node_ptr tmp = create_node(x->get_node_ptr()->value);
tmp->color = x->color;
tmp->left = nullptr;
tmp->right = nullptr;
return tmp;
}
//
template <class T, class Compare>
void rb_tree<T, Compare>::
destroy_node(node_ptr p)
{
data_allocator::destroy(&p->value);
node_allocator::deallocate(p);
}
//
template <class T, class Compare>
void rb_tree<T, Compare>::
rb_tree_init()
{
header_ = base_allocator::allocate(1);
header_->color = rb_tree_red; // header_ root
root() = nullptr;
leftmost() = header_;
rightmost() = header_;
node_count_ = 0;
}
// reset
template <class T, class Compare>
void rb_tree<T, Compare>::reset()
{
header_ = nullptr;
node_count_ = 0;
}
// get_insert_multi_pos
template <class T, class Compare>
mystl::pair<typename rb_tree<T, Compare>::base_ptr, bool>
rb_tree<T, Compare>::get_insert_multi_pos(const key_type& key)
{
auto x = root();
auto y = header_;
bool add_to_left = true;
while (x != nullptr)
{
y = x;
add_to_left = key_comp_(key, value_traits::get_key(x->get_node_ptr()->value));
x = add_to_left ? x->left : x->right;
}
return mystl::make_pair(y, add_to_left);
}
// get_insert_unique_pos
template <class T, class Compare>
mystl::pair<mystl::pair<typename rb_tree<T, Compare>::base_ptr, bool>, bool>
rb_tree<T, Compare>::get_insert_unique_pos(const key_type& key)
{ // pair pair bool
// bool
auto x = root();
auto y = header_;
bool add_to_left = true; // header_
while (x != nullptr)
{
y = x;
add_to_left = key_comp_(key, value_traits::get_key(x->get_node_ptr()->value));
x = add_to_left ? x->left : x->right;
}
iterator j = iterator(y); // y
if (add_to_left)
{
if (y == header_ || j == begin())
{ //
return mystl::make_pair(mystl::make_pair(y, true), true);
}
else
{ // --j
--j;
}
}
if (key_comp_(value_traits::get_key(*j), key))
{ //
return mystl::make_pair(mystl::make_pair(y, add_to_left), true);
}
//
return mystl::make_pair(mystl::make_pair(y, add_to_left), false);
}
// insert_value_at
// x value add_to_left
template <class T, class Compare>
typename rb_tree<T, Compare>::iterator
rb_tree<T, Compare>::
insert_value_at(base_ptr x, const value_type& value, bool add_to_left)
{
node_ptr node = create_node(value);
node->parent = x;
auto base_node = node->get_base_ptr();
if (x == header_)
{
root() = base_node;
leftmost() = base_node;
rightmost() = base_node;
}
else if (add_to_left)
{
x->left = base_node;
if (leftmost() == x)
leftmost() = base_node;
}
else
{
x->right = base_node;
if (rightmost() == x)
rightmost() = base_node;
}
rb_tree_insert_rebalance(base_node, root());
++node_count_;
return iterator(node);
}
// x
// x node add_to_left
template <class T, class Compare>
typename rb_tree<T, Compare>::iterator
rb_tree<T, Compare>::
insert_node_at(base_ptr x, node_ptr node, bool add_to_left)
{
node->parent = x;
auto base_node = node->get_base_ptr();
if (x == header_)
{
root() = base_node;
leftmost() = base_node;
rightmost() = base_node;
}
else if (add_to_left)
{
x->left = base_node;
if (leftmost() == x)
leftmost() = base_node;
}
else
{
x->right = base_node;
if (rightmost() == x)
rightmost() = base_node;
}
rb_tree_insert_rebalance(base_node, root());
++node_count_;
return iterator(node);
}
// hint
template <class T, class Compare>
typename rb_tree<T, Compare>::iterator
rb_tree<T, Compare>::
insert_multi_use_hint(iterator hint, key_type key, node_ptr node)
{
// hint
auto np = hint.node;
auto before = hint;
--before;
auto bnp = before.node;
if (!key_comp_(key, value_traits::get_key(*before)) &&
!key_comp_(value_traits::get_key(*hint), key))
{ // before <= node <= hint
if (bnp->right == nullptr)
{
return insert_node_at(bnp, node, false);
}
else if (np->left == nullptr)
{
return insert_node_at(np, node, true);
}
}
auto pos = get_insert_multi_pos(key);
return insert_node_at(pos.first, node, pos.second);
}
// hint
template <class T, class Compare>
typename rb_tree<T, Compare>::iterator
rb_tree<T, Compare>::
insert_unique_use_hint(iterator hint, key_type key, node_ptr node)
{
// hint
auto np = hint.node;
auto before = hint;
--before;
auto bnp = before.node;
if (key_comp_(value_traits::get_key(*before), key) &&
key_comp_(key, value_traits::get_key(*hint)))
{ // before < node < hint
if (bnp->right == nullptr)
{
return insert_node_at(bnp, node, false);
}
else if (np->left == nullptr)
{
return insert_node_at(np, node, true);
}
}
auto pos = get_insert_unique_pos(key);
if (!pos.second)
{
destroy_node(node);
return pos.first.first;
}
return insert_node_at(pos.first.first, node, pos.first.second);
}
// copy_from
// x p x
template <class T, class Compare>
typename rb_tree<T, Compare>::base_ptr
rb_tree<T, Compare>::copy_from(base_ptr x, base_ptr p)
{
auto top = clone_node(x);
top->parent = p;
try
{
if (x->right)
top->right = copy_from(x->right, top);
p = top;
x = x->left;
while (x != nullptr)
{
auto y = clone_node(x);
p->left = y;
y->parent = p;
if (x->right)
y->right = copy_from(x->right, y);
p = y;
x = x->left;
}
}
catch (...)
{
erase_since(top);
throw;
}
return top;
}
// erase_since
// x
template <class T, class Compare>
void rb_tree<T, Compare>::
erase_since(base_ptr x)
{
while (x != nullptr)
{
erase_since(x->right);
auto y = x->left;
destroy_node(x->get_node_ptr());
x = y;
}
}
//
template <class T, class Compare>
bool operator==(const rb_tree<T, Compare>& lhs, const rb_tree<T, Compare>& rhs)
{
return lhs.size() == rhs.size() && mystl::equal(lhs.begin(), lhs.end(), rhs.begin());
}
template <class T, class Compare>
bool operator<(const rb_tree<T, Compare>& lhs, const rb_tree<T, Compare>& rhs)
{
return mystl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
template <class T, class Compare>
bool operator!=(const rb_tree<T, Compare>& lhs, const rb_tree<T, Compare>& rhs)
{
return !(lhs == rhs);
}
template <class T, class Compare>
bool operator>(const rb_tree<T, Compare>& lhs, const rb_tree<T, Compare>& rhs)
{
return rhs < lhs;
}
template <class T, class Compare>
bool operator<=(const rb_tree<T, Compare>& lhs, const rb_tree<T, Compare>& rhs)
{
return !(rhs < lhs);
}
template <class T, class Compare>
bool operator>=(const rb_tree<T, Compare>& lhs, const rb_tree<T, Compare>& rhs)
{
return !(lhs < rhs);
}
// mystl swap
template <class T, class Compare>
void swap(rb_tree<T, Compare>& lhs, rb_tree<T, Compare>& rhs) noexcept
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_RB_TREE_H_
``` | /content/code_sandbox/MyTinySTL/rb_tree.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 11,266 |
```objective-c
#ifndef MYTINYSTL_NUMERIC_H_
#define MYTINYSTL_NUMERIC_H_
// mystl
#include "iterator.h"
namespace mystl
{
/*****************************************************************************************/
// accumulate
// 1 init
// 2 init
/*****************************************************************************************/
// 1
template <class InputIter, class T>
T accumulate(InputIter first, InputIter last, T init)
{
for (; first != last; ++first)
{
init += *first;
}
return init;
}
// 2
template <class InputIter, class T, class BinaryOp>
T accumulate(InputIter first, InputIter last, T init, BinaryOp binary_op)
{
for (; first != last; ++first)
{
init = binary_op(init, *first);
}
return init;
}
/*****************************************************************************************/
// adjacent_difference
// 1 result
// 2
/*****************************************************************************************/
// 1
template <class InputIter, class OutputIter>
OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter result)
{
if (first == last) return result;
*result = *first; //
auto value = *first;
while (++first != last)
{
auto tmp = *first;
*++result = tmp - value;
value = tmp;
}
return ++result;
}
// 2
template <class InputIter, class OutputIter, class BinaryOp>
OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter result,
BinaryOp binary_op)
{
if (first == last) return result;
*result = *first; //
auto value = *first;
while (++first != last)
{
auto tmp = *first;
*++result = binary_op(tmp, value);
value = tmp;
}
return ++result;
}
/*****************************************************************************************/
// inner_product
// 1 init
// 2 operator+ operator*
/*****************************************************************************************/
// 1
template <class InputIter1, class InputIter2, class T>
T inner_product(InputIter1 first1, InputIter1 last1, InputIter2 first2, T init)
{
for (; first1 != last1; ++first1, ++first2)
{
init = init + (*first1 * *first2);
}
return init;
}
// 2
template <class InputIter1, class InputIter2, class T, class BinaryOp1, class BinaryOp2>
T inner_product(InputIter1 first1, InputIter1 last1, InputIter2 first2, T init,
BinaryOp1 binary_op1, BinaryOp2 binary_op2)
{
for (; first1 != last1; ++first1, ++first2)
{
init = binary_op1(init, binary_op2(*first1, *first2));
}
return init;
}
/*****************************************************************************************/
// iota
// [first, last) value
/*****************************************************************************************/
template <class ForwardIter, class T>
void iota(ForwardIter first, ForwardIter last, T value)
{
while (first != last)
{
*first++ = value;
++value;
}
}
/*****************************************************************************************/
// partial_sum
// 1 result
// 2
/*****************************************************************************************/
template <class InputIter, class OutputIter>
OutputIter partial_sum(InputIter first, InputIter last, OutputIter result)
{
if (first == last) return result;
*result = *first; //
auto value = *first;
while (++first != last)
{
value = value + *first;
*++result = value;
}
return ++result;
}
// 2
template <class InputIter, class OutputIter, class BinaryOp>
OutputIter partial_sum(InputIter first, InputIter last, OutputIter result,
BinaryOp binary_op)
{
if (first == last) return result;
*result = *first; //
auto value = *first;
while (++first != last)
{
value = binary_op(value, *first);
*++result = value;
}
return ++result;
}
} // namespace mystl
#endif // !MYTINYSTL_NUMERIC_H_
``` | /content/code_sandbox/MyTinySTL/numeric.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 904 |
```objective-c
#ifndef MYTINYSTL_ASTRING_H_
#define MYTINYSTL_ASTRING_H_
// string, wstring, u16string, u32string
#include "basic_string.h"
namespace mystl
{
using string = mystl::basic_string<char>;
using wstring = mystl::basic_string<wchar_t>;
using u16string = mystl::basic_string<char16_t>;
using u32string = mystl::basic_string<char32_t>;
}
#endif // !MYTINYSTL_ASTRING_H_
``` | /content/code_sandbox/MyTinySTL/astring.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 113 |
```objective-c
#ifndef MYTINYSTL_ALGO_H_
#define MYTINYSTL_ALGO_H_
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4244)
#endif
// mystl
#include <cstddef>
#include <ctime>
#include "algobase.h"
#include "memory.h"
#include "heap_algo.h"
#include "functional.h"
namespace mystl
{
/*****************************************************************************************/
// all_of
// [first, last) unary_pred true true
/*****************************************************************************************/
template <class InputIter, class UnaryPredicate>
bool all_of(InputIter first, InputIter last, UnaryPredicate unary_pred)
{
for (; first != last; ++first)
{
if (!unary_pred(*first))
return false;
}
return true;
}
/*****************************************************************************************/
// any_of
// [first, last) unary_pred true true
/*****************************************************************************************/
template <class InputIter, class UnaryPredicate>
bool any_of(InputIter first, InputIter last, UnaryPredicate unary_pred)
{
for (; first != last; ++first)
{
if (unary_pred(*first))
return true;
}
return false;
}
/*****************************************************************************************/
// none_of
// [first, last) unary_pred true true
/*****************************************************************************************/
template <class InputIter, class UnaryPredicate>
bool none_of(InputIter first, InputIter last, UnaryPredicate unary_pred)
{
for (; first != last; ++first)
{
if (unary_pred(*first))
return false;
}
return true;
}
/*****************************************************************************************/
// count
// [first, last) operator==
/*****************************************************************************************/
template <class InputIter, class T>
size_t count(InputIter first, InputIter last, const T& value)
{
size_t n = 0;
for (; first != last; ++first)
{
if (*first == value)
++n;
}
return n;
}
/*****************************************************************************************/
// count_if
// [first, last) unary_pred true
/*****************************************************************************************/
template <class InputIter, class UnaryPredicate>
size_t count_if(InputIter first, InputIter last, UnaryPredicate unary_pred)
{
size_t n = 0;
for (; first != last; ++first)
{
if (unary_pred(*first))
++n;
}
return n;
}
/*****************************************************************************************/
// find
// [first, last) value
/*****************************************************************************************/
template <class InputIter, class T>
InputIter
find(InputIter first, InputIter last, const T& value)
{
while (first != last && *first != value)
++first;
return first;
}
/*****************************************************************************************/
// find_if
// [first, last) unary_pred true
/*****************************************************************************************/
template <class InputIter, class UnaryPredicate>
InputIter
find_if(InputIter first, InputIter last, UnaryPredicate unary_pred)
{
while (first != last && !unary_pred(*first))
++first;
return first;
}
/*****************************************************************************************/
// find_if_not
// [first, last) unary_pred false
/*****************************************************************************************/
template <class InputIter, class UnaryPredicate>
InputIter
find_if_not(InputIter first, InputIter last, UnaryPredicate unary_pred)
{
while (first != last && unary_pred(*first))
++first;
return first;
}
/*****************************************************************************************/
// search
// [first1, last1)[first2, last2)
/*****************************************************************************************/
template <class ForwardIter1, class ForwardIter2>
ForwardIter1
search(ForwardIter1 first1, ForwardIter1 last1,
ForwardIter2 first2, ForwardIter2 last2)
{
auto d1 = mystl::distance(first1, last1);
auto d2 = mystl::distance(first2, last2);
if (d1 < d2)
return last1;
auto current1 = first1;
auto current2 = first2;
while (current2 != last2)
{
if (*current1 == *current2)
{
++current1;
++current2;
}
else
{
if (d1 == d2)
{
return last1;
}
else
{
current1 = ++first1;
current2 = first2;
--d1;
}
}
}
return first1;
}
// comp
template <class ForwardIter1, class ForwardIter2, class Compared>
ForwardIter1
search(ForwardIter1 first1, ForwardIter1 last1,
ForwardIter2 first2, ForwardIter2 last2, Compared comp)
{
auto d1 = mystl::distance(first1, last1);
auto d2 = mystl::distance(first2, last2);
if (d1 < d2)
return last1;
auto current1 = first1;
auto current2 = first2;
while (current2 != last2)
{
if (comp(*current1, *current2))
{
++current1;
++current2;
}
else
{
if (d1 == d2)
{
return last1;
}
else
{
current1 = ++first1;
current2 = first2;
--d1;
}
}
}
return first1;
}
/*****************************************************************************************/
// search_n
// [first, last) n value
/*****************************************************************************************/
template <class ForwardIter, class Size, class T>
ForwardIter
search_n(ForwardIter first, ForwardIter last, Size n, const T& value)
{
if (n <= 0)
{
return first;
}
else
{
first = mystl::find(first, last, value);
while (first != last)
{
auto m = n - 1;
auto i = first;
++i;
while (i != last && m != 0 && *i == value)
{
++i;
--m;
}
if (m == 0)
{
return first;
}
else
{
first = mystl::find(i, last, value);
}
}
return last;
}
}
// comp
template <class ForwardIter, class Size, class T, class Compared>
ForwardIter
search_n(ForwardIter first, ForwardIter last,
Size n, const T& value, Compared comp)
{
if (n <= 0)
{
return first;
}
else
{
while (first != last)
{
if (comp(*first, value))
break;
++first;
}
while (first != last)
{
auto m = n - 1;
auto i = first;
++i;
while (i != last && m != 0 && comp(*i, value))
{
++i;
--m;
}
if (m == 0)
{
return first;
}
else
{
while (i != last)
{
if (comp(*i, value))
break;
++i;
}
first = i;
}
}
return last;
}
}
/*****************************************************************************************/
// find_end
// [first1, last1)[first2, last2) last1
/*****************************************************************************************/
// find_end_dispatch forward_iterator_tag
template <class ForwardIter1, class ForwardIter2>
ForwardIter1
find_end_dispatch(ForwardIter1 first1, ForwardIter1 last1,
ForwardIter2 first2, ForwardIter2 last2,
forward_iterator_tag, forward_iterator_tag)
{
if (first2 == last2)
{
return last1;
}
else
{
auto result = last1;
while (true)
{
// search last1
auto new_result = mystl::search(first1, last1, first2, last2);
if (new_result == last1)
{
return result;
}
else
{
result = new_result;
first1 = new_result;
++first1;
}
}
}
}
// find_end_dispatch bidirectional_iterator_tag
template <class BidirectionalIter1, class BidirectionalIter2>
BidirectionalIter1
find_end_dispatch(BidirectionalIter1 first1, BidirectionalIter1 last1,
BidirectionalIter2 first2, BidirectionalIter2 last2,
bidirectional_iterator_tag, bidirectional_iterator_tag)
{
typedef reverse_iterator<BidirectionalIter1> reviter1;
typedef reverse_iterator<BidirectionalIter2> reviter2;
reviter1 rlast1(first1);
reviter2 rlast2(first2);
reviter1 rresult = mystl::search(reviter1(last1), rlast1, reviter2(last2), rlast2);
if (rresult == rlast1)
{
return last1;
}
else
{
auto result = rresult.base();
mystl::advance(result, -mystl::distance(first2, last2));
return result;
}
}
template <class ForwardIter1, class ForwardIter2>
ForwardIter1
find_end(ForwardIter1 first1, ForwardIter1 last1,
ForwardIter2 first2, ForwardIter2 last2)
{
typedef typename iterator_traits<ForwardIter1>::iterator_category Category1;
typedef typename iterator_traits<ForwardIter2>::iterator_category Category2;
return mystl::find_end_dispatch(first1, last1, first2, last2, Category1(), Category2());
}
// comp
// find_end_dispatch forward_iterator_tag
template <class ForwardIter1, class ForwardIter2, class Compared>
ForwardIter1
find_end_dispatch(ForwardIter1 first1, ForwardIter1 last1,
ForwardIter2 first2, ForwardIter2 last2,
forward_iterator_tag, forward_iterator_tag, Compared comp)
{
if (first2 == last2)
{
return last1;
}
else
{
auto result = last1;
while (true)
{
// search last1
auto new_result = mystl::search(first1, last1, first2, last2, comp);
if (new_result == last1)
{
return result;
}
else
{
result = new_result;
first1 = new_result;
++first1;
}
}
}
}
// find_end_dispatch bidirectional_iterator_tag
template <class BidirectionalIter1, class BidirectionalIter2, class Compared>
BidirectionalIter1
find_end_dispatch(BidirectionalIter1 first1, BidirectionalIter1 last1,
BidirectionalIter2 first2, BidirectionalIter2 last2,
bidirectional_iterator_tag, bidirectional_iterator_tag, Compared comp)
{
typedef reverse_iterator<BidirectionalIter1> reviter1;
typedef reverse_iterator<BidirectionalIter2> reviter2;
reviter1 rlast1(first1);
reviter2 rlast2(first2);
reviter1 rresult = mystl::search(reviter1(last1), rlast1, reviter2(last2), rlast2, comp);
if (rresult == rlast1)
{
return last1;
}
else
{
auto result = rresult.base();
mystl::advance(result, -mystl::distance(first2, last2));
return result;
}
}
template <class ForwardIter1, class ForwardIter2, class Compared>
ForwardIter1
find_end(ForwardIter1 first1, ForwardIter1 last1,
ForwardIter2 first2, ForwardIter2 last2, Compared comp)
{
typedef typename iterator_traits<ForwardIter1>::iterator_category Category1;
typedef typename iterator_traits<ForwardIter2>::iterator_category Category2;
return mystl::find_end_dispatch(first1, last1, first2, last2, Category1(), Category2(), comp);
}
/*****************************************************************************************/
// find_first_of
// [first1, last1)[first2, last2)
/*****************************************************************************************/
template <class InputIter, class ForwardIter>
InputIter
find_first_of(InputIter first1, InputIter last1,
ForwardIter first2, ForwardIter last2)
{
for (; first1 != last1; ++first1)
{
for (auto iter = first2; iter != last2; ++iter)
{
if (*first1 == *iter)
return first1;
}
}
return last1;
}
// comp
template <class InputIter, class ForwardIter, class Compared>
InputIter
find_first_of(InputIter first1, InputIter last1,
ForwardIter first2, ForwardIter last2, Compared comp)
{
for (; first1 != last1; ++first1)
{
for (auto iter = first2; iter != last2; ++iter)
{
if (comp(*first1, *iter))
return first1;
}
}
return last1;
}
/*****************************************************************************************/
// for_each
// f [first, last) operator()
// f()
/*****************************************************************************************/
template <class InputIter, class Function>
Function for_each(InputIter first, InputIter last, Function f)
{
for (; first != last; ++first)
{
f(*first);
}
return f;
}
/*****************************************************************************************/
// adjacent_find
// operator==
/*****************************************************************************************/
template <class ForwardIter>
ForwardIter adjacent_find(ForwardIter first, ForwardIter last)
{
if (first == last) return last;
auto next = first;
while (++next != last)
{
if (*first == *next) return first;
first = next;
}
return last;
}
// comp
template <class ForwardIter, class Compared>
ForwardIter adjacent_find(ForwardIter first, ForwardIter last, Compared comp)
{
if (first == last) return last;
auto next = first;
while (++next != last)
{
if (comp(*first, *next)) return first;
first = next;
}
return last;
}
/*****************************************************************************************/
// lower_bound
// [first, last) value last
/*****************************************************************************************/
// lbound_dispatch forward_iterator_tag
template <class ForwardIter, class T>
ForwardIter
lbound_dispatch(ForwardIter first, ForwardIter last,
const T& value, forward_iterator_tag)
{
auto len = mystl::distance(first, last);
auto half = len;
ForwardIter middle;
while (len > 0)
{
half = len >> 1;
middle = first;
mystl::advance(middle, half);
if (*middle < value)
{
first = middle;
++first;
len = len - half - 1;
}
else
{
len = half;
}
}
return first;
}
// lbound_dispatch random_access_iterator_tag
template <class RandomIter, class T>
RandomIter
lbound_dispatch(RandomIter first, RandomIter last,
const T& value, random_access_iterator_tag)
{
auto len = last - first;
auto half = len;
RandomIter middle;
while (len > 0)
{
half = len >> 1;
middle = first + half;
if (*middle < value)
{
first = middle + 1;
len = len - half - 1;
}
else
{
len = half;
}
}
return first;
}
template <class ForwardIter, class T>
ForwardIter
lower_bound(ForwardIter first, ForwardIter last, const T& value)
{
return mystl::lbound_dispatch(first, last, value, iterator_category(first));
}
// comp
// lbound_dispatch forward_iterator_tag
template <class ForwardIter, class T, class Compared>
ForwardIter
lbound_dispatch(ForwardIter first, ForwardIter last,
const T& value, forward_iterator_tag, Compared comp)
{
auto len = mystl::distance(first, last);
auto half = len;
ForwardIter middle;
while (len > 0)
{
half = len >> 1;
middle = first;
mystl::advance(middle, half);
if (comp(*middle, value))
{
first = middle;
++first;
len = len - half - 1;
}
else
{
len = half;
}
}
return first;
}
// lbound_dispatch random_access_iterator_tag
template <class RandomIter, class T, class Compared>
RandomIter
lbound_dispatch(RandomIter first, RandomIter last,
const T& value, random_access_iterator_tag, Compared comp)
{
auto len = last - first;
auto half = len;
RandomIter middle;
while (len > 0)
{
half = len >> 1;
middle = first + half;
if (comp(*middle, value))
{
first = middle + 1;
len = len - half - 1;
}
else
{
len = half;
}
}
return first;
}
template <class ForwardIter, class T, class Compared>
ForwardIter
lower_bound(ForwardIter first, ForwardIter last, const T& value, Compared comp)
{
return mystl::lbound_dispatch(first, last, value, iterator_category(first), comp);
}
/*****************************************************************************************/
// upper_bound
// [first, last)value last
/*****************************************************************************************/
// ubound_dispatch forward_iterator_tag
template <class ForwardIter, class T>
ForwardIter
ubound_dispatch(ForwardIter first, ForwardIter last,
const T& value, forward_iterator_tag)
{
auto len = mystl::distance(first, last);
auto half = len;
ForwardIter middle;
while (len > 0)
{
half = len >> 1;
middle = first;
mystl::advance(middle, half);
if (value < *middle)
{
len = half;
}
else
{
first = middle;
++first;
len = len - half - 1;
}
}
return first;
}
// ubound_dispatch random_access_iterator_tag
template <class RandomIter, class T>
RandomIter
ubound_dispatch(RandomIter first, RandomIter last,
const T& value, random_access_iterator_tag)
{
auto len = last - first;
auto half = len;
RandomIter middle;
while (len > 0)
{
half = len >> 1;
middle = first + half;
if (value < *middle)
{
len = half;
}
else
{
first = middle + 1;
len = len - half - 1;
}
}
return first;
}
template <class ForwardIter, class T>
ForwardIter
upper_bound(ForwardIter first, ForwardIter last, const T& value)
{
return mystl::ubound_dispatch(first, last, value, iterator_category(first));
}
// comp
// ubound_dispatch forward_iterator_tag
template <class ForwardIter, class T, class Compared>
ForwardIter
ubound_dispatch(ForwardIter first, ForwardIter last,
const T& value, forward_iterator_tag, Compared comp)
{
auto len = mystl::distance(first, last);
auto half = len;
ForwardIter middle;
while (len > 0)
{
half = len >> 1;
middle = first;
mystl::advance(middle, half);
if (comp(value, *middle))
{
len = half;
}
else
{
first = middle;
++first;
len = len - half - 1;
}
}
return first;
}
// ubound_dispatch random_access_iterator_tag
template <class RandomIter, class T, class Compared>
RandomIter
ubound_dispatch(RandomIter first, RandomIter last,
const T& value, random_access_iterator_tag, Compared comp)
{
auto len = last - first;
auto half = len;
RandomIter middle;
while (len > 0)
{
half = len >> 1;
middle = first + half;
if (comp(value, *middle))
{
len = half;
}
else
{
first = middle + 1;
len = len - half - 1;
}
}
return first;
}
template <class ForwardIter, class T, class Compared>
ForwardIter
upper_bound(ForwardIter first, ForwardIter last, const T& value, Compared comp)
{
return mystl::ubound_dispatch(first, last, value, iterator_category(first), comp);
}
/*****************************************************************************************/
// binary_search
// [first, last) value true false
/*****************************************************************************************/
template <class ForwardIter, class T>
bool binary_search(ForwardIter first, ForwardIter last, const T& value)
{
auto i = mystl::lower_bound(first, last, value);
return i != last && !(value < *i);
}
// comp
template <class ForwardIter, class T, class Compared>
bool binary_search(ForwardIter first, ForwardIter last, const T& value, Compared comp)
{
auto i = mystl::lower_bound(first, last, value);
return i != last && !comp(value, *i);
}
/*****************************************************************************************/
// equal_range
// [first,last) value
// value value
/*****************************************************************************************/
// erange_dispatch forward_iterator_tag
template <class ForwardIter, class T>
mystl::pair<ForwardIter, ForwardIter>
erange_dispatch(ForwardIter first, ForwardIter last,
const T& value, forward_iterator_tag)
{
auto len = mystl::distance(first, last);
auto half = len;
ForwardIter middle, left, right;
while (len > 0)
{
half = len >> 1;
middle = first;
mystl::advance(middle, half);
if (*middle < value)
{
first = middle;
++first;
len = len - half - 1;
}
else if (value < *middle)
{
len = half;
}
else
{
left = mystl::lower_bound(first, last, value);
mystl::advance(first, len);
right = mystl::upper_bound(++middle, first, value);
return mystl::pair<ForwardIter, ForwardIter>(left, right);
}
}
return mystl::pair<ForwardIter, ForwardIter>(last, last);
}
// erange_dispatch random_access_iterator_tag
template <class RandomIter, class T>
mystl::pair<RandomIter, RandomIter>
erange_dispatch(RandomIter first, RandomIter last,
const T& value, random_access_iterator_tag)
{
auto len = last - first;
auto half = len;
RandomIter middle, left, right;
while (len > 0)
{
half = len >> 1;
middle = first + half;
if (*middle < value)
{
first = middle + 1;
len = len - half - 1;
}
else if (value < *middle)
{
len = half;
}
else
{
left = mystl::lower_bound(first, middle, value);
right = mystl::upper_bound(++middle, first + len, value);
return mystl::pair<RandomIter, RandomIter>(left, right);
}
}
return mystl::pair<RandomIter, RandomIter>(last, last);
}
template <class ForwardIter, class T>
mystl::pair<ForwardIter, ForwardIter>
equal_range(ForwardIter first, ForwardIter last, const T& value)
{
return mystl::erange_dispatch(first, last, value, iterator_category(first));
}
// comp
// erange_dispatch forward iterator
template <class ForwardIter, class T, class Compared>
mystl::pair<ForwardIter, ForwardIter>
erange_dispatch(ForwardIter first, ForwardIter last,
const T& value, forward_iterator_tag, Compared comp)
{
auto len = mystl::distance(first, last);
auto half = len;
ForwardIter middle, left, right;
while (len > 0)
{
half = len >> 1;
middle = first;
mystl::advance(middle, half);
if (comp(*middle, value))
{
first = middle;
++first;
len = len - half - 1;
}
else if (comp(value, *middle))
{
len = half;
}
else
{
left = mystl::lower_bound(first, last, value, comp);
mystl::advance(first, len);
right = mystl::upper_bound(++middle, first, value, comp);
return mystl::pair<ForwardIter, ForwardIter>(left, right);
}
}
return mystl::pair<ForwardIter, ForwardIter>(last, last);
}
// erange_dispatch random access iterator
template <class RandomIter, class T, class Compared>
mystl::pair<RandomIter, RandomIter>
erange_dispatch(RandomIter first, RandomIter last,
const T& value, random_access_iterator_tag, Compared comp)
{
auto len = last - first;
auto half = len;
RandomIter middle, left, right;
while (len > 0)
{
half = len >> 1;
middle = first + half;
if (comp(*middle, value))
{
first = middle + 1;
len = len - half - 1;
}
else if (comp(value, *middle))
{
len = half;
}
else
{
left = mystl::lower_bound(first, middle, value, comp);
right = mystl::upper_bound(++middle, first + len, value, comp);
return mystl::pair<RandomIter, RandomIter>(left, right);
}
}
return mystl::pair<RandomIter, RandomIter>(last, last);
}
template <class ForwardIter, class T, class Compared>
mystl::pair<ForwardIter, ForwardIter>
equal_range(ForwardIter first, ForwardIter last, const T& value, Compared comp)
{
return mystl::erange_dispatch(first, last, value, iterator_category(first), comp);
}
/*****************************************************************************************/
// generate
// gen [first, last)
/*****************************************************************************************/
template <class ForwardIter, class Generator>
void generate(ForwardIter first, ForwardIter last, Generator gen)
{
for (; first != last; ++first)
{
*first = gen();
}
}
/*****************************************************************************************/
// generate_n
// gen n
/*****************************************************************************************/
template <class ForwardIter, class Size, class Generator>
void generate_n(ForwardIter first, Size n, Generator gen)
{
for (; n > 0; --n, ++first)
{
*first = gen();
}
}
/*****************************************************************************************/
// includes
// S1 S2
/*****************************************************************************************/
template <class InputIter1, class InputIter2>
bool includes(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2)
{
while (first1 != last1 && first2 != last2)
{
if (*first2 < *first1)
{
return false;
}
else if (*first1 < *first2)
{
++first1;
}
else
{
++first1, ++first2;
}
}
return first2 == last2;
}
// comp
template <class InputIter1, class InputIter2, class Compared>
bool includes(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2, Compared comp)
{
while (first1 != last1 && first2 != last2)
{
if (comp(*first2, *first1))
{
return false;
}
else if (comp(*first1, *first2))
{
++first1;
}
else
{
++first1, ++first2;
}
}
return first2 == last2;
}
/*****************************************************************************************/
// is_heap
// [first, last) true
/*****************************************************************************************/
template <class RandomIter>
bool is_heap(RandomIter first, RandomIter last)
{
auto n = mystl::distance(first, last);
auto parent = 0;
for (auto child = 1; child < n; ++child)
{
if (first[parent] < first[child])
return false;
if ((child & 1) == 0)
++parent;
}
return true;
}
// comp
template <class RandomIter, class Compared>
bool is_heap(RandomIter first, RandomIter last, Compared comp)
{
auto n = mystl::distance(first, last);
auto parent = 0;
for (auto child = 1; child < n; ++child)
{
if (comp(first[parent], first[child]))
return false;
if ((child & 1) == 0)
++parent;
}
return true;
}
/*****************************************************************************************/
// is_sorted
// [first, last) true
/*****************************************************************************************/
template <class ForwardIter>
bool is_sorted(ForwardIter first, ForwardIter last)
{
if (first == last)
return true;
auto next = first;
++next;
for (; next != last; first = next, ++next)
{
if (*next < *first)
return false;
}
return true;
}
// comp
template <class ForwardIter, class Compared>
bool is_sorted(ForwardIter first, ForwardIter last, Compared comp)
{
if (first == last)
return true;
auto next = first;
++next;
for (; next != last; first = next, ++next)
{
if (comp(*next, *first))
return false;
}
return true;
}
/*****************************************************************************************/
// median
//
/*****************************************************************************************/
template <class T>
const T& median(const T& left, const T& mid, const T& right)
{
if (left < mid)
if (mid < right) // left < mid < right
return mid;
else if (left < right) // left < right <= mid
return right;
else // right <= left < mid
return left;
else if (left < right) // mid <= left < right
return left;
else if (mid < right) // mid < right <= left
return right;
else // right <= mid <= left
return mid;
}
// comp
template <class T, class Compared>
const T& median(const T& left, const T& mid, const T& right, Compared comp)
{
if (comp(left, mid))
if (comp(mid, right))
return mid;
else if (comp(left, right))
return right;
else
return left;
else if (comp(left, right))
return left;
else if (comp(mid, right))
return right;
else
return mid;
}
/*****************************************************************************************/
// max_element
//
/*****************************************************************************************/
template <class ForwardIter>
ForwardIter max_element(ForwardIter first, ForwardIter last)
{
if (first == last)
return first;
auto result = first;
while (++first != last)
{
if (*result < *first)
result = first;
}
return result;
}
// comp
template <class ForwardIter, class Compared>
ForwardIter max_element(ForwardIter first, ForwardIter last, Compared comp)
{
if (first == last)
return first;
auto result = first;
while (++first != last)
{
if (comp(*result, *first))
result = first;
}
return result;
}
/*****************************************************************************************/
// min_element
//
/*****************************************************************************************/
template <class ForwardIter>
ForwardIter min_elememt(ForwardIter first, ForwardIter last)
{
if (first == last)
return first;
auto result = first;
while (++first != last)
{
if (*first < *result)
result = first;
}
return result;
}
// comp
template <class ForwardIter, class Compared>
ForwardIter min_elememt(ForwardIter first, ForwardIter last, Compared comp)
{
if (first == last)
return first;
auto result = first;
while (++first != last)
{
if (comp(*first, *result))
result = first;
}
return result;
}
/*****************************************************************************************/
// swap_ranges
// [first1, last1) first2
//
/*****************************************************************************************/
template <class ForwardIter1, class ForwardIter2>
ForwardIter2
swap_ranges(ForwardIter1 first1, ForwardIter1 last1,
ForwardIter2 first2)
{
for (; first1 != last1; ++first1, ++first2)
{
mystl::iter_swap(first1, first2);
}
return first2;
}
/*****************************************************************************************/
// transform
// unary_op [first, last) result
// binary_op [first1, last1)[first2, last2)
/*****************************************************************************************/
template <class InputIter, class OutputIter, class UnaryOperation>
OutputIter
transform(InputIter first, InputIter last,
OutputIter result, UnaryOperation unary_op)
{
for (; first != last; ++first, ++result)
{
*result = unary_op(*first);
}
return result;
}
template <class InputIter1, class InputIter2, class OutputIter, class BinaryOperation>
OutputIter
transform(InputIter1 first1, InputIter1 last1,
InputIter2 first2, OutputIter result, BinaryOperation binary_op)
{
for (; first1 != last1; ++first1, ++first2, ++result)
{
*result = binary_op(*first1, *first2);
}
return result;
}
/*****************************************************************************************/
// remove_copy
// value result
/*****************************************************************************************/
template <class InputIter, class OutputIter, class T>
OutputIter
remove_copy(InputIter first, InputIter last, OutputIter result, const T& value)
{
for (; first != last; ++first)
{
if (*first != value)
{
*result++ = *first;
}
}
return result;
}
/*****************************************************************************************/
// remove
// value
// remove remove_if array
/*****************************************************************************************/
template <class ForwardIter, class T>
ForwardIter remove(ForwardIter first, ForwardIter last, const T& value)
{
first = mystl::find(first, last, value); // find
auto next = first;
return first == last ? first : mystl::remove_copy(++next, last, first, value);
}
/*****************************************************************************************/
// remove_copy_if
// unary_pred true result
/*****************************************************************************************/
template <class InputIter, class OutputIter, class UnaryPredicate>
OutputIter
remove_copy_if(InputIter first, InputIter last,
OutputIter result, UnaryPredicate unary_pred)
{
for (; first != last; ++first)
{
if (!unary_pred(*first))
{
*result = *first;
++result;
}
}
return result;
}
/*****************************************************************************************/
// remove_if
// unary_pred true
/*****************************************************************************************/
template <class ForwardIter, class UnaryPredicate>
ForwardIter
remove_if(ForwardIter first, ForwardIter last, UnaryPredicate unary_pred)
{
first = mystl::find_if(first, last, unary_pred); // find_if
auto next = first;
return first == last ? first : mystl::remove_copy_if(++next, last, first, unary_pred);
}
/*****************************************************************************************/
// replace
// old_value new_value
/*****************************************************************************************/
template <class ForwardIter, class T>
void replace(ForwardIter first, ForwardIter last,
const T& old_value, const T& new_value)
{
for (; first != last; ++first)
{
if (*first == old_value)
*first = new_value;
}
}
/*****************************************************************************************/
// replace_copy
// replace result
/*****************************************************************************************/
template <class InputIter, class OutputIter, class T>
OutputIter
replace_copy(InputIter first, InputIter last,
OutputIter result, const T& old_value, const T& new_value)
{
for (; first != last; ++first, ++result)
{
*result = *first == old_value ? new_value : *first;
}
return result;
}
/*****************************************************************************************/
// replace_copy_if
// replace_if result
/*****************************************************************************************/
template <class InputIter, class OutputIter, class UnaryPredicate, class T>
OutputIter
replace_copy_if(InputIter first, InputIter last,
OutputIter result, UnaryPredicate unary_pred, const T& new_value)
{
for (; first != last; ++first, ++result)
{
*result = unary_pred(*first) ? new_value : *first;
}
return result;
}
/*****************************************************************************************/
// replace_if
// unary_pred true new_value
/*****************************************************************************************/
template <class ForwardIter, class UnaryPredicate, class T>
void replace_if(ForwardIter first, ForwardIter last,
UnaryPredicate unary_pred, const T& new_value)
{
for (; first != last; ++first)
{
if (unary_pred(*first))
*first = new_value;
}
}
/*****************************************************************************************/
// reverse
// [first, last)
/*****************************************************************************************/
// reverse_dispatch bidirectional_iterator_tag
template <class BidirectionalIter>
void reverse_dispatch(BidirectionalIter first, BidirectionalIter last,
bidirectional_iterator_tag)
{
while (true)
{
if (first == last || first == --last)
return;
mystl::iter_swap(first++, last);
}
}
// reverse_dispatch random_access_iterator_tag
template <class RandomIter>
void reverse_dispatch(RandomIter first, RandomIter last,
random_access_iterator_tag)
{
while (first < last)
mystl::iter_swap(first++, --last);
}
template <class BidirectionalIter>
void reverse(BidirectionalIter first, BidirectionalIter last)
{
mystl::reverse_dispatch(first, last, iterator_category(first));
}
/*****************************************************************************************/
// reverse_copy
// reverse result
/*****************************************************************************************/
template <class BidirectionalIter, class OutputIter>
OutputIter
reverse_copy(BidirectionalIter first, BidirectionalIter last,
OutputIter result)
{
while (first != last)
{
--last;
*result = *last;
++result;
}
return result;
}
/*****************************************************************************************/
// random_shuffle
// [first, last)
// rand
/*****************************************************************************************/
template <class RandomIter>
void random_shuffle(RandomIter first, RandomIter last)
{
if (first == last)
return;
srand((unsigned)time(0));
for (auto i = first + 1; i != last; ++i)
{
mystl::iter_swap(i, first + (rand() % (i - first + 1)));
}
}
// rand
template <class RandomIter, class RandomNumberGenerator>
void random_shuffle(RandomIter first, RandomIter last,
RandomNumberGenerator& rand)
{
if (first == last)
return;
auto len = mystl::distance(first, last);
for (auto i = first + 1; i != last; ++i)
{
mystl::iter_swap(i, first + (rand(i - first + 1) % len));
}
}
/*****************************************************************************************/
// rotate
// [first, middle) [middle, last)
// middle
/*****************************************************************************************/
// rotate_dispatch forward_iterator_tag
template <class ForwardIter>
ForwardIter
rotate_dispatch(ForwardIter first, ForwardIter middle,
ForwardIter last, forward_iterator_tag)
{
auto first2 = middle;
do
{
mystl::swap(*first++, *first2++);
if (first == middle)
middle = first2;
} while (first2 != last); //
auto new_middle = first; //
first2 = middle;
while (first2 != last)
{ //
mystl::swap(*first++, *first2++);
if (first == middle)
{
middle = first2;
}
else if (first2 == last)
{
first2 = middle;
}
}
return new_middle;
}
// rotate_dispatch bidirectional_iterator_tag
template <class BidirectionalIter>
BidirectionalIter
rotate_dispatch(BidirectionalIter first, BidirectionalIter middle,
BidirectionalIter last, bidirectional_iterator_tag)
{
mystl::reverse_dispatch(first, middle, bidirectional_iterator_tag());
mystl::reverse_dispatch(middle, last, bidirectional_iterator_tag());
while (first != middle && middle != last)
mystl::swap(*first++, *--last);
if (first == middle)
{
mystl::reverse_dispatch(middle, last, bidirectional_iterator_tag());
return last;
}
else
{
mystl::reverse_dispatch(first, middle, bidirectional_iterator_tag());
return first;
}
}
//
template <class EuclideanRingElement>
EuclideanRingElement rgcd(EuclideanRingElement m, EuclideanRingElement n)
{
while (n != 0)
{
auto t = m % n;
m = n;
n = t;
}
return m;
}
// rotate_dispatch random_access_iterator_tag
template <class RandomIter>
RandomIter
rotate_dispatch(RandomIter first, RandomIter middle,
RandomIter last, random_access_iterator_tag)
{
// random access iterator
auto n = last - first;
auto l = middle - first;
auto r = n - l;
auto result = first + (last - middle);
if (l == r)
{
mystl::swap_ranges(first, middle, middle);
return result;
}
auto cycle_times = rgcd(n, l);
for (auto i = 0; i < cycle_times; ++i)
{
auto tmp = *first;
auto p = first;
if (l < r)
{
for (auto j = 0; j < r / cycle_times; ++j)
{
if (p > first + r)
{
*p = *(p - r);
p -= r;
}
*p = *(p + l);
p += l;
}
}
else
{
for (auto j = 0; j < l / cycle_times - 1; ++j)
{
if (p < last - l)
{
*p = *(p + l);
p += l;
}
*p = *(p - r);
p -= r;
}
}
*p = tmp;
++first;
}
return result;
}
template <class ForwardIter>
ForwardIter
rotate(ForwardIter first, ForwardIter middle, ForwardIter last)
{
if (first == middle)
return last;
if (middle == last)
return first;
return mystl::rotate_dispatch(first, middle, last, iterator_category(first));
}
/*****************************************************************************************/
// rotate_copy
// rotate result
/*****************************************************************************************/
template <class ForwardIter, class OutputIter>
ForwardIter
rotate_copy(ForwardIter first, ForwardIter middle,
ForwardIter last, OutputIter result)
{
return mystl::copy(first, middle, mystl::copy(middle, last, result));
}
/*****************************************************************************************/
// is_permutation
// [first1,last1)[first2, last2)
/*****************************************************************************************/
template <class ForwardIter1, class ForwardIter2, class BinaryPred>
bool is_permutation_aux(ForwardIter1 first1, ForwardIter1 last1,
ForwardIter2 first2, ForwardIter2 last2,
BinaryPred pred)
{
constexpr bool is_ra_it = mystl::is_random_access_iterator<ForwardIter1>::value
&& mystl::is_random_access_iterator<ForwardIter2>::value;
if (is_ra_it)
{
auto len1 = last1 - first1;
auto len2 = last2 - first2;
if (len1 != len2)
return false;
}
//
for (; first1 != last1 && first2 != last2; ++first1, (void) ++first2)
{
if (!pred(*first1, *first2))
break;
}
if (is_ra_it)
{
if (first1 == last1)
return true;
}
else
{
auto len1 = mystl::distance(first1, last1);
auto len2 = mystl::distance(first2, last2);
if (len1 == 0 && len2 == 0)
return true;
if (len1 != len2)
return false;
}
//
for (auto i = first1; i != last1; ++i)
{
bool is_repeated = false;
for (auto j = first1; j != i; ++j)
{
if (pred(*j, *i))
{
is_repeated = true;
break;
}
}
if (!is_repeated)
{
// *i [first2, last2)
auto c2 = 0;
for (auto j = first2; j != last2; ++j)
{
if (pred(*i, *j))
++c2;
}
if (c2 == 0)
return false;
// *i [first1, last1)
auto c1 = 1;
auto j = i;
for (++j; j != last1; ++j)
{
if (pred(*i, *j))
++c1;
}
if (c1 != c2)
return false;
}
}
return true;
}
template <class ForwardIter1, class ForwardIter2, class BinaryPred>
bool is_permutation(ForwardIter1 first1, ForwardIter1 last1,
ForwardIter2 first2, ForwardIter2 last2,
BinaryPred pred)
{
return is_permutation_aux(first1, last1, first2, last2, pred);
}
template <class ForwardIter1, class ForwardIter2>
bool is_permutation(ForwardIter1 first1, ForwardIter1 last1,
ForwardIter2 first2, ForwardIter2 last2)
{
typedef typename iterator_traits<ForwardIter1>::value_type v1;
typedef typename iterator_traits<ForwardIter2>::value_type v2;
static_assert(std::is_same<v1, v2>::value,
"the type should be same in mystl::is_permutation");
return is_permutation_aux(first1, last1, first2, last2,
mystl::equal_to<v1>());
}
/*****************************************************************************************/
// next_permutation
// [first, last) false true
/*****************************************************************************************/
template <class BidirectionalIter>
bool next_permutation(BidirectionalIter first, BidirectionalIter last)
{
auto i = last;
if (first == last || first == --i)
return false;
for (;;)
{
auto ii = i;
if (*--i < *ii)
{ //
auto j = last;
while (!(*i < *--j)) {}
mystl::iter_swap(i, j); // ij
mystl::reverse(ii, last); // ii
return true;
}
if (i == first)
{
mystl::reverse(first, last);
return false;
}
}
}
// comp
template <class BidirectionalIter, class Compared>
bool next_permutation(BidirectionalIter first, BidirectionalIter last, Compared comp)
{
auto i = last;
if (first == last || first == --i)
return false;
for (;;)
{
auto ii = i;
if (comp(*--i, *ii))
{
auto j = last;
while (!comp(*i, *--j)) {}
mystl::iter_swap(i, j); // ij
mystl::reverse(ii, last); // ii
return true;
}
if (i == first)
{
mystl::reverse(first, last);
return false;
}
}
}
/*****************************************************************************************/
// prev_permutation
// [first, last) false true
/*****************************************************************************************/
template <class BidirectionalIter>
bool prev_permutation(BidirectionalIter first, BidirectionalIter last)
{
auto i = last;
if (first == last || first == --i)
return false;
for (;;)
{
auto ii = i;
if (*ii < *--i)
{ //
auto j = last;
while (!(*--j < *i)) {}
mystl::iter_swap(i, j); // ij
mystl::reverse(ii, last); // ii
return true;
}
if (i == first)
{
mystl::reverse(first, last);
return false;
}
}
}
// comp
template <class BidirectionalIter, class Compared>
bool prev_permutation(BidirectionalIter first, BidirectionalIter last, Compared comp)
{
auto i = last;
if (first == last || first == --i)
return false;
for (;;)
{
auto ii = i;
if (comp(*ii, *--i))
{
auto j = last;
while (!comp(*--j, *i)) {}
mystl::iter_swap(i, j); // ij
mystl::reverse(ii, last); // ii
return true;
}
if (i == first)
{
mystl::reverse(first, last);
return false;
}
}
}
/*****************************************************************************************/
// merge
// S1 S2
/*****************************************************************************************/
template <class InputIter1, class InputIter2, class OutputIter>
OutputIter
merge(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2,
OutputIter result)
{
while (first1 != last1 && first2 != last2)
{
if (*first2 < *first1)
{
*result = *first2;
++first2;
}
else
{
*result = *first1;
++first1;
}
++result;
}
return mystl::copy(first2, last2, mystl::copy(first1, last1, result));
}
// comp
template <class InputIter1, class InputIter2, class OutputIter, class Compared>
OutputIter
merge(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2,
OutputIter result, Compared comp)
{
while (first1 != last1 && first2 != last2)
{
if (comp(*first2, *first1))
{
*result = *first2;
++first2;
}
else
{
*result = *first1;
++first1;
}
++result;
}
return mystl::copy(first2, last2, mystl::copy(first1, last1, result));
}
/*****************************************************************************************/
// inplace_merge
//
/*****************************************************************************************/
//
template <class BidirectionalIter, class Distance>
void merge_without_buffer(BidirectionalIter first, BidirectionalIter middle,
BidirectionalIter last, Distance len1, Distance len2)
{
if (len1 == 0 || len2 == 0)
return;
if (len1 + len2 == 2)
{
if (*middle < *first)
mystl::iter_swap(first, middle);
return;
}
auto first_cut = first;
auto second_cut = middle;
Distance len11 = 0;
Distance len22 = 0;
if (len1 > len2)
{ //
len11 = len1 >> 1;
mystl::advance(first_cut, len11);
second_cut = mystl::lower_bound(middle, last, *first_cut);
len22 = mystl::distance(middle, second_cut);
}
else
{ //
len22 = len2 >> 1;
mystl::advance(second_cut, len22);
first_cut = mystl::upper_bound(first, middle, *second_cut);
len11 = mystl::distance(first, first_cut);
}
auto new_middle = mystl::rotate(first_cut, middle, second_cut);
mystl::merge_without_buffer(first, first_cut, new_middle, len11, len22);
mystl::merge_without_buffer(new_middle, second_cut, last, len1 - len11, len2 - len22);
}
template <class BidirectionalIter1, class BidirectionalIter2>
BidirectionalIter1
merge_backward(BidirectionalIter1 first1, BidirectionalIter1 last1,
BidirectionalIter2 first2, BidirectionalIter2 last2,
BidirectionalIter1 result)
{
if (first1 == last1)
return mystl::copy_backward(first2, last2, result);
if (first2 == last2)
return mystl::copy_backward(first1, last1, result);
--last1;
--last2;
while (true)
{
if (*last2 < *last1)
{
*--result = *last1;
if (first1 == last1)
return mystl::copy_backward(first2, ++last2, result);
--last1;
}
else
{
*--result = *last2;
if (first2 == last2)
return mystl::copy_backward(first1, ++last1, result);
--last2;
}
}
}
template <class BidirectionalIter1, class BidirectionalIter2, class Distance>
BidirectionalIter1
rotate_adaptive(BidirectionalIter1 first, BidirectionalIter1 middle,
BidirectionalIter1 last, Distance len1, Distance len2,
BidirectionalIter2 buffer, Distance buffer_size)
{
BidirectionalIter2 buffer_end;
if (len1 > len2 && len2 <= buffer_size)
{
buffer_end = mystl::copy(middle, last, buffer);
mystl::copy_backward(first, middle, last);
return mystl::copy(buffer, buffer_end, first);
}
else if (len1 <= buffer_size)
{
buffer_end = mystl::copy(first, middle, buffer);
mystl::copy(middle, last, first);
return mystl::copy_backward(buffer, buffer_end, last);
}
else
{
return mystl::rotate(first, middle, last);
}
}
//
template <class BidirectionalIter, class Distance, class Pointer>
void merge_adaptive(BidirectionalIter first, BidirectionalIter middle,
BidirectionalIter last, Distance len1, Distance len2,
Pointer buffer, Distance buffer_size)
{
//
if (len1 <= len2 && len1 <= buffer_size)
{
Pointer buffer_end = mystl::copy(first, middle, buffer);
mystl::merge(buffer, buffer_end, middle, last, first);
}
else if (len2 <= buffer_size)
{
Pointer buffer_end = mystl::copy(middle, last, buffer);
mystl::merge_backward(first, middle, buffer, buffer_end, last);
}
else
{ //
auto first_cut = first;
auto second_cut = middle;
Distance len11 = 0;
Distance len22 = 0;
if (len1 > len2)
{
len11 = len1 >> 1;
mystl::advance(first_cut, len11);
second_cut = mystl::lower_bound(middle, last, *first_cut);
len22 = mystl::distance(middle, second_cut);
}
else
{
len22 = len2 >> 1;
mystl::advance(second_cut, len22);
first_cut = mystl::upper_bound(first, middle, *second_cut);
len11 = mystl::distance(first, first_cut);
}
auto new_middle = mystl::rotate_adaptive(first_cut, middle, second_cut,
len1 - len11, len22, buffer, buffer_size);
mystl::merge_adaptive(first, first_cut, new_middle, len11, len22, buffer, buffer_size);
mystl::merge_adaptive(new_middle, second_cut, last, len1 - len11,
len2 - len22, buffer, buffer_size);
}
}
template <class BidirectionalIter, class T>
void
inplace_merge_aux(BidirectionalIter first, BidirectionalIter middle,
BidirectionalIter last, T*)
{
auto len1 = mystl::distance(first, middle);
auto len2 = mystl::distance(middle, last);
temporary_buffer<BidirectionalIter, T> buf(first, last);
if (!buf.begin())
{
mystl::merge_without_buffer(first, middle, last, len1, len2);
}
else
{
mystl::merge_adaptive(first, middle, last, len1, len2, buf.begin(), buf.size());
}
}
template <class BidirectionalIter>
void
inplace_merge(BidirectionalIter first, BidirectionalIter middle,
BidirectionalIter last)
{
if (first == middle || middle == last)
return;
mystl::inplace_merge_aux(first, middle, last, value_type(first));
}
// comp
//
template <class BidirectionalIter, class Distance, class Compared>
void merge_without_buffer(BidirectionalIter first, BidirectionalIter middle,
BidirectionalIter last, Distance len1, Distance len2,
Compared comp)
{
if (len1 == 0 || len2 == 0)
return;
if (len1 + len2 == 2)
{
if (comp(*middle, *first))
mystl::iter_swap(first, middle);
return;
}
auto first_cut = first;
auto second_cut = middle;
Distance len11 = 0;
Distance len22 = 0;
if (len1 > len2)
{
len11 = len1 >> 1;
mystl::advance(first_cut, len11);
second_cut = mystl::lower_bound(middle, last, *first_cut, comp);
len22 = mystl::distance(middle, second_cut);
}
else
{
len22 = len2 >> 1;
mystl::advance(second_cut, len22);
first_cut = mystl::upper_bound(first, middle, *second_cut, comp);
len11 = mystl::distance(first, first_cut);
}
auto new_middle = mystl::rotate(first_cut, middle, second_cut);
mystl::merge_without_buffer(first, first_cut, new_middle, len11, len22, comp);
mystl::merge_without_buffer(new_middle, second_cut, last, len1 - len11, len2 - len22, comp);
}
template <class BidirectionalIter1, class BidirectionalIter2, class Compared>
BidirectionalIter1
merge_backward(BidirectionalIter1 first1, BidirectionalIter1 last1,
BidirectionalIter2 first2, BidirectionalIter2 last2,
BidirectionalIter1 result, Compared comp)
{
if (first1 == last1)
return mystl::copy_backward(first2, last2, result);
if (first2 == last2)
return mystl::copy_backward(first1, last1, result);
--last1;
--last2;
while (true)
{
if (comp(*last2, *last1))
{
*--result = *last1;
if (first1 == last1)
return mystl::copy_backward(first2, ++last2, result);
--last1;
}
else
{
*--result = *last2;
if (first2 == last2)
return mystl::copy_backward(first1, ++last1, result);
--last2;
}
}
}
//
template <class BidirectionalIter, class Distance, class Pointer, class Compared>
void merge_adaptive(BidirectionalIter first, BidirectionalIter middle,
BidirectionalIter last, Distance len1, Distance len2,
Pointer buffer, Distance buffer_size, Compared comp)
{
//
if (len1 <= len2 && len1 <= buffer_size)
{
Pointer buffer_end = mystl::copy(first, middle, buffer);
mystl::merge(buffer, buffer_end, middle, last, first, comp);
}
else if (len2 <= buffer_size)
{
Pointer buffer_end = mystl::copy(middle, last, buffer);
mystl::merge_backward(first, middle, buffer, buffer_end, last, comp);
}
else
{ //
auto first_cut = first;
auto second_cut = middle;
Distance len11 = 0;
Distance len22 = 0;
if (len1 > len2)
{
len11 = len1 >> 1;
mystl::advance(first_cut, len11);
second_cut = mystl::lower_bound(middle, last, *first_cut, comp);
len22 = mystl::distance(middle, second_cut);
}
else
{
len22 = len2 >> 1;
mystl::advance(second_cut, len22);
first_cut = mystl::upper_bound(first, middle, *second_cut, comp);
len11 = mystl::distance(first, first_cut);
}
auto new_middle = mystl::rotate_adaptive(first_cut, middle, second_cut, len1 - len11,
len22, buffer, buffer_size);
mystl::merge_adaptive(first, first_cut, new_middle, len11,
len22, buffer, buffer_size, comp);
mystl::merge_adaptive(new_middle, second_cut, last, len1 - len11,
len2 - len22, buffer, buffer_size, comp);
}
}
template <class BidirectionalIter, class T, class Compared>
void
inplace_merge_aux(BidirectionalIter first, BidirectionalIter middle,
BidirectionalIter last, T*, Compared comp)
{
auto len1 = mystl::distance(first, middle);
auto len2 = mystl::distance(middle, last);
temporary_buffer<BidirectionalIter, T> buf(first, last);
if (!buf.begin())
{
mystl::merge_without_buffer(first, middle, last, len1, len2, comp);
}
else
{
mystl::merge_adaptive(first, middle, last, len1, len2, buf.begin(), buf.size(), comp);
}
}
template <class BidirectionalIter, class Compared>
void
inplace_merge(BidirectionalIter first, BidirectionalIter middle,
BidirectionalIter last, Compared comp)
{
if (first == middle || middle == last)
return;
mystl::inplace_merge_aux(first, middle, last, value_type(first), comp);
}
/*****************************************************************************************/
// partial_sort
// N [first, first + N)
/*****************************************************************************************/
template <class RandomIter>
void partial_sort(RandomIter first, RandomIter middle,
RandomIter last)
{
mystl::make_heap(first, middle);
for (auto i = middle; i < last; ++i)
{
if (*i < *first)
{
mystl::pop_heap_aux(first, middle, i, *i, distance_type(first));
}
}
mystl::sort_heap(first, middle);
}
// comp
template <class RandomIter, class Compared>
void partial_sort(RandomIter first, RandomIter middle,
RandomIter last, Compared comp)
{
mystl::make_heap(first, middle, comp);
for (auto i = middle; i < last; ++i)
{
if (comp(*i, *first))
{
mystl::pop_heap_aux(first, middle, i, *i, distance_type(first), comp);
}
}
mystl::sort_heap(first, middle, comp);
}
/*****************************************************************************************/
// partial_sort_copy
// partial_sort result
/*****************************************************************************************/
template <class InputIter, class RandomIter, class Distance>
RandomIter
psort_copy_aux(InputIter first, InputIter last,
RandomIter result_first, RandomIter result_last,
Distance*)
{
if (result_first == result_last)
return result_last;
auto result_iter = result_first;
while (first != last && result_iter != result_last)
{
*result_iter = *first;
++result_iter;
++first;
}
mystl::make_heap(result_first, result_iter);
while (first != last)
{
if (*first < *result_first)
{
mystl::adjust_heap(result_first, static_cast<Distance>(0),
result_iter - result_first, *first);
}
++first;
}
mystl::sort_heap(result_first, result_iter);
return result_iter;
}
template <class InputIter, class RandomIter>
RandomIter
partial_sort_copy(InputIter first, InputIter last,
RandomIter result_first, RandomIter result_last)
{
return mystl::psort_copy_aux(first, last, result_first, result_last,
distance_type(result_first));
}
// comp
template <class InputIter, class RandomIter, class Distance, class Compared>
RandomIter
psort_copy_aux(InputIter first, InputIter last,
RandomIter result_first, RandomIter result_last,
Distance*, Compared comp)
{
if (result_first == result_last)
return result_last;
auto result_iter = result_first;
while (first != last && result_iter != result_last)
{
*result_iter = *first;
++result_iter;
++first;
}
mystl::make_heap(result_first, result_iter, comp);
while (first != last)
{
if (comp(*first, *result_first))
{
mystl::adjust_heap(result_first, static_cast<Distance>(0),
result_iter - result_first, *first, comp);
}
++first;
}
mystl::sort_heap(result_first, result_iter, comp);
return result_iter;
}
template <class InputIter, class RandomIter, class Compared>
RandomIter
partial_sort_copy(InputIter first, InputIter last,
RandomIter result_first, RandomIter result_last,
Compared comp)
{
return mystl::psort_copy_aux(first, last, result_first, result_last,
distance_type(result_first), comp);
}
/*****************************************************************************************/
// partition
// true
//
/*****************************************************************************************/
template <class BidirectionalIter, class UnaryPredicate>
BidirectionalIter
partition(BidirectionalIter first, BidirectionalIter last,
UnaryPredicate unary_pred)
{
while (true)
{
while (first != last && unary_pred(*first))
{
++first;
}
if (first == last)
break;
--last;
while (first != last && !unary_pred(*last))
{
--last;
}
if (first == last)
break;
mystl::iter_swap(first, last);
++first;
}
return first;
}
/*****************************************************************************************/
// partition_copy
// partition true result_true
// result_false mystl::pair
/*****************************************************************************************/
template <class InputIter, class OutputIter1, class OutputIter2, class UnaryPredicate>
mystl::pair<OutputIter1, OutputIter2>
partition_copy(InputIter first, InputIter last,
OutputIter1 result_true, OutputIter2 result_false,
UnaryPredicate unary_pred)
{
for (; first != last; ++first)
{
if (unary_pred(*first))
{
*result_true++ = *first;
}
else
{
*result_false++ = *first;
}
}
return mystl::pair<OutputIter1, OutputIter2>(result_true, result_false);
}
/*****************************************************************************************/
// sort
// [first, last)
/*****************************************************************************************/
constexpr static size_t kSmallSectionSize = 128; //
//
template <class Size>
Size slg2(Size n)
{ // lgk <= n k
Size k = 0;
for (; n > 1; n >>= 1)
++k;
return k;
}
// unchecked_partition
template <class RandomIter, class T>
RandomIter
unchecked_partition(RandomIter first, RandomIter last, const T& pivot)
{
while (true)
{
while (*first < pivot)
++first;
--last;
while (pivot < *last)
--last;
if (!(first < last))
return first;
mystl::iter_swap(first, last);
++first;
}
}
// quick sort heap sort
template <class RandomIter, class Size>
void intro_sort(RandomIter first, RandomIter last, Size depth_limit)
{
while (static_cast<size_t>(last - first) > kSmallSectionSize)
{
if (depth_limit == 0)
{ //
mystl::partial_sort(first, last, last); // heap_sort
return;
}
--depth_limit;
auto mid = mystl::median(*(first), *(first + (last - first) / 2), *(last - 1));
auto cut = mystl::unchecked_partition(first, last, mid);
mystl::intro_sort(cut, last, depth_limit);
last = cut;
}
}
// unchecked_linear_insert
template <class RandomIter, class T>
void unchecked_linear_insert(RandomIter last, const T& value)
{
auto next = last;
--next;
while (value < *next)
{
*last = *next;
last = next;
--next;
}
*last = value;
}
// unchecked_insertion_sort
template <class RandomIter>
void unchecked_insertion_sort(RandomIter first, RandomIter last)
{
for (auto i = first; i != last; ++i)
{
mystl::unchecked_linear_insert(i, *i);
}
}
// insertion_sort
template <class RandomIter>
void insertion_sort(RandomIter first, RandomIter last)
{
if (first == last)
return;
for (auto i = first + 1; i != last; ++i)
{
auto value = *i;
if (value < *first)
{
mystl::copy_backward(first, i, i + 1);
*first = value;
}
else
{
mystl::unchecked_linear_insert(i, value);
}
}
}
// final_insertion_sort
template <class RandomIter>
void final_insertion_sort(RandomIter first, RandomIter last)
{
if (static_cast<size_t>(last - first) > kSmallSectionSize)
{
mystl::insertion_sort(first, first + kSmallSectionSize);
mystl::unchecked_insertion_sort(first + kSmallSectionSize, last);
}
else
{
mystl::insertion_sort(first, last);
}
}
template <class RandomIter>
void sort(RandomIter first, RandomIter last)
{
if (first != last)
{
//
mystl::intro_sort(first, last, slg2(last - first) * 2);
mystl::final_insertion_sort(first, last);
}
}
// comp
// unchecked_partition
template <class RandomIter, class T, class Compared>
RandomIter
unchecked_partition(RandomIter first, RandomIter last,
const T& pivot, Compared comp)
{
while (true)
{
while (comp(*first, pivot))
++first;
--last;
while (comp(pivot, *last))
--last;
if (!(first < last))
return first;
mystl::iter_swap(first, last);
++first;
}
}
// quick sort heap sort
template <class RandomIter, class Size, class Compared>
void intro_sort(RandomIter first, RandomIter last,
Size depth_limit, Compared comp)
{
while (static_cast<size_t>(last - first) > kSmallSectionSize)
{
if (depth_limit == 0)
{ //
mystl::partial_sort(first, last, last, comp); // heap_sort
return;
}
--depth_limit;
auto mid = mystl::median(*(first), *(first + (last - first) / 2), *(last - 1));
auto cut = mystl::unchecked_partition(first, last, mid, comp);
mystl::intro_sort(cut, last, depth_limit, comp);
last = cut;
}
}
// unchecked_linear_insert
template <class RandomIter, class T, class Compared>
void unchecked_linear_insert(RandomIter last, const T& value, Compared comp)
{
auto next = last;
--next;
while (comp(value, *next))
{ //
*last = *next;
last = next;
--next;
}
*last = value;
}
// unchecked_insertion_sort
template <class RandomIter, class Compared>
void unchecked_insertion_sort(RandomIter first, RandomIter last,
Compared comp)
{
for (auto i = first; i != last; ++i)
{
mystl::unchecked_linear_insert(i, *i, comp);
}
}
// insertion_sort
template <class RandomIter, class Compared>
void insertion_sort(RandomIter first, RandomIter last, Compared comp)
{
if (first == last)
return;
for (auto i = first + 1; i != last; ++i)
{
auto value = *i;
if (comp(value, *first))
{
mystl::copy_backward(first, i, i + 1);
*first = value;
}
else
{
mystl::unchecked_linear_insert(i, value, comp);
}
}
}
// final_insertion_sort
template <class RandomIter, class Compared>
void final_insertion_sort(RandomIter first, RandomIter last, Compared comp)
{
if (static_cast<size_t>(last - first) > kSmallSectionSize)
{
mystl::insertion_sort(first, first + kSmallSectionSize, comp);
mystl::unchecked_insertion_sort(first + kSmallSectionSize, last, comp);
}
else
{
mystl::insertion_sort(first, last, comp);
}
}
template <class RandomIter, class Compared>
void sort(RandomIter first, RandomIter last, Compared comp)
{
if (first != last)
{
//
mystl::intro_sort(first, last, slg2(last - first) * 2, comp);
mystl::final_insertion_sort(first, last, comp);
}
}
/*****************************************************************************************/
// nth_element
// n
/*****************************************************************************************/
template <class RandomIter>
void nth_element(RandomIter first, RandomIter nth,
RandomIter last)
{
if (nth == last)
return;
while (last - first > 3)
{
auto cut = mystl::unchecked_partition(first, last, mystl::median(*first,
*(first + (last - first) / 2),
*(last - 1)));
if (cut <= nth) // nth
first = cut; //
else
last = cut; //
}
mystl::insertion_sort(first, last);
}
// comp
template <class RandomIter, class Compared>
void nth_element(RandomIter first, RandomIter nth,
RandomIter last, Compared comp)
{
if (nth == last)
return;
while (last - first > 3)
{
auto cut = mystl::unchecked_partition(first, last, mystl::median(*first,
*(first + (last - first) / 2),
*(last - 1)), comp);
if (cut <= nth) // nth
first = cut; //
else
last = cut; //
}
mystl::insertion_sort(first, last, comp);
}
/*****************************************************************************************/
// unique_copy
// [first, last) result
/*****************************************************************************************/
// unique_copy_dispatch forward_iterator_tag
template <class InputIter, class ForwardIter>
ForwardIter
unique_copy_dispatch(InputIter first, InputIter last,
ForwardIter result, forward_iterator_tag)
{
*result = *first;
while (++first != last)
{
if (*result != *first)
*++result = *first;
}
return ++result;
}
// unique_copy_dispatch output_iterator_tag
// output iterator *result != *first
template <class InputIter, class OutputIter>
OutputIter
unique_copy_dispatch(InputIter first, InputIter last,
OutputIter result, output_iterator_tag)
{
auto value = *first;
*result = value;
while (++first != last)
{
if (value != *first)
{
value = *first;
*++result = value;
}
}
return ++result;
}
template <class InputIter, class OutputIter>
OutputIter
unique_copy(InputIter first, InputIter last, OutputIter result)
{
if (first == last)
return result;
return mystl::unique_copy_dispatch(first, last, result, iterator_category(result));
}
// comp
// unique_copy_dispatch forward_iterator_tag
template <class InputIter, class ForwardIter, class Compared>
ForwardIter
unique_copy_dispatch(InputIter first, InputIter last,
ForwardIter result, forward_iterator_tag, Compared comp)
{
*result = *first;
while (++first != last)
{
if (!comp(*result, *first))
*++result = *first;
}
return ++result;
}
// unique_copy_dispatch output_iterator_tag
// output iterator *result != *first
template <class InputIter, class OutputIter, class Compared>
OutputIter
unique_copy_dispatch(InputIter first, InputIter last,
OutputIter result, output_iterator_tag, Compared comp)
{
auto value = *first;
*result = value;
while (++first != last)
{
if (!comp(value, *first))
{
value = *first;
*++result = value;
}
}
return ++result;
}
template <class InputIter, class OutputIter, class Compared>
OutputIter
unique_copy(InputIter first, InputIter last, OutputIter result, Compared comp)
{
if (first == last)
return result;
return mystl::unique_copy_dispatch(first, last, result, iterator_category(result), comp);
}
/*****************************************************************************************/
// unique
// [first, last) remove
/*****************************************************************************************/
template <class ForwardIter>
ForwardIter unique(ForwardIter first, ForwardIter last)
{
first = mystl::adjacent_find(first, last);
return mystl::unique_copy(first, last, first);
}
// comp
template <class ForwardIter, class Compared>
ForwardIter unique(ForwardIter first, ForwardIter last, Compared comp)
{
first = mystl::adjacent_find(first, last, comp);
return mystl::unique_copy(first, last, first, comp);
}
} // namespace mystl
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#endif // !MYTINYSTL_ALGO_H_
``` | /content/code_sandbox/MyTinySTL/algo.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 17,380 |
```objective-c
#ifndef MYTINYSTL_ALGOBASE_H_
#define MYTINYSTL_ALGOBASE_H_
// mystl
#include <cstring>
#include "iterator.h"
#include "util.h"
namespace mystl
{
#ifdef max
#pragma message("#undefing marco max")
#undef max
#endif // max
#ifdef min
#pragma message("#undefing marco min")
#undef min
#endif // min
/*****************************************************************************************/
// max
//
/*****************************************************************************************/
template <class T>
const T& max(const T& lhs, const T& rhs)
{
return lhs < rhs ? rhs : lhs;
}
// comp
template <class T, class Compare>
const T& max(const T& lhs, const T& rhs, Compare comp)
{
return comp(lhs, rhs) ? rhs : lhs;
}
/*****************************************************************************************/
// min
//
/*****************************************************************************************/
template <class T>
const T& min(const T& lhs, const T& rhs)
{
return rhs < lhs ? rhs : lhs;
}
// comp
template <class T, class Compare>
const T& min(const T& lhs, const T& rhs, Compare comp)
{
return comp(rhs, lhs) ? rhs : lhs;
}
/*****************************************************************************************/
// iter_swap
//
/*****************************************************************************************/
template <class FIter1, class FIter2>
void iter_swap(FIter1 lhs, FIter2 rhs)
{
mystl::swap(*lhs, *rhs);
}
/*****************************************************************************************/
// copy
// [first, last) [result, result + (last - first))
/*****************************************************************************************/
// input_iterator_tag
template <class InputIter, class OutputIter>
OutputIter
unchecked_copy_cat(InputIter first, InputIter last, OutputIter result,
mystl::input_iterator_tag)
{
for (; first != last; ++first, ++result)
{
*result = *first;
}
return result;
}
// ramdom_access_iterator_tag
template <class RandomIter, class OutputIter>
OutputIter
unchecked_copy_cat(RandomIter first, RandomIter last, OutputIter result,
mystl::random_access_iterator_tag)
{
for (auto n = last - first; n > 0; --n, ++first, ++result)
{
*result = *first;
}
return result;
}
template <class InputIter, class OutputIter>
OutputIter
unchecked_copy(InputIter first, InputIter last, OutputIter result)
{
return unchecked_copy_cat(first, last, result, iterator_category(first));
}
// trivially_copy_assignable
template <class Tp, class Up>
typename std::enable_if<
std::is_same<typename std::remove_const<Tp>::type, Up>::value &&
std::is_trivially_copy_assignable<Up>::value,
Up*>::type
unchecked_copy(Tp* first, Tp* last, Up* result)
{
const auto n = static_cast<size_t>(last - first);
if (n != 0)
std::memmove(result, first, n * sizeof(Up));
return result + n;
}
template <class InputIter, class OutputIter>
OutputIter copy(InputIter first, InputIter last, OutputIter result)
{
return unchecked_copy(first, last, result);
}
/*****************************************************************************************/
// copy_backward
// [first, last) [result - (last - first), result)
/*****************************************************************************************/
// unchecked_copy_backward_cat bidirectional_iterator_tag
template <class BidirectionalIter1, class BidirectionalIter2>
BidirectionalIter2
unchecked_copy_backward_cat(BidirectionalIter1 first, BidirectionalIter1 last,
BidirectionalIter2 result, mystl::bidirectional_iterator_tag)
{
while (first != last)
*--result = *--last;
return result;
}
// unchecked_copy_backward_cat random_access_iterator_tag
template <class RandomIter1, class BidirectionalIter2>
BidirectionalIter2
unchecked_copy_backward_cat(RandomIter1 first, RandomIter1 last,
BidirectionalIter2 result, mystl::random_access_iterator_tag)
{
for (auto n = last - first; n > 0; --n)
*--result = *--last;
return result;
}
template <class BidirectionalIter1, class BidirectionalIter2>
BidirectionalIter2
unchecked_copy_backward(BidirectionalIter1 first, BidirectionalIter1 last,
BidirectionalIter2 result)
{
return unchecked_copy_backward_cat(first, last, result,
iterator_category(first));
}
// trivially_copy_assignable
template <class Tp, class Up>
typename std::enable_if<
std::is_same<typename std::remove_const<Tp>::type, Up>::value &&
std::is_trivially_copy_assignable<Up>::value,
Up*>::type
unchecked_copy_backward(Tp* first, Tp* last, Up* result)
{
const auto n = static_cast<size_t>(last - first);
if (n != 0)
{
result -= n;
std::memmove(result, first, n * sizeof(Up));
}
return result;
}
template <class BidirectionalIter1, class BidirectionalIter2>
BidirectionalIter2
copy_backward(BidirectionalIter1 first, BidirectionalIter1 last, BidirectionalIter2 result)
{
return unchecked_copy_backward(first, last, result);
}
/*****************************************************************************************/
// copy_if
// [first, last) unary_pred result
/*****************************************************************************************/
template <class InputIter, class OutputIter, class UnaryPredicate>
OutputIter
copy_if(InputIter first, InputIter last, OutputIter result, UnaryPredicate unary_pred)
{
for (; first != last; ++first)
{
if (unary_pred(*first))
*result++ = *first;
}
return result;
}
/*****************************************************************************************/
// copy_n
// [first, first + n) [result, result + n)
// pair
/*****************************************************************************************/
template <class InputIter, class Size, class OutputIter>
mystl::pair<InputIter, OutputIter>
unchecked_copy_n(InputIter first, Size n, OutputIter result, mystl::input_iterator_tag)
{
for (; n > 0; --n, ++first, ++result)
{
*result = *first;
}
return mystl::pair<InputIter, OutputIter>(first, result);
}
template <class RandomIter, class Size, class OutputIter>
mystl::pair<RandomIter, OutputIter>
unchecked_copy_n(RandomIter first, Size n, OutputIter result,
mystl::random_access_iterator_tag)
{
auto last = first + n;
return mystl::pair<RandomIter, OutputIter>(last, mystl::copy(first, last, result));
}
template <class InputIter, class Size, class OutputIter>
mystl::pair<InputIter, OutputIter>
copy_n(InputIter first, Size n, OutputIter result)
{
return unchecked_copy_n(first, n, result, iterator_category(first));
}
/*****************************************************************************************/
// move
// [first, last) [result, result + (last - first))
/*****************************************************************************************/
// input_iterator_tag
template <class InputIter, class OutputIter>
OutputIter
unchecked_move_cat(InputIter first, InputIter last, OutputIter result,
mystl::input_iterator_tag)
{
for (; first != last; ++first, ++result)
{
*result = mystl::move(*first);
}
return result;
}
// ramdom_access_iterator_tag
template <class RandomIter, class OutputIter>
OutputIter
unchecked_move_cat(RandomIter first, RandomIter last, OutputIter result,
mystl::random_access_iterator_tag)
{
for (auto n = last - first; n > 0; --n, ++first, ++result)
{
*result = mystl::move(*first);
}
return result;
}
template <class InputIter, class OutputIter>
OutputIter
unchecked_move(InputIter first, InputIter last, OutputIter result)
{
return unchecked_move_cat(first, last, result, iterator_category(first));
}
// trivially_copy_assignable
template <class Tp, class Up>
typename std::enable_if<
std::is_same<typename std::remove_const<Tp>::type, Up>::value &&
std::is_trivially_move_assignable<Up>::value,
Up*>::type
unchecked_move(Tp* first, Tp* last, Up* result)
{
const size_t n = static_cast<size_t>(last - first);
if (n != 0)
std::memmove(result, first, n * sizeof(Up));
return result + n;
}
template <class InputIter, class OutputIter>
OutputIter move(InputIter first, InputIter last, OutputIter result)
{
return unchecked_move(first, last, result);
}
/*****************************************************************************************/
// move_backward
// [first, last) [result - (last - first), result)
/*****************************************************************************************/
// bidirectional_iterator_tag
template <class BidirectionalIter1, class BidirectionalIter2>
BidirectionalIter2
unchecked_move_backward_cat(BidirectionalIter1 first, BidirectionalIter1 last,
BidirectionalIter2 result, mystl::bidirectional_iterator_tag)
{
while (first != last)
*--result = mystl::move(*--last);
return result;
}
// random_access_iterator_tag
template <class RandomIter1, class RandomIter2>
RandomIter2
unchecked_move_backward_cat(RandomIter1 first, RandomIter1 last,
RandomIter2 result, mystl::random_access_iterator_tag)
{
for (auto n = last - first; n > 0; --n)
*--result = mystl::move(*--last);
return result;
}
template <class BidirectionalIter1, class BidirectionalIter2>
BidirectionalIter2
unchecked_move_backward(BidirectionalIter1 first, BidirectionalIter1 last,
BidirectionalIter2 result)
{
return unchecked_move_backward_cat(first, last, result,
iterator_category(first));
}
// trivially_copy_assignable
template <class Tp, class Up>
typename std::enable_if<
std::is_same<typename std::remove_const<Tp>::type, Up>::value &&
std::is_trivially_move_assignable<Up>::value,
Up*>::type
unchecked_move_backward(Tp* first, Tp* last, Up* result)
{
const size_t n = static_cast<size_t>(last - first);
if (n != 0)
{
result -= n;
std::memmove(result, first, n * sizeof(Up));
}
return result;
}
template <class BidirectionalIter1, class BidirectionalIter2>
BidirectionalIter2
move_backward(BidirectionalIter1 first, BidirectionalIter1 last, BidirectionalIter2 result)
{
return unchecked_move_backward(first, last, result);
}
/*****************************************************************************************/
// equal
// [first, last)
/*****************************************************************************************/
template <class InputIter1, class InputIter2>
bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2)
{
for (; first1 != last1; ++first1, ++first2)
{
if (*first1 != *first2)
return false;
}
return true;
}
// comp
template <class InputIter1, class InputIter2, class Compared>
bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2, Compared comp)
{
for (; first1 != last1; ++first1, ++first2)
{
if (!comp(*first1, *first2))
return false;
}
return true;
}
/*****************************************************************************************/
// fill_n
// first n
/*****************************************************************************************/
template <class OutputIter, class Size, class T>
OutputIter unchecked_fill_n(OutputIter first, Size n, const T& value)
{
for (; n > 0; --n, ++first)
{
*first = value;
}
return first;
}
// one-byte
template <class Tp, class Size, class Up>
typename std::enable_if<
std::is_integral<Tp>::value && sizeof(Tp) == 1 &&
!std::is_same<Tp, bool>::value &&
std::is_integral<Up>::value && sizeof(Up) == 1,
Tp*>::type
unchecked_fill_n(Tp* first, Size n, Up value)
{
if (n > 0)
{
std::memset(first, (unsigned char)value, (size_t)(n));
}
return first + n;
}
template <class OutputIter, class Size, class T>
OutputIter fill_n(OutputIter first, Size n, const T& value)
{
return unchecked_fill_n(first, n, value);
}
/*****************************************************************************************/
// fill
// [first, last)
/*****************************************************************************************/
template <class ForwardIter, class T>
void fill_cat(ForwardIter first, ForwardIter last, const T& value,
mystl::forward_iterator_tag)
{
for (; first != last; ++first)
{
*first = value;
}
}
template <class RandomIter, class T>
void fill_cat(RandomIter first, RandomIter last, const T& value,
mystl::random_access_iterator_tag)
{
fill_n(first, last - first, value);
}
template <class ForwardIter, class T>
void fill(ForwardIter first, ForwardIter last, const T& value)
{
fill_cat(first, last, value, iterator_category(first));
}
/*****************************************************************************************/
// lexicographical_compare
//
// (1) true false
// (2) last1 last2 true
// (3) last2 last1 false
// (4) last1 last2 false
/*****************************************************************************************/
template <class InputIter1, class InputIter2>
bool lexicographical_compare(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2)
{
for (; first1 != last1 && first2 != last2; ++first1, ++first2)
{
if (*first1 < *first2)
return true;
if (*first2 < *first1)
return false;
}
return first1 == last1 && first2 != last2;
}
// comp
template <class InputIter1, class InputIter2, class Compred>
bool lexicographical_compare(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2, Compred comp)
{
for (; first1 != last1 && first2 != last2; ++first1, ++first2)
{
if (comp(*first1, *first2))
return true;
if (comp(*first2, *first1))
return false;
}
return first1 == last1 && first2 != last2;
}
// const unsigned char*
bool lexicographical_compare(const unsigned char* first1,
const unsigned char* last1,
const unsigned char* first2,
const unsigned char* last2)
{
const auto len1 = last1 - first1;
const auto len2 = last2 - first2;
//
const auto result = std::memcmp(first1, first2, mystl::min(len1, len2));
//
return result != 0 ? result < 0 : len1 < len2;
}
/*****************************************************************************************/
// mismatch
//
/*****************************************************************************************/
template <class InputIter1, class InputIter2>
mystl::pair<InputIter1, InputIter2>
mismatch(InputIter1 first1, InputIter1 last1, InputIter2 first2)
{
while (first1 != last1 && *first1 == *first2)
{
++first1;
++first2;
}
return mystl::pair<InputIter1, InputIter2>(first1, first2);
}
// comp
template <class InputIter1, class InputIter2, class Compred>
mystl::pair<InputIter1, InputIter2>
mismatch(InputIter1 first1, InputIter1 last1, InputIter2 first2, Compred comp)
{
while (first1 != last1 && comp(*first1, *first2))
{
++first1;
++first2;
}
return mystl::pair<InputIter1, InputIter2>(first1, first2);
}
} // namespace mystl
#endif // !MYTINYSTL_ALGOBASE_H_
``` | /content/code_sandbox/MyTinySTL/algobase.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 3,570 |
```objective-c
#ifndef MYTINYSTL_LIST_H_
#define MYTINYSTL_LIST_H_
// list
// list :
// notes:
//
//
// mystl::list<T>
// * emplace_front
// * emplace_back
// * emplace
// * push_front
// * push_back
// * insert
#include <initializer_list>
#include "iterator.h"
#include "memory.h"
#include "functional.h"
#include "util.h"
#include "exceptdef.h"
namespace mystl
{
template <class T> struct list_node_base;
template <class T> struct list_node;
template <class T>
struct node_traits
{
typedef list_node_base<T>* base_ptr;
typedef list_node<T>* node_ptr;
};
// list
template <class T>
struct list_node_base
{
typedef typename node_traits<T>::base_ptr base_ptr;
typedef typename node_traits<T>::node_ptr node_ptr;
base_ptr prev; //
base_ptr next; //
list_node_base() = default;
node_ptr as_node()
{
return static_cast<node_ptr>(self());
}
void unlink()
{
prev = next = self();
}
base_ptr self()
{
return static_cast<base_ptr>(&*this);
}
};
template <class T>
struct list_node : public list_node_base<T>
{
typedef typename node_traits<T>::base_ptr base_ptr;
typedef typename node_traits<T>::node_ptr node_ptr;
T value; //
list_node() = default;
list_node(const T& v)
:value(v)
{
}
list_node(T&& v)
:value(mystl::move(v))
{
}
base_ptr as_base()
{
return static_cast<base_ptr>(&*this);
}
node_ptr self()
{
return static_cast<node_ptr>(&*this);
}
};
// list
template <class T>
struct list_iterator : public mystl::iterator<mystl::bidirectional_iterator_tag, T>
{
typedef T value_type;
typedef T* pointer;
typedef T& reference;
typedef typename node_traits<T>::base_ptr base_ptr;
typedef typename node_traits<T>::node_ptr node_ptr;
typedef list_iterator<T> self;
base_ptr node_; //
//
list_iterator() = default;
list_iterator(base_ptr x)
:node_(x) {}
list_iterator(node_ptr x)
:node_(x->as_base()) {}
list_iterator(const list_iterator& rhs)
:node_(rhs.node_) {}
//
reference operator*() const { return node_->as_node()->value; }
pointer operator->() const { return &(operator*()); }
self& operator++()
{
MYSTL_DEBUG(node_ != nullptr);
node_ = node_->next;
return *this;
}
self operator++(int)
{
self tmp = *this;
++*this;
return tmp;
}
self& operator--()
{
MYSTL_DEBUG(node_ != nullptr);
node_ = node_->prev;
return *this;
}
self operator--(int)
{
self tmp = *this;
--*this;
return tmp;
}
//
bool operator==(const self& rhs) const { return node_ == rhs.node_; }
bool operator!=(const self& rhs) const { return node_ != rhs.node_; }
};
template <class T>
struct list_const_iterator : public iterator<bidirectional_iterator_tag, T>
{
typedef T value_type;
typedef const T* pointer;
typedef const T& reference;
typedef typename node_traits<T>::base_ptr base_ptr;
typedef typename node_traits<T>::node_ptr node_ptr;
typedef list_const_iterator<T> self;
base_ptr node_;
list_const_iterator() = default;
list_const_iterator(base_ptr x)
:node_(x) {}
list_const_iterator(node_ptr x)
:node_(x->as_base()) {}
list_const_iterator(const list_iterator<T>& rhs)
:node_(rhs.node_) {}
list_const_iterator(const list_const_iterator& rhs)
:node_(rhs.node_) {}
reference operator*() const { return node_->as_node()->value; }
pointer operator->() const { return &(operator*()); }
self& operator++()
{
MYSTL_DEBUG(node_ != nullptr);
node_ = node_->next;
return *this;
}
self operator++(int)
{
self tmp = *this;
++*this;
return tmp;
}
self& operator--()
{
MYSTL_DEBUG(node_ != nullptr);
node_ = node_->prev;
return *this;
}
self operator--(int)
{
self tmp = *this;
--*this;
return tmp;
}
//
bool operator==(const self& rhs) const { return node_ == rhs.node_; }
bool operator!=(const self& rhs) const { return node_ != rhs.node_; }
};
// : list
// T
template <class T>
class list
{
public:
// list
typedef mystl::allocator<T> allocator_type;
typedef mystl::allocator<T> data_allocator;
typedef mystl::allocator<list_node_base<T>> base_allocator;
typedef mystl::allocator<list_node<T>> node_allocator;
typedef typename allocator_type::value_type value_type;
typedef typename allocator_type::pointer pointer;
typedef typename allocator_type::const_pointer const_pointer;
typedef typename allocator_type::reference reference;
typedef typename allocator_type::const_reference const_reference;
typedef typename allocator_type::size_type size_type;
typedef typename allocator_type::difference_type difference_type;
typedef list_iterator<T> iterator;
typedef list_const_iterator<T> const_iterator;
typedef mystl::reverse_iterator<iterator> reverse_iterator;
typedef mystl::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename node_traits<T>::base_ptr base_ptr;
typedef typename node_traits<T>::node_ptr node_ptr;
allocator_type get_allocator() { return node_allocator(); }
private:
base_ptr node_; //
size_type size_; //
public:
//
list()
{ fill_init(0, value_type()); }
explicit list(size_type n)
{ fill_init(n, value_type()); }
list(size_type n, const T& value)
{ fill_init(n, value); }
template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::value, int>::type = 0>
list(Iter first, Iter last)
{ copy_init(first, last); }
list(std::initializer_list<T> ilist)
{ copy_init(ilist.begin(), ilist.end()); }
list(const list& rhs)
{ copy_init(rhs.cbegin(), rhs.cend()); }
list(list&& rhs) noexcept
:node_(rhs.node_), size_(rhs.size_)
{
rhs.node_ = nullptr;
rhs.size_ = 0;
}
list& operator=(const list& rhs)
{
if (this != &rhs)
{
assign(rhs.begin(), rhs.end());
}
return *this;
}
list& operator=(list&& rhs) noexcept
{
clear();
splice(end(), rhs);
return *this;
}
list& operator=(std::initializer_list<T> ilist)
{
list tmp(ilist.begin(), ilist.end());
swap(tmp);
return *this;
}
~list()
{
if (node_)
{
clear();
base_allocator::deallocate(node_);
node_ = nullptr;
size_ = 0;
}
}
public:
//
iterator begin() noexcept
{ return node_->next; }
const_iterator begin() const noexcept
{ return node_->next; }
iterator end() noexcept
{ return node_; }
const_iterator end() const noexcept
{ return node_; }
reverse_iterator rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept
{ return reverse_iterator(end()); }
reverse_iterator rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept
{ return reverse_iterator(begin()); }
const_iterator cbegin() const noexcept
{ return begin(); }
const_iterator cend() const noexcept
{ return end(); }
const_reverse_iterator crbegin() const noexcept
{ return rbegin(); }
const_reverse_iterator crend() const noexcept
{ return rend(); }
//
bool empty() const noexcept
{ return node_->next == node_; }
size_type size() const noexcept
{ return size_; }
size_type max_size() const noexcept
{ return static_cast<size_type>(-1); }
//
reference front()
{
MYSTL_DEBUG(!empty());
return *begin();
}
const_reference front() const
{
MYSTL_DEBUG(!empty());
return *begin();
}
reference back()
{
MYSTL_DEBUG(!empty());
return *(--end());
}
const_reference back() const
{
MYSTL_DEBUG(!empty());
return *(--end());
}
//
// assign
void assign(size_type n, const value_type& value)
{ fill_assign(n, value); }
template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::value, int>::type = 0>
void assign(Iter first, Iter last)
{ copy_assign(first, last); }
void assign(std::initializer_list<T> ilist)
{ copy_assign(ilist.begin(), ilist.end()); }
// emplace_front / emplace_back / emplace
template <class ...Args>
void emplace_front(Args&& ...args)
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list<T>'s size too big");
auto link_node = create_node(mystl::forward<Args>(args)...);
link_nodes_at_front(link_node->as_base(), link_node->as_base());
++size_;
}
template <class ...Args>
void emplace_back(Args&& ...args)
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list<T>'s size too big");
auto link_node = create_node(mystl::forward<Args>(args)...);
link_nodes_at_back(link_node->as_base(), link_node->as_base());
++size_;
}
template <class ...Args>
iterator emplace(const_iterator pos, Args&& ...args)
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list<T>'s size too big");
auto link_node = create_node(mystl::forward<Args>(args)...);
link_nodes(pos.node_, link_node->as_base(), link_node->as_base());
++size_;
return iterator(link_node);
}
// insert
iterator insert(const_iterator pos, const value_type& value)
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list<T>'s size too big");
auto link_node = create_node(value);
++size_;
return link_iter_node(pos, link_node->as_base());
}
iterator insert(const_iterator pos, value_type&& value)
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list<T>'s size too big");
auto link_node = create_node(mystl::move(value));
++size_;
return link_iter_node(pos, link_node->as_base());
}
iterator insert(const_iterator pos, size_type n, const value_type& value)
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - n, "list<T>'s size too big");
return fill_insert(pos, n, value);
}
template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::value, int>::type = 0>
iterator insert(const_iterator pos, Iter first, Iter last)
{
size_type n = mystl::distance(first, last);
THROW_LENGTH_ERROR_IF(size_ > max_size() - n, "list<T>'s size too big");
return copy_insert(pos, n, first);
}
// push_front / push_back
void push_front(const value_type& value)
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list<T>'s size too big");
auto link_node = create_node(value);
link_nodes_at_front(link_node->as_base(), link_node->as_base());
++size_;
}
void push_front(value_type&& value)
{
emplace_front(mystl::move(value));
}
void push_back(const value_type& value)
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list<T>'s size too big");
auto link_node = create_node(value);
link_nodes_at_back(link_node->as_base(), link_node->as_base());
++size_;
}
void push_back(value_type&& value)
{
emplace_back(mystl::move(value));
}
// pop_front / pop_back
void pop_front()
{
MYSTL_DEBUG(!empty());
auto n = node_->next;
unlink_nodes(n, n);
destroy_node(n->as_node());
--size_;
}
void pop_back()
{
MYSTL_DEBUG(!empty());
auto n = node_->prev;
unlink_nodes(n, n);
destroy_node(n->as_node());
--size_;
}
// erase / clear
iterator erase(const_iterator pos);
iterator erase(const_iterator first, const_iterator last);
void clear();
// resize
void resize(size_type new_size) { resize(new_size, value_type()); }
void resize(size_type new_size, const value_type& value);
void swap(list& rhs) noexcept
{
mystl::swap(node_, rhs.node_);
mystl::swap(size_, rhs.size_);
}
// list
void splice(const_iterator pos, list& other);
void splice(const_iterator pos, list& other, const_iterator it);
void splice(const_iterator pos, list& other, const_iterator first, const_iterator last);
void remove(const value_type& value)
{ remove_if([&](const value_type& v) {return v == value; }); }
template <class UnaryPredicate>
void remove_if(UnaryPredicate pred);
void unique()
{ unique(mystl::equal_to<T>()); }
template <class BinaryPredicate>
void unique(BinaryPredicate pred);
void merge(list& x)
{ merge(x, mystl::less<T>()); }
template <class Compare>
void merge(list& x, Compare comp);
void sort()
{ list_sort(begin(), end(), size(), mystl::less<T>()); }
template <class Compared>
void sort(Compared comp)
{ list_sort(begin(), end(), size(), comp); }
void reverse();
private:
// helper functions
// create / destroy node
template <class ...Args>
node_ptr create_node(Args&& ...agrs);
void destroy_node(node_ptr p);
// initialize
void fill_init(size_type n, const value_type& value);
template <class Iter>
void copy_init(Iter first, Iter last);
// link / unlink
iterator link_iter_node(const_iterator pos, base_ptr node);
void link_nodes(base_ptr p, base_ptr first, base_ptr last);
void link_nodes_at_front(base_ptr first, base_ptr last);
void link_nodes_at_back(base_ptr first, base_ptr last);
void unlink_nodes(base_ptr f, base_ptr l);
// assign
void fill_assign(size_type n, const value_type& value);
template <class Iter>
void copy_assign(Iter first, Iter last);
// insert
iterator fill_insert(const_iterator pos, size_type n, const value_type& value);
template <class Iter>
iterator copy_insert(const_iterator pos, size_type n, Iter first);
// sort
template <class Compared>
iterator list_sort(iterator first, iterator last, size_type n, Compared comp);
};
/*****************************************************************************************/
// pos
template <class T>
typename list<T>::iterator
list<T>::erase(const_iterator pos)
{
MYSTL_DEBUG(pos != cend());
auto n = pos.node_;
auto next = n->next;
unlink_nodes(n, n);
destroy_node(n->as_node());
--size_;
return iterator(next);
}
// [first, last)
template <class T>
typename list<T>::iterator
list<T>::erase(const_iterator first, const_iterator last)
{
if (first != last)
{
unlink_nodes(first.node_, last.node_->prev);
while (first != last)
{
auto cur = first.node_;
++first;
destroy_node(cur->as_node());
--size_;
}
}
return iterator(last.node_);
}
// list
template <class T>
void list<T>::clear()
{
if (size_ != 0)
{
auto cur = node_->next;
for (base_ptr next = cur->next; cur != node_; cur = next, next = cur->next)
{
destroy_node(cur->as_node());
}
node_->unlink();
size_ = 0;
}
}
//
template <class T>
void list<T>::resize(size_type new_size, const value_type& value)
{
auto i = begin();
size_type len = 0;
while (i != end() && len < new_size)
{
++i;
++len;
}
if (len == new_size)
{
erase(i, node_);
}
else
{
insert(node_, new_size - len, value);
}
}
// list x pos
template <class T>
void list<T>::splice(const_iterator pos, list& x)
{
MYSTL_DEBUG(this != &x);
if (!x.empty())
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - x.size_, "list<T>'s size too big");
auto f = x.node_->next;
auto l = x.node_->prev;
x.unlink_nodes(f, l);
link_nodes(pos.node_, f, l);
size_ += x.size_;
x.size_ = 0;
}
}
// it pos
template <class T>
void list<T>::splice(const_iterator pos, list& x, const_iterator it)
{
if (pos.node_ != it.node_ && pos.node_ != it.node_->next)
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list<T>'s size too big");
auto f = it.node_;
x.unlink_nodes(f, f);
link_nodes(pos.node_, f, f);
++size_;
--x.size_;
}
}
// list x [first, last) pos
template <class T>
void list<T>::splice(const_iterator pos, list& x, const_iterator first, const_iterator last)
{
if (first != last && this != &x)
{
size_type n = mystl::distance(first, last);
THROW_LENGTH_ERROR_IF(size_ > max_size() - n, "list<T>'s size too big");
auto f = first.node_;
auto l = last.node_->prev;
x.unlink_nodes(f, l);
link_nodes(pos.node_, f, l);
size_ += n;
x.size_ -= n;
}
}
// pred true
template <class T>
template <class UnaryPredicate>
void list<T>::remove_if(UnaryPredicate pred)
{
auto f = begin();
auto l = end();
for (auto next = f; f != l; f = next)
{
++next;
if (pred(*f))
{
erase(f);
}
}
}
// list pred true
template <class T>
template <class BinaryPredicate>
void list<T>::unique(BinaryPredicate pred)
{
auto i = begin();
auto e = end();
auto j = i;
++j;
while (j != e)
{
if (pred(*i, *j))
{
erase(j);
}
else
{
i = j;
}
j = i;
++j;
}
}
// list comp true
template <class T>
template <class Compare>
void list<T>::merge(list& x, Compare comp)
{
if (this != &x)
{
THROW_LENGTH_ERROR_IF(size_ > max_size() - x.size_, "list<T>'s size too big");
auto f1 = begin();
auto l1 = end();
auto f2 = x.begin();
auto l2 = x.end();
while (f1 != l1 && f2 != l2)
{
if (comp(*f2, *f1))
{
// comp true
auto next = f2;
++next;
for (; next != l2 && comp(*next, *f1); ++next)
;
auto f = f2.node_;
auto l = next.node_->prev;
f2 = next;
// link node
x.unlink_nodes(f, l);
link_nodes(f1.node_, f, l);
++f1;
}
else
{
++f1;
}
}
//
if (f2 != l2)
{
auto f = f2.node_;
auto l = l2.node_->prev;
x.unlink_nodes(f, l);
link_nodes(l1.node_, f, l);
}
size_ += x.size_;
x.size_ = 0;
}
}
// list
template <class T>
void list<T>::reverse()
{
if (size_ <= 1)
{
return;
}
auto i = begin();
auto e = end();
while (i.node_ != e.node_)
{
mystl::swap(i.node_->prev, i.node_->next);
i.node_ = i.node_->prev;
}
mystl::swap(e.node_->prev, e.node_->next);
}
/*****************************************************************************************/
// helper function
//
template <class T>
template <class ...Args>
typename list<T>::node_ptr
list<T>::create_node(Args&& ...args)
{
node_ptr p = node_allocator::allocate(1);
try
{
data_allocator::construct(mystl::address_of(p->value), mystl::forward<Args>(args)...);
p->prev = nullptr;
p->next = nullptr;
}
catch (...)
{
node_allocator::deallocate(p);
throw;
}
return p;
}
//
template <class T>
void list<T>::destroy_node(node_ptr p)
{
data_allocator::destroy(mystl::address_of(p->value));
node_allocator::deallocate(p);
}
// n
template <class T>
void list<T>::fill_init(size_type n, const value_type& value)
{
node_ = base_allocator::allocate(1);
node_->unlink();
size_ = n;
try
{
for (; n > 0; --n)
{
auto node = create_node(value);
link_nodes_at_back(node->as_base(), node->as_base());
}
}
catch (...)
{
clear();
base_allocator::deallocate(node_);
node_ = nullptr;
throw;
}
}
// [first, last)
template <class T>
template <class Iter>
void list<T>::copy_init(Iter first, Iter last)
{
node_ = base_allocator::allocate(1);
node_->unlink();
size_type n = mystl::distance(first, last);
size_ = n;
try
{
for (; n > 0; --n, ++first)
{
auto node = create_node(*first);
link_nodes_at_back(node->as_base(), node->as_base());
}
}
catch (...)
{
clear();
base_allocator::deallocate(node_);
node_ = nullptr;
throw;
}
}
// pos
template <class T>
typename list<T>::iterator
list<T>::link_iter_node(const_iterator pos, base_ptr link_node)
{
if (pos == node_->next)
{
link_nodes_at_front(link_node, link_node);
}
else if (pos == node_)
{
link_nodes_at_back(link_node, link_node);
}
else
{
link_nodes(pos.node_, link_node, link_node);
}
return iterator(link_node);
}
// pos [first, last]
template <class T>
void list<T>::link_nodes(base_ptr pos, base_ptr first, base_ptr last)
{
pos->prev->next = first;
first->prev = pos->prev;
pos->prev = last;
last->next = pos;
}
// [first, last]
template <class T>
void list<T>::link_nodes_at_front(base_ptr first, base_ptr last)
{
first->prev = node_;
last->next = node_->next;
last->next->prev = last;
node_->next = first;
}
// [first, last]
template <class T>
void list<T>::link_nodes_at_back(base_ptr first, base_ptr last)
{
last->next = node_;
first->prev = node_->prev;
first->prev->next = first;
node_->prev = last;
}
// [first, last]
template <class T>
void list<T>::unlink_nodes(base_ptr first, base_ptr last)
{
first->prev->next = last->next;
last->next->prev = first->prev;
}
// n
template <class T>
void list<T>::fill_assign(size_type n, const value_type& value)
{
auto i = begin();
auto e = end();
for (; n > 0 && i != e; --n, ++i)
{
*i = value;
}
if (n > 0)
{
insert(e, n, value);
}
else
{
erase(i, e);
}
}
// [f2, l2)
template <class T>
template <class Iter>
void list<T>::copy_assign(Iter f2, Iter l2)
{
auto f1 = begin();
auto l1 = end();
for (; f1 != l1 && f2 != l2; ++f1, ++f2)
{
*f1 = *f2;
}
if (f2 == l2)
{
erase(f1, l1);
}
else
{
insert(l1, f2, l2);
}
}
// pos n
template <class T>
typename list<T>::iterator
list<T>::fill_insert(const_iterator pos, size_type n, const value_type& value)
{
iterator r(pos.node_);
if (n != 0)
{
const auto add_size = n;
auto node = create_node(value);
node->prev = nullptr;
r = iterator(node);
iterator end = r;
try
{
// n - 1
for (--n; n > 0; --n, ++end)
{
auto next = create_node(value);
end.node_->next = next->as_base(); // link node
next->prev = end.node_;
}
size_ += add_size;
}
catch (...)
{
auto enode = end.node_;
while (true)
{
auto prev = enode->prev;
destroy_node(enode->as_node());
if (prev == nullptr)
break;
enode = prev;
}
throw;
}
link_nodes(pos.node_, r.node_, end.node_);
}
return r;
}
// pos [first, last)
template <class T>
template <class Iter>
typename list<T>::iterator
list<T>::copy_insert(const_iterator pos, size_type n, Iter first)
{
iterator r(pos.node_);
if (n != 0)
{
const auto add_size = n;
auto node = create_node(*first);
node->prev = nullptr;
r = iterator(node);
iterator end = r;
try
{
for (--n, ++first; n > 0; --n, ++first, ++end)
{
auto next = create_node(*first);
end.node_->next = next->as_base(); // link node
next->prev = end.node_;
}
size_ += add_size;
}
catch (...)
{
auto enode = end.node_;
while (true)
{
auto prev = enode->prev;
destroy_node(enode->as_node());
if (prev == nullptr)
break;
enode = prev;
}
throw;
}
link_nodes(pos.node_, r.node_, end.node_);
}
return r;
}
// list
template <class T>
template <class Compared>
typename list<T>::iterator
list<T>::list_sort(iterator f1, iterator l2, size_type n, Compared comp)
{
if (n < 2)
return f1;
if (n == 2)
{
if (comp(*--l2, *f1))
{
auto ln = l2.node_;
unlink_nodes(ln, ln);
link_nodes(f1.node_, ln, ln);
return l2;
}
return f1;
}
auto n2 = n / 2;
auto l1 = f1;
mystl::advance(l1, n2);
auto result = f1 = list_sort(f1, l1, n2, comp); //
auto f2 = l1 = list_sort(l1, l2, n - n2, comp); //
//
if (comp(*f2, *f1))
{
auto m = f2;
++m;
for (; m != l2 && comp(*m, *f1); ++m)
;
auto f = f2.node_;
auto l = m.node_->prev;
result = f2;
l1 = f2 = m;
unlink_nodes(f, l);
m = f1;
++m;
link_nodes(f1.node_, f, l);
f1 = m;
}
else
{
++f1;
}
//
while (f1 != l1 && f2 != l2)
{
if (comp(*f2, *f1))
{
auto m = f2;
++m;
for (; m != l2 && comp(*m, *f1); ++m)
;
auto f = f2.node_;
auto l = m.node_->prev;
if (l1 == f2)
l1 = m;
f2 = m;
unlink_nodes(f, l);
m = f1;
++m;
link_nodes(f1.node_, f, l);
f1 = m;
}
else
{
++f1;
}
}
return result;
}
//
template <class T>
bool operator==(const list<T>& lhs, const list<T>& rhs)
{
auto f1 = lhs.cbegin();
auto f2 = rhs.cbegin();
auto l1 = lhs.cend();
auto l2 = rhs.cend();
for (; f1 != l1 && f2 != l2 && *f1 == *f2; ++f1, ++f2)
;
return f1 == l1 && f2 == l2;
}
template <class T>
bool operator<(const list<T>& lhs, const list<T>& rhs)
{
return mystl::lexicographical_compare(lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend());
}
template <class T>
bool operator!=(const list<T>& lhs, const list<T>& rhs)
{
return !(lhs == rhs);
}
template <class T>
bool operator>(const list<T>& lhs, const list<T>& rhs)
{
return rhs < lhs;
}
template <class T>
bool operator<=(const list<T>& lhs, const list<T>& rhs)
{
return !(rhs < lhs);
}
template <class T>
bool operator>=(const list<T>& lhs, const list<T>& rhs)
{
return !(lhs < rhs);
}
// mystl swap
template <class T>
void swap(list<T>& lhs, list<T>& rhs) noexcept
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_LIST_H_
``` | /content/code_sandbox/MyTinySTL/list.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 7,263 |
```objective-c
#ifndef MYTINYSTL_UNORDERED_SET_H_
#define MYTINYSTL_UNORDERED_SET_H_
// unordered_set unordered_multiset
// set multiset hashtable
// notes:
//
//
// mystl::unordered_set<Key> / mystl::unordered_multiset<Key>
// * emplace
// * emplace_hint
// * insert
#include "hashtable.h"
namespace mystl
{
// unordered_set
// mystl::hash
// mystl::equal_to
template <class Key, class Hash = mystl::hash<Key>, class KeyEqual = mystl::equal_to<Key>>
class unordered_set
{
private:
// hashtable
typedef hashtable<Key, Hash, KeyEqual> base_type;
base_type ht_;
public:
// hashtable
typedef typename base_type::allocator_type allocator_type;
typedef typename base_type::key_type key_type;
typedef typename base_type::value_type value_type;
typedef typename base_type::hasher hasher;
typedef typename base_type::key_equal key_equal;
typedef typename base_type::size_type size_type;
typedef typename base_type::difference_type difference_type;
typedef typename base_type::pointer pointer;
typedef typename base_type::const_pointer const_pointer;
typedef typename base_type::reference reference;
typedef typename base_type::const_reference const_reference;
typedef typename base_type::const_iterator iterator;
typedef typename base_type::const_iterator const_iterator;
typedef typename base_type::const_local_iterator local_iterator;
typedef typename base_type::const_local_iterator const_local_iterator;
allocator_type get_allocator() const { return ht_.get_allocator(); }
public:
//
unordered_set()
:ht_(100, Hash(), KeyEqual())
{
}
explicit unordered_set(size_type bucket_count,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(bucket_count, hash, equal)
{
}
template <class InputIterator>
unordered_set(InputIterator first, InputIterator last,
const size_type bucket_count = 100,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
: ht_(mystl::max(bucket_count, static_cast<size_type>(mystl::distance(first, last))), hash, equal)
{
for (; first != last; ++first)
ht_.insert_unique_noresize(*first);
}
unordered_set(std::initializer_list<value_type> ilist,
const size_type bucket_count = 100,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(mystl::max(bucket_count, static_cast<size_type>(ilist.size())), hash, equal)
{
for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
ht_.insert_unique_noresize(*first);
}
unordered_set(const unordered_set& rhs)
:ht_(rhs.ht_)
{
}
unordered_set(unordered_set&& rhs) noexcept
: ht_(mystl::move(rhs.ht_))
{
}
unordered_set& operator=(const unordered_set& rhs)
{
ht_ = rhs.ht_;
return *this;
}
unordered_set& operator=(unordered_set&& rhs)
{
ht_ = mystl::move(rhs.ht_);
return *this;
}
unordered_set& operator=(std::initializer_list<value_type> ilist)
{
ht_.clear();
ht_.reserve(ilist.size());
for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
ht_.insert_unique_noresize(*first);
return *this;
}
~unordered_set() = default;
//
iterator begin() noexcept
{ return ht_.begin(); }
const_iterator begin() const noexcept
{ return ht_.begin(); }
iterator end() noexcept
{ return ht_.end(); }
const_iterator end() const noexcept
{ return ht_.end(); }
const_iterator cbegin() const noexcept
{ return ht_.cbegin(); }
const_iterator cend() const noexcept
{ return ht_.cend(); }
//
bool empty() const noexcept { return ht_.empty(); }
size_type size() const noexcept { return ht_.size(); }
size_type max_size() const noexcept { return ht_.max_size(); }
//
// empalce / empalce_hint
template <class ...Args>
pair<iterator, bool> emplace(Args&& ...args)
{ return ht_.emplace_unique(mystl::forward<Args>(args)...); }
template <class ...Args>
iterator emplace_hint(const_iterator hint, Args&& ...args)
{ return ht_.emplace_unique_use_hint(hint, mystl::forward<Args>(args)...); }
// insert
pair<iterator, bool> insert(const value_type& value)
{ return ht_.insert_unique(value); }
pair<iterator, bool> insert(value_type&& value)
{ return ht_.emplace_unique(mystl::move(value)); }
iterator insert(const_iterator hint, const value_type& value)
{ return ht_.insert_unique_use_hint(hint, value); }
iterator insert(const_iterator hint, value_type&& value)
{ return ht_.emplace_unique_use_hint(hint, mystl::move(value)); }
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{ ht_.insert_unique(first, last); }
// erase / clear
void erase(iterator it)
{ ht_.erase(it); }
void erase(iterator first, iterator last)
{ ht_.erase(first, last); }
size_type erase(const key_type& key)
{ return ht_.erase_unique(key); }
void clear()
{ ht_.clear(); }
void swap(unordered_set& other) noexcept
{ ht_.swap(other.ht_); }
//
size_type count(const key_type& key) const
{ return ht_.count(key); }
iterator find(const key_type& key)
{ return ht_.find(key); }
const_iterator find(const key_type& key) const
{ return ht_.find(key); }
pair<iterator, iterator> equal_range(const key_type& key)
{ return ht_.equal_range_unique(key); }
pair<const_iterator, const_iterator> equal_range(const key_type& key) const
{ return ht_.equal_range_unique(key); }
// bucket interface
local_iterator begin(size_type n) noexcept
{ return ht_.begin(n); }
const_local_iterator begin(size_type n) const noexcept
{ return ht_.begin(n); }
const_local_iterator cbegin(size_type n) const noexcept
{ return ht_.cbegin(n); }
local_iterator end(size_type n) noexcept
{ return ht_.end(n); }
const_local_iterator end(size_type n) const noexcept
{ return ht_.end(n); }
const_local_iterator cend(size_type n) const noexcept
{ return ht_.cend(n); }
size_type bucket_count() const noexcept
{ return ht_.bucket_count(); }
size_type max_bucket_count() const noexcept
{ return ht_.max_bucket_count(); }
size_type bucket_size(size_type n) const noexcept
{ return ht_.bucket_size(n); }
size_type bucket(const key_type& key) const
{ return ht_.bucket(key); }
// hash policy
float load_factor() const noexcept { return ht_.load_factor(); }
float max_load_factor() const noexcept { return ht_.max_load_factor(); }
void max_load_factor(float ml) { ht_.max_load_factor(ml); }
void rehash(size_type count) { ht_.rehash(count); }
void reserve(size_type count) { ht_.reserve(count); }
hasher hash_fcn() const { return ht_.hash_fcn(); }
key_equal key_eq() const { return ht_.key_eq(); }
public:
friend bool operator==(const unordered_set& lhs, const unordered_set& rhs)
{
return lhs.ht_.equal_range_unique(rhs.ht_);
}
friend bool operator!=(const unordered_set& lhs, const unordered_set& rhs)
{
return !lhs.ht_.equal_range_unique(rhs.ht_);
}
};
//
template <class Key, class Hash, class KeyEqual, class Alloc>
bool operator==(const unordered_set<Key, Hash, KeyEqual>& lhs,
const unordered_set<Key, Hash, KeyEqual>& rhs)
{
return lhs == rhs;
}
template <class Key, class Hash, class KeyEqual, class Alloc>
bool operator!=(const unordered_set<Key, Hash, KeyEqual>& lhs,
const unordered_set<Key, Hash, KeyEqual>& rhs)
{
return lhs != rhs;
}
// mystl swap
template <class Key, class Hash, class KeyEqual, class Alloc>
void swap(unordered_set<Key, Hash, KeyEqual>& lhs,
unordered_set<Key, Hash, KeyEqual>& rhs)
{
lhs.swap(rhs);
}
/*****************************************************************************************/
// unordered_multiset
// mystl::hash
// mystl::equal_to
template <class Key, class Hash = mystl::hash<Key>, class KeyEqual = mystl::equal_to<Key>>
class unordered_multiset
{
private:
// hashtable
typedef hashtable<Key, Hash, KeyEqual> base_type;
base_type ht_;
public:
// hashtable
typedef typename base_type::allocator_type allocator_type;
typedef typename base_type::key_type key_type;
typedef typename base_type::value_type value_type;
typedef typename base_type::hasher hasher;
typedef typename base_type::key_equal key_equal;
typedef typename base_type::size_type size_type;
typedef typename base_type::difference_type difference_type;
typedef typename base_type::pointer pointer;
typedef typename base_type::const_pointer const_pointer;
typedef typename base_type::reference reference;
typedef typename base_type::const_reference const_reference;
typedef typename base_type::const_iterator iterator;
typedef typename base_type::const_iterator const_iterator;
typedef typename base_type::const_local_iterator local_iterator;
typedef typename base_type::const_local_iterator const_local_iterator;
allocator_type get_allocator() const { return ht_.get_allocator(); }
public:
//
unordered_multiset()
:ht_(100, Hash(), KeyEqual())
{
}
explicit unordered_multiset(size_type bucket_count,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(bucket_count, hash, equal)
{
}
template <class InputIterator>
unordered_multiset(InputIterator first, InputIterator last,
const size_type bucket_count = 100,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
: ht_(mystl::max(bucket_count, static_cast<size_type>(mystl::distance(first, last))), hash, equal)
{
for (; first != last; ++first)
ht_.insert_multi_noresize(*first);
}
unordered_multiset(std::initializer_list<value_type> ilist,
const size_type bucket_count = 100,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(mystl::max(bucket_count, static_cast<size_type>(ilist.size())), hash, equal)
{
for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
ht_.insert_multi_noresize(*first);
}
unordered_multiset(const unordered_multiset& rhs)
:ht_(rhs.ht_)
{
}
unordered_multiset(unordered_multiset&& rhs) noexcept
: ht_(mystl::move(rhs.ht_))
{
}
unordered_multiset& operator=(const unordered_multiset& rhs)
{
ht_ = rhs.ht_;
return *this;
}
unordered_multiset& operator=(unordered_multiset&& rhs)
{
ht_ = mystl::move(rhs.ht_);
return *this;
}
unordered_multiset& operator=(std::initializer_list<value_type> ilist)
{
ht_.clear();
ht_.reserve(ilist.size());
for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
ht_.insert_multi_noresize(*first);
return *this;
}
~unordered_multiset() = default;
//
iterator begin() noexcept
{ return ht_.begin(); }
const_iterator begin() const noexcept
{ return ht_.begin(); }
iterator end() noexcept
{ return ht_.end(); }
const_iterator end() const noexcept
{ return ht_.end(); }
const_iterator cbegin() const noexcept
{ return ht_.cbegin(); }
const_iterator cend() const noexcept
{ return ht_.cend(); }
//
bool empty() const noexcept { return ht_.empty(); }
size_type size() const noexcept { return ht_.size(); }
size_type max_size() const noexcept { return ht_.max_size(); }
//
// emplace / emplace_hint
template <class ...Args>
iterator emplace(Args&& ...args)
{ return ht_.emplace_multi(mystl::forward<Args>(args)...); }
template <class ...Args>
iterator emplace_hint(const_iterator hint, Args&& ...args)
{ return ht_.emplace_multi_use_hint(hint, mystl::forward<Args>(args)...); }
// insert
iterator insert(const value_type& value)
{ return ht_.insert_multi(value); }
iterator insert(value_type&& value)
{ return ht_.emplace_multi(mystl::move(value)); }
iterator insert(const_iterator hint, const value_type& value)
{ return ht_.insert_multi_use_hint(hint, value); }
iterator insert(const_iterator hint, value_type&& value)
{ return ht_.emplace_multi_use_hint(hint, mystl::move(value)); }
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{ ht_.insert_multi(first, last); }
// erase / clear
void erase(iterator it)
{ ht_.erase(it); }
void erase(iterator first, iterator last)
{ ht_.erase(first, last); }
size_type erase(const key_type& key)
{ return ht_.erase_multi(key); }
void clear()
{ ht_.clear(); }
void swap(unordered_multiset& other) noexcept
{ ht_.swap(other.ht_); }
//
size_type count(const key_type& key) const
{ return ht_.count(key); }
iterator find(const key_type& key)
{ return ht_.find(key); }
const_iterator find(const key_type& key) const
{ return ht_.find(key); }
pair<iterator, iterator> equal_range(const key_type& key)
{ return ht_.equal_range_multi(key); }
pair<const_iterator, const_iterator> equal_range(const key_type& key) const
{ return ht_.equal_range_multi(key); }
// bucket interface
local_iterator begin(size_type n) noexcept
{ return ht_.begin(n); }
const_local_iterator begin(size_type n) const noexcept
{ return ht_.begin(n); }
const_local_iterator cbegin(size_type n) const noexcept
{ return ht_.cbegin(n); }
local_iterator end(size_type n) noexcept
{ return ht_.end(n); }
const_local_iterator end(size_type n) const noexcept
{ return ht_.end(n); }
const_local_iterator cend(size_type n) const noexcept
{ return ht_.cend(n); }
size_type bucket_count() const noexcept
{ return ht_.bucket_count(); }
size_type max_bucket_count() const noexcept
{ return ht_.max_bucket_count(); }
size_type bucket_size(size_type n) const noexcept
{ return ht_.bucket_size(n); }
size_type bucket(const key_type& key) const
{ return ht_.bucket(key); }
// hash policy
float load_factor() const noexcept { return ht_.load_factor(); }
float max_load_factor() const noexcept { return ht_.max_load_factor(); }
void max_load_factor(float ml) { ht_.max_load_factor(ml); }
void rehash(size_type count) { ht_.rehash(count); }
void reserve(size_type count) { ht_.reserve(count); }
hasher hash_fcn() const { return ht_.hash_fcn(); }
key_equal key_eq() const { return ht_.key_eq(); }
public:
friend bool operator==(const unordered_multiset& lhs, const unordered_multiset& rhs)
{
return lhs.ht_.equal_range_multi(rhs.ht_);
}
friend bool operator!=(const unordered_multiset& lhs, const unordered_multiset& rhs)
{
return !lhs.ht_.equal_range_multi(rhs.ht_);
}
};
//
template <class Key, class Hash, class KeyEqual, class Alloc>
bool operator==(const unordered_multiset<Key, Hash, KeyEqual>& lhs,
const unordered_multiset<Key, Hash, KeyEqual>& rhs)
{
return lhs == rhs;
}
template <class Key, class Hash, class KeyEqual, class Alloc>
bool operator!=(const unordered_multiset<Key, Hash, KeyEqual>& lhs,
const unordered_multiset<Key, Hash, KeyEqual>& rhs)
{
return lhs != rhs;
}
// mystl swap
template <class Key, class Hash, class KeyEqual, class Alloc>
void swap(unordered_multiset<Key, Hash, KeyEqual>& lhs,
unordered_multiset<Key, Hash, KeyEqual>& rhs)
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_UNORDERED_SET_H_
``` | /content/code_sandbox/MyTinySTL/unordered_set.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 3,984 |
```objective-c
#ifndef MYTINYSTL_SET_H_
#define MYTINYSTL_SET_H_
// set multiset
// set :
// multiset :
// notes:
//
//
// mystl::set<Key> / mystl::multiset<Key>
// * emplace
// * emplace_hint
// * insert
#include "rb_tree.h"
namespace mystl
{
// set
// mystl::less
template <class Key, class Compare = mystl::less<Key>>
class set
{
public:
typedef Key key_type;
typedef Key value_type;
typedef Compare key_compare;
typedef Compare value_compare;
private:
// mystl::rb_tree
typedef mystl::rb_tree<value_type, key_compare> base_type;
base_type tree_;
public:
// rb_tree
typedef typename base_type::node_type node_type;
typedef typename base_type::const_pointer pointer;
typedef typename base_type::const_pointer const_pointer;
typedef typename base_type::const_reference reference;
typedef typename base_type::const_reference const_reference;
typedef typename base_type::const_iterator iterator;
typedef typename base_type::const_iterator const_iterator;
typedef typename base_type::const_reverse_iterator reverse_iterator;
typedef typename base_type::const_reverse_iterator const_reverse_iterator;
typedef typename base_type::size_type size_type;
typedef typename base_type::difference_type difference_type;
typedef typename base_type::allocator_type allocator_type;
public:
//
set() = default;
template <class InputIterator>
set(InputIterator first, InputIterator last)
:tree_()
{ tree_.insert_unique(first, last); }
set(std::initializer_list<value_type> ilist)
:tree_()
{ tree_.insert_unique(ilist.begin(), ilist.end()); }
set(const set& rhs)
:tree_(rhs.tree_)
{
}
set(set&& rhs) noexcept
:tree_(mystl::move(rhs.tree_))
{
}
set& operator=(const set& rhs)
{
tree_ = rhs.tree_;
return *this;
}
set& operator=(set&& rhs)
{
tree_ = mystl::move(rhs.tree_);
return *this;
}
set& operator=(std::initializer_list<value_type> ilist)
{
tree_.clear();
tree_.insert_unique(ilist.begin(), ilist.end());
return *this;
}
//
key_compare key_comp() const { return tree_.key_comp(); }
value_compare value_comp() const { return tree_.key_comp(); }
allocator_type get_allocator() const { return tree_.get_allocator(); }
//
iterator begin() noexcept
{ return tree_.begin(); }
const_iterator begin() const noexcept
{ return tree_.begin(); }
iterator end() noexcept
{ return tree_.end(); }
const_iterator end() const noexcept
{ return tree_.end(); }
reverse_iterator rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator cbegin() const noexcept
{ return begin(); }
const_iterator cend() const noexcept
{ return end(); }
const_reverse_iterator crbegin() const noexcept
{ return rbegin(); }
const_reverse_iterator crend() const noexcept
{ return rend(); }
//
bool empty() const noexcept { return tree_.empty(); }
size_type size() const noexcept { return tree_.size(); }
size_type max_size() const noexcept { return tree_.max_size(); }
//
template <class ...Args>
pair<iterator, bool> emplace(Args&& ...args)
{
return tree_.emplace_unique(mystl::forward<Args>(args)...);
}
template <class ...Args>
iterator emplace_hint(iterator hint, Args&& ...args)
{
return tree_.emplace_unique_use_hint(hint, mystl::forward<Args>(args)...);
}
pair<iterator, bool> insert(const value_type& value)
{
return tree_.insert_unique(value);
}
pair<iterator, bool> insert(value_type&& value)
{
return tree_.insert_unique(mystl::move(value));
}
iterator insert(iterator hint, const value_type& value)
{
return tree_.insert_unique(hint, value);
}
iterator insert(iterator hint, value_type&& value)
{
return tree_.insert_unique(hint, mystl::move(value));
}
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{
tree_.insert_unique(first, last);
}
void erase(iterator position) { tree_.erase(position); }
size_type erase(const key_type& key) { return tree_.erase_unique(key); }
void erase(iterator first, iterator last) { tree_.erase(first, last); }
void clear() { tree_.clear(); }
// set
iterator find(const key_type& key) { return tree_.find(key); }
const_iterator find(const key_type& key) const { return tree_.find(key); }
size_type count(const key_type& key) const { return tree_.count_unique(key); }
iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); }
const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); }
iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); }
const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); }
pair<iterator, iterator>
equal_range(const key_type& key)
{ return tree_.equal_range_unique(key); }
pair<const_iterator, const_iterator>
equal_range(const key_type& key) const
{ return tree_.equal_range_unique(key); }
void swap(set& rhs) noexcept
{ tree_.swap(rhs.tree_); }
public:
friend bool operator==(const set& lhs, const set& rhs) { return lhs.tree_ == rhs.tree_; }
friend bool operator< (const set& lhs, const set& rhs) { return lhs.tree_ < rhs.tree_; }
};
//
template <class Key, class Compare>
bool operator==(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
{
return lhs == rhs;
}
template <class Key, class Compare>
bool operator<(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
{
return lhs < rhs;
}
template <class Key, class Compare>
bool operator!=(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
{
return !(lhs == rhs);
}
template <class Key, class Compare>
bool operator>(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
{
return rhs < lhs;
}
template <class Key, class Compare>
bool operator<=(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
{
return !(rhs < lhs);
}
template <class Key, class Compare>
bool operator>=(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
{
return !(lhs < rhs);
}
// mystl swap
template <class Key, class Compare>
void swap(set<Key, Compare>& lhs, set<Key, Compare>& rhs) noexcept
{
lhs.swap(rhs);
}
/*****************************************************************************************/
// multiset
// mystl::less
template <class Key, class Compare = mystl::less<Key>>
class multiset
{
public:
typedef Key key_type;
typedef Key value_type;
typedef Compare key_compare;
typedef Compare value_compare;
private:
// mystl::rb_tree
typedef mystl::rb_tree<value_type, key_compare> base_type;
base_type tree_; // rb_tree multiset
public:
// rb_tree
typedef typename base_type::node_type node_type;
typedef typename base_type::const_pointer pointer;
typedef typename base_type::const_pointer const_pointer;
typedef typename base_type::const_reference reference;
typedef typename base_type::const_reference const_reference;
typedef typename base_type::const_iterator iterator;
typedef typename base_type::const_iterator const_iterator;
typedef typename base_type::const_reverse_iterator reverse_iterator;
typedef typename base_type::const_reverse_iterator const_reverse_iterator;
typedef typename base_type::size_type size_type;
typedef typename base_type::difference_type difference_type;
typedef typename base_type::allocator_type allocator_type;
public:
//
multiset() = default;
template <class InputIterator>
multiset(InputIterator first, InputIterator last)
:tree_()
{ tree_.insert_multi(first, last); }
multiset(std::initializer_list<value_type> ilist)
:tree_()
{ tree_.insert_multi(ilist.begin(), ilist.end()); }
multiset(const multiset& rhs)
:tree_(rhs.tree_)
{
}
multiset(multiset&& rhs) noexcept
:tree_(mystl::move(rhs.tree_))
{
}
multiset& operator=(const multiset& rhs)
{
tree_ = rhs.tree_;
return *this;
}
multiset& operator=(multiset&& rhs)
{
tree_ = mystl::move(rhs.tree_);
return *this;
}
multiset& operator=(std::initializer_list<value_type> ilist)
{
tree_.clear();
tree_.insert_multi(ilist.begin(), ilist.end());
return *this;
}
//
key_compare key_comp() const { return tree_.key_comp(); }
value_compare value_comp() const { return tree_.key_comp(); }
allocator_type get_allocator() const { return tree_.get_allocator(); }
//
iterator begin() noexcept
{ return tree_.begin(); }
const_iterator begin() const noexcept
{ return tree_.begin(); }
iterator end() noexcept
{ return tree_.end(); }
const_iterator end() const noexcept
{ return tree_.end(); }
reverse_iterator rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator cbegin() const noexcept
{ return begin(); }
const_iterator cend() const noexcept
{ return end(); }
const_reverse_iterator crbegin() const noexcept
{ return rbegin(); }
const_reverse_iterator crend() const noexcept
{ return rend(); }
//
bool empty() const noexcept { return tree_.empty(); }
size_type size() const noexcept { return tree_.size(); }
size_type max_size() const noexcept { return tree_.max_size(); }
//
template <class ...Args>
iterator emplace(Args&& ...args)
{
return tree_.emplace_multi(mystl::forward<Args>(args)...);
}
template <class ...Args>
iterator emplace_hint(iterator hint, Args&& ...args)
{
return tree_.emplace_multi_use_hint(hint, mystl::forward<Args>(args)...);
}
iterator insert(const value_type& value)
{
return tree_.insert_multi(value);
}
iterator insert(value_type&& value)
{
return tree_.insert_multi(mystl::move(value));
}
iterator insert(iterator hint, const value_type& value)
{
return tree_.insert_multi(hint, value);
}
iterator insert(iterator hint, value_type&& value)
{
return tree_.insert_multi(hint, mystl::move(value));
}
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{
tree_.insert_multi(first, last);
}
void erase(iterator position) { tree_.erase(position); }
size_type erase(const key_type& key) { return tree_.erase_multi(key); }
void erase(iterator first, iterator last) { tree_.erase(first, last); }
void clear() { tree_.clear(); }
// multiset
iterator find(const key_type& key) { return tree_.find(key); }
const_iterator find(const key_type& key) const { return tree_.find(key); }
size_type count(const key_type& key) const { return tree_.count_multi(key); }
iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); }
const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); }
iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); }
const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); }
pair<iterator, iterator>
equal_range(const key_type& key)
{ return tree_.equal_range_multi(key); }
pair<const_iterator, const_iterator>
equal_range(const key_type& key) const
{ return tree_.equal_range_multi(key); }
void swap(multiset& rhs) noexcept
{ tree_.swap(rhs.tree_); }
public:
friend bool operator==(const multiset& lhs, const multiset& rhs) { return lhs.tree_ == rhs.tree_; }
friend bool operator< (const multiset& lhs, const multiset& rhs) { return lhs.tree_ < rhs.tree_; }
};
//
template <class Key, class Compare>
bool operator==(const multiset<Key, Compare>& lhs, const multiset<Key, Compare>& rhs)
{
return lhs == rhs;
}
template <class Key, class Compare>
bool operator<(const multiset<Key, Compare>& lhs, const multiset<Key, Compare>& rhs)
{
return lhs < rhs;
}
template <class Key, class Compare>
bool operator!=(const multiset<Key, Compare>& lhs, const multiset<Key, Compare>& rhs)
{
return !(lhs == rhs);
}
template <class Key, class Compare>
bool operator>(const multiset<Key, Compare>& lhs, const multiset<Key, Compare>& rhs)
{
return rhs < lhs;
}
template <class Key, class Compare>
bool operator<=(const multiset<Key, Compare>& lhs, const multiset<Key, Compare>& rhs)
{
return !(rhs < lhs);
}
template <class Key, class Compare>
bool operator>=(const multiset<Key, Compare>& lhs, const multiset<Key, Compare>& rhs)
{
return !(lhs < rhs);
}
// mystl swap
template <class Key, class Compare>
void swap(multiset<Key, Compare>& lhs, multiset<Key, Compare>& rhs) noexcept
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_SET_H_
``` | /content/code_sandbox/MyTinySTL/set.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 3,380 |
```objective-c
#ifndef MYTINYSTL_SET_ALGO_H_
#define MYTINYSTL_SET_ALGO_H_
// set : union, intersection, difference, symmetric_difference
//
#include "algobase.h"
#include "iterator.h"
namespace mystl
{
/*****************************************************************************************/
// set_union
// S1S2 result
/*****************************************************************************************/
template <class InputIter1, class InputIter2, class OutputIter>
OutputIter set_union(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2,
OutputIter result)
{
while (first1 != last1 && first2 != last2)
{
if (*first1 < *first2)
{
*result = *first1;
++first1;
}
else if (*first2 < *first1)
{
*result = *first2;
++first2;
}
else
{
*result = *first1;
++first1;
++first2;
}
++result;
}
// result
return mystl::copy(first2, last2, mystl::copy(first1, last1, result));
}
// comp
template <class InputIter1, class InputIter2, class OutputIter, class Compared>
OutputIter set_union(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2,
OutputIter result, Compared comp)
{
while (first1 != last1 && first2 != last2)
{
if (comp(*first1, *first2))
{
*result = *first1;
++first1;
}
else if (comp(*first2, *first1))
{
*result = *first2;
++first2;
}
else
{
*result = *first1;
++first1;
++first2;
}
++result;
}
// result
return mystl::copy(first2, last2, mystl::copy(first1, last1, result));
}
/*****************************************************************************************/
// set_intersection
// S1S2 result
/*****************************************************************************************/
template <class InputIter1, class InputIter2, class OutputIter>
OutputIter set_intersection(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2,
OutputIter result)
{
while (first1 != last1 && first2 != last2)
{
if (*first1 < *first2)
{
++first1;
}
else if (*first2 < *first1)
{
++first2;
}
else
{
*result = *first1;
++first1;
++first2;
++result;
}
}
return result;
}
// comp
template <class InputIter1, class InputIter2, class OutputIter, class Compared>
OutputIter set_intersection(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2,
OutputIter result, Compared comp)
{
while (first1 != last1 && first2 != last2)
{
if (comp(*first1, *first2))
{
++first1;
}
else if (comp(*first2, *first1))
{
++first2;
}
else
{
*result = *first1;
++first1;
++first2;
++result;
}
}
return result;
}
/*****************************************************************************************/
// set_difference
// S1-S2 result
/*****************************************************************************************/
template <class InputIter1, class InputIter2, class OutputIter>
OutputIter set_difference(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2,
OutputIter result)
{
while (first1 != last1 && first2 != last2)
{
if (*first1 < *first2)
{
*result = *first1;
++first1;
++result;
}
else if (*first2 < *first1)
{
++first2;
}
else
{
++first1;
++first2;
}
}
return mystl::copy(first1, last1, result);
}
// comp
template <class InputIter1, class InputIter2, class OutputIter, class Compared>
OutputIter set_difference(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2,
OutputIter result, Compared comp)
{
while (first1 != last1 && first2 != last2)
{
if (comp(*first1, *first2))
{
*result = *first1;
++first1;
++result;
}
else if (comp(*first2, *first1))
{
++first2;
}
else
{
++first1;
++first2;
}
}
return mystl::copy(first1, last1, result);
}
/*****************************************************************************************/
// set_symmetric_difference
// (S1-S2)(S2-S1) result
/*****************************************************************************************/
template <class InputIter1, class InputIter2, class OutputIter>
OutputIter set_symmetric_difference(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2,
OutputIter result)
{
while (first1 != last1 && first2 != last2)
{
if (*first1 < *first2)
{
*result = *first1;
++first1;
++result;
}
else if (*first2 < *first1)
{
*result = *first2;
++first2;
++result;
}
else
{
++first1;
++first2;
}
}
return mystl::copy(first2, last2, mystl::copy(first1, last1, result));
}
// comp
template <class InputIter1, class InputIter2, class OutputIter, class Compared>
OutputIter set_symmetric_difference(InputIter1 first1, InputIter1 last1,
InputIter2 first2, InputIter2 last2,
OutputIter result, Compared comp)
{
while (first1 != last1 && first2 != last2)
{
if (comp(*first1, *first2))
{
*result = *first1;
++first1;
++result;
}
else if (comp(*first2, *first1))
{
*result = *first2;
++first2;
++result;
}
else
{
++first1;
++first2;
}
}
return mystl::copy(first2, last2, mystl::copy(first1, last1, result));
}
} // namespace mystl
#endif // !MYTINYSTL_SET_ALGO_H_
``` | /content/code_sandbox/MyTinySTL/set_algo.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 1,534 |
```objective-c
#ifndef MYTINYSTL_ALGORITHM_H_
#define MYTINYSTL_ALGORITHM_H_
// mystl heap set
#include "algobase.h"
#include "algo.h"
#include "set_algo.h"
#include "heap_algo.h"
#include "numeric.h"
namespace mystl
{
} // namespace mystl
#endif // !MYTINYSTL_ALGORITHM_H_
``` | /content/code_sandbox/MyTinySTL/algorithm.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 80 |
```objective-c
#ifndef MYTINYSTL_FUNCTIONAL_H_
#define MYTINYSTL_FUNCTIONAL_H_
// mystl
#include <cstddef>
namespace mystl
{
//
template <class Arg, class Result>
struct unarg_function
{
typedef Arg argument_type;
typedef Result result_type;
};
//
template <class Arg1, class Arg2, class Result>
struct binary_function
{
typedef Arg1 first_argument_type;
typedef Arg2 second_argument_type;
typedef Result result_type;
};
//
template <class T>
struct plus :public binary_function<T, T, T>
{
T operator()(const T& x, const T& y) const { return x + y; }
};
//
template <class T>
struct minus :public binary_function<T, T, T>
{
T operator()(const T& x, const T& y) const { return x - y; }
};
//
template <class T>
struct multiplies :public binary_function<T, T, T>
{
T operator()(const T& x, const T& y) const { return x * y; }
};
//
template <class T>
struct divides :public binary_function<T, T, T>
{
T operator()(const T& x, const T& y) const { return x / y; }
};
//
template <class T>
struct modulus :public binary_function<T, T, T>
{
T operator()(const T& x, const T& y) const { return x % y; }
};
//
template <class T>
struct negate :public unarg_function<T, T>
{
T operator()(const T& x) const { return -x; }
};
//
template <class T>
T identity_element(plus<T>) { return T(0); }
//
template <class T>
T identity_element(multiplies<T>) { return T(1); }
//
template <class T>
struct equal_to :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x == y; }
};
//
template <class T>
struct not_equal_to :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x != y; }
};
//
template <class T>
struct greater :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x > y; }
};
//
template <class T>
struct less :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x < y; }
};
//
template <class T>
struct greater_equal :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x >= y; }
};
//
template <class T>
struct less_equal :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x <= y; }
};
//
template <class T>
struct logical_and :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x && y; }
};
//
template <class T>
struct logical_or :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x || y; }
};
//
template <class T>
struct logical_not :public unarg_function<T, bool>
{
bool operator()(const T& x) const { return !x; }
};
//
template <class T>
struct identity :public unarg_function<T, bool>
{
const T& operator()(const T& x) const { return x; }
};
// pair
template <class Pair>
struct selectfirst :public unarg_function<Pair, typename Pair::first_type>
{
const typename Pair::first_type& operator()(const Pair& x) const
{
return x.first;
}
};
// pair
template <class Pair>
struct selectsecond :public unarg_function<Pair, typename Pair::second_type>
{
const typename Pair::second_type& operator()(const Pair& x) const
{
return x.second;
}
};
//
template <class Arg1, class Arg2>
struct projectfirst :public binary_function<Arg1, Arg2, Arg1>
{
Arg1 operator()(const Arg1& x, const Arg2&) const { return x; }
};
//
template <class Arg1, class Arg2>
struct projectsecond :public binary_function<Arg1, Arg2, Arg1>
{
Arg2 operator()(const Arg1&, const Arg2& y) const { return y; }
};
/*****************************************************************************************/
//
// hash function
template <class Key>
struct hash {};
//
template <class T>
struct hash<T*>
{
size_t operator()(T* p) const noexcept
{ return reinterpret_cast<size_t>(p); }
};
//
#define MYSTL_TRIVIAL_HASH_FCN(Type) \
template <> struct hash<Type> \
{ \
size_t operator()(Type val) const noexcept \
{ return static_cast<size_t>(val); } \
};
MYSTL_TRIVIAL_HASH_FCN(bool)
MYSTL_TRIVIAL_HASH_FCN(char)
MYSTL_TRIVIAL_HASH_FCN(signed char)
MYSTL_TRIVIAL_HASH_FCN(unsigned char)
MYSTL_TRIVIAL_HASH_FCN(wchar_t)
MYSTL_TRIVIAL_HASH_FCN(char16_t)
MYSTL_TRIVIAL_HASH_FCN(char32_t)
MYSTL_TRIVIAL_HASH_FCN(short)
MYSTL_TRIVIAL_HASH_FCN(unsigned short)
MYSTL_TRIVIAL_HASH_FCN(int)
MYSTL_TRIVIAL_HASH_FCN(unsigned int)
MYSTL_TRIVIAL_HASH_FCN(long)
MYSTL_TRIVIAL_HASH_FCN(unsigned long)
MYSTL_TRIVIAL_HASH_FCN(long long)
MYSTL_TRIVIAL_HASH_FCN(unsigned long long)
#undef MYSTL_TRIVIAL_HASH_FCN
//
inline size_t bitwise_hash(const unsigned char* first, size_t count)
{
#if (_MSC_VER && _WIN64) || ((__GNUC__ || __clang__) &&__SIZEOF_POINTER__ == 8)
const size_t fnv_offset = 14695981039346656037ull;
const size_t fnv_prime = 1099511628211ull;
#else
const size_t fnv_offset = 2166136261u;
const size_t fnv_prime = 16777619u;
#endif
size_t result = fnv_offset;
for (size_t i = 0; i < count; ++i)
{
result ^= (size_t)first[i];
result *= fnv_prime;
}
return result;
}
template <>
struct hash<float>
{
size_t operator()(const float& val)
{
return val == 0.0f ? 0 : bitwise_hash((const unsigned char*)&val, sizeof(float));
}
};
template <>
struct hash<double>
{
size_t operator()(const double& val)
{
return val == 0.0f ? 0 : bitwise_hash((const unsigned char*)&val, sizeof(double));
}
};
template <>
struct hash<long double>
{
size_t operator()(const long double& val)
{
return val == 0.0f ? 0 : bitwise_hash((const unsigned char*)&val, sizeof(long double));
}
};
} // namespace mystl
#endif // !MYTINYSTL_FUNCTIONAL_H_
``` | /content/code_sandbox/MyTinySTL/functional.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 1,667 |
```objective-c
#ifndef MYTINYSTL_QUEUE_H_
#define MYTINYSTL_QUEUE_H_
// queue priority_queue
// queue :
// priority_queue :
#include "deque.h"
#include "vector.h"
#include "functional.h"
#include "heap_algo.h"
namespace mystl
{
// queue
// mystl::deque
template <class T, class Container = mystl::deque<T>>
class queue
{
public:
typedef Container container_type;
//
typedef typename Container::value_type value_type;
typedef typename Container::size_type size_type;
typedef typename Container::reference reference;
typedef typename Container::const_reference const_reference;
static_assert(std::is_same<T, value_type>::value,
"the value_type of Container should be same with T");
private:
container_type c_; // queue
public:
//
queue() = default;
explicit queue(size_type n)
:c_(n)
{
}
queue(size_type n, const value_type& value)
:c_(n, value)
{
}
template <class IIter>
queue(IIter first, IIter last)
:c_(first, last)
{
}
queue(std::initializer_list<T> ilist)
:c_(ilist.begin(), ilist.end())
{
}
queue(const Container& c)
:c_(c)
{
}
queue(Container&& c) noexcept(std::is_nothrow_move_constructible<Container>::value)
:c_(mystl::move(c))
{
}
queue(const queue& rhs)
:c_(rhs.c_)
{
}
queue(queue&& rhs) noexcept(std::is_nothrow_move_constructible<Container>::value)
:c_(mystl::move(rhs.c_))
{
}
queue& operator=(const queue& rhs)
{
c_ = rhs.c_;
return *this;
}
queue& operator=(queue&& rhs) noexcept(std::is_nothrow_move_assignable<Container>::value)
{
c_ = mystl::move(rhs.c_);
return *this;
}
queue& operator=(std::initializer_list<T> ilist)
{
c_ = ilist;
return *this;
}
~queue() = default;
//
reference front() { return c_.front(); }
const_reference front() const { return c_.front(); }
reference back() { return c_.back(); }
const_reference back() const { return c_.back(); }
//
bool empty() const noexcept { return c_.empty(); }
size_type size() const noexcept { return c_.size(); }
//
template <class ...Args>
void emplace(Args&& ...args)
{ c_.emplace_back(mystl::forward<Args>(args)...); }
void push(const value_type& value)
{ c_.push_back(value); }
void push(value_type&& value)
{ c_.emplace_back(mystl::move(value)); }
void pop()
{ c_.pop_front(); }
void clear()
{
while (!empty())
pop();
}
void swap(queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_)))
{ mystl::swap(c_, rhs.c_); }
public:
friend bool operator==(const queue& lhs, const queue& rhs) { return lhs.c_ == rhs.c_; }
friend bool operator< (const queue& lhs, const queue& rhs) { return lhs.c_ < rhs.c_; }
};
//
template <class T, class Container>
bool operator==(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return lhs == rhs;
}
template <class T, class Container>
bool operator!=(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return !(lhs == rhs);
}
template <class T, class Container>
bool operator<(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return lhs < rhs;
}
template <class T, class Container>
bool operator>(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return rhs < lhs;
}
template <class T, class Container>
bool operator<=(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return !(rhs < lhs);
}
template <class T, class Container>
bool operator>=(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return !(lhs < rhs);
}
// mystl swap
template <class T, class Container>
void swap(queue<T, Container>& lhs, queue<T, Container>& rhs) noexcept(noexcept(lhs.swap(rhs)))
{
lhs.swap(rhs);
}
/*****************************************************************************************/
// priority_queue
// mystl::vector
// mystl::less
template <class T, class Container = mystl::vector<T>,
class Compare = mystl::less<typename Container::value_type>>
class priority_queue
{
public:
typedef Container container_type;
typedef Compare value_compare;
//
typedef typename Container::value_type value_type;
typedef typename Container::size_type size_type;
typedef typename Container::reference reference;
typedef typename Container::const_reference const_reference;
static_assert(std::is_same<T, value_type>::value,
"the value_type of Container should be same with T");
private:
container_type c_; // priority_queue
value_compare comp_; //
public:
//
priority_queue() = default;
priority_queue(const Compare& c)
:c_(), comp_(c)
{
}
explicit priority_queue(size_type n)
:c_(n)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(size_type n, const value_type& value)
:c_(n, value)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
template <class IIter>
priority_queue(IIter first, IIter last)
:c_(first, last)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(std::initializer_list<T> ilist)
:c_(ilist)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(const Container& s)
:c_(s)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(Container&& s)
:c_(mystl::move(s))
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(const priority_queue& rhs)
:c_(rhs.c_), comp_(rhs.comp_)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(priority_queue&& rhs)
:c_(mystl::move(rhs.c_)), comp_(rhs.comp_)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue& operator=(const priority_queue& rhs)
{
c_ = rhs.c_;
comp_ = rhs.comp_;
mystl::make_heap(c_.begin(), c_.end(), comp_);
return *this;
}
priority_queue& operator=(priority_queue&& rhs)
{
c_ = mystl::move(rhs.c_);
comp_ = rhs.comp_;
mystl::make_heap(c_.begin(), c_.end(), comp_);
return *this;
}
priority_queue& operator=(std::initializer_list<T> ilist)
{
c_ = ilist;
comp_ = value_compare();
mystl::make_heap(c_.begin(), c_.end(), comp_);
return *this;
}
~priority_queue() = default;
public:
//
const_reference top() const { return c_.front(); }
//
bool empty() const noexcept { return c_.empty(); }
size_type size() const noexcept { return c_.size(); }
//
template <class... Args>
void emplace(Args&& ...args)
{
c_.emplace_back(mystl::forward<Args>(args)...);
mystl::push_heap(c_.begin(), c_.end(), comp_);
}
void push(const value_type& value)
{
c_.push_back(value);
mystl::push_heap(c_.begin(), c_.end(), comp_);
}
void push(value_type&& value)
{
c_.push_back(mystl::move(value));
mystl::push_heap(c_.begin(), c_.end(), comp_);
}
void pop()
{
mystl::pop_heap(c_.begin(), c_.end(), comp_);
c_.pop_back();
}
void clear()
{
while (!empty())
pop();
}
void swap(priority_queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_)) &&
noexcept(mystl::swap(comp_, rhs.comp_)))
{
mystl::swap(c_, rhs.c_);
mystl::swap(comp_, rhs.comp_);
}
public:
friend bool operator==(const priority_queue& lhs, const priority_queue& rhs)
{
return lhs.c_ == rhs.c_;
}
friend bool operator!=(const priority_queue& lhs, const priority_queue& rhs)
{
return lhs.c_ != rhs.c_;
}
};
//
template <class T, class Container, class Compare>
bool operator==(priority_queue<T, Container, Compare>& lhs,
priority_queue<T, Container, Compare>& rhs)
{
return lhs == rhs;
}
template <class T, class Container, class Compare>
bool operator!=(priority_queue<T, Container, Compare>& lhs,
priority_queue<T, Container, Compare>& rhs)
{
return lhs != rhs;
}
// mystl swap
template <class T, class Container, class Compare>
void swap(priority_queue<T, Container, Compare>& lhs,
priority_queue<T, Container, Compare>& rhs) noexcept(noexcept(lhs.swap(rhs)))
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_QUEUE_H_
``` | /content/code_sandbox/MyTinySTL/queue.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 2,274 |
```objective-c
#ifndef MYTINYSTL_HASHTABLE_H_
#define MYTINYSTL_HASHTABLE_H_
// hashtable
// hashtable :
#include <initializer_list>
#include "algo.h"
#include "functional.h"
#include "memory.h"
#include "vector.h"
#include "util.h"
#include "exceptdef.h"
namespace mystl
{
// hashtable
template <class T>
struct hashtable_node
{
hashtable_node* next; //
T value; //
hashtable_node() = default;
hashtable_node(const T& n) :next(nullptr), value(n) {}
hashtable_node(const hashtable_node& node) :next(node.next), value(node.value) {}
hashtable_node(hashtable_node&& node) :next(node.next), value(mystl::move(node.value))
{
node.next = nullptr;
}
};
// value traits
template <class T, bool>
struct ht_value_traits_imp
{
typedef T key_type;
typedef T mapped_type;
typedef T value_type;
template <class Ty>
static const key_type& get_key(const Ty& value)
{
return value;
}
template <class Ty>
static const value_type& get_value(const Ty& value)
{
return value;
}
};
template <class T>
struct ht_value_traits_imp<T, true>
{
typedef typename std::remove_cv<typename T::first_type>::type key_type;
typedef typename T::second_type mapped_type;
typedef T value_type;
template <class Ty>
static const key_type& get_key(const Ty& value)
{
return value.first;
}
template <class Ty>
static const value_type& get_value(const Ty& value)
{
return value;
}
};
template <class T>
struct ht_value_traits
{
static constexpr bool is_map = mystl::is_pair<T>::value;
typedef ht_value_traits_imp<T, is_map> value_traits_type;
typedef typename value_traits_type::key_type key_type;
typedef typename value_traits_type::mapped_type mapped_type;
typedef typename value_traits_type::value_type value_type;
template <class Ty>
static const key_type& get_key(const Ty& value)
{
return value_traits_type::get_key(value);
}
template <class Ty>
static const value_type& get_value(const Ty& value)
{
return value_traits_type::get_value(value);
}
};
// forward declaration
template <class T, class HashFun, class KeyEqual>
class hashtable;
template <class T, class HashFun, class KeyEqual>
struct ht_iterator;
template <class T, class HashFun, class KeyEqual>
struct ht_const_iterator;
template <class T>
struct ht_local_iterator;
template <class T>
struct ht_const_local_iterator;
// ht_iterator
template <class T, class Hash, class KeyEqual>
struct ht_iterator_base :public mystl::iterator<mystl::forward_iterator_tag, T>
{
typedef mystl::hashtable<T, Hash, KeyEqual> hashtable;
typedef ht_iterator_base<T, Hash, KeyEqual> base;
typedef mystl::ht_iterator<T, Hash, KeyEqual> iterator;
typedef mystl::ht_const_iterator<T, Hash, KeyEqual> const_iterator;
typedef hashtable_node<T>* node_ptr;
typedef hashtable* contain_ptr;
typedef const node_ptr const_node_ptr;
typedef const contain_ptr const_contain_ptr;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
node_ptr node; //
contain_ptr ht; //
ht_iterator_base() = default;
bool operator==(const base& rhs) const { return node == rhs.node; }
bool operator!=(const base& rhs) const { return node != rhs.node; }
};
template <class T, class Hash, class KeyEqual>
struct ht_iterator :public ht_iterator_base<T, Hash, KeyEqual>
{
typedef ht_iterator_base<T, Hash, KeyEqual> base;
typedef typename base::hashtable hashtable;
typedef typename base::iterator iterator;
typedef typename base::const_iterator const_iterator;
typedef typename base::node_ptr node_ptr;
typedef typename base::contain_ptr contain_ptr;
typedef ht_value_traits<T> value_traits;
typedef T value_type;
typedef value_type* pointer;
typedef value_type& reference;
using base::node;
using base::ht;
ht_iterator() = default;
ht_iterator(node_ptr n, contain_ptr t)
{
node = n;
ht = t;
}
ht_iterator(const iterator& rhs)
{
node = rhs.node;
ht = rhs.ht;
}
ht_iterator(const const_iterator& rhs)
{
node = rhs.node;
ht = rhs.ht;
}
iterator& operator=(const iterator& rhs)
{
if (this != &rhs)
{
node = rhs.node;
ht = rhs.ht;
}
return *this;
}
iterator& operator=(const const_iterator& rhs)
{
if (this != &rhs)
{
node = rhs.node;
ht = rhs.ht;
}
return *this;
}
//
reference operator*() const { return node->value; }
pointer operator->() const { return &(operator*()); }
iterator& operator++()
{
MYSTL_DEBUG(node != nullptr);
const node_ptr old = node;
node = node->next;
if (node == nullptr)
{ // bucket
auto index = ht->hash(value_traits::get_key(old->value));
while (!node && ++index < ht->bucket_size_)
node = ht->buckets_[index];
}
return *this;
}
iterator operator++(int)
{
iterator tmp = *this;
++*this;
return tmp;
}
};
template <class T, class Hash, class KeyEqual>
struct ht_const_iterator :public ht_iterator_base<T, Hash, KeyEqual>
{
typedef ht_iterator_base<T, Hash, KeyEqual> base;
typedef typename base::hashtable hashtable;
typedef typename base::iterator iterator;
typedef typename base::const_iterator const_iterator;
typedef typename base::const_node_ptr node_ptr;
typedef typename base::const_contain_ptr contain_ptr;
typedef ht_value_traits<T> value_traits;
typedef T value_type;
typedef const value_type* pointer;
typedef const value_type& reference;
using base::node;
using base::ht;
ht_const_iterator() = default;
ht_const_iterator(node_ptr n, contain_ptr t)
{
node = n;
ht = t;
}
ht_const_iterator(const iterator& rhs)
{
node = rhs.node;
ht = rhs.ht;
}
ht_const_iterator(const const_iterator& rhs)
{
node = rhs.node;
ht = rhs.ht;
}
const_iterator& operator=(const iterator& rhs)
{
if (this != &rhs)
{
node = rhs.node;
ht = rhs.ht;
}
return *this;
}
const_iterator& operator=(const const_iterator& rhs)
{
if (this != &rhs)
{
node = rhs.node;
ht = rhs.ht;
}
return *this;
}
//
reference operator*() const { return node->value; }
pointer operator->() const { return &(operator*()); }
const_iterator& operator++()
{
MYSTL_DEBUG(node != nullptr);
const node_ptr old = node;
node = node->next;
if (node == nullptr)
{ // bucket
auto index = ht->hash(value_traits::get_key(old->value));
while (!node && ++index < ht->bucket_size_)
{
node = ht->buckets_[index];
}
}
return *this;
}
const_iterator operator++(int)
{
const_iterator tmp = *this;
++*this;
return tmp;
}
};
// local iterator
template <class T>
struct ht_local_iterator :public mystl::iterator<mystl::forward_iterator_tag, T>
{
typedef T value_type;
typedef value_type* pointer;
typedef value_type& reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef hashtable_node<T>* node_ptr;
typedef ht_local_iterator<T> self;
typedef ht_local_iterator<T> local_iterator;
typedef ht_const_local_iterator<T> const_local_iterator;
node_ptr node;
ht_local_iterator(node_ptr n)
:node(n)
{
}
ht_local_iterator(const local_iterator& rhs)
:node(rhs.node)
{
}
ht_local_iterator(const const_local_iterator& rhs)
:node(rhs.node)
{
}
reference operator*() const { return node->value; }
pointer operator->() const { return &(operator*()); }
self& operator++()
{
MYSTL_DEBUG(node != nullptr);
node = node->next;
return *this;
}
self operator++(int)
{
self tmp(*this);
++*this;
return tmp;
}
bool operator==(const self& other) const { return node == other.node; }
bool operator!=(const self& other) const { return node != other.node; }
};
template <class T>
struct ht_const_local_iterator :public mystl::iterator<mystl::forward_iterator_tag, T>
{
typedef T value_type;
typedef const value_type* pointer;
typedef const value_type& reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef const hashtable_node<T>* node_ptr;
typedef ht_const_local_iterator<T> self;
typedef ht_local_iterator<T> local_iterator;
typedef ht_const_local_iterator<T> const_local_iterator;
node_ptr node;
ht_const_local_iterator(node_ptr n)
:node(n)
{
}
ht_const_local_iterator(const local_iterator& rhs)
:node(rhs.node)
{
}
ht_const_local_iterator(const const_local_iterator& rhs)
:node(rhs.node)
{
}
reference operator*() const { return node->value; }
pointer operator->() const { return &(operator*()); }
self& operator++()
{
MYSTL_DEBUG(node != nullptr);
node = node->next;
return *this;
}
self operator++(int)
{
self tmp(*this);
++*this;
return tmp;
}
bool operator==(const self& other) const { return node == other.node; }
bool operator!=(const self& other) const { return node != other.node; }
};
// bucket
#if (_MSC_VER && _WIN64) || ((__GNUC__ || __clang__) &&__SIZEOF_POINTER__ == 8)
#define SYSTEM_64 1
#else
#define SYSTEM_32 1
#endif
#ifdef SYSTEM_64
#define PRIME_NUM 99
// 1. start with p = 101
// 2. p = next_prime(p * 1.7)
// 3. if p < (2 << 63), go to step 2, otherwise, go to step 4
// 4. end with p = prev_prime(2 << 63 - 1)
static constexpr size_t ht_prime_list[] = {
101ull, 173ull, 263ull, 397ull, 599ull, 907ull, 1361ull, 2053ull, 3083ull,
4637ull, 6959ull, 10453ull, 15683ull, 23531ull, 35311ull, 52967ull, 79451ull,
119179ull, 178781ull, 268189ull, 402299ull, 603457ull, 905189ull, 1357787ull,
2036687ull, 3055043ull, 4582577ull, 6873871ull, 10310819ull, 15466229ull,
23199347ull, 34799021ull, 52198537ull, 78297827ull, 117446801ull, 176170229ull,
264255353ull, 396383041ull, 594574583ull, 891861923ull, 1337792887ull,
2006689337ull, 3010034021ull, 4515051137ull, 6772576709ull, 10158865069ull,
15238297621ull, 22857446471ull, 34286169707ull, 51429254599ull, 77143881917ull,
115715822899ull, 173573734363ull, 260360601547ull, 390540902329ull,
585811353559ull, 878717030339ull, 1318075545511ull, 1977113318311ull,
2965669977497ull, 4448504966249ull, 6672757449409ull, 10009136174239ull,
15013704261371ull, 22520556392057ull, 33780834588157ull, 50671251882247ull,
76006877823377ull, 114010316735089ull, 171015475102649ull, 256523212653977ull,
384784818980971ull, 577177228471507ull, 865765842707309ull, 1298648764060979ull,
1947973146091477ull, 2921959719137273ull, 4382939578705967ull, 6574409368058969ull,
9861614052088471ull, 14792421078132871ull, 22188631617199337ull, 33282947425799017ull,
49924421138698549ull, 74886631708047827ull, 112329947562071807ull, 168494921343107851ull,
252742382014661767ull, 379113573021992729ull, 568670359532989111ull, 853005539299483657ull,
1279508308949225477ull, 1919262463423838231ull, 2878893695135757317ull, 4318340542703636011ull,
6477510814055453699ull, 9716266221083181299ull, 14574399331624771603ull, 18446744073709551557ull
};
#else
#define PRIME_NUM 44
// 1. start with p = 101
// 2. p = next_prime(p * 1.7)
// 3. if p < (2 << 31), go to step 2, otherwise, go to step 4
// 4. end with p = prev_prime(2 << 31 - 1)
static constexpr size_t ht_prime_list[] = {
101u, 173u, 263u, 397u, 599u, 907u, 1361u, 2053u, 3083u, 4637u, 6959u,
10453u, 15683u, 23531u, 35311u, 52967u, 79451u, 119179u, 178781u, 268189u,
402299u, 603457u, 905189u, 1357787u, 2036687u, 3055043u, 4582577u, 6873871u,
10310819u, 15466229u, 23199347u, 34799021u, 52198537u, 78297827u, 117446801u,
176170229u, 264255353u, 396383041u, 594574583u, 891861923u, 1337792887u,
2006689337u, 3010034021u, 4294967291u,
};
#endif
// n
inline size_t ht_next_prime(size_t n)
{
const size_t* first = ht_prime_list;
const size_t* last = ht_prime_list + PRIME_NUM;
const size_t* pos = mystl::lower_bound(first, last, n);
return pos == last ? *(last - 1) : *pos;
}
// hashtable
//
template <class T, class Hash, class KeyEqual>
class hashtable
{
friend struct mystl::ht_iterator<T, Hash, KeyEqual>;
friend struct mystl::ht_const_iterator<T, Hash, KeyEqual>;
public:
// hashtable
typedef ht_value_traits<T> value_traits;
typedef typename value_traits::key_type key_type;
typedef typename value_traits::mapped_type mapped_type;
typedef typename value_traits::value_type value_type;
typedef Hash hasher;
typedef KeyEqual key_equal;
typedef hashtable_node<T> node_type;
typedef node_type* node_ptr;
typedef mystl::vector<node_ptr> bucket_type;
typedef mystl::allocator<T> allocator_type;
typedef mystl::allocator<T> data_allocator;
typedef mystl::allocator<node_type> node_allocator;
typedef typename allocator_type::pointer pointer;
typedef typename allocator_type::const_pointer const_pointer;
typedef typename allocator_type::reference reference;
typedef typename allocator_type::const_reference const_reference;
typedef typename allocator_type::size_type size_type;
typedef typename allocator_type::difference_type difference_type;
typedef mystl::ht_iterator<T, Hash, KeyEqual> iterator;
typedef mystl::ht_const_iterator<T, Hash, KeyEqual> const_iterator;
typedef mystl::ht_local_iterator<T> local_iterator;
typedef mystl::ht_const_local_iterator<T> const_local_iterator;
allocator_type get_allocator() const { return allocator_type(); }
private:
// hashtable
bucket_type buckets_;
size_type bucket_size_;
size_type size_;
float mlf_;
hasher hash_;
key_equal equal_;
private:
bool is_equal(const key_type& key1, const key_type& key2)
{
return equal_(key1, key2);
}
bool is_equal(const key_type& key1, const key_type& key2) const
{
return equal_(key1, key2);
}
const_iterator M_cit(node_ptr node) const noexcept
{
return const_iterator(node, const_cast<hashtable*>(this));
}
iterator M_begin() noexcept
{
for (size_type n = 0; n < bucket_size_; ++n)
{
if (buckets_[n]) //
return iterator(buckets_[n], this);
}
return iterator(nullptr, this);
}
const_iterator M_begin() const noexcept
{
for (size_type n = 0; n < bucket_size_; ++n)
{
if (buckets_[n]) //
return M_cit(buckets_[n]);
}
return M_cit(nullptr);
}
public:
//
explicit hashtable(size_type bucket_count,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:size_(0), mlf_(1.0f), hash_(hash), equal_(equal)
{
init(bucket_count);
}
template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::value, int>::type = 0>
hashtable(Iter first, Iter last,
size_type bucket_count,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:size_(mystl::distance(first, last)), mlf_(1.0f), hash_(hash), equal_(equal)
{
init(mystl::max(bucket_count, static_cast<size_type>(mystl::distance(first, last))));
}
hashtable(const hashtable& rhs)
:hash_(rhs.hash_), equal_(rhs.equal_)
{
copy_init(rhs);
}
hashtable(hashtable&& rhs) noexcept
: bucket_size_(rhs.bucket_size_),
size_(rhs.size_),
mlf_(rhs.mlf_),
hash_(rhs.hash_),
equal_(rhs.equal_)
{
buckets_ = mystl::move(rhs.buckets_);
rhs.bucket_size_ = 0;
rhs.size_ = 0;
rhs.mlf_ = 0.0f;
}
hashtable& operator=(const hashtable& rhs);
hashtable& operator=(hashtable&& rhs) noexcept;
~hashtable() { clear(); }
//
iterator begin() noexcept
{ return M_begin(); }
const_iterator begin() const noexcept
{ return M_begin(); }
iterator end() noexcept
{ return iterator(nullptr, this); }
const_iterator end() const noexcept
{ return M_cit(nullptr); }
const_iterator cbegin() const noexcept
{ return begin(); }
const_iterator cend() const noexcept
{ return end(); }
//
bool empty() const noexcept { return size_ == 0; }
size_type size() const noexcept { return size_; }
size_type max_size() const noexcept { return static_cast<size_type>(-1); }
//
// emplace / empalce_hint
template <class ...Args>
iterator emplace_multi(Args&& ...args);
template <class ...Args>
pair<iterator, bool> emplace_unique(Args&& ...args);
// [note]: hint hash_table hint hash
// hash_table
template <class ...Args>
iterator emplace_multi_use_hint(const_iterator /*hint*/, Args&& ...args)
{ return emplace_multi(mystl::forward<Args>(args)...); }
template <class ...Args>
iterator emplace_unique_use_hint(const_iterator /*hint*/, Args&& ...args)
{ return emplace_unique(mystl::forward<Args>(args)...).first; }
// insert
iterator insert_multi_noresize(const value_type& value);
pair<iterator, bool> insert_unique_noresize(const value_type& value);
iterator insert_multi(const value_type& value)
{
rehash_if_need(1);
return insert_multi_noresize(value);
}
iterator insert_multi(value_type&& value)
{ return emplace_multi(mystl::move(value)); }
pair<iterator, bool> insert_unique(const value_type& value)
{
rehash_if_need(1);
return insert_unique_noresize(value);
}
pair<iterator, bool> insert_unique(value_type&& value)
{ return emplace_unique(mystl::move(value)); }
// [note]: emplace_hint
iterator insert_multi_use_hint(const_iterator /*hint*/, const value_type& value)
{ return insert_multi(value); }
iterator insert_multi_use_hint(const_iterator /*hint*/, value_type&& value)
{ return emplace_multi(mystl::move(value)); }
iterator insert_unique_use_hint(const_iterator /*hint*/, const value_type& value)
{ return insert_unique(value).first; }
iterator insert_unique_use_hint(const_iterator /*hint*/, value_type&& value)
{ return emplace_unique(mystl::move(value)); }
template <class InputIter>
void insert_multi(InputIter first, InputIter last)
{ copy_insert_multi(first, last, iterator_category(first)); }
template <class InputIter>
void insert_unique(InputIter first, InputIter last)
{ copy_insert_unique(first, last, iterator_category(first)); }
// erase / clear
void erase(const_iterator position);
void erase(const_iterator first, const_iterator last);
size_type erase_multi(const key_type& key);
size_type erase_unique(const key_type& key);
void clear();
void swap(hashtable& rhs) noexcept;
//
size_type count(const key_type& key) const;
iterator find(const key_type& key);
const_iterator find(const key_type& key) const;
pair<iterator, iterator> equal_range_multi(const key_type& key);
pair<const_iterator, const_iterator> equal_range_multi(const key_type& key) const;
pair<iterator, iterator> equal_range_unique(const key_type& key);
pair<const_iterator, const_iterator> equal_range_unique(const key_type& key) const;
// bucket interface
local_iterator begin(size_type n) noexcept
{
MYSTL_DEBUG(n < size_);
return buckets_[n];
}
const_local_iterator begin(size_type n) const noexcept
{
MYSTL_DEBUG(n < size_);
return buckets_[n];
}
const_local_iterator cbegin(size_type n) const noexcept
{
MYSTL_DEBUG(n < size_);
return buckets_[n];
}
local_iterator end(size_type n) noexcept
{
MYSTL_DEBUG(n < size_);
return nullptr;
}
const_local_iterator end(size_type n) const noexcept
{
MYSTL_DEBUG(n < size_);
return nullptr;
}
const_local_iterator cend(size_type n) const noexcept
{
MYSTL_DEBUG(n < size_);
return nullptr;
}
size_type bucket_count() const noexcept
{ return bucket_size_; }
size_type max_bucket_count() const noexcept
{ return ht_prime_list[PRIME_NUM - 1]; }
size_type bucket_size(size_type n) const noexcept;
size_type bucket(const key_type& key) const
{ return hash(key); }
// hash policy
float load_factor() const noexcept
{ return bucket_size_ != 0 ? (float)size_ / bucket_size_ : 0.0f; }
float max_load_factor() const noexcept
{ return mlf_; }
void max_load_factor(float ml)
{
THROW_OUT_OF_RANGE_IF(ml != ml || ml < 0, "invalid hash load factor");
mlf_ = ml;
}
void rehash(size_type count);
void reserve(size_type count)
{ rehash(static_cast<size_type>((float)count / max_load_factor() + 0.5f)); }
hasher hash_fcn() const { return hash_; }
key_equal key_eq() const { return equal_; }
private:
// hashtable
// init
void init(size_type n);
void copy_init(const hashtable& ht);
// node
template <class ...Args>
node_ptr create_node(Args&& ...args);
void destroy_node(node_ptr n);
// hash
size_type next_size(size_type n) const;
size_type hash(const key_type& key, size_type n) const;
size_type hash(const key_type& key) const;
void rehash_if_need(size_type n);
// insert
template <class InputIter>
void copy_insert_multi(InputIter first, InputIter last, mystl::input_iterator_tag);
template <class ForwardIter>
void copy_insert_multi(ForwardIter first, ForwardIter last, mystl::forward_iterator_tag);
template <class InputIter>
void copy_insert_unique(InputIter first, InputIter last, mystl::input_iterator_tag);
template <class ForwardIter>
void copy_insert_unique(ForwardIter first, ForwardIter last, mystl::forward_iterator_tag);
// insert node
pair<iterator, bool> insert_node_unique(node_ptr np);
iterator insert_node_multi(node_ptr np);
// bucket operator
void replace_bucket(size_type bucket_count);
void erase_bucket(size_type n, node_ptr first, node_ptr last);
void erase_bucket(size_type n, node_ptr last);
// comparision
bool equal_to_multi(const hashtable& other);
bool equal_to_unique(const hashtable& other);
};
/*****************************************************************************************/
//
template <class T, class Hash, class KeyEqual>
hashtable<T, Hash, KeyEqual>&
hashtable<T, Hash, KeyEqual>::
operator=(const hashtable& rhs)
{
if (this != &rhs)
{
hashtable tmp(rhs);
swap(tmp);
}
return *this;
}
//
template <class T, class Hash, class KeyEqual>
hashtable<T, Hash, KeyEqual>&
hashtable<T, Hash, KeyEqual>::
operator=(hashtable&& rhs) noexcept
{
hashtable tmp(mystl::move(rhs));
swap(tmp);
return *this;
}
//
//
template <class T, class Hash, class KeyEqual>
template <class ...Args>
typename hashtable<T, Hash, KeyEqual>::iterator
hashtable<T, Hash, KeyEqual>::
emplace_multi(Args&& ...args)
{
auto np = create_node(mystl::forward<Args>(args)...);
try
{
if ((float)(size_ + 1) > (float)bucket_size_ * max_load_factor())
rehash(size_ + 1);
}
catch (...)
{
destroy_node(np);
throw;
}
return insert_node_multi(np);
}
//
//
template <class T, class Hash, class KeyEqual>
template <class ...Args>
pair<typename hashtable<T, Hash, KeyEqual>::iterator, bool>
hashtable<T, Hash, KeyEqual>::
emplace_unique(Args&& ...args)
{
auto np = create_node(mystl::forward<Args>(args)...);
try
{
if ((float)(size_ + 1) > (float)bucket_size_ * max_load_factor())
rehash(size_ + 1);
}
catch (...)
{
destroy_node(np);
throw;
}
return insert_node_unique(np);
}
//
template <class T, class Hash, class KeyEqual>
pair<typename hashtable<T, Hash, KeyEqual>::iterator, bool>
hashtable<T, Hash, KeyEqual>::
insert_unique_noresize(const value_type& value)
{
const auto n = hash(value_traits::get_key(value));
auto first = buckets_[n];
for (auto cur = first; cur; cur = cur->next)
{
if (is_equal(value_traits::get_key(cur->value), value_traits::get_key(value)))
return mystl::make_pair(iterator(cur, this), false);
}
//
auto tmp = create_node(value);
tmp->next = first;
buckets_[n] = tmp;
++size_;
return mystl::make_pair(iterator(tmp, this), true);
}
//
template <class T, class Hash, class KeyEqual>
typename hashtable<T, Hash, KeyEqual>::iterator
hashtable<T, Hash, KeyEqual>::
insert_multi_noresize(const value_type& value)
{
const auto n = hash(value_traits::get_key(value));
auto first = buckets_[n];
auto tmp = create_node(value);
for (auto cur = first; cur; cur = cur->next)
{
if (is_equal(value_traits::get_key(cur->value), value_traits::get_key(value)))
{ //
tmp->next = cur->next;
cur->next = tmp;
++size_;
return iterator(tmp, this);
}
}
//
tmp->next = first;
buckets_[n] = tmp;
++size_;
return iterator(tmp, this);
}
//
template <class T, class Hash, class KeyEqual>
void hashtable<T, Hash, KeyEqual>::
erase(const_iterator position)
{
auto p = position.node;
if (p)
{
const auto n = hash(value_traits::get_key(p->value));
auto cur = buckets_[n];
if (cur == p)
{ // p
buckets_[n] = cur->next;
destroy_node(cur);
--size_;
}
else
{
auto next = cur->next;
while (next)
{
if (next == p)
{
cur->next = next->next;
destroy_node(next);
--size_;
break;
}
else
{
cur = next;
next = cur->next;
}
}
}
}
}
// [first, last)
template <class T, class Hash, class KeyEqual>
void hashtable<T, Hash, KeyEqual>::
erase(const_iterator first, const_iterator last)
{
if (first.node == last.node)
return;
auto first_bucket = first.node
? hash(value_traits::get_key(first.node->value))
: bucket_size_;
auto last_bucket = last.node
? hash(value_traits::get_key(last.node->value))
: bucket_size_;
if (first_bucket == last_bucket)
{ // bucket
erase_bucket(first_bucket, first.node, last.node);
}
else
{
erase_bucket(first_bucket, first.node, nullptr);
for (auto n = first_bucket + 1; n < last_bucket; ++n)
{
if(buckets_[n] != nullptr)
erase_bucket(n, nullptr);
}
if (last_bucket != bucket_size_)
{
erase_bucket(last_bucket, last.node);
}
}
}
// key
template <class T, class Hash, class KeyEqual>
typename hashtable<T, Hash, KeyEqual>::size_type
hashtable<T, Hash, KeyEqual>::
erase_multi(const key_type& key)
{
auto p = equal_range_multi(key);
if (p.first.node != nullptr)
{
erase(p.first, p.second);
return mystl::distance(p.first, p.second);
}
return 0;
}
template <class T, class Hash, class KeyEqual>
typename hashtable<T, Hash, KeyEqual>::size_type
hashtable<T, Hash, KeyEqual>::
erase_unique(const key_type& key)
{
const auto n = hash(key);
auto first = buckets_[n];
if (first)
{
if (is_equal(value_traits::get_key(first->value), key))
{
buckets_[n] = first->next;
destroy_node(first);
--size_;
return 1;
}
else
{
auto next = first->next;
while (next)
{
if (is_equal(value_traits::get_key(next->value), key))
{
first->next = next->next;
destroy_node(next);
--size_;
return 1;
}
first = next;
next = first->next;
}
}
}
return 0;
}
// hashtable
template <class T, class Hash, class KeyEqual>
void hashtable<T, Hash, KeyEqual>::
clear()
{
if (size_ != 0)
{
for (size_type i = 0; i < bucket_size_; ++i)
{
node_ptr cur = buckets_[i];
while (cur != nullptr)
{
node_ptr next = cur->next;
destroy_node(cur);
cur = next;
}
buckets_[i] = nullptr;
}
size_ = 0;
}
}
// bucket
template <class T, class Hash, class KeyEqual>
typename hashtable<T, Hash, KeyEqual>::size_type
hashtable<T, Hash, KeyEqual>::
bucket_size(size_type n) const noexcept
{
size_type result = 0;
for (auto cur = buckets_[n]; cur; cur = cur->next)
{
++result;
}
return result;
}
//
template <class T, class Hash, class KeyEqual>
void hashtable<T, Hash, KeyEqual>::
rehash(size_type count)
{
auto n = ht_next_prime(count);
if (n > bucket_size_)
{
replace_bucket(n);
}
else
{
if ((float)size_ / (float)n < max_load_factor() - 0.25f &&
(float)n < (float)bucket_size_ * 0.75) // worth rehash
{
replace_bucket(n);
}
}
}
// key
template <class T, class Hash, class KeyEqual>
typename hashtable<T, Hash, KeyEqual>::iterator
hashtable<T, Hash, KeyEqual>::
find(const key_type& key)
{
const auto n = hash(key);
node_ptr first = buckets_[n];
for (; first && !is_equal(value_traits::get_key(first->value), key); first = first->next) {}
return iterator(first, this);
}
template <class T, class Hash, class KeyEqual>
typename hashtable<T, Hash, KeyEqual>::const_iterator
hashtable<T, Hash, KeyEqual>::
find(const key_type& key) const
{
const auto n = hash(key);
node_ptr first = buckets_[n];
for (; first && !is_equal(value_traits::get_key(first->value), key); first = first->next) {}
return M_cit(first);
}
// key
template <class T, class Hash, class KeyEqual>
typename hashtable<T, Hash, KeyEqual>::size_type
hashtable<T, Hash, KeyEqual>::
count(const key_type& key) const
{
const auto n = hash(key);
size_type result = 0;
for (node_ptr cur = buckets_[n]; cur; cur = cur->next)
{
if (is_equal(value_traits::get_key(cur->value), key))
++result;
}
return result;
}
// key pair
template <class T, class Hash, class KeyEqual>
pair<typename hashtable<T, Hash, KeyEqual>::iterator,
typename hashtable<T, Hash, KeyEqual>::iterator>
hashtable<T, Hash, KeyEqual>::
equal_range_multi(const key_type& key)
{
const auto n = hash(key);
for (node_ptr first = buckets_[n]; first; first = first->next)
{
if (is_equal(value_traits::get_key(first->value), key))
{ //
for (node_ptr second = first->next; second; second = second->next)
{
if (!is_equal(value_traits::get_key(second->value), key))
return mystl::make_pair(iterator(first, this), iterator(second, this));
}
for (auto m = n + 1; m < bucket_size_; ++m)
{ //
if (buckets_[m])
return mystl::make_pair(iterator(first, this), iterator(buckets_[m], this));
}
return mystl::make_pair(iterator(first, this), end());
}
}
return mystl::make_pair(end(), end());
}
template <class T, class Hash, class KeyEqual>
pair<typename hashtable<T, Hash, KeyEqual>::const_iterator,
typename hashtable<T, Hash, KeyEqual>::const_iterator>
hashtable<T, Hash, KeyEqual>::
equal_range_multi(const key_type& key) const
{
const auto n = hash(key);
for (node_ptr first = buckets_[n]; first; first = first->next)
{
if (is_equal(value_traits::get_key(first->value), key))
{
for (node_ptr second = first->next; second; second = second->next)
{
if (!is_equal(value_traits::get_key(second->value), key))
return mystl::make_pair(M_cit(first), M_cit(second));
}
for (auto m = n + 1; m < bucket_size_; ++m)
{ //
if (buckets_[m])
return mystl::make_pair(M_cit(first), M_cit(buckets_[m]));
}
return mystl::make_pair(M_cit(first), cend());
}
}
return mystl::make_pair(cend(), cend());
}
template <class T, class Hash, class KeyEqual>
pair<typename hashtable<T, Hash, KeyEqual>::iterator,
typename hashtable<T, Hash, KeyEqual>::iterator>
hashtable<T, Hash, KeyEqual>::
equal_range_unique(const key_type& key)
{
const auto n = hash(key);
for (node_ptr first = buckets_[n]; first; first = first->next)
{
if (is_equal(value_traits::get_key(first->value), key))
{
if (first->next)
return mystl::make_pair(iterator(first, this), iterator(first->next, this));
for (auto m = n + 1; m < bucket_size_; ++m)
{ //
if (buckets_[m])
return mystl::make_pair(iterator(first, this), iterator(buckets_[m], this));
}
return mystl::make_pair(iterator(first, this), end());
}
}
return mystl::make_pair(end(), end());
}
template <class T, class Hash, class KeyEqual>
pair<typename hashtable<T, Hash, KeyEqual>::const_iterator,
typename hashtable<T, Hash, KeyEqual>::const_iterator>
hashtable<T, Hash, KeyEqual>::
equal_range_unique(const key_type& key) const
{
const auto n = hash(key);
for (node_ptr first = buckets_[n]; first; first = first->next)
{
if (is_equal(value_traits::get_key(first->value), key))
{
if (first->next)
return mystl::make_pair(M_cit(first), M_cit(first->next));
for (auto m = n + 1; m < bucket_size_; ++m)
{ //
if (buckets_[m])
return mystl::make_pair(M_cit(first), M_cit(buckets_[m]));
}
return mystl::make_pair(M_cit(first), cend());
}
}
return mystl::make_pair(cend(), cend());
}
// hashtable
template <class T, class Hash, class KeyEqual>
void hashtable<T, Hash, KeyEqual>::
swap(hashtable& rhs) noexcept
{
if (this != &rhs)
{
buckets_.swap(rhs.buckets_);
mystl::swap(bucket_size_, rhs.bucket_size_);
mystl::swap(size_, rhs.size_);
mystl::swap(mlf_, rhs.mlf_);
mystl::swap(hash_, rhs.hash_);
mystl::swap(equal_, rhs.equal_);
}
}
/****************************************************************************************/
// helper function
// init
template <class T, class Hash, class KeyEqual>
void hashtable<T, Hash, KeyEqual>::
init(size_type n)
{
const auto bucket_nums = next_size(n);
try
{
buckets_.reserve(bucket_nums);
buckets_.assign(bucket_nums, nullptr);
}
catch (...)
{
bucket_size_ = 0;
size_ = 0;
throw;
}
bucket_size_ = buckets_.size();
}
// copy_init
template <class T, class Hash, class KeyEqual>
void hashtable<T, Hash, KeyEqual>::
copy_init(const hashtable& ht)
{
bucket_size_ = 0;
buckets_.reserve(ht.bucket_size_);
buckets_.assign(ht.bucket_size_, nullptr);
try
{
for (size_type i = 0; i < ht.bucket_size_; ++i)
{
node_ptr cur = ht.buckets_[i];
if (cur)
{ // bucket
auto copy = create_node(cur->value);
buckets_[i] = copy;
for (auto next = cur->next; next; cur = next, next = cur->next)
{ //
copy->next = create_node(next->value);
copy = copy->next;
}
copy->next = nullptr;
}
}
bucket_size_ = ht.bucket_size_;
mlf_ = ht.mlf_;
size_ = ht.size_;
}
catch (...)
{
clear();
}
}
// create_node
template <class T, class Hash, class KeyEqual>
template <class ...Args>
typename hashtable<T, Hash, KeyEqual>::node_ptr
hashtable<T, Hash, KeyEqual>::
create_node(Args&& ...args)
{
node_ptr tmp = node_allocator::allocate(1);
try
{
data_allocator::construct(mystl::address_of(tmp->value), mystl::forward<Args>(args)...);
tmp->next = nullptr;
}
catch (...)
{
node_allocator::deallocate(tmp);
throw;
}
return tmp;
}
// destroy_node
template <class T, class Hash, class KeyEqual>
void hashtable<T, Hash, KeyEqual>::
destroy_node(node_ptr node)
{
data_allocator::destroy(mystl::address_of(node->value));
node_allocator::deallocate(node);
node = nullptr;
}
// next_size
template <class T, class Hash, class KeyEqual>
typename hashtable<T, Hash, KeyEqual>::size_type
hashtable<T, Hash, KeyEqual>::next_size(size_type n) const
{
return ht_next_prime(n);
}
// hash
template <class T, class Hash, class KeyEqual>
typename hashtable<T, Hash, KeyEqual>::size_type
hashtable<T, Hash, KeyEqual>::
hash(const key_type& key, size_type n) const
{
return hash_(key) % n;
}
template <class T, class Hash, class KeyEqual>
typename hashtable<T, Hash, KeyEqual>::size_type
hashtable<T, Hash, KeyEqual>::
hash(const key_type& key) const
{
return hash_(key) % bucket_size_;
}
// rehash_if_need
template <class T, class Hash, class KeyEqual>
void hashtable<T, Hash, KeyEqual>::
rehash_if_need(size_type n)
{
if (static_cast<float>(size_ + n) > (float)bucket_size_ * max_load_factor())
rehash(size_ + n);
}
// copy_insert
template <class T, class Hash, class KeyEqual>
template <class InputIter>
void hashtable<T, Hash, KeyEqual>::
copy_insert_multi(InputIter first, InputIter last, mystl::input_iterator_tag)
{
rehash_if_need(mystl::distance(first, last));
for (; first != last; ++first)
insert_multi_noresize(*first);
}
template <class T, class Hash, class KeyEqual>
template <class ForwardIter>
void hashtable<T, Hash, KeyEqual>::
copy_insert_multi(ForwardIter first, ForwardIter last, mystl::forward_iterator_tag)
{
size_type n = mystl::distance(first, last);
rehash_if_need(n);
for (; n > 0; --n, ++first)
insert_multi_noresize(*first);
}
template <class T, class Hash, class KeyEqual>
template <class InputIter>
void hashtable<T, Hash, KeyEqual>::
copy_insert_unique(InputIter first, InputIter last, mystl::input_iterator_tag)
{
rehash_if_need(mystl::distance(first, last));
for (; first != last; ++first)
insert_unique_noresize(*first);
}
template <class T, class Hash, class KeyEqual>
template <class ForwardIter>
void hashtable<T, Hash, KeyEqual>::
copy_insert_unique(ForwardIter first, ForwardIter last, mystl::forward_iterator_tag)
{
size_type n = mystl::distance(first, last);
rehash_if_need(n);
for (; n > 0; --n, ++first)
insert_unique_noresize(*first);
}
// insert_node
template <class T, class Hash, class KeyEqual>
typename hashtable<T, Hash, KeyEqual>::iterator
hashtable<T, Hash, KeyEqual>::
insert_node_multi(node_ptr np)
{
const auto n = hash(value_traits::get_key(np->value));
auto cur = buckets_[n];
if (cur == nullptr)
{
buckets_[n] = np;
++size_;
return iterator(np, this);
}
for (; cur; cur = cur->next)
{
if (is_equal(value_traits::get_key(cur->value), value_traits::get_key(np->value)))
{
np->next = cur->next;
cur->next = np;
++size_;
return iterator(np, this);
}
}
np->next = buckets_[n];
buckets_[n] = np;
++size_;
return iterator(np, this);
}
// insert_node_unique
template <class T, class Hash, class KeyEqual>
pair<typename hashtable<T, Hash, KeyEqual>::iterator, bool>
hashtable<T, Hash, KeyEqual>::
insert_node_unique(node_ptr np)
{
const auto n = hash(value_traits::get_key(np->value));
auto cur = buckets_[n];
if (cur == nullptr)
{
buckets_[n] = np;
++size_;
return mystl::make_pair(iterator(np, this), true);
}
for (; cur; cur = cur->next)
{
if (is_equal(value_traits::get_key(cur->value), value_traits::get_key(np->value)))
{
return mystl::make_pair(iterator(cur, this), false);
}
}
np->next = buckets_[n];
buckets_[n] = np;
++size_;
return mystl::make_pair(iterator(np, this), true);
}
// replace_bucket
template <class T, class Hash, class KeyEqual>
void hashtable<T, Hash, KeyEqual>::
replace_bucket(size_type bucket_count)
{
bucket_type bucket(bucket_count);
if (size_ != 0)
{
for (size_type i = 0; i < bucket_size_; ++i)
{
for (auto first = buckets_[i]; first; first = first->next)
{
auto tmp = create_node(first->value);
const auto n = hash(value_traits::get_key(first->value), bucket_count);
auto f = bucket[n];
bool is_inserted = false;
for (auto cur = f; cur; cur = cur->next)
{
if (is_equal(value_traits::get_key(cur->value), value_traits::get_key(first->value)))
{
tmp->next = cur->next;
cur->next = tmp;
is_inserted = true;
break;
}
}
if (!is_inserted)
{
tmp->next = f;
bucket[n] = tmp;
}
}
}
}
buckets_.swap(bucket);
bucket_size_ = buckets_.size();
}
// erase_bucket
// n bucket [first, last)
template <class T, class Hash, class KeyEqual>
void hashtable<T, Hash, KeyEqual>::
erase_bucket(size_type n, node_ptr first, node_ptr last)
{
auto cur = buckets_[n];
if (cur == first)
{
erase_bucket(n, last);
}
else
{
node_ptr next = cur->next;
for (; next != first; cur = next, next = cur->next) {}
while (next != last)
{
cur->next = next->next;
destroy_node(next);
next = cur->next;
--size_;
}
}
}
// erase_bucket
// n bucket [buckets_[n], last)
template <class T, class Hash, class KeyEqual>
void hashtable<T, Hash, KeyEqual>::
erase_bucket(size_type n, node_ptr last)
{
auto cur = buckets_[n];
while (cur != last)
{
auto next = cur->next;
destroy_node(cur);
cur = next;
--size_;
}
buckets_[n] = last;
}
// equal_to
template <class T, class Hash, class KeyEqual>
bool hashtable<T, Hash, KeyEqual>::equal_to_multi(const hashtable& other)
{
if (size_ != other.size_)
return false;
for (auto f = begin(), l = end(); f != l;)
{
auto p1 = equal_range_multi(value_traits::get_key(*f));
auto p2 = other.equal_range_multi(value_traits::get_key(*f));
if (mystl::distance(p1.first, p1.last) != mystl::distance(p2.first, p2.last) ||
!mystl::is_permutation(p1.first, p2.last, p2.first, p2.last))
return false;
f = p1.last;
}
return true;
}
template <class T, class Hash, class KeyEqual>
bool hashtable<T, Hash, KeyEqual>::equal_to_unique(const hashtable& other)
{
if (size_ != other.size_)
return false;
for (auto f = begin(), l = end(); f != l; ++f)
{
auto res = other.find(value_traits::get_key(*f));
if (res.node == nullptr || *res != *f)
return false;
}
return true;
}
// mystl swap
template <class T, class Hash, class KeyEqual>
void swap(hashtable<T, Hash, KeyEqual>& lhs,
hashtable<T, Hash, KeyEqual>& rhs) noexcept
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_HASHTABLE_H_
``` | /content/code_sandbox/MyTinySTL/hashtable.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 11,625 |
```objective-c
#ifndef MYTINYSTL_CONSTRUCT_H_
#define MYTINYSTL_CONSTRUCT_H_
// constructdestroy
// construct :
// destroy :
#include <new>
#include "type_traits.h"
#include "iterator.h"
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4100) // unused parameter
#endif // _MSC_VER
namespace mystl
{
// construct
template <class Ty>
void construct(Ty* ptr)
{
::new ((void*)ptr) Ty();
}
template <class Ty1, class Ty2>
void construct(Ty1* ptr, const Ty2& value)
{
::new ((void*)ptr) Ty1(value);
}
template <class Ty, class... Args>
void construct(Ty* ptr, Args&&... args)
{
::new ((void*)ptr) Ty(mystl::forward<Args>(args)...);
}
// destroy
template <class Ty>
void destroy_one(Ty*, std::true_type) {}
template <class Ty>
void destroy_one(Ty* pointer, std::false_type)
{
if (pointer != nullptr)
{
pointer->~Ty();
}
}
template <class ForwardIter>
void destroy_cat(ForwardIter , ForwardIter , std::true_type) {}
template <class ForwardIter>
void destroy_cat(ForwardIter first, ForwardIter last, std::false_type)
{
for (; first != last; ++first)
destroy(&*first);
}
template <class Ty>
void destroy(Ty* pointer)
{
destroy_one(pointer, std::is_trivially_destructible<Ty>{});
}
template <class ForwardIter>
void destroy(ForwardIter first, ForwardIter last)
{
destroy_cat(first, last, std::is_trivially_destructible<
typename iterator_traits<ForwardIter>::value_type>{});
}
} // namespace mystl
#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER
#endif // !MYTINYSTL_CONSTRUCT_H_
``` | /content/code_sandbox/MyTinySTL/construct.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 425 |
```objective-c
#ifndef MYTINYSTL_DEQUE_H_
#define MYTINYSTL_DEQUE_H_
// deque
// deque:
// notes:
//
//
// mystl::deque<T>
// * emplace_front
// * emplace_back
// * emplace
// * push_front
// * push_back
// * insert
#include <initializer_list>
#include "iterator.h"
#include "memory.h"
#include "util.h"
#include "exceptdef.h"
namespace mystl
{
#ifdef max
#pragma message("#undefing marco max")
#undef max
#endif // max
#ifdef min
#pragma message("#undefing marco min")
#undef min
#endif // min
// deque map
#ifndef DEQUE_MAP_INIT_SIZE
#define DEQUE_MAP_INIT_SIZE 8
#endif
template <class T>
struct deque_buf_size
{
static constexpr size_t value = sizeof(T) < 256 ? 4096 / sizeof(T) : 16;
};
// deque
template <class T, class Ref, class Ptr>
struct deque_iterator : public iterator<random_access_iterator_tag, T>
{
typedef deque_iterator<T, T&, T*> iterator;
typedef deque_iterator<T, const T&, const T*> const_iterator;
typedef deque_iterator self;
typedef T value_type;
typedef Ptr pointer;
typedef Ref reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T* value_pointer;
typedef T** map_pointer;
static const size_type buffer_size = deque_buf_size<T>::value;
//
value_pointer cur; //
value_pointer first; //
value_pointer last; //
map_pointer node; //
//
deque_iterator() noexcept
:cur(nullptr), first(nullptr), last(nullptr), node(nullptr) {}
deque_iterator(value_pointer v, map_pointer n)
:cur(v), first(*n), last(*n + buffer_size), node(n) {}
deque_iterator(const iterator& rhs)
:cur(rhs.cur), first(rhs.first), last(rhs.last), node(rhs.node)
{
}
deque_iterator(iterator&& rhs) noexcept
:cur(rhs.cur), first(rhs.first), last(rhs.last), node(rhs.node)
{
rhs.cur = nullptr;
rhs.first = nullptr;
rhs.last = nullptr;
rhs.node = nullptr;
}
deque_iterator(const const_iterator& rhs)
:cur(rhs.cur), first(rhs.first), last(rhs.last), node(rhs.node)
{
}
self& operator=(const iterator& rhs)
{
if (this != &rhs)
{
cur = rhs.cur;
first = rhs.first;
last = rhs.last;
node = rhs.node;
}
return *this;
}
//
void set_node(map_pointer new_node)
{
node = new_node;
first = *new_node;
last = first + buffer_size;
}
//
reference operator*() const { return *cur; }
pointer operator->() const { return cur; }
difference_type operator-(const self& x) const
{
return static_cast<difference_type>(buffer_size) * (node - x.node)
+ (cur - first) - (x.cur - x.first);
}
self& operator++()
{
++cur;
if (cur == last)
{ //
set_node(node + 1);
cur = first;
}
return *this;
}
self operator++(int)
{
self tmp = *this;
++*this;
return tmp;
}
self& operator--()
{
if (cur == first)
{ //
set_node(node - 1);
cur = last;
}
--cur;
return *this;
}
self operator--(int)
{
self tmp = *this;
--*this;
return tmp;
}
self& operator+=(difference_type n)
{
const auto offset = n + (cur - first);
if (offset >= 0 && offset < static_cast<difference_type>(buffer_size))
{ //
cur += n;
}
else
{ //
const auto node_offset = offset > 0
? offset / static_cast<difference_type>(buffer_size)
: -static_cast<difference_type>((-offset - 1) / buffer_size) - 1;
set_node(node + node_offset);
cur = first + (offset - node_offset * static_cast<difference_type>(buffer_size));
}
return *this;
}
self operator+(difference_type n) const
{
self tmp = *this;
return tmp += n;
}
self& operator-=(difference_type n)
{
return *this += -n;
}
self operator-(difference_type n) const
{
self tmp = *this;
return tmp -= n;
}
reference operator[](difference_type n) const { return *(*this + n); }
//
bool operator==(const self& rhs) const { return cur == rhs.cur; }
bool operator< (const self& rhs) const
{ return node == rhs.node ? (cur < rhs.cur) : (node < rhs.node); }
bool operator!=(const self& rhs) const { return !(*this == rhs); }
bool operator> (const self& rhs) const { return rhs < *this; }
bool operator<=(const self& rhs) const { return !(rhs < *this); }
bool operator>=(const self& rhs) const { return !(*this < rhs); }
};
// deque
//
template <class T>
class deque
{
public:
// deque
typedef mystl::allocator<T> allocator_type;
typedef mystl::allocator<T> data_allocator;
typedef mystl::allocator<T*> map_allocator;
typedef typename allocator_type::value_type value_type;
typedef typename allocator_type::pointer pointer;
typedef typename allocator_type::const_pointer const_pointer;
typedef typename allocator_type::reference reference;
typedef typename allocator_type::const_reference const_reference;
typedef typename allocator_type::size_type size_type;
typedef typename allocator_type::difference_type difference_type;
typedef pointer* map_pointer;
typedef const_pointer* const_map_pointer;
typedef deque_iterator<T, T&, T*> iterator;
typedef deque_iterator<T, const T&, const T*> const_iterator;
typedef mystl::reverse_iterator<iterator> reverse_iterator;
typedef mystl::reverse_iterator<const_iterator> const_reverse_iterator;
allocator_type get_allocator() { return allocator_type(); }
static const size_type buffer_size = deque_buf_size<T>::value;
private:
// deque
iterator begin_; //
iterator end_; //
map_pointer map_; // mapmap
size_type map_size_; // map
public:
//
deque()
{ fill_init(0, value_type()); }
explicit deque(size_type n)
{ fill_init(n, value_type()); }
deque(size_type n, const value_type& value)
{ fill_init(n, value); }
template <class IIter, typename std::enable_if<
mystl::is_input_iterator<IIter>::value, int>::type = 0>
deque(IIter first, IIter last)
{ copy_init(first, last, iterator_category(first)); }
deque(std::initializer_list<value_type> ilist)
{
copy_init(ilist.begin(), ilist.end(), mystl::forward_iterator_tag());
}
deque(const deque& rhs)
{
copy_init(rhs.begin(), rhs.end(), mystl::forward_iterator_tag());
}
deque(deque&& rhs) noexcept
:begin_(mystl::move(rhs.begin_)),
end_(mystl::move(rhs.end_)),
map_(rhs.map_),
map_size_(rhs.map_size_)
{
rhs.map_ = nullptr;
rhs.map_size_ = 0;
}
deque& operator=(const deque& rhs);
deque& operator=(deque&& rhs);
deque& operator=(std::initializer_list<value_type> ilist)
{
deque tmp(ilist);
swap(tmp);
return *this;
}
~deque()
{
if (map_ != nullptr)
{
clear();
data_allocator::deallocate(*begin_.node, buffer_size);
*begin_.node = nullptr;
map_allocator::deallocate(map_, map_size_);
map_ = nullptr;
}
}
public:
//
iterator begin() noexcept
{ return begin_; }
const_iterator begin() const noexcept
{ return begin_; }
iterator end() noexcept
{ return end_; }
const_iterator end() const noexcept
{ return end_; }
reverse_iterator rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept
{ return reverse_iterator(end()); }
reverse_iterator rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept
{ return reverse_iterator(begin()); }
const_iterator cbegin() const noexcept
{ return begin(); }
const_iterator cend() const noexcept
{ return end(); }
const_reverse_iterator crbegin() const noexcept
{ return rbegin(); }
const_reverse_iterator crend() const noexcept
{ return rend(); }
//
bool empty() const noexcept { return begin() == end(); }
size_type size() const noexcept { return end_ - begin_; }
size_type max_size() const noexcept { return static_cast<size_type>(-1); }
void resize(size_type new_size) { resize(new_size, value_type()); }
void resize(size_type new_size, const value_type& value);
void shrink_to_fit() noexcept;
//
reference operator[](size_type n)
{
MYSTL_DEBUG(n < size());
return begin_[n];
}
const_reference operator[](size_type n) const
{
MYSTL_DEBUG(n < size());
return begin_[n];
}
reference at(size_type n)
{
THROW_OUT_OF_RANGE_IF(!(n < size()), "deque<T>::at() subscript out of range");
return (*this)[n];
}
const_reference at(size_type n) const
{
THROW_OUT_OF_RANGE_IF(!(n < size()), "deque<T>::at() subscript out of range");
return (*this)[n];
}
reference front()
{
MYSTL_DEBUG(!empty());
return *begin();
}
const_reference front() const
{
MYSTL_DEBUG(!empty());
return *begin();
}
reference back()
{
MYSTL_DEBUG(!empty());
return *(end() - 1);
}
const_reference back() const
{
MYSTL_DEBUG(!empty());
return *(end() - 1);
}
//
// assign
void assign(size_type n, const value_type& value)
{ fill_assign(n, value); }
template <class IIter, typename std::enable_if<
mystl::is_input_iterator<IIter>::value, int>::type = 0>
void assign(IIter first, IIter last)
{ copy_assign(first, last, iterator_category(first)); }
void assign(std::initializer_list<value_type> ilist)
{ copy_assign(ilist.begin(), ilist.end(), mystl::forward_iterator_tag{}); }
// emplace_front / emplace_back / emplace
template <class ...Args>
void emplace_front(Args&& ...args);
template <class ...Args>
void emplace_back(Args&& ...args);
template <class ...Args>
iterator emplace(iterator pos, Args&& ...args);
// push_front / push_back
void push_front(const value_type& value);
void push_back(const value_type& value);
void push_front(value_type&& value) { emplace_front(mystl::move(value)); }
void push_back(value_type&& value) { emplace_back(mystl::move(value)); }
// pop_back / pop_front
void pop_front();
void pop_back();
// insert
iterator insert(iterator position, const value_type& value);
iterator insert(iterator position, value_type&& value);
void insert(iterator position, size_type n, const value_type& value);
template <class IIter, typename std::enable_if<
mystl::is_input_iterator<IIter>::value, int>::type = 0>
void insert(iterator position, IIter first, IIter last)
{ insert_dispatch(position, first, last, iterator_category(first)); }
// erase /clear
iterator erase(iterator position);
iterator erase(iterator first, iterator last);
void clear();
// swap
void swap(deque& rhs) noexcept;
private:
// helper functions
// create node / destroy node
map_pointer create_map(size_type size);
void create_buffer(map_pointer nstart, map_pointer nfinish);
void destroy_buffer(map_pointer nstart, map_pointer nfinish);
// initialize
void map_init(size_type nelem);
void fill_init(size_type n, const value_type& value);
template <class IIter>
void copy_init(IIter, IIter, input_iterator_tag);
template <class FIter>
void copy_init(FIter, FIter, forward_iterator_tag);
// assign
void fill_assign(size_type n, const value_type& value);
template <class IIter>
void copy_assign(IIter first, IIter last, input_iterator_tag);
template <class FIter>
void copy_assign(FIter first, FIter last, forward_iterator_tag);
// insert
template <class... Args>
iterator insert_aux(iterator position, Args&& ...args);
void fill_insert(iterator position, size_type n, const value_type& x);
template <class FIter>
void copy_insert(iterator, FIter, FIter, size_type);
template <class IIter>
void insert_dispatch(iterator, IIter, IIter, input_iterator_tag);
template <class FIter>
void insert_dispatch(iterator, FIter, FIter, forward_iterator_tag);
// reallocate
void require_capacity(size_type n, bool front);
void reallocate_map_at_front(size_type need);
void reallocate_map_at_back(size_type need);
};
/*****************************************************************************************/
//
template <class T>
deque<T>& deque<T>::operator=(const deque& rhs)
{
if (this != &rhs)
{
const auto len = size();
if (len >= rhs.size())
{
erase(mystl::copy(rhs.begin_, rhs.end_, begin_), end_);
}
else
{
iterator mid = rhs.begin() + static_cast<difference_type>(len);
mystl::copy(rhs.begin_, mid, begin_);
insert(end_, mid, rhs.end_);
}
}
return *this;
}
//
template <class T>
deque<T>& deque<T>::operator=(deque&& rhs)
{
clear();
begin_ = mystl::move(rhs.begin_);
end_ = mystl::move(rhs.end_);
map_ = rhs.map_;
map_size_ = rhs.map_size_;
rhs.map_ = nullptr;
rhs.map_size_ = 0;
return *this;
}
//
template <class T>
void deque<T>::resize(size_type new_size, const value_type& value)
{
const auto len = size();
if (new_size < len)
{
erase(begin_ + new_size, end_);
}
else
{
insert(end_, new_size - len, value);
}
}
//
template <class T>
void deque<T>::shrink_to_fit() noexcept
{
//
for (auto cur = map_; cur < begin_.node; ++cur)
{
data_allocator::deallocate(*cur, buffer_size);
*cur = nullptr;
}
for (auto cur = end_.node + 1; cur < map_ + map_size_; ++cur)
{
data_allocator::deallocate(*cur, buffer_size);
*cur = nullptr;
}
}
//
template <class T>
template <class ...Args>
void deque<T>::emplace_front(Args&& ...args)
{
if (begin_.cur != begin_.first)
{
data_allocator::construct(begin_.cur - 1, mystl::forward<Args>(args)...);
--begin_.cur;
}
else
{
require_capacity(1, true);
try
{
--begin_;
data_allocator::construct(begin_.cur, mystl::forward<Args>(args)...);
}
catch (...)
{
++begin_;
throw;
}
}
}
//
template <class T>
template <class ...Args>
void deque<T>::emplace_back(Args&& ...args)
{
if (end_.cur != end_.last - 1)
{
data_allocator::construct(end_.cur, mystl::forward<Args>(args)...);
++end_.cur;
}
else
{
require_capacity(1, false);
data_allocator::construct(end_.cur, mystl::forward<Args>(args)...);
++end_;
}
}
// pos
template <class T>
template <class ...Args>
typename deque<T>::iterator deque<T>::emplace(iterator pos, Args&& ...args)
{
if (pos.cur == begin_.cur)
{
emplace_front(mystl::forward<Args>(args)...);
return begin_;
}
else if (pos.cur == end_.cur)
{
emplace_back(mystl::forward<Args>(args)...);
return end_ - 1;
}
return insert_aux(pos, mystl::forward<Args>(args)...);
}
//
template <class T>
void deque<T>::push_front(const value_type& value)
{
if (begin_.cur != begin_.first)
{
data_allocator::construct(begin_.cur - 1, value);
--begin_.cur;
}
else
{
require_capacity(1, true);
try
{
--begin_;
data_allocator::construct(begin_.cur, value);
}
catch (...)
{
++begin_;
throw;
}
}
}
//
template <class T>
void deque<T>::push_back(const value_type& value)
{
if (end_.cur != end_.last - 1)
{
data_allocator::construct(end_.cur, value);
++end_.cur;
}
else
{
require_capacity(1, false);
data_allocator::construct(end_.cur, value);
++end_;
}
}
//
template <class T>
void deque<T>::pop_front()
{
MYSTL_DEBUG(!empty());
if (begin_.cur != begin_.last - 1)
{
data_allocator::destroy(begin_.cur);
++begin_.cur;
}
else
{
data_allocator::destroy(begin_.cur);
++begin_;
destroy_buffer(begin_.node - 1, begin_.node - 1);
}
}
//
template <class T>
void deque<T>::pop_back()
{
MYSTL_DEBUG(!empty());
if (end_.cur != end_.first)
{
--end_.cur;
data_allocator::destroy(end_.cur);
}
else
{
--end_;
data_allocator::destroy(end_.cur);
destroy_buffer(end_.node + 1, end_.node + 1);
}
}
// position
template <class T>
typename deque<T>::iterator
deque<T>::insert(iterator position, const value_type& value)
{
if (position.cur == begin_.cur)
{
push_front(value);
return begin_;
}
else if (position.cur == end_.cur)
{
push_back(value);
auto tmp = end_;
--tmp;
return tmp;
}
else
{
return insert_aux(position, value);
}
}
template <class T>
typename deque<T>::iterator
deque<T>::insert(iterator position, value_type&& value)
{
if (position.cur == begin_.cur)
{
emplace_front(mystl::move(value));
return begin_;
}
else if (position.cur == end_.cur)
{
emplace_back(mystl::move(value));
auto tmp = end_;
--tmp;
return tmp;
}
else
{
return insert_aux(position, mystl::move(value));
}
}
// position n
template <class T>
void deque<T>::insert(iterator position, size_type n, const value_type& value)
{
if (position.cur == begin_.cur)
{
require_capacity(n, true);
auto new_begin = begin_ - n;
mystl::uninitialized_fill_n(new_begin, n, value);
begin_ = new_begin;
}
else if (position.cur == end_.cur)
{
require_capacity(n, false);
auto new_end = end_ + n;
mystl::uninitialized_fill_n(end_, n, value);
end_ = new_end;
}
else
{
fill_insert(position, n, value);
}
}
// position
template <class T>
typename deque<T>::iterator
deque<T>::erase(iterator position)
{
auto next = position;
++next;
const size_type elems_before = position - begin_;
if (elems_before < (size() / 2))
{
mystl::copy_backward(begin_, position, next);
pop_front();
}
else
{
mystl::copy(next, end_, position);
pop_back();
}
return begin_ + elems_before;
}
// [first, last)
template <class T>
typename deque<T>::iterator
deque<T>::erase(iterator first, iterator last)
{
if (first == begin_ && last == end_)
{
clear();
return end_;
}
else
{
const size_type len = last - first;
const size_type elems_before = first - begin_;
if (elems_before < ((size() - len) / 2))
{
mystl::copy_backward(begin_, first, last);
auto new_begin = begin_ + len;
data_allocator::destroy(begin_.cur, new_begin.cur);
begin_ = new_begin;
}
else
{
mystl::copy(last, end_, first);
auto new_end = end_ - len;
data_allocator::destroy(new_end.cur, end_.cur);
end_ = new_end;
}
return begin_ + elems_before;
}
}
// deque
template <class T>
void deque<T>::clear()
{
// clear
for (map_pointer cur = begin_.node + 1; cur < end_.node; ++cur)
{
data_allocator::destroy(*cur, *cur + buffer_size);
}
if (begin_.node != end_.node)
{ //
mystl::destroy(begin_.cur, begin_.last);
mystl::destroy(end_.first, end_.cur);
}
else
{
mystl::destroy(begin_.cur, end_.cur);
}
shrink_to_fit();
end_ = begin_;
}
// deque
template <class T>
void deque<T>::swap(deque& rhs) noexcept
{
if (this != &rhs)
{
mystl::swap(begin_, rhs.begin_);
mystl::swap(end_, rhs.end_);
mystl::swap(map_, rhs.map_);
mystl::swap(map_size_, rhs.map_size_);
}
}
/*****************************************************************************************/
// helper function
template <class T>
typename deque<T>::map_pointer
deque<T>::create_map(size_type size)
{
map_pointer mp = nullptr;
mp = map_allocator::allocate(size);
for (size_type i = 0; i < size; ++i)
*(mp + i) = nullptr;
return mp;
}
// create_buffer
template <class T>
void deque<T>::
create_buffer(map_pointer nstart, map_pointer nfinish)
{
map_pointer cur;
try
{
for (cur = nstart; cur <= nfinish; ++cur)
{
*cur = data_allocator::allocate(buffer_size);
}
}
catch (...)
{
while (cur != nstart)
{
--cur;
data_allocator::deallocate(*cur, buffer_size);
*cur = nullptr;
}
throw;
}
}
// destroy_buffer
template <class T>
void deque<T>::
destroy_buffer(map_pointer nstart, map_pointer nfinish)
{
for (map_pointer n = nstart; n <= nfinish; ++n)
{
data_allocator::deallocate(*n, buffer_size);
*n = nullptr;
}
}
// map_init
template <class T>
void deque<T>::
map_init(size_type nElem)
{
const size_type nNode = nElem / buffer_size + 1; //
map_size_ = mystl::max(static_cast<size_type>(DEQUE_MAP_INIT_SIZE), nNode + 2);
try
{
map_ = create_map(map_size_);
}
catch (...)
{
map_ = nullptr;
map_size_ = 0;
throw;
}
// nstart nfinish map_
map_pointer nstart = map_ + (map_size_ - nNode) / 2;
map_pointer nfinish = nstart + nNode - 1;
try
{
create_buffer(nstart, nfinish);
}
catch (...)
{
map_allocator::deallocate(map_, map_size_);
map_ = nullptr;
map_size_ = 0;
throw;
}
begin_.set_node(nstart);
end_.set_node(nfinish);
begin_.cur = begin_.first;
end_.cur = end_.first + (nElem % buffer_size);
}
// fill_init
template <class T>
void deque<T>::
fill_init(size_type n, const value_type& value)
{
map_init(n);
if (n != 0)
{
for (auto cur = begin_.node; cur < end_.node; ++cur)
{
mystl::uninitialized_fill(*cur, *cur + buffer_size, value);
}
mystl::uninitialized_fill(end_.first, end_.cur, value);
}
}
// copy_init
template <class T>
template <class IIter>
void deque<T>::
copy_init(IIter first, IIter last, input_iterator_tag)
{
const size_type n = mystl::distance(first, last);
map_init(n);
for (; first != last; ++first)
emplace_back(*first);
}
template <class T>
template <class FIter>
void deque<T>::
copy_init(FIter first, FIter last, forward_iterator_tag)
{
const size_type n = mystl::distance(first, last);
map_init(n);
for (auto cur = begin_.node; cur < end_.node; ++cur)
{
auto next = first;
mystl::advance(next, buffer_size);
mystl::uninitialized_copy(first, next, *cur);
first = next;
}
mystl::uninitialized_copy(first, last, end_.first);
}
// fill_assign
template <class T>
void deque<T>::
fill_assign(size_type n, const value_type& value)
{
if (n > size())
{
mystl::fill(begin(), end(), value);
insert(end(), n - size(), value);
}
else
{
erase(begin() + n, end());
mystl::fill(begin(), end(), value);
}
}
// copy_assign
template <class T>
template <class IIter>
void deque<T>::
copy_assign(IIter first, IIter last, input_iterator_tag)
{
auto first1 = begin();
auto last1 = end();
for (; first != last && first1 != last1; ++first, ++first1)
{
*first1 = *first;
}
if (first1 != last1)
{
erase(first1, last1);
}
else
{
insert_dispatch(end_, first, last, input_iterator_tag{});
}
}
template <class T>
template <class FIter>
void deque<T>::
copy_assign(FIter first, FIter last, forward_iterator_tag)
{
const size_type len1 = size();
const size_type len2 = mystl::distance(first, last);
if (len1 < len2)
{
auto next = first;
mystl::advance(next, len1);
mystl::copy(first, next, begin_);
insert_dispatch(end_, next, last, forward_iterator_tag{});
}
else
{
erase(mystl::copy(first, last, begin_), end_);
}
}
// insert_aux
template <class T>
template <class... Args>
typename deque<T>::iterator
deque<T>::
insert_aux(iterator position, Args&& ...args)
{
const size_type elems_before = position - begin_;
value_type value_copy = value_type(mystl::forward<Args>(args)...);
if (elems_before < (size() / 2))
{ //
emplace_front(front());
auto front1 = begin_;
++front1;
auto front2 = front1;
++front2;
position = begin_ + elems_before;
auto pos = position;
++pos;
mystl::copy(front2, pos, front1);
}
else
{ //
emplace_back(back());
auto back1 = end_;
--back1;
auto back2 = back1;
--back2;
position = begin_ + elems_before;
mystl::copy_backward(position, back2, back1);
}
*position = mystl::move(value_copy);
return position;
}
// fill_insert
template <class T>
void deque<T>::
fill_insert(iterator position, size_type n, const value_type& value)
{
const size_type elems_before = position - begin_;
const size_type len = size();
auto value_copy = value;
if (elems_before < (len / 2))
{
require_capacity(n, true);
//
auto old_begin = begin_;
auto new_begin = begin_ - n;
position = begin_ + elems_before;
try
{
if (elems_before >= n)
{
auto begin_n = begin_ + n;
mystl::uninitialized_copy(begin_, begin_n, new_begin);
begin_ = new_begin;
mystl::copy(begin_n, position, old_begin);
mystl::fill(position - n, position, value_copy);
}
else
{
mystl::uninitialized_fill(
mystl::uninitialized_copy(begin_, position, new_begin), begin_, value_copy);
begin_ = new_begin;
mystl::fill(old_begin, position, value_copy);
}
}
catch (...)
{
if (new_begin.node != begin_.node)
destroy_buffer(new_begin.node, begin_.node - 1);
throw;
}
}
else
{
require_capacity(n, false);
//
auto old_end = end_;
auto new_end = end_ + n;
const size_type elems_after = len - elems_before;
position = end_ - elems_after;
try
{
if (elems_after > n)
{
auto end_n = end_ - n;
mystl::uninitialized_copy(end_n, end_, end_);
end_ = new_end;
mystl::copy_backward(position, end_n, old_end);
mystl::fill(position, position + n, value_copy);
}
else
{
mystl::uninitialized_fill(end_, position + n, value_copy);
mystl::uninitialized_copy(position, end_, position + n);
end_ = new_end;
mystl::fill(position, old_end, value_copy);
}
}
catch (...)
{
if(new_end.node != end_.node)
destroy_buffer(end_.node + 1, new_end.node);
throw;
}
}
}
// copy_insert
template <class T>
template <class FIter>
void deque<T>::
copy_insert(iterator position, FIter first, FIter last, size_type n)
{
const size_type elems_before = position - begin_;
auto len = size();
if (elems_before < (len / 2))
{
require_capacity(n, true);
//
auto old_begin = begin_;
auto new_begin = begin_ - n;
position = begin_ + elems_before;
try
{
if (elems_before >= n)
{
auto begin_n = begin_ + n;
mystl::uninitialized_copy(begin_, begin_n, new_begin);
begin_ = new_begin;
mystl::copy(begin_n, position, old_begin);
mystl::copy(first, last, position - n);
}
else
{
auto mid = first;
mystl::advance(mid, n - elems_before);
mystl::uninitialized_copy(first, mid,
mystl::uninitialized_copy(begin_, position, new_begin));
begin_ = new_begin;
mystl::copy(mid, last, old_begin);
}
}
catch (...)
{
if(new_begin.node != begin_.node)
destroy_buffer(new_begin.node, begin_.node - 1);
throw;
}
}
else
{
require_capacity(n, false);
//
auto old_end = end_;
auto new_end = end_ + n;
const auto elems_after = len - elems_before;
position = end_ - elems_after;
try
{
if (elems_after > n)
{
auto end_n = end_ - n;
mystl::uninitialized_copy(end_n, end_, end_);
end_ = new_end;
mystl::copy_backward(position, end_n, old_end);
mystl::copy(first, last, position);
}
else
{
auto mid = first;
mystl::advance(mid, elems_after);
mystl::uninitialized_copy(position, end_,
mystl::uninitialized_copy(mid, last, end_));
end_ = new_end;
mystl::copy(first, mid, position);
}
}
catch (...)
{
if(new_end.node != end_.node)
destroy_buffer(end_.node + 1, new_end.node);
throw;
}
}
}
// insert_dispatch
template <class T>
template <class IIter>
void deque<T>::
insert_dispatch(iterator position, IIter first, IIter last, input_iterator_tag)
{
if (last <= first) return;
const size_type n = mystl::distance(first, last);
const size_type elems_before = position - begin_;
if (elems_before < (size() / 2))
{
require_capacity(n, true);
}
else
{
require_capacity(n, false);
}
position = begin_ + elems_before;
auto cur = --last;
for (size_type i = 0; i < n; ++i, --cur)
{
insert(position, *cur);
}
}
template <class T>
template <class FIter>
void deque<T>::
insert_dispatch(iterator position, FIter first, FIter last, forward_iterator_tag)
{
if (last <= first) return;
const size_type n = mystl::distance(first, last);
if (position.cur == begin_.cur)
{
require_capacity(n, true);
auto new_begin = begin_ - n;
try
{
mystl::uninitialized_copy(first, last, new_begin);
begin_ = new_begin;
}
catch (...)
{
if(new_begin.node != begin_.node)
destroy_buffer(new_begin.node, begin_.node - 1);
throw;
}
}
else if (position.cur == end_.cur)
{
require_capacity(n, false);
auto new_end = end_ + n;
try
{
mystl::uninitialized_copy(first, last, end_);
end_ = new_end;
}
catch (...)
{
if(new_end.node != end_.node)
destroy_buffer(end_.node + 1, new_end.node);
throw;
}
}
else
{
copy_insert(position, first, last, n);
}
}
// require_capacity
template <class T>
void deque<T>::require_capacity(size_type n, bool front)
{
if (front && (static_cast<size_type>(begin_.cur - begin_.first) < n))
{
const size_type need_buffer = (n - (begin_.cur - begin_.first)) / buffer_size + 1;
if (need_buffer > static_cast<size_type>(begin_.node - map_))
{
reallocate_map_at_front(need_buffer);
return;
}
create_buffer(begin_.node - need_buffer, begin_.node - 1);
}
else if (!front && (static_cast<size_type>(end_.last - end_.cur - 1) < n))
{
const size_type need_buffer = (n - (end_.last - end_.cur - 1)) / buffer_size + 1;
if (need_buffer > static_cast<size_type>((map_ + map_size_) - end_.node - 1))
{
reallocate_map_at_back(need_buffer);
return;
}
create_buffer(end_.node + 1, end_.node + need_buffer);
}
}
// reallocate_map_at_front
template <class T>
void deque<T>::reallocate_map_at_front(size_type need_buffer)
{
const size_type new_map_size = mystl::max(map_size_ << 1,
map_size_ + need_buffer + DEQUE_MAP_INIT_SIZE);
map_pointer new_map = create_map(new_map_size);
const size_type old_buffer = end_.node - begin_.node + 1;
const size_type new_buffer = old_buffer + need_buffer;
// map buffer buffer
auto begin = new_map + (new_map_size - new_buffer) / 2;
auto mid = begin + need_buffer;
auto end = mid + old_buffer;
create_buffer(begin, mid - 1);
for (auto begin1 = mid, begin2 = begin_.node; begin1 != end; ++begin1, ++begin2)
*begin1 = *begin2;
//
map_allocator::deallocate(map_, map_size_);
map_ = new_map;
map_size_ = new_map_size;
begin_ = iterator(*mid + (begin_.cur - begin_.first), mid);
end_ = iterator(*(end - 1) + (end_.cur - end_.first), end - 1);
}
// reallocate_map_at_back
template <class T>
void deque<T>::reallocate_map_at_back(size_type need_buffer)
{
const size_type new_map_size = mystl::max(map_size_ << 1,
map_size_ + need_buffer + DEQUE_MAP_INIT_SIZE);
map_pointer new_map = create_map(new_map_size);
const size_type old_buffer = end_.node - begin_.node + 1;
const size_type new_buffer = old_buffer + need_buffer;
// map buffer buffer
auto begin = new_map + ((new_map_size - new_buffer) / 2);
auto mid = begin + old_buffer;
auto end = mid + need_buffer;
for (auto begin1 = begin, begin2 = begin_.node; begin1 != mid; ++begin1, ++begin2)
*begin1 = *begin2;
create_buffer(mid, end - 1);
//
map_allocator::deallocate(map_, map_size_);
map_ = new_map;
map_size_ = new_map_size;
begin_ = iterator(*begin + (begin_.cur - begin_.first), begin);
end_ = iterator(*(mid - 1) + (end_.cur - end_.first), mid - 1);
}
//
template <class T>
bool operator==(const deque<T>& lhs, const deque<T>& rhs)
{
return lhs.size() == rhs.size() &&
mystl::equal(lhs.begin(), lhs.end(), rhs.begin());
}
template <class T>
bool operator<(const deque<T>& lhs, const deque<T>& rhs)
{
return mystl::lexicographical_compare(
lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
template <class T>
bool operator!=(const deque<T>& lhs, const deque<T>& rhs)
{
return !(lhs == rhs);
}
template <class T>
bool operator>(const deque<T>& lhs, const deque<T>& rhs)
{
return rhs < lhs;
}
template <class T>
bool operator<=(const deque<T>& lhs, const deque<T>& rhs)
{
return !(rhs < lhs);
}
template <class T>
bool operator>=(const deque<T>& lhs, const deque<T>& rhs)
{
return !(lhs < rhs);
}
// mystl swap
template <class T>
void swap(deque<T>& lhs, deque<T>& rhs)
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_DEQUE_H_
``` | /content/code_sandbox/MyTinySTL/deque.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 9,102 |
```objective-c
#ifndef MYTINYSTL_VECTOR_TEST_H_
#define MYTINYSTL_VECTOR_TEST_H_
// vector test : vector push_back
#include <vector>
#include "../MyTinySTL/vector.h"
#include "test.h"
namespace mystl
{
namespace test
{
namespace vector_test
{
void vector_test()
{
std::cout << "[===============================================================]\n";
std::cout << "[----------------- Run container test : vector -----------------]\n";
std::cout << "[-------------------------- API test ---------------------------]\n";
int a[] = { 1,2,3,4,5 };
mystl::vector<int> v1;
mystl::vector<int> v2(10);
mystl::vector<int> v3(10, 1);
mystl::vector<int> v4(a, a + 5);
mystl::vector<int> v5(v2);
mystl::vector<int> v6(std::move(v2));
mystl::vector<int> v7{ 1,2,3,4,5,6,7,8,9 };
mystl::vector<int> v8, v9, v10;
v8 = v3;
v9 = std::move(v3);
v10 = { 1,2,3,4,5,6,7,8,9 };
FUN_AFTER(v1, v1.assign(8, 8));
FUN_AFTER(v1, v1.assign(a, a + 5));
FUN_AFTER(v1, v1.emplace(v1.begin(), 0));
FUN_AFTER(v1, v1.emplace_back(6));
FUN_AFTER(v1, v1.push_back(6));
FUN_AFTER(v1, v1.insert(v1.end(), 7));
FUN_AFTER(v1, v1.insert(v1.begin() + 3, 2, 3));
FUN_AFTER(v1, v1.insert(v1.begin(), a, a + 5));
FUN_AFTER(v1, v1.pop_back());
FUN_AFTER(v1, v1.erase(v1.begin()));
FUN_AFTER(v1, v1.erase(v1.begin(), v1.begin() + 2));
FUN_AFTER(v1, v1.reverse());
FUN_AFTER(v1, v1.swap(v4));
FUN_VALUE(*v1.begin());
FUN_VALUE(*(v1.end() - 1));
FUN_VALUE(*v1.rbegin());
FUN_VALUE(*(v1.rend() - 1));
FUN_VALUE(v1.front());
FUN_VALUE(v1.back());
FUN_VALUE(v1[0]);
FUN_VALUE(v1.at(1));
int* p = v1.data();
*p = 10;
*++p = 20;
p[1] = 30;
std::cout << " After change v1.data() :" << "\n";
COUT(v1);
std::cout << std::boolalpha;
FUN_VALUE(v1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(v1.size());
FUN_VALUE(v1.max_size());
FUN_VALUE(v1.capacity());
FUN_AFTER(v1, v1.resize(10));
FUN_VALUE(v1.size());
FUN_VALUE(v1.capacity());
FUN_AFTER(v1, v1.shrink_to_fit());
FUN_VALUE(v1.size());
FUN_VALUE(v1.capacity());
FUN_AFTER(v1, v1.resize(6, 6));
FUN_VALUE(v1.size());
FUN_VALUE(v1.capacity());
FUN_AFTER(v1, v1.shrink_to_fit());
FUN_VALUE(v1.size());
FUN_VALUE(v1.capacity());
FUN_AFTER(v1, v1.clear());
FUN_VALUE(v1.size());
FUN_VALUE(v1.capacity());
FUN_AFTER(v1, v1.reserve(5));
FUN_VALUE(v1.size());
FUN_VALUE(v1.capacity());
FUN_AFTER(v1, v1.reserve(20));
FUN_VALUE(v1.size());
FUN_VALUE(v1.capacity());
FUN_AFTER(v1, v1.shrink_to_fit());
FUN_VALUE(v1.size());
FUN_VALUE(v1.capacity());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]\n";
std::cout << "|---------------------|-------------|-------------|-------------|\n";
std::cout << "| push_back |";
#if LARGER_TEST_DATA_ON
CON_TEST_P1(vector<int>, push_back, rand(), SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3));
#else
CON_TEST_P1(vector<int>, push_back, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3));
#endif
std::cout << "\n";
std::cout << "|---------------------|-------------|-------------|-------------|\n";
PASSED;
#endif
std::cout << "[----------------- End container test : vector -----------------]\n";
}
} // namespace vector_test
} // namespace test
} // namespace mystl
#endif // !MYTINYSTL_VECTOR_TEST_H_
``` | /content/code_sandbox/Test/vector_test.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 1,090 |
```objective-c
#ifndef MYTINYSTL_QUEUE_TEST_H_
#define MYTINYSTL_QUEUE_TEST_H_
// queue test : queue, priority_queue push
#include <queue>
#include "../MyTinySTL/queue.h"
#include "test.h"
namespace mystl
{
namespace test
{
namespace queue_test
{
void queue_print(mystl::queue<int> q)
{
while (!q.empty())
{
std::cout << " " << q.front();
q.pop();
}
std::cout << std::endl;
}
void p_queue_print(mystl::priority_queue<int> p)
{
while (!p.empty())
{
std::cout << " " << p.top();
p.pop();
}
std::cout << std::endl;
}
// queue
#define QUEUE_COUT(q) do { \
std::string q_name = #q; \
std::cout << " " << q_name << " :"; \
queue_print(q); \
} while(0)
// priority_queue
#define P_QUEUE_COUT(p) do { \
std::string p_name = #p; \
std::cout << " " << p_name << " :"; \
p_queue_print(p); \
} while(0)
#define QUEUE_FUN_AFTER(con, fun) do { \
std::string fun_name = #fun; \
std::cout << " After " << fun_name << " :\n"; \
fun; \
QUEUE_COUT(con); \
} while(0)
#define P_QUEUE_FUN_AFTER(con, fun) do { \
std::string fun_name = #fun; \
std::cout << " After " << fun_name << " :\n"; \
fun; \
P_QUEUE_COUT(con); \
} while(0)
void queue_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[----------------- Run container test : queue ------------------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
int a[] = { 1,2,3,4,5 };
mystl::deque<int> d1(5);
mystl::queue<int> q1;
mystl::queue<int> q2(5);
mystl::queue<int> q3(5, 1);
mystl::queue<int> q4(a, a + 5);
mystl::queue<int> q5(d1);
mystl::queue<int> q6(std::move(d1));
mystl::queue<int> q7(q2);
mystl::queue<int> q8(std::move(q2));
mystl::queue<int> q9;
q9 = q3;
mystl::queue<int> q10;
q10 = std::move(q3);
mystl::queue<int> q11{ 1,2,3,4,5 };
mystl::queue<int> q12;
q12 = { 1,2,3,4,5 };
QUEUE_FUN_AFTER(q1, q1.push(1));
QUEUE_FUN_AFTER(q1, q1.push(2));
QUEUE_FUN_AFTER(q1, q1.push(3));
QUEUE_FUN_AFTER(q1, q1.pop());
QUEUE_FUN_AFTER(q1, q1.emplace(4));
QUEUE_FUN_AFTER(q1, q1.emplace(5));
std::cout << std::boolalpha;
FUN_VALUE(q1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(q1.size());
FUN_VALUE(q1.front());
FUN_VALUE(q1.back());
while (!q1.empty())
{
QUEUE_FUN_AFTER(q1, q1.pop());
}
QUEUE_FUN_AFTER(q1, q1.swap(q4));
QUEUE_FUN_AFTER(q1, q1.clear());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| push |";
#if LARGER_TEST_DATA_ON
CON_TEST_P1(queue<int>, push, rand(), SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3));
#else
CON_TEST_P1(queue<int>, push, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[----------------- End container test : queue ------------------]" << std::endl;
}
void priority_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[------------- Run container test : priority_queue -------------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
int a[] = { 1,2,3,4,5 };
mystl::vector<int> v1(5);
mystl::priority_queue<int> p1;
mystl::priority_queue<int> p2(5);
mystl::priority_queue<int> p3(5, 1);
mystl::priority_queue<int> p4(a, a + 5);
mystl::priority_queue<int> p5(v1);
mystl::priority_queue<int> p6(std::move(v1));
mystl::priority_queue<int> p7(p2);
mystl::priority_queue<int> p8(std::move(p2));
mystl::priority_queue<int> p9;
p9 = p3;
mystl::priority_queue<int> p10;
p10 = std::move(p3);
mystl::priority_queue<int> p11{ 1,2,3,4,5 };
mystl::priority_queue<int> p12;
p12 = { 1,2,3,4,5 };
P_QUEUE_FUN_AFTER(p1, p1.push(1));
P_QUEUE_FUN_AFTER(p1, p1.push(5));
P_QUEUE_FUN_AFTER(p1, p1.push(3));
P_QUEUE_FUN_AFTER(p1, p1.pop());
P_QUEUE_FUN_AFTER(p1, p1.emplace(7));
P_QUEUE_FUN_AFTER(p1, p1.emplace(2));
P_QUEUE_FUN_AFTER(p1, p1.emplace(8));
std::cout << std::boolalpha;
FUN_VALUE(p1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(p1.size());
FUN_VALUE(p1.top());
while (!p1.empty())
{
P_QUEUE_FUN_AFTER(p1, p1.pop());
}
P_QUEUE_FUN_AFTER(p1, p1.swap(p4));
P_QUEUE_FUN_AFTER(p1, p1.clear());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| push |";
#if LARGER_TEST_DATA_ON
CON_TEST_P1(priority_queue<int>, push, rand(), SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3));
#else
CON_TEST_P1(priority_queue<int>, push, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[------------- End container test : priority_queue -------------]" << std::endl;
}
} // namespace queue_test
} // namespace test
} // namespace mystl
#endif // !MYTINYSTL_QUEUE_TEST_H_
``` | /content/code_sandbox/Test/queue_test.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 1,723 |
```objective-c
#ifndef MYTINYSTL_STACK_TEST_H_
#define MYTINYSTL_STACK_TEST_H_
// stack test : stack push
#include <stack>
#include "../MyTinySTL/stack.h"
#include "test.h"
namespace mystl
{
namespace test
{
namespace stack_test
{
void stack_print(mystl::stack<int> s)
{
while (!s.empty())
{
std::cout << " " << s.top();
s.pop();
}
std::cout << std::endl;
}
// stack
#define STACK_COUT(s) do { \
std::string s_name = #s; \
std::cout << " " << s_name << " :"; \
stack_print(s); \
} while(0)
#define STACK_FUN_AFTER(con, fun) do { \
std::string fun_name = #fun; \
std::cout << " After " << fun_name << " :\n"; \
fun; \
STACK_COUT(con); \
} while(0)
void stack_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[----------------- Run container test : stack ------------------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
int a[] = { 1,2,3,4,5 };
mystl::deque<int> d1(5);
mystl::stack<int> s1;
mystl::stack<int> s2(5);
mystl::stack<int> s3(5, 1);
mystl::stack<int> s4(a, a + 5);
mystl::stack<int> s5(d1);
mystl::stack<int> s6(std::move(d1));
mystl::stack<int> s7(s2);
mystl::stack<int> s8(std::move(s2));
mystl::stack<int> s9;
s9 = s3;
mystl::stack<int> s10;
s10 = std::move(s3);
mystl::stack<int> s11{ 1,2,3,4,5 };
mystl::stack<int> s12;
s12 = { 1,2,3,4,5 };
STACK_FUN_AFTER(s1, s1.push(1));
STACK_FUN_AFTER(s1, s1.push(2));
STACK_FUN_AFTER(s1, s1.push(3));
STACK_FUN_AFTER(s1, s1.pop());
STACK_FUN_AFTER(s1, s1.emplace(4));
STACK_FUN_AFTER(s1, s1.emplace(5));
std::cout << std::boolalpha;
FUN_VALUE(s1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(s1.size());
FUN_VALUE(s1.top());
while (!s1.empty())
{
STACK_FUN_AFTER(s1, s1.pop());
}
STACK_FUN_AFTER(s1, s1.swap(s4));
STACK_FUN_AFTER(s1, s1.clear());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| push |";
#if LARGER_TEST_DATA_ON
CON_TEST_P1(stack<int>, push, rand(), SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3));
#else
CON_TEST_P1(stack<int>, push, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[----------------- End container test : stack ------------------]" << std::endl;
}
} // namespace stack_test
} // namespace test
} // namespace mystl
#endif // !MYTINYSTL_STACK_TEST_H_
``` | /content/code_sandbox/Test/stack_test.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 881 |
```objective-c
#ifndef MYTINYSTL_MAP_TEST_H_
#define MYTINYSTL_MAP_TEST_H_
// map test : map, multimap insert
#include <map>
#include "../MyTinySTL/map.h"
#include "../MyTinySTL/vector.h"
#include "test.h"
namespace mystl
{
namespace test
{
namespace map_test
{
// pair
#define PAIR mystl::pair<int, int>
// map
#define MAP_COUT(m) do { \
std::string m_name = #m; \
std::cout << " " << m_name << " :"; \
for (auto it : m) std::cout << " <" << it.first << "," << it.second << ">"; \
std::cout << std::endl; \
} while(0)
// map
#define MAP_FUN_AFTER(con, fun) do { \
std::string str = #fun; \
std::cout << " After " << str << " :" << std::endl; \
fun; \
MAP_COUT(con); \
} while(0)
// map
#define MAP_VALUE(fun) do { \
std::string str = #fun; \
auto it = fun; \
std::cout << " " << str << " : <" << it.first << "," << it.second << ">\n"; \
} while(0)
void map_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[------------------ Run container test : map -------------------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
mystl::vector<PAIR> v;
for (int i = 0; i < 5; ++i)
v.push_back(PAIR(i, i));
mystl::map<int, int> m1;
mystl::map<int, int, mystl::greater<int>> m2;
mystl::map<int, int> m3(v.begin(), v.end());
mystl::map<int, int> m4(v.begin(), v.end());
mystl::map<int, int> m5(m3);
mystl::map<int, int> m6(std::move(m3));
mystl::map<int, int> m7;
m7 = m4;
mystl::map<int, int> m8;
m8 = std::move(m4);
mystl::map<int, int> m9{ PAIR(1,1),PAIR(3,2),PAIR(2,3) };
mystl::map<int, int> m10;
m10 = { PAIR(1,1),PAIR(3,2),PAIR(2,3) };
for (int i = 5; i > 0; --i)
{
MAP_FUN_AFTER(m1, m1.emplace(i, i));
}
MAP_FUN_AFTER(m1, m1.emplace_hint(m1.begin(), 0, 0));
MAP_FUN_AFTER(m1, m1.erase(m1.begin()));
MAP_FUN_AFTER(m1, m1.erase(0));
MAP_FUN_AFTER(m1, m1.erase(1));
MAP_FUN_AFTER(m1, m1.erase(m1.begin(), m1.end()));
for (int i = 0; i < 5; ++i)
{
MAP_FUN_AFTER(m1, m1.insert(PAIR(i, i)));
}
MAP_FUN_AFTER(m1, m1.insert(v.begin(), v.end()));
MAP_FUN_AFTER(m1, m1.insert(m1.end(), PAIR(5, 5)));
FUN_VALUE(m1.count(1));
MAP_VALUE(*m1.find(3));
MAP_VALUE(*m1.lower_bound(3));
MAP_VALUE(*m1.upper_bound(2));
auto first = *m1.equal_range(2).first;
auto second = *m1.equal_range(2).second;
std::cout << " m1.equal_range(2) : from <" << first.first << ", " << first.second
<< "> to <" << second.first << ", " << second.second << ">" << std::endl;
MAP_FUN_AFTER(m1, m1.erase(m1.begin()));
MAP_FUN_AFTER(m1, m1.erase(1));
MAP_FUN_AFTER(m1, m1.erase(m1.begin(), m1.find(3)));
MAP_FUN_AFTER(m1, m1.clear());
MAP_FUN_AFTER(m1, m1.swap(m9));
MAP_VALUE(*m1.begin());
MAP_VALUE(*m1.rbegin());
FUN_VALUE(m1[1]);
MAP_FUN_AFTER(m1, m1[1] = 3);
FUN_VALUE(m1.at(1));
std::cout << std::boolalpha;
FUN_VALUE(m1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(m1.size());
FUN_VALUE(m1.max_size());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| emplace |";
#if LARGER_TEST_DATA_ON
MAP_EMPLACE_TEST(map, SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3));
#else
MAP_EMPLACE_TEST(map, SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[------------------ End container test : map -------------------]" << std::endl;
}
void multimap_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[---------------- Run container test : multimap ----------------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
mystl::vector<PAIR> v;
for (int i = 0; i < 5; ++i)
v.push_back(PAIR(i, i));
mystl::multimap<int, int> m1;
mystl::multimap<int, int, mystl::greater<int>> m2;
mystl::multimap<int, int> m3(v.begin(), v.end());
mystl::multimap<int, int> m4(v.begin(), v.end());
mystl::multimap<int, int> m5(m3);
mystl::multimap<int, int> m6(std::move(m3));
mystl::multimap<int, int> m7;
m7 = m4;
mystl::multimap<int, int> m8;
m8 = std::move(m4);
mystl::multimap<int, int> m9{ PAIR(1,1),PAIR(3,2),PAIR(2,3) };
mystl::multimap<int, int> m10;
m10 = { PAIR(1,1),PAIR(3,2),PAIR(2,3) };
for (int i = 5; i > 0; --i)
{
MAP_FUN_AFTER(m1, m1.emplace(i, i));
}
MAP_FUN_AFTER(m1, m1.emplace_hint(m1.begin(), 0, 0));
MAP_FUN_AFTER(m1, m1.erase(m1.begin()));
MAP_FUN_AFTER(m1, m1.erase(0));
MAP_FUN_AFTER(m1, m1.erase(1));
MAP_FUN_AFTER(m1, m1.erase(m1.begin(), m1.end()));
for (int i = 0; i < 5; ++i)
{
MAP_FUN_AFTER(m1, m1.insert(mystl::make_pair(i, i)));
}
MAP_FUN_AFTER(m1, m1.insert(v.begin(), v.end()));
MAP_FUN_AFTER(m1, m1.insert(PAIR(5, 5)));
MAP_FUN_AFTER(m1, m1.insert(m1.end(), PAIR(5, 5)));
FUN_VALUE(m1.count(3));
MAP_VALUE(*m1.find(3));
MAP_VALUE(*m1.lower_bound(3));
MAP_VALUE(*m1.upper_bound(2));
auto first = *m1.equal_range(2).first;
auto second = *m1.equal_range(2).second;
std::cout << " m1.equal_range(2) : from <" << first.first << ", " << first.second
<< "> to <" << second.first << ", " << second.second << ">" << std::endl;
MAP_FUN_AFTER(m1, m1.erase(m1.begin()));
MAP_FUN_AFTER(m1, m1.erase(1));
MAP_FUN_AFTER(m1, m1.erase(m1.begin(), m1.find(3)));
MAP_FUN_AFTER(m1, m1.clear());
MAP_FUN_AFTER(m1, m1.swap(m9));
MAP_FUN_AFTER(m1, m1.insert(PAIR(3, 3)));
MAP_VALUE(*m1.begin());
MAP_VALUE(*m1.rbegin());
std::cout << std::boolalpha;
FUN_VALUE(m1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(m1.size());
FUN_VALUE(m1.max_size());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| emplace |";
#if LARGER_TEST_DATA_ON
MAP_EMPLACE_TEST(multimap, SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3));
#else
MAP_EMPLACE_TEST(multimap, SCALE_S(LEN1), SCALE_S(LEN2), SCALE_S(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[---------------- End container test : multimap ----------------]" << std::endl;
}
} // namespace map_test
} // namespace test
} // namespace mystl
#endif // !MYTINYSTL_MAP_TEST_H_
``` | /content/code_sandbox/Test/map_test.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 2,235 |
```objective-c
#ifndef MYTINYSTL_UNORDERED_SET_TEST_H_
#define MYTINYSTL_UNORDERED_SET_TEST_H_
// unordered_set test : unordered_set, unordered_multiset insert
#include <unordered_set>
#include "../MyTinySTL/unordered_set.h"
#include "set_test.h"
#include "test.h"
namespace mystl
{
namespace test
{
namespace unordered_set_test
{
void unordered_set_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[-------------- Run container test : unordered_set -------------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
int a[] = { 5,4,3,2,1 };
mystl::unordered_set<int> us1;
mystl::unordered_set<int> us2(520);
mystl::unordered_set<int> us3(520, mystl::hash<int>());
mystl::unordered_set<int> us4(520, mystl::hash<int>(), mystl::equal_to<int>());
mystl::unordered_set<int> us5(a, a + 5);
mystl::unordered_set<int> us6(a, a + 5, 100);
mystl::unordered_set<int> us7(a, a + 5, 100, mystl::hash<int>());
mystl::unordered_set<int> us8(a, a + 5, 100, mystl::hash<int>(), mystl::equal_to<int>());
mystl::unordered_set<int> us9(us5);
mystl::unordered_set<int> us10(std::move(us5));
mystl::unordered_set<int> us11;
us11 = us6;
mystl::unordered_set<int> us12;
us12 = std::move(us6);
mystl::unordered_set<int> us13{ 1,2,3,4,5 };
mystl::unordered_set<int> us14;
us13 = { 1,2,3,4,5 };
FUN_AFTER(us1, us1.emplace(1));
FUN_AFTER(us1, us1.emplace_hint(us1.end(), 2));
FUN_AFTER(us1, us1.insert(5));
FUN_AFTER(us1, us1.insert(us1.begin(), 5));
FUN_AFTER(us1, us1.insert(a, a + 5));
FUN_AFTER(us1, us1.erase(us1.begin()));
FUN_AFTER(us1, us1.erase(us1.begin(), us1.find(3)));
FUN_AFTER(us1, us1.erase(1));
std::cout << std::boolalpha;
FUN_VALUE(us1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(us1.size());
FUN_VALUE(us1.bucket_count());
FUN_VALUE(us1.max_bucket_count());
FUN_VALUE(us1.bucket(1));
FUN_VALUE(us1.bucket_size(us1.bucket(5)));
FUN_AFTER(us1, us1.clear());
FUN_AFTER(us1, us1.swap(us7));
FUN_VALUE(*us1.begin());
std::cout << std::boolalpha;
FUN_VALUE(us1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(us1.size());
FUN_VALUE(us1.max_size());
FUN_VALUE(us1.bucket_count());
FUN_AFTER(us1, us1.reserve(1000));
FUN_VALUE(*us1.begin(us1.bucket(1)));
FUN_VALUE(us1.size());
FUN_VALUE(us1.bucket_count());
FUN_VALUE(us1.bucket_size(1));
FUN_VALUE(us1.bucket_size(2));
FUN_VALUE(us1.bucket_size(3));
FUN_AFTER(us1, us1.rehash(150));
FUN_VALUE(us1.bucket_count());
FUN_VALUE(us1.count(1));
FUN_VALUE(*us1.find(3));
auto first = *us1.equal_range(3).first;
auto second = *us1.equal_range(3).second;
std::cout << " us1.equal_range(3) : from " << first << " to " << second << std::endl;
FUN_VALUE(us1.load_factor());
FUN_VALUE(us1.max_load_factor());
FUN_AFTER(us1, us1.max_load_factor(1.5f));
FUN_VALUE(us1.max_load_factor());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| emplace |";
#if LARGER_TEST_DATA_ON
CON_TEST_P1(unordered_set<int>, emplace, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3));
#else
CON_TEST_P1(unordered_set<int>, emplace, rand(), SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[-------------- End container test : unordered_set -------------]" << std::endl;
}
void unordered_multiset_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[------------ Run container test : unordered_multiset ----------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
int a[] = { 5,4,3,2,1 };
mystl::unordered_multiset<int> us1;
mystl::unordered_multiset<int> us2(520);
mystl::unordered_multiset<int> us3(520, mystl::hash<int>());
mystl::unordered_multiset<int> us4(520, mystl::hash<int>(), mystl::equal_to<int>());
mystl::unordered_multiset<int> us5(a, a + 5);
mystl::unordered_multiset<int> us6(a, a + 5, 100);
mystl::unordered_multiset<int> us7(a, a + 5, 100, mystl::hash<int>());
mystl::unordered_multiset<int> us8(a, a + 5, 100, mystl::hash<int>(), mystl::equal_to<int>());
mystl::unordered_multiset<int> us9(us5);
mystl::unordered_multiset<int> us10(std::move(us5));
mystl::unordered_multiset<int> us11;
us11 = us6;
mystl::unordered_multiset<int> us12;
us12 = std::move(us6);
mystl::unordered_multiset<int> us13{ 1,2,3,4,5 };
mystl::unordered_multiset<int> us14;
us14 = { 1,2,3,4,5 };
FUN_AFTER(us1, us1.emplace(1));
FUN_AFTER(us1, us1.emplace_hint(us1.end(), 2));
FUN_AFTER(us1, us1.insert(5));
FUN_AFTER(us1, us1.insert(us1.begin(), 5));
FUN_AFTER(us1, us1.insert(a, a + 5));
FUN_AFTER(us1, us1.erase(us1.begin()));
FUN_AFTER(us1, us1.erase(us1.begin(), us1.find(3)));
FUN_AFTER(us1, us1.erase(1));
std::cout << std::boolalpha;
FUN_VALUE(us1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(us1.size());
FUN_VALUE(us1.bucket_count());
FUN_VALUE(us1.max_bucket_count());
FUN_VALUE(us1.bucket(1));
FUN_VALUE(us1.bucket_size(us1.bucket(5)));
FUN_AFTER(us1, us1.clear());
FUN_AFTER(us1, us1.swap(us7));
FUN_VALUE(*us1.begin());
std::cout << std::boolalpha;
FUN_VALUE(us1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(us1.size());
FUN_VALUE(us1.max_size());
FUN_VALUE(us1.bucket_count());
FUN_AFTER(us1, us1.reserve(1000));
FUN_VALUE(*us1.begin(us1.bucket(1)));
FUN_VALUE(us1.size());
FUN_VALUE(us1.bucket_count());
FUN_VALUE(us1.bucket_size(1));
FUN_VALUE(us1.bucket_size(2));
FUN_VALUE(us1.bucket_size(3));
FUN_AFTER(us1, us1.rehash(150));
FUN_VALUE(us1.bucket_count());
FUN_VALUE(us1.count(1));
FUN_VALUE(*us1.find(3));
auto first = *us1.equal_range(3).first;
auto second = *us1.equal_range(3).second;
std::cout << " us1.equal_range(3) : from " << first << " to " << second << std::endl;
FUN_VALUE(us1.load_factor());
FUN_VALUE(us1.max_load_factor());
FUN_AFTER(us1, us1.max_load_factor(1.5f));
FUN_VALUE(us1.max_load_factor());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| emplace |";
#if LARGER_TEST_DATA_ON
CON_TEST_P1(unordered_multiset<int>, emplace, rand(), SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3));
#else
CON_TEST_P1(unordered_multiset<int>, emplace, rand(), SCALE_S(LEN1), SCALE_S(LEN2), SCALE_S(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[------------ End container test : unordered_multiset ----------]" << std::endl;
}
} // namespace unordered_set_test
} // namespace test
} // namespace mystl
#endif // !MYTINYSTL_UNORDERED_SET_TEST_H_
``` | /content/code_sandbox/Test/unordered_set_test.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 2,200 |
```objective-c
#ifndef MYTINYSTL_STRING_TEST_H_
#define MYTINYSTL_STRING_TEST_H_
// string test : string insert
#include <string>
#include "../MyTinySTL/astring.h"
#include "test.h"
namespace mystl
{
namespace test
{
namespace string_test
{
void string_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[----------------- Run container test : string -----------------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
const char* s = "abcdefg";
mystl::string str;
mystl::string str1(5, 'a');
mystl::string str2(str1, 3);
mystl::string str3(str1, 0, 3);
mystl::string str4("abc");
mystl::string str5("abcde",3);
mystl::string str6(s, s + 5);
mystl::string str7(str1);
mystl::string str8(std::move(str1));
mystl::string str9;
str9 = str2;
mystl::string str10;
str10 = std::move(str2);
mystl::string str11;
str11 = "123";
mystl::string str12;
str12 = 'A';
STR_FUN_AFTER(str, str = 'a');
STR_FUN_AFTER(str, str = "string");
FUN_VALUE(*str.begin());
FUN_VALUE(*str.rbegin());
FUN_VALUE(*(str.end() - 1));
FUN_VALUE(*(str.rend() - 1));
FUN_VALUE(str.front());
FUN_VALUE(str.back());
FUN_VALUE(str[1]);
FUN_VALUE(str.at(2));
STR_COUT(str.data());
STR_COUT(str.c_str());
std::cout << std::boolalpha;
FUN_VALUE(str.empty());
std::cout << std::noboolalpha;
FUN_VALUE(str.size());
FUN_VALUE(str.length());
FUN_VALUE(str.capacity());
FUN_VALUE(str.max_size());
STR_FUN_AFTER(str, str.shrink_to_fit());
FUN_VALUE(str.capacity());
STR_FUN_AFTER(str, str.insert(str.begin(), 'a'));
STR_FUN_AFTER(str, str.insert(str.end(), 3, 'x'));
STR_FUN_AFTER(str, str.insert(str.end(), s, s + 3));
STR_FUN_AFTER(str, str.erase(str.begin()));
STR_FUN_AFTER(str, str.erase(str.begin(), str.begin() + 3));
STR_FUN_AFTER(str, str.clear());
STR_FUN_AFTER(str, str.push_back('s'));
STR_FUN_AFTER(str, str.push_back('t'));
STR_FUN_AFTER(str, str.pop_back());
STR_FUN_AFTER(str, str.append(1, 't'));
STR_FUN_AFTER(str, str.append(str4));
STR_FUN_AFTER(str, str.append(str4, 1));
STR_FUN_AFTER(str, str.append(str4, 2, 1));
STR_FUN_AFTER(str, str.append("str"));
STR_FUN_AFTER(str, str.append("inging", 3));
STR_FUN_AFTER(str, str.append(s, s + 3));
STR_FUN_AFTER(str, str.resize(10));
FUN_VALUE(str.size());
STR_FUN_AFTER(str, str.resize(20, 'x'));
FUN_VALUE(str.size());
STR_FUN_AFTER(str, str.clear());
STR_FUN_AFTER(str, str = "string");
STR_FUN_AFTER(str3, str3 = "astrings");
FUN_VALUE(str.compare(str3));
FUN_VALUE(str.compare(0, 6, str3));
FUN_VALUE(str.compare(0, 6, str3, 1, 6));
FUN_VALUE(str.compare("atringgg"));
FUN_VALUE(str.compare("zzz"));
FUN_VALUE(str.compare(0, 3, "str"));
FUN_VALUE(str.compare(0, 3, "stri", 4));
FUN_VALUE(str.compare(0, 3, "s", 2));
FUN_VALUE(str.compare(0, 9, "stringabc", 9));
FUN_VALUE(str.substr(0));
FUN_VALUE(str.substr(3));
FUN_VALUE(str.substr(0, 3));
FUN_VALUE(str.substr(0, 10));
STR_FUN_AFTER(str, str.replace(0, 6, str3));
STR_FUN_AFTER(str, str.replace(str.end() - 1, str.end(), str3));
STR_FUN_AFTER(str, str.replace(0, 1, "my "));
STR_FUN_AFTER(str, str.replace(str.end() - 8, str.end(), " test"));
STR_FUN_AFTER(str, str.replace(10, 4, "replace"));
STR_FUN_AFTER(str, str.replace(str.end(), str.end(), " test"));
STR_FUN_AFTER(str, str.replace(0, 2, 3, '6'));
STR_FUN_AFTER(str, str.replace(str.begin(), str.begin() + 3, 6, '6'));
STR_FUN_AFTER(str, str.replace(0, 3, str3, 1, 3));
STR_FUN_AFTER(str, str.replace(str.begin(), str.begin() + 6, s, s + 3));
STR_FUN_AFTER(str, str.reverse());
STR_FUN_AFTER(str, str.reverse());
STR_FUN_AFTER(str, str = "abcabc stringgg");
STR_FUN_AFTER(str3, str3 = "abc");
FUN_VALUE(str.find('a'));
FUN_VALUE(str.find('a', 3));
FUN_VALUE(str.find('a', 4));
FUN_VALUE(str.find("abc"));
FUN_VALUE(str.find("abc", 1));
FUN_VALUE(str.find("abc", 1, 1));
FUN_VALUE(str.find(str3));
FUN_VALUE(str.find(str3, 1));
FUN_VALUE(str.rfind('g'));
FUN_VALUE(str.rfind('g', 3));
FUN_VALUE(str.rfind("gg"));
FUN_VALUE(str.rfind("bc", 10));
FUN_VALUE(str.rfind(str3));
FUN_VALUE(str.rfind(str3, 3));
FUN_VALUE(str.find_first_of('g'));
FUN_VALUE(str.find_first_of('k'));
FUN_VALUE(str.find_first_of("bca"));
FUN_VALUE(str.find_first_of("defg", 10));
FUN_VALUE(str.find_first_of("gnirts"));
FUN_VALUE(str.find_first_of("abc", 6));
FUN_VALUE(str.find_first_of("abcdf", 2, 3));
FUN_VALUE(str.find_first_of(str3, 1));
FUN_VALUE(str.find_first_of(str3, 10));
FUN_VALUE(str.find_first_not_of('a'));
FUN_VALUE(str.find_first_not_of('d'));
FUN_VALUE(str.find_first_not_of('g', 14));
FUN_VALUE(str.find_first_not_of("abc"));
FUN_VALUE(str.find_first_not_of("ggggg", 14, 4));
FUN_VALUE(str.find_first_not_of(str3));
FUN_VALUE(str.find_first_not_of(str3, 3));
FUN_VALUE(str.find_last_of('a'));
FUN_VALUE(str.find_last_of('a', 4));
FUN_VALUE(str.find_last_of('g'));
FUN_VALUE(str.find_last_of("gg"));
FUN_VALUE(str.find_last_of("gg", 14));
FUN_VALUE(str.find_last_of("ggg", 14, 1));
FUN_VALUE(str.find_last_of(str3));
FUN_VALUE(str.find_last_of(str3, 3));
FUN_VALUE(str.find_last_not_of('g'));
FUN_VALUE(str.find_last_not_of('a'));
FUN_VALUE(str.find_last_not_of('a', 1));
FUN_VALUE(str.find_last_not_of("ggg"));
FUN_VALUE(str.find_last_not_of("ggg", 14));
FUN_VALUE(str.find_last_not_of("abc", 3, 1));
FUN_VALUE(str.find_last_not_of(str3));
FUN_VALUE(str.find_last_not_of(str3, 2));
FUN_VALUE(str.count('a'));
FUN_VALUE(str.count('a', 2));
FUN_VALUE(str.count('d', 10));
STR_FUN_AFTER(str, str.swap(str3));
FUN_VALUE(str.size());
FUN_VALUE(str.length());
FUN_VALUE(str.capacity());
STR_FUN_AFTER(str, str += str);
STR_FUN_AFTER(str, str += 'a');
STR_FUN_AFTER(str, str += "bc");
FUN_VALUE(str.size());
FUN_VALUE(str.length());
FUN_VALUE(str.capacity());
STR_FUN_AFTER(str, str.shrink_to_fit());
FUN_VALUE(str.capacity());
STR_FUN_AFTER(str, str.reserve(50));
FUN_VALUE(str.capacity());
STR_FUN_AFTER(str3, str3 = "test");
STR_FUN_AFTER(str4, str4 = " ok!");
std::cout << " str3 + '!' : " << str3 + '!' << std::endl;
std::cout << " '#' + str3 : " << '#' + str3 << std::endl;
std::cout << " str3 + \" success\" : " << str3 + " success" << std::endl;
std::cout << " \"My \" + str3 : " << "My " + str3 << std::endl;
std::cout << " str3 + str4 : " << str3 + str4 << std::endl;
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| append |";
#if LARGER_TEST_DATA_ON
CON_TEST_P1(string, append, "s", SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3));
#else
CON_TEST_P1(string, append, "s", SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[----------------- End container test : string -----------------]" << std::endl;
}
} // namespace string_test
} // namespace test
} // namespace mystl
#endif // !MYTINYSTL_STRING_TEST_H_
``` | /content/code_sandbox/Test/string_test.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 2,231 |
```objective-c
#ifndef MYTINYSTL_LIST_TEST_H_
#define MYTINYSTL_LIST_TEST_H_
// list test : list insert, sort
#include <list>
#include "../MyTinySTL/list.h"
#include "test.h"
namespace mystl
{
namespace test
{
namespace list_test
{
//
bool is_odd(int x) { return x & 1; }
void list_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[------------------ Run container test : list ------------------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
int a[] = { 1,2,3,4,5 };
mystl::list<int> l1;
mystl::list<int> l2(5);
mystl::list<int> l3(5, 1);
mystl::list<int> l4(a, a + 5);
mystl::list<int> l5(l2);
mystl::list<int> l6(std::move(l2));
mystl::list<int> l7{ 1,2,3,4,5,6,7,8,9 };
mystl::list<int> l8;
l8 = l3;
mystl::list<int> l9;
l9 = std::move(l3);
mystl::list<int> l10;
l10 = { 1, 2, 2, 3, 5, 6, 7, 8, 9 };
FUN_AFTER(l1, l1.assign(8, 8));
FUN_AFTER(l1, l1.assign(a, a + 5));
FUN_AFTER(l1, l1.assign({ 1,2,3,4,5,6 }));
FUN_AFTER(l1, l1.insert(l1.end(), 6));
FUN_AFTER(l1, l1.insert(l1.end(), 2, 7));
FUN_AFTER(l1, l1.insert(l1.begin(), a, a + 5));
FUN_AFTER(l1, l1.push_back(2));
FUN_AFTER(l1, l1.push_front(1));
FUN_AFTER(l1, l1.emplace(l1.begin(),1));
FUN_AFTER(l1, l1.emplace_front(0));
FUN_AFTER(l1, l1.emplace_back(10));
FUN_VALUE(l1.size());
FUN_AFTER(l1, l1.pop_front());
FUN_AFTER(l1, l1.pop_back());
FUN_AFTER(l1, l1.erase(l1.begin()));
FUN_AFTER(l1, l1.erase(l1.begin(), l1.end()));
FUN_VALUE(l1.size());
FUN_AFTER(l1, l1.resize(10));
FUN_AFTER(l1, l1.resize(5, 1));
FUN_AFTER(l1, l1.resize(8, 2));
FUN_VALUE(l1.size());
FUN_AFTER(l1, l1.splice(l1.end(), l4));
FUN_AFTER(l1, l1.splice(l1.begin(), l5, l5.begin()));
FUN_AFTER(l1, l1.splice(l1.end(), l6, l6.begin(), ++l6.begin()));
FUN_VALUE(l1.size());
FUN_AFTER(l1, l1.remove(0));
FUN_AFTER(l1, l1.remove_if(is_odd));
FUN_VALUE(l1.size());
FUN_AFTER(l1, l1.assign({ 9,5,3,3,7,1,3,2,2,0,10 }));
FUN_VALUE(l1.size());
FUN_AFTER(l1, l1.sort());
FUN_AFTER(l1, l1.unique());
FUN_AFTER(l1, l1.unique([&](int a, int b) {return b == a + 1; }));
FUN_AFTER(l1, l1.merge(l7));
FUN_AFTER(l1, l1.sort(mystl::greater<int>()));
FUN_AFTER(l1, l1.merge(l8, mystl::greater<int>()));
FUN_AFTER(l1, l1.reverse());
FUN_AFTER(l1, l1.clear());
FUN_AFTER(l1, l1.swap(l9));
FUN_VALUE(*l1.begin());
FUN_VALUE(*l1.rbegin());
FUN_VALUE(l1.front());
FUN_VALUE(l1.back());
std::cout << std::boolalpha;
FUN_VALUE(l1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(l1.size());
FUN_VALUE(l1.max_size());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| insert |";
#if LARGER_TEST_DATA_ON
CON_TEST_P2(list<int>, insert, end, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3));
#else
CON_TEST_P2(list<int>, insert, end, rand(), SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| sort |";
#if LARGER_TEST_DATA_ON
LIST_SORT_TEST(SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3));
#else
LIST_SORT_TEST(SCALE_S(LEN1), SCALE_S(LEN2), SCALE_S(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[------------------ End container test : list ------------------]" << std::endl;
}
} // namespace list_test
} // namespace test
} // namespace mystl
#endif // !MYTINYSTL_LIST_TEST_H_
``` | /content/code_sandbox/Test/list_test.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 1,291 |
```objective-c
#ifndef MYTINYSTL_ALGORITHM_TEST_H_
#define MYTINYSTL_ALGORITHM_TEST_H_
// : mystl 81
#include <algorithm>
#include <functional>
#include <numeric>
#include "../MyTinySTL/algorithm.h"
#include "../MyTinySTL/vector.h"
#include "test.h"
namespace mystl
{
namespace test
{
#ifdef max
#pragma message("#undefing marco max")
#undef max
#endif // max
#ifdef min
#pragma message("#undefing marco min")
#undef min
#endif // min
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4389)
#endif // _MSC_VER
namespace algorithm_test
{
//
int for_each_sum = 0;
int gen() { return 5; }
int r(int i) { return (i * 5 + 1) % 9; }
bool is_odd(int i) { return i & 1; }
bool is_even(int i) { return !(i & 1); }
void arr_sum(int i) { for_each_sum += i; }
bool cmp(const int& a, const int& b) { return b < a; }
int unary_op(const int& x) { return x + 1; }
int binary_op(const int& x, const int& y) { return x + y; }
// 80
// algobase test:
TEST(copy_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int exp[5], act[5];
std::copy(arr1, arr1 + 5, exp);
mystl::copy(arr1, arr1 + 5, act);
EXPECT_CON_EQ(exp, act);
std::copy(arr1 + 5, arr1 + 10, exp);
mystl::copy(arr1 + 5, arr1 + 10, act);
EXPECT_CON_EQ(exp, act);
}
TEST(copy_backward_test)
{
int arr1[] = { 1,2,3,4,5 };
std::vector<int> exp{ 0,0,0,0,0,6,7,8,9,10 };
int act[] = { 0,0,0,0,0,6,7,8,9,10 };
std::copy_backward(arr1, arr1 + 5, exp.begin() + 5);
mystl::copy_backward(arr1, arr1 + 5, act + 5);
EXPECT_CON_EQ(exp, act);
std::copy_backward(exp.begin(), exp.begin() + 8, exp.begin() + 9);
mystl::copy_backward(act, act + 8, act + 9);
EXPECT_CON_EQ(exp, act);
}
TEST(copy_if_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int exp[5], act[5];
std::copy_if(arr1, arr1 + 10, exp, is_odd);
mystl::copy_if(arr1, arr1 + 10, act, is_odd);
EXPECT_CON_EQ(exp, act);
std::copy_if(arr1, arr1 + 10, exp, is_even);
mystl::copy_if(arr1, arr1 + 10, act, is_even);
EXPECT_CON_EQ(exp, act);
}
TEST(copy_n_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int exp[10], act[10];
std::copy_n(arr1, 10, exp);
mystl::copy_n(arr1, 10, act);
EXPECT_CON_EQ(exp, act);
std::copy_n(arr1 + 5, 5, exp);
mystl::copy_n(arr1 + 5, 5, act);
EXPECT_CON_EQ(exp, act);
}
TEST(move_test)
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,2,3,4,5 };
int exp[5], act[5];
std::move(arr1, arr1 + 5, exp);
mystl::move(arr2, arr2 + 5, act);
EXPECT_CON_EQ(exp, act);
EXPECT_CON_EQ(arr1, arr2);
}
TEST(move_backward_test)
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,2,3,4,5 };
int exp[5], act[5];
std::move_backward(arr1, arr1 + 5, exp + 5);
mystl::move_backward(arr2, arr2 + 5, act + 5);
EXPECT_CON_EQ(exp, act);
EXPECT_CON_EQ(arr1, arr2);
}
TEST(equal_test)
{
std::vector<int> v1{ 1,2,3,4,5 };
std::vector<int> v2{ 1,2,3,4,5,6 };
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,2,3,4,6 };
EXPECT_EQ(std::equal(v1.begin(), v1.end(), v2.begin()),
mystl::equal(v1.begin(), v1.end(), v2.begin()));
EXPECT_EQ(std::equal(arr1, arr1 + 5, arr2),
mystl::equal(arr1, arr1 + 5, arr2));
EXPECT_EQ(std::equal(v1.begin(), v1.end(), arr1),
mystl::equal(v1.begin(), v1.end(), arr1));
EXPECT_EQ(std::equal(v1.begin(), v1.end(), arr2, std::equal_to<int>()),
mystl::equal(v1.begin(), v1.end(), arr2, std::equal_to<int>()));
}
TEST(fill_test)
{
int exp[10], act[10];
mystl::vector<int> v1(10, 1);
mystl::vector<int> v2(10, 2);
std::fill(exp, exp + 10, 1);
mystl::fill(act, act + 10, 1);
EXPECT_CON_EQ(exp, act);
std::fill(v1.begin(), v1.end(), 3);
mystl::fill(v2.begin(), v2.end(), 3);
EXPECT_CON_EQ(v1, v2);
}
TEST(fill_n_test)
{
int arr1[5];
int arr2[5];
std::fill_n(arr2, 5, 1);
mystl::fill_n(arr1, 5, 1);
EXPECT_CON_EQ(arr1, arr2);
std::fill_n(arr1 + 2, 3, 2);
mystl::fill_n(arr2 + 2, 3, 2);
EXPECT_CON_EQ(arr1, arr2);
}
TEST(iter_swap_test)
{
int a = 1;
int b = 2;
int *p1 = &a;
int *p2 = &b;
int *p3 = &a;
int *p4 = &b;
std::iter_swap(p1, p2);
mystl::iter_swap(p3, p4);
EXPECT_PTR_EQ(p1, p3);
EXPECT_PTR_EQ(p2, p4);
EXPECT_EQ(p1, p3);
EXPECT_EQ(p2, p4);
}
TEST(lexicographical_compare_test)
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 0,2,4,6,8 };
int arr3[] = { 1,2,3,4,5 };
int arr4[] = { 1,2,3,4,5,6 };
int arr5[] = { 2,3,4 };
EXPECT_EQ(std::lexicographical_compare(arr1, arr1 + 5, arr2, arr2 + 5),
mystl::lexicographical_compare(arr1, arr1 + 5, arr2, arr2 + 5));
EXPECT_EQ(std::lexicographical_compare(arr1, arr1 + 5, arr3, arr3 + 5),
mystl::lexicographical_compare(arr1, arr1 + 5, arr3, arr3 + 5));
EXPECT_EQ(std::lexicographical_compare(arr1, arr1 + 5, arr4, arr4 + 6, std::less<int>()),
mystl::lexicographical_compare(arr1, arr1 + 5, arr4, arr4 + 6, std::less<int>()));
EXPECT_EQ(std::lexicographical_compare(arr1, arr1 + 5, arr5, arr5 + 3, std::less<int>()),
mystl::lexicographical_compare(arr1, arr1 + 5, arr5, arr5 + 3, std::less<int>()));
}
TEST(max_test)
{
int i1 = 1, i2 = 2;
double d1 = 1.1, d2 = 2.2;
char c1 = 'a', c2 = 'b';
EXPECT_EQ(std::max(i1, i2), mystl::max(i1, i2));
EXPECT_EQ(std::max(d1, d2), mystl::max(d1, d2));
EXPECT_EQ(std::max(c1, c2), mystl::max(c1, c2));
}
TEST(min_test)
{
int i1 = 1, i2 = 2;
double d1 = 1.1, d2 = 2.2;
char c1 = 'a', c2 = 'b';
EXPECT_EQ(std::min(i1, i2), mystl::min(i1, i2));
EXPECT_EQ(std::min(d1, d2), mystl::min(d1, d2));
EXPECT_EQ(std::min(c1, c2), mystl::min(c1, c2));
}
TEST(mismatch_test)
{
int arr1[] = { 1,1,2,2,3,4,5 };
int arr2[] = { 1,1,2,2,3,3,3 };
int arr3[] = { 0,1,2,2,3,4,5 };
int arr4[] = { 1,1,2,2,3,4,5 };
auto p1 = std::mismatch(arr1, arr1 + 7, arr2);
auto p2 = mystl::mismatch(arr1, arr1 + 7, arr2);
auto p3 = std::mismatch(arr1, arr1 + 7, arr3);
auto p4 = mystl::mismatch(arr1, arr1 + 7, arr3);
auto p5 = std::mismatch(arr1, arr1 + 7, arr4, std::equal_to<int>());
auto p6 = mystl::mismatch(arr1, arr1 + 7, arr4, std::equal_to<int>());
EXPECT_EQ(p1.first, p2.first);
EXPECT_EQ(p1.second, p2.second);
EXPECT_EQ(p3.first, p4.first);
EXPECT_EQ(p3.second, p4.second);
EXPECT_EQ(p5.first, p6.first);
EXPECT_EQ(p5.second, p6.second);
}
// heap_algo test
TEST(make_heap_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[] = { 1,2,3,4,5,6,7,8,9 };
int arr3[] = { 2,1,6,5,4,9,8,7,6 };
int arr4[] = { 2,1,6,5,4,9,8,7,6 };
int arr5[] = { 1,1,2,2,3,3,4,4,5,5 };
int arr6[] = { 1,1,2,2,3,3,4,4,5,5 };
std::make_heap(arr1, arr1 + 9);
mystl::make_heap(arr2, arr2 + 9);
std::make_heap(arr3, arr3 + 9);
mystl::make_heap(arr4, arr4 + 9);
std::make_heap(arr5, arr5 + 10, std::greater<int>());
mystl::make_heap(arr6, arr6 + 10, std::greater<int>());
EXPECT_CON_EQ(arr1, arr2);
EXPECT_CON_EQ(arr3, arr4);
EXPECT_CON_EQ(arr5, arr6);
}
TEST(pop_heap_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[] = { 1,2,3,4,5,6,7,8,9 };
std::make_heap(arr1, arr1 + 9);
std::make_heap(arr2, arr2 + 9);
for (int i = 9; i > 0; --i)
{
std::pop_heap(arr1, arr1 + i);
mystl::pop_heap(arr2, arr2 + i);
EXPECT_CON_EQ(arr1, arr2);
}
int arr3[] = { 1,2,3,4,5,6,7,8,9 };
int arr4[] = { 1,2,3,4,5,6,7,8,9 };
std::make_heap(arr3, arr3 + 9, std::greater<int>());
std::make_heap(arr4, arr4 + 9, std::greater<int>());
std::pop_heap(arr3, arr3 + 9, std::greater<int>());
mystl::pop_heap(arr4, arr4 + 9, std::greater<int>());
EXPECT_CON_EQ(arr3, arr4);
}
TEST(push_heap_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[] = { 1,2,3,4,5,6,7,8,9 };
std::make_heap(arr1, arr1 + 4);
std::make_heap(arr2, arr2 + 4);
for (int i = 4; i <= 9; ++i)
{
std::push_heap(arr1, arr1 + i);
mystl::push_heap(arr2, arr2 + i);
EXPECT_CON_EQ(arr1, arr2);
}
int arr3[] = { 1,2,3,4,5,6,7,8,9 };
int arr4[] = { 1,2,3,4,5,6,7,8,9 };
std::make_heap(arr3, arr3 + 9, std::greater<int>());
std::make_heap(arr4, arr4 + 9, std::greater<int>());
std::push_heap(arr3, arr3 + 9, std::greater<int>());
mystl::push_heap(arr4, arr4 + 9, std::greater<int>());
EXPECT_CON_EQ(arr3, arr4);
}
TEST(sort_heap_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[] = { 1,2,3,4,5,6,7,8,9 };
int arr3[] = { 1,2,3,4,5,6,7,8,9 };
int arr4[] = { 1,2,3,4,5,6,7,8,9 };
std::make_heap(arr1, arr1 + 9);
std::make_heap(arr2, arr2 + 9);
std::make_heap(arr3, arr3 + 9, std::greater<int>());
std::make_heap(arr4, arr4 + 9, std::greater<int>());
std::sort_heap(arr1, arr1 + 9);
mystl::sort_heap(arr2, arr2 + 9);
std::sort_heap(arr3, arr3 + 9, std::greater<int>());
mystl::sort_heap(arr4, arr4 + 9, std::greater<int>());
EXPECT_CON_EQ(arr1, arr2);
EXPECT_CON_EQ(arr3, arr4);
}
// set_algo test
TEST(set_difference_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[] = { 1,2,3,4,5,6 };
int arr3[] = { 1,2,3 };
int exp[6] = { 0 }, act[6] = { 0 };
std::set_difference(arr1, arr1 + 9, arr2, arr2 + 6, exp);
mystl::set_difference(arr1, arr1 + 9, arr2, arr2 + 6, act);
EXPECT_CON_EQ(exp, act);
std::set_difference(arr2, arr2 + 6, arr3, arr3 + 3, exp);
mystl::set_difference(arr2, arr2 + 6, arr3, arr3 + 3, act);
EXPECT_CON_EQ(exp, act);
std::set_difference(arr1, arr1 + 9, arr3, arr3 + 3, exp, std::less<int>());
mystl::set_difference(arr1, arr1 + 9, arr3, arr3 + 3, act, std::less<int>());
EXPECT_CON_EQ(exp, act);
}
TEST(set_intersection_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[] = { 1,2,3,4,5,6 };
int arr3[] = { 1,2,3 };
int exp[9] = { 0 }, act[9] = { 0 };
std::set_intersection(arr1, arr1 + 9, arr2, arr2 + 6, exp);
mystl::set_intersection(arr1, arr1 + 9, arr2, arr2 + 6, act);
EXPECT_CON_EQ(exp, act);
std::set_intersection(arr2, arr2 + 6, arr3, arr3 + 3, exp);
mystl::set_intersection(arr2, arr2 + 6, arr3, arr3 + 3, act);
EXPECT_CON_EQ(exp, act);
std::set_intersection(arr1, arr1 + 9, arr3, arr3 + 3, exp, std::less<int>());
mystl::set_intersection(arr1, arr1 + 9, arr3, arr3 + 3, act, std::less<int>());
EXPECT_CON_EQ(exp, act);
}
TEST(set_symmetric_difference_test)
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,3,5,7,9 };
int arr3[] = { 2,4,6,8,10 };
int exp[10] = { 0 }, act[10] = { 0 };
std::set_symmetric_difference(arr1, arr1 + 5, arr2, arr2 + 5, exp);
mystl::set_symmetric_difference(arr1, arr1 + 5, arr2, arr2 + 5, act);
EXPECT_CON_EQ(exp, act);
std::set_symmetric_difference(arr1, arr1 + 5, arr3, arr3 + 5, exp);
mystl::set_symmetric_difference(arr1, arr1 + 5, arr3, arr3 + 5, act);
EXPECT_CON_EQ(exp, act);
std::set_symmetric_difference(arr2, arr2 + 5, arr3, arr3 + 5, exp, std::less<int>());
mystl::set_symmetric_difference(arr2, arr2 + 5, arr3, arr3 + 5, act, std::less<int>());
EXPECT_CON_EQ(exp, act);
}
TEST(set_union_test)
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,3,5,7,9 };
int arr3[] = { 2,4,6,8,10 };
int exp[10] = { 0 }, act[10] = { 0 };
std::set_union(arr1, arr1 + 5, arr2, arr2 + 5, exp);
mystl::set_union(arr1, arr1 + 5, arr2, arr2 + 5, act);
EXPECT_CON_EQ(exp, act);
std::set_union(arr1, arr1 + 5, arr3, arr3 + 5, exp);
mystl::set_union(arr1, arr1 + 5, arr3, arr3 + 5, act);
EXPECT_CON_EQ(exp, act);
std::set_union(arr2, arr2 + 5, arr3, arr3 + 5, exp, std::less<int>());
mystl::set_union(arr2, arr2 + 5, arr3, arr3 + 5, act, std::less<int>());
EXPECT_CON_EQ(exp, act);
}
// numeric test
TEST(accumulate_test)
{
int arr1[] = { 1,2,3,4,5 };
EXPECT_EQ(std::accumulate(arr1, arr1 + 5, 0),
mystl::accumulate(arr1, arr1 + 5, 0));
EXPECT_EQ(std::accumulate(arr1, arr1 + 5, 5),
mystl::accumulate(arr1, arr1 + 5, 5));
EXPECT_EQ(std::accumulate(arr1, arr1 + 5, 0, std::minus<int>()),
mystl::accumulate(arr1, arr1 + 5, 0, std::minus<int>()));
}
TEST(adjacent_difference_test)
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,1,1,1,1 };
int exp[5], act[5];
std::adjacent_difference(arr1, arr1 + 5, exp);
mystl::adjacent_difference(arr1, arr1 + 5, act);
EXPECT_CON_EQ(exp, act);
std::adjacent_difference(arr2, arr2 + 5, exp, std::minus<int>());
mystl::adjacent_difference(arr2, arr2 + 5, act, std::minus<int>());
EXPECT_CON_EQ(exp, act);
}
TEST(inner_product_test)
{
int arr1[] = { 1,1,1,1,1 };
int arr2[] = { 2,2,2,2,2 };
int arr3[] = { 1,2,3,4,5 };
EXPECT_EQ(std::inner_product(arr1, arr1 + 5, arr3, 0),
mystl::inner_product(arr1, arr1 + 5, arr3, 0));
EXPECT_EQ(std::inner_product(arr2, arr2 + 5, arr3, 0, std::minus<int>(), std::multiplies<int>()),
mystl::inner_product(arr2, arr2 + 5, arr3, 0, std::minus<int>(), std::multiplies<int>()));
}
TEST(iota_test)
{
int arr1[10];
int arr2[10];
std::iota(arr1, arr1 + 10, 1);
mystl::iota(arr2, arr2 + 10, 1);
EXPECT_CON_EQ(arr1, arr2);
std::iota(arr1, arr1 + 10, -1);
mystl::iota(arr2, arr2 + 10, -1);
EXPECT_CON_EQ(arr1, arr2);
}
TEST(partial_sum_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int exp1[5], act1[5];
int exp2[9], act2[9];
std::partial_sum(arr1, arr1 + 5, exp1);
mystl::partial_sum(arr1, arr1 + 5, act1);
std::partial_sum(arr1, arr1 + 9, exp2);
mystl::partial_sum(arr1, arr1 + 9, act2);
EXPECT_CON_EQ(exp1, act1);
EXPECT_CON_EQ(exp2, act2);
std::partial_sum(arr1, arr1 + 9, exp2, std::multiplies<int>());
mystl::partial_sum(arr1, arr1 + 9, act2, std::multiplies<int>());
EXPECT_CON_EQ(exp2, act2);
}
// algo test
TEST(adjacent_find_test)
{
int arr1[] = { 1,2,3,3,4 };
int arr2[] = { 1,2,3,4,5 };
EXPECT_EQ(std::adjacent_find(arr1, arr1 + 5),
mystl::adjacent_find(arr1, arr1 + 5));
EXPECT_EQ(std::adjacent_find(arr2, arr2 + 5),
mystl::adjacent_find(arr2, arr2 + 5));
EXPECT_EQ(std::adjacent_find(arr1, arr1 + 5, std::greater<int>()),
mystl::adjacent_find(arr1, arr1 + 5, std::greater<int>()));
}
TEST(all_of_test)
{
int arr1[] = { 1,3,5,7,9 };
int arr2[] = { 1,3,5,7,8 };
EXPECT_EQ(std::all_of(arr1, arr1 + 5, is_odd),
mystl::all_of(arr1, arr1 + 5, is_odd));
EXPECT_EQ(std::all_of(arr2, arr2 + 5, is_odd),
mystl::all_of(arr2, arr2 + 5, is_odd));
}
TEST(any_of_test)
{
int arr1[] = { 1,2,4,6,8 };
int arr2[] = { 2,4,6,8,10 };
EXPECT_EQ(std::any_of(arr1, arr1 + 5, is_odd),
mystl::any_of(arr1, arr1 + 5, is_odd));
EXPECT_EQ(std::any_of(arr2, arr2 + 5, is_odd),
mystl::any_of(arr2, arr2 + 5, is_odd));
}
TEST(binary_search_test)
{
int arr1[] = { 1,2,3,4,5 };
EXPECT_EQ(std::binary_search(arr1, arr1 + 5, 1),
mystl::binary_search(arr1, arr1 + 5, 1));
EXPECT_EQ(std::binary_search(arr1, arr1 + 5, 6),
mystl::binary_search(arr1, arr1 + 5, 6));
}
TEST(count_test)
{
int arr1[] = { 1,2,2,3,3,3,4,5,8 };
EXPECT_EQ(std::count(arr1, arr1 + 9, 2),
mystl::count(arr1, arr1 + 9, 2));
EXPECT_EQ(std::count(arr1, arr1 + 9, 3),
mystl::count(arr1, arr1 + 9, 3));
EXPECT_EQ(std::count(arr1, arr1 + 9, 6),
mystl::count(arr1, arr1 + 9, 6));
}
TEST(count_if_test)
{
int arr1[] = { 1,2,2,3,3,3,4,5,8 };
EXPECT_EQ(std::count_if(arr1, arr1 + 9, is_odd),
mystl::count_if(arr1, arr1 + 9, is_odd));
EXPECT_EQ(std::count_if(arr1, arr1 + 9, is_even),
mystl::count_if(arr1, arr1 + 9, is_even));
}
TEST(equal_range_test)
{
int arr1[] = { 1,2,3,3,3,4,5 };
auto p1 = mystl::equal_range(arr1, arr1 + 7, 3);
auto p2 = std::equal_range(arr1, arr1 + 7, 3);
auto p3 = mystl::equal_range(arr1, arr1 + 7, 6, std::equal_to<int>());
auto p4 = std::equal_range(arr1, arr1 + 7, 6, std::equal_to<int>());
EXPECT_EQ(p2.first, p1.first);
EXPECT_EQ(p2.second, p1.second);
EXPECT_EQ(p4.first, p3.first);
EXPECT_EQ(p4.second, p3.second);
}
TEST(find_test)
{
int arr1[] = { 1,2,3,4,5 };
EXPECT_EQ(std::find(arr1, arr1 + 5, 3), mystl::find(arr1, arr1 + 5, 3));
EXPECT_EQ(std::find(arr1, arr1 + 5, 6), mystl::find(arr1, arr1 + 5, 6));
}
TEST(find_end_test)
{
int arr1[] = { 1,2,3,2,2,3,4,5 };
int arr2[] = { 2,3 };
int arr3[] = { 4,5,6 };
EXPECT_EQ(std::find_end(arr1, arr1 + 8, arr2, arr2 + 1),
mystl::find_end(arr1, arr1 + 8, arr2, arr2 + 1));
EXPECT_EQ(std::find_end(arr1, arr1 + 8, arr3, arr3 + 2),
mystl::find_end(arr1, arr1 + 8, arr3, arr3 + 2));
EXPECT_EQ(std::find_end(arr1, arr1 + 8, arr3, arr3 + 2),
mystl::find_end(arr1, arr1 + 8, arr3, arr3 + 2));
EXPECT_EQ(std::find_end(arr1, arr1 + 8, arr3, arr3, std::less<int>()),
mystl::find_end(arr1, arr1 + 8, arr3, arr3, std::less<int>()));
}
TEST(find_first_of_test)
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 2,3,4 };
int arr3[] = { 6,7,8 };
EXPECT_EQ(std::find_first_of(arr1, arr1 + 5, arr2, arr2 + 3),
mystl::find_first_of(arr1, arr1 + 5, arr2, arr2 + 3));
EXPECT_EQ(std::find_first_of(arr1, arr1 + 5, arr3, arr3 + 3, std::equal_to<int>()),
mystl::find_first_of(arr1, arr1 + 5, arr3, arr3 + 3, std::equal_to<int>()));
}
TEST(find_if_test)
{
int arr1[] = { 1,2,3,4,5 };
EXPECT_EQ(std::find_if(arr1, arr1 + 5, is_odd),
mystl::find_if(arr1, arr1 + 5, is_odd));
EXPECT_EQ(std::find_if(arr1, arr1 + 5, is_even),
mystl::find_if(arr1, arr1 + 5, is_even));
}
TEST(find_if_not_test)
{
int arr1[] = { 1,2,3,4,5 };
EXPECT_EQ(std::find_if_not(arr1, arr1 + 5, is_odd),
mystl::find_if_not(arr1, arr1 + 5, is_odd));
EXPECT_EQ(std::find_if_not(arr1, arr1 + 5, is_even),
mystl::find_if_not(arr1, arr1 + 5, is_even));
}
TEST(for_each_test)
{
std::vector<int> v1{ 1,2,3,4,5 };
std::for_each(v1.begin(), v1.end(), arr_sum);
EXPECT_EQ(15, for_each_sum);
mystl::for_each(v1.begin(), v1.end(), arr_sum);
EXPECT_EQ(30, for_each_sum);
}
TEST(generate_test)
{
int arr1[5];
int arr2[5];
std::generate(arr1, arr1 + 5, gen);
mystl::generate(arr2, arr2 + 5, gen);
EXPECT_CON_EQ(arr1, arr2);
}
TEST(generate_n_test)
{
int arr1[] = { 1,1,1,1,1,6,7,8,9,10 };
int arr2[] = { 2,2,2,2,2,6,7,8,9,10 };
std::generate_n(arr1, 5, gen);
mystl::generate_n(arr2, 5, gen);
EXPECT_CON_EQ(arr1, arr2);
}
TEST(includes_test)
{
std::vector<int> v1{ 1,2,3,4,5,6,7,8,9 };
std::vector<int> v2{ 2,3,5,6,9 };
std::vector<int> v3{ 0,1,2,3,4 };
std::vector<int> v4{ 1,2,5,7,10 };
std::vector<int> v5;
EXPECT_EQ(std::includes(v1.begin(), v1.end(), v2.begin(), v2.end()),
mystl::includes(v1.begin(), v1.end(), v2.begin(), v2.end()));
EXPECT_EQ(std::includes(v1.begin(), v1.end(), v3.begin(), v3.end()),
mystl::includes(v1.begin(), v1.end(), v3.begin(), v3.end()));
EXPECT_EQ(std::includes(v1.begin(), v1.end(), v4.begin(), v4.end()),
mystl::includes(v1.begin(), v1.end(), v4.begin(), v4.end()));
EXPECT_EQ(std::includes(v1.begin(), v1.end(), v5.begin(), v5.end(), std::less<int>()),
mystl::includes(v1.begin(), v1.end(), v5.begin(), v5.end(), std::less<int>()));
}
TEST(inplace_merge_test)
{
int arr1[] = { 1,3,5,7,9,2,4,6,8,10 };
int arr2[] = { 1,3,5,7,9,2,4,6,8,10 };
int arr3[] = { 1,2,3,1,2,3,4,5 };
int arr4[] = { 1,2,3,1,2,3,4,5 };
std::inplace_merge(arr1, arr1 + 5, arr1 + 10);
mystl::inplace_merge(arr2, arr2 + 5, arr2 + 10);
std::inplace_merge(arr3, arr3 + 3, arr3 + 8, std::less<int>());
mystl::inplace_merge(arr4, arr4 + 3, arr4 + 8, std::less<int>());
EXPECT_CON_EQ(arr1, arr2);
EXPECT_CON_EQ(arr3, arr4);
}
TEST(is_heap_test)
{
int arr1[] = { 0,1,2,3,4,5,6,7,8,9 };
int arr2[] = { 9,8,7,6,5,4,3,2,1,0 };
int arr3[] = { 1,3,5,7,9,0,2,4,6,8 };
int arr4[] = { 0,1,2,3,4,5,6,7,8,9 };
std::make_heap(arr4, arr4 + 10);
EXPECT_EQ(std::is_heap(arr1, arr1 + 10), mystl::is_heap(arr1, arr1 + 10));
EXPECT_EQ(std::is_heap(arr2, arr2 + 10, std::less<int>()),
mystl::is_heap(arr2, arr2 + 10, std::less<int>()));
EXPECT_EQ(std::is_heap(arr3, arr3 + 10), mystl::is_heap(arr3, arr3 + 10));
EXPECT_EQ(std::is_heap(arr4, arr4 + 10), mystl::is_heap(arr4, arr4 + 10));
}
TEST(is_sorted_test)
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,2,3,5,4 };
int arr3[] = { 5,4,3,2,1 };
int arr4[] = { 1,2,5,4,3 };
EXPECT_EQ(std::is_sorted(arr1, arr1 + 5), mystl::is_sorted(arr1, arr1 + 5));
EXPECT_EQ(std::is_sorted(arr2, arr2 + 5), mystl::is_sorted(arr2, arr2 + 5));
EXPECT_EQ(std::is_sorted(arr3, arr3 + 5, std::less<int>()),
mystl::is_sorted(arr3, arr3 + 5, std::less<int>()));
EXPECT_EQ(std::is_sorted(arr4, arr4 + 5, std::less<int>()),
mystl::is_sorted(arr4, arr4 + 5, std::less<int>()));
}
TEST(lower_bound_test)
{
int arr1[] = { 1,2,3,3,3,4,5 };
EXPECT_EQ(std::lower_bound(arr1, arr1 + 7, 1),
mystl::lower_bound(arr1, arr1 + 7, 1));
EXPECT_EQ(std::lower_bound(arr1, arr1 + 7, 2),
mystl::lower_bound(arr1, arr1 + 7, 2));
EXPECT_EQ(std::lower_bound(arr1, arr1 + 7, 3),
mystl::lower_bound(arr1, arr1 + 7, 3));
EXPECT_EQ(std::lower_bound(arr1, arr1 + 7, 5, std::less<int>()),
mystl::lower_bound(arr1, arr1 + 7, 5, std::less<int>()));
}
TEST(max_elememt_test)
{
int arr1[] = { 1,2,3,4,5,4,3,2,1 };
double arr2[] = { 1.0,2.2,6.6,8.8,8.81,2.4 };
EXPECT_PTR_EQ(std::max_element(arr1, arr1 + 9),
mystl::max_element(arr1, arr1 + 9));
EXPECT_PTR_EQ(std::max_element(arr2, arr2 + 6, std::less<double>()),
mystl::max_element(arr2, arr2 + 6, std::less<double>()));
}
TEST(median_test)
{
int ia = 2, ib = 1, ic = 3;
double da = 3.1, db = 3.0, dc = 3.2;
EXPECT_EQ(2, mystl::median(ia, ib, ic));
EXPECT_EQ(3.1, mystl::median(da, db, dc, std::greater<double>()));
}
TEST(merge_test)
{
int arr1[] = { 1,2,5,9,10 };
int arr2[] = { 3,7,8,8,9 };
int arr3[] = { 1,2,5,9,10 };
int arr4[] = { 3,7,8,8,9 };
int exp[10], act[10];
std::merge(arr1, arr1 + 5, arr2, arr2 + 5, exp);
mystl::merge(arr3, arr3 + 5, arr4, arr4 + 5, act);
EXPECT_CON_EQ(exp, act);
std::merge(arr1, arr1 + 5, arr2, arr2 + 5, exp, std::less<int>());
mystl::merge(arr3, arr3 + 5, arr4, arr4 + 5, act, std::less<int>());
EXPECT_CON_EQ(exp, act);
}
TEST(min_elememt_test)
{
int arr1[] = { 2,4,8,1,6,5,8,9,3 };
double arr2[] = { 1.5,2.2,1.4,1.33,1.333,2.33 };
EXPECT_PTR_EQ(std::max_element(arr1, arr1 + 9),
mystl::max_element(arr1, arr1 + 9));
EXPECT_PTR_EQ(std::max_element(arr2, arr2 + 6, std::less<double>()),
mystl::max_element(arr2, arr2 + 6, std::less<double>()));
}
TEST(is_permutation_test)
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 3,4,5,2,1 };
int arr3[] = { 1,2,3,4,6 };
// C++11 std::is_permutation C++14
EXPECT_EQ(std::is_permutation(arr1, arr1 + 5, arr2),
mystl::is_permutation(arr1, arr1 + 5, arr2, arr2 + 5));
EXPECT_EQ(std::is_permutation(arr1, arr1 + 5, arr3),
mystl::is_permutation(arr1, arr1 + 5, arr3, arr3 + 5));
EXPECT_EQ(std::is_permutation(arr1, arr1 + 5, arr2, std::equal_to<int>()),
mystl::is_permutation(arr1, arr1 + 5, arr2, arr2 + 5, std::equal_to<int>()));
EXPECT_EQ(std::is_permutation(arr1, arr1 + 5, arr3, std::equal_to<int>()),
mystl::is_permutation(arr1, arr1 + 5, arr3, arr3 + 5, std::equal_to<int>()));
}
TEST(next_permutation_test)
{
int arr1[] = { 1,2,3,3 };
int arr2[] = { 1,2,3,3 };
int n1 = 0, n2 = 0;
while (std::next_permutation(arr1, arr1 + 4)) n1++;
while (mystl::next_permutation(arr1, arr1 + 4)) n2++;
EXPECT_EQ(n1, n2);
for (; n1 > 0; n1--)
{
std::next_permutation(arr1, arr1 + 4);
mystl::next_permutation(arr2, arr2 + 4);
EXPECT_CON_EQ(arr1, arr2);
}
std::next_permutation(arr1, arr1 + 4, std::greater<int>());
mystl::next_permutation(arr2, arr2 + 4, std::greater<int>());
EXPECT_CON_EQ(arr1, arr2);
}
TEST(none_of_test)
{
int arr1[] = { 1,3,5,7,9 };
int arr2[] = { 1,3,5,7,8 };
int arr3[] = { 2,4,6,8,10 };
EXPECT_EQ(std::none_of(arr1, arr1 + 5, is_even),
mystl::none_of(arr1, arr1 + 5, is_even));
EXPECT_EQ(std::none_of(arr2, arr2 + 5, is_even),
mystl::none_of(arr2, arr2 + 5, is_even));
EXPECT_EQ(std::none_of(arr3, arr3 + 5, is_even),
mystl::none_of(arr3, arr3 + 5, is_even));
}
TEST(nth_element_test)
{
int arr1[] = { 9,8,7,6,5,4,3,2,1 };
int arr2[] = { 1,2,3,4,5,6,3,2,1 };
int arr3[] = { 1,2,8,9,6,5,3,4,7 };
int arr4[] = { 1,5,1,5,8,4,9,6,8,4,10,13,20,4,2,1 };
mystl::nth_element(arr1, arr1 + 4, arr1 + 9);
mystl::nth_element(arr2, arr2 + 2, arr2 + 9);
mystl::nth_element(arr3, arr3 + 8, arr3 + 9, std::less<int>());
mystl::nth_element(arr4, arr4 + 3, arr4 + 16, std::less<int>());
bool arr1_left_less = true, arr1_right_greater = true;
bool arr2_left_less = true, arr2_right_greater = true;
bool arr3_left_less = true, arr3_right_greater = true;
bool arr4_left_less = true, arr4_right_greater = true;
for (int i = 0; i < 9; ++i)
{
if (i < 4 && arr1[i] > arr1[4]) arr1_left_less = false;
else if (i > 4 && arr1[i] < arr1[4]) arr1_right_greater = false;
}
for (int i = 0; i < 9; ++i)
{
if (i < 2 && arr2[i] > arr2[2]) arr2_left_less = false;
else if (i > 2 && arr2[i] < arr2[2]) arr2_right_greater = false;
}
for (int i = 0; i < 9; ++i)
{
if (i < 8 && arr3[i] > arr3[8]) arr3_left_less = false;
}
for (int i = 0; i < 16; ++i)
{
if (i < 3 && arr4[i] > arr4[3]) arr4_left_less = false;
else if (i > 3 && arr4[i] < arr4[3]) arr4_right_greater = false;
}
EXPECT_TRUE(arr1_left_less);
EXPECT_TRUE(arr1_right_greater);
EXPECT_TRUE(arr2_left_less);
EXPECT_TRUE(arr2_right_greater);
EXPECT_TRUE(arr3_left_less);
EXPECT_TRUE(arr3_right_greater);
EXPECT_TRUE(arr4_left_less);
EXPECT_TRUE(arr4_right_greater);
}
TEST(partial_sort_test)
{
int arr1[] = { 3,2,1,9,8,7,6,5,4 };
int arr2[] = { 3,2,1,9,8,7,6,5,4 };
int arr3[] = { 5,1,5,8,6,4,8,4,1,3,5,8,4 };
int arr4[] = { 5,1,5,8,6,4,8,4,1,3,5,8,4 };
std::partial_sort(arr1, arr1 + 2, arr1 + 9);
mystl::partial_sort(arr2, arr2 + 2, arr2 + 9);
std::partial_sort(arr3, arr3 + 5, arr3 + 13, std::greater<int>());
mystl::partial_sort(arr4, arr4 + 5, arr4 + 13, std::greater<int>());
EXPECT_CON_EQ(arr1, arr2);
EXPECT_CON_EQ(arr3, arr4);
}
TEST(partial_sort_copy_test)
{
int arr1[] = { 3,2,1,9,8,7,6,5,4 };
int arr2[] = { 1,2,3,4,5,6,7,8,9 };
int arr3[] = { 1,6,8,4,2,1,6,8,4,7,6,2,1,3,6 };
int exp[5], act[5];
std::partial_sort_copy(arr1, arr1 + 9, exp, exp + 5);
mystl::partial_sort_copy(arr1, arr1 + 9, act, act + 5);
EXPECT_CON_EQ(exp, act);
std::partial_sort_copy(arr2, arr2 + 9, exp, exp + 5);
mystl::partial_sort_copy(arr2, arr2 + 9, act, act + 5);
EXPECT_CON_EQ(exp, act);
std::partial_sort_copy(arr3, arr3 + 15, exp, exp + 5, std::greater<int>());
mystl::partial_sort_copy(arr3, arr3 + 15, act, act + 5, std::greater<int>());
EXPECT_CON_EQ(exp, act);
}
TEST(partition_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[] = { 1,2,3,4,5,6,7,8,9 };
std::partition(arr1, arr1 + 9, is_odd);
mystl::partition(arr2, arr2 + 9, is_odd);
EXPECT_CON_EQ(arr1, arr2);
std::partition(arr1, arr1 + 9, is_even);
mystl::partition(arr2, arr2 + 9, is_even);
EXPECT_CON_EQ(arr1, arr2);
}
TEST(partition_copy_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int exp_true[5], exp_false[5];
int act_true[5], act_false[5];
std::partition_copy(arr1, arr1 + 10, exp_true, exp_false, is_odd);
mystl::partition_copy(arr1, arr1 + 10, act_true, act_false, is_odd);
EXPECT_CON_EQ(exp_true, act_true);
EXPECT_CON_EQ(exp_false, act_false);
}
TEST(prev_permutation_test)
{
int arr1[] = { 3,2,1,1 };
int arr2[] = { 3,2,1,1 };
int n1 = 0, n2 = 0;
while (std::prev_permutation(arr1, arr1 + 4)) n1++;
while (mystl::prev_permutation(arr1, arr1 + 4)) n2++;
EXPECT_EQ(n1, n2);
for (; n1 > 0; n1--)
{
std::prev_permutation(arr1, arr1 + 4);
mystl::prev_permutation(arr2, arr2 + 4);
EXPECT_CON_EQ(arr1, arr2);
}
std::prev_permutation(arr1, arr1 + 4, std::greater<int>());
mystl::prev_permutation(arr2, arr2 + 4, std::greater<int>());
EXPECT_CON_EQ(arr1, arr2);
}
TEST(random_shuffle_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[9];
for (int i = 0; i < 9; ++i)
{
std::copy(arr1, arr1 + 9, arr2);
mystl::random_shuffle(arr1, arr1 + 9);
EXPECT_CON_NE(arr1, arr2);
}
std::copy(arr1, arr1 + 9, arr2);
mystl::random_shuffle(arr1, arr1 + 9, r);
EXPECT_CON_NE(arr1, arr2);
}
TEST(remove_test)
{
std::vector<int> v1{ 1,2,3,4,5,6,6,6 };
std::vector<int> v2(v1);
std::remove(v1.begin(), v1.end(), 3);
mystl::remove(v2.begin(), v2.end(), 3);
EXPECT_CON_EQ(v1, v2);
std::remove(v1.begin(), v1.end(), 6);
mystl::remove(v2.begin(), v2.end(), 6);
EXPECT_CON_EQ(v1, v2);
}
TEST(remove_copy_test)
{
int arr1[] = { 1,2,3,4,5,6,6,6 };
int arr2[] = { 1,2,3,4,5,6,6,6 };
int exp[5], act[5];
std::remove_copy(arr1, arr1 + 8, exp, 6);
mystl::remove_copy(arr2, arr2 + 8, act, 6);
EXPECT_CON_EQ(exp, act);
std::remove_copy(arr1, arr1 + 5, exp, 3);
mystl::remove_copy(arr2, arr2 + 5, act, 3);
EXPECT_CON_EQ(exp, act);
}
TEST(remove_copy_if_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int exp[5], act[5];
std::remove_copy_if(arr1, arr1 + 10, exp, is_odd);
mystl::remove_copy_if(arr1, arr1 + 10, act, is_odd);
EXPECT_CON_EQ(exp, act);
std::remove_copy_if(arr1, arr1 + 10, exp, is_even);
mystl::remove_copy_if(arr1, arr1 + 10, act, is_even);
EXPECT_CON_EQ(exp, act);
}
TEST(remove_if_test)
{
std::vector<int> v1{ 1,2,3,4,5,6,7,8,9,10 };
std::vector<int> v2(v1);
std::remove_if(v1.begin(), v1.end(), is_odd);
mystl::remove_if(v2.begin(), v2.end(), is_odd);
EXPECT_CON_EQ(v1, v2);
}
TEST(replace_test)
{
int arr1[] = { 1,1,1,2,2,2,3,3,3 };
int arr2[] = { 1,1,1,2,2,2,3,3,3 };
std::replace(arr1, arr1 + 9, 1, 4);
mystl::replace(arr2, arr2 + 9, 1, 4);
EXPECT_CON_EQ(arr1, arr2);
std::replace(arr1, arr1 + 9, 2, 5);
mystl::replace(arr2, arr2 + 9, 2, 5);
EXPECT_CON_EQ(arr1, arr2);
std::replace(arr1, arr1 + 9, 3, 6);
mystl::replace(arr2, arr2 + 9, 3, 6);
EXPECT_CON_EQ(arr1, arr2);
}
TEST(replace_copy_test)
{
int arr1[] = { 1,1,1,2,2,2,3,3,3 };
int exp[9], act[9];
std::replace_copy(arr1, arr1 + 9, exp, 1, 4);
mystl::replace_copy(arr1, arr1 + 9, act, 1, 4);
EXPECT_CON_EQ(exp, act);
std::replace_copy(arr1, arr1 + 9, exp, 2, 5);
mystl::replace_copy(arr1, arr1 + 9, act, 2, 5);
EXPECT_CON_EQ(exp, act);
std::replace_copy(arr1, arr1 + 9, exp, 3, 6);
mystl::replace_copy(arr1, arr1 + 9, act, 3, 6);
EXPECT_CON_EQ(exp, act);
}
TEST(replace_copy_if_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int exp[10] = { 0 }, act[10] = { 0 };
std::replace_copy_if(arr1, arr1 + 10, exp, is_odd, 1);
mystl::replace_copy_if(arr1, arr1 + 10, act, is_odd, 1);
EXPECT_CON_EQ(exp, act);
std::replace_copy_if(arr1, arr1 + 10, exp, is_even, 2);
mystl::replace_copy_if(arr1, arr1 + 10, act, is_even, 2);
EXPECT_CON_EQ(exp, act);
}
TEST(replace_if_test)
{
std::vector<int> v1{ 1,2,3,4,5,6,7,8,9,10 };
std::vector<int> v2(v1);
std::replace_if(v1.begin(), v1.end(), is_odd, 1);
mystl::replace_if(v2.begin(), v2.end(), is_odd, 1);
EXPECT_CON_EQ(v1, v2);
std::replace_if(v1.begin(), v1.end(), is_even, 2);
mystl::replace_if(v2.begin(), v2.end(), is_even, 2);
EXPECT_CON_EQ(v1, v2);
}
TEST(reverse_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[] = { 1,2,3,4,5,6,7,8,9 };
std::reverse(arr1, arr1 + 9);
mystl::reverse(arr2, arr2 + 9);
EXPECT_CON_EQ(arr1, arr2);
std::reverse(arr1, arr1 + 5);
mystl::reverse(arr2, arr2 + 5);
EXPECT_CON_EQ(arr1, arr2);
}
TEST(reverse_copy_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int exp[5], act[5];
std::reverse_copy(arr1, arr1 + 5, exp);
mystl::reverse_copy(arr1, arr1 + 5, act);
EXPECT_CON_EQ(exp, act);
std::reverse_copy(arr1 + 4, arr1 + 9, exp);
mystl::reverse_copy(arr1 + 4, arr1 + 9, act);
EXPECT_CON_EQ(exp, act);
}
TEST(rotate_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[] = { 1,2,3,4,5,6,7,8,9 };
std::rotate(arr1, arr1 + 3, arr1 + 9);
mystl::rotate(arr2, arr2 + 3, arr2 + 9);
EXPECT_CON_EQ(arr1, arr2);
std::rotate(arr1 + 3, arr1 + 5, arr1 + 9);
mystl::rotate(arr2 + 3, arr2 + 5, arr2 + 9);
EXPECT_CON_EQ(arr1, arr2);
std::rotate(arr1, arr1 + 9, arr1 + 9);
mystl::rotate(arr2, arr2 + 9, arr2 + 9);
EXPECT_CON_EQ(arr1, arr2);
}
TEST(rotate_copy_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int exp[9], act[9];
std::rotate_copy(arr1, arr1 + 5, arr1 + 9, exp);
mystl::rotate_copy(arr1, arr1 + 5, arr1 + 9, act);
EXPECT_CON_EQ(exp, act);
std::rotate_copy(arr1, arr1, arr1 + 9, exp);
mystl::rotate_copy(arr1, arr1, arr1 + 9, act);
EXPECT_CON_EQ(exp, act);
std::rotate_copy(arr1, arr1 + 9, arr1 + 9, exp);
mystl::rotate_copy(arr1, arr1 + 9, arr1 + 9, act);
EXPECT_CON_EQ(exp, act);
}
TEST(search_test)
{
int arr1[] = { 1,2,3,3,3,4,5,6,6, };
int arr2[] = { 1 };
int arr3[] = { 3,3 };
int arr4[] = { 5,6,6,6 };
EXPECT_EQ(std::search(arr1, arr1 + 9, arr2, arr2 + 1),
mystl::search(arr1, arr1 + 9, arr2, arr2 + 1));
EXPECT_EQ(std::search(arr1, arr1 + 9, arr3, arr3 + 2),
mystl::search(arr1, arr1 + 9, arr3, arr3 + 2));
EXPECT_EQ(std::search(arr1, arr1 + 9, arr4, arr4 + 3, std::less<int>()),
mystl::search(arr1, arr1 + 9, arr4, arr4 + 3, std::less<int>()));
EXPECT_EQ(std::search(arr1, arr1 + 9, arr4, arr4 + 4, std::less<int>()),
mystl::search(arr1, arr1 + 9, arr4, arr4 + 4, std::less<int>()));
}
TEST(search_n_test)
{
int arr1[] = { 1,2,2,3,3,3,6,6,9 };
EXPECT_EQ(std::search_n(arr1, arr1 + 9, 1, 0),
mystl::search_n(arr1, arr1 + 9, 1, 0));
EXPECT_EQ(std::search_n(arr1, arr1 + 9, 2, 2),
mystl::search_n(arr1, arr1 + 9, 2, 2));
EXPECT_EQ(std::search_n(arr1, arr1 + 9, 1, 3),
mystl::search_n(arr1, arr1 + 9, 1, 3));
EXPECT_EQ(std::search_n(arr1, arr1 + 9, 3, 6, std::less<int>()),
mystl::search_n(arr1, arr1 + 9, 3, 6, std::less<int>()));
EXPECT_EQ(std::search_n(arr1, arr1 + 9, 2, 10, std::less<int>()),
mystl::search_n(arr1, arr1 + 9, 2, 10, std::less<int>()));
}
TEST(sort_test)
{
int arr1[] = { 6,1,2,5,4,8,3,2,4,6,10,2,1,9 };
int arr2[] = { 6,1,2,5,4,8,3,2,4,6,10,2,1,9 };
int arr3[] = { 80,30,51,65,12,10,24,87,62,51,32,45,1,33,66,20,35,84,62,14 };
int arr4[] = { 80,30,51,65,12,10,24,87,62,51,32,45,1,33,66,20,35,84,62,14 };
int arr5[] = { 9,9,9,8,8,8,7,7,7 };
int arr6[] = { 9,9,9,8,8,8,7,7,7 };
std::sort(arr1, arr1 + 14);
mystl::sort(arr2, arr2 + 14);
std::sort(arr3, arr3 + 20);
mystl::sort(arr4, arr4 + 20);
std::sort(arr5, arr5 + 9, std::greater<int>());
mystl::sort(arr6, arr6 + 9, std::greater<int>());
EXPECT_CON_EQ(arr1, arr2);
EXPECT_CON_EQ(arr3, arr4);
EXPECT_CON_EQ(arr5, arr6);
}
TEST(swap_ranges_test)
{
int arr1[] = { 4,5,6,1,2,3 };
int arr2[] = { 4,5,6,1,2,3 };
int arr3[] = { 1,2,3,4,5,6 };
int arr4[] = { 1,2,3,4,5,6 };
int arr5[] = { 1,1,1 };
int arr6[] = { 1,1,1 };
std::swap_ranges(arr1, arr1 + 6, arr3);
mystl::swap_ranges(arr2, arr2 + 6, arr4);
std::swap_ranges(arr1, arr1 + 3, arr5);
mystl::swap_ranges(arr2, arr2 + 3, arr6);
EXPECT_CON_EQ(arr1, arr2);
EXPECT_CON_EQ(arr1, arr2);
}
TEST(transform_test)
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[] = { 9,8,7,6,5,4,3,2,1 };
int exp[9], act[9];
std::transform(arr1, arr1 + 9, exp, unary_op);
mystl::transform(arr1, arr1 + 9, act, unary_op);
EXPECT_CON_EQ(exp, act);
std::transform(arr1, arr1 + 9, arr2, exp, binary_op);
mystl::transform(arr1, arr1 + 9, arr2, act, binary_op);
EXPECT_CON_EQ(exp, act);
}
TEST(unique_test)
{
int arr1[] = { 1,1,1,2,2,3,4,4,5,6 };
int arr2[] = { 1,1,1,2,2,3,4,4,5,6 };
int arr3[] = { 1,2,3,6,6,6,8,8,9 };
int arr4[] = { 1,2,3,6,6,6,8,8,9 };
std::unique(arr1, arr1 + 10);
mystl::unique(arr2, arr2 + 10);
std::unique(arr3, arr3 + 9, std::equal_to<int>());
mystl::unique(arr4, arr4 + 9, std::equal_to<int>());
EXPECT_CON_EQ(arr1, arr2);
EXPECT_CON_EQ(arr3, arr4);
}
TEST(unique_copy_test)
{
int arr1[] = { 1,1,1,2,2,3,4,4,5,6 };
int arr2[] = { 1,2,3,6,6,6,8,8,9 };
int exp[6], act[6];
std::unique_copy(arr1, arr1 + 10, exp);
mystl::unique_copy(arr1, arr1 + 10, act);
EXPECT_CON_EQ(exp, act);
std::unique_copy(arr2, arr2 + 9, exp, std::equal_to<int>());
mystl::unique_copy(arr2, arr2 + 9, act, std::equal_to<int>());
EXPECT_CON_EQ(exp, act);
}
TEST(upper_bound_test)
{
int arr1[] = { 1,2,3,3,3,4,5,6,6 };
EXPECT_EQ(std::upper_bound(arr1, arr1 + 9, 0),
mystl::upper_bound(arr1, arr1 + 9, 0));
EXPECT_EQ(std::upper_bound(arr1, arr1 + 9, 1),
mystl::upper_bound(arr1, arr1 + 9, 1));
EXPECT_EQ(std::upper_bound(arr1, arr1 + 9, 3),
mystl::upper_bound(arr1, arr1 + 9, 3));
EXPECT_EQ(std::upper_bound(arr1, arr1 + 9, 6, std::less<int>()),
mystl::upper_bound(arr1, arr1 + 9, 6, std::less<int>()));
EXPECT_EQ(std::upper_bound(arr1, arr1 + 9, 7, std::less<int>()),
mystl::upper_bound(arr1, arr1 + 9, 7, std::less<int>()));
}
} // namespace algorithm_test
#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER
} // namespace test
} // namespace mystl
#endif // !MYTINYSTL_ALGORITHM_TEST_H_
``` | /content/code_sandbox/Test/algorithm_test.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 15,482 |
```objective-c
#ifndef MYTINYSTL_SET_TEST_H_
#define MYTINYSTL_SET_TEST_H_
// set test : set, multiset insert
#include <set>
#include "../MyTinySTL/set.h"
#include "test.h"
namespace mystl
{
namespace test
{
namespace set_test
{
void set_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[------------------ Run container test : set -------------------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
int a[] = { 5,4,3,2,1 };
mystl::set<int> s1;
mystl::set<int, mystl::greater<int>> s2;
mystl::set<int> s3(a, a + 5);
mystl::set<int> s4(a, a + 5);
mystl::set<int> s5(s3);
mystl::set<int> s6(std::move(s3));
mystl::set<int> s7;
s7 = s4;
mystl::set<int> s8;
s8 = std::move(s4);
mystl::set<int> s9{ 1,2,3,4,5 };
mystl::set<int> s10;
s10 = { 1,2,3,4,5 };
for (int i = 5; i > 0; --i)
{
FUN_AFTER(s1, s1.emplace(i));
}
FUN_AFTER(s1, s1.emplace_hint(s1.begin(), 0));
FUN_AFTER(s1, s1.erase(s1.begin()));
FUN_AFTER(s1, s1.erase(0));
FUN_AFTER(s1, s1.erase(1));
FUN_AFTER(s1, s1.erase(s1.begin(), s1.end()));
for (int i = 0; i < 5; ++i)
{
FUN_AFTER(s1, s1.insert(i));
}
FUN_AFTER(s1, s1.insert(a, a + 5));
FUN_AFTER(s1, s1.insert(5));
FUN_AFTER(s1, s1.insert(s1.end(), 5));
FUN_VALUE(s1.count(5));
FUN_VALUE(*s1.find(3));
FUN_VALUE(*s1.lower_bound(3));
FUN_VALUE(*s1.upper_bound(3));
auto first = *s1.equal_range(3).first;
auto second = *s1.equal_range(3).second;
std::cout << " s1.equal_range(3) : from " << first << " to " << second << std::endl;
FUN_AFTER(s1, s1.erase(s1.begin()));
FUN_AFTER(s1, s1.erase(1));
FUN_AFTER(s1, s1.erase(s1.begin(), s1.find(3)));
FUN_AFTER(s1, s1.clear());
FUN_AFTER(s1, s1.swap(s5));
FUN_VALUE(*s1.begin());
FUN_VALUE(*s1.rbegin());
std::cout << std::boolalpha;
FUN_VALUE(s1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(s1.size());
FUN_VALUE(s1.max_size());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| emplace |";
#if LARGER_TEST_DATA_ON
CON_TEST_P1(set<int>, emplace, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3));
#else
CON_TEST_P1(set<int>, emplace, rand(), SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[------------------ End container test : set -------------------]" << std::endl;
}
void multiset_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[---------------- Run container test : multiset ----------------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
int a[] = { 5,4,3,2,1 };
mystl::multiset<int> s1;
mystl::multiset<int, mystl::greater<int>> s2;
mystl::multiset<int> s3(a, a + 5);
mystl::multiset<int> s4(a, a + 5);
mystl::multiset<int> s5(s3);
mystl::multiset<int> s6(std::move(s3));
mystl::multiset<int> s7;
s7 = s4;
mystl::multiset<int> s8;
s8 = std::move(s4);
mystl::multiset<int> s9{ 1,2,3,4,5 };
mystl::multiset<int> s10;
s10 = { 1,2,3,4,5 };
for (int i = 5; i > 0; --i)
{
FUN_AFTER(s1, s1.emplace(i));
}
FUN_AFTER(s1, s1.emplace_hint(s1.begin(), 0));
FUN_AFTER(s1, s1.erase(s1.begin()));
FUN_AFTER(s1, s1.erase(0));
FUN_AFTER(s1, s1.erase(1));
FUN_AFTER(s1, s1.erase(s1.begin(), s1.end()));
for (int i = 0; i < 5; ++i)
{
FUN_AFTER(s1, s1.insert(i));
}
FUN_AFTER(s1, s1.insert(a, a + 5));
FUN_AFTER(s1, s1.insert(5));
FUN_AFTER(s1, s1.insert(s1.end(), 5));
FUN_VALUE(s1.count(5));
FUN_VALUE(*s1.find(3));
FUN_VALUE(*s1.lower_bound(3));
FUN_VALUE(*s1.upper_bound(3));
auto first = *s1.equal_range(3).first;
auto second = *s1.equal_range(3).second;
std::cout << " s1.equal_range(3) : from " << first << " to " << second << std::endl;
FUN_AFTER(s1, s1.erase(s1.begin()));
FUN_AFTER(s1, s1.erase(1));
FUN_AFTER(s1, s1.erase(s1.begin(), s1.find(3)));
FUN_AFTER(s1, s1.clear());
FUN_AFTER(s1, s1.swap(s5));
FUN_VALUE(*s1.begin());
FUN_VALUE(*s1.rbegin());
std::cout << std::boolalpha;
FUN_VALUE(s1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(s1.size());
FUN_VALUE(s1.max_size());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| emplace |";
#if LARGER_TEST_DATA_ON
CON_TEST_P1(multiset<int>, emplace, rand(), SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3));
#else
CON_TEST_P1(multiset<int>, emplace, rand(), SCALE_S(LEN1), SCALE_S(LEN2), SCALE_S(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[---------------- End container test : multiset ----------------]" << std::endl;
}
} // namespace set_test
} // namespace test
} // namespace mystl
#endif // !MYTINYSTL_SET_TEST_H_
``` | /content/code_sandbox/Test/set_test.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 1,779 |
```c++
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif
#if defined(_MSC_VER) && defined(_DEBUG)
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#endif // check memory leaks
#include "algorithm_performance_test.h"
#include "algorithm_test.h"
#include "vector_test.h"
#include "list_test.h"
#include "deque_test.h"
#include "queue_test.h"
#include "stack_test.h"
#include "map_test.h"
#include "set_test.h"
#include "unordered_map_test.h"
#include "unordered_set_test.h"
#include "string_test.h"
int main()
{
using namespace mystl::test;
std::cout.sync_with_stdio(false);
RUN_ALL_TESTS();
algorithm_performance_test::algorithm_performance_test();
vector_test::vector_test();
list_test::list_test();
deque_test::deque_test();
queue_test::queue_test();
queue_test::priority_test();
stack_test::stack_test();
map_test::map_test();
map_test::multimap_test();
set_test::set_test();
set_test::multiset_test();
unordered_map_test::unordered_map_test();
unordered_map_test::unordered_multimap_test();
unordered_set_test::unordered_set_test();
unordered_set_test::unordered_multiset_test();
string_test::string_test();
#if defined(_MSC_VER) && defined(_DEBUG)
_CrtDumpMemoryLeaks();
#endif // check memory leaks
}
``` | /content/code_sandbox/Test/test.cpp | c++ | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 305 |
```objective-c
#ifndef MYTINYSTL_UNORDERED_MAP_TEST_H_
#define MYTINYSTL_UNORDERED_MAP_TEST_H_
// unordered_map test : unordered_map, unordered_multimap insert
#include <unordered_map>
#include "../MyTinySTL/unordered_map.h"
#include "map_test.h"
#include "test.h"
namespace mystl
{
namespace test
{
namespace unordered_map_test
{
void unordered_map_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[-------------- Run container test : unordered_map -------------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
mystl::vector<PAIR> v;
for (int i = 0; i < 5; ++i)
v.push_back(PAIR(5 - i, 5 - i));
mystl::unordered_map<int, int> um1;
mystl::unordered_map<int, int> um2(520);
mystl::unordered_map<int, int> um3(520, mystl::hash<int>());
mystl::unordered_map<int, int> um4(520, mystl::hash<int>(), mystl::equal_to<int>());
mystl::unordered_map<int, int> um5(v.begin(), v.end());
mystl::unordered_map<int, int> um6(v.begin(), v.end(), 100);
mystl::unordered_map<int, int> um7(v.begin(), v.end(), 100, mystl::hash<int>());
mystl::unordered_map<int, int> um8(v.begin(), v.end(), 100, mystl::hash<int>(), mystl::equal_to<int>());
mystl::unordered_map<int, int> um9(um5);
mystl::unordered_map<int, int> um10(std::move(um5));
mystl::unordered_map<int, int> um11;
um11 = um6;
mystl::unordered_map<int, int> um12;
um12 = std::move(um6);
mystl::unordered_map<int, int> um13{ PAIR(1,1),PAIR(2,3),PAIR(3,3) };
mystl::unordered_map<int, int> um14;
um14 = { PAIR(1,1),PAIR(2,3),PAIR(3,3) };
MAP_FUN_AFTER(um1, um1.emplace(1, 1));
MAP_FUN_AFTER(um1, um1.emplace_hint(um1.begin(), 1, 2));
MAP_FUN_AFTER(um1, um1.insert(PAIR(2, 2)));
MAP_FUN_AFTER(um1, um1.insert(um1.end(), PAIR(3, 3)));
MAP_FUN_AFTER(um1, um1.insert(v.begin(), v.end()));
MAP_FUN_AFTER(um1, um1.erase(um1.begin()));
MAP_FUN_AFTER(um1, um1.erase(um1.begin(), um1.find(3)));
MAP_FUN_AFTER(um1, um1.erase(1));
std::cout << std::boolalpha;
FUN_VALUE(um1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(um1.size());
FUN_VALUE(um1.bucket_count());
FUN_VALUE(um1.max_bucket_count());
FUN_VALUE(um1.bucket(1));
FUN_VALUE(um1.bucket_size(um1.bucket(5)));
MAP_FUN_AFTER(um1, um1.clear());
MAP_FUN_AFTER(um1, um1.swap(um7));
MAP_VALUE(*um1.begin());
FUN_VALUE(um1.at(1));
FUN_VALUE(um1[1]);
std::cout << std::boolalpha;
FUN_VALUE(um1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(um1.size());
FUN_VALUE(um1.max_size());
FUN_VALUE(um1.bucket_count());
FUN_VALUE(um1.max_bucket_count());
FUN_VALUE(um1.bucket(1));
FUN_VALUE(um1.bucket_size(um1.bucket(1)));
MAP_FUN_AFTER(um1, um1.reserve(1000));
FUN_VALUE(um1.size());
FUN_VALUE(um1.bucket_count());
FUN_VALUE(um1.bucket_size(1));
FUN_VALUE(um1.bucket_size(2));
FUN_VALUE(um1.bucket_size(3));
MAP_FUN_AFTER(um1, um1.rehash(150));
FUN_VALUE(um1.bucket_count());
FUN_VALUE(um1.count(1));
MAP_VALUE(*um1.find(3));
auto first = *um1.equal_range(3).first;
auto second = *um1.equal_range(3).second;
std::cout << " um1.equal_range(3) : from <" << first.first << ", " << first.second
<< "> to <" << second.first << ", " << second.second << ">" << std::endl;
FUN_VALUE(um1.load_factor());
FUN_VALUE(um1.max_load_factor());
MAP_FUN_AFTER(um1, um1.max_load_factor(1.5f));
FUN_VALUE(um1.max_load_factor());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| emplace |";
#if LARGER_TEST_DATA_ON
MAP_EMPLACE_TEST(unordered_map, SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3));
#else
MAP_EMPLACE_TEST(unordered_map, SCALE_S(LEN1), SCALE_S(LEN2), SCALE_S(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[-------------- End container test : unordered_map -------------]" << std::endl;
}
void unordered_multimap_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[----------- Run container test : unordered_multimap -----------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
mystl::vector<PAIR> v;
for (int i = 0; i < 5; ++i)
v.push_back(PAIR(5 - i, 5 - i));
mystl::unordered_multimap<int, int> um1;
mystl::unordered_multimap<int, int> um2(520);
mystl::unordered_multimap<int, int> um3(520, mystl::hash<int>());
mystl::unordered_multimap<int, int> um4(520, mystl::hash<int>(), mystl::equal_to<int>());
mystl::unordered_multimap<int, int> um5(v.begin(), v.end());
mystl::unordered_multimap<int, int> um6(v.begin(), v.end(), 100);
mystl::unordered_multimap<int, int> um7(v.begin(), v.end(), 100, mystl::hash<int>());
mystl::unordered_multimap<int, int> um8(v.begin(), v.end(), 100, mystl::hash<int>(), mystl::equal_to<int>());
mystl::unordered_multimap<int, int> um9(um5);
mystl::unordered_multimap<int, int> um10(std::move(um5));
mystl::unordered_multimap<int, int> um11;
um11 = um6;
mystl::unordered_multimap<int, int> um12;
um12 = std::move(um6);
mystl::unordered_multimap<int, int> um13{ PAIR(1,1),PAIR(2,3),PAIR(3,3) };
mystl::unordered_multimap<int, int> um14;
um14 = { PAIR(1,1),PAIR(2,3),PAIR(3,3) };
MAP_FUN_AFTER(um1, um1.emplace(1, 1));
MAP_FUN_AFTER(um1, um1.emplace_hint(um1.begin(), 1, 2));
MAP_FUN_AFTER(um1, um1.insert(PAIR(2, 2)));
MAP_FUN_AFTER(um1, um1.insert(um1.end(), PAIR(3, 3)));
MAP_FUN_AFTER(um1, um1.insert(v.begin(), v.end()));
MAP_FUN_AFTER(um1, um1.erase(um1.begin()));
MAP_FUN_AFTER(um1, um1.erase(um1.begin(), um1.find(3)));
MAP_FUN_AFTER(um1, um1.erase(1));
std::cout << std::boolalpha;
FUN_VALUE(um1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(um1.size());
FUN_VALUE(um1.bucket_count());
FUN_VALUE(um1.max_bucket_count());
FUN_VALUE(um1.bucket(1));
FUN_VALUE(um1.bucket_size(um1.bucket(5)));
MAP_FUN_AFTER(um1, um1.clear());
MAP_FUN_AFTER(um1, um1.swap(um7));
MAP_VALUE(*um1.begin());
std::cout << std::boolalpha;
FUN_VALUE(um1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(um1.size());
FUN_VALUE(um1.max_size());
FUN_VALUE(um1.bucket_count());
FUN_VALUE(um1.max_bucket_count());
FUN_VALUE(um1.bucket(1));
FUN_VALUE(um1.bucket_size(um1.bucket(1)));
MAP_FUN_AFTER(um1, um1.reserve(1000));
FUN_VALUE(um1.size());
FUN_VALUE(um1.bucket_count());
FUN_VALUE(um1.bucket_size(1));
FUN_VALUE(um1.bucket_size(2));
FUN_VALUE(um1.bucket_size(3));
MAP_FUN_AFTER(um1, um1.rehash(150));
FUN_VALUE(um1.bucket_count());
FUN_VALUE(um1.count(1));
MAP_VALUE(*um1.find(3));
auto first = *um1.equal_range(3).first;
auto second = *um1.equal_range(3).second;
std::cout << " um1.equal_range(3) : from <" << first.first << ", " << first.second
<< "> to <" << second.first << ", " << second.second << ">" << std::endl;
FUN_VALUE(um1.load_factor());
FUN_VALUE(um1.max_load_factor());
MAP_FUN_AFTER(um1, um1.max_load_factor(1.5f));
FUN_VALUE(um1.max_load_factor());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| emplace |";
#if LARGER_TEST_DATA_ON
MAP_EMPLACE_TEST(unordered_multimap, SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3));
#else
MAP_EMPLACE_TEST(unordered_multimap, SCALE_S(LEN1), SCALE_S(LEN2), SCALE_S(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[----------- End container test : unordered_multimap -----------]" << std::endl;
}
} // namespace unordered_map_test
} // namespace test
} // namespace mystl
#endif // !MYTINYSTL_UNORDERED_MAP_TEST_H_
``` | /content/code_sandbox/Test/unordered_map_test.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 2,555 |
```objective-c
#ifndef MYTINYSTL_DEQUE_TEST_H_
#define MYTINYSTL_DEQUE_TEST_H_
// deque test : deque push_front/push_back
#include <deque>
#include "../MyTinySTL/deque.h"
#include "test.h"
namespace mystl
{
namespace test
{
namespace deque_test
{
void deque_test()
{
std::cout << "[===============================================================]" << std::endl;
std::cout << "[----------------- Run container test : deque ------------------]" << std::endl;
std::cout << "[-------------------------- API test ---------------------------]" << std::endl;
int a[] = { 1,2,3,4,5 };
mystl::deque<int> d1;
mystl::deque<int> d2(5);
mystl::deque<int> d3(5, 1);
mystl::deque<int> d4(a, a + 5);
mystl::deque<int> d5(d2);
mystl::deque<int> d6(std::move(d2));
mystl::deque<int> d7;
d7 = d3;
mystl::deque<int> d8;
d8 = std::move(d3);
mystl::deque<int> d9{ 1,2,3,4,5,6,7,8,9 };
mystl::deque<int> d10;
d10 = { 1,2,3,4,5,6,7,8,9 };
FUN_AFTER(d1, d1.assign(5, 1));
FUN_AFTER(d1, d1.assign(8, 8));
FUN_AFTER(d1, d1.assign(a, a + 5));
FUN_AFTER(d1, d1.assign({ 1,2,3,4,5 }));
FUN_AFTER(d1, d1.insert(d1.end(), 6));
FUN_AFTER(d1, d1.insert(d1.end() - 1, 2, 7));
FUN_AFTER(d1, d1.insert(d1.begin(), a, a + 5));
FUN_AFTER(d1, d1.erase(d1.begin()));
FUN_AFTER(d1, d1.erase(d1.begin(), d1.begin() + 4));
FUN_AFTER(d1, d1.emplace_back(8));
FUN_AFTER(d1, d1.emplace_front(8));
FUN_AFTER(d1, d1.emplace(d1.begin() + 1, 9));
FUN_AFTER(d1, d1.push_front(1));
FUN_AFTER(d1, d1.push_back(2));
FUN_AFTER(d1, d1.pop_back());
FUN_AFTER(d1, d1.pop_front());
FUN_AFTER(d1, d1.shrink_to_fit());
FUN_AFTER(d1, d1.resize(5));
FUN_AFTER(d1, d1.resize(8, 8));
FUN_AFTER(d1, d1.clear());
FUN_AFTER(d1, d1.shrink_to_fit());
FUN_AFTER(d1, d1.swap(d4));
FUN_VALUE(*(d1.begin()));
FUN_VALUE(*(d1.end() - 1));
FUN_VALUE(*(d1.rbegin()));
FUN_VALUE(*(d1.rend() - 1));
FUN_VALUE(d1.front());
FUN_VALUE(d1.back());
FUN_VALUE(d1.at(1));
FUN_VALUE(d1[2]);
std::cout << std::boolalpha;
FUN_VALUE(d1.empty());
std::cout << std::noboolalpha;
FUN_VALUE(d1.size());
FUN_VALUE(d1.max_size());
PASSED;
#if PERFORMANCE_TEST_ON
std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| push_front |";
#if LARGER_TEST_DATA_ON
CON_TEST_P1(deque<int>, push_front, rand(), SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3));
#else
CON_TEST_P1(deque<int>, push_front, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
std::cout << "| push_back |";
#if LARGER_TEST_DATA_ON
CON_TEST_P1(deque<int>, push_back, rand(), SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3));
#else
CON_TEST_P1(deque<int>, push_back, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3));
#endif
std::cout << std::endl;
std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl;
PASSED;
#endif
std::cout << "[----------------- End container test : deque ------------------]" << std::endl;
}
} // namespace deque_test
} // namespace test
} // namespace mystl
#endif // !MYTINYSTL_DEQUE_TEST_H_
``` | /content/code_sandbox/Test/deque_test.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 1,106 |
```objective-c
#ifndef MYTINYSTL_TEST_H_
#define MYTINYSTL_TEST_H_
// TestCase UnitTest
#include <ctime>
#include <cstring>
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <vector>
#include "Lib/redbud/io/color.h"
namespace mystl
{
namespace test
{
#define green redbud::io::state::manual << redbud::io::hfg::green
#define red redbud::io::state::manual << redbud::io::hfg::red
#if defined(_MSC_VER)
#pragma warning(disable : 4244)
#pragma warning(disable : 4996)
#endif
} // namespace test
namespace test
{
// TestCase
//
class TestCase
{
public:
//
TestCase(const char* case_name) : testcase_name(case_name) {}
//
virtual void Run() = 0;
public:
const char* testcase_name; //
int nTestResult; //
double nFailed; //
double nPassed; //
};
// UnitTest
// vector
class UnitTest
{
public:
//
static UnitTest* GetInstance();
// vector
TestCase* RegisterTestCase(TestCase* testcase);
void Run();
public:
TestCase* CurrentTestCase; //
double nPassed; //
double nFailed; //
protected:
std::vector<TestCase*> testcases_; //
};
UnitTest* UnitTest::GetInstance()
{
static UnitTest instance;
return &instance;
}
TestCase* UnitTest::RegisterTestCase(TestCase* testcase)
{
testcases_.push_back(testcase);
return testcase;
}
void UnitTest::Run()
{
for (auto it : testcases_)
{
TestCase* testcase = it;
CurrentTestCase = testcase;
testcase->nTestResult = 1;
testcase->nFailed = 0;
testcase->nPassed = 0;
std::cout << green << "============================================\n";
std::cout << green << " Run TestCase:" << testcase->testcase_name << "\n";
testcase->Run();
if (testcase->nFailed == 0)
std::cout << green;
else
std::cout << red;
std::cout << " " << testcase->nPassed << " / " << testcase->nFailed + testcase->nPassed
<< " Cases passed. ( " << testcase->nPassed /
(testcase->nFailed + testcase->nPassed) * 100 << "% )\n";
std::cout << green << " End TestCase:" << testcase->testcase_name << "\n";
if (testcase->nTestResult)
++nPassed;
else
++nFailed;
}
std::cout << green << "============================================\n";
std::cout << green << " Total TestCase : " << nPassed + nFailed << "\n";
std::cout << green << " Total Passed : " << nPassed << "\n";
std::cout << red << " Total Failed : " << nFailed << "\n";
std::cout << green << " " << nPassed << " / " << nFailed + nPassed
<< " TestCases passed. ( " << nPassed / (nFailed + nPassed) * 100 << "% )\n";
}
/*****************************************************************************************/
// test_cast_TEST
#define TESTCASE_NAME(testcase_name) \
testcase_name##_TEST
// TEXT
#define MYTINYSTL_TEST_(testcase_name) \
class TESTCASE_NAME(testcase_name) : public TestCase { \
public: \
TESTCASE_NAME(testcase_name)(const char* case_name) \
: TestCase(case_name) {}; \
virtual void Run(); \
private: \
static TestCase* const testcase_; \
}; \
\
TestCase* const TESTCASE_NAME(testcase_name) \
::testcase_ = UnitTest::GetInstance()->RegisterTestCase( \
new TESTCASE_NAME(testcase_name)(#testcase_name)); \
void TESTCASE_NAME(testcase_name)::Run()
/*
Run() Run
TEST(AddTestDemo)
{
EXPECT_EQ(3, Add(1, 2));
EXPECT_EQ(2, Add(1, 1));
}
{ EXPECT_EQ(3, Add(1, 2)); EXPECT_EQ(2, Add(1, 1)); } Run()
*/
/*****************************************************************************************/
//
// : EXPECT_*
// :
/*
EXPECT_TRUE : Condition true
EXPECT_FALSE : Condition false
Example:
bool isPrime(int n);
EXPECT_TRUE(isPrime(2));
EXPECT_FALSE(isPrime(4));
EXPECT_TRUE(isPrime(6));
EXPECT_FALSE(isPrime(3));
*/
#define EXPECT_TRUE(Condition) do { \
if (Condition) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_TRUE succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_TRUE failed!\n"; \
}} while(0)
#define EXPECT_FALSE(Condition) do { \
if (!Condition) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_FALSE succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_FALSE failed!\n"; \
}} while(0)
/*
EXPECT_EQ(v1, v2) : v1 == v2
EXPECT_NE(v1, v2) : v1 != v2
EXPECT_LT(v1, v2) : v1 < v2
EXPECT_LE(v1, v2) : v1 <= v2
EXPECT_GT(v1, v2) : v1 > v2
EXPECT_GE(v1, v2) : v1 >= v2
Note:
1. EXPECT_*(Expect, Actual)
2.
3. <<
ostream
4. == <
5. EXPECT_EQ
C (const char*)
EXPECT_STREQ C (NULL)
EXPECT_STREQ(NULL, c_str) string
EXPECT_EQ
Example:
EXPECT_EQ(3, foo());
EXPECT_NE(NULL, pointer);
EXPECT_LT(len, v.size());
*/
#define EXPECT_EQ(v1, v2) do { \
if (v1 == v2) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_EQ succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_EQ failed!\n"; \
std::cout << red << " Expect:" << v1 << "\n"; \
std::cout << red << " Actual:" << v2 << "\n"; \
}} while(0)
#define EXPECT_NE(v1, v2) do { \
if (v1 != v2) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_NE succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_NE failed!\n"; \
std::cout << red << " Expect:" << v1 << "\n"; \
std::cout << red << " Actual:" << v2 << "\n"; \
}} while(0)
#define EXPECT_LT(v1, v2) do { \
if (v1 < v2) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_LT succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_LT failed!\n"; \
std::cout << red << " Expect:" << v1 << "\n"; \
std::cout << red << " Actual:" << v2 << "\n"; \
}} while(0)
#define EXPECT_LE(v1, v2) do { \
if (v1 <= v2) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_LE succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_LE failed!\n"; \
std::cout << red << " Expect:" << v1 << "\n"; \
std::cout << red << " Actual:" << v2 << "\n"; \
}} while(0)
#define EXPECT_GT(v1, v2) do { \
if (v1 > v2) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_GT succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_GT failed!\n"; \
std::cout << red << " Expect:" << v1 << "\n"; \
std::cout << red << " Actual:" << v2 << "\n"; \
}} while(0)
#define EXPECT_GE(v1, v2) do { \
if (v1 >= v2) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_GE succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_GE failed!\n"; \
std::cout << red << " Expect:" << v1 << "\n"; \
std::cout << red << " Actual:" << v2 << "\n"; \
}} while(0)
/*
EXPECT_STREQ(s1, s2) : C
EXPECT_STRNE(s1, s2) : C
Note:
1. EXPECT_STR*(Expect, Actual)
2. C string
EXPECT_EQEXPECT_NE
3. EXPECT_STREQ EXPECT_STRNE wchar_t*
4. NULL
Example:
char* s1 = "", char* s2 = "abc", char* s3 = NULL;
EXPECT_STREQ("abc", s2);
EXPECT_STREQ(s1, s3);
EXPECT_STREQ(NULL, s3);
EXPECT_STRNE(" ", s1);
*/
#define EXPECT_STREQ(s1, s2) do { \
if (s1 == NULL || s2 == NULL) { \
if (s1 == NULL && s2 == NULL) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_STRED succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_STRED failed!\n"; \
if(s1 == NULL) std::cout << " Expect: NULL\n"; \
else std::cout << " Expect:\"" << s1 << "\"\n"; \
if(s2 == NULL) std::cout << " Actual: NULL\n"; \
else std::cout << " Actual:\"" << s2 << "\"\n"; \
} \
} \
else if (strcmp(s1, s2) == 0) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_STRED succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_STRED failed!\n"; \
std::cout << red << " Expect:\"" << s1 << "\"\n"; \
std::cout << red << " Actual:\"" << s2 << "\"\n"; \
}} while(0)
#define EXPECT_STRNE(s1, s2) do { \
if (s1 == NULL || s2 == NULL) { \
if (s1 != NULL || s2 != NULL) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_STRNE succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_STRNE failed!\n"; \
if(s1 == NULL) std::cout << " Expect: NULL\n"; \
else std::cout << " Expect:\"" << s1 << "\"\n"; \
if(s2 == NULL) std::cout << " Actual: NULL\n"; \
else std::cout << " Actual:\"" << s2 << "\"\n"; \
} \
} \
else if (strcmp(s1, s2) != 0) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_STRNE succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_STRNE failed!\n"; \
std::cout << red << " Expect:\"" << s1 << "\"\n"; \
std::cout << red << " Actual:\"" << s2 << "\"\n"; \
}} while(0)
/*
EXPECT_PTR_EQ(p1, p2) : *p1 == *p2
EXPECT_PTR_NE(p1, p2) : *p1 != *p2
EXPECT_PTR_RANGE_EQ(p1, p2, len) : i (*p1 + i) == (*p2 + i) i[0,len)
EXPECT_PTR_RANGE_NE(p1, p2, len) : i (*p1 + i) != (*p2 + i) i[0,len)
Note:
1. EXPECT_PTR_*(Expect, Actual)
EXPECT_PTR_RANGE_*(Expect, Actual, len)
2. EXPECT_PTR_EQ
EXPECT_EQ
3. EXPECT_PTR_RANGE_* p1p2
len
Example:
int a[] = {1,2,3,4,5};
int b[] = {1,2,3,4,6};
int *p1 = a, *p2 = b;
EXPECT_PTR_EQ(p1, p2);
p1 = a + 4, p2 = b + 4;
EXPECT_PTR_EQ(p1, p2);
EXPECT_PTR_EQ(p1, std::find(a, a + 5, 5));
EXPECT_PTR_RANGE_EQ(a, b, 5);
EXPECT_PTR_RANGE_EQ(a, b, 4);
*/
#define EXPECT_PTR_EQ(p1, p2) do { \
if (*p1 == *p2) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_PTR_EQ succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_PTR_EQ failed!\n"; \
std::cout << red << " Expect:" << *p1 << "\n"; \
std::cout << red << " Actual:" << *p2 << "\n"; \
}} while(0)
#define EXPECT_PTR_NE(p1, p2) do { \
if (*p1 != *p2) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_PTR_NE succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_PTR_NE failed!\n"; \
std::cout << red << " Expect:" << *p1 << "\n"; \
std::cout << red << " Actual:" << *p2 << "\n"; \
}} while(0)
#define EXPECT_PTR_RANGE_EQ(p1, p2, len) do { \
if (std::equal(p1, p1 + len, p2)) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_PTR_RANGE_EQ succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_PTR_RANGE_EQ failed!\n"; \
}} while(0)
#define EXPECT_PTR_RANGE_NE(p1, p2, len) do { \
if (!std::equal(p1, p1 + len, p2)) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_PTR_RANGE_NE succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_PTR_RANGE_NE failed!\n"; \
}} while(0)
/*
EXPECT_CON_EQ(c1, c2) : c1 == c2
EXPECT_CON_NE(c1, c2) : c1 != c2
Note:
1. STL
2.
3. EXPECT_CON_EQ
Example:
int arr[] = {1,2,3};
std::vector<int> v1{1, 2, 3};
std::vector<int> v2{2, 3, 4};
mystl::vector<long> v3(arr, arr + 3);
EXPECT_CON_NE(v1, v2) ok
EXPECT_CON_EQ(arr, v1) ok
EXPECT_CON_EQ(v1, v3) ok
*/
#define EXPECT_CON_EQ(c1, c2) do { \
auto first1 = std::begin(c1), last1 = std::end(c1); \
auto first2 = std::begin(c2), last2 = std::end(c2); \
for (; first1 != last1 && first2 != last2; ++first1, ++first2) { \
if (*first1 != *first2) break; \
} \
if (first1 == last1 && first2 == last2) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_CON_EQ succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_CON_EQ failed!\n"; \
std::cout << red << " Expect:" << *first1 << "\n"; \
std::cout << red << " Actual:" << *first2 << "\n"; \
}} while(0)
#define EXPECT_CON_NE(c1, c2) do { \
auto first1 = std::begin(c1), last1 = std::end(c1); \
auto first2 = std::begin(c2), last2 = std::end(c2); \
for (; first1 != last1 && first2 != last2; ++first1, ++first2) { \
if (*first1 != *first2) break; \
} \
if (first1 != last1 || first2 != last2) { \
UnitTest::GetInstance()->CurrentTestCase->nPassed++; \
std::cout << green << " EXPECT_CON_NE succeeded!\n"; \
} \
else { \
UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \
UnitTest::GetInstance()->CurrentTestCase->nFailed++; \
std::cout << red << " EXPECT_CON_NE failed!\n"; \
}} while(0)
/*****************************************************************************************/
//
//
#if defined(_DEBUG) || defined(DEBUG)
#define LEN1 10000
#define LEN2 100000
#define LEN3 1000000
#else
#define LEN1 100000
#define LEN2 1000000
#define LEN3 10000000
#endif
#define SCALE_LLL(N) (N * 20)
#define SCALE_LL(N) (N * 10)
#define SCALE_L(N) (N * 5)
#define SCALE_M(N) (N)
#define SCALE_S(N) (N / 5)
#define SCALE_SS(N) (N / 10)
#define SCALE_SSS(N) (N / 20)
#define WIDE 14
//
#define PASSED std::cout << "[ PASSED ]\n"
//
#define COUT(container) do { \
std::string con_name = #container; \
std::cout << " " << con_name << " :"; \
for (auto it : container) \
std::cout << " " << it; \
std::cout << "\n"; \
} while(0)
#define STR_COUT(str) do { \
std::string str_name = #str; \
std::cout << " " << str_name << " : " << str << "\n"; \
} while(0)
//
#define FUN_AFTER(con, fun) do { \
std::string fun_name = #fun; \
std::cout << " After " << fun_name << " :\n"; \
fun; \
COUT(con); \
} while(0)
#define STR_FUN_AFTER(str, fun) do { \
std::string fun_name = #fun; \
std::cout << " After " << fun_name << " :\n"; \
fun; \
STR_COUT(str); \
} while(0)
//
#define FUN_VALUE(fun) do { \
std::string fun_name = #fun; \
std::cout << " " << fun_name << " : " << fun << "\n"; \
} while(0)
//
void test_len(size_t len1, size_t len2, size_t len3, size_t wide)
{
std::string str1, str2, str3;
std::stringstream ss;
ss << len1 << " " << len2 << " " << len3;
ss >> str1 >> str2 >> str3;
str1 += " |";
std::cout << std::setw(wide) << str1;
str2 += " |";
std::cout << std::setw(wide) << str2;
str3 += " |";
std::cout << std::setw(wide) << str3 << "\n";
}
#define TEST_LEN(len1, len2, len3, wide) \
test_len(len1, len2, len3, wide)
//
#define FUN_TEST_FORMAT1(mode, fun, arg, count) do { \
srand((int)time(0)); \
clock_t start, end; \
mode c; \
char buf[10]; \
start = clock(); \
for (size_t i = 0; i < count; ++i) \
c.fun(arg); \
end = clock(); \
int n = static_cast<int>(static_cast<double>(end - start) \
/ CLOCKS_PER_SEC * 1000); \
std::snprintf(buf, sizeof(buf), "%d", n); \
std::string t = buf; \
t += "ms |"; \
std::cout << std::setw(WIDE) << t; \
} while(0)
#define FUN_TEST_FORMAT2(mode, fun, arg1, arg2, count) do { \
srand((int)time(0)); \
clock_t start, end; \
mode c; \
char buf[10]; \
start = clock(); \
for (size_t i = 0; i < count; ++i) \
c.fun(c.arg1(), arg2); \
end = clock(); \
int n = static_cast<int>(static_cast<double>(end - start) \
/ CLOCKS_PER_SEC * 1000); \
std::snprintf(buf, sizeof(buf), "%d", n); \
std::string t = buf; \
t += "ms |"; \
std::cout << std::setw(WIDE) << t; \
} while(0)
#define LIST_SORT_DO_TEST(mode, count) do { \
srand((int)time(0)); \
clock_t start, end; \
mode::list<int> l; \
char buf[10]; \
for (size_t i = 0; i < count; ++i) \
l.insert(l.end(), rand()); \
start = clock(); \
l.sort(); \
end = clock(); \
int n = static_cast<int>(static_cast<double>(end - start) \
/ CLOCKS_PER_SEC * 1000); \
std::snprintf(buf, sizeof(buf), "%d", n); \
std::string t = buf; \
t += "ms |"; \
std::cout << std::setw(WIDE) << t; \
} while(0)
#define MAP_EMPLACE_DO_TEST(mode, con, count) do { \
srand((int)time(0)); \
clock_t start, end; \
mode::con<int, int> c; \
char buf[10]; \
start = clock(); \
for (size_t i = 0; i < count; ++i) \
c.emplace(mode::make_pair(rand(), rand())); \
end = clock(); \
int n = static_cast<int>(static_cast<double>(end - start) \
/ CLOCKS_PER_SEC * 1000); \
std::snprintf(buf, sizeof(buf), "%d", n); \
std::string t = buf; \
t += "ms |"; \
std::cout << std::setw(WIDE) << t; \
} while(0)
//
#define CON_TEST_P1(con, fun, arg, len1, len2, len3) \
TEST_LEN(len1, len2, len3, WIDE); \
std::cout << "| std |"; \
FUN_TEST_FORMAT1(std::con, fun, arg, len1); \
FUN_TEST_FORMAT1(std::con, fun, arg, len2); \
FUN_TEST_FORMAT1(std::con, fun, arg, len3); \
std::cout << "\n| mystl |"; \
FUN_TEST_FORMAT1(mystl::con, fun, arg, len1); \
FUN_TEST_FORMAT1(mystl::con, fun, arg, len2); \
FUN_TEST_FORMAT1(mystl::con, fun, arg, len3);
#define CON_TEST_P2(con, fun, arg1, arg2, len1, len2, len3) \
TEST_LEN(len1, len2, len3, WIDE); \
std::cout << "| std |"; \
FUN_TEST_FORMAT2(std::con, fun, arg1, arg2, len1); \
FUN_TEST_FORMAT2(std::con, fun, arg1, arg2, len2); \
FUN_TEST_FORMAT2(std::con, fun, arg1, arg2, len3); \
std::cout << "\n| mystl |"; \
FUN_TEST_FORMAT2(mystl::con, fun, arg1, arg2, len1); \
FUN_TEST_FORMAT2(mystl::con, fun, arg1, arg2, len2); \
FUN_TEST_FORMAT2(mystl::con, fun, arg1, arg2, len3);
#define MAP_EMPLACE_TEST(con, len1, len2, len3) \
TEST_LEN(len1, len2, len3, WIDE); \
std::cout << "| std |"; \
MAP_EMPLACE_DO_TEST(std, con, len1); \
MAP_EMPLACE_DO_TEST(std, con, len2); \
MAP_EMPLACE_DO_TEST(std, con, len3); \
std::cout << "\n| mystl |"; \
MAP_EMPLACE_DO_TEST(mystl, con, len1); \
MAP_EMPLACE_DO_TEST(mystl, con, len2); \
MAP_EMPLACE_DO_TEST(mystl, con, len3);
#define LIST_SORT_TEST(len1, len2, len3) \
TEST_LEN(len1, len2, len3, WIDE); \
std::cout << "| std |"; \
LIST_SORT_DO_TEST(std, len1); \
LIST_SORT_DO_TEST(std, len2); \
LIST_SORT_DO_TEST(std, len3); \
std::cout << "\n| mystl |"; \
LIST_SORT_DO_TEST(mystl, len1); \
LIST_SORT_DO_TEST(mystl, len2); \
LIST_SORT_DO_TEST(mystl, len3);
//
#define TEST(testcase_name) \
MYTINYSTL_TEST_(testcase_name)
//
#define RUN_ALL_TESTS() \
mystl::test::UnitTest::GetInstance()->Run()
//
#ifndef PERFORMANCE_TEST_ON
#define PERFORMANCE_TEST_ON 1
#endif // !PERFORMANCE_TEST_ON
//
#ifndef LARGER_TEST_DATA_ON
#define LARGER_TEST_DATA_ON 0
#endif // !LARGER_TEST_DATA_ON
} // namespace test
} // namespace mystl
#endif // !MYTINYSTL_TEST_H_
``` | /content/code_sandbox/Test/test.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 6,931 |
```objective-c
#ifndef MYTINYSTL_ALGORITHM_PERFORMANCE_TEST_H_
#define MYTINYSTL_ALGORITHM_PERFORMANCE_TEST_H_
// sort, binary_search
#include <algorithm>
#include "../MyTinySTL/algorithm.h"
#include "test.h"
namespace mystl
{
namespace test
{
namespace algorithm_performance_test
{
//
#define FUN_TEST1(mode, fun, count) do { \
std::string fun_name = #fun; \
srand((int)time(0)); \
char buf[10]; \
clock_t start, end; \
int *arr = new int[count]; \
for(size_t i = 0; i < count; ++i) *(arr + i) = rand(); \
start = clock(); \
mode::fun(arr, arr + count); \
end = clock(); \
int n = static_cast<int>(static_cast<double>(end - start) \
/ CLOCKS_PER_SEC * 1000); \
std::snprintf(buf, sizeof(buf), "%d", n); \
std::string t = buf; \
t += "ms |"; \
std::cout << std::setw(WIDE) << t; \
delete []arr; \
} while(0)
#define FUN_TEST2(mode, fun, count) do { \
std::string fun_name = #fun; \
srand((int)time(0)); \
char buf[10]; \
clock_t start, end; \
int *arr = new int[count]; \
for(size_t i = 0; i < count; ++i) *(arr + i) = rand(); \
start = clock(); \
for(size_t i = 0; i < count; ++i) \
mode::fun(arr, arr + count, rand()); \
end = clock(); \
int n = static_cast<int>(static_cast<double>(end - start) \
/ CLOCKS_PER_SEC * 1000); \
std::snprintf(buf, sizeof(buf), "%d", n); \
std::string t = buf; \
t += "ms |"; \
std::cout << std::setw(WIDE) << t; \
delete []arr; \
} while(0)
void binary_search_test()
{
std::cout << "[------------------- function : binary_search ------------------]" << std::endl;
std::cout << "| orders of magnitude |";
TEST_LEN(LEN1, LEN2, LEN3, WIDE);
std::cout << "| std |";
FUN_TEST2(std, binary_search, LEN1);
FUN_TEST2(std, binary_search, LEN2);
FUN_TEST2(std, binary_search, LEN3);
std::cout << std::endl << "| mystl |";
FUN_TEST2(mystl, binary_search, LEN1);
FUN_TEST2(mystl, binary_search, LEN2);
FUN_TEST2(mystl, binary_search, LEN3);
std::cout << std::endl;
}
void sort_test()
{
std::cout << "[----------------------- function : sort -----------------------]" << std::endl;
std::cout << "| orders of magnitude |";
TEST_LEN(LEN1, LEN2, LEN3, WIDE);
std::cout << "| std |";
FUN_TEST1(std, sort, LEN1);
FUN_TEST1(std, sort, LEN2);
FUN_TEST1(std, sort, LEN3);
std::cout << std::endl << "| mystl |";
FUN_TEST1(mystl, sort, LEN1);
FUN_TEST1(mystl, sort, LEN2);
FUN_TEST1(mystl, sort, LEN3);
std::cout << std::endl;
}
void algorithm_performance_test()
{
#if PERFORMANCE_TEST_ON
std::cout << "[===============================================================]" << std::endl;
std::cout << "[--------------- Run algorithm performance test ----------------]" << std::endl;
sort_test();
binary_search_test();
std::cout << "[--------------- End algorithm performance test ----------------]" << std::endl;
std::cout << "[===============================================================]" << std::endl;
#endif // PERFORMANCE_TEST_ON
}
} // namespace algorithm_performance_test
} // namespace test
} // namespace mystl
#endif // !MYTINYSTL_ALGORITHM_PERFORMANCE_TEST_H_
``` | /content/code_sandbox/Test/algorithm_performance_test.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 970 |
```objective-c
// ============================================================================
//
// Header File : redbud/platform.h
//
// This file contains some preprocessing macros related to the platform.
// ============================================================================
#ifndef ALINSHANS_REDBUD_PLATFORM_H_
#define ALINSHANS_REDBUD_PLATFORM_H_
// your_sha256_hash------------
// os
#if defined(WIN32) || defined(_WIN32) || defined(_WIN64)
#define REDBUD_WIN 1
#elif defined(__unix__) || defined(__unix) || defined(__linux__)
#define REDBUD_LINUX 1
#elif defined(__APPLE__) || defined(__MACH__)
#define REDBUD_OSX 1
#else
#error "System that is not supported yet."
#endif
// your_sha256_hash------------
// complier
#if defined(__clang__)
#define REDBUD_CLANG __clang__
#elif defined(__GNUC__)
#define REDBUD_GNUC __GNUC__
#elif defined(_MSC_VER)
#define REDBUD_MSVC _MSC_VER
#else
#error "Complier that is not supported yet."
#endif
// your_sha256_hash------------
// stringify
#define REDBUD_TO_STRING(x) #x
#define REDBUD_STRING(x) REDBUD_TO_STRING(x)
// your_sha256_hash------------
// join
#define REDBUD_DO_JOIN(x ,y) x##y
#define REDBUD_JOIN(x, y) REDBUD_DO_JOIN(x, y)
// your_sha256_hash------------
// version
#define REDBUD_MAJOR 1
#define REDBUD_MINOR 0
#define REDBUD_PATCH 0
#define REDBUD_VERSION \
REDBUD_STRING(REDBUD_MAJOR.REDBUD_MINOR.REDBUD_PATCH)
#define _VERSION_CODE(x,y,z) \
(((x)*100000) + ((y)*100) + (z))
#define GNUC_VERSION \
_VERSION_CODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
#define CLANG_VERSION \
_VERSION_CODE(__clang_major__, __clang_minor__, __clang_patchlevel__)
// your_sha256_hash------------
// redbud API
#ifndef _REDBUD_API
#define _REDBUD_API ::redbud::
#endif
// your_sha256_hash------------
// C++11 required
#ifndef REDBUD_HAS_CXX11
#if defined(REDBUD_MSVC) && (REDBUD_MSVC >= 1900)
#define REDBUD_HAS_CXX11 1
#elif defined(REDBUD_GNUC) && (GNUC_VERSION >= _VERSION_CODE(4,8,0)) && \
defined(__GXX_EXPERIMENTAL_CXX0X__)
#define REDBUD_HAS_CXX11 1
#elif defined(REDBUD_CLANG) && (CLANG_VERSION >= _VERSION_CODE(3,3,0))
#define REDBUD_HAS_CXX11 1
#else
#define REDBUD_HAS_CXX11 0
#endif
#endif // !REDBUD_HAS_CXX11
#if REDBUD_HAS_CXX11 == 0
#error "C++11 required."
#endif
// your_sha256_hash------------
// Undefines macro min and max in MSVC.
namespace redbud
{
#if REDBUD_MSVC
#define NOMINMAX
#endif
}
#endif // !ALINSHANS_REDBUD_PLATFORM_H_
``` | /content/code_sandbox/Test/Lib/redbud/platform.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 722 |
```objective-c
// ============================================================================
//
// Header File : redbud/io/color.h
//
// This file is used to control font format and color in the terminal, which
// refers to a project on github, see path_to_url .
// ============================================================================
#ifndef ALINSHANS_REDBUD_IO_COLOR_H_
#define ALINSHANS_REDBUD_IO_COLOR_H_
#include "../platform.h"
#if defined(REDBUD_LINUX) || defined(REDBUD_OSX)
#include <unistd.h> // getenv
#include <cstring> // strstr
#elif defined(REDBUD_WIN)
#include <Windows.h>
#include <io.h>
#endif
#include <cstdlib>
#include <iostream>
#include <type_traits>
namespace redbud
{
namespace io
{
// ============================================================================
// Enumerates the ANSI escape code corresponding to the font attributes.
// See path_to_url for details.
//
// Example:
// using namespace redbud::io;
// std::cout << fg::red << "This text has a red foreground color\n";
// std::cout << bg::green << "This text has a green background color\n"
// ============================================================================
// Sets the text format, some of them is not widely supported.
enum class format
{
reset = 0, // All attributes off.
bold = 1, // Bold or increased intensity.
faint = 2, // Faint (decreased intensity).
italic = 3, // Italian font.
underline = 4, // Underline.
blinkslow = 5, // Blink slowly.
blinkrapid = 6, // Blink quickly.
inverse = 7, // Swap foreground and background.
conceal = 8, // Hide the text.
strikeline = 9 // Characters legible, but marked for deletion.
};
// Sets the foreground color.
enum class fg
{
black = 30,
red = 31,
green = 32,
yellow = 33,
blue = 34,
purple = 35,
cyan = 36,
white = 37,
reserve = 38,
reset = 39
};
// Sets the background color.
enum class bg
{
black = 40,
red = 41,
green = 42,
yellow = 43,
blue = 44,
purple = 45,
cyan = 46,
white = 47,
reserve = 38,
reset = 39
};
// Sets the highlight foreground color.
enum class hfg
{
black = 90,
red = 91,
green = 92,
yellow = 93,
blue = 94,
purple = 95,
cyan = 96,
white = 97
};
// Sets the highlight background color.
enum class hbg
{
black = 100,
red = 101,
green = 102,
yellow = 103,
blue = 104,
purple = 105,
cyan = 106,
white = 107
};
// Sets the control state.
enum class state
{
automatic = 0, // Automatic control.
manual = 1 // Manual control.
};
// your_sha256_hash------------
// Details
namespace details
{
// Manages associated stream buffer.
inline const std::streambuf*& get_coutbuf()
{
static const std::streambuf* pout = std::cout.rdbuf();
return pout;
}
inline const std::streambuf*& get_cerrbuf()
{
static const std::streambuf* perr = std::cerr.rdbuf();
return perr;
}
inline const std::streambuf*& get_clogbuf()
{
static const std::streambuf* plog = std::clog.rdbuf();
return plog;
}
// Gets an unique integer to use as index to iword()
inline int get_iword()
{
static int i = std::ios_base::xalloc();
return i;
}
// Determines whether the terminal color of this system can be modified.
inline bool is_modifiable()
{
#if defined(REDBUD_LINUX) || defined(REDBUD_OSX)
static constexpr const char* terms[] = {
"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm",
"linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"
};
const char *penv = std::getenv("TERM");
if (penv == nullptr)
{
return false;
}
bool result = false;
for (const auto& t : terms)
{
if (std::strstr(penv, t) != nullptr)
{
result = true;
break;
}
}
#elif defined(REDBUD_WIN)
static constexpr bool result = true;
#endif
return result;
}
/// Determines whether the buffer stream reaches the end.
inline bool is_terminal(const std::streambuf* buf)
{
if (buf == get_coutbuf())
{
#if defined(REDBUD_LINUX) || defined(REDBUD_OSX)
return isatty(fileno(stdout)) ? true : false;
#elif defined(REDBUD_WIN)
return _isatty(_fileno(stdout)) ? true : false;
#endif
}
if (buf == get_cerrbuf() || buf == get_clogbuf())
{
#if defined(REDBUD_LINUX) || defined(REDBUD_OSX)
return isatty(fileno(stderr)) ? true : false;
#elif defined(REDBUD_WIN)
return _isatty(_fileno(stderr)) ? true : false;
#endif
}
return false;
}
// For overloading standard output stream.
template <typename T>
using color_return_t = typename std::enable_if<
std::is_same<T, redbud::io::format>::value ||
std::is_same<T, redbud::io::fg>::value ||
std::is_same<T, redbud::io::bg>::value ||
std::is_same<T, redbud::io::hfg>::value ||
std::is_same<T, redbud::io::hbg>::value,
std::ostream&>::type;
template <typename T>
using state_return_t = typename std::enable_if<
std::is_same<T, redbud::io::state>::value,
std::ostream&>::type;
// Sets the format and color of the text.
#if defined(REDBUD_LINUX) || defined(REDBUD_OSX)
template <typename T>
inline color_return_t<T> set_color(std::ostream& os, const T& value)
{
return os << "\033[" << static_cast<int>(value) << "m";
}
#elif defined(REDBUD_WIN)
static constexpr WORD default_state = (FOREGROUND_BLUE |
FOREGROUND_GREEN |
FOREGROUND_RED);
// Gets the corresponding RGB value on Windows.
inline WORD get_rgb(WORD rgb)
{
static constexpr WORD cor[8] = { 0, 4, 2, 6, 1, 5, 3, 7 };
return cor[rgb];
}
// Sets font attributes on Windows.
inline void set_attributes(redbud::io::fg color, WORD& state)
{
if (color == redbud::io::fg::reserve)
{
return;
}
state &= 0xFFF0;
if (color == redbud::io::fg::reset)
{
state |= default_state;
return;
}
state |= get_rgb(static_cast<WORD>(color) - 30);
}
inline void set_attributes(redbud::io::bg color, WORD& state)
{
if (color == redbud::io::bg::reserve)
{
return;
}
state &= 0xFF0F;
if (color == redbud::io::bg::reset)
{
return;
}
state |= get_rgb(static_cast<WORD>(color) - 40) << 4;
}
inline void set_attributes(redbud::io::hfg color, WORD& state)
{
state &= 0xFFF0;
state |= (static_cast<WORD>(0x8) |
get_rgb(static_cast<WORD>(color) - 90));
}
inline void set_attributes(redbud::io::hbg color, WORD& state)
{
state &= 0xFF0F;
state |= (static_cast<WORD>(0x80) |
get_rgb(static_cast<WORD>(color) - 100) << 4);
}
inline void set_attributes(redbud::io::format format, WORD& state)
{
if (format == redbud::io::format::reset)
{
state = default_state;
}
}
inline WORD& current_state()
{
static WORD state = default_state;
return state;
}
inline HANDLE get_console_handle()
{
static HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
return h;
}
template <typename T>
inline color_return_t<T> set_color(std::ostream& os, const T& value)
{
HANDLE h = get_console_handle();
if (h && is_terminal(os.rdbuf()))
{
set_attributes(value, current_state());
SetConsoleTextAttribute(h, current_state());
return os;
}
return os;
}
#endif
} // namespace details
// your_sha256_hash------------
// Overloads standard output stream to control the color of text.
template <typename T>
inline details::color_return_t<T>
operator<<(std::ostream& os, const T& value)
{
return (os.iword(details::get_iword()) ||
(details::is_modifiable() &&
details::is_terminal(os.rdbuf())))
? details::set_color(os, value)
: os;
}
template <typename T>
inline details::state_return_t<T>
operator<<(std::ostream& os, const T& value)
{
if (value == redbud::io::state::automatic)
{
os.iword(details::get_iword()) = 0;
}
else if (value == redbud::io::state::manual)
{
os.iword(details::get_iword()) = 1;
}
return os;
}
} // namespace io
} // namespace redbud
#endif // !ALINSHANS_REDBUD_IO_COLOR_H_
``` | /content/code_sandbox/Test/Lib/redbud/io/color.h | objective-c | 2016-08-05T04:08:41 | 2024-08-16T17:50:46 | MyTinySTL | Alinshans/MyTinySTL | 11,147 | 2,281 |
```javascript
const request = require('request');
const os = require('os');
const fs = require('fs');
const unzip = require('unzip2');
const platform = os.platform();
const DIST = './bin';
const urls = {
darwin: 'path_to_url
win32: 'path_to_url
linux: 'path_to_url
};
const files = {
darwin: ['ffmpeg', 'fpcalc', 'ffprobe', 'eyeD3/bin/eyeD3'],
linux: ['eyeD3/bin/eyeD3'],
win32: [],
};
const dlUnzip = (url, execFiles) => {
if (!fs.existsSync(DIST)) {
fs.mkdirSync(DIST);
}
console.log('Downloading binaries...');
const dl = request(url).pipe(fs.createWriteStream('./bin.zip'));
dl.on('finish', () => {
console.log('Unzipping binaries...');
const unz = fs.createReadStream('./bin.zip').pipe(unzip.Extract({ path: DIST }));
unz.on('finish', () => {
execFiles.forEach((file) => {
fs.chmodSync(DIST + '/' + file, 0755);
});
fs.unlinkSync('./bin.zip');
console.log('Done!');
});
});
};
if (urls[platform]) {
dlUnzip(urls[platform], files[platform]);
} else {
console.warning(`No binaries for your platform ${platform}, that's strange`);
}
``` | /content/code_sandbox/install.js | javascript | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 312 |
```yaml
branches:
only:
- master
image: Visual Studio 2017
platform:
- x64
environment:
CYG_ROOT: C:\cygwin64
init:
- git config --global core.autocrlf input
install:
- ps: Install-Product node 11 x64
build_script:
- npm install -g @angular/cli@1.0.0
- cd app/
- npm install
- '%CYG_ROOT%/bin/bash -lc "cd $APPVEYOR_BUILD_FOLDER; cd app; ./build.sh"'
- cd ../
- npm install
- npm run release
test: off
``` | /content/code_sandbox/appveyor.yml | yaml | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 146 |
```shell
#!/bin/sh
cd app
ng build --base-href './'
cd ..
electron .
``` | /content/code_sandbox/launch.sh | shell | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 20 |
```html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>AllToMP3 - Feedback</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="style.css">
</head>
<body>
<h1>AllToMP3 <small>Feedback</small></h1>
<form method="post" id="form">
<label for="email" i18n="email">
Your email address (if you want, so I can contact you if necessary)
</label>
<input type="text" name="email" class="email" id="email" />
<label for="message" i18n="message">
Your message
</label>
<textarea name="message" class="message" id="message"></textarea>
<input type="submit" value="Send" i18n="send" i18n-attr="value" />
</form>
<script type="text/javascript" src="feedback.js" charset="utf-8"></script>
</body>
</html>
``` | /content/code_sandbox/feedback/index.html | html | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 249 |
```javascript
var electron = require('electron');
var fform = document.getElementById('form');
var femail = document.getElementById('email');
var fmessage = document.getElementById('message');
var infos;
if (localStorage.getItem('email')) {
femail.value = localStorage.getItem('email');
}
fform.onsubmit = function(e) {
e.preventDefault();
var data = {
email: femail.value,
message: fmessage.value,
infos: infos
};
localStorage.setItem('email', data.email);
console.log(data);
var http = new XMLHttpRequest();
var url = "path_to_url";
http.open("POST", url, true);
http.setRequestHeader("Content-Type", "application/json");
http.send(JSON.stringify(data));
alert(translation.confirmation);
fmessage.value = '';
};
electron.ipcRenderer.on('feedback.infos', function (event, inf) {
console.log("[Feedback] infos");
infos = inf;
});
var translations = {
fr: {
email: 'Votre adresse email (si vous le souhaitez, pour que je puisse vous contacter si ncessaire)',
message: 'Votre message',
send: 'Envoyer',
confirmation: 'Votre message a t envoy !'
},
en: {
confirmation: 'Your message has been sent!'
}
};
var translation = translations[navigator.language] || translations.en;
document.querySelectorAll('[i18n]').forEach(function (e) {
var attr = e.getAttribute('i18n-attr') || 'innerHTML';
if (translation[e.getAttribute('i18n')]) {
e[attr] = translation[e.getAttribute('i18n')];
}
});
``` | /content/code_sandbox/feedback/feedback.js | javascript | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 350 |
```css
@import url('path_to_url
html {
margin: 0;
padding: 0;
font-family: 'Source Sans Pro';
}
body {
padding: 20px;
}
label {
display: block;
}
.message {
width: 100%;
height: 200px;
margin-bottom: 20px;
}
.email {
margin-bottom: 20px;
}
input {
width: 100%;
font-family: 'Source Sans Pro';
}
textarea {
font-family: 'Source Sans Pro';
font-size: 1em;
}
h1 {
text-align: center;
margin-top: 0;
}
input, textarea {
color: #111;
background: none;
border: 1px solid #ff8a65;
}
input:focus, textarea:focus {
outline: none;
}
``` | /content/code_sandbox/feedback/style.css | css | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 182 |
```javascript
// Karma configuration file, see link for more information
// path_to_url
module.exports = function (config) {
config.set({
basePath: '',
frameworks: ['jasmine', 'angular-cli'],
plugins: [
require('karma-jasmine'),
require('karma-chrome-launcher'),
require('karma-remap-istanbul'),
require('angular-cli/plugins/karma')
],
files: [
{ pattern: './src/test.ts', watched: false }
],
preprocessors: {
'./src/test.ts': ['angular-cli']
},
mime: {
'text/x-typescript': ['ts','tsx']
},
remapIstanbulReporter: {
reports: {
html: 'coverage',
lcovonly: './coverage/coverage.lcov'
}
},
angularCli: {
config: './angular-cli.json',
environment: 'dev'
},
reporters: config.angularCli && config.angularCli.codeCoverage
? ['progress', 'karma-remap-istanbul']
: ['progress'],
port: 9876,
colors: true,
logLevel: config.LOG_INFO,
autoWatch: true,
browsers: ['Chrome'],
singleRun: false
});
};
``` | /content/code_sandbox/app/karma.conf.js | javascript | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 272 |
```javascript
// Protractor configuration file, see link for more information
// path_to_url
/*global jasmine */
var SpecReporter = require('jasmine-spec-reporter');
exports.config = {
allScriptsTimeout: 11000,
specs: [
'./e2e/**/*.e2e-spec.ts'
],
capabilities: {
'browserName': 'chrome'
},
directConnect: true,
baseUrl: 'path_to_url
framework: 'jasmine',
jasmineNodeOpts: {
showColors: true,
defaultTimeoutInterval: 30000,
print: function() {}
},
useAllAngular2AppRoots: true,
beforeLaunch: function() {
require('ts-node').register({
project: 'e2e'
});
},
onPrepare: function() {
jasmine.getEnv().addReporter(new SpecReporter());
}
};
``` | /content/code_sandbox/app/protractor.conf.js | javascript | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 188 |
```javascript
const { app, BrowserWindow, ipcMain, Menu } = require('electron');
const autoUpdater = require("electron-updater").autoUpdater;
const path = require('path');
const url = require('url');
const nedb = require('nedb-promise');
const util = require('util');
const os = require('os');
const ncp = require('ncp');
const request = require('request');
const alltomp3 = require('alltomp3');
const VERSION = app.getVersion();
let DEV = false;
if (process.env.ALLTOMP3_DEV == '1') {
DEV = true;
}
// autoUpdater
if (!DEV && os.platform() != 'linux') {
autoUpdater.checkForUpdates();
}
var db = {
config: nedb.datastore({ filename: path.join(app.getPath('userData'), 'config.db'), autoload: true })
};
var perrors = [];
process.on('uncaughtException', function (error) {
perrors.push(error);
console.log(error);
});
// Configure alltomp3 library binaries
function asarPath(p) {
return p.replace('app.asar', 'app.asar.unpacked');
}
alltomp3.tempFolder = app.getPath('temp') + path.sep;
if (os.platform() == 'win32') { // On Windows, we need to move eyeD3 in the tempFolder
let eyeD3Folder = alltomp3.tempFolder + 'eyeD3';
let eyeD3Exe = path.join(eyeD3Folder, 'main.exe');
ncp(asarPath(path.join(__dirname, 'bin/eyeD3')), eyeD3Folder, () => {});
alltomp3.setFfmpegPaths(asarPath(path.join(__dirname, 'bin/ffmpeg.exe')), asarPath(path.join(__dirname, 'bin/ffprobe.exe')));
alltomp3.setFpcalcPath(asarPath(path.join(__dirname, 'bin/fpcalc.exe')));
alltomp3.configEyeD3(eyeD3Exe, eyeD3Folder, (m) => {
function changep(p) {
return path.join('..', path.basename(p));
}
if (m.lyrics) {
m.lyrics = changep(m.lyrics);
}
if (m.image) {
m.image = changep(m.image);
}
return m;
});
} else if (os.platform() == 'darwin') {
alltomp3.setFfmpegPaths(asarPath(path.join(__dirname, 'bin/ffmpeg')), asarPath(path.join(__dirname, 'bin/ffprobe')));
alltomp3.setFpcalcPath(asarPath(path.join(__dirname, 'bin/fpcalc')));
alltomp3.configEyeD3(asarPath(path.join(__dirname, 'bin/eyeD3/bin/eyeD3')), asarPath(path.join(__dirname, 'bin/eyeD3/build/lib')));
} else if (os.platform() == 'linux') {
alltomp3.configEyeD3(asarPath(path.join(__dirname, 'bin/eyeD3/bin/eyeD3')), asarPath(path.join(__dirname, 'bin/eyeD3/build/lib')));
}
// Database
// Initialization
db.config.findOne({ name: 'saving-path' }).then(conf => {
console.log(conf);
if (!conf) {
return db.config.insert({ name: 'saving-path', value: app.getPath('music') });
}
return conf;
});
let firstLaunch = false;
db.config.findOne({ name: 'help-displayedn' }).then(helpDisplayed => {
if (!helpDisplayed) {
firstLaunch = true;
return db.config.insert({ name: 'help-displayedn', value: 0 });
}
});
// Messages so the renderer can query the database
ipcMain.on('db.findOne', (event, arg) => {
console.log('[DB] findOne', arg);
db[arg.db].findOne(arg.query).then(record => {
console.log(record);
event.returnValue = record;
});
});
ipcMain.on('db.update', (event, arg) => {
console.log('[DB] update', arg);
db[arg.db].update(arg.query, arg.update).then(num => {
console.log(num, 'records updated');
event.returnValue = num;
});
});
ipcMain.on('app.ready', (event, arg) => {
db.config.findOne({ name: 'previous-version' }).then(previousVersion => {
if ((!firstLaunch && !previousVersion) || (previousVersion && previousVersion.value !== VERSION)) {
let pv;
if (previousVersion) {
pv = previousVersion.value;
} else {
pv = '0.2.5';
}
request({
uri: 'path_to_url + pv + '/' + VERSION,
json: true
}, (e, r, releaseNotes) => {
if (!e && releaseNotes && releaseNotes.length > 0) {
event.sender.send('releasenotes', releaseNotes);
}
});
}
if (!previousVersion) {
db.config.insert({ name: 'previous-version', value: VERSION });
} else if (previousVersion !== VERSION) {
db.config.update({ name: 'previous-version' }, { name: 'previous-version', value: VERSION });
}
});
db.config.findOne({ name: 'last-news' }).then(lastNews => {
if (lastNews){
request({
uri: 'path_to_url + os.platform() + '/' + VERSION + '/' + lastNews.value,
json: true
}, (e, r, news) => {
if (!e && news && news.length > 0) {
event.sender.send('news', news);
}
});
}
if (!lastNews) {
db.config.insert({ name: 'last-news', value: (new Date()).toISOString() });
} else {
db.config.update({ name: 'last-news' }, { name: 'last-news', value: (new Date()).toISOString() });
}
});
});
// alltomp3 library
function forwardEvents(emitter, sender, id, allData) {
let events = ['download', 'download-end', 'convert', 'error', 'infos', 'convert-end', 'end', 'begin-url', 'end-url'];
events.forEach(e => {
emitter.on(e, forwardEvent(e, sender, id, allData));
});
ipcMain.once('at3.abort.' + id, () => {
emitter.emit('abort');
});
}
function forwardEvent(name, sender, id, allData) {
return function(d) {
console.log('[AT3] event', name, d);
if (d instanceof Error) {
d = { error: true, name: d.name, message: d.message, stack: d.stack };
}
sender.send('at3.event', {
id: id,
name: name,
data: d,
allData: allData
});
}
}
ipcMain.on('at3.suggestions', (event, id, q) => {
console.log('[AT3] suggestions', q);
let type = alltomp3.typeOfQuery(q);
if (type == 'text') {
Promise.all([
alltomp3.suggestedSongs(q, 5),
alltomp3.suggestedAlbums(q, 5),
]).then(suggestions => {
event.sender.send('at3.answer.' + id, {
type: type,
suggestions: {
songs: suggestions[0],
albums: suggestions[1]
}
});
});
} else {
event.sender.send('at3.answer.' + id, {
type: type,
urlType: alltomp3.guessURLType(q)
});
}
});
/**
* q = {
* url: 'url to download',
* folder: 'folder where downloading the song',
* id: 'identifier choosen by the renderer to identify this download'
* }
*/
ipcMain.on('at3.downloadSingleURL', (event, q) => {
console.log('[AT3] downloadSingleURL', q);
let e = alltomp3.downloadAndTagSingleURL(q.url, q.folder);
forwardEvents(e, event.sender, q.id);
});
/**
* q = {
* track: 'trackInfos',
* folder: 'folder where downloading the song',
* id: 'identifier choosen by the renderer to identify this download'
* }
*/
ipcMain.on('at3.downloadTrack', (event, q) => {
console.log('[AT3] downloadTrack', q);
let e = alltomp3.downloadTrack(q.track, q.folder);
forwardEvents(e, event.sender, q.id);
});
/**
* q = {
* url: 'track url',
* folder: 'folder where downloading the song',
* id: 'identifier choosen by the renderer to identify this download'
* }
*/
ipcMain.on('at3.downloadTrackURL', (event, q) => {
console.log('[AT3] downloadTrackURL', q);
let e = alltomp3.downloadTrackURL(q.url, q.folder);
forwardEvents(e, event.sender, q.id);
});
/**
* q = {
* url: 'playlist URL',
* folder: 'folder where downloading the playlist',
* id: 'identifier choosen by the renderer to identify this download'
* }
*/
ipcMain.on('at3.downloadPlaylist', (event, q) => {
console.log('[AT3] downloadPlaylist', q);
let e = alltomp3.downloadPlaylist(q.url, q.folder, () => {}, 4, path.join('{artist}', '{title}'));
e.on('playlist-infos', playlistInfos => {
forwardEvents(e, event.sender, q.id, playlistInfos.items);
event.sender.send('at3.event', {
id: q.id,
name: 'playlist-infos',
data: playlistInfos,
allData: playlistInfos
});
});
});
// Install update
ipcMain.on('update.install', (event) => {
autoUpdater.quitAndInstall();
});
autoUpdater.on('update-downloaded', () => {
win.webContents.send('update.downloaded');
});
autoUpdater.on('update-available', () => {
win.webContents.send('update.available');
});
// Feedback
let feedbackWin = null;
ipcMain.on('feedback.launch', (event, infos) => {
console.log('[Feedback] launch');
if (feedbackWin != null) {
return;
}
feedbackWin = new BrowserWindow({width: 800, height: 460})
feedbackWin.webContents.on('did-finish-load', () => {
win.capturePage(image => {
infos.os = {
platform: process.platform,
version: os.release()
};
infos.version = VERSION;
infos.perrors = util.inspect(perrors);
infos.errors = util.inspect(infos.errors);
infos.screenshot = image.toPNG().toString('base64');
infos.locale = app.getLocale();
let infosify = JSON.stringify(infos);
feedbackWin.webContents.send('feedback.infos', infosify);
});
});
feedbackWin.loadURL(url.format({
pathname: path.join(__dirname, 'feedback/index.html'),
protocol: 'file:',
slashes: true
}));
// Open the DevTools.
if (DEV) {
feedbackWin.webContents.openDevTools();
}
feedbackWin.on('closed', () => {
feedbackWin = null;
});
});
let menuTexts = {
ar: {
about: '',
quit: '',
edit: '',
undo: '',
redo: ' ',
cut: '',
copy: '',
paste: '',
selectAll: ' ',
},
fa: {
about: '',
quit: '',
edit: '',
undo: ' ',
redo: ' ',
cut: '',
copy: '',
paste: '',
selectAll: ' ',
},
en: {
about: 'About',
quit: 'Quit',
edit: 'Edit',
undo: 'Undo',
redo: 'Redo',
cut: 'Cut',
copy: 'Copy',
paste: 'Paste',
selectAll: 'Select All',
},
es: {
about: 'Acerca de',
quit: 'Salir',
edit: 'Editar',
undo: 'Deshacer',
redo: 'Rehacer',
cut: 'Cortar',
copy: 'Copiar',
paste: 'Pegar',
selectAll: 'Seleccionar Todo',
},
fi: {
about: 'Tietoa',
quit: 'Sulje',
edit: 'Muokkaa',
undo: 'Kumoa',
redo: 'Tee uudestaan',
cut: 'Leikkaa',
copy: 'Kopioi',
paste: 'Liit',
selectAll: 'Valitse kaikki',
},
fr: {
about: ' propos',
quit: 'Quitter',
edit: 'dition',
undo: 'Annuler',
redo: 'Rpter',
cut: 'Couper',
copy: 'Copier',
paste: 'Coller',
selectAll: 'Tout slectionner',
},
it: {
about: 'Info',
quit: 'Esci',
edit: 'Modifica',
undo: 'Indietro',
redo: 'Avanti',
cut: 'Taglia',
copy: 'Copia',
paste: 'Incolla',
selectAll: 'Seleziona tutto',
},
ja: {
about: 'AllToMP3',
quit: '',
edit: '',
undo: '',
redo: '',
cut: '',
copy: '',
paste: '',
selectAll: '',
},
pt: {
about: 'Sobre',
quit: 'Sair',
edit: 'Editar',
undo: 'Desfazer',
redo: 'Refazer',
cut: 'Recortar',
copy: 'Copiar',
paste: 'Colar',
selectAll: 'Selecionar Tudo',
},
ru: {
about: ' ',
quit: '',
edit: '',
undo: '',
redo: '',
cut: '',
copy: '',
paste: '',
selectAll: ' ',
},
tr: {
about: 'Hakknda',
quit: 'k',
edit: 'Deitir',
undo: 'Geri',
redo: 'Tekrar',
cut: 'Kes',
copy: 'Kopyala',
paste: 'Yaptr',
selectAll: 'Hepsini se',
},
hu: {
about: 'Nvjegy',
quit: 'Kilps',
edit: 'Szerkeszts',
undo: 'Visszavons',
redo: 'Ismt',
cut: 'Kivgs',
copy: 'Msols',
paste: 'Beilleszts',
selectAll: 'sszes kijellse',
},
de: {
about: 'ber',
quit: 'Schlieen',
edit: 'Bearbeiten',
undo: 'Widerrufen',
redo: 'Wiederholen',
cut: 'Ausschneiden',
copy: 'Kopieren',
paste: 'Einfgen',
selectAll: 'Alles auswhlen'
},
he: {
about: '',
quit: '',
edit: '',
undo: '',
redo: '',
cut: '',
copy: '',
paste: '',
selectAll: ' '
},
nl: {
about: 'Over',
quit: 'Sluiten',
edit: 'Bewerken',
undo: 'Ongedaan maken',
redo: 'Opnieuw toepassen',
cut: 'Knippen',
copy: 'Kopiren',
paste: 'Plakken',
selectAll: 'Alles selecteren'
}
};
// Keep a global reference of the window object, if you don't, the window will
// be closed automatically when the JavaScript object is garbage collected.
let win;
function createWindow () {
let locales = app.getLocale().split('-');
let locale = locales[0];
if (locales.length == 2) {
alltomp3.regionCode = locales[1];
} else {
alltomp3.relevanceLanguage = locale;
}
let supportedLocales = ['en', 'fr', 'ar', 'tr', 'fi', 'ja', 'es', 'pt', 'de', 'it', 'hu', 'he', 'ru', 'ir', 'nl'];
let supportedLocale = 'en';
if (supportedLocales.indexOf(locale) > -1) {
supportedLocale = locale;
}
// Create the browser window.
win = new BrowserWindow({width: 400, height: 700})
// and load the index.html of the app.
if (DEV) {
win.loadURL('path_to_url
} else {
win.loadURL(url.format({
pathname: path.join(__dirname, 'app/dist/' + supportedLocale + '/index.html'),
protocol: 'file:',
slashes: true
}));
}
// Open the DevTools.
if (DEV) {
win.webContents.openDevTools();
}
// Emitted when the window is closed.
win.on('closed', () => {
// Dereference the window object, usually you would store windows
// in an array if your app supports multi windows, this is the time
// when you should delete the corresponding element.
win = null
});
let menuText = menuTexts[supportedLocale];
let template = [{
label: "AllToMP3",
submenu: [
{ label: menuText.about, selector: "orderFrontStandardAboutPanel:" },
{ type: "separator" },
{ label: menuText.quit, accelerator: "Command+Q", click: function() { app.quit(); }}
]}, {
label: menuText.edit,
submenu: [
{ label: menuText.undo, accelerator: "CmdOrCtrl+Z", selector: "undo:" },
{ label: menuText.redo, accelerator: "Shift+CmdOrCtrl+Z", selector: "redo:" },
{ type: "separator" },
{ label: menuText.cut, accelerator: "CmdOrCtrl+X", selector: "cut:" },
{ label: menuText.copy, accelerator: "CmdOrCtrl+C", selector: "copy:" },
{ label: menuText.paste, accelerator: "CmdOrCtrl+V", selector: "paste:" },
{ label: menuText.selectAll, accelerator: "CmdOrCtrl+A", selector: "selectAll:" }
]}
];
if (os.platform() == 'darwin') {
Menu.setApplicationMenu(Menu.buildFromTemplate(template));
}
}
// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
app.on('ready', createWindow);
// Quit when all windows are closed.
app.on('window-all-closed', () => {
// On macOS it is common for applications and their menu bar
// to stay active until the user quits explicitly with Cmd + Q
if (process.platform !== 'darwin') {
app.quit()
}
})
app.on('activate', () => {
// On macOS it's common to re-create a window in the app when the
// dock icon is clicked and there are no other windows open.
if (win === null) {
createWindow()
}
})
// In this file you can include the rest of your app's specific main process
// code. You can also put them in separate files and require them here.
``` | /content/code_sandbox/main.js | javascript | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 4,295 |
```html
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>AllToMP3</title>
<base href="/">
<script type="text/javascript">
var electron = require('electron');
</script>
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
<app-root>
<div style="text-align: center; text-transform: uppercase;" i18n>Loading</div>
</app-root>
</body>
</html>
``` | /content/code_sandbox/app/src/index.html | html | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 114 |
```shell
rm -rf dist/
mkdir dist
ng build --aot --output-path dist/en --base-href './'
ng build --aot --output-path dist/fr --locale fr --i18n-format xlf --i18n-file src/locale/messages.fr.xlf --base-href './'
ng build --aot --output-path dist/fi --locale fi --i18n-format xlf --i18n-file src/locale/messages.fi.xlf --base-href './'
ng build --aot --output-path dist/tr --locale tr --i18n-format xlf --i18n-file src/locale/messages.tr.xlf --base-href './'
ng build --aot --output-path dist/ja --locale ja --i18n-format xlf --i18n-file src/locale/messages.ja.xlf --base-href './'
ng build --aot --output-path dist/es --locale es --i18n-format xlf --i18n-file src/locale/messages.es.xlf --base-href './'
ng build --aot --output-path dist/pt --locale pt --i18n-format xlf --i18n-file src/locale/messages.pt.xlf --base-href './'
ng build --aot --output-path dist/de --locale de --i18n-format xlf --i18n-file src/locale/messages.de.xlf --base-href './'
ng build --aot --output-path dist/ar --locale ar --i18n-format xlf --i18n-file src/locale/messages.ar.xlf --base-href './'
ng build --aot --output-path dist/it --locale it --i18n-format xlf --i18n-file src/locale/messages.it.xlf --base-href './'
ng build --aot --output-path dist/he --locale he --i18n-format xlf --i18n-file src/locale/messages.he.xlf --base-href './'
ng build --aot --output-path dist/hu --locale hu --i18n-format xlf --i18n-file src/locale/messages.hu.xlf --base-href './'
ng build --aot --output-path dist/ru --locale ru --i18n-format xlf --i18n-file src/locale/messages.ru.xlf --base-href './'
ng build --aot --output-path dist/ir --locale ir --i18n-format xlf --i18n-file src/locale/messages.ir.xlf --base-href './'
ng build --aot --output-path dist/nl --locale nl --i18n-format xlf --i18n-file src/locale/messages.nl.xlf --base-href './'
``` | /content/code_sandbox/app/build.sh | shell | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 552 |
```css
/* You can add global styles to this file, and also import other style files */
@import '../node_modules/@typopro/web-source-sans-pro/TypoPRO-SourceSansPro.css';
@import './assets/css/entypo.css';
html {
margin: 0;
padding: 0;
}
body {
margin: 0;
padding: 0;
font-family: 'TypoPRO Source Sans Pro';
background-color: #111;
color: white;
padding-bottom: 30px;
}
.legend {
font-size: 12px;
color: #888;
font-weight: 100;
margin-top: 4px;
margin-left: 16px;
font-style: italic;
}
.label {
display: inline-block;
font-size: 0.8em;
background-color: #222;
border: 1px solid #777;
border-radius: 3px;
padding: 0.2em;
cursor: pointer;
}
.clickable {
cursor: pointer;
}
.tooltip {
position: relative;
display: inline-block;
}
/* Tooltip text */
.tooltip .tooltiptext {
visibility: hidden;
width: 260px;
background-color: rgba(0, 0, 0, 0.7);
color: #fff;
font-size: 14px;
text-align: center;
padding: 5px;
border-radius: 6px;
/* Position the tooltip text - see examples below! */
position: absolute;
z-index: 1;
top: 125%;
left: 50%;
margin-left: -257px;
opacity: 0;
transition: visibility 0s linear 0.3s, opacity 0.3s linear;
}
/* Show the tooltip text when you mouse over the tooltip container */
.tooltip:hover .tooltiptext {
visibility: visible;
opacity: 1;
transition-delay: 0s;
}
.tooltip .tooltiptext::after {
content: " ";
position: absolute;
bottom: 100%; /* At the bottom of the tooltip */
left: 95%;
margin-left: -5px;
border-width: 5px;
border-style: solid;
border-color: transparent transparent black transparent;
}
``` | /content/code_sandbox/app/src/styles.css | css | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 502 |
```css
@font-face {
font-family: 'entypo';
src: url('../font/entypo.eot?34335183');
src: url('../font/entypo.eot?34335183#iefix') format('embedded-opentype'),
url('../font/entypo.woff2?34335183') format('woff2'),
url('../font/entypo.woff?34335183') format('woff'),
url('../font/entypo.ttf?34335183') format('truetype'),
url('../font/entypo.svg?34335183#entypo') format('svg');
font-weight: normal;
font-style: normal;
}
/* Chrome hack: SVG is rendered more smooth in Windozze. 100% magic, uncomment if you need it. */
/* Note, that will break hinting! In other OS-es font will be not as sharp as it could be */
/*
@media screen and (-webkit-min-device-pixel-ratio:0) {
@font-face {
font-family: 'entypo';
src: url('../font/entypo.svg?34335183#entypo') format('svg');
}
}
*/
[class^="icon-"]:before, [class*=" icon-"]:before {
font-family: "entypo";
font-style: normal;
font-weight: normal;
speak: none;
display: inline-block;
text-decoration: inherit;
width: 1em;
margin-right: .2em;
text-align: center;
/* opacity: .8; */
/* For safety - reset parent styles, that can break glyph codes*/
font-variant: normal;
text-transform: none;
/* fix buttons height, for twitter bootstrap */
line-height: 1em;
/* Animation center compensation - margins should be symmetric */
/* remove if not needed */
margin-left: .2em;
/* you can be more comfortable with increased icons size */
/* font-size: 120%; */
/* Font smoothing. That was taken from TWBS */
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
/* Uncomment for 3D effect */
/* text-shadow: 1px 1px 1px rgba(127, 127, 127, 0.3); */
}
.icon-beamed-note:before { content: '\e800'; } /* '' */
.icon-bug:before { content: '\e801'; } /* '' */
.icon-ccw:before { content: '\e802'; } /* '' */
.icon-circle:before { content: '\e803'; } /* '' */
.icon-circular-graph:before { content: '\e804'; } /* '' */
.icon-clapperboard:before { content: '\e805'; } /* '' */
.icon-cloud:before { content: '\e806'; } /* '' */
.icon-code:before { content: '\e807'; } /* '' */
.icon-cog:before { content: '\e808'; } /* '' */
.icon-controller-next:before { content: '\e809'; } /* '' */
.icon-controller-paus:before { content: '\e80a'; } /* '' */
.icon-controller-play:before { content: '\e80b'; } /* '' */
.icon-controller-stop:before { content: '\e80c'; } /* '' */
.icon-credit-card:before { content: '\e80d'; } /* '' */
.icon-cross:before { content: '\e80e'; } /* '' */
.icon-cw:before { content: '\e80f'; } /* '' */
.icon-cycle:before { content: '\e810'; } /* '' */
.icon-dot-single:before { content: '\e811'; } /* '' */
.icon-dots-three-horizontal:before { content: '\e812'; } /* '' */
.icon-dots-three-vertical:before { content: '\e813'; } /* '' */
.icon-dots-two-horizontal:before { content: '\e814'; } /* '' */
.icon-dots-two-vertical:before { content: '\e815'; } /* '' */
.icon-download:before { content: '\e816'; } /* '' */
.icon-drive:before { content: '\e817'; } /* '' */
.icon-edit:before { content: '\e818'; } /* '' */
.icon-email:before { content: '\e819'; } /* '' */
.icon-emoji-flirt:before { content: '\e81a'; } /* '' */
.icon-emoji-happy:before { content: '\e81b'; } /* '' */
.icon-emoji-neutral:before { content: '\e81c'; } /* '' */
.icon-emoji-sad:before { content: '\e81d'; } /* '' */
.icon-export:before { content: '\e81e'; } /* '' */
.icon-eye-with-line:before { content: '\e81f'; } /* '' */
.icon-eye:before { content: '\e820'; } /* '' */
.icon-flash:before { content: '\e821'; } /* '' */
.icon-folder-music:before { content: '\e822'; } /* '' */
.icon-folder:before { content: '\e823'; } /* '' */
.icon-gauge:before { content: '\e824'; } /* '' */
.icon-globe:before { content: '\e825'; } /* '' */
.icon-heart-outlined:before { content: '\e826'; } /* '' */
.icon-heart:before { content: '\e827'; } /* '' */
.icon-help-with-circle:before { content: '\e828'; } /* '' */
.icon-help:before { content: '\e829'; } /* '' */
.icon-home:before { content: '\e82a'; } /* '' */
.icon-hour-glass:before { content: '\e82b'; } /* '' */
.icon-infinity:before { content: '\e82c'; } /* '' */
.icon-install:before { content: '\e82d'; } /* '' */
.icon-lab-flask:before { content: '\e82e'; } /* '' */
.icon-link:before { content: '\e82f'; } /* '' */
.icon-list:before { content: '\e830'; } /* '' */
.icon-mail:before { content: '\e831'; } /* '' */
.icon-message:before { content: '\e832'; } /* '' */
.icon-music:before { content: '\e833'; } /* '' */
.icon-network:before { content: '\e834'; } /* '' */
.icon-new:before { content: '\e835'; } /* '' */
.icon-note:before { content: '\e836'; } /* '' */
.icon-save:before { content: '\e837'; } /* '' */
.icon-shuffle:before { content: '\e838'; } /* '' */
.icon-star-outlined:before { content: '\e839'; } /* '' */
.icon-star:before { content: '\e83a'; } /* '' */
.icon-typing:before { content: '\e83b'; } /* '' */
.icon-uninstall:before { content: '\e83c'; } /* '' */
.icon-upload:before { content: '\e83d'; } /* '' */
.icon-video:before { content: '\e83e'; } /* '' */
.icon-vinyl:before { content: '\e83f'; } /* '' */
.icon-warning:before { content: '\e840'; } /* '' */
.icon-app-store:before { content: '\e841'; } /* '' */
.icon-facebook-with-circle:before { content: '\e842'; } /* '' */
.icon-facebook:before { content: '\e843'; } /* '' */
.icon-github-with-circle:before { content: '\e844'; } /* '' */
.icon-grooveshark:before { content: '\e845'; } /* '' */
.icon-mail-with-circle:before { content: '\e846'; } /* '' */
.icon-soundcloud:before { content: '\e847'; } /* '' */
.icon-spotify-with-circle:before { content: '\e848'; } /* '' */
.icon-spotify:before { content: '\e849'; } /* '' */
.icon-vimeo-with-circle:before { content: '\e84a'; } /* '' */
.icon-vimeo:before { content: '\e84b'; } /* '' */
.icon-windows-store:before { content: '\e84c'; } /* '' */
.icon-youtube-with-circle:before { content: '\e84d'; } /* '' */
.icon-youtube:before { content: '\e84e'; } /* '' */
.icon-github:before { content: '\e84f'; } /* '' */
.icon-deezer-square:before { content: '\e850'; } /* '' */
.icon-deezer:before { content: '\e851'; } /* '' */
``` | /content/code_sandbox/app/src/assets/css/entypo.css | css | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 1,787 |
```css
[class^="icon-"], [class*=" icon-"] {
font-family: 'entypo';
font-style: normal;
font-weight: normal;
/* fix buttons height */
line-height: 1em;
/* you can be more comfortable with increased icons size */
/* font-size: 120%; */
}
.icon-beamed-note { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-bug { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-ccw { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-circular-graph { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-clapperboard { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-cloud { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-code { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-cog { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-controller-next { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-controller-paus { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-controller-play { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-controller-stop { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-credit-card { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-cross { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-cw { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-cycle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-dot-single { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-dots-three-horizontal { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-dots-three-vertical { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-dots-two-horizontal { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-dots-two-vertical { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-download { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-drive { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-edit { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-email { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-emoji-flirt { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-emoji-happy { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-emoji-neutral { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-emoji-sad { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-export { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-eye-with-line { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-eye { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-flash { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-folder-music { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-folder { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-gauge { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-globe { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-heart-outlined { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-heart { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-help-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-help { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-home { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-hour-glass { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-infinity { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-install { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-lab-flask { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-link { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-list { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-mail { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-message { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-music { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-network { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-new { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-note { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-save { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-shuffle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-star-outlined { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-star { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-typing { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-uninstall { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-upload { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-video { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-vinyl { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-warning { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-app-store { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-facebook-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-facebook { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-github-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-grooveshark { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-mail-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-soundcloud { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-spotify-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-spotify { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-vimeo-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-vimeo { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-windows-store { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-youtube-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-youtube { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-github { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-deezer-square { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-deezer { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
``` | /content/code_sandbox/app/src/assets/css/entypo-ie7.css | css | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 2,582 |
```css
.icon-beamed-note { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-bug { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-ccw { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-circular-graph { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-clapperboard { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-cloud { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-code { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-cog { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-controller-next { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-controller-paus { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-controller-play { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-controller-stop { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-credit-card { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-cross { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-cw { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-cycle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-dot-single { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-dots-three-horizontal { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-dots-three-vertical { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-dots-two-horizontal { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-dots-two-vertical { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-download { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-drive { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-edit { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-email { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-emoji-flirt { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-emoji-happy { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-emoji-neutral { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-emoji-sad { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-export { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-eye-with-line { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-eye { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-flash { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-folder-music { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-folder { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-gauge { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-globe { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-heart-outlined { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-heart { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-help-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-help { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-home { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-hour-glass { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-infinity { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-install { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-lab-flask { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-link { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-list { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-mail { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-message { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-music { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-network { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-new { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-note { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-save { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-shuffle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-star-outlined { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-star { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-typing { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-uninstall { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-upload { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-video { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-vinyl { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-warning { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-app-store { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-facebook-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-facebook { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-github-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-grooveshark { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-mail-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-soundcloud { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-spotify-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-spotify { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-vimeo-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-vimeo { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-windows-store { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-youtube-with-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-youtube { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-github { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-deezer-square { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
.icon-deezer { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); }
``` | /content/code_sandbox/app/src/assets/css/entypo-ie7-codes.css | css | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 2,510 |
```css
/*
Animation example, for spinners
*/
.animate-spin {
-moz-animation: spin 2s infinite linear;
-o-animation: spin 2s infinite linear;
-webkit-animation: spin 2s infinite linear;
animation: spin 2s infinite linear;
display: inline-block;
}
@-moz-keyframes spin {
0% {
-moz-transform: rotate(0deg);
-o-transform: rotate(0deg);
-webkit-transform: rotate(0deg);
transform: rotate(0deg);
}
100% {
-moz-transform: rotate(359deg);
-o-transform: rotate(359deg);
-webkit-transform: rotate(359deg);
transform: rotate(359deg);
}
}
@-webkit-keyframes spin {
0% {
-moz-transform: rotate(0deg);
-o-transform: rotate(0deg);
-webkit-transform: rotate(0deg);
transform: rotate(0deg);
}
100% {
-moz-transform: rotate(359deg);
-o-transform: rotate(359deg);
-webkit-transform: rotate(359deg);
transform: rotate(359deg);
}
}
@-o-keyframes spin {
0% {
-moz-transform: rotate(0deg);
-o-transform: rotate(0deg);
-webkit-transform: rotate(0deg);
transform: rotate(0deg);
}
100% {
-moz-transform: rotate(359deg);
-o-transform: rotate(359deg);
-webkit-transform: rotate(359deg);
transform: rotate(359deg);
}
}
@-ms-keyframes spin {
0% {
-moz-transform: rotate(0deg);
-o-transform: rotate(0deg);
-webkit-transform: rotate(0deg);
transform: rotate(0deg);
}
100% {
-moz-transform: rotate(359deg);
-o-transform: rotate(359deg);
-webkit-transform: rotate(359deg);
transform: rotate(359deg);
}
}
@keyframes spin {
0% {
-moz-transform: rotate(0deg);
-o-transform: rotate(0deg);
-webkit-transform: rotate(0deg);
transform: rotate(0deg);
}
100% {
-moz-transform: rotate(359deg);
-o-transform: rotate(359deg);
-webkit-transform: rotate(359deg);
transform: rotate(359deg);
}
}
``` | /content/code_sandbox/app/src/assets/css/animation.css | css | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 555 |
```css
.icon-beamed-note:before { content: '\e800'; } /* '' */
.icon-bug:before { content: '\e801'; } /* '' */
.icon-ccw:before { content: '\e802'; } /* '' */
.icon-circle:before { content: '\e803'; } /* '' */
.icon-circular-graph:before { content: '\e804'; } /* '' */
.icon-clapperboard:before { content: '\e805'; } /* '' */
.icon-cloud:before { content: '\e806'; } /* '' */
.icon-code:before { content: '\e807'; } /* '' */
.icon-cog:before { content: '\e808'; } /* '' */
.icon-controller-next:before { content: '\e809'; } /* '' */
.icon-controller-paus:before { content: '\e80a'; } /* '' */
.icon-controller-play:before { content: '\e80b'; } /* '' */
.icon-controller-stop:before { content: '\e80c'; } /* '' */
.icon-credit-card:before { content: '\e80d'; } /* '' */
.icon-cross:before { content: '\e80e'; } /* '' */
.icon-cw:before { content: '\e80f'; } /* '' */
.icon-cycle:before { content: '\e810'; } /* '' */
.icon-dot-single:before { content: '\e811'; } /* '' */
.icon-dots-three-horizontal:before { content: '\e812'; } /* '' */
.icon-dots-three-vertical:before { content: '\e813'; } /* '' */
.icon-dots-two-horizontal:before { content: '\e814'; } /* '' */
.icon-dots-two-vertical:before { content: '\e815'; } /* '' */
.icon-download:before { content: '\e816'; } /* '' */
.icon-drive:before { content: '\e817'; } /* '' */
.icon-edit:before { content: '\e818'; } /* '' */
.icon-email:before { content: '\e819'; } /* '' */
.icon-emoji-flirt:before { content: '\e81a'; } /* '' */
.icon-emoji-happy:before { content: '\e81b'; } /* '' */
.icon-emoji-neutral:before { content: '\e81c'; } /* '' */
.icon-emoji-sad:before { content: '\e81d'; } /* '' */
.icon-export:before { content: '\e81e'; } /* '' */
.icon-eye-with-line:before { content: '\e81f'; } /* '' */
.icon-eye:before { content: '\e820'; } /* '' */
.icon-flash:before { content: '\e821'; } /* '' */
.icon-folder-music:before { content: '\e822'; } /* '' */
.icon-folder:before { content: '\e823'; } /* '' */
.icon-gauge:before { content: '\e824'; } /* '' */
.icon-globe:before { content: '\e825'; } /* '' */
.icon-heart-outlined:before { content: '\e826'; } /* '' */
.icon-heart:before { content: '\e827'; } /* '' */
.icon-help-with-circle:before { content: '\e828'; } /* '' */
.icon-help:before { content: '\e829'; } /* '' */
.icon-home:before { content: '\e82a'; } /* '' */
.icon-hour-glass:before { content: '\e82b'; } /* '' */
.icon-infinity:before { content: '\e82c'; } /* '' */
.icon-install:before { content: '\e82d'; } /* '' */
.icon-lab-flask:before { content: '\e82e'; } /* '' */
.icon-link:before { content: '\e82f'; } /* '' */
.icon-list:before { content: '\e830'; } /* '' */
.icon-mail:before { content: '\e831'; } /* '' */
.icon-message:before { content: '\e832'; } /* '' */
.icon-music:before { content: '\e833'; } /* '' */
.icon-network:before { content: '\e834'; } /* '' */
.icon-new:before { content: '\e835'; } /* '' */
.icon-note:before { content: '\e836'; } /* '' */
.icon-save:before { content: '\e837'; } /* '' */
.icon-shuffle:before { content: '\e838'; } /* '' */
.icon-star-outlined:before { content: '\e839'; } /* '' */
.icon-star:before { content: '\e83a'; } /* '' */
.icon-typing:before { content: '\e83b'; } /* '' */
.icon-uninstall:before { content: '\e83c'; } /* '' */
.icon-upload:before { content: '\e83d'; } /* '' */
.icon-video:before { content: '\e83e'; } /* '' */
.icon-vinyl:before { content: '\e83f'; } /* '' */
.icon-warning:before { content: '\e840'; } /* '' */
.icon-app-store:before { content: '\e841'; } /* '' */
.icon-facebook-with-circle:before { content: '\e842'; } /* '' */
.icon-facebook:before { content: '\e843'; } /* '' */
.icon-github-with-circle:before { content: '\e844'; } /* '' */
.icon-grooveshark:before { content: '\e845'; } /* '' */
.icon-mail-with-circle:before { content: '\e846'; } /* '' */
.icon-soundcloud:before { content: '\e847'; } /* '' */
.icon-spotify-with-circle:before { content: '\e848'; } /* '' */
.icon-spotify:before { content: '\e849'; } /* '' */
.icon-vimeo-with-circle:before { content: '\e84a'; } /* '' */
.icon-vimeo:before { content: '\e84b'; } /* '' */
.icon-windows-store:before { content: '\e84c'; } /* '' */
.icon-youtube-with-circle:before { content: '\e84d'; } /* '' */
.icon-youtube:before { content: '\e84e'; } /* '' */
.icon-github:before { content: '\e84f'; } /* '' */
.icon-deezer-square:before { content: '\e850'; } /* '' */
.icon-deezer:before { content: '\e851'; } /* '' */
``` | /content/code_sandbox/app/src/assets/css/entypo-codes.css | css | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 1,280 |
```html
<div class="body">
<div class="header">
<div class="header-title">AllToMP3</div>
<div class="header-logos">
<i class="icon-youtube"></i>
<i class="icon-soundcloud"></i>
<i class="icon-spotify"></i>
<i class="icon-deezer"></i>
</div>
<div class="header-contact">
<div id="share-btn" class="share-div" (click)="shareClick()" (mouseout)="shareLeave()" data-clipboard-text="path_to_url">
<div class="tooltip">
<i class="icon-export"></i>
<span class="tooltiptext" i18n *ngIf="!shareCopied">Click to copy a link to AllToMP3's website, to share it with friends </span>
<span class="tooltiptext" i18n *ngIf="shareCopied">Copied in clipboard!</span>
</div>
</div>
<div id="share-btn" class="share-div" (click)="donateClick()">
<div class="tooltip">
<i class="icon-heart"></i>
<span class="tooltiptext" i18n>Like this program? Help me!</span>
</div>
</div>
<app-feedback></app-feedback>
</div>
</div>
<div class="input-div">
<form method="post" (submit)="execute($event)">
<input type="text" class="input-main" id="input-main" i18n-placeholder placeholder="What do you want to download?" (keydown)="search($event)" name="queryi" [(ngModel)]="queryi" autofocus="autofocus" [ngClass]="{'input-main-open': (suggestions.songs || suggestions.albums)}" (contextmenu)="contextMenu.openEditMenu()" />
<button type="submit" style="display: none"></button>
</form>
<div class="legend" *ngIf="unsupported" i18n>
This URL is not supported
</div>
<div class="legend" *ngIf="legend && !unsupported" i18n>
Press <span class="label">Enter</span> to download
</div>
<div *ngIf="suggestions.songs || suggestions.albums">
<app-suggestion *ngFor="let suggestion of suggestions.songs; let i = index" [suggestion]="suggestion" [type]="'track'" (click)="selectSuggestion(suggestion, 'track')" [active]="i === activeSuggestion"></app-suggestion>
<app-suggestion *ngFor="let suggestion of suggestions.albums; let i = index; let l = last" [suggestion]="suggestion" [type]="'album'" (click)="selectSuggestion(suggestion, 'album')" [active]="i === (activeSuggestion - suggestions.songs.length)" [last]="l"></app-suggestion>
</div>
<saving-path></saving-path>
</div>
<div class="requests-div">
<app-request *ngFor="let r of requests" [request]="r"></app-request>
</div>
<div class="help-div" *ngIf="displayHelp">
<app-help [selectProposal]="selectProposal()"></app-help>
</div>
<div class="news-div" *ngIf="!displayHelp">
<app-news></app-news>
</div>
</div>
``` | /content/code_sandbox/app/src/app/app.component.html | html | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 768 |
```css
.body {
max-width: 550px;
margin: 0 auto;
}
.header {
display: flex;
flex-direction: row;
margin: 20px;
justify-content: space-between;
align-items: center;
}
.header-title {
color: #ff8a65;
font-weight: 400;
font-size: 24px;
}
.header-logos {
color: #ff8a65;
text-align: center;
}
.header-contact {
color: #ff8a65;
text-align: center;
}
.share-div {
display: inline-block;
cursor: pointer;
}
.title {
text-align: center;
margin-bottom: 0px;
}
.subtitle {
text-align: center;
color: #ff8a65;
}
.input-div {
margin: 20px;
}
.input-main {
width: calc(100% - 32px);
background-color: #1a1a1a;
border: none;
padding-top: 4px;
padding-bottom: 4px;
padding-left: 16px;
padding-right: 16px;
color: white;
height: 22px;
border-radius: 15px;
border-right: none;
font-size: 14px;
font-family: 'TypoPRO Source Sans Pro';
font-weight: 200;
}
.input-main.input-main-open {
border-top-left-radius: 15px;
border-top-right-radius: 15px;
border-bottom-left-radius: 0px;
border-bottom-right-radius: 0px;
}
.input-main:focus {
outline: none;
}
.input-main::-webkit-input-placeholder {
transition: opacity 0.3s linear;
}
.input-main.fade::-webkit-input-placeholder {
opacity: 0;
}
.requests-div {
margin: 20px;
}
.help-div {
width: 90%;
text-align: left;
margin: 0 auto;
}
.news-div {
margin: 20px;
}
``` | /content/code_sandbox/app/src/app/app.component.css | css | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 437 |
```css
@font-face {
font-family: 'entypo';
src: url('../font/entypo.eot?72521212');
src: url('../font/entypo.eot?72521212#iefix') format('embedded-opentype'),
url('../font/entypo.svg?72521212#entypo') format('svg');
font-weight: normal;
font-style: normal;
}
@font-face {
font-family: 'entypo';
src: url('data:application/octet-stream;base64,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') format('woff'),
url('data:application/octet-stream;base64,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') format('truetype');
}
/* Chrome hack: SVG is rendered more smooth in Windozze. 100% magic, uncomment if you need it. */
/* Note, that will break hinting! In other OS-es font will be not as sharp as it could be */
/*
@media screen and (-webkit-min-device-pixel-ratio:0) {
@font-face {
font-family: 'entypo';
src: url('../font/entypo.svg?72521212#entypo') format('svg');
}
}
*/
[class^="icon-"]:before, [class*=" icon-"]:before {
font-family: "entypo";
font-style: normal;
font-weight: normal;
speak: none;
display: inline-block;
text-decoration: inherit;
width: 1em;
margin-right: .2em;
text-align: center;
/* opacity: .8; */
/* For safety - reset parent styles, that can break glyph codes*/
font-variant: normal;
text-transform: none;
/* fix buttons height, for twitter bootstrap */
line-height: 1em;
/* Animation center compensation - margins should be symmetric */
/* remove if not needed */
margin-left: .2em;
/* you can be more comfortable with increased icons size */
/* font-size: 120%; */
/* Uncomment for 3D effect */
/* text-shadow: 1px 1px 1px rgba(127, 127, 127, 0.3); */
}
.icon-beamed-note:before { content: '\e800'; } /* '' */
.icon-bug:before { content: '\e801'; } /* '' */
.icon-ccw:before { content: '\e802'; } /* '' */
.icon-circle:before { content: '\e803'; } /* '' */
.icon-circular-graph:before { content: '\e804'; } /* '' */
.icon-clapperboard:before { content: '\e805'; } /* '' */
.icon-cloud:before { content: '\e806'; } /* '' */
.icon-code:before { content: '\e807'; } /* '' */
.icon-cog:before { content: '\e808'; } /* '' */
.icon-controller-next:before { content: '\e809'; } /* '' */
.icon-controller-paus:before { content: '\e80a'; } /* '' */
.icon-controller-play:before { content: '\e80b'; } /* '' */
.icon-controller-stop:before { content: '\e80c'; } /* '' */
.icon-credit-card:before { content: '\e80d'; } /* '' */
.icon-cross:before { content: '\e80e'; } /* '' */
.icon-cw:before { content: '\e80f'; } /* '' */
.icon-cycle:before { content: '\e810'; } /* '' */
.icon-dot-single:before { content: '\e811'; } /* '' */
.icon-dots-three-horizontal:before { content: '\e812'; } /* '' */
.icon-dots-three-vertical:before { content: '\e813'; } /* '' */
.icon-dots-two-horizontal:before { content: '\e814'; } /* '' */
.icon-dots-two-vertical:before { content: '\e815'; } /* '' */
.icon-download:before { content: '\e816'; } /* '' */
.icon-drive:before { content: '\e817'; } /* '' */
.icon-edit:before { content: '\e818'; } /* '' */
.icon-email:before { content: '\e819'; } /* '' */
.icon-emoji-flirt:before { content: '\e81a'; } /* '' */
.icon-emoji-happy:before { content: '\e81b'; } /* '' */
.icon-emoji-neutral:before { content: '\e81c'; } /* '' */
.icon-emoji-sad:before { content: '\e81d'; } /* '' */
.icon-export:before { content: '\e81e'; } /* '' */
.icon-eye-with-line:before { content: '\e81f'; } /* '' */
.icon-eye:before { content: '\e820'; } /* '' */
.icon-flash:before { content: '\e821'; } /* '' */
.icon-folder-music:before { content: '\e822'; } /* '' */
.icon-folder:before { content: '\e823'; } /* '' */
.icon-gauge:before { content: '\e824'; } /* '' */
.icon-globe:before { content: '\e825'; } /* '' */
.icon-heart-outlined:before { content: '\e826'; } /* '' */
.icon-heart:before { content: '\e827'; } /* '' */
.icon-help-with-circle:before { content: '\e828'; } /* '' */
.icon-help:before { content: '\e829'; } /* '' */
.icon-home:before { content: '\e82a'; } /* '' */
.icon-hour-glass:before { content: '\e82b'; } /* '' */
.icon-infinity:before { content: '\e82c'; } /* '' */
.icon-install:before { content: '\e82d'; } /* '' */
.icon-lab-flask:before { content: '\e82e'; } /* '' */
.icon-link:before { content: '\e82f'; } /* '' */
.icon-list:before { content: '\e830'; } /* '' */
.icon-mail:before { content: '\e831'; } /* '' */
.icon-message:before { content: '\e832'; } /* '' */
.icon-music:before { content: '\e833'; } /* '' */
.icon-network:before { content: '\e834'; } /* '' */
.icon-new:before { content: '\e835'; } /* '' */
.icon-note:before { content: '\e836'; } /* '' */
.icon-save:before { content: '\e837'; } /* '' */
.icon-shuffle:before { content: '\e838'; } /* '' */
.icon-star-outlined:before { content: '\e839'; } /* '' */
.icon-star:before { content: '\e83a'; } /* '' */
.icon-typing:before { content: '\e83b'; } /* '' */
.icon-uninstall:before { content: '\e83c'; } /* '' */
.icon-upload:before { content: '\e83d'; } /* '' */
.icon-video:before { content: '\e83e'; } /* '' */
.icon-vinyl:before { content: '\e83f'; } /* '' */
.icon-warning:before { content: '\e840'; } /* '' */
.icon-app-store:before { content: '\e841'; } /* '' */
.icon-facebook-with-circle:before { content: '\e842'; } /* '' */
.icon-facebook:before { content: '\e843'; } /* '' */
.icon-github-with-circle:before { content: '\e844'; } /* '' */
.icon-grooveshark:before { content: '\e845'; } /* '' */
.icon-mail-with-circle:before { content: '\e846'; } /* '' */
.icon-soundcloud:before { content: '\e847'; } /* '' */
.icon-spotify-with-circle:before { content: '\e848'; } /* '' */
.icon-spotify:before { content: '\e849'; } /* '' */
.icon-vimeo-with-circle:before { content: '\e84a'; } /* '' */
.icon-vimeo:before { content: '\e84b'; } /* '' */
.icon-windows-store:before { content: '\e84c'; } /* '' */
.icon-youtube-with-circle:before { content: '\e84d'; } /* '' */
.icon-youtube:before { content: '\e84e'; } /* '' */
.icon-github:before { content: '\e84f'; } /* '' */
.icon-deezer-square:before { content: '\e850'; } /* '' */
.icon-deezer:before { content: '\e851'; } /* '' */
``` | /content/code_sandbox/app/src/assets/css/entypo-embedded.css | css | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 17,727 |
```html
<div class="request-div" *ngIf="!request.aborted" (click)="clickRequest()" [ngClass]="{'clickable': clickable()}">
<div class="request--icon" [ngStyle]="{'background-image': 'url(' + request.cover + ')'}">
<div class="request--progress--div" (mouseenter)="coverMouseEnter()" (mouseleave)="coverMouseLeave()" [ngClass]="{'clickable': (abortable || openable()), 'displayed': (!request.finished || (coverOver && openable()))}">
<div *ngIf="!request.finished">
<div class="request--progress" *ngIf="!abortable || !coverOver">
<svg viewbox="0 0 84 84" style="display: block; height: 84px; width: 84px; margin: -2px;">
<path fill="none" stroke-linecap="round" stroke-width="4" stroke="#fff"
[attr.d]="'M42 2 A 40 40 0 ' + pz() + ' 1 ' + px() + ' ' + py()">
</path>
</svg>
</div>
<div class="request--abort" (click)="abort()" *ngIf="abortable && coverOver">
<div class="abort--icon">
<i class="icon-cross"></i>
</div>
<div class="abort--legend" i18n>
Abort
</div>
</div>
</div>
<div class="request--open" *ngIf="openable() && coverOver" (click)="open($event)">
<div class="abort--icon">
<i class="icon-beamed-note"></i>
</div>
<div class="abort--legend">
Play
</div>
</div>
<div class="request--eta"></div>
</div>
</div>
<div class="request--core">
<div class="request--title">{{ request.title }}</div>
<div class="request--artist">{{ request.artistName }}</div>
<div class="request--length">{{ request.length }}</div>
<div *ngIf="request.playlist && !subOpened" (click)="subOpened = true" class="request-subs-open" i18n>
See the list
</div>
<div *ngIf="request.playlist && subOpened" (click)="subOpened = false" class="request-subs-open request-subs-opened" i18n>
Hide the list
</div>
<div *ngIf="subOpened">
<div *ngFor="let r of request.subrequests">
<div *ngIf="!r.aborted" class="request--sub" [ngClass]="{'request--sub--running': !r.finished}" [ngStyle]="{'background-image': (!r.finished && '-webkit-linear-gradient(0deg, white, white ' + r.progress + '%, #666 ' + r.progress + '%, #666)' || 'none')}">
{{ r.title }}
</div>
</div>
</div>
</div>
</div>
``` | /content/code_sandbox/app/src/app/request/request.component.html | html | 2016-07-29T12:27:38 | 2024-08-14T13:08:01 | alltomp3-app | AllToMP3/alltomp3-app | 1,313 | 689 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.