From: pabs Date: Mon, 3 Mar 2008 05:13:22 +0000 (+0000) Subject: Release 0.61.08 X-Git-Url: https://git.pterodactylus.net/?a=commitdiff_plain;h=882d07ee047a39f22beb7b77e120e1fe2ca4358e;p=synfig.git Release 0.61.08 git-svn-id: http://svn.voria.com/code@1842 1f10aa63-cdf2-0310-b900-c93c546f37ac --- diff --git a/ETL/tags/0.61.06/AUTHORS b/ETL/tags/0.61.06/AUTHORS new file mode 100644 index 0000000..83446da --- /dev/null +++ b/ETL/tags/0.61.06/AUTHORS @@ -0,0 +1,12 @@ +Developers: + +Robert B. Quattlebaum Jr (darco) +Adrian Bentley + +Contributors: + +Paul Wise (pabs) +Andreas Jochens +Chris Moore (dooglus) +Martin Michlmayr +Ralf Corsepius diff --git a/ETL/tags/0.61.06/ETL-config.in b/ETL/tags/0.61.06/ETL-config.in new file mode 100644 index 0000000..61bce4f --- /dev/null +++ b/ETL/tags/0.61.06/ETL-config.in @@ -0,0 +1,64 @@ +#!/bin/sh + +VERSION=@VERSION@ +PACKAGE=@PACKAGE@ + +usage() +{ + cat < + + + + ActivePerspectiveName + Project + AllowedModules + + + BundleLoadPath + + MaxInstances + n + Module + PBXSmartGroupTreeModule + Name + Groups and Files Outline View + + + BundleLoadPath + + MaxInstances + n + Module + PBXNavigatorGroup + Name + Editor + + + BundleLoadPath + + MaxInstances + n + Module + XCTaskListModule + Name + Task List + + + BundleLoadPath + + MaxInstances + n + Module + XCDetailModule + Name + File and Smart Group Detail Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXBuildResultsModule + Name + Detailed Build Results Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXProjectFindModule + Name + Project Batch Find Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXRunSessionModule + Name + Run Log + + + BundleLoadPath + + MaxInstances + n + Module + PBXBookmarksModule + Name + Bookmarks Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXClassBrowserModule + Name + Class Browser + + + BundleLoadPath + + MaxInstances + n + Module + PBXCVSModule + Name + Source Code Control Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXDebugBreakpointsModule + Name + Debug Breakpoints Tool + + + BundleLoadPath + + MaxInstances + n + Module + XCDockableInspector + Name + Inspector + + + BundleLoadPath + + MaxInstances + n + Module + PBXOpenQuicklyModule + Name + Open Quickly Tool + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugSessionModule + Name + Debugger + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugCLIModule + Name + Debug Console + + + Description + This workspace mimics that found in Xcode 1.2, with various minor improvements such as including attached editors to the build results window and the project find window. + DockingSystemVisible + + Extension + mode1 + FirstTimeWindowDisplayed + + Identifier + com.apple.perspectives.project.mode1 + MajorVersion + 31 + MinorVersion + 0 + Name + Default Workspace + Notifications + + OpenEditors + + Perspectives + + + ChosenToolbarItems + + active-target-popup + action + NSToolbarFlexibleSpaceItem + buildOrClean + build-and-runOrDebug + clean-target + com.apple.ide.PBXToolbarStopButton + get-info + toggle-editor + NSToolbarFlexibleSpaceItem + com.apple.pbx.toolbar.searchfield + + ControllerClassBaseName + + IconName + WindowOfProject + Identifier + perspective.project + IsVertical + + Layout + + + BecomeActive + + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C37FBAC04509CD000000102 + 1C37FAAC04509CD000000102 + 1C08E77C0454961000C914BD + 1C37FABC05509CD000000102 + 1C37FABC05539CD112110102 + E2644B35053B69B200211256 + 1C37FABC04509CD000100104 + + PBXProjectModuleGUID + 1CE0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + yes + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 265 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + F550016102F0983D01000102 + F550017202F0ABE401000102 + 1C37FABC05509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 1044}, {265, 435}} + + PBXTopSmartGroupGIDs + + + GeometryConfiguration + + Frame + {{0, 0}, {282, 453}} + GroupTreeTableConfiguration + + MainColumn + 265 + + RubberWindowFrame + 46 184 812 495 0 0 1152 848 + + Module + PBXSmartGroupTreeModule + Proportion + 282pt + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CE0B20306471E060097A5F4 + PBXProjectModuleLabel + _angle.h + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CE0B20406471E060097A5F4 + PBXProjectModuleLabel + _angle.h + bookmark + A6E2EB1707656ADC002AF736 + history + + A6E2EAF207656836002AF736 + + + SplitCount + 1 + + StatusBarVisibility + + + GeometryConfiguration + + Frame + {{0, 0}, {524, 0}} + RubberWindowFrame + 46 184 812 495 0 0 1152 848 + + Module + PBXNavigatorGroup + Proportion + 0pt + + + ContentConfiguration + + PBXProjectModuleGUID + 1CE0B20506471E060097A5F4 + PBXProjectModuleLabel + Targets + + GeometryConfiguration + + Frame + {{0, 7}, {524, 446}} + RubberWindowFrame + 46 184 812 495 0 0 1152 848 + + Module + XCDetailModule + Proportion + 446pt + + + Proportion + 524pt + + + Name + Project + ServiceClasses + + XCModuleDock + PBXSmartGroupTreeModule + XCModuleDock + PBXNavigatorGroup + XCDetailModule + + TableOfContents + + A6E2EAF407656836002AF736 + 1CE0B1FE06471DED0097A5F4 + A6E2EAF507656836002AF736 + 1CE0B20306471E060097A5F4 + 1CE0B20506471E060097A5F4 + + ToolbarConfiguration + xcode.toolbar.config.default + + + PerspectivesBarVisible + + StatusbarIsVisible + + TimeStamp + 0.0 + ToolbarDisplayMode + 1 + ToolbarIsVisible + + ToolbarSizeMode + 1 + Type + Perspectives + UpdateMessage + + WindowJustification + 5 + WindowOrderList + + A6E2EAFD076568E5002AF736 + A6E2EAFB076568E5002AF736 + /Users/darco/Projects/Voria/ETL/ETL.pbproj + + WindowString + 46 184 812 495 0 0 1152 848 + WindowTools + + + FirstTimeWindowDisplayed + + Identifier + windowTool.build + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528F0623707200166675 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CD052900623707200166675 + + SplitCount + 1 + + StatusBarVisibility + + + GeometryConfiguration + + Frame + {{0, 0}, {500, 66}} + RubberWindowFrame + 377 21 500 500 0 0 1152 848 + + Module + PBXNavigatorGroup + Proportion + 66pt + + + BecomeActive + + ContentConfiguration + + PBXProjectModuleGUID + XCMainBuildResultsModuleGUID + PBXProjectModuleLabel + Build + XCBuildResultsTrigger_Collapse + 1021 + XCBuildResultsTrigger_Open + 1011 + + GeometryConfiguration + + Frame + {{0, 73}, {500, 385}} + RubberWindowFrame + 377 21 500 500 0 0 1152 848 + + Module + PBXBuildResultsModule + Proportion + 385pt + + + Proportion + 458pt + + + Name + Build Results + ServiceClasses + + PBXBuildResultsModule + + StatusbarIsVisible + + TableOfContents + + A6E2EAFB076568E5002AF736 + A6E2EAFC076568E5002AF736 + 1CD0528F0623707200166675 + XCMainBuildResultsModuleGUID + + ToolbarConfiguration + xcode.toolbar.config.build + WindowString + 377 21 500 500 0 0 1152 848 + WindowToolGUID + A6E2EAFB076568E5002AF736 + WindowToolIsVisible + + + + Identifier + windowTool.debugger + Layout + + + Dock + + + ContentConfiguration + + Debugger + + HorizontalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {317, 164}} + {{317, 0}, {377, 164}} + + + VerticalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {694, 164}} + {{0, 164}, {694, 216}} + + + + LauncherConfigVersion + 8 + PBXProjectModuleGUID + 1C162984064C10D400B95A72 + PBXProjectModuleLabel + Debug - GLUTExamples (Underwater) + + GeometryConfiguration + + DebugConsoleDrawerSize + {100, 120} + DebugConsoleVisible + None + DebugConsoleWindowFrame + {{200, 200}, {500, 300}} + DebugSTDIOWindowFrame + {{200, 200}, {500, 300}} + Frame + {{0, 0}, {694, 380}} + RubberWindowFrame + 321 238 694 422 0 0 1440 878 + + Module + PBXDebugSessionModule + Proportion + 380pt + + + Proportion + 380pt + + + Name + Debugger + ServiceClasses + + PBXDebugSessionModule + + StatusbarIsVisible + + TableOfContents + + 1CD10A99069EF8BA00B06720 + 1C0AD2AB069F1E9B00FABCE6 + 1C162984064C10D400B95A72 + 1C0AD2AC069F1E9B00FABCE6 + + ToolbarConfiguration + xcode.toolbar.config.debug + WindowString + 321 238 694 422 0 0 1440 878 + WindowToolGUID + 1CD10A99069EF8BA00B06720 + WindowToolIsVisible + + + + Identifier + windowTool.find + Layout + + + Dock + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CDD528C0622207200134675 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CD0528D0623707200166675 + + SplitCount + 1 + + StatusBarVisibility + + + GeometryConfiguration + + Frame + {{0, 0}, {781, 167}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXNavigatorGroup + Proportion + 781pt + + + Proportion + 50% + + + BecomeActive + + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528E0623707200166675 + PBXProjectModuleLabel + Project Find + + GeometryConfiguration + + Frame + {{8, 0}, {773, 254}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXProjectFindModule + Proportion + 50% + + + Proportion + 428pt + + + Name + Project Find + ServiceClasses + + PBXProjectFindModule + + StatusbarIsVisible + + TableOfContents + + 1C530D57069F1CE1000CFCEE + 1C530D58069F1CE1000CFCEE + 1C530D59069F1CE1000CFCEE + 1CDD528C0622207200134675 + 1C530D5A069F1CE1000CFCEE + 1CE0B1FE06471DED0097A5F4 + 1CD0528E0623707200166675 + + WindowString + 62 385 781 470 0 0 1440 878 + WindowToolGUID + 1C530D57069F1CE1000CFCEE + WindowToolIsVisible + + + + Identifier + MENUSEPARATOR + + + Identifier + windowTool.debuggerConsole + Layout + + + Dock + + + BecomeActive + + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAAC065D492600B07095 + PBXProjectModuleLabel + Debugger Console + + GeometryConfiguration + + Frame + {{0, 0}, {440, 358}} + RubberWindowFrame + 650 41 440 400 0 0 1280 1002 + + Module + PBXDebugCLIModule + Proportion + 358pt + + + Proportion + 358pt + + + Name + Debugger Console + ServiceClasses + + PBXDebugCLIModule + + StatusbarIsVisible + + TableOfContents + + 1C78EAAD065D492600B07095 + 1C78EAAE065D492600B07095 + 1C78EAAC065D492600B07095 + + WindowString + 650 41 440 400 0 0 1280 1002 + + + FirstTimeWindowDisplayed + + Identifier + windowTool.run + Layout + + + Dock + + + ContentConfiguration + + LauncherConfigVersion + 3 + PBXProjectModuleGUID + 1CD0528B0623707200166675 + PBXProjectModuleLabel + Run + Runner + + HorizontalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {493, 167}} + {{0, 176}, {493, 267}} + + + VerticalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {405, 443}} + {{414, 0}, {514, 443}} + + + + + GeometryConfiguration + + Frame + {{0, 0}, {458, 143}} + RubberWindowFrame + 653 537 458 185 0 0 1152 848 + + Module + PBXRunSessionModule + Proportion + 143pt + + + Proportion + 143pt + + + Name + Run Log + ServiceClasses + + PBXRunSessionModule + + StatusbarIsVisible + + TableOfContents + + A6E2EAFD076568E5002AF736 + A6E2EAFE076568E5002AF736 + 1CD0528B0623707200166675 + A6E2EAFF076568E5002AF736 + + ToolbarConfiguration + xcode.toolbar.config.run + WindowString + 653 537 458 185 0 0 1152 848 + WindowToolGUID + A6E2EAFD076568E5002AF736 + WindowToolIsVisible + + + + Identifier + windowTool.scm + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAB2065D492600B07095 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1C78EAB3065D492600B07095 + + SplitCount + 1 + + StatusBarVisibility + + + GeometryConfiguration + + Frame + {{0, 0}, {452, 0}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + + Module + PBXNavigatorGroup + Proportion + 0pt + + + BecomeActive + + ContentConfiguration + + PBXProjectModuleGUID + 1CD052920623707200166675 + PBXProjectModuleLabel + SCM + + GeometryConfiguration + + ConsoleFrame + {{0, 259}, {452, 0}} + Frame + {{0, 7}, {452, 259}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + TableConfiguration + + Status + 30 + FileName + 199 + Path + 197.09500122070312 + + TableFrame + {{0, 0}, {452, 250}} + + Module + PBXCVSModule + Proportion + 259pt + + + Proportion + 266pt + + + Name + SCM + ServiceClasses + + PBXCVSModule + + StatusbarIsVisible + + TableOfContents + + 1C78EAB4065D492600B07095 + 1C78EAB5065D492600B07095 + 1C78EAB2065D492600B07095 + 1CD052920623707200166675 + + WindowString + 743 379 452 308 0 0 1280 1002 + + + Identifier + windowTool.breakpoints + Layout + + + Dock + + + BecomeActive + + ContentConfiguration + + PBXProjectModuleGUID + 1CD052930623707200166675 + PBXProjectModuleLabel + Breakpoints + + GeometryConfiguration + + BreakpointsTreeTableConfiguration + + enabledColumn + 16 + breakpointColumn + 201.5830078125 + + Frame + {{0, 0}, {240, 195}} + RubberWindowFrame + 342 421 240 216 0 0 1440 878 + + Module + PBXDebugBreakpointsModule + Proportion + 195pt + + + Proportion + 195pt + + + Name + Breakpoints + ServiceClasses + + PBXDebugBreakpointsModule + + StatusbarIsVisible + + TableOfContents + + 1C0AD2AD069F1E9B00FABCE6 + 1C0AD2AE069F1E9B00FABCE6 + 1CD052930623707200166675 + + WindowString + 342 421 240 216 0 0 1440 878 + WindowToolGUID + 1C0AD2AD069F1E9B00FABCE6 + WindowToolIsVisible + + + + Identifier + windowTool.bookmarks + Layout + + + Dock + + + Module + PBXBookmarksModule + Proportion + 166pt + + + Proportion + 166pt + + + Name + Bookmarks + ServiceClasses + + PBXBookmarksModule + + StatusbarIsVisible + + WindowString + 538 42 401 187 0 0 1280 1002 + + + Identifier + windowTool.classBrowser + Layout + + + Dock + + + BecomeActive + + ContentConfiguration + + OptionsSetName + Hierarchy, all classes + PBXProjectModuleGUID + 1CA6456E063B45B4001379D8 + PBXProjectModuleLabel + Class Browser - NSObject + + GeometryConfiguration + + ClassesFrame + {{0, 0}, {374, 96}} + ClassesTreeTableConfiguration + + PBXClassNameColumnIdentifier + 208 + PBXClassBookColumnIdentifier + 22 + + Frame + {{0, 0}, {630, 331}} + MembersFrame + {{0, 105}, {374, 395}} + MembersTreeTableConfiguration + + PBXMemberTypeIconColumnIdentifier + 22 + PBXMemberNameColumnIdentifier + 216 + PBXMemberTypeColumnIdentifier + 97 + PBXMemberBookColumnIdentifier + 22 + + PBXModuleWindowStatusBarHidden2 + + RubberWindowFrame + 385 179 630 352 0 0 1440 878 + + Module + PBXClassBrowserModule + Proportion + 331pt + + + Proportion + 331pt + + + Name + Class Browser + ServiceClasses + + PBXClassBrowserModule + + StatusbarIsVisible + + TableOfContents + + 1C0AD2AF069F1E9B00FABCE6 + 1C0AD2B0069F1E9B00FABCE6 + 1CA6456E063B45B4001379D8 + + ToolbarConfiguration + xcode.toolbar.config.classbrowser + WindowString + 385 179 630 352 0 0 1440 878 + WindowToolGUID + 1C0AD2AF069F1E9B00FABCE6 + WindowToolIsVisible + + + + + diff --git a/ETL/tags/0.61.06/ETL.pbproj/darco.pbxuser b/ETL/tags/0.61.06/ETL.pbproj/darco.pbxuser new file mode 100755 index 0000000..63eaae6 --- /dev/null +++ b/ETL/tags/0.61.06/ETL.pbproj/darco.pbxuser @@ -0,0 +1,859 @@ +// !$*UTF8*$! +{ + A6E2EADA07656777002AF736 = { + fallbackIsa = XCSourceControlManager; + isSCMEnabled = 0; + isa = PBXSourceControlManager; + scmConfiguration = { + }; + scmType = ""; + }; + A6E2EADB07656777002AF736 = { + indexTemplatePath = ""; + isa = PBXCodeSenseManager; + usesDefaults = 1; + wantsCodeCompletion = 1; + wantsCodeCompletionAutoSuggestions = 0; + wantsCodeCompletionCaseSensitivity = 1; + wantsCodeCompletionListAlways = 1; + wantsCodeCompletionOnlyMatchingItems = 1; + wantsCodeCompletionParametersIncluded = 1; + wantsCodeCompletionPlaceholdersInserted = 1; + wantsCodeCompletionTabCompletes = 1; + wantsIndex = 1; + }; + A6E2EAF207656836002AF736 = { + fRef = F5060A1C02F342A901000102; + isa = PBXBookmark; + }; + A6E2EB1707656ADC002AF736 = { + fRef = F5060A1C02F342A901000102; + isa = PBXTextBookmark; + name = "_angle.h: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 0; + vrLoc = 0; + }; + F5060A1C02F342A901000102 = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {608, 6187}}"; + sepNavSelRange = "{0, 0}"; + sepNavVisRect = "{{0, 0}, {0, 0}}"; + }; + }; + F5060A3602F37B5E01000102 = { + activeExec = 0; + executables = ( + F5060A3802F37B5E01000102, + ); + }; + F5060A3802F37B5E01000102 = { + activeArgIndex = 2147483647; + activeArgIndices = ( + ); + argumentStrings = ( + ); + configStateDict = { + }; + cppStopOnCatchEnabled = 0; + cppStopOnThrowEnabled = 0; + customDataFormattersEnabled = 1; + debuggerPlugin = GDBDebugging; + disassemblyDisplayState = 0; + dylibVariantSuffix = ""; + enableDebugStr = 1; + environmentEntries = ( + ); + isa = PBXExecutable; + libgmallocEnabled = 0; + name = "Handle Test"; + shlibInfoDictList = ( + ); + sourceDirectories = ( + ); + }; + F5060A3C02F37BAC01000102 = { + activeExec = 0; + executables = ( + F5060A4402F37BAC01000102, + ); + }; + F5060A4402F37BAC01000102 = { + activeArgIndex = 2147483647; + activeArgIndices = ( + ); + argumentStrings = ( + ); + configStateDict = { + }; + cppStopOnCatchEnabled = 0; + cppStopOnThrowEnabled = 0; + customDataFormattersEnabled = 1; + debuggerPlugin = GDBDebugging; + disassemblyDisplayState = 0; + dylibVariantSuffix = ""; + enableDebugStr = 1; + environmentEntries = ( + ); + isa = PBXExecutable; + libgmallocEnabled = 0; + name = "Angle Test"; + shlibInfoDictList = ( + ); + sourceDirectories = ( + ); + }; + F5060A4802F37BDD01000102 = { + activeExec = 0; + }; + F5060A5102F37D8201000102 = { + activeExec = 0; + executables = ( + F5060A5902F37D8201000102, + ); + }; + F5060A5902F37D8201000102 = { + activeArgIndex = 2147483647; + activeArgIndices = ( + ); + argumentStrings = ( + ); + configStateDict = { + }; + cppStopOnCatchEnabled = 0; + cppStopOnThrowEnabled = 0; + customDataFormattersEnabled = 1; + debuggerPlugin = GDBDebugging; + disassemblyDisplayState = 0; + dylibVariantSuffix = ""; + enableDebugStr = 1; + environmentEntries = ( + ); + isa = PBXExecutable; + libgmallocEnabled = 0; + name = "Smach Test"; + shlibInfoDictList = ( + ); + sourceDirectories = ( + ); + }; + F5060A5A02F37D8501000102 = { + activeExec = 0; + executables = ( + F5060A6202F37D8501000102, + ); + }; + F5060A6202F37D8501000102 = { + activeArgIndex = 2147483647; + activeArgIndices = ( + ); + argumentStrings = ( + ); + configStateDict = { + }; + cppStopOnCatchEnabled = 0; + cppStopOnThrowEnabled = 0; + customDataFormattersEnabled = 1; + debuggerPlugin = GDBDebugging; + disassemblyDisplayState = 0; + dylibVariantSuffix = ""; + enableDebugStr = 1; + environmentEntries = ( + ); + isa = PBXExecutable; + libgmallocEnabled = 0; + name = "Random Test"; + shlibInfoDictList = ( + ); + sourceDirectories = ( + ); + }; + F5060A6702F37DEF01000102 = { + activeExec = 0; + executables = ( + F5060A6F02F37DEF01000102, + ); + }; + F5060A6F02F37DEF01000102 = { + activeArgIndex = 2147483647; + activeArgIndices = ( + ); + argumentStrings = ( + ); + configStateDict = { + }; + cppStopOnCatchEnabled = 0; + cppStopOnThrowEnabled = 0; + customDataFormattersEnabled = 1; + debuggerPlugin = GDBDebugging; + disassemblyDisplayState = 0; + dylibVariantSuffix = ""; + enableDebugStr = 1; + environmentEntries = ( + ); + isa = PBXExecutable; + libgmallocEnabled = 0; + name = "Fixed Test"; + shlibInfoDictList = ( + ); + sourceDirectories = ( + ); + }; + F513069D032666F8012F4765 = { + activeExec = 0; + }; + F51307D803269B0F012F4765 = { + activeExec = 0; + executables = ( + F51307E103269B0F012F4765, + ); + }; + F51307E103269B0F012F4765 = { + activeArgIndex = 2147483647; + activeArgIndices = ( + ); + argumentStrings = ( + ); + configStateDict = { + }; + cppStopOnCatchEnabled = 0; + cppStopOnThrowEnabled = 0; + customDataFormattersEnabled = 1; + debuggerPlugin = GDBDebugging; + disassemblyDisplayState = 0; + dylibVariantSuffix = ""; + enableDebugStr = 1; + environmentEntries = ( + ); + isa = PBXExecutable; + libgmallocEnabled = 0; + name = "Stringf Test"; + shlibInfoDictList = ( + ); + sourceDirectories = ( + ); + }; + F54AEB2B02F6899D01000102 = { + activeExec = 0; + executables = ( + F54AEB3302F6899D01000102, + ); + }; + F54AEB3302F6899D01000102 = { + activeArgIndex = 2147483647; + activeArgIndices = ( + ); + argumentStrings = ( + ); + configStateDict = { + }; + cppStopOnCatchEnabled = 0; + cppStopOnThrowEnabled = 0; + customDataFormattersEnabled = 1; + debuggerPlugin = GDBDebugging; + disassemblyDisplayState = 0; + dylibVariantSuffix = ""; + enableDebugStr = 1; + environmentEntries = ( + ); + isa = PBXExecutable; + libgmallocEnabled = 0; + name = "Clock Test"; + shlibInfoDictList = ( + ); + sourceDirectories = ( + ); + }; + F550016502F0983D01000102 = { + activeBuildStyle = F550016402F0983D01000102; + activeExecutable = F5060A5902F37D8201000102; + activeTarget = F513069D032666F8012F4765; + addToTargets = ( + F588A3BC02F0CCE501000102, + ); + breakpoints = ( + F5AD1D3D03098DA401B5FFC8, + ); + codeSenseManager = A6E2EADB07656777002AF736; + executables = ( + F5060A3802F37B5E01000102, + F5060A4402F37BAC01000102, + F5060A5902F37D8201000102, + F5060A6202F37D8501000102, + F5060A6F02F37DEF01000102, + F54AEB3302F6899D01000102, + F576CB76031841EA01A80006, + F5CAA207031AD533012F434D, + F51307E103269B0F012F4765, + F58D9F8E037F146301A80006, + F58D9F97037F14FE01A80006, + ); + perUserDictionary = { + PBXConfiguration.PBXFileTableDataSource3.PBXFileTableDataSource = { + PBXFileTableDataSourceColumnSortingDirectionKey = "-1"; + PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID; + PBXFileTableDataSourceColumnWidthsKey = ( + 20, + 279, + 20, + 54, + 43, + 43, + 20, + ); + PBXFileTableDataSourceColumnsKey = ( + PBXFileDataSource_FiletypeID, + PBXFileDataSource_Filename_ColumnID, + PBXFileDataSource_Built_ColumnID, + PBXFileDataSource_ObjectSize_ColumnID, + PBXFileDataSource_Errors_ColumnID, + PBXFileDataSource_Warnings_ColumnID, + PBXFileDataSource_Target_ColumnID, + ); + }; + PBXConfiguration.PBXTargetDataSource.PBXTargetDataSource = { + PBXFileTableDataSourceColumnSortingDirectionKey = "-1"; + PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID; + PBXFileTableDataSourceColumnWidthsKey = ( + 20, + 241, + 62, + 20, + 56, + 43, + 43, + ); + PBXFileTableDataSourceColumnsKey = ( + PBXFileDataSource_FiletypeID, + PBXFileDataSource_Filename_ColumnID, + PBXTargetDataSource_PrimaryAttribute, + PBXFileDataSource_Built_ColumnID, + PBXFileDataSource_ObjectSize_ColumnID, + PBXFileDataSource_Errors_ColumnID, + PBXFileDataSource_Warnings_ColumnID, + ); + }; + PBXPerProjectTemplateStateSaveDate = 124086103; + PBXPrepackagedSmartGroups_v2 = ( + { + PBXTransientLocationAtTop = bottom; + absolutePathToBundle = ""; + activationKey = OldTargetSmartGroup; + clz = PBXTargetSmartGroup; + description = "Displays all targets of the project."; + globalID = 1C37FABC04509CD000000102; + name = Targets; + preferences = { + image = Targets; + }; + }, + { + PBXTransientLocationAtTop = bottom; + absolutePathToBundle = ""; + clz = PBXTargetSmartGroup2; + description = "Displays all targets of the project as well as nested build phases."; + globalID = 1C37FBAC04509CD000000102; + name = Targets; + preferences = { + image = Targets; + }; + }, + { + PBXTransientLocationAtTop = bottom; + absolutePathToBundle = ""; + clz = PBXExecutablesSmartGroup; + description = "Displays all executables of the project."; + globalID = 1C37FAAC04509CD000000102; + name = Executables; + preferences = { + image = Executable; + }; + }, + { + " PBXTransientLocationAtTop " = bottom; + absolutePathToBundle = ""; + clz = PBXErrorsWarningsSmartGroup; + description = "Displays files with errors or warnings."; + globalID = 1C08E77C0454961000C914BD; + name = "Errors and Warnings"; + preferences = { + fnmatch = ""; + image = WarningsErrors; + recursive = 1; + regex = ""; + root = ""; + }; + }, + { + PBXTransientLocationAtTop = bottom; + absolutePathToBundle = ""; + clz = PBXFilenameSmartGroup; + description = "Filters items in a given group (potentially recursively) based on matching the name with the regular expression of the filter."; + globalID = 1CC0EA4004350EF90044410B; + name = "Implementation Files"; + preferences = { + canSave = 1; + fnmatch = ""; + image = SmartFolder; + isLeaf = 0; + recursive = 1; + regex = "?*\\.[mcMC]"; + root = ""; + }; + }, + { + PBXTransientLocationAtTop = bottom; + absolutePathToBundle = ""; + clz = PBXFilenameSmartGroup; + description = "This group displays Interface Builder NIB Files."; + globalID = 1CC0EA4004350EF90041110B; + name = "NIB Files"; + preferences = { + canSave = 1; + fnmatch = "*.nib"; + image = SmartFolder; + isLeaf = 0; + recursive = 1; + regex = ""; + root = ""; + }; + }, + { + PBXTransientLocationAtTop = no; + absolutePathToBundle = ""; + clz = PBXFindSmartGroup; + description = "Displays Find Results."; + globalID = 1C37FABC05509CD000000102; + name = "Find Results"; + preferences = { + image = spyglass; + }; + }, + { + PBXTransientLocationAtTop = no; + absolutePathToBundle = ""; + clz = PBXBookmarksSmartGroup; + description = "Displays Project Bookmarks."; + globalID = 1C37FABC05539CD112110102; + name = Bookmarks; + preferences = { + image = Bookmarks; + }; + }, + { + PBXTransientLocationAtTop = bottom; + absolutePathToBundle = ""; + clz = XCSCMSmartGroup; + description = "Displays files with interesting SCM status."; + globalID = E2644B35053B69B200211256; + name = SCM; + preferences = { + image = PBXRepository; + isLeaf = 0; + }; + }, + { + PBXTransientLocationAtTop = bottom; + absolutePathToBundle = ""; + clz = PBXSymbolsSmartGroup; + description = "Displays all symbols for the project."; + globalID = 1C37FABC04509CD000100104; + name = "Project Symbols"; + preferences = { + image = ProjectSymbols; + isLeaf = 1; + }; + }, + { + PBXTransientLocationAtTop = bottom; + absolutePathToBundle = ""; + clz = PBXFilenameSmartGroup; + description = "Filters items in a given group (potentially recursively) based on matching the name with the regular expression of the filter."; + globalID = PBXTemplateMarker; + name = "Simple Filter SmartGroup"; + preferences = { + canSave = 1; + fnmatch = "*.nib"; + image = SmartFolder; + isLeaf = 0; + recursive = 1; + regex = ""; + root = ""; + }; + }, + { + PBXTransientLocationAtTop = bottom; + absolutePathToBundle = ""; + clz = PBXFilenameSmartGroup; + description = "Filters items in a given group (potentially recursively) based on matching the name with the regular expression of the filter."; + globalID = PBXTemplateMarker; + name = "Simple Regular Expression SmartGroup"; + preferences = { + canSave = 1; + fnmatch = ""; + image = SmartFolder; + isLeaf = 0; + recursive = 1; + regex = "?*\\.[mcMC]"; + root = ""; + }; + }, + { + PBXTransientLocationAtTop = bottom; + clz = XDDesignSmartGroup; + description = "Displays Xdesign models"; + globalID = 2E4A936305E6979E00701470; + name = Design; + preferences = { + image = Design; + isLeaf = 0; + }; + }, + ); + PBXWorkspaceContents = ( + { + LeftSlideOut = { + Split0 = { + Split0 = { + NavContent0 = { + bookmark = A6FEFDFB05DF3B2E00140006; + history = ( + F530FB0803650921012F4ADF, + F5429FB903A918AB01A80006, + F5429FBA03A918AB01A80006, + F5C1F0ED03BCE61101A80006, + A64F6F3B052BE34900140006, + A64F6F3C052BE34900140006, + A64F6F3D052BE34900140006, + A64F6F3E052BE34900140006, + A63F3B810551700E00140006, + A63F3B820551700E00140006, + A64EF6BF05A73A8F00140006, + ); + prevStack = ( + F5429FBC03A918AB01A80006, + F5429FBD03A918AB01A80006, + F5429FBE03A918AB01A80006, + F5C1F0EF03BCE61101A80006, + A64F6F41052BE34900140006, + A64F6F42052BE34900140006, + A64F6F43052BE34900140006, + A64F6F44052BE34900140006, + A64F6F45052BE34900140006, + A64F6F46052BE34900140006, + A63F3B830551700E00140006, + A63F3B840551700E00140006, + ); + }; + NavCount = 1; + NavGeometry0 = { + Frame = "{{0, 0}, {992, 458}}"; + NavBarVisible = YES; + }; + NavSplitVertical = NO; + }; + SplitCount = 1; + Tab1 = { + Debugger = { + Split0 = { + SplitCount = 2; + }; + SplitCount = 1; + TabCount = 2; + }; + LauncherConfigVersion = 7; + }; + Tab2 = { + LauncherConfigVersion = 3; + Runner = { + }; + }; + TabCount = 5; + }; + SplitCount = 1; + Tab1 = { + OptionsSetName = "Hierarchy, all classes"; + }; + TabCount = 5; + }; + }, + ); + PBXWorkspaceGeometries = ( + { + ContentSize = "{1276, 770}"; + LeftSlideOut = { + ActiveTab = 0; + ActiveTabName = PBXGroupTreeModule; + Collapsed = NO; + Frame = "{{0, 23}, {1276, 747}}"; + Split0 = { + ActiveTab = 2; + ActiveTabName = PBXBuildResultsModule; + Collapsed = NO; + Frame = "{{284, 0}, {992, 747}}"; + Split0 = { + Frame = "{{0, 289}, {992, 458}}"; + }; + SplitCount = 1; + Tab0 = { + Frame = "{{0, 0}, {572, 214}}"; + }; + Tab1 = { + Debugger = { + Collapsed = NO; + Frame = "{{0, 0}, {992, 150}}"; + Split0 = { + Frame = "{{0, 24}, {992, 126}}"; + Split0 = { + Frame = "{{0, 0}, {488, 126}}"; + }; + Split1 = { + DebugVariablesTableConfiguration = ( + Name, + 123, + Value, + 85, + Summary, + 261.123, + ); + Frame = "{{497, 0}, {495, 126}}"; + }; + SplitCount = 2; + }; + SplitCount = 1; + Tab0 = { + Frame = "{{0, 0}, {100, 50}}"; + }; + Tab1 = { + Frame = "{{0, 0}, {100, 50}}"; + }; + TabCount = 2; + TabsVisible = YES; + }; + Frame = "{{0, 0}, {992, 125}}"; + LauncherConfigVersion = 7; + }; + Tab2 = { + Frame = "{{0, 0}, {992, 254}}"; + LauncherConfigVersion = 3; + Runner = { + Frame = "{{0, 0}, {992, 254}}"; + }; + }; + Tab3 = { + BuildMessageFrame = "{{0, 0}, {994, 232}}"; + BuildTranscriptFrame = "{{0, 241}, {994, 2}}"; + BuildTranscriptFrameExpanded = YES; + Frame = "{{0, 0}, {992, 265}}"; + }; + Tab4 = { + Frame = "{{0, 0}, {612, 295}}"; + }; + TabCount = 5; + TabsVisible = YES; + }; + SplitCount = 1; + Tab0 = { + Frame = "{{0, 0}, {260, 747}}"; + GroupTreeTableConfiguration = ( + TargetStatusColumn, + 18, + MainColumn, + 205, + SCMStatusColumn, + 22, + ); + }; + Tab1 = { + ClassesFrame = "{{0, 0}, {247, 330}}"; + ClassesTreeTableConfiguration = ( + PBXBookColumnIdentifier, + 20, + PBXClassColumnIdentifier, + 204, + ); + Frame = "{{0, 0}, {245, 549}}"; + MembersFrame = "{{0, 339}, {247, 210}}"; + MembersTreeTableConfiguration = ( + PBXBookColumnIdentifier, + 20, + PBXMethodColumnIdentifier, + 203, + ); + }; + Tab2 = { + Frame = "{{0, 0}, {226, 549}}"; + }; + Tab3 = { + Frame = "{{0, 0}, {191, 747}}"; + TargetTableConfiguration = ( + ActiveObject, + 16, + ObjectNames, + 202.296, + ); + }; + Tab4 = { + BreakpointsTreeTableConfiguration = ( + breakpointColumn, + 138, + enabledColumn, + 31, + ); + Frame = "{{0, 0}, {191, 549}}"; + }; + TabCount = 5; + TabsVisible = YES; + }; + NavBarShownByDefault = YES; + StatusViewVisible = YES; + Template = F5F68CF101725D4C0D7A8F4C; + ToolbarVisible = YES; + WindowLocation = "{4, 0}"; + }, + ); + PBXWorkspaceStateSaveDate = 124086103; + }; + perUserProjectItems = { + A6E2EAF207656836002AF736 = A6E2EAF207656836002AF736; + A6E2EB1707656ADC002AF736 = A6E2EB1707656ADC002AF736; + }; + sourceControlManager = A6E2EADA07656777002AF736; + userBuildSettings = { + }; + }; + F576CB6D031841EA01A80006 = { + activeExec = 0; + executables = ( + F576CB76031841EA01A80006, + ); + }; + F576CB76031841EA01A80006 = { + activeArgIndex = 2147483647; + activeArgIndices = ( + ); + argumentStrings = ( + ); + configStateDict = { + }; + cppStopOnCatchEnabled = 0; + cppStopOnThrowEnabled = 0; + customDataFormattersEnabled = 1; + debuggerPlugin = GDBDebugging; + disassemblyDisplayState = 0; + dylibVariantSuffix = ""; + enableDebugStr = 1; + environmentEntries = ( + ); + isa = PBXExecutable; + libgmallocEnabled = 0; + name = "Hermite Test"; + shlibInfoDictList = ( + ); + sourceDirectories = ( + ); + }; + F588A3BC02F0CCE501000102 = { + activeExec = 0; + }; + F58D9F85037F146301A80006 = { + activeExec = 0; + executables = ( + F58D9F8E037F146301A80006, + ); + }; + F58D9F8E037F146301A80006 = { + activeArgIndex = 2147483647; + activeArgIndices = ( + ); + argumentStrings = ( + ); + configStateDict = { + }; + cppStopOnCatchEnabled = 0; + cppStopOnThrowEnabled = 0; + customDataFormattersEnabled = 1; + debuggerPlugin = GDBDebugging; + disassemblyDisplayState = 0; + enableDebugStr = 1; + environmentEntries = ( + ); + isa = PBXExecutable; + libgmallocEnabled = 0; + name = "Pen Test"; + shlibInfoDictList = ( + ); + sourceDirectories = ( + ); + }; + F58D9F8F037F14FE01A80006 = { + activeExec = 0; + executables = ( + F58D9F97037F14FE01A80006, + ); + }; + F58D9F97037F14FE01A80006 = { + activeArgIndex = 2147483647; + activeArgIndices = ( + ); + argumentStrings = ( + ); + configStateDict = { + }; + cppStopOnCatchEnabled = 0; + cppStopOnThrowEnabled = 0; + customDataFormattersEnabled = 1; + debuggerPlugin = GDBDebugging; + disassemblyDisplayState = 0; + dylibVariantSuffix = ""; + enableDebugStr = 1; + environmentEntries = ( + ); + isa = PBXExecutable; + libgmallocEnabled = 0; + name = "Surface Test"; + shlibInfoDictList = ( + ); + sourceDirectories = ( + ); + }; + F5AD1D3D03098DA401B5FFC8 = { + fileReference = F5060A1E02F342A901000102; + isa = PBXFileBreakpoint; + lineNumber = 5; + state = 2; + }; + F5CAA1FE031AD533012F434D = { + activeExec = 0; + executables = ( + F5CAA207031AD533012F434D, + ); + }; + F5CAA207031AD533012F434D = { + activeArgIndex = 2147483647; + activeArgIndices = ( + ); + argumentStrings = ( + ); + configStateDict = { + }; + cppStopOnCatchEnabled = 0; + cppStopOnThrowEnabled = 0; + customDataFormattersEnabled = 1; + debuggerPlugin = GDBDebugging; + disassemblyDisplayState = 0; + dylibVariantSuffix = ""; + enableDebugStr = 1; + environmentEntries = ( + ); + isa = PBXExecutable; + libgmallocEnabled = 0; + name = "Spline Test"; + shlibInfoDictList = ( + ); + sourceDirectories = ( + ); + }; +} diff --git a/ETL/tags/0.61.06/ETL.pbproj/etl_profile.h b/ETL/tags/0.61.06/ETL.pbproj/etl_profile.h new file mode 100644 index 0000000..e63e0fe --- /dev/null +++ b/ETL/tags/0.61.06/ETL.pbproj/etl_profile.h @@ -0,0 +1,40 @@ +/* include/etl_profile.h. Generated by configure. */ +/* include/etl_profile.h.in. Generated from configure.in by autoheader. */ + + +#ifndef __VETL_PROFILE_H +#define __VETL_PROFILE_H + +/* define if target is big endian */ +#define WORDS_BIGENDIAN + +#ifndef HAVE_GETTIMEOFDAY +#define HAVE_GETTIMEOFDAY +#endif + +#ifndef HAVE_PTHREAD_H +#define HAVE_PTHREAD_H +#endif + +#ifndef HAVE_SCHED_H +#define HAVE_SCHED_H +#endif + +#ifndef HAVE_PTHREAD_CREATE +#define HAVE_PTHREAD_CREATE +#endif + +#ifndef HAVE_VASPRINTF +#define HAVE_VASPRINTF +#endif + +#ifndef HAVE_VSNPRINTF +#define HAVE_VSNPRINTF +#endif + +#ifndef HAVE_VSPRINTF +#define HAVE_VSPRINTF +#endif + +#endif // __VETL_CONFIG_H + diff --git a/ETL/tags/0.61.06/ETL.pbproj/frameworkfix.cpp b/ETL/tags/0.61.06/ETL.pbproj/frameworkfix.cpp new file mode 100644 index 0000000..0aee6e8 --- /dev/null +++ b/ETL/tags/0.61.06/ETL.pbproj/frameworkfix.cpp @@ -0,0 +1,8 @@ +/* + * untitled.cpp + * ETL + * + * Created by Robert Quattlebaum on Mon Aug 26 2002. + * + */ + diff --git a/ETL/tags/0.61.06/ETL.pbproj/project.pbxproj b/ETL/tags/0.61.06/ETL.pbproj/project.pbxproj new file mode 100755 index 0000000..1be00a6 --- /dev/null +++ b/ETL/tags/0.61.06/ETL.pbproj/project.pbxproj @@ -0,0 +1,3111 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 39; + objects = { + A63F3B3E054DA00200140006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _misc.h; + path = ETL/_misc.h; + refType = 4; + sourceTree = ""; + }; + A63F3B3F054DA00200140006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = misc; + path = ETL/misc; + refType = 4; + sourceTree = ""; + }; + A63F3B40054DA00200140006 = { + fileRef = A63F3B3E054DA00200140006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + Private, + ); + }; + }; + A63F3B42054DA02500140006 = { + fileRef = A63F3B3F054DA00200140006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + A64F6D24052A9DCC00140006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _ref_count.h; + path = ETL/_ref_count.h; + refType = 4; + sourceTree = ""; + }; + A64F6D25052A9DCC00140006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = ref_count; + path = ETL/ref_count; + refType = 4; + sourceTree = ""; + }; + A64F6D26052A9DCC00140006 = { + fileRef = A64F6D24052A9DCC00140006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + Private, + ); + }; + }; + A64F6D28052A9DFF00140006 = { + fileRef = A64F6D25052A9DCC00140006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + A6E2EAC007656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F588A3BC02F0CCE501000102; + remoteInfo = "ETL Framework"; + }; + A6E2EAC107656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F51307D803269B0F012F4765; + remoteInfo = "Stringf Test"; + }; + A6E2EAC207656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F5060A6702F37DEF01000102; + remoteInfo = "Fixed Test"; + }; + A6E2EAC307656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F5060A5A02F37D8501000102; + remoteInfo = "Random Test"; + }; + A6E2EAC407656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F5060A5102F37D8201000102; + remoteInfo = "Smach Test"; + }; + A6E2EAC507656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F5060A3C02F37BAC01000102; + remoteInfo = "Angle Test"; + }; + A6E2EAC607656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F5060A3602F37B5E01000102; + remoteInfo = "Handle Test"; + }; + A6E2EAC707656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F576CB6D031841EA01A80006; + remoteInfo = "Hermite Test"; + }; + A6E2EAC807656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F54AEB2B02F6899D01000102; + remoteInfo = "Clock Test"; + }; + A6E2EAC907656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F5CAA1FE031AD533012F434D; + remoteInfo = "Spline Test"; + }; + A6E2EACA07656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F588A3BC02F0CCE501000102; + remoteInfo = "ETL Framework"; + }; + A6E2EACB07656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F588A3BC02F0CCE501000102; + remoteInfo = "ETL Framework"; + }; + A6E2EACC07656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F588A3BC02F0CCE501000102; + remoteInfo = "ETL Framework"; + }; + A6E2EACD07656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F588A3BC02F0CCE501000102; + remoteInfo = "ETL Framework"; + }; + A6E2EACE07656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F588A3BC02F0CCE501000102; + remoteInfo = "ETL Framework"; + }; + A6E2EACF07656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F588A3BC02F0CCE501000102; + remoteInfo = "ETL Framework"; + }; + A6E2EAD007656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F588A3BC02F0CCE501000102; + remoteInfo = "ETL Framework"; + }; + A6E2EAD107656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F588A3BC02F0CCE501000102; + remoteInfo = "ETL Framework"; + }; + A6E2EAD207656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F588A3BC02F0CCE501000102; + remoteInfo = "ETL Framework"; + }; + A6E2EAD307656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F588A3BC02F0CCE501000102; + remoteInfo = "ETL Framework"; + }; + A6E2EAD407656757002AF736 = { + containerPortal = F550016502F0983D01000102; + isa = PBXContainerItemProxy; + proxyType = 1; + remoteGlobalIDString = F588A3BC02F0CCE501000102; + remoteInfo = "ETL Framework"; + }; + A6E2EADC076567C1002AF736 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _rect.h; + path = ETL/_rect.h; + refType = 4; + sourceTree = ""; + }; + A6E2EADD076567C1002AF736 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _value.h; + path = ETL/_value.h; + refType = 4; + sourceTree = ""; + }; + A6E2EADE076567C1002AF736 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = rect; + path = ETL/rect; + refType = 4; + sourceTree = ""; + }; + A6E2EADF076567C1002AF736 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = value; + path = ETL/value; + refType = 4; + sourceTree = ""; + }; + A6E2EAE0076567C1002AF736 = { + fileRef = A6E2EADC076567C1002AF736; + isa = PBXBuildFile; + settings = { + }; + }; + A6E2EAE1076567C1002AF736 = { + fileRef = A6E2EADD076567C1002AF736; + isa = PBXBuildFile; + settings = { + }; + }; + A6E2EAE2076567C1002AF736 = { + fileRef = A6E2EADE076567C1002AF736; + isa = PBXBuildFile; + settings = { + }; + }; + A6E2EAE3076567C1002AF736 = { + fileRef = A6E2EADF076567C1002AF736; + isa = PBXBuildFile; + settings = { + }; + }; +//A60 +//A61 +//A62 +//A63 +//A64 +//F50 +//F51 +//F52 +//F53 +//F54 + F504527502F391C901000102 = { + buildSettings = { + COPY_PHASE_STRIP = NO; + DEBUGGING_SYMBOLS = YES; + OPTIMIZATION_CFLAGS = "-O0"; + PROFILING_CODE = YES; + }; + isa = PBXBuildStyle; + name = "Development (GCC3)"; + }; + F5060A0302F3337A01000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = etl_profile.h; + path = ETL.pbproj/etl_profile.h; + refType = 4; + sourceTree = ""; + }; + F5060A0402F3337A01000102 = { + fileRef = F5060A0302F3337A01000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F5060A0502F3366801000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = ipc; + path = ETL/ipc; + refType = 4; + sourceTree = ""; + }; + F5060A0602F3366801000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = thread; + path = ETL/thread; + refType = 4; + sourceTree = ""; + }; + F5060A0702F3366801000102 = { + fileRef = F5060A0502F3366801000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F5060A0802F3366801000102 = { + fileRef = F5060A0602F3366801000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F5060A1C02F342A901000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _angle.h; + path = ETL/_angle.h; + refType = 4; + sourceTree = ""; + }; + F5060A1D02F342A901000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _curve.h; + path = ETL/_curve.h; + refType = 4; + sourceTree = ""; + }; + F5060A1E02F342A901000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _fixed.h; + path = ETL/_fixed.h; + refType = 4; + sourceTree = ""; + }; + F5060A1F02F342A901000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _handle.h; + path = ETL/_handle.h; + refType = 4; + sourceTree = ""; + }; + F5060A2102F342A901000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _smach.h; + path = ETL/_smach.h; + refType = 4; + sourceTree = ""; + }; + F5060A2202F342A901000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _thread.h; + path = ETL/_thread.h; + refType = 4; + sourceTree = ""; + }; + F5060A2302F342A901000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _trivial.h; + path = ETL/_trivial.h; + refType = 4; + sourceTree = ""; + }; + F5060A2402F342A901000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = fixed; + path = ETL/fixed; + refType = 4; + sourceTree = ""; + }; + F5060A2502F342A901000102 = { + fileRef = F5060A1C02F342A901000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F5060A2602F342A901000102 = { + fileRef = F5060A1D02F342A901000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F5060A2702F342A901000102 = { + fileRef = F5060A1E02F342A901000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F5060A2802F342A901000102 = { + fileRef = F5060A1F02F342A901000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F5060A2A02F342A901000102 = { + fileRef = F5060A2102F342A901000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F5060A2B02F342A901000102 = { + fileRef = F5060A2202F342A901000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F5060A2C02F342A901000102 = { + fileRef = F5060A2302F342A901000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F5060A2D02F342A901000102 = { + fileRef = F5060A2402F342A901000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F5060A2E02F379BC01000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _random.h; + path = ETL/_random.h; + refType = 4; + sourceTree = ""; + }; + F5060A2F02F379BC01000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = random; + path = ETL/random; + refType = 4; + sourceTree = ""; + }; + F5060A3002F379BC01000102 = { + fileRef = F5060A2E02F379BC01000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F5060A3102F379BC01000102 = { + fileRef = F5060A2F02F379BC01000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F5060A3202F37B5E01000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXHeadersBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A3302F37B5E01000102 = { + buildActionMask = 2147483647; + files = ( + F5060A3B02F37BA101000102, + ); + isa = PBXSourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A3402F37B5E01000102 = { + buildActionMask = 2147483647; + files = ( + F5060A3A02F37B6E01000102, + ); + isa = PBXFrameworksBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A3502F37B5E01000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXRezBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A3602F37B5E01000102 = { + buildPhases = ( + F5060A3202F37B5E01000102, + F5060A3302F37B5E01000102, + F5060A3402F37B5E01000102, + F5060A3502F37B5E01000102, + ); + buildSettings = { + HEADER_SEARCH_PATHS = build/ETL.framework/Versions/A/Headers; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = "Handle Test"; + REZ_EXECUTABLE = YES; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + }; + dependencies = ( + F5060A4602F37BCA01000102, + ); + isa = PBXToolTarget; + name = "Handle Test"; + productInstallPath = /usr/local/bin; + productName = "Handle Test"; + productReference = F5060A3702F37B5E01000102; + }; + F5060A3702F37B5E01000102 = { + explicitFileType = "compiled.mach-o.executable"; + isa = PBXFileReference; + path = "Handle Test"; + refType = 3; + sourceTree = BUILT_PRODUCTS_DIR; + }; + F5060A3A02F37B6E01000102 = { + fileRef = F588A3BD02F0CCE501000102; + isa = PBXBuildFile; + settings = { + }; + }; + F5060A3B02F37BA101000102 = { + fileRef = F588A3D602F0CF9101000102; + isa = PBXBuildFile; + settings = { + }; + }; + F5060A3C02F37BAC01000102 = { + buildPhases = ( + F5060A3D02F37BAC01000102, + F5060A3E02F37BAC01000102, + F5060A4002F37BAC01000102, + F5060A4202F37BAC01000102, + ); + buildSettings = { + DEBUGGING_SYMBOLS = NO; + HEADER_SEARCH_PATHS = ETL.pbproj; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = "Angle Test"; + PROFILING_CODE = YES; + REZ_EXECUTABLE = YES; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + }; + dependencies = ( + F5060A4702F37BCD01000102, + ); + isa = PBXToolTarget; + name = "Angle Test"; + productInstallPath = /usr/local/bin; + productName = "Handle Test"; + productReference = F5060A4302F37BAC01000102; + }; + F5060A3D02F37BAC01000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXHeadersBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A3E02F37BAC01000102 = { + buildActionMask = 2147483647; + files = ( + F5060A4502F37BBA01000102, + ); + isa = PBXSourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A4002F37BAC01000102 = { + buildActionMask = 2147483647; + files = ( + F5060A4102F37BAC01000102, + ); + isa = PBXFrameworksBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A4102F37BAC01000102 = { + fileRef = F588A3BD02F0CCE501000102; + isa = PBXBuildFile; + settings = { + }; + }; + F5060A4202F37BAC01000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXRezBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A4302F37BAC01000102 = { + explicitFileType = "compiled.mach-o.executable"; + isa = PBXFileReference; + path = "Angle Test"; + refType = 3; + sourceTree = BUILT_PRODUCTS_DIR; + }; + F5060A4502F37BBA01000102 = { + fileRef = F5627F1902F0D1F801000102; + isa = PBXBuildFile; + settings = { + }; + }; + F5060A4602F37BCA01000102 = { + isa = PBXTargetDependency; + target = F588A3BC02F0CCE501000102; + targetProxy = A6E2EAD407656757002AF736; + }; + F5060A4702F37BCD01000102 = { + isa = PBXTargetDependency; + target = F588A3BC02F0CCE501000102; + targetProxy = A6E2EACB07656757002AF736; + }; + F5060A4802F37BDD01000102 = { + buildPhases = ( + ); + buildSettings = { + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = "All Tests"; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + }; + dependencies = ( + F51307E203269B1E012F4765, + F5CAA305031AEFBC012F434D, + F54AEB3502F689AD01000102, + F5CAA306031AEFC1012F434D, + F5060A4A02F37BF601000102, + F5060A4902F37BF401000102, + F5060A6502F37DD001000102, + F5060A6602F37DD201000102, + F5060A7402F37E3401000102, + ); + isa = PBXAggregateTarget; + name = "All Tests"; + productName = "All Tests"; + }; + F5060A4902F37BF401000102 = { + isa = PBXTargetDependency; + target = F5060A3C02F37BAC01000102; + targetProxy = A6E2EAC507656757002AF736; + }; + F5060A4A02F37BF601000102 = { + isa = PBXTargetDependency; + target = F5060A3602F37B5E01000102; + targetProxy = A6E2EAC607656757002AF736; + }; + F5060A4B02F37D3301000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.cpp.cpp; + name = fixed.cpp; + path = test/fixed.cpp; + refType = 4; + sourceTree = ""; + }; + F5060A4C02F37D3301000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.cpp.cpp; + name = random.cpp; + path = test/random.cpp; + refType = 4; + sourceTree = ""; + }; + F5060A4D02F37D3301000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.cpp.cpp; + name = smach.cpp; + path = test/smach.cpp; + refType = 4; + sourceTree = ""; + }; + F5060A5102F37D8201000102 = { + buildPhases = ( + F5060A5202F37D8201000102, + F5060A5302F37D8201000102, + F5060A5502F37D8201000102, + F5060A5702F37D8201000102, + ); + buildSettings = { + HEADER_SEARCH_PATHS = build/ETL.framework/Versions/A/Headers; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = "Smach Test"; + REZ_EXECUTABLE = YES; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + }; + dependencies = ( + F5060A7102F37E2601000102, + ); + isa = PBXToolTarget; + name = "Smach Test"; + productInstallPath = /usr/local/bin; + productName = "Handle Test"; + productReference = F5060A5802F37D8201000102; + }; + F5060A5202F37D8201000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXHeadersBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A5302F37D8201000102 = { + buildActionMask = 2147483647; + files = ( + F5060A6302F37DB001000102, + ); + isa = PBXSourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A5502F37D8201000102 = { + buildActionMask = 2147483647; + files = ( + F5060A5602F37D8201000102, + ); + isa = PBXFrameworksBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A5602F37D8201000102 = { + fileRef = F588A3BD02F0CCE501000102; + isa = PBXBuildFile; + settings = { + }; + }; + F5060A5702F37D8201000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXRezBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A5802F37D8201000102 = { + explicitFileType = "compiled.mach-o.executable"; + isa = PBXFileReference; + path = "Smach Test"; + refType = 3; + sourceTree = BUILT_PRODUCTS_DIR; + }; + F5060A5A02F37D8501000102 = { + buildPhases = ( + F5060A5B02F37D8501000102, + F5060A5C02F37D8501000102, + F5060A5E02F37D8501000102, + F5060A6002F37D8501000102, + ); + buildSettings = { + HEADER_SEARCH_PATHS = "ETL.pbproj include"; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = "Random Test"; + REZ_EXECUTABLE = YES; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + }; + dependencies = ( + F5060A7202F37E2901000102, + ); + isa = PBXToolTarget; + name = "Random Test"; + productInstallPath = /usr/local/bin; + productName = "Handle Test"; + productReference = F5060A6102F37D8501000102; + }; + F5060A5B02F37D8501000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXHeadersBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A5C02F37D8501000102 = { + buildActionMask = 2147483647; + files = ( + F5060A6402F37DB501000102, + ); + isa = PBXSourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A5E02F37D8501000102 = { + buildActionMask = 2147483647; + files = ( + F5060A5F02F37D8501000102, + ); + isa = PBXFrameworksBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A5F02F37D8501000102 = { + fileRef = F588A3BD02F0CCE501000102; + isa = PBXBuildFile; + settings = { + }; + }; + F5060A6002F37D8501000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXRezBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A6102F37D8501000102 = { + explicitFileType = "compiled.mach-o.executable"; + isa = PBXFileReference; + path = "Random Test"; + refType = 3; + sourceTree = BUILT_PRODUCTS_DIR; + }; + F5060A6302F37DB001000102 = { + fileRef = F5060A4D02F37D3301000102; + isa = PBXBuildFile; + settings = { + }; + }; + F5060A6402F37DB501000102 = { + fileRef = F5060A4C02F37D3301000102; + isa = PBXBuildFile; + settings = { + }; + }; + F5060A6502F37DD001000102 = { + isa = PBXTargetDependency; + target = F5060A5102F37D8201000102; + targetProxy = A6E2EAC407656757002AF736; + }; + F5060A6602F37DD201000102 = { + isa = PBXTargetDependency; + target = F5060A5A02F37D8501000102; + targetProxy = A6E2EAC307656757002AF736; + }; + F5060A6702F37DEF01000102 = { + buildPhases = ( + F5060A6802F37DEF01000102, + F5060A6902F37DEF01000102, + F5060A6B02F37DEF01000102, + F5060A6D02F37DEF01000102, + ); + buildSettings = { + HEADER_SEARCH_PATHS = "ETL.pbproj include"; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = "Fixed Test"; + REZ_EXECUTABLE = YES; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + }; + dependencies = ( + F5060A7302F37E2B01000102, + ); + isa = PBXToolTarget; + name = "Fixed Test"; + productInstallPath = /usr/local/bin; + productName = "Handle Test"; + productReference = F5060A6E02F37DEF01000102; + }; + F5060A6802F37DEF01000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXHeadersBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A6902F37DEF01000102 = { + buildActionMask = 2147483647; + files = ( + F5060A7002F37E0001000102, + ); + isa = PBXSourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A6B02F37DEF01000102 = { + buildActionMask = 2147483647; + files = ( + F5060A6C02F37DEF01000102, + ); + isa = PBXFrameworksBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A6C02F37DEF01000102 = { + fileRef = F588A3BD02F0CCE501000102; + isa = PBXBuildFile; + settings = { + }; + }; + F5060A6D02F37DEF01000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXRezBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5060A6E02F37DEF01000102 = { + explicitFileType = "compiled.mach-o.executable"; + isa = PBXFileReference; + path = "Fixed Test"; + refType = 3; + sourceTree = BUILT_PRODUCTS_DIR; + }; + F5060A7002F37E0001000102 = { + fileRef = F5060A4B02F37D3301000102; + isa = PBXBuildFile; + settings = { + }; + }; + F5060A7102F37E2601000102 = { + isa = PBXTargetDependency; + target = F588A3BC02F0CCE501000102; + targetProxy = A6E2EAD307656757002AF736; + }; + F5060A7202F37E2901000102 = { + isa = PBXTargetDependency; + target = F588A3BC02F0CCE501000102; + targetProxy = A6E2EACD07656757002AF736; + }; + F5060A7302F37E2B01000102 = { + isa = PBXTargetDependency; + target = F588A3BC02F0CCE501000102; + targetProxy = A6E2EACA07656757002AF736; + }; + F5060A7402F37E3401000102 = { + isa = PBXTargetDependency; + target = F5060A6702F37DEF01000102; + targetProxy = A6E2EAC207656757002AF736; + }; + F50AFD3D0370620B01A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _bezier_angle.h; + path = ETL/_bezier_angle.h; + refType = 4; + sourceTree = ""; + }; + F50AFD3E0370620B01A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _bezier.h; + path = ETL/_bezier.h; + refType = 4; + sourceTree = ""; + }; + F50AFD3F0370620B01A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = bezier; + path = ETL/bezier; + refType = 4; + sourceTree = ""; + }; + F50AFD400370620B01A80006 = { + fileRef = F50AFD3D0370620B01A80006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + Private, + ); + }; + }; + F50AFD410370620B01A80006 = { + fileRef = F50AFD3E0370620B01A80006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + Private, + ); + }; + }; + F50AFD420370620B01A80006 = { + fileRef = F50AFD3F0370620B01A80006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F50AFD490373BEC801A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _status.h; + path = ETL/_status.h; + refType = 4; + sourceTree = ""; + }; + F50AFD4A0373BEC801A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = status; + path = ETL/status; + refType = 4; + sourceTree = ""; + }; + F50AFD4B0373BEC801A80006 = { + fileRef = F50AFD490373BEC801A80006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + Private, + ); + }; + }; + F50AFD4D0373BEE001A80006 = { + fileRef = F50AFD4A0373BEC801A80006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F51305C10325EF93012F4765 = { + children = ( + F51305C20325EFB8012F4765, + F51305C70325EFB8012F4765, + ); + isa = PBXGroup; + name = "Package Files"; + refType = 4; + sourceTree = ""; + }; + F51305C20325EFB8012F4765 = { + children = ( + F51305C40325EFB8012F4765, + F5D988CB03325BFC01A80006, + F5D988CC03325BFC01A80006, + F5D988CD03325BFC01A80006, + ); + isa = PBXGroup; + name = "devel-resources"; + path = "config/pkg-support/devel-resources"; + refType = 4; + sourceTree = ""; + }; + F51305C40325EFB8012F4765 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text.script.sh; + path = install.sh; + refType = 4; + sourceTree = ""; + }; + F51305C70325EFB8012F4765 = { + isa = PBXFileReference; + lastKnownFileType = text; + name = "ETL-devel.info"; + path = "config/pkg-support/ETL-devel.info"; + refType = 4; + sourceTree = ""; + }; + F513067A03266039012F4765 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text.script.sh; + path = "ETL-config.in"; + refType = 4; + sourceTree = ""; + }; + F5130699032666F8012F4765 = { + buildActionMask = 2147483647; + files = ( + F51306A2032668FA012F4765, + F51306A6032668FF012F4765, + F5D988D503325CDB01A80006, + F5D988D603325CDE01A80006, + F5D988D403325CD801A80006, + ); + isa = PBXResourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F513069D032666F8012F4765 = { + buildPhases = ( + F5C1EE4903BCE00701A80006, + F513069F03266806012F4765, + F51306A00326682D012F4765, + F5130699032666F8012F4765, + F51306D203266E6A012F4765, + ); + buildSettings = { + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = "ETL-devel"; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + WRAPPER_EXTENSION = pkg; + }; + dependencies = ( + F51306B303266DAC012F4765, + ); + isa = PBXBundleTarget; + name = "Devel Package"; + productInstallPath = "$(USER_LIBRARY_DIR)/Bundles"; + productName = Untitled; + productReference = F513069E032666F8012F4765; + productSettingsXML = " + + + + CFBundleDevelopmentRegion + English + CFBundleExecutable + + CFBundleGetInfoString + + CFBundleIconFile + + CFBundleIdentifier + + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + + CFBundlePackageType + PKG + CFBundleShortVersionString + + CFBundleSignature + ???? + CFBundleVersion + 0.0.1d1 + + +"; + }; + F513069E032666F8012F4765 = { + explicitFileType = wrapper.cfbundle; + isa = PBXFileReference; + path = "ETL-devel.pkg"; + refType = 3; + sourceTree = BUILT_PRODUCTS_DIR; + }; + F513069F03266806012F4765 = { + buildActionMask = 2147483647; + dstPath = "pkg-tmp"; + dstSubfolderSpec = 16; + files = ( + F51306A1032668E7012F4765, + ); + isa = PBXCopyFilesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F51306A00326682D012F4765 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXShellScriptBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = ". config/build.cfg\n\nset -x\n\n# clean up the framework, remove extra files\nrm -rf build/pkg-tmp/ETL.framework/Resources/pbdevelopment.plist\n\n# remove the .DS_Store file to keep tool from crapping out\nrm -rf pkg-support/devel-resources/.DS_Store\n\nsed \"\ns:@_VERSION_@:$VERSION:;\ns:@_PACKAGE_@:$PACKAGE:;\ns:@_RELEASE_@:$RELEASE:;\ns:@_PACKAGE_NAME_@:$PACKAGE_NAME:;\n\" < config/pkg-support/ETL-devel.info > build/ETL-devel.info\n\n# create the .pkg\npackage build/pkg-tmp build/ETL-devel.info -d build \n\n# remove temporary files\nrm -rf build/pkg-tmp build/ETL-devel.info\n\n# compress\n(cd build; sleep 1; tar -zcvf ETL-devel.pkg.tar.gz ETL-devel.pkg)"; + }; + F51306A1032668E7012F4765 = { + fileRef = F588A3BD02F0CCE501000102; + isa = PBXBuildFile; + settings = { + }; + }; + F51306A2032668FA012F4765 = { + fileRef = F51305C40325EFB8012F4765; + isa = PBXBuildFile; + settings = { + }; + }; + F51306A6032668FF012F4765 = { + fileRef = F513067A03266039012F4765; + isa = PBXBuildFile; + settings = { + }; + }; + F51306B303266DAC012F4765 = { + isa = PBXTargetDependency; + target = F588A3BC02F0CCE501000102; + targetProxy = A6E2EAD007656757002AF736; + }; + F51306D203266E6A012F4765 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXShellScriptBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = ". config/build.cfg\n\nDIR=build/ETL-devel.pkg/Contents/Resources\n\nsed \"\ns:@_VERSION_@:$VERSION:;\ns:@_PACKAGE_@:$PACKAGE:;\ns:@_RELEASE_@:$RELEASE:;\ns:@_PACKAGE_NAME_@:$PACKAGE_NAME:;\n\" < $DIR/install.sh > $DIR/ETL-devel.post_install\ncp $DIR/ETL-devel.post_install $DIR/ETL-devel.post_upgrade\n\nrm $DIR/install.sh\n\n# add execute flag to scripts\nchmod 755 $DIR/ETL-devel.post_install $DIR/ETL-devel.post_upgrade\n"; + }; + F51307D2032699F1012F4765 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _stringf.h; + path = ETL/_stringf.h; + refType = 4; + sourceTree = ""; + }; + F51307D3032699F1012F4765 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = stringf; + path = ETL/stringf; + refType = 4; + sourceTree = ""; + }; + F51307D4032699F1012F4765 = { + fileRef = F51307D2032699F1012F4765; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + Private, + ); + }; + }; + F51307D603269AA2012F4765 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.cpp.cpp; + name = stringf.cpp; + path = test/stringf.cpp; + refType = 4; + sourceTree = ""; + }; + F51307D803269B0F012F4765 = { + buildPhases = ( + F51307DA03269B0F012F4765, + F51307DB03269B0F012F4765, + F51307DD03269B0F012F4765, + F51307DF03269B0F012F4765, + ); + buildSettings = { + HEADER_SEARCH_PATHS = "ETL.pbproj include"; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = "Stringf Test"; + REZ_EXECUTABLE = YES; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + }; + dependencies = ( + F51307D903269B0F012F4765, + ); + isa = PBXToolTarget; + name = "Stringf Test"; + productInstallPath = /usr/local/bin; + productName = "Handle Test"; + productReference = F51307E003269B0F012F4765; + }; + F51307D903269B0F012F4765 = { + isa = PBXTargetDependency; + target = F588A3BC02F0CCE501000102; + targetProxy = A6E2EAD107656757002AF736; + }; + F51307DA03269B0F012F4765 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXHeadersBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F51307DB03269B0F012F4765 = { + buildActionMask = 2147483647; + files = ( + F51307E503269DBE012F4765, + ); + isa = PBXSourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F51307DD03269B0F012F4765 = { + buildActionMask = 2147483647; + files = ( + F51307DE03269B0F012F4765, + ); + isa = PBXFrameworksBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F51307DE03269B0F012F4765 = { + fileRef = F588A3BD02F0CCE501000102; + isa = PBXBuildFile; + settings = { + }; + }; + F51307DF03269B0F012F4765 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXRezBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F51307E003269B0F012F4765 = { + explicitFileType = "compiled.mach-o.executable"; + isa = PBXFileReference; + path = "Stringf Test"; + refType = 3; + sourceTree = BUILT_PRODUCTS_DIR; + }; + F51307E203269B1E012F4765 = { + isa = PBXTargetDependency; + target = F51307D803269B0F012F4765; + targetProxy = A6E2EAC107656757002AF736; + }; + F51307E403269DA6012F4765 = { + fileRef = F51307D3032699F1012F4765; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F51307E503269DBE012F4765 = { + fileRef = F51307D603269AA2012F4765; + isa = PBXBuildFile; + settings = { + }; + }; + F51307F90326A75C012F4765 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = ETL.m4; + path = config/ETL.m4; + refType = 4; + sourceTree = ""; + }; + F51307FA0326A75C012F4765 = { + fileRef = F51307F90326A75C012F4765; + isa = PBXBuildFile; + settings = { + }; + }; + F519539B0332717E01A80006 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXShellScriptBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/bash; + shellScript = ". config/build.cfg\nset -x\nexport FRAMEWORK_VERSION=$VERSION\n"; + }; + F51F41DF02FF6A8F010001CC = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _condition.h; + path = ETL/_condition.h; + refType = 4; + sourceTree = ""; + }; + F51F41E002FF6A8F010001CC = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _mutex_pthreads.h; + path = ETL/_mutex_pthreads.h; + refType = 4; + sourceTree = ""; + }; + F51F41E102FF6A8F010001CC = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _mutex_win32.h; + path = ETL/_mutex_win32.h; + refType = 4; + sourceTree = ""; + }; + F51F41E202FF6A8F010001CC = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _rwlock.h; + path = ETL/_rwlock.h; + refType = 4; + sourceTree = ""; + }; + F51F41E302FF6A8F010001CC = { + fileRef = F51F41DF02FF6A8F010001CC; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F51F41E402FF6A8F010001CC = { + fileRef = F51F41E002FF6A8F010001CC; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F51F41E502FF6A8F010001CC = { + fileRef = F51F41E102FF6A8F010001CC; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F51F41E602FF6A8F010001CC = { + fileRef = F51F41E202FF6A8F010001CC; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F51F41E702FF71F6010001CC = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _surface.h; + path = ETL/_surface.h; + refType = 4; + sourceTree = ""; + }; + F51F41E802FF71F6010001CC = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = surface; + path = ETL/surface; + refType = 4; + sourceTree = ""; + }; + F51F41E902FF71F6010001CC = { + fileRef = F51F41E702FF71F6010001CC; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F51F41EA02FF71F6010001CC = { + fileRef = F51F41E802FF71F6010001CC; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F51F41EB02FFBD64010001CC = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _bit_rotate.h; + path = ETL/_bit_rotate.h; + refType = 4; + sourceTree = ""; + }; + F51F41EC02FFBD64010001CC = { + fileRef = F51F41EB02FFBD64010001CC; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F54A063F030DA3DD01CC8267 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _fastangle_tables.h; + path = ETL/_fastangle_tables.h; + refType = 4; + sourceTree = ""; + }; + F54A0640030DA3DD01CC8267 = { + fileRef = F54A063F030DA3DD01CC8267; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F54A06CF030DE8A501CC8267 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = fastangle; + path = ETL/fastangle; + refType = 4; + sourceTree = ""; + }; + F54A06D0030DE8A501CC8267 = { + fileRef = F54A06CF030DE8A501CC8267; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F54A06D5030E4BCE01CC8267 = { + buildSettings = { + COPY_PHASE_STRIP = YES; + DEBUGGING_SYMBOLS = NO; + OPTIMIZATION_CFLAGS = "-O1"; + PROFILING_CODE = NO; + }; + isa = PBXBuildStyle; + name = "Slight Optimization"; + }; + F54AEAE202F6374901000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _clock_base.h; + path = ETL/_clock_base.h; + refType = 4; + sourceTree = ""; + }; + F54AEAE302F6374901000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = clock; + path = ETL/clock; + refType = 4; + sourceTree = ""; + }; + F54AEAE402F6374901000102 = { + fileRef = F54AEAE202F6374901000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F54AEAE502F6374901000102 = { + fileRef = F54AEAE302F6374901000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F54AEB2702F6785101000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _clock_system.h; + path = ETL/_clock_system.h; + refType = 4; + sourceTree = ""; + }; + F54AEB2802F6785101000102 = { + fileRef = F54AEB2702F6785101000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F54AEB2902F6793801000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _clock_gettimeofday.h; + path = ETL/_clock_gettimeofday.h; + refType = 4; + sourceTree = ""; + }; + F54AEB2A02F6793801000102 = { + fileRef = F54AEB2902F6793801000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F54AEB2B02F6899D01000102 = { + buildPhases = ( + F54AEB2C02F6899D01000102, + F54AEB2D02F6899D01000102, + F54AEB2F02F6899D01000102, + F54AEB3102F6899D01000102, + ); + buildSettings = { + HEADER_SEARCH_PATHS = ETL.pbproj; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = "Clock Test"; + REZ_EXECUTABLE = YES; + SECTORDER_FLAGS = ""; + USE_GCC3_PFE_SUPPORT = YES; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + }; + dependencies = ( + F54AEB3402F689A901000102, + ); + isa = PBXToolTarget; + name = "Clock Test"; + productInstallPath = /usr/local/bin; + productName = "Handle Test"; + productReference = F54AEB3202F6899D01000102; + }; + F54AEB2C02F6899D01000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXHeadersBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F54AEB2D02F6899D01000102 = { + buildActionMask = 2147483647; + files = ( + F54AEB3702F689C801000102, + ); + isa = PBXSourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F54AEB2F02F6899D01000102 = { + buildActionMask = 2147483647; + files = ( + F54AEB3002F6899D01000102, + ); + isa = PBXFrameworksBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F54AEB3002F6899D01000102 = { + fileRef = F588A3BD02F0CCE501000102; + isa = PBXBuildFile; + settings = { + }; + }; + F54AEB3102F6899D01000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXRezBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F54AEB3202F6899D01000102 = { + explicitFileType = "compiled.mach-o.executable"; + isa = PBXFileReference; + path = "Clock Test"; + refType = 3; + sourceTree = BUILT_PRODUCTS_DIR; + }; + F54AEB3402F689A901000102 = { + isa = PBXTargetDependency; + target = F588A3BC02F0CCE501000102; + targetProxy = A6E2EACF07656757002AF736; + }; + F54AEB3502F689AD01000102 = { + isa = PBXTargetDependency; + target = F54AEB2B02F6899D01000102; + targetProxy = A6E2EAC807656757002AF736; + }; + F54AEB3602F689C801000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.cpp.cpp; + name = clock.cpp; + path = test/clock.cpp; + refType = 4; + sourceTree = ""; + }; + F54AEB3702F689C801000102 = { + fileRef = F54AEB3602F689C801000102; + isa = PBXBuildFile; + settings = { + }; + }; + F54AEB3802F68F8D01000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _fastangle.h; + path = ETL/_fastangle.h; + refType = 4; + sourceTree = ""; + }; + F54AEB3902F68F8D01000102 = { + fileRef = F54AEB3802F68F8D01000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F550016102F0983D01000102 = { + children = ( + F51305C10325EF93012F4765, + F550017202F0ABE401000102, + F550017302F0ABFA01000102, + F588A3BE02F0CCE501000102, + F550016802F0987601000102, + F550016A02F0987601000102, + F550016B02F0987601000102, + F550016C02F0987601000102, + F550016E02F09B9701000102, + F550017102F0A69401000102, + F588A3B502F0C38001000102, + F513067A03266039012F4765, + F51307F90326A75C012F4765, + ); + isa = PBXGroup; + refType = 4; + sourceTree = ""; + }; + F550016302F0983D01000102 = { + buildSettings = { + COPY_PHASE_STRIP = NO; + DEBUGGING_SYMBOLS = YES; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + OPTIMIZATION_CFLAGS = "-O0"; + PROFILING_CODE = YES; + ZERO_LINK = YES; + }; + isa = PBXBuildStyle; + name = Development; + }; + F550016402F0983D01000102 = { + buildSettings = { + COPY_PHASE_STRIP = YES; + DEBUGGING_SYMBOLS = NO; + OPTIMIZATION_CFLAGS = "-O3 -ffast-math"; + PROFILING_CODE = NO; + }; + isa = PBXBuildStyle; + name = "Deployment (GCC3)"; + }; + F550016502F0983D01000102 = { + buildSettings = { + }; + buildStyles = ( + F550016302F0983D01000102, + F504527502F391C901000102, + F550016402F0983D01000102, + F54A06D5030E4BCE01CC8267, + ); + hasScannedForEncodings = 1; + isa = PBXProject; + mainGroup = F550016102F0983D01000102; + productRefGroup = F588A3BE02F0CCE501000102; + projectDirPath = ""; + targets = ( + F588A3BC02F0CCE501000102, + F5060A4802F37BDD01000102, + F5060A3602F37B5E01000102, + F5060A3C02F37BAC01000102, + F5060A5102F37D8201000102, + F5060A5A02F37D8501000102, + F5060A6702F37DEF01000102, + F54AEB2B02F6899D01000102, + F576CB6D031841EA01A80006, + F5CAA1FE031AD533012F434D, + F513069D032666F8012F4765, + F51307D803269B0F012F4765, + F58D9F85037F146301A80006, + F58D9F8F037F14FE01A80006, + ); + }; + F550016A02F0987601000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + path = INSTALL; + refType = 4; + sourceTree = ""; + }; + F550016B02F0987601000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + path = Makefile.am; + refType = 4; + sourceTree = ""; + }; + F550016C02F0987601000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + path = README; + refType = 4; + sourceTree = ""; + }; + F550016E02F09B9701000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = build.cfg; + path = config/build.cfg; + refType = 4; + sourceTree = ""; + }; + F550017102F0A69401000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = project.spec.in; + path = config/project.spec.in; + refType = 4; + sourceTree = ""; + }; + F550017202F0ABE401000102 = { + children = ( + F5CAA30A031AF0E1012F434D, + F550017402F0AC5701000102, + F55001B702F0B61101000102, + F5060A0302F3337A01000102, + F54A063F030DA3DD01CC8267, + F5060A1C02F342A901000102, + A6E2EADC076567C1002AF736, + A6E2EADD076567C1002AF736, + A6E2EADE076567C1002AF736, + A6E2EADF076567C1002AF736, + F54AEB3802F68F8D01000102, + F5060A1D02F342A901000102, + F5060A1E02F342A901000102, + F5060A1F02F342A901000102, + F5060A2102F342A901000102, + F5060A2202F342A901000102, + F5060A2302F342A901000102, + F51F41EB02FFBD64010001CC, + F5060A2E02F379BC01000102, + F54AEAE202F6374901000102, + F54AEB2702F6785101000102, + F54AEB2902F6793801000102, + F5CAA1EF031AB630012F434D, + F51F41E002FF6A8F010001CC, + F51F41E102FF6A8F010001CC, + F5CAA1F2031AB74F012F434D, + F51F41DF02FF6A8F010001CC, + F51F41E202FF6A8F010001CC, + F51F41E702FF71F6010001CC, + F579DD9A0315B65001682FCB, + F579DD9E0315C9F001682FCB, + F5CAA1F4031AB947012F434D, + F5CAA1F9031AD342012F434D, + F51307D2032699F1012F4765, + F50AFD3D0370620B01A80006, + F50AFD3E0370620B01A80006, + F50AFD490373BEC801A80006, + F58D9F76037F141A01A80006, + F58D9F77037F141A01A80006, + F58D9F78037F141A01A80006, + F5D51DF00399C74801A80006, + A64F6D24052A9DCC00140006, + A63F3B3E054DA00200140006, + A64F6D25052A9DCC00140006, + F5D51DF10399C74801A80006, + F5060A2402F342A901000102, + F588A3D202F0CDCC01000102, + F588A3D302F0CDCC01000102, + F5060A0502F3366801000102, + F5060A0602F3366801000102, + F5060A2F02F379BC01000102, + F54AEAE302F6374901000102, + F51F41E802FF71F6010001CC, + F54A06CF030DE8A501CC8267, + F579DD9B0315B65001682FCB, + F5CAA1ED031AB61C012F434D, + F5CAA1F5031AB947012F434D, + F5CAA1FB031AD4E7012F434D, + F51307D3032699F1012F4765, + F5EDFAE8032D514001A80082, + F50AFD3F0370620B01A80006, + F50AFD4A0373BEC801A80006, + F58D9F79037F141A01A80006, + F58D9F7A037F141A01A80006, + F58D9F7B037F141A01A80006, + A63F3B3F054DA00200140006, + ); + isa = PBXGroup; + name = "ETL Source"; + refType = 4; + sourceTree = ""; + }; + F550017302F0ABFA01000102 = { + children = ( + F550017502F0AC6D01000102, + F588A3D602F0CF9101000102, + F5627F1902F0D1F801000102, + F5060A4B02F37D3301000102, + F5060A4C02F37D3301000102, + F5060A4D02F37D3301000102, + F54AEB3602F689C801000102, + F576CB6B0318419101A80006, + F5CAA208031AD56B012F434D, + F51307D603269AA2012F4765, + F58D9F98037F154401A80006, + ); + isa = PBXGroup; + name = "Test Sources"; + path = ""; + refType = 4; + sourceTree = ""; + }; + F550017402F0AC5701000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = Makefile.am; + path = ETL/Makefile.am; + refType = 4; + sourceTree = ""; + }; + F550017502F0AC6D01000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = Makefile.am; + path = test/Makefile.am; + refType = 4; + sourceTree = ""; + }; + F55001B702F0B61101000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = etl_config.h; + path = ETL/etl_config.h; + refType = 4; + sourceTree = ""; + }; + F5627F1902F0D1F801000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.cpp.cpp; + name = angle.cpp; + path = test/angle.cpp; + refType = 4; + sourceTree = ""; + }; + F576CB6B0318419101A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.cpp.cpp; + name = hermite.cpp; + path = test/hermite.cpp; + refType = 4; + sourceTree = ""; + }; + F576CB6D031841EA01A80006 = { + buildPhases = ( + F576CB6F031841EA01A80006, + F576CB70031841EA01A80006, + F576CB72031841EA01A80006, + F576CB74031841EA01A80006, + ); + buildSettings = { + HEADER_SEARCH_PATHS = "ETL.pbproj include"; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = "Hermite Test"; + REZ_EXECUTABLE = YES; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + }; + dependencies = ( + F576CB6E031841EA01A80006, + ); + isa = PBXToolTarget; + name = "Hermite Test"; + productInstallPath = /usr/local/bin; + productName = "Handle Test"; + productReference = F576CB75031841EA01A80006; + }; + F576CB6E031841EA01A80006 = { + isa = PBXTargetDependency; + target = F588A3BC02F0CCE501000102; + targetProxy = A6E2EACC07656757002AF736; + }; + F576CB6F031841EA01A80006 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXHeadersBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F576CB70031841EA01A80006 = { + buildActionMask = 2147483647; + files = ( + F576CB780318421D01A80006, + ); + isa = PBXSourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F576CB72031841EA01A80006 = { + buildActionMask = 2147483647; + files = ( + F576CB73031841EA01A80006, + ); + isa = PBXFrameworksBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F576CB73031841EA01A80006 = { + fileRef = F588A3BD02F0CCE501000102; + isa = PBXBuildFile; + settings = { + }; + }; + F576CB74031841EA01A80006 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXRezBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F576CB75031841EA01A80006 = { + explicitFileType = "compiled.mach-o.executable"; + isa = PBXFileReference; + path = "Hermite Test"; + refType = 3; + sourceTree = BUILT_PRODUCTS_DIR; + }; + F576CB780318421D01A80006 = { + fileRef = F576CB6B0318419101A80006; + isa = PBXBuildFile; + settings = { + }; + }; + F579DD9A0315B65001682FCB = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _hermite.h; + path = ETL/_hermite.h; + refType = 4; + sourceTree = ""; + }; + F579DD9B0315B65001682FCB = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = hermite; + path = ETL/hermite; + refType = 4; + sourceTree = ""; + }; + F579DD9C0315B65001682FCB = { + fileRef = F579DD9A0315B65001682FCB; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F579DD9D0315B65001682FCB = { + fileRef = F579DD9B0315B65001682FCB; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F579DD9E0315C9F001682FCB = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _curve_func.h; + path = ETL/_curve_func.h; + refType = 4; + sourceTree = ""; + }; + F579DD9F0315C9F001682FCB = { + fileRef = F579DD9E0315C9F001682FCB; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F588A3B502F0C38001000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = configure.ac; + path = config/configure.ac; + refType = 4; + sourceTree = ""; + }; + F588A3B702F0CCE501000102 = { + buildActionMask = 2147483647; + files = ( + F588A3D402F0CDCC01000102, + F5060A0702F3366801000102, + F5060A0802F3366801000102, + F588A3D502F0CDCC01000102, + F5060A2D02F342A901000102, + F5060A3102F379BC01000102, + F54AEAE502F6374901000102, + F51F41EA02FF71F6010001CC, + F54A06D0030DE8A501CC8267, + F579DD9D0315B65001682FCB, + F5CAA1F1031AB64F012F434D, + F5CAA1F8031AB957012F434D, + F5CAA1FD031AD509012F434D, + F51307E403269DA6012F4765, + F5EDFAEA032D516D01A80082, + F50AFD420370620B01A80006, + F50AFD4D0373BEE001A80006, + F58D9F82037F144701A80006, + F58D9F83037F144901A80006, + F58D9F84037F144C01A80006, + F5D51DF40399C7C201A80006, + A64F6D28052A9DFF00140006, + A63F3B42054DA02500140006, + F588A3C502F0CCF701000102, + F5060A0402F3337A01000102, + F5060A2502F342A901000102, + F5060A2602F342A901000102, + F5060A2702F342A901000102, + F5060A2802F342A901000102, + F5060A2A02F342A901000102, + F5060A2B02F342A901000102, + F5060A2C02F342A901000102, + F5060A3002F379BC01000102, + F54AEAE402F6374901000102, + F54AEB2802F6785101000102, + F54AEB2A02F6793801000102, + F54AEB3902F68F8D01000102, + F51F41E302FF6A8F010001CC, + F51F41E402FF6A8F010001CC, + F51F41E502FF6A8F010001CC, + F51F41E602FF6A8F010001CC, + F51F41E902FF71F6010001CC, + F51F41EC02FFBD64010001CC, + F54A0640030DA3DD01CC8267, + F579DD9C0315B65001682FCB, + F579DD9F0315C9F001682FCB, + F5CAA1F0031AB630012F434D, + F5CAA1F3031AB74F012F434D, + F5CAA1F6031AB947012F434D, + F5CAA1FA031AD342012F434D, + F51307D4032699F1012F4765, + F50AFD400370620B01A80006, + F50AFD410370620B01A80006, + F50AFD4B0373BEC801A80006, + F58D9F7C037F141A01A80006, + F58D9F7D037F141A01A80006, + F58D9F7E037F141A01A80006, + F5D51DF20399C74801A80006, + A64F6D26052A9DCC00140006, + A63F3B40054DA00200140006, + A6E2EAE0076567C1002AF736, + A6E2EAE1076567C1002AF736, + ); + isa = PBXHeadersBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F588A3B802F0CCE501000102 = { + buildActionMask = 2147483647; + files = ( + F51307FA0326A75C012F4765, + F5D988CE03325BFC01A80006, + F5D988CF03325BFC01A80006, + F5D988D003325BFC01A80006, + A6E2EAE2076567C1002AF736, + A6E2EAE3076567C1002AF736, + ); + isa = PBXResourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F588A3B902F0CCE501000102 = { + buildActionMask = 2147483647; + files = ( + F5CAA30B031AF0E1012F434D, + ); + isa = PBXSourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F588A3BA02F0CCE501000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXFrameworksBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F588A3BB02F0CCE501000102 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXRezBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F588A3BC02F0CCE501000102 = { + buildPhases = ( + F519539B0332717E01A80006, + F588A3B702F0CCE501000102, + F588A3B802F0CCE501000102, + F588A3B902F0CCE501000102, + F588A3BA02F0CCE501000102, + F588A3BB02F0CCE501000102, + ); + buildSettings = { + DEBUGGING_SYMBOLS = NO; + DYLIB_COMPATIBILITY_VERSION = 1; + DYLIB_CURRENT_VERSION = 1; + FRAMEWORK_VERSION = A; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_LIBTOOL_FLAGS = "-static"; + OTHER_REZFLAGS = ""; + PRINCIPAL_CLASS = ""; + PRODUCT_NAME = ETL; + SECTORDER_FLAGS = ""; + USE_GCC3_PFE_SUPPORT = YES; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + WRAPPER_EXTENSION = framework; + }; + dependencies = ( + ); + isa = PBXFrameworkTarget; + name = "ETL Framework"; + productInstallPath = "$(LOCAL_LIBRARY_DIR)/Frameworks"; + productName = ETL; + productReference = F588A3BD02F0CCE501000102; + productSettingsXML = " + + + + CFBundleDevelopmentRegion + English + CFBundleExecutable + + CFBundleGetInfoString + + CFBundleIconFile + + CFBundleIdentifier + + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + + CFBundlePackageType + FMWK + CFBundleShortVersionString + + CFBundleSignature + ???? + CFBundleVersion + 0.0.1d1 + + +"; + }; + F588A3BD02F0CCE501000102 = { + explicitFileType = wrapper.framework; + isa = PBXFileReference; + path = ETL.framework; + refType = 3; + sourceTree = BUILT_PRODUCTS_DIR; + }; + F588A3BE02F0CCE501000102 = { + children = ( + F513069E032666F8012F4765, + F588A3BD02F0CCE501000102, + F5060A3702F37B5E01000102, + F5060A4302F37BAC01000102, + F5060A5802F37D8201000102, + F5060A6102F37D8501000102, + F5060A6E02F37DEF01000102, + F54AEB3202F6899D01000102, + F576CB75031841EA01A80006, + F5CAA206031AD533012F434D, + F51307E003269B0F012F4765, + F58D9F8D037F146301A80006, + F58D9F96037F14FE01A80006, + ); + isa = PBXGroup; + name = Products; + path = ""; + refType = 4; + sourceTree = ""; + }; + F588A3C502F0CCF701000102 = { + fileRef = F55001B702F0B61101000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F588A3D202F0CDCC01000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = angle; + path = ETL/angle; + refType = 4; + sourceTree = ""; + }; + F588A3D302F0CDCC01000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = handle; + path = ETL/handle; + refType = 4; + sourceTree = ""; + }; + F588A3D402F0CDCC01000102 = { + fileRef = F588A3D202F0CDCC01000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F588A3D502F0CDCC01000102 = { + fileRef = F588A3D302F0CDCC01000102; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F588A3D602F0CF9101000102 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.cpp.cpp; + name = handle.cpp; + path = test/handle.cpp; + refType = 4; + sourceTree = ""; + }; + F58D9F76037F141A01A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _boxblur.h; + path = ETL/_boxblur.h; + refType = 4; + sourceTree = ""; + }; + F58D9F77037F141A01A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _gaussian.h; + path = ETL/_gaussian.h; + refType = 4; + sourceTree = ""; + }; + F58D9F78037F141A01A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _pen.h; + path = ETL/_pen.h; + refType = 4; + sourceTree = ""; + }; + F58D9F79037F141A01A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = boxblur; + path = ETL/boxblur; + refType = 4; + sourceTree = ""; + }; + F58D9F7A037F141A01A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = gaussian; + path = ETL/gaussian; + refType = 4; + sourceTree = ""; + }; + F58D9F7B037F141A01A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = pen; + path = ETL/pen; + refType = 4; + sourceTree = ""; + }; + F58D9F7C037F141A01A80006 = { + fileRef = F58D9F76037F141A01A80006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + Private, + ); + }; + }; + F58D9F7D037F141A01A80006 = { + fileRef = F58D9F77037F141A01A80006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + Private, + ); + }; + }; + F58D9F7E037F141A01A80006 = { + fileRef = F58D9F78037F141A01A80006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + Private, + ); + }; + }; + F58D9F82037F144701A80006 = { + fileRef = F58D9F79037F141A01A80006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F58D9F83037F144901A80006 = { + fileRef = F58D9F7A037F141A01A80006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F58D9F84037F144C01A80006 = { + fileRef = F58D9F7B037F141A01A80006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F58D9F85037F146301A80006 = { + buildPhases = ( + F58D9F87037F146301A80006, + F58D9F88037F146301A80006, + F58D9F8A037F146301A80006, + F58D9F8C037F146301A80006, + ); + buildSettings = { + HEADER_SEARCH_PATHS = "ETL.pbproj include"; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = "Pen Test"; + REZ_EXECUTABLE = YES; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + }; + dependencies = ( + F58D9F86037F146301A80006, + ); + isa = PBXToolTarget; + name = "Pen Test"; + productInstallPath = /usr/local/bin; + productName = "Handle Test"; + productReference = F58D9F8D037F146301A80006; + }; + F58D9F86037F146301A80006 = { + isa = PBXTargetDependency; + target = F588A3BC02F0CCE501000102; + targetProxy = A6E2EACE07656757002AF736; + }; + F58D9F87037F146301A80006 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXHeadersBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F58D9F88037F146301A80006 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXSourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F58D9F8A037F146301A80006 = { + buildActionMask = 2147483647; + files = ( + F58D9F8B037F146301A80006, + ); + isa = PBXFrameworksBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F58D9F8B037F146301A80006 = { + fileRef = F588A3BD02F0CCE501000102; + isa = PBXBuildFile; + settings = { + }; + }; + F58D9F8C037F146301A80006 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXRezBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F58D9F8D037F146301A80006 = { + explicitFileType = "compiled.mach-o.executable"; + isa = PBXFileReference; + path = "Pen Test"; + refType = 3; + sourceTree = BUILT_PRODUCTS_DIR; + }; + F58D9F8F037F14FE01A80006 = { + buildPhases = ( + F58D9F91037F14FE01A80006, + F58D9F92037F14FE01A80006, + F58D9F93037F14FE01A80006, + F58D9F95037F14FE01A80006, + ); + buildSettings = { + HEADER_SEARCH_PATHS = "ETL.pbproj include"; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = "Surface Test"; + REZ_EXECUTABLE = YES; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + }; + dependencies = ( + F58D9F90037F14FE01A80006, + ); + isa = PBXToolTarget; + name = "Surface Test"; + productInstallPath = /usr/local/bin; + productName = "Handle Test"; + productReference = F58D9F96037F14FE01A80006; + }; + F58D9F90037F14FE01A80006 = { + isa = PBXTargetDependency; + target = F588A3BC02F0CCE501000102; + targetProxy = A6E2EAD207656757002AF736; + }; + F58D9F91037F14FE01A80006 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXHeadersBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F58D9F92037F14FE01A80006 = { + buildActionMask = 2147483647; + files = ( + F58D9F9A037F154D01A80006, + ); + isa = PBXSourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F58D9F93037F14FE01A80006 = { + buildActionMask = 2147483647; + files = ( + F58D9F94037F14FE01A80006, + ); + isa = PBXFrameworksBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F58D9F94037F14FE01A80006 = { + fileRef = F588A3BD02F0CCE501000102; + isa = PBXBuildFile; + settings = { + }; + }; + F58D9F95037F14FE01A80006 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXRezBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F58D9F96037F14FE01A80006 = { + explicitFileType = "compiled.mach-o.executable"; + isa = PBXFileReference; + path = "Surface Test"; + refType = 3; + sourceTree = BUILT_PRODUCTS_DIR; + }; + F58D9F98037F154401A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.cpp.cpp; + name = surface.cpp; + path = test/surface.cpp; + refType = 4; + sourceTree = ""; + }; + F58D9F9A037F154D01A80006 = { + fileRef = F58D9F98037F154401A80006; + isa = PBXBuildFile; + settings = { + }; + }; + F5C1EE4903BCE00701A80006 = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXShellScriptBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "rm -fr ETL-devel.pkg"; + }; + F5CAA1ED031AB61C012F434D = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = smach; + path = ETL/smach; + refType = 4; + sourceTree = ""; + }; + F5CAA1EF031AB630012F434D = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _clock_win32hpcount.h; + path = ETL/_clock_win32hpcount.h; + refType = 4; + sourceTree = ""; + }; + F5CAA1F0031AB630012F434D = { + fileRef = F5CAA1EF031AB630012F434D; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F5CAA1F1031AB64F012F434D = { + fileRef = F5CAA1ED031AB61C012F434D; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F5CAA1F2031AB74F012F434D = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _mutex_null.h; + path = ETL/_mutex_null.h; + refType = 4; + sourceTree = ""; + }; + F5CAA1F3031AB74F012F434D = { + fileRef = F5CAA1F2031AB74F012F434D; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F5CAA1F4031AB947012F434D = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _calculus.h; + path = ETL/_calculus.h; + refType = 4; + sourceTree = ""; + }; + F5CAA1F5031AB947012F434D = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = calculus; + path = ETL/calculus; + refType = 4; + sourceTree = ""; + }; + F5CAA1F6031AB947012F434D = { + fileRef = F5CAA1F4031AB947012F434D; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F5CAA1F8031AB957012F434D = { + fileRef = F5CAA1F5031AB947012F434D; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F5CAA1F9031AD342012F434D = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _bspline.h; + path = ETL/_bspline.h; + refType = 4; + sourceTree = ""; + }; + F5CAA1FA031AD342012F434D = { + fileRef = F5CAA1F9031AD342012F434D; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Private, + Public, + ); + }; + }; + F5CAA1FB031AD4E7012F434D = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = spline; + path = ETL/spline; + refType = 4; + sourceTree = ""; + }; + F5CAA1FD031AD509012F434D = { + fileRef = F5CAA1FB031AD4E7012F434D; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F5CAA1FE031AD533012F434D = { + buildPhases = ( + F5CAA200031AD533012F434D, + F5CAA201031AD533012F434D, + F5CAA203031AD533012F434D, + F5CAA205031AD533012F434D, + ); + buildSettings = { + HEADER_SEARCH_PATHS = "ETL.pbproj include"; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = "Spline Test"; + REZ_EXECUTABLE = YES; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = "-Wmost -Wno-four-char-constants -Wno-unknown-pragmas"; + }; + dependencies = ( + F5CAA1FF031AD533012F434D, + ); + isa = PBXToolTarget; + name = "Spline Test"; + productInstallPath = /usr/local/bin; + productName = "Handle Test"; + productReference = F5CAA206031AD533012F434D; + }; + F5CAA1FF031AD533012F434D = { + isa = PBXTargetDependency; + target = F588A3BC02F0CCE501000102; + targetProxy = A6E2EAC007656757002AF736; + }; + F5CAA200031AD533012F434D = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXHeadersBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5CAA201031AD533012F434D = { + buildActionMask = 2147483647; + files = ( + F5CAA209031AD56B012F434D, + ); + isa = PBXSourcesBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5CAA203031AD533012F434D = { + buildActionMask = 2147483647; + files = ( + F5CAA204031AD533012F434D, + ); + isa = PBXFrameworksBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5CAA204031AD533012F434D = { + fileRef = F588A3BD02F0CCE501000102; + isa = PBXBuildFile; + settings = { + }; + }; + F5CAA205031AD533012F434D = { + buildActionMask = 2147483647; + files = ( + ); + isa = PBXRezBuildPhase; + runOnlyForDeploymentPostprocessing = 0; + }; + F5CAA206031AD533012F434D = { + explicitFileType = "compiled.mach-o.executable"; + isa = PBXFileReference; + path = "Spline Test"; + refType = 3; + sourceTree = BUILT_PRODUCTS_DIR; + }; + F5CAA208031AD56B012F434D = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.cpp.cpp; + name = spline.cpp; + path = test/spline.cpp; + refType = 4; + sourceTree = ""; + }; + F5CAA209031AD56B012F434D = { + fileRef = F5CAA208031AD56B012F434D; + isa = PBXBuildFile; + settings = { + }; + }; + F5CAA305031AEFBC012F434D = { + isa = PBXTargetDependency; + target = F5CAA1FE031AD533012F434D; + targetProxy = A6E2EAC907656757002AF736; + }; + F5CAA306031AEFC1012F434D = { + isa = PBXTargetDependency; + target = F576CB6D031841EA01A80006; + targetProxy = A6E2EAC707656757002AF736; + }; + F5CAA30A031AF0E1012F434D = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.cpp.cpp; + name = frameworkfix.cpp; + path = ETL.pbproj/frameworkfix.cpp; + refType = 4; + sourceTree = ""; + }; + F5CAA30B031AF0E1012F434D = { + fileRef = F5CAA30A031AF0E1012F434D; + isa = PBXBuildFile; + settings = { + }; + }; + F5D51DF00399C74801A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = sourcecode.c.h; + name = _smart_ptr.h; + path = ETL/_smart_ptr.h; + refType = 4; + sourceTree = ""; + }; + F5D51DF10399C74801A80006 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = smart_ptr; + path = ETL/smart_ptr; + refType = 4; + sourceTree = ""; + }; + F5D51DF20399C74801A80006 = { + fileRef = F5D51DF00399C74801A80006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + Private, + ); + }; + }; + F5D51DF40399C7C201A80006 = { + fileRef = F5D51DF10399C74801A80006; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + F5D988CB03325BFC01A80006 = { + isa = PBXFileReference; + lastKnownFileType = text.rtf; + path = License.rtf; + refType = 4; + sourceTree = ""; + }; + F5D988CC03325BFC01A80006 = { + isa = PBXFileReference; + lastKnownFileType = text.rtf; + path = ReadMe.rtf; + refType = 4; + sourceTree = ""; + }; + F5D988CD03325BFC01A80006 = { + isa = PBXFileReference; + lastKnownFileType = text.rtf; + path = Welcome.rtf; + refType = 4; + sourceTree = ""; + }; + F5D988CE03325BFC01A80006 = { + fileRef = F5D988CB03325BFC01A80006; + isa = PBXBuildFile; + settings = { + }; + }; + F5D988CF03325BFC01A80006 = { + fileRef = F5D988CC03325BFC01A80006; + isa = PBXBuildFile; + settings = { + }; + }; + F5D988D003325BFC01A80006 = { + fileRef = F5D988CD03325BFC01A80006; + isa = PBXBuildFile; + settings = { + }; + }; + F5D988D403325CD801A80006 = { + fileRef = F5D988CD03325BFC01A80006; + isa = PBXBuildFile; + settings = { + }; + }; + F5D988D503325CDB01A80006 = { + fileRef = F5D988CC03325BFC01A80006; + isa = PBXBuildFile; + settings = { + }; + }; + F5D988D603325CDE01A80006 = { + fileRef = F5D988CB03325BFC01A80006; + isa = PBXBuildFile; + settings = { + }; + }; + F5EDFAE8032D514001A80082 = { + fileEncoding = 30; + isa = PBXFileReference; + lastKnownFileType = text; + name = trivial; + path = ETL/trivial; + refType = 4; + sourceTree = ""; + }; + F5EDFAEA032D516D01A80082 = { + fileRef = F5EDFAE8032D514001A80082; + isa = PBXBuildFile; + settings = { + ATTRIBUTES = ( + Public, + ); + }; + }; + }; + rootObject = F550016502F0983D01000102; +} diff --git a/ETL/tags/0.61.06/ETL.pc.in b/ETL/tags/0.61.06/ETL.pc.in new file mode 100644 index 0000000..93c32bf --- /dev/null +++ b/ETL/tags/0.61.06/ETL.pc.in @@ -0,0 +1,11 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: @PACKAGE_TARNAME@ +Description: @PACKAGE_NAME@ +Requires: +Version: @VERSION@ +Libs: @LIBS@ +Cflags: -I${includedir} diff --git a/ETL/tags/0.61.06/ETL.prj b/ETL/tags/0.61.06/ETL.prj new file mode 100644 index 0000000..f7fd779 --- /dev/null +++ b/ETL/tags/0.61.06/ETL.prj @@ -0,0 +1,169 @@ +# Anjuta Version 1.2.0 +Compatibility Level: 1 + + +Extended Template library + + + + + + + + + + + + + + + + + + + +props.file.type=project + +anjuta.version=1.2.0 +anjuta.compatibility.level=1 + +project.name=ETL +project.type=GENERIC +project.target.type=EXECUTABLE +project.version=0.99 +project.author=Robert Quattlebaum +project.source.target=unknown +project.has.gettext=0 +project.gui.command= +project.programming.language=C++ +project.excluded.modules=intl + +project.config.extra.modules.before= +project.config.extra.modules.after= +project.config.blocked=1 +project.config.disable.overwriting=1 1 1 1 1 1 1 1 1 + +project.menu.entry=ETL Version 0.99 +project.menu.group=Application +project.menu.comment=ETL Version 0.99 +project.menu.icon= +project.menu.need.terminal=0 + +project.configure.options= +anjuta.program.arguments= +preferences.build.option.jobs=0 +preferences.build.option.silent=0 +preferences.build.option.autosave=0 +preferences.anjuta.make.options=-k +preferences.make=make +preferences.build.option.keep.going=1 +preferences.build.option.warn.undef=0 +preferences.autoformat.custom.style= -i8 -sc -bli0 -bl0 -cbi0 -ss +preferences.indent.opening=0 +preferences.autoformat.disable=1 +preferences.indent.automatic=1 +preferences.use.tabs=1 +preferences.indent.size=4 +preferences.tabsize=4 +preferences.indent.closing=0 + +module.include.name=. +module.include.type= +module.include.files=\ + ETL/_bit_rotate.h\ + ETL/_bezier.h\ + ETL/_fastangle_tables.h\ + ETL/_boxblur.h\ + ETL/_clock_system.h\ + ETL/_gaussian.h\ + ETL/_rwlock.h\ + ETL/_stringf.h\ + ETL/_status.h\ + ETL/_smart_ptr.h\ + ETL/_thread.h\ + ETL/_curve_func.h\ + ETL/etl_profile_.h\ + ETL/_curve.h\ + ETL/_calculus.h\ + ETL/_trivial.h\ + ETL/etl_profile.h\ + ETL/_pen.h\ + ETL/_misc.h\ + ETL/_mutex_win32.h\ + ETL/_clock_gettimeofday.h\ + ETL/_ref_count.h\ + ETL/_bezier_angle.h\ + ETL/_clock_base.h\ + ETL/_bspline.h\ + ETL/_smach.h\ + ETL/_fixed.h\ + ETL/_condition.h\ + ETL/_mutex_null.h\ + ETL/_surface.h\ + ETL/_fastangle.h\ + ETL/_mutex_pthreads.h\ + ETL/_hermite.h\ + ETL/_handle.h\ + ETL/_random.h\ + ETL/_angle.h\ + ETL/_clock_win32hpcount.h\ + ETL/etl_config.h\ + ETL.pbproj/etl_profile.h + +module.source.name=. +module.source.type= +module.source.files=\ + test/surface.cpp\ + test/random.cpp\ + test/smach.cpp\ + test/smart_ptr.cpp\ + test/benchmark.cpp\ + test/spline.cpp\ + test/handle.cpp\ + test/stringf.cpp\ + test/clock.cpp\ + test/angle.cpp\ + test/hermite.cpp\ + test/fixed.cpp\ + test/pen.cpp\ + ETL.pbproj/frameworkfix.cpp + +module.pixmap.name=. +module.pixmap.type= +module.pixmap.files= + +module.data.name=. +module.data.type= +module.data.files= + +module.help.name=. +module.help.type= +module.help.files= + +module.doc.name=. +module.doc.type= +module.doc.files=\ + README\ + INSTALL\ + ChangeLog + +module.po.files= + +compiler.options.supports= +compiler.options.include.paths=\ + .\ + .. +compiler.options.library.paths= +compiler.options.libraries= +compiler.options.libraries.selected= +compiler.options.defines=\ + HAVE_CONFIG_H +compiler.options.defines.selected= +compiler.options.warning.buttons=0 0 1 1 0 1 0 0 0 0 0 0 0 1 0 0 +compiler.options.optimize.buttons=0 0 1 0 +compiler.options.other.buttons=1 0 +compiler.options.other.c.flags= +compiler.options.other.l.flags= +compiler.options.other.l.libs= + +project.src.paths= diff --git a/ETL/tags/0.61.06/ETL/Makefile.am b/ETL/tags/0.61.06/ETL/Makefile.am new file mode 100644 index 0000000..68ccdda --- /dev/null +++ b/ETL/tags/0.61.06/ETL/Makefile.am @@ -0,0 +1,15 @@ +# $Id$ + +MAINTAINERCLEANFILES=Makefile.in + +CLEANFILES=$(top_builddir)/ETL/etl_profile.h + +etldir = $(includedir)/ETL + +etl_HEADERS= value _value.h rect _rect.h misc _misc.h ref_count _ref_count.h angle fastangle handle ipc thread fixed random clock hermite calculus stringf trivial spline _stringf.h _bspline.h _calculus.h _mutex_null.h _hermite.h _curve_func.h _clock_base.h _clock_system.h _clock_gettimeofday.h _random.h _angle.h _fastangle.h _curve.h _handle.h _thread.h _mutex_pthreads.h _mutex_win32.h _condition.h _rwlock.h smach _smach.h _trivial.h _fixed.h etl_config.h $(top_builddir)/ETL/etl_profile.h _fastangle_tables.h bezier _bezier.h _bezier_angle.h _status.h status pen _pen.h boxblur _boxblur.h gaussian _gaussian.h surface _surface.h smart_ptr _smart_ptr.h _clock_win32hpcount.h mutex _mutex_pthreads_simple.h + +$(top_builddir)/ETL/etl_profile.h:$(top_builddir)/ETL/etl_profile_.h + sed "s/PACKAGE/ETL/g;" < $(top_builddir)/ETL/etl_profile_.h > $(top_builddir)/ETL/etl_profile.h + +# FIXME: figure out why this is in SVN, but isn't installed +EXTRA_DIST=_bit_rotate.h diff --git a/ETL/tags/0.61.06/ETL/_angle.h b/ETL/tags/0.61.06/ETL/_angle.h new file mode 100644 index 0000000..c15f90d --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_angle.h @@ -0,0 +1,516 @@ +#include +/* ======================================================================== +** Extended Template and Library +** Angle Abstraction Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** Copyright (c) 2007 Chris Moore +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL_ANGLE_H +#define __ETL_ANGLE_H + +/* === H E A D E R S ======================================================= */ + +#include +#include + +/* === M A C R O S ========================================================= */ + +#ifndef PI +# define PI (3.1415926535897932384626433832795029L) +# define HALF_PI (PI/2) +#endif + +#define ANGLE_EPSILON (1.0e-6) + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +// ======================================================================== +/*! \class angle _angle.h ETL/angle +** \brief Abstraction of the concept of an angle +** \see angle::deg, angle::rad, angle::rot, angle::sin, angle::cos, angle::tan, fastangle +** \writeme +*/ +class angle +{ +public: + typedef float value_type; + +protected: + typedef value_type unit; + + unit v; //! Stored in radians; positive values indicate counter-clockwise. + +public: + + /* + ** Arithmetic Operators + */ + + const angle & + operator+=(const angle &rhs) + { v+=rhs.v; return *this; } + + const angle & + operator-=(const angle &rhs) + { v-=rhs.v; return *this; } + + const angle & + operator*=(const unit &rhs) + { v*=rhs; return *this; } + + const angle & + operator/=(const unit &rhs) + { v/=rhs; return *this; } + + //! Angle Addition Operator + angle + operator+(const angle &rhs)const + { return angle(*this)+=rhs; } + + //! Angle Subtraction Operator + /*! \sa angle dist(const angle &) */ + angle + operator-(const angle &rhs)const + { return angle(*this)-=rhs; } + + //! Angle Scalar Multiplication Operator + /*! This operator will multiply the given + angle by the given scalar value. */ + angle + operator*(const unit &rhs)const + { return angle(*this)*=rhs; } + + angle + operator/(const unit &rhs)const + { return angle(*this)/=rhs; } + + //! Angle Negation + angle + operator-()const + { + angle ret; + ret.v=-v; + return ret; + } + +#ifdef ETL_NOT_USED + //! 180 degree rotation operator + /*! Returns the angle directly opposite of + the given angle, and will yield a result + between 0 and 2PI */ + angle + operator~()const + { + angle ret; + ret.v = v+PI; + return ret.mod(); + } +#endif // ETL_NOT_USED + +#ifdef ETL_WRAP_ANGLES + /*! Returns true if the shortest + angle from the left-hand to the + right-hand side is counter-clockwise */ + bool + operator<(const angle &rhs)const + { return dist(rhs).v<(value_type)0.0; } + + /*! Returns true if the shortest + angle from the left-hand to the + right-hand side is clockwise */ + bool + operator>(const angle &rhs)const + { return dist(rhs).v>(value_type)0.0; } + + /*! Returns true if the shortest + angle from the left-hand to the + right-hand side is counter-clockwise, + or if the angles are refer to the same + point on the unit circle. */ + bool + operator<=(const angle &rhs)const + { return dist(rhs).v<=(value_type)0.0; } + + /*! Returns true if the shortest + angle from the left-hand to the + right-hand side is clockwise, + or if the angles are refer to the same + point on the unit circle. */ + bool + operator>=(const angle &rhs)const + { return dist(rhs).v>=(value_type)0.0; } + + /*! Returns true if the angles + are refer to the same point + on the unit circle. */ + bool + operator==(const angle &rhs)const + { return std::abs(dist(rhs).v)ANGLE_EPSILON; } +#else // ETL_WRAP_ANGLES + /*! Returns true if the left-hand + side is less than the + right-hand side */ + bool + operator<(const angle &rhs)const + { return v < rhs.v; } + + /*! Returns true if the left-hand + side is greater than the + right-hand side */ + bool + operator>(const angle &rhs)const + { return v > rhs.v; } + + /*! Returns true if the left-hand + side is less or equal to the + right-hand side */ + bool + operator<=(const angle &rhs)const + { return v <= rhs.v; } + + /*! Returns true if the left-hand + side is greater than or equal + to the right-hand side */ + bool + operator>=(const angle &rhs)const + { return v >= rhs.v; } + + /*! Returns true if the angles + are the same, or close */ + bool + operator==(const angle &rhs)const + { return std::abs(v - rhs.v)ANGLE_EPSILON; } +#endif // ETL_WRAP_ANGLES + + //! Absolute Angle Function + /*! This function will return the + absolute value of the angle. */ + angle + abs()const + { + angle ret; + ret.v=std::abs(v); + return ret; + } + +#ifdef ETL_WRAP_ANGLES + //! Angle Difference Function + /*! This function will return the + shortest physical distance between + two angles, from -PI/2 to PI/2 + \sa angle operator-(const angle &) */ + angle + dist(const angle &rhs)const + { + angle ret; + ret.v=v-rhs.v; + ret.v-=rot_floor(ret.v+PI); + return ret; + } + + //! Rotation Modulus + /*! This function will return the + value of the angle between 0 and 2PI */ + angle + mod()const + { + angle ret(*this); + ret.v-=rot_floor(ret.v); + return ret; + } +#else // ETL_WRAP_ANGLES + //! Angle Difference Function + /*! This function will return the + difference between + two angles, just like + \sa angle operator-(const angle &) */ + angle + dist(const angle &rhs)const + { return angle(*this)-=rhs; } + + //! Rotation Modulus + /*! This function will return the + value of the angle */ + angle + mod()const + { + angle ret(*this); + return ret; + } +#endif // ETL_WRAP_ANGLES + + //! Zero Rotation (0 degrees) + static angle + zero() + { + angle ret; + ret.v=0; + return ret; + } + + //! One Complete Rotation (360 degrees) + static angle + one() + { + angle ret; + ret.v=PI*2; + return ret; + } + + //! One Half Rotation (180 degrees) + static angle + half() + { + angle ret; + ret.v=PI; + return ret; + } + + bool operator!()const { return std::abs(mod().v) < ANGLE_EPSILON; } + +private: + +#ifdef ETL_WRAP_ANGLES + static value_type rot_floor(value_type x) + { return static_cast(std::floor(x/(PI*2))*PI*2); } +#endif // ETL_WRAP_ANGLES + +public: + /* + ** Conversion Classes + */ + + class rad; + class deg; + class rot; + + /* + ** Trigonometric Classes + */ + + class sin; + class cos; + class tan; + + /* + ** Friend classes + */ + + friend class rad; + friend class deg; + friend class rot; + friend class sin; + friend class cos; + friend class tan; + + /* + ** Deprecated + */ + +#ifndef ETL_NO_DEPRECATED + typedef rad radians; + typedef deg degrees; + typedef rot rotations; +#endif +}; // END of class angle + +// ======================================================================== +/*! \class angle::rad _angle.h ETL/angle +** \brief Angle representation in radians +** \see angle +** \writeme +*/ +class angle::rad : public angle +{ +public: + explicit rad(const value_type &x) { v=x; } + rad(const angle &a):angle(a) { } + rad mod()const { return angle::mod(); } + rad dist(const angle &rhs)const { return angle::dist(rhs); } + value_type get()const { return v; } +#ifndef ETL_NO_DEPRECATED + // operator value_type()const ETL_DEPRECATED_FUNCTION; +#endif +}; // END of class angle::radians +// inline angle::rad::operator angle::value_type()const { return get(); } + +// ======================================================================== +/*! \class angle::deg _angle.h ETL/angle +** \brief Angle representation in degrees +** \see angle +** \writeme +*/ +class angle::deg : public angle +{ +public: + explicit deg(const value_type &x) { v=x*((PI*2)/360); } + deg(const angle &a):angle(a) { } + deg mod()const { return angle::mod(); } + deg dist(const angle &rhs)const { return angle::dist(rhs); } + value_type get()const { return v*360/(PI*2); } +#ifndef ETL_NO_DEPRECATED + // operator value_type()const ETL_DEPRECATED_FUNCTION; +#endif +}; // END of class angle::degrees +// inline angle::deg::operator angle::value_type()const { return get(); } + +// ======================================================================== +/*! \class angle::rot _angle.h ETL/angle +** \brief Angle representation in rotations +** \see angle +** \writeme +*/ +class angle::rot : public angle +{ +public: + explicit rot(const value_type &x) { v=x*(PI*2); } + rot(const angle &a):angle(a) { } + rot mod()const { return angle::mod(); } + rot dist(const angle &rhs)const { return angle::dist(rhs); } + value_type get()const { return v/(PI*2); } +#ifndef ETL_NO_DEPRECATED + // operator value_type()const ETL_DEPRECATED_FUNCTION; +#endif +}; // END of class angle::rotations +// inline angle::rot::operator angle::value_type()const { return get(); } + +// ======================================================================== +/*! \class angle::sin _angle.h ETL/angle +** \brief Angle representation as a sine function +** \see angle +** \writeme +*/ +class angle::sin : public angle +{ +public: + explicit sin(const value_type &x) { v=static_cast(std::asin(x)); } + sin(const angle &a):angle(a) { } + sin mod()const { return angle::mod(); } + sin dist(const angle &rhs)const { return angle::dist(rhs); } + value_type get()const { return static_cast(std::sin(v)); } +#ifndef ETL_NO_DEPRECATED + // operator value_type()const ETL_DEPRECATED_FUNCTION; +#endif +}; // END of class angle::sin +// inline angle::sin::operator angle::value_type()const { return get(); } + +// ======================================================================== +/*! \class angle::cos _angle.h ETL/angle +** \brief Angle representation as a cosine function +** \see angle +** \writeme +*/ +class angle::cos : public angle +{ +public: + explicit cos(const value_type &x) { v=(value_type)(std::acos(x)); } + cos(const angle &a):angle(a) { } + cos mod()const { return angle::mod(); } + cos dist(const angle &rhs)const { return angle::dist(rhs); } + value_type get()const { return (value_type)std::cos(v); } +#ifndef ETL_NO_DEPRECATED + // operator value_type()const ETL_DEPRECATED_FUNCTION; +#endif +}; // END of class angle::cos +// inline angle::cos::operator angle::value_type()const { return get(); } + +// ======================================================================== +/*! \class angle::tan _angle.h ETL/angle +** \brief Angle representation as a tangent function +** \see angle +** \writeme +*/ +class angle::tan : public angle +{ +public: + explicit tan(const value_type &x) { v=(value_type)(std::atan(x)); } + tan(const value_type &y,const value_type &x) { v=(value_type)(std::atan2(y,x)); } + tan(const angle &a):angle(a) { } + tan mod()const { return angle::mod(); } + tan dist(const angle &rhs)const { return angle::dist(rhs); } + value_type get()const { return (value_type)std::tan(v); } +#ifndef ETL_NO_DEPRECATED + // operator value_type()const ETL_DEPRECATED_FUNCTION; +#endif +}; // END of class angle::tan +// inline angle::tan::operator angle::value_type()const { return get(); } + +_ETL_END_NAMESPACE + +//#include + +template +struct affine_combo +{ + typedef T time_type; + + //affine_combo() { std::cerr<<"affine_combo: I was created!"<: I was DELETED!"< +struct distance_func : public std::binary_function +{ + etl::angle operator()(const etl::angle &a,const etl::angle &b)const + { + etl::angle delta=b.dist(a); + //if(delta // for ldexp +// #include // not used + +/* === M A C R O S ========================================================= */ + +#define MAXDEPTH 64 /* Maximum depth for recursion */ + +/* take binary sign of a, either -1, or 1 if >= 0 */ +#define SGN(a) (((a)<0) ? -1 : 1) + +/* find minimum of a and b */ +#ifndef MIN +#define MIN(a,b) (((a)<(b))?(a):(b)) +#endif + +/* find maximum of a and b */ +#ifndef MAX +#define MAX(a,b) (((a)>(b))?(a):(b)) +#endif + +#define BEZIER_EPSILON (ldexp(1.0,-MAXDEPTH-1)) /*Flatness control value */ +//#define BEZIER_EPSILON 0.00005 /*Flatness control value */ +#define DEGREE 3 /* Cubic Bezier curve */ +#define W_DEGREE 5 /* Degree of eqn to find roots of */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +template class bezier; + +//! Cubic Bezier Curve Base Class +// This generic implementation uses the DeCasteljau algorithm. +// Works for just about anything that has an affine combination function +template +class bezier_base : public std::unary_function +{ +public: + typedef V value_type; + typedef T time_type; + +private: + value_type a,b,c,d; + time_type r,s; + +protected: + affine_combo affine_func; + +public: + bezier_base():r(0.0),s(1.0) { } + bezier_base( + const value_type &a, const value_type &b, const value_type &c, const value_type &d, + const time_type &r=0.0, const time_type &s=1.0): + a(a),b(b),c(c),d(d),r(r),s(s) { sync(); } + + void sync() + { + } + + value_type + operator()(time_type t)const + { + t=(t-r)/(s-r); + return + affine_func( + affine_func( + affine_func(a,b,t), + affine_func(b,c,t) + ,t), + affine_func( + affine_func(b,c,t), + affine_func(c,d,t) + ,t) + ,t); + } + + /* + void evaluate(time_type t, value_type &f, value_type &df) const + { + t=(t-r)/(s-r); + + value_type p1 = affine_func( + affine_func(a,b,t), + affine_func(b,c,t) + ,t); + value_type p2 = affine_func( + affine_func(b,c,t), + affine_func(c,d,t) + ,t); + + f = affine_func(p1,p2,t); + df = (p2-p1)*3; + } + */ + + void set_rs(time_type new_r, time_type new_s) { r=new_r; s=new_s; } + void set_r(time_type new_r) { r=new_r; } + void set_s(time_type new_s) { s=new_s; } + const time_type &get_r()const { return r; } + const time_type &get_s()const { return s; } + time_type get_dt()const { return s-r; } + + bool intersect_hull(const bezier_base &x)const + { + return 0; + } + + //! Bezier curve intersection function + /*! Calculates the time of intersection + ** for the calling curve. + ** + ** I still have not figured out a good generic + ** method of doing this for a bi-infinite + ** cubic bezier curve calculated with the DeCasteljau + ** algorithm. + ** + ** One method, although it does not work for the + ** entire bi-infinite curve, is to iteratively + ** intersect the hulls. However, we would only detect + ** intersections that occur between R and S. + ** + ** It is entirely possible that a new construct similar + ** to the affine combination function will be necessary + ** for this to work properly. + ** + ** For now, this function is BROKEN. (although it works + ** for the floating-point specializations, using newton's method) + */ + time_type intersect(const bezier_base &x, time_type near=0.0)const + { + return 0; + } + + /* subdivide at some time t into 2 separate curves left and right + + b0 l1 + * 0+1 l2 + b1 * 1+2*1+2 l3 + * 1+2 * 0+3*1+3*2+3 l4,r1 + b2 * 1+2*2+2 r2 * + * 2+3 r3 * + b3 r4 * + * + + 0.1 2.3 -> 0.1 2 3 4 5.6 + */ +/* void subdivide(bezier_base *left, bezier_base *right, const time_type &time = (time_type)0.5) const + { + time_type t = (time-r)/(s-r); + bezier_base lt,rt; + + value_type temp; + + //1st stage points to keep + lt.a = a; + rt.d = d; + + //2nd stage calc + lt.b = affine_func(a,b,t); + temp = affine_func(b,c,t); + rt.c = affine_func(c,d,t); + + //3rd stage calc + lt.c = affine_func(lt.b,temp,t); + rt.b = affine_func(temp,rt.c,t); + + //last stage calc + lt.d = rt.a = affine_func(lt.c,rt.b,t); + + //set the time range for l,r (the inside values should be 1, 0 respectively) + lt.r = r; + rt.s = s; + + //give back the curves + if(left) *left = lt; + if(right) *right = rt; + } + */ + value_type & + operator[](int i) + { return (&a)[i]; } + + const value_type & + operator[](int i) const + { return (&a)[i]; } +}; + + +#if 1 +// Fast float implementation of a cubic bezier curve +template <> +class bezier_base : public std::unary_function +{ +public: + typedef float value_type; + typedef float time_type; +private: + affine_combo affine_func; + value_type a,b,c,d; + time_type r,s; + + value_type _coeff[4]; + time_type drs; // reciprocal of (s-r) +public: + bezier_base():r(0.0),s(1.0),drs(1.0) { } + bezier_base( + const value_type &a, const value_type &b, const value_type &c, const value_type &d, + const time_type &r=0.0, const time_type &s=1.0): + a(a),b(b),c(c),d(d),r(r),s(s),drs(1.0/(s-r)) { sync(); } + + void sync() + { +// drs=1.0/(s-r); + _coeff[0]= a; + _coeff[1]= b*3 - a*3; + _coeff[2]= c*3 - b*6 + a*3; + _coeff[3]= d - c*3 + b*3 - a; + } + + // Cost Summary: 4 products, 3 sums, and 1 difference. + inline value_type + operator()(time_type t)const + { t-=r; t*=drs; return _coeff[0]+(_coeff[1]+(_coeff[2]+(_coeff[3])*t)*t)*t; } + + void set_rs(time_type new_r, time_type new_s) { r=new_r; s=new_s; drs=1.0/(s-r); } + void set_r(time_type new_r) { r=new_r; drs=1.0/(s-r); } + void set_s(time_type new_s) { s=new_s; drs=1.0/(s-r); } + const time_type &get_r()const { return r; } + const time_type &get_s()const { return s; } + time_type get_dt()const { return s-r; } + + //! Bezier curve intersection function + /*! Calculates the time of intersection + ** for the calling curve. + */ + time_type intersect(const bezier_base &x, time_type t=0.0,int i=15)const + { + //BROKEN - the time values of the 2 curves should be independent + value_type system[4]; + system[0]=_coeff[0]-x._coeff[0]; + system[1]=_coeff[1]-x._coeff[1]; + system[2]=_coeff[2]-x._coeff[2]; + system[3]=_coeff[3]-x._coeff[3]; + + t-=r; + t*=drs; + + // Newton's method + // Inner loop cost summary: 7 products, 5 sums, 1 difference + for(;i;i--) + t-= (system[0]+(system[1]+(system[2]+(system[3])*t)*t)*t)/ + (system[1]+(system[2]*2+(system[3]*3)*t)*t); + + t*=(s-r); + t+=r; + + return t; + } + + value_type & + operator[](int i) + { return (&a)[i]; } + + const value_type & + operator[](int i) const + { return (&a)[i]; } +}; + + +// Fast double implementation of a cubic bezier curve +template <> +class bezier_base : public std::unary_function +{ +public: + typedef double value_type; + typedef float time_type; +private: + affine_combo affine_func; + value_type a,b,c,d; + time_type r,s; + + value_type _coeff[4]; + time_type drs; // reciprocal of (s-r) +public: + bezier_base():r(0.0),s(1.0),drs(1.0) { } + bezier_base( + const value_type &a, const value_type &b, const value_type &c, const value_type &d, + const time_type &r=0.0, const time_type &s=1.0): + a(a),b(b),c(c),d(d),r(r),s(s),drs(1.0/(s-r)) { sync(); } + + void sync() + { +// drs=1.0/(s-r); + _coeff[0]= a; + _coeff[1]= b*3 - a*3; + _coeff[2]= c*3 - b*6 + a*3; + _coeff[3]= d - c*3 + b*3 - a; + } + + // 4 products, 3 sums, and 1 difference. + inline value_type + operator()(time_type t)const + { t-=r; t*=drs; return _coeff[0]+(_coeff[1]+(_coeff[2]+(_coeff[3])*t)*t)*t; } + + void set_rs(time_type new_r, time_type new_s) { r=new_r; s=new_s; drs=1.0/(s-r); } + void set_r(time_type new_r) { r=new_r; drs=1.0/(s-r); } + void set_s(time_type new_s) { s=new_s; drs=1.0/(s-r); } + const time_type &get_r()const { return r; } + const time_type &get_s()const { return s; } + time_type get_dt()const { return s-r; } + + //! Bezier curve intersection function + /*! Calculates the time of intersection + ** for the calling curve. + */ + time_type intersect(const bezier_base &x, time_type t=0.0,int i=15)const + { + //BROKEN - the time values of the 2 curves should be independent + value_type system[4]; + system[0]=_coeff[0]-x._coeff[0]; + system[1]=_coeff[1]-x._coeff[1]; + system[2]=_coeff[2]-x._coeff[2]; + system[3]=_coeff[3]-x._coeff[3]; + + t-=r; + t*=drs; + + // Newton's method + // Inner loop: 7 products, 5 sums, 1 difference + for(;i;i--) + t-= (system[0]+(system[1]+(system[2]+(system[3])*t)*t)*t)/ + (system[1]+(system[2]*2+(system[3]*3)*t)*t); + + t*=(s-r); + t+=r; + + return t; + } + + value_type & + operator[](int i) + { return (&a)[i]; } + + const value_type & + operator[](int i) const + { return (&a)[i]; } +}; + +//#ifdef __FIXED__ + +// Fast double implementation of a cubic bezier curve +/* +template <> +template +class bezier_base > : std::unary_function,fixed_base > +{ +public: + typedef fixed_base value_type; + typedef fixed_base time_type; + +private: + affine_combo affine_func; + value_type a,b,c,d; + time_type r,s; + + value_type _coeff[4]; + time_type drs; // reciprocal of (s-r) +public: + bezier_base():r(0.0),s(1.0),drs(1.0) { } + bezier_base( + const value_type &a, const value_type &b, const value_type &c, const value_type &d, + const time_type &r=0, const time_type &s=1): + a(a),b(b),c(c),d(d),r(r),s(s),drs(1.0/(s-r)) { sync(); } + + void sync() + { + drs=time_type(1)/(s-r); + _coeff[0]= a; + _coeff[1]= b*3 - a*3; + _coeff[2]= c*3 - b*6 + a*3; + _coeff[3]= d - c*3 + b*3 - a; + } + + // 4 products, 3 sums, and 1 difference. + inline value_type + operator()(time_type t)const + { t-=r; t*=drs; return _coeff[0]+(_coeff[1]+(_coeff[2]+(_coeff[3])*t)*t)*t; } + + void set_rs(time_type new_r, time_type new_s) { r=new_r; s=new_s; drs=time_type(1)/(s-r); } + void set_r(time_type new_r) { r=new_r; drs=time_type(1)/(s-r); } + void set_s(time_type new_s) { s=new_s; drs=time_type(1)/(s-r); } + const time_type &get_r()const { return r; } + const time_type &get_s()const { return s; } + time_type get_dt()const { return s-r; } + + //! Bezier curve intersection function + //! Calculates the time of intersection + // for the calling curve. + // + time_type intersect(const bezier_base &x, time_type t=0,int i=15)const + { + value_type system[4]; + system[0]=_coeff[0]-x._coeff[0]; + system[1]=_coeff[1]-x._coeff[1]; + system[2]=_coeff[2]-x._coeff[2]; + system[3]=_coeff[3]-x._coeff[3]; + + t-=r; + t*=drs; + + // Newton's method + // Inner loop: 7 products, 5 sums, 1 difference + for(;i;i--) + t-=(time_type) ( (system[0]+(system[1]+(system[2]+(system[3])*t)*t)*t)/ + (system[1]+(system[2]*2+(system[3]*3)*t)*t) ); + + t*=(s-r); + t+=r; + + return t; + } + + value_type & + operator[](int i) + { return (&a)[i]; } + + const value_type & + operator[](int i) const + { return (&a)[i]; } +}; +*/ +//#endif + +#endif + + + +template +class bezier_iterator +{ +public: + + struct iterator_category {}; + typedef V value_type; + typedef T difference_type; + typedef V reference; + +private: + difference_type t; + difference_type dt; + bezier_base curve; + +public: + +/* + reference + operator*(void)const { return curve(t); } + const surface_iterator& + + operator++(void) + { t+=dt; return &this; } + + const surface_iterator& + operator++(int) + { hermite_iterator _tmp=*this; t+=dt; return _tmp; } + + const surface_iterator& + operator--(void) + { t-=dt; return &this; } + + const surface_iterator& + operator--(int) + { hermite_iterator _tmp=*this; t-=dt; return _tmp; } + + + surface_iterator + operator+(difference_type __n) const + { return surface_iterator(data+__n[0]+__n[1]*pitch,pitch); } + + surface_iterator + operator-(difference_type __n) const + { return surface_iterator(data-__n[0]-__n[1]*pitch,pitch); } +*/ + +}; + +template +class bezier : public bezier_base +{ +public: + typedef V value_type; + typedef T time_type; + typedef float distance_type; + typedef bezier_iterator iterator; + typedef bezier_iterator const_iterator; + + distance_func dist; + + using bezier_base::get_r; + using bezier_base::get_s; + using bezier_base::get_dt; + +public: + bezier() { } + bezier(const value_type &a, const value_type &b, const value_type &c, const value_type &d): + bezier_base(a,b,c,d) { } + + + const_iterator begin()const; + const_iterator end()const; + + time_type find_closest(bool fast, const value_type& x, int i=7)const + { + if (!fast) + { + value_type array[4] = { + bezier::operator[](0), + bezier::operator[](1), + bezier::operator[](2), + bezier::operator[](3)}; + float t = NearestPointOnCurve(x, array); + return t > 0.999999 ? 0.999999 : t < 0.000001 ? 0.000001 : t; + } + else + { + time_type r(0), s(1); + float t((r+s)*0.5); /* half way between r and s */ + + for(;i;i--) + { + // compare 33% of the way between r and s with 67% of the way between r and s + if(dist(operator()((s-r)*(1.0/3.0)+r), x) < + dist(operator()((s-r)*(2.0/3.0)+r), x)) + s=t; + else + r=t; + t=((r+s)*0.5); + } + return t; + } + } + + distance_type find_distance(time_type r, time_type s, int steps=7)const + { + const time_type inc((s-r)/steps); + distance_type ret(0); + value_type last(operator()(r)); + + for(r+=inc;r 0.1 2 3 4 5.6 + */ + void subdivide(bezier *left, bezier *right, const time_type &time = (time_type)0.5) const + { + time_type t=(time-get_r())/get_dt(); + bezier lt,rt; + + value_type temp; + const value_type& a((*this)[0]); + const value_type& b((*this)[1]); + const value_type& c((*this)[2]); + const value_type& d((*this)[3]); + + //1st stage points to keep + lt[0] = a; + rt[3] = d; + + //2nd stage calc + lt[1] = affine_func(a,b,t); + temp = affine_func(b,c,t); + rt[2] = affine_func(c,d,t); + + //3rd stage calc + lt[2] = affine_func(lt[1],temp,t); + rt[1] = affine_func(temp,rt[2],t); + + //last stage calc + lt[3] = rt[0] = affine_func(lt[2],rt[1],t); + + //set the time range for l,r (the inside values should be 1, 0 respectively) + lt.set_r(get_r()); + rt.set_s(get_s()); + + lt.sync(); + rt.sync(); + + //give back the curves + if(left) *left = lt; + if(right) *right = rt; + } + + + void evaluate(time_type t, value_type &f, value_type &df) const + { + t=(t-get_r())/get_dt(); + + const value_type& a((*this)[0]); + const value_type& b((*this)[1]); + const value_type& c((*this)[2]); + const value_type& d((*this)[3]); + + const value_type p1 = affine_func( + affine_func(a,b,t), + affine_func(b,c,t) + ,t); + const value_type p2 = affine_func( + affine_func(b,c,t), + affine_func(c,d,t) + ,t); + + f = affine_func(p1,p2,t); + df = (p2-p1)*3; + } + +private: + /* + * Bezier : + * Evaluate a Bezier curve at a particular parameter value + * Fill in control points for resulting sub-curves if "Left" and + * "Right" are non-null. + * + * int degree; Degree of bezier curve + * value_type *VT; Control pts + * time_type t; Parameter value + * value_type *Left; RETURN left half ctl pts + * value_type *Right; RETURN right half ctl pts + */ + static value_type Bezier(value_type *VT, int degree, time_type t, value_type *Left, value_type *Right) + { + int i, j; /* Index variables */ + value_type Vtemp[W_DEGREE+1][W_DEGREE+1]; + + /* Copy control points */ + for (j = 0; j <= degree; j++) + Vtemp[0][j] = VT[j]; + + /* Triangle computation */ + for (i = 1; i <= degree; i++) + for (j =0 ; j <= degree - i; j++) + { + Vtemp[i][j][0] = (1.0 - t) * Vtemp[i-1][j][0] + t * Vtemp[i-1][j+1][0]; + Vtemp[i][j][1] = (1.0 - t) * Vtemp[i-1][j][1] + t * Vtemp[i-1][j+1][1]; + } + + if (Left != NULL) + for (j = 0; j <= degree; j++) + Left[j] = Vtemp[j][0]; + + if (Right != NULL) + for (j = 0; j <= degree; j++) + Right[j] = Vtemp[degree-j][j]; + + return (Vtemp[degree][0]); + } + + /* + * CrossingCount : + * Count the number of times a Bezier control polygon + * crosses the 0-axis. This number is >= the number of roots. + * + * value_type *VT; Control pts of Bezier curve + */ + static int CrossingCount(value_type *VT) + { + int i; + int n_crossings = 0; /* Number of zero-crossings */ + int sign, old_sign; /* Sign of coefficients */ + + sign = old_sign = SGN(VT[0][1]); + for (i = 1; i <= W_DEGREE; i++) + { + sign = SGN(VT[i][1]); + if (sign != old_sign) n_crossings++; + old_sign = sign; + } + + return n_crossings; + } + + /* + * ControlPolygonFlatEnough : + * Check if the control polygon of a Bezier curve is flat enough + * for recursive subdivision to bottom out. + * + * value_type *VT; Control points + */ + static int ControlPolygonFlatEnough(value_type *VT) + { + int i; /* Index variable */ + distance_type distance[W_DEGREE]; /* Distances from pts to line */ + distance_type max_distance_above; /* maximum of these */ + distance_type max_distance_below; + time_type intercept_1, intercept_2, left_intercept, right_intercept; + distance_type a, b, c; /* Coefficients of implicit */ + /* eqn for line from VT[0]-VT[deg] */ + /* Find the perpendicular distance */ + /* from each interior control point to */ + /* line connecting VT[0] and VT[W_DEGREE] */ + { + distance_type abSquared; + + /* Derive the implicit equation for line connecting first * + * and last control points */ + a = VT[0][1] - VT[W_DEGREE][1]; + b = VT[W_DEGREE][0] - VT[0][0]; + c = VT[0][0] * VT[W_DEGREE][1] - VT[W_DEGREE][0] * VT[0][1]; + + abSquared = (a * a) + (b * b); + + for (i = 1; i < W_DEGREE; i++) + { + /* Compute distance from each of the points to that line */ + distance[i] = a * VT[i][0] + b * VT[i][1] + c; + if (distance[i] > 0.0) distance[i] = (distance[i] * distance[i]) / abSquared; + if (distance[i] < 0.0) distance[i] = -(distance[i] * distance[i]) / abSquared; + } + } + + /* Find the largest distance */ + max_distance_above = max_distance_below = 0.0; + + for (i = 1; i < W_DEGREE; i++) + { + if (distance[i] < 0.0) max_distance_below = MIN(max_distance_below, distance[i]); + if (distance[i] > 0.0) max_distance_above = MAX(max_distance_above, distance[i]); + } + + /* Implicit equation for "above" line */ + intercept_1 = -(c + max_distance_above)/a; + + /* Implicit equation for "below" line */ + intercept_2 = -(c + max_distance_below)/a; + + /* Compute intercepts of bounding box */ + left_intercept = MIN(intercept_1, intercept_2); + right_intercept = MAX(intercept_1, intercept_2); + + return 0.5 * (right_intercept-left_intercept) < BEZIER_EPSILON ? 1 : 0; + } + + /* + * ComputeXIntercept : + * Compute intersection of chord from first control point to last + * with 0-axis. + * + * value_type *VT; Control points + */ + static time_type ComputeXIntercept(value_type *VT) + { + distance_type YNM = VT[W_DEGREE][1] - VT[0][1]; + return (YNM*VT[0][0] - (VT[W_DEGREE][0] - VT[0][0])*VT[0][1]) / YNM; + } + + /* + * FindRoots : + * Given a 5th-degree equation in Bernstein-Bezier form, find + * all of the roots in the interval [0, 1]. Return the number + * of roots found. + * + * value_type *w; The control points + * time_type *t; RETURN candidate t-values + * int depth; The depth of the recursion + */ + static int FindRoots(value_type *w, time_type *t, int depth) + { + int i; + value_type Left[W_DEGREE+1]; /* New left and right */ + value_type Right[W_DEGREE+1]; /* control polygons */ + int left_count; /* Solution count from */ + int right_count; /* children */ + time_type left_t[W_DEGREE+1]; /* Solutions from kids */ + time_type right_t[W_DEGREE+1]; + + switch (CrossingCount(w)) + { + case 0 : + { /* No solutions here */ + return 0; + } + case 1 : + { /* Unique solution */ + /* Stop recursion when the tree is deep enough */ + /* if deep enough, return 1 solution at midpoint */ + if (depth >= MAXDEPTH) + { + t[0] = (w[0][0] + w[W_DEGREE][0]) / 2.0; + return 1; + } + if (ControlPolygonFlatEnough(w)) + { + t[0] = ComputeXIntercept(w); + return 1; + } + break; + } + } + + /* Otherwise, solve recursively after */ + /* subdividing control polygon */ + Bezier(w, W_DEGREE, 0.5, Left, Right); + left_count = FindRoots(Left, left_t, depth+1); + right_count = FindRoots(Right, right_t, depth+1); + + /* Gather solutions together */ + for (i = 0; i < left_count; i++) t[i] = left_t[i]; + for (i = 0; i < right_count; i++) t[i+left_count] = right_t[i]; + + /* Send back total number of solutions */ + return (left_count+right_count); + } + + /* + * ConvertToBezierForm : + * Given a point and a Bezier curve, generate a 5th-degree + * Bezier-format equation whose solution finds the point on the + * curve nearest the user-defined point. + * + * value_type& P; The point to find t for + * value_type *VT; The control points + */ + static void ConvertToBezierForm(const value_type& P, value_type *VT, value_type w[W_DEGREE+1]) + { + int i, j, k, m, n, ub, lb; + int row, column; /* Table indices */ + value_type c[DEGREE+1]; /* VT(i)'s - P */ + value_type d[DEGREE]; /* VT(i+1) - VT(i) */ + distance_type cdTable[3][4]; /* Dot product of c, d */ + static distance_type z[3][4] = { /* Precomputed "z" for cubics */ + {1.0, 0.6, 0.3, 0.1}, + {0.4, 0.6, 0.6, 0.4}, + {0.1, 0.3, 0.6, 1.0}}; + + /* Determine the c's -- these are vectors created by subtracting */ + /* point P from each of the control points */ + for (i = 0; i <= DEGREE; i++) + c[i] = VT[i] - P; + + /* Determine the d's -- these are vectors created by subtracting */ + /* each control point from the next */ + for (i = 0; i <= DEGREE - 1; i++) + d[i] = (VT[i+1] - VT[i]) * 3.0; + + /* Create the c,d table -- this is a table of dot products of the */ + /* c's and d's */ + for (row = 0; row <= DEGREE - 1; row++) + for (column = 0; column <= DEGREE; column++) + cdTable[row][column] = d[row] * c[column]; + + /* Now, apply the z's to the dot products, on the skew diagonal */ + /* Also, set up the x-values, making these "points" */ + for (i = 0; i <= W_DEGREE; i++) + { + w[i][0] = (distance_type)(i) / W_DEGREE; + w[i][1] = 0.0; + } + + n = DEGREE; + m = DEGREE-1; + for (k = 0; k <= n + m; k++) + { + lb = MAX(0, k - m); + ub = MIN(k, n); + for (i = lb; i <= ub; i++) + { + j = k - i; + w[i+j][1] += cdTable[j][i] * z[j][i]; + } + } + } + + /* + * NearestPointOnCurve : + * Compute the parameter value of the point on a Bezier + * curve segment closest to some arbitrary, user-input point. + * Return the point on the curve at that parameter value. + * + * value_type& P; The user-supplied point + * value_type *VT; Control points of cubic Bezier + */ + static time_type NearestPointOnCurve(const value_type& P, value_type VT[4]) + { + value_type w[W_DEGREE+1]; /* Ctl pts of 5th-degree curve */ + time_type t_candidate[W_DEGREE]; /* Possible roots */ + int n_solutions; /* Number of roots found */ + time_type t; /* Parameter value of closest pt */ + + /* Convert problem to 5th-degree Bezier form */ + ConvertToBezierForm(P, VT, w); + + /* Find all possible roots of 5th-degree equation */ + n_solutions = FindRoots(w, t_candidate, 0); + + /* Compare distances of P to all candidates, and to t=0, and t=1 */ + { + distance_type dist, new_dist; + value_type p, v; + int i; + + /* Check distance to beginning of curve, where t = 0 */ + dist = (P - VT[0]).mag_squared(); + t = 0.0; + + /* Find distances for candidate points */ + for (i = 0; i < n_solutions; i++) + { + p = Bezier(VT, DEGREE, t_candidate[i], (value_type *)NULL, (value_type *)NULL); + new_dist = (P - p).mag_squared(); + if (new_dist < dist) + { + dist = new_dist; + t = t_candidate[i]; + } + } + + /* Finally, look at distance to end point, where t = 1.0 */ + new_dist = (P - VT[DEGREE]).mag_squared(); + if (new_dist < dist) + { + dist = new_dist; + t = 1.0; + } + } + + /* Return the point on the curve at parameter value t */ + return t; + } +}; + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_bezier_angle.h b/ETL/tags/0.61.06/ETL/_bezier_angle.h new file mode 100644 index 0000000..10156f2 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_bezier_angle.h @@ -0,0 +1,107 @@ +/*! ======================================================================== +** Extended Template Library +** Bezier Template Class Implementation (Angle Specialization) +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL_BEZIER_ANGLE_H +#define __ETL_BEZIER_ANGLE_H + +/* === H E A D E R S ======================================================= */ + +#include "_curve_func.h" +#include "angle" + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +/* +template <> +class bezier_base : std::unary_function +{ +public: + typedef angle value_type; + typedef float time_type; +private: + affine_combo affine_func; + value_type a,b,c,d; + time_type r,s; + +public: + bezier_base():r(0.0),s(1.0) { } + bezier_base( + const value_type &a, const value_type &b, const value_type &c, const value_type &d, + const time_type &r=0.0, const time_type &s=1.0): + a(a),b(b),c(c),d(d),r(r),s(s) { sync(); } + + void sync(void) + { + } + + value_type + operator()(time_type t)const + { + t=(t-r)/(s-r); + return + affine_func( + affine_func( + affine_func(a,b,t), + affine_func(b,c,t) + ,t), + affine_func( + affine_func(b,c,t), + affine_func(c,d,t) + ,t) + ,t); + } + + void set_rs(time_type new_r, time_type new_s) { r=new_r; s=new_s; } + void set_r(time_type new_r) { r=new_r; } + void set_s(time_type new_s) { s=new_s; } + const time_type &get_r(void)const { return r; } + const time_type &get_s(void)const { return s; } + time_type get_dt(void)const { return s-r; } + + value_type & + operator[](int i) + { return (&a)[i]; } + + const value_type & + operator[](int i) const + { return (&a)[i]; } +}; +*/ + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif + diff --git a/ETL/tags/0.61.06/ETL/_bit_rotate.h b/ETL/tags/0.61.06/ETL/_bit_rotate.h new file mode 100644 index 0000000..c21c0e7 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_bit_rotate.h @@ -0,0 +1,62 @@ +/*! ======================================================================== +** Extended Template Library +** Bit Rotation Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** These template functions have not yet been throughly tested, +** and may be inaccurate or just plain wrong. You have been warned. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL_BIT_ROTATE_H +#define __ETL_BIT_ROTATE_H + +/* === H E A D E R S ======================================================= */ + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +template T +rot_left(const T &val, const int &bits=1) +{ + return (T)( ((unsigned)val<>(sizeof(T)*8-bits)) ); +} + +template T +rot_right(const T &val, const int &bits=1) +{ + return (T)( ((unsigned)val>>bits)+((unsigned)val<<(sizeof(T)*8-bits)) ); +} + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif + diff --git a/ETL/tags/0.61.06/ETL/_boxblur.h b/ETL/tags/0.61.06/ETL/_boxblur.h new file mode 100644 index 0000000..39413e8 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_boxblur.h @@ -0,0 +1,246 @@ +/*! ======================================================================== +** Extended Template Library +** Box Blur Template Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL_BOXBLUR_H +#define __ETL_BOXBLUR_H + +/* === H E A D E R S ======================================================= */ + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +template void +hbox_blur(T1 pen,int w, int h, int length, T2 outpen) +{ + int x,y; + typename T1::iterator_x iter, end; + + length=std::min(w,length); + const float divisor(1.0f/(length*2+1)); + + for(y=0;ylength) ? iter[-length-1] : *pen.x(); + tot += ((x+length) void +vbox_blur(T1 pen,const int w, const int h, int length, T2 outpen) +{ + int x,y; + typename T1::iterator_y iter, end; + + length=std::min(h,length); + const float divisor(1.0f/(length*2+1)); + + for(x=0;xlength) ? iter[-length-1] : *pen.y(); + tot += ((y+length) void +vbox_blur(T1 pen,int w, int h, int length,T2 outpen) +{ + int x,y; + typename T1::iterator_y iter, end, biter,eiter; + + //print out the info I need to figure out if this is somehow a buffer overrun... + /*char *beginptr=0,*endptr=0; + { + T1 ypen = pen; + T1 endpen = pen; + endpen.move(w,h); + ypen.inc_y(); + + T2 open = outpen, + oepen = outpen; + oepen.move(w,h); + printf("V Blur (%d,%d,s-%d) in(%p,%p,st %d) out(%p,%p)\n", + w,h,length,(char*)pen.x(),(char*)endpen.x(),(char*)ypen.x()-(char*)pen.x(), + (char*)open.x(),(char*)oepen.x()); + }*/ + length=min(h-1,length); + + const float divisor(1.0f/(length*2+1)); + //const int div = (length*2+1); + + //since the filter range is 2*length+1 we need h-1 + for(x=0;x%.3f),",y,&iter[y],iter[y],tot); + } + iter=pen.y(); + + //printf(" tot=%.3f\n",tot); + + biter = iter+(-length-1); //get the first one... + eiter = iter+length; + + //y will always be > length + //T2 open = outpen; + for (y=0;ylength) + { + typename T1::value_type &v = *biter; + /*if( (char*)&v < beginptr || + (char*)&v >= endptr) + printf("crap! %d (%p off %p)\n",y,(char*)&v,(char*)&*iter);*/ + tot -= v; + //printf("[%.3f,",v); + } + else + { + tot -= bval; + //printf("[%.3f,",bval); + } + + if (y+length= endptr) + printf("crap! %d (%p off %p)\n",y,(char*)&v,(char*)&*iter);*/ + tot += v; + //printf("%.3f]",v); + } + else + { + tot += eval; + //printf("%.3f]",eval); + } + + //test handled in the previous case... + //tot -= (y>length) ? *biter : bval; + //tot += (y+length void +box_blur(T1 pen,int w, int h, int blur_w, int blur_h, T2 outpen) + { hbox_blur(pen,w,h,blur_w,outpen); vbox_blur(pen,w,h,blur_h,outpen); } + +template void +box_blur(T1 pen,int w, int h, int size, T2 outpen) + { hbox_blur(pen,w,h,size,outpen); vbox_blur(pen,w,h,size,outpen); } + +template void +hbox_blur(T1 begin,T1 end, int len,T2 outpen) +{ + typename T1::difference_type size(end-begin); + hbox_blur(begin,size.x,size.y,len,outpen); +} + +template void +vbox_blur(T1 begin,T1 end, int len,T2 outpen) +{ + typename T1::difference_type size(end-begin); + vbox_blur(begin,size.x,size.y,len,outpen); +} + +template void +box_blur(T1 begin,T1 end, int blur_w, int blur_h,T2 outpen) +{ + typename T1::difference_type size(end-begin); + hbox_blur(begin,size.x,size.y,blur_w,outpen); vbox_blur(begin,size.x,size.y,blur_h,outpen); +} + +template void +box_blur(T1 begin,T1 end, int blursize,T2 outpen) +{ + typename T1::difference_type size(end-begin); + hbox_blur(begin,size.x,size.y,blursize,outpen); vbox_blur(begin,size.x,size.y,blursize,outpen); +} + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_bspline.h b/ETL/tags/0.61.06/ETL/_bspline.h new file mode 100644 index 0000000..edc00a7 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_bspline.h @@ -0,0 +1,237 @@ +/*! ======================================================================== +** Extended Template and Library +** B-Spline Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__BSPLINE_H +#define __ETL__BSPLINE_H + +/* === H E A D E R S ======================================================= */ + +#include +#include +#include "_curve_func.h" + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +template , class D=distance_func > +class bspline : public std::unary_function +{ +public: + typedef T value_type; + typedef K knot_type; + typedef std::vector knot_container; + typedef std::vector cpoint_container; + typedef typename knot_container::iterator knot_iterator; + typedef typename cpoint_container::iterator cpoint_iterator; + + typedef C affine_func_type; + typedef D distance_func_type; + +protected: + affine_func_type affine_func; + distance_func_type distance_func; + +private: + int m; + knot_container _knots; + cpoint_container _cpoints; + bool _loop; + +public: + bspline():m(2),_loop(false) { } + + int get_m()const { return m-1; }; + int set_m(int new_m) { m=new_m+1; return m-1; }; + + bool set_loop(bool x) { _loop=x; reset_knots(); return _loop; } + + knot_container & knots() { return _knots; }; + cpoint_container & cpoints() { return _cpoints; }; + + const knot_container & knots()const { return _knots; }; + const cpoint_container & cpoints()const { return _cpoints; }; + + void reset_knots() + { + int i; + + if(!_loop) + { + _knots.clear(); + if(!_cpoints.size()) + return; + while(m>(signed)_cpoints.size()) + m--; + for(i=0;i(signed)_cpoints.size()) + m--; + for(i=0;i<=(signed)_cpoints.size()-m+1;i++) + *_knots.insert(_knots.end())=i; + } + } + + int calc_curve_segment(knot_type t)const + { + int k; + if(t<0) + t=0; + if(t>=_knots.back()) + t=_knots.back()-0.0001; + for(k=0;_knots[k]>t || _knots[k+1]<=t;k++) + ; + + return k; + } + + knot_container get_segment_knots(int i)const + { + if(i+1=(signed)_knots.size()) + { + knot_container ret(_knots.begin()+i-m+1,_knots.end()); + return ret; + } + return knot_container(_knots.begin()+i-m+1, _knots.begin()+i+m); + } + + cpoint_container get_segment_cpoints(int i)const + { + if(i+1=(signed)_knots.size()) + { + return cpoint_container(); + } + return cpoint_container(_cpoints.begin()+i-m+1, _cpoints.begin()+i+1); + } + + cpoint_container calc_shell(knot_type t, int level)const + { + int + i=calc_curve_segment(t), + j,k; + + knot_container u=get_segment_knots(i); + + cpoint_container d=get_segment_cpoints(i); + + if(!d.size()) + return cpoint_container(); + + for(j=0;d.size()>1 && j1;d.pop_back(),j++) + { + for(k=0;k<(signed)d.size()-1;k++) + { + d[k]=affine_func(d[k],d[k+1],((t-u[j+k+1])/(u[m+k]-u[j+k+1]))); + } + } + return d.front(); + } + + cpoint_iterator find_closest_cpoint(const value_type &point, typename distance_func_type::result_type max) + { + cpoint_iterator i=_cpoints.begin(); + cpoint_iterator ret=i; + typename distance_func_type::result_type dist=distance_func(point,_cpoints[0]); + + // The distance function returns "cooked" (ie: squared) + // distances, so we need to cook our max distance for + // the comparison to work correctly. + max=distance_func.cook(max); + + for(++i;i<_cpoints.end();i++) + { + typename distance_func_type::result_type thisdist=distance_func(point,*i); + + if(thisdist + +/* === M A C R O S ========================================================= */ + +//#ifndef _EPSILON +//#define _EPSILON 0.0000001 +//#endif + +#define ETL_FIXED_DERIVATIVE 1 + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +template +class derivative : public std::unary_function +{ + T func; + typename T::argument_type epsilon; +public: + explicit derivative(const T &x, const typename T::argument_type &epsilon=0.000001):func(x),epsilon(epsilon) { } + + typename T::result_type + operator()(const typename T::argument_type &x)const + { +#ifdef ETL_FIXED_DERIVATIVE + return (func(x+epsilon)-func(x))/epsilon; +#else + return (func(x)-func(x+epsilon))/epsilon; +#endif + } +}; + +template +class integral : public std::binary_function +{ + T func; + int samples; +public: + explicit integral(const T &x, const int &samples=500):func(x),samples(samples) { } + + typename T::result_type + operator()(typename T::argument_type x,typename T::argument_type y)const + { + typename T::result_type ret=0; + int i=samples; + const typename T::argument_type increment=(y-x)/i; + + for(;i;i--,x+=increment) + ret+=(func(x)+func(x+increment))*increment/2; + return ret; + } +}; + +_ETL_END_NAMESPACE + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_clock_base.h b/ETL/tags/0.61.06/ETL/_clock_base.h new file mode 100644 index 0000000..32d8742 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_clock_base.h @@ -0,0 +1,133 @@ +/*! ======================================================================== +** Extended Template and Library +** Clock Abstraction Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__CLOCK_H +#define __ETL__CLOCK_H + +/* === H E A D E R S ======================================================= */ + +#ifndef WIN32 +#include +#else +inline void sleep(int i) { Sleep(i*1000); } +#endif + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +inline void yield() { sleep(0); } + +/*! ======================================================================== +** \class clock_base +** \brief clock abstraction +** +** A more detailed description needs to be written. +*/ +template +class clock_base : public DESC +{ +public: + typedef typename DESC::value_type value_type; + +private: + typedef clock_base _clock; + typedef typename DESC::timestamp timestamp; + + timestamp base_time; + + using DESC::get_current_time; + using DESC::realtime; + using DESC::one_second; +public: + + clock_base() { reset(); } + + void reset() + { get_current_time(base_time); } + + value_type operator()()const + { return timestamp_to_seconds(get_current_time()-base_time); } + + value_type pop_time() + { + // Grab the old base time + timestamp old_time=base_time; + + // Put the current time into base_time + get_current_time(base_time); + + return timestamp_to_seconds(base_time-old_time); + } + + static void + sleep(const value_type &length) + { + if(!realtime()) + ::sleep((int)(length+0.5)); + else + { + _clock timer; + timer.reset(); + value_type val; + for(val=timer();one_second() +#include + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +class clock_desc_gettimeofday +{ +public: + typedef double value_type; + + inline static bool realtime() + { return true; } + + inline static bool proctime() + { return false; } + + inline static value_type + one_second() + { return 1.0f; } + + inline static value_type precision() + { return one_second()/(value_type)1000000.0f; } + + inline static const char *description() + { return "UNIX gettimeofday()"; }; + +protected: + class timestamp : public timeval + { + timestamp(int sec, int usec) + { tv_sec=sec; tv_usec=usec; } + + friend class clock_desc_gettimeofday; + public: + timestamp() { } + + + inline timestamp operator-(const timestamp &rhs)const + { + timestamp ret; + ret.tv_usec=tv_usec-rhs.tv_usec; + + if(ret.tv_usec<0) + { + ret.tv_sec=tv_sec-rhs.tv_sec-1; + ret.tv_usec+=1000000; + } + else + ret.tv_sec=tv_sec-rhs.tv_sec; + return ret; + } + + inline timestamp operator+(timestamp rhs)const + { + rhs.tv_usec+=tv_usec; + + if(rhs.tv_usec>1000000) + { + rhs.tv_sec+=tv_sec+1; + rhs.tv_usec-=1000000; + } + else + rhs.tv_sec+=tv_sec; + return rhs; + } + + inline bool operator<(const timestamp &rhs)const + { return tv_sec +# define __sys_clock ::clock +# define __sys_time ::time +#else +# ifdef __GNUG__ +# include +# define __sys_clock ::clock +# define __sys_time ::time +# else +typedef int clock_t; +typedef int time_t; +extern clock_t _clock(); +extern time_t _time(time_t *); +# define CLOCKS_PER_SEC 1000 +# define __sys_clock _clock +# define __sys_time _time +# endif +#endif + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +class clock_desc_sys_clock +{ +public: + typedef float value_type; + + inline static bool realtime() + { return false; } + + inline static bool proctime() + { return true; } + + inline static value_type + one_second() + { return 1.0f; } + + inline static value_type precision() + { return one_second()/(value_type)CLOCKS_PER_SEC; } + + inline static const char *description() + { return "ANSI C clock()"; }; + +protected: + typedef clock_t timestamp; + + static void + get_current_time(timestamp &time) + { time=__sys_clock(); } + + static timestamp + get_current_time() + { return __sys_clock(); } + + static value_type + timestamp_to_seconds(const timestamp &x) + { return precision()*x; } + + static timestamp + seconds_to_timestamp(const value_type &x) + { return (timestamp)(x*(value_type)CLOCKS_PER_SEC+0.5); } + +}; + +class clock_desc_sys_time +{ +public: + typedef float value_type; + + inline static bool realtime() + { return true; } + + inline static bool proctime() + { return false; } + + inline static value_type + one_second() + { return 1.0f; } + + inline static value_type precision() + { return one_second(); } + + inline static const char *description() + { return "ANSI C time()"; }; + +protected: + typedef time_t timestamp; + + static void + get_current_time(timestamp &time) + { __sys_time(&time); } + + static timestamp + get_current_time() + { return __sys_time(NULL); } + + static value_type + timestamp_to_seconds(const timestamp &x) + { return (value_type)x; } + + static timestamp + seconds_to_timestamp(const value_type &x) + { return (timestamp)(x+(value_type)0.5f); } +}; + +_ETL_END_NAMESPACE + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_clock_win32hpcount.h b/ETL/tags/0.61.06/ETL/_clock_win32hpcount.h new file mode 100644 index 0000000..561a9d4 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_clock_win32hpcount.h @@ -0,0 +1,98 @@ +/*! ======================================================================== +** Extended Template and Library +** Win32 Clock Description Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__CLOCK_WIN32HPCOUNT_H +#define __ETL__CLOCK_WIN32HPCOUNT_H + +/* === H E A D E R S ======================================================= */ + +#define WIN32_LEAN_AND_MEAN +#include + +/* === M A C R O S ========================================================= */ + +#if defined(__GNUG__) && defined(__int64) +#undef __int64 +#define __int64 long long int +#endif + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +class clock_desc_win32hpcount +{ +public: + typedef double value_type; + + static bool realtime() + { return true; } + + static bool proctime() + { return false; } + + static value_type + one_second() + { return 1.0f; } + + static value_type precision() + { + __int64 freq; + QueryPerformanceFrequency((LARGE_INTEGER*)&freq); + return one_second()/(value_type)freq; + } + + static const char *description() + { return "Win32 QueryPerformanceCounter()"; }; + +protected: + typedef __int64 timestamp; + + static void + get_current_time(timestamp &x) + { QueryPerformanceCounter((LARGE_INTEGER*)&x);} + + static timestamp + get_current_time() + { timestamp ret; QueryPerformanceCounter((LARGE_INTEGER*)&ret); return ret; } + + static value_type + timestamp_to_seconds(const timestamp &x) + { return precision()*x; } + + static timestamp + seconds_to_timestamp(const value_type &x) + { return (timestamp)(x/precision()); } +}; + +_ETL_END_NAMESPACE + +/* === E N D =============================================================== */ + +#endif + diff --git a/ETL/tags/0.61.06/ETL/_condition.h b/ETL/tags/0.61.06/ETL/_condition.h new file mode 100644 index 0000000..26a4d2d --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_condition.h @@ -0,0 +1,70 @@ +/*! ======================================================================== +** Extended Template and Library +** Mutex Abstraction Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__CONDITION_H_ +#define __ETL__CONDITION_H_ + +/* === H E A D E R S ======================================================= */ + +/* === M A C R O S ========================================================= */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +class condition : private mutex +{ + bool flag; +public: + condition() + { flag=false; } + ~condition() + { } + void operator()() + { flag=true; } + void wait() + { + mutex::lock lock(*this); + + while(!flag)Yield(); + flag=false; + } + void wait_next() + { + mutex::lock lock(*this); + + flag=false; + while(!flag)Yield(); + } +}; + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_curve.h b/ETL/tags/0.61.06/ETL/_curve.h new file mode 100644 index 0000000..e5fd2f3 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_curve.h @@ -0,0 +1,80 @@ +/*! ======================================================================== +** Extended Template Library +** Curve Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL_CURVE_H +#define __ETL_CURVE_H + +/* === H E A D E R S ======================================================= */ + +#include "_hermite.h" +#include + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE +/* +#ifdef AUTO +#undef AUTO +#endif +#ifdef LINEAR +#undef LINEAR +#endif +#ifdef ABSOLUTE +#undef ABSOLUTE +#endif +#ifdef FAST_TO_SLOW +#undef FAST_TO_SLOW +#endif + +template +class curve +{ +public: + typedef T value_type; +private: + enum interpolate_type + { + AUTO, + LINEAR, + ABSOLUTE, + FAST_TO_SLOW, + + }; +public: +}; +*/ +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif + diff --git a/ETL/tags/0.61.06/ETL/_curve_func.h b/ETL/tags/0.61.06/ETL/_curve_func.h new file mode 100644 index 0000000..fc33402 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_curve_func.h @@ -0,0 +1,66 @@ +/*! ======================================================================== +** Extended Template and Library +** Utility Curve Template Class Implementations +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__CURVE_FUNC_H +#define __ETL__CURVE_FUNC_H + +/* === H E A D E R S ======================================================= */ + +#include + +/* -- C L A S S E S --------------------------------------------------------- */ + +template +struct affine_combo +{ + T operator()(const T &a,const T &b,const K &t)const + { + return T( (b-a)*t+a ); + } + + T reverse(const T &x, const T &b, const K &t)const + { + return T( (x-t*b)*(static_cast(1)/(static_cast(1)-t)) ); + } +}; + +template +struct distance_func : public std::binary_function +{ + K operator()(const T &a,const T &b)const + { + T delta=b-a; + return static_cast(delta*delta); + } + + K cook(const K &x)const { return x*x; } + K uncook(const K &x)const { return sqrt(x); } + +}; + +/* -- E N D ----------------------------------------------------------------- */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_fastangle.h b/ETL/tags/0.61.06/ETL/_fastangle.h new file mode 100644 index 0000000..78ac67a --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_fastangle.h @@ -0,0 +1,461 @@ +/*! ======================================================================== +** Extended Template and Library +** Fast fastangle Abstraction Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL_FASTANGLE_H +#define __ETL_FASTANGLE_H + +/* === H E A D E R S ======================================================= */ + +#include +#include + +#include "_fastangle_tables.h" + +/* === M A C R O S ========================================================= */ + +#ifndef PI +# define PI (3.1415926535897932384626433832795029L) +#endif + +#define ETL_FASTANGLE_INIT() + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +/*! ======================================================================== +** \class fastangle +** \brief Optimized abstraction of the concept of an angle +** +** A more detailed description needs to be written. +*/ +class fastangle +{ +public: + typedef double value_type; + +protected: + typedef fixed_base unit; + + unit v; //! Stored in rotations + +public: + + /* + ** Arithmetic Operators + */ + + //! fastangle Addition Operator + fastangle + operator+(const fastangle &rhs)const + { + fastangle ret; + ret.v=v+rhs.v; + return ret; + } + + //! fastangle Subtraction Operator + /*! \sa fastangle dist(const fastangle &) */ + fastangle + operator-(const fastangle &rhs)const + { + fastangle ret; + ret.v=v-rhs.v; + return ret; + } + + //! fastangle Scalar Multiplication Operator + /*! This operator will multiply the given + fastangle by the given scalar value. */ + fastangle + operator*(const unit &rhs)const + { + fastangle ret; + ret.v=v*rhs; + return ret; + } + + fastangle + operator/(const unit &rhs)const + { + fastangle ret; + ret.v=v/rhs; + return ret; + } + + const fastangle & + operator+=(const fastangle &rhs) + { + v+=rhs.v; + return *this; + } + + const fastangle & + operator-=(const fastangle &rhs) + { + v-=rhs.v; + return *this; + } + + const fastangle & + operator*=(const unit &rhs) + { + v*=rhs; + return *this; + } + + const fastangle & + operator/=(const unit &rhs) + { + v/=rhs; + return *this; + } + + //! fastangle Negation + fastangle + operator-()const + { + fastangle ret; + ret.v=-v; + return ret; + } + + //! 180 degree rotation operator + /*! Returns the fastangle directly opposite of + the given fastangle, and will yield a result + between 0 and 2PI */ + fastangle + operator~()const + { + fastangle ret; + ret.v=(unit)std::floor(v+0.5f); + return ret; + } + + /*! Returns true if the shortest + fastangle between the left-hand and + right-hand side is clockwise */ + bool + operator<(const fastangle &rhs)const + { return v(const fastangle &rhs)const + { return v>rhs.v; } +// { return dist(rhs).v>(value_type)0.0; } + + /*! Returns true if the shortest + fastangle between the left-hand and + right-hand side is clockwise, + or if the angles are refer to the same + point on the unit circle. */ + bool + operator<=(const fastangle &rhs)const + { return v<=rhs.v; } +// { return dist(rhs).v<=(value_type)0.0; } + + /*! Returns true if the shortest + fastangle between the left-hand and + right-hand side is counter-clockwise, + or if the angles are refer to the same + point on the unit circle. */ + bool + operator>=(const fastangle &rhs)const + { return v>=rhs.v; } +// { return dist(rhs).v>=(value_type)0.0; } + + /*! Returns true if the angles + are refer to the same point + on the unit circle. */ + bool + operator==(const fastangle &rhs)const + { return v==rhs.v; } +// { return dist(rhs).v==(value_type)0.0; } + + /*! Returns false if the angles + are refer to the same point + on the unit circle. */ + bool + operator!=(const fastangle &rhs)const + { return v!=rhs.v; } +// { return dist(rhs).v!=(value_type)0.0; } + + //! fastangle Difference Function + /*! This function will return the + shortest physical distance between + two angles, from -PI/2 to PI/2 + \warning Not yet tested + \sa fastangle operator-(const fastangle &) */ + fastangle + dist(const fastangle &rhs)const + { + fastangle ret; + ret.v=v-rhs.v; + ret.v-=(unit)std::floor(ret.v+0.5f); + return ret; + } + + //! Rotation Modulus + /*! This function will return the + value of the fastangle between 0 and 2PI */ + fastangle + mod()const + { + fastangle ret(*this); + ret.v-=(unit)std::floor(ret.v); + return ret; + } + + static fastangle + zero() + { + fastangle ret; + ret.v=0; + return ret; + } + + bool operator!()const { return v==unit(0); } + + /* + ** Conversion Classes + */ + + class radians; + class degrees; + class rotations; + + /* + ** Trigonometric Classes + */ + + class sin; + class cos; + class tan; + + /* + ** Friend classes + */ + + friend class radians; + friend class degrees; + friend class rotations; + friend class sin; + friend class cos; + friend class tan; + + /* + ** Bleh... + */ + + typedef radians rad; + typedef degrees deg; + typedef rotations rot; + +}; // END of class fastangle + +/*! ======================================================================== +** \class fastangle::radians +** \brief fastangle representation in radians +** +** A more detailed description needs to be written. +*/ +class fastangle::radians : public fastangle +{ +public: + radians(const value_type &x) { v=x/((value_type)PI*2.0f); } + radians(const fastangle &a):fastangle(a) { } + radians mod()const { return fastangle::mod(); } + radians dist(const fastangle &rhs)const { return fastangle::dist(rhs); } + operator value_type()const { return get(); } + value_type get()const { return (value_type)v*(value_type)PI*2.0f; } +}; // END of class fastangle::radians + +/*! ======================================================================== +** \class fastangle::degrees +** \brief fastangle representation in degrees +** +** A more detailed description needs to be written. +*/ +class fastangle::degrees : public fastangle +{ +public: + degrees(const value_type &x) { v=x/360; } + degrees(const fastangle &a):fastangle(a) { } + degrees mod()const { return fastangle::mod(); } + degrees dist(const fastangle &rhs)const { return fastangle::dist(rhs); } + operator value_type()const { return get(); } + value_type get()const { return v*360/*(value_type)(v-::floor(v))*360*/; } +}; // END of class fastangle::degrees + +/*! ======================================================================== +** \class fastangle::rotations +** \brief fastangle representation in rotations +** +** A more detailed description needs to be written. +*/ +class fastangle::rotations : public fastangle +{ +public: + rotations(const value_type &x) { v=x; } + rotations(const fastangle &a):fastangle(a) { } + rotations mod()const { return fastangle::mod(); } + rotations dist(const fastangle &rhs)const { return fastangle::dist(rhs); } + operator value_type()const { return get(); } + value_type get()const { return v; } +}; // END of class fastangle::rotations + +/*! ======================================================================== +** \class fastangle::sin +** \brief fastangle representation as a sine function +** +** A more detailed description needs to be written. +*/ +class fastangle::sin : public fastangle +{ +public: + sin(const value_type &x) { v.data()=_fastangle_asin_table[(int)((x+1)*(value_type)(1<<(ETL_FASTANGLE_LOOKUP_RES-1)))]; } + sin(const fastangle &a):fastangle(a) { } + sin mod()const { return fastangle::mod(); } + sin dist(const fastangle &rhs)const { return fastangle::dist(rhs); } + operator value_type()const { return get(); } + value_type get()const { return (value_type)_fastangle_sin_table[v.data()&( (1<1) + v.data()=(1<<(ETL_FASTANGLE_LOOKUP_RES-2))-_fastangle_atan_table[(int)(((1.0/x)+1)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))]; + else if(x<-1) + v.data()=-(1<<(ETL_FASTANGLE_LOOKUP_RES-1)) + (1<<(ETL_FASTANGLE_LOOKUP_RES-2)) - _fastangle_atan_table[(int)(((1.0/x)+1)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))]; + else + v.data()=_fastangle_atan_table[(int)((x+1)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))]; + } + + tan(const value_type &y,const value_type &x) + { + if(x>=0 && y>=0) // First quadrant + { + if(y>x) + v.data()=(1<<(ETL_FASTANGLE_LOOKUP_RES-2))-_fastangle_atan_table[(int)(((x/y)+1)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))]; + else + v.data()=_fastangle_atan_table[(int)(((y/x)+1)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))]; + } + else if(x>=0 && y<0) // Fourth quadrant + { + if(-y>x) + v.data()=-(1<<(ETL_FASTANGLE_LOOKUP_RES-1)) + (1<<(ETL_FASTANGLE_LOOKUP_RES-2))-_fastangle_atan_table[(int)(((x/y)+1.0)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))]; + else + v.data()=_fastangle_atan_table[(int)(((y/x)+1.0)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))]; + } + else if(x<0 && y>=0) // Second quadrant + { + if(y>-x) + v.data()=(1<<(ETL_FASTANGLE_LOOKUP_RES-2))-_fastangle_atan_table[(int)(((x/y)+1.0)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))]; + else + v.data()=_fastangle_atan_table[(int)(((y/x)+1.0)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))]+(1<<(ETL_FASTANGLE_LOOKUP_RES-1)); + } + else if(x<0 && y<0) // Third Quadrant + { + if(-y>-x) + v.data()=(1<<(ETL_FASTANGLE_LOOKUP_RES-2))-_fastangle_atan_table[(int)(((x/y)+1.0)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))] - (1<<(ETL_FASTANGLE_LOOKUP_RES-1)); + else + v.data()=_fastangle_atan_table[(int)(((y/x)+1.0)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))]-(1<<(ETL_FASTANGLE_LOOKUP_RES-1)); + } + else v.data()=0; + } + tan(const fastangle &a):fastangle(a) { } + tan mod()const { return fastangle::mod(); } + tan dist(const fastangle &rhs)const { return fastangle::dist(rhs); } + operator value_type()const { return get(); } + value_type get()const { return (value_type)_fastangle_tan_table[v.data()&( (1< +struct affine_combo +{ + etl::fastangle operator()(const etl::fastangle &a,const etl::fastangle &b,const float &t)const + { + return b.dist(a)*t+a; + } + + etl::fastangle reverse(const etl::fastangle &x, const etl::fastangle &b, const float &t)const + { + return x.dist(b*t)*((float)1/((float)1-t)); + } +}; + +template <> +struct distance_func : public std::binary_function +{ + etl::fastangle operator()(const etl::fastangle &a,const etl::fastangle &b)const + { + etl::fastangle delta=b.dist(a); + if(delta + +/* === M A C R O S ========================================================= */ + +// the "+0.5" code was commented out - maybe to make thing run faster? +// it can be re-enabled by uncommenting this next line: +// #define ROUND_TO_NEAREST_INTEGER + +#ifndef ETL_FIXED_TYPE +# define ETL_FIXED_TYPE int +#endif + +#ifndef ETL_FIXED_BITS +#define ETL_FIXED_BITS 12 +#endif + +#ifndef ETL_FIXED_EPSILON +#define ETL_FIXED_EPSILON _EPSILON() +#endif + +#ifdef __GNUC___ +#define ETL_ATTRIB_CONST __attribute__ ((const)) +#define ETL_ATTRIB_PURE __attribute__ ((pure)) +#define ETL_ATTRIB_INLINE __attribute__ ((always_inline)) +#else +#define ETL_ATTRIB_CONST +#define ETL_ATTRIB_PURE +#define ETL_ATTRIB_INLINE +#endif + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +// Forward declarations +template class fixed_base; +//template<> class fixed_base; + +_ETL_END_NAMESPACE + +_STD_BEGIN_NAMESPACE +template _ETL::fixed_base abs(const _ETL::fixed_base&); +template _ETL::fixed_base cos(const _ETL::fixed_base&); +template _ETL::fixed_base cosh(const _ETL::fixed_base&); +template _ETL::fixed_base exp(const _ETL::fixed_base&); +template _ETL::fixed_base log(const _ETL::fixed_base&); +template _ETL::fixed_base log10(const _ETL::fixed_base&); +template _ETL::fixed_base pow(const _ETL::fixed_base&, int); +template _ETL::fixed_base pow(const _ETL::fixed_base&, const T&); +template _ETL::fixed_base pow(const _ETL::fixed_base&, + const _ETL::fixed_base&); +template _ETL::fixed_base pow(const _ETL::fixed_base&, const _ETL::fixed_base&); +template _ETL::fixed_base sin(const _ETL::fixed_base&); +template _ETL::fixed_base sinh(const _ETL::fixed_base&); +template _ETL::fixed_base sqrt(const _ETL::fixed_base&); +template _ETL::fixed_base tan(const _ETL::fixed_base&); +template _ETL::fixed_base tanh(const _ETL::fixed_base&); +_STD_END_NAMESPACE +_ETL_BEGIN_NAMESPACE + +/*! ======================================================================== +** \class fixed_base +** \brief Fixed-point template base class +** +** A more detailed description needs to be written. +*/ +template +class fixed_base +{ +public: + typedef T value_type; +private: + T _data; + + typedef fixed_base _fixed; + typedef fixed_base self_type; + + inline static bool _TYPE_SMALLER_THAN_INT() ETL_ATTRIB_CONST ETL_ATTRIB_INLINE; + inline static bool _USING_ALL_BITS() ETL_ATTRIB_CONST ETL_ATTRIB_INLINE; + inline static value_type _ONE() ETL_ATTRIB_CONST ETL_ATTRIB_INLINE; + inline static value_type _F_MASK() ETL_ATTRIB_CONST ETL_ATTRIB_INLINE; + inline static float _EPSILON() ETL_ATTRIB_CONST ETL_ATTRIB_INLINE; + + class raw { }; +public: + fixed_base()ETL_ATTRIB_INLINE; + fixed_base(const float &f)ETL_ATTRIB_INLINE; + fixed_base(const double &f)ETL_ATTRIB_INLINE; + fixed_base(const long double &f)ETL_ATTRIB_INLINE; + fixed_base(const int &i)ETL_ATTRIB_INLINE; + fixed_base(const int &n,const int &d)ETL_ATTRIB_INLINE; //!< Fraction constructor + fixed_base(const _fixed &x)ETL_ATTRIB_INLINE; + fixed_base(value_type x,raw)ETL_ATTRIB_INLINE; + + T &data() ETL_ATTRIB_PURE ETL_ATTRIB_INLINE; + const T &data()const ETL_ATTRIB_PURE ETL_ATTRIB_INLINE; + + const _fixed& operator+=(const _fixed &rhs) ETL_ATTRIB_INLINE; + const _fixed& operator-=(const _fixed &rhs) ETL_ATTRIB_INLINE; + template const _fixed& operator*=(const U &rhs) ETL_ATTRIB_INLINE; + template const _fixed& operator/=(const U &rhs) ETL_ATTRIB_INLINE; + const _fixed& operator*=(const _fixed &rhs) ETL_ATTRIB_INLINE; + const _fixed& operator/=(const _fixed &rhs) ETL_ATTRIB_INLINE; + const _fixed& operator*=(const int &rhs) ETL_ATTRIB_INLINE; + const _fixed& operator/=(const int &rhs) ETL_ATTRIB_INLINE; + + + template _fixed operator+(const U &rhs)const ETL_ATTRIB_INLINE; + template _fixed operator-(const U &rhs)const ETL_ATTRIB_INLINE; + template _fixed operator*(const U &rhs)const ETL_ATTRIB_INLINE; + template _fixed operator/(const U &rhs)const ETL_ATTRIB_INLINE; + _fixed operator+(const _fixed &rhs)const ETL_ATTRIB_INLINE; + _fixed operator-(const _fixed &rhs)const ETL_ATTRIB_INLINE; + _fixed operator*(const _fixed &rhs)const ETL_ATTRIB_INLINE; + _fixed operator/(const _fixed &rhs)const ETL_ATTRIB_INLINE; + _fixed operator*(const int &rhs)const ETL_ATTRIB_INLINE; + _fixed operator/(const int &rhs)const ETL_ATTRIB_INLINE; + _fixed operator*(const float &rhs)const ETL_ATTRIB_INLINE; + _fixed operator*(const double &rhs)const ETL_ATTRIB_INLINE; + + // Negation Operator + _fixed operator-()const ETL_ATTRIB_INLINE; + + // Casting Operators + inline operator float()const ETL_ATTRIB_INLINE; + inline operator double()const ETL_ATTRIB_INLINE; + inline operator long double()const ETL_ATTRIB_INLINE; + inline operator int()const ETL_ATTRIB_INLINE; + inline operator bool()const ETL_ATTRIB_INLINE; + + _fixed floor()const; + _fixed ceil()const; + _fixed round()const; + + bool operator==(const _fixed &rhs)const { return data()==rhs.data(); } + bool operator!=(const _fixed &rhs)const { return data()!=rhs.data(); } + bool operator<(const _fixed &rhs)const { return data()(const _fixed &rhs)const { return data()>rhs.data(); } + bool operator<=(const _fixed &rhs)const { return data()<=rhs.data(); } + bool operator>=(const _fixed &rhs)const { return data()>=rhs.data(); } +}; + + +template +fixed_base::fixed_base() +{} + +template +fixed_base::fixed_base(const _fixed &x):_data(x._data) +{} + +template +fixed_base::fixed_base(const float &f):_data(static_cast(f*_ONE() +#ifdef ROUND_TO_NEAREST_INTEGER + +0.5f +#endif + )) {} + +template +fixed_base::fixed_base(const double &f):_data(static_cast(f*_ONE() +#ifdef ROUND_TO_NEAREST_INTEGER + +0.5 +#endif + )) {} + +template +fixed_base::fixed_base(const long double &f):_data(static_cast(f*_ONE() +#ifdef ROUND_TO_NEAREST_INTEGER + +0.5 +#endif + )) {} + +template +fixed_base::fixed_base(const int &i):_data(i< +fixed_base::fixed_base(value_type x,raw):_data(x) { } + +template +fixed_base::fixed_base(const int &n,const int &d):_data((n< inline bool +fixed_base::_TYPE_SMALLER_THAN_INT() +{ + return sizeof(T) inline bool +fixed_base::_USING_ALL_BITS() +{ + return sizeof(T)*8==FIXED_BITS; +} + +template inline T +fixed_base::_ONE() +{ + return static_cast((_USING_ALL_BITS()?~T(0):1< inline T +fixed_base::_F_MASK() +{ + return static_cast(_USING_ALL_BITS()?~T(0):_ONE()-1); +} + +template inline float +fixed_base::_EPSILON() +{ + return 1.0f/((float)_ONE()*2); +} + + +template T & +fixed_base::data() +{ + return _data; +} + +template const T & +fixed_base::data()const +{ + return _data; +} + +//! fixed+=fixed +template const fixed_base & +fixed_base::operator+=(const _fixed &rhs) +{ + _data+=rhs._data; + return *this; +} + +//! fixed-=fixed +template const fixed_base & +fixed_base::operator-=(const _fixed &rhs) +{ + _data-=rhs._data; + return *this; +} + +//! fixed*=fixed +template const fixed_base & +fixed_base::operator*=(const _fixed &rhs) +{ + if(_TYPE_SMALLER_THAN_INT()) + _data=static_cast((int)_data*(int)rhs._data>>FIXED_BITS); + else + { + _data*=rhs._data; + _data>>=FIXED_BITS; + } + + return *this; +} + +//! fixed/=fixed +template const fixed_base & +fixed_base::operator/=(const _fixed &rhs) +{ + if(_TYPE_SMALLER_THAN_INT()) + _data=static_cast((int)_data/(int)rhs._data< template const fixed_base & +fixed_base::operator*=(const U &rhs) +{ + return operator*=(fixed_base(rhs)); +} + +template template const fixed_base & +fixed_base::operator/=(const U &rhs) +{ + return operator/=(fixed_base(rhs)); +} + +//! fixed*=int +template const fixed_base & +fixed_base::operator*=(const int &rhs) +{ + _data*=rhs; return *this; +} + +//! fixed/=int +template const fixed_base & +fixed_base::operator/=(const int &rhs) +{ + _data/=rhs; return *this; +} + + + + + + + +//! fixed + fixed +template fixed_base +fixed_base::operator+(const _fixed &rhs)const +{ + _fixed ret; + ret._data=_data+rhs._data; + return ret; +} + +//! fixed - fixed +template fixed_base +fixed_base::operator-(const _fixed &rhs)const +{ + _fixed ret; + ret._data=_data-rhs._data; + return ret; +} + +//! fixed * fixed +template fixed_base +fixed_base::operator*(const _fixed &rhs)const +{ + _fixed ret; + ret._data=((_data*rhs._data)>>FIXED_BITS); + return ret; + //return reinterpret_cast<_fixed>((_data*rhs._data)>>FIXED_BITS); +} + +//! fixed / fixed +template fixed_base +fixed_base::operator/(const _fixed &rhs)const +{ + _fixed ret; + ret._data=((_data/rhs._data)<((_data/rhs._data)< template fixed_base +fixed_base::operator+(const U &rhs) const +{ + return operator+(fixed_base(rhs)); +} + +//! fixed - ... +template template fixed_base +fixed_base::operator-(const U &rhs) const +{ + return operator-(fixed_base(rhs)); +} + +//! fixed * ... +template template fixed_base +fixed_base::operator*(const U &rhs) const +{ + return operator*(fixed_base(rhs)); +} + +//! fixed / ... +template template fixed_base +fixed_base::operator/(const U &rhs) const +{ + return operator/(fixed_base(rhs)); +} + +//! fixed * int +template fixed_base +fixed_base::operator*(const int &rhs)const +{ + _fixed ret; + ret._data=_data*rhs; + return ret; + //return reinterpret_cast<_fixed>(_data*rhs); +} + +//! fixed * float +template fixed_base +fixed_base::operator*(const float &rhs)const +{ + return (*this)*_fixed(rhs); +} + +//! fixed * double +template fixed_base +fixed_base::operator*(const double &rhs)const +{ + return (*this)*_fixed(rhs); +} + + +//! fixed / int +template fixed_base +fixed_base::operator/(const int &rhs)const +{ + _fixed ret; + ret._data=_data/rhs; + return ret; + //return reinterpret_cast<_fixed>(_data/rhs); +} + +//! float * fixed +template fixed_base +operator*(const float& lhs, const fixed_base &rhs) +{ + return rhs*lhs; +} + +//! double * fixed +template fixed_base +operator*(const double& lhs, const fixed_base &rhs) +{ + return rhs*lhs; +} + + + + + + +// Negation Operator +template fixed_base +fixed_base::operator-()const +{ + _fixed ret; ret._data=-_data; return ret; +} + +// Casting Operators +template +fixed_base::operator float()const +{ + return static_cast(_data)/static_cast(_ONE()); +} + +template +fixed_base::operator double()const +{ + return static_cast(_data)/static_cast(_ONE()); +} + +template +fixed_base::operator long double()const +{ + return static_cast(_data)/static_cast(_ONE()); +} + +template +fixed_base::operator int()const +{ + return static_cast(_data>>FIXED_BITS); +} + +template +fixed_base::operator bool()const +{ + return static_cast(_data); +} + + +template fixed_base +fixed_base::floor()const +{ + _fixed ret(*this); + ret._data&=~_F_MASK(); + return ret; +} + +template fixed_base +fixed_base::ceil()const +{ + _fixed ret(*this); + if(ret._data&_F_MASK()) + ret._data=(ret._data&~_F_MASK()) + _ONE(); + else + ret._data&=~_F_MASK(); + return ret; +} + +template fixed_base +fixed_base::round()const +{ + _fixed ret(*this); + ret._data+=_ONE()>>1; + ret._data&=~_F_MASK(); + return ret; +} + + + + + + + + + + + + + + + + + + + + + + + + + + +typedef fixed_base fixed; + +_ETL_END_NAMESPACE + +_STD_BEGIN_NAMESPACE + +template +inline _ETL::fixed_base +ceil(const _ETL::fixed_base &rhs) +{ return rhs.ceil(); } + +template +_ETL::fixed_base +floor(const _ETL::fixed_base &rhs) +{ return rhs.floor(); } + +template +_ETL::fixed_base +round(const _ETL::fixed_base &rhs) +{ return rhs.round(); } + +template +_ETL::fixed_base +abs(const _ETL::fixed_base &rhs) +{ return rhs<_ETL::fixed_base(0)?-rhs:rhs; } + +_STD_END_NAMESPACE + +/* +template bool +operator==(const _ETL::fixed_base& lhs, const _ETL::fixed_base& rhs) +{ return lhs.data()==rhs.data(); } + +template bool +operator!=(const _ETL::fixed_base& lhs, const _ETL::fixed_base& rhs) +{ return lhs.data()!=rhs.data(); } + +template bool +operator>(const _ETL::fixed_base& lhs, const _ETL::fixed_base& rhs) +{ return lhs.data()>rhs.data(); } + +template bool +operator<(const _ETL::fixed_base& lhs, const _ETL::fixed_base& rhs) +{ return lhs.data() bool +operator>=(const _ETL::fixed_base& lhs, const _ETL::fixed_base& rhs) +{ return lhs.data()>=rhs.data(); } + +template bool +operator<=(const _ETL::fixed_base& lhs, const _ETL::fixed_base& rhs) +{ return lhs.data()<=rhs.data(); } +*/ + + +#if defined(__GNUC__) && __GNUC__ == 3 +template U +operator*(const U &a,const _ETL::fixed_base &b) + { return a*static_cast(b); } + +template U +operator/(const U &a,const _ETL::fixed_base &b) + { return a/static_cast(b); } + +template U +operator+(const U &a,const _ETL::fixed_base &b) + { return a+static_cast(b); } + +template U +operator-(const U &a,const _ETL::fixed_base &b) + { return a-static_cast(b); } + + +/* +inline const float & +operator*=(float &a,const _ETL::fixed &b) + { a*=(float)b; return a; } + +inline const float & +operator/=(float &a,const _ETL::fixed &b) + { a/=(float)b; return a; } + +inline const float & +operator-=(float &a,const _ETL::fixed &b) + { a-=(float)b; return a; } + +inline const float & +operator+=(float &a,const _ETL::fixed &b) + { a+=(float)b; return a; } +*/ +#endif + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_gaussian.h b/ETL/tags/0.61.06/ETL/_gaussian.h new file mode 100644 index 0000000..6ad9882 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_gaussian.h @@ -0,0 +1,315 @@ +/*! ======================================================================== +** Extended Template Library +** Gaussian Blur Template Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL_GAUSSIAN_H +#define __ETL_GAUSSIAN_H + +/* === H E A D E R S ======================================================= */ + +#include // for memset() +#include + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +template void +gaussian_blur_5x5_(T pen,int w, int h, +typename T::pointer SC0, +typename T::pointer SC1, +typename T::pointer SC2, +typename T::pointer SC3) +{ + int x,y; + typename T::value_type Tmp1,Tmp2,SR0,SR1,SR2,SR3; + + //typename T::iterator_x iter; + + // Setup the row buffers + for(x=0;x=h) + {yadj=(h-y)-1; SR0=pen.y()[yadj]*1.35;} + else + {yadj=0; SR0=pen.get_value()*1.35; } + + SR1=SR2=SR3=typename T::value_type(); + for(x=0;x=w) + Tmp1=pen[yadj][(w-x)-1]; + else + Tmp1=*pen[yadj]; + + Tmp2=SR0+Tmp1; + SR0=Tmp1; + Tmp1=SR1+Tmp2; + SR1=Tmp2; + Tmp2=SR2+Tmp1; + SR2=Tmp1; + Tmp1=SR3+Tmp2; + SR3=Tmp2; + + // Column Machine + Tmp2=SC0[x]+Tmp1; + SC0[x]=Tmp1; + Tmp1=SC1[x]+Tmp2; + SC1[x]=Tmp2; + Tmp2=SC2[x]+Tmp1; + SC2[x]=Tmp1; + if(y>1&&x>1) + pen[-2][-2]=(SC3[x]+Tmp2)/256; + SC3[x]=Tmp2; + } + pen.dec_x(x); + } + +} + +template void +gaussian_blur_5x5(T pen, int w, int h) +{ + typename T::pointer SC0=new typename T::value_type[w+2]; + typename T::pointer SC1=new typename T::value_type[w+2]; + typename T::pointer SC2=new typename T::value_type[w+2]; + typename T::pointer SC3=new typename T::value_type[w+2]; + + gaussian_blur_5x5_(pen,w,h,SC0,SC1,SC2,SC3); + + delete [] SC0; + delete [] SC1; + delete [] SC2; + delete [] SC3; +} + +template void +gaussian_blur_5x5(T begin, T end) +{ + typename T::difference_type size(end-begin); + + typename T::pointer SC0=new typename T::value_type[size.x+2]; + typename T::pointer SC1=new typename T::value_type[size.x+2]; + typename T::pointer SC2=new typename T::value_type[size.x+2]; + typename T::pointer SC3=new typename T::value_type[size.x+2]; + + gaussian_blur_5x5_(begin,size.x,size.y,SC0,SC1,SC2,SC3); + + delete [] SC0; + delete [] SC1; + delete [] SC2; + delete [] SC3; +} + +template void +gaussian_blur_3x3(T pen,int w, int h) +{ + int x,y; + typename T::value_type Tmp1,Tmp2,SR0,SR1; + +// typename T::iterator_x iter; + + typename T::pointer SC0=new typename T::value_type[w+1]; + typename T::pointer SC1=new typename T::value_type[w+1]; + + // Setup the row buffers + for(x=0;x=h) + {yadj=-1; SR1=SR0=pen.y()[yadj];} + else + {yadj=0; SR1=SR0=pen.get_value(); } + + for(x=0;x=w) + Tmp1=pen[yadj][(w-x)-2]; + else + Tmp1=*pen[yadj]; + + Tmp2=SR0+Tmp1; + SR0=Tmp1; + Tmp1=SR1+Tmp2; + SR1=Tmp2; + + Tmp2=SC0[x]+Tmp1; + SC0[x]=Tmp1; + if(y&&x) + pen[-1][-1]=(SC1[x]+Tmp2)/16; + SC1[x]=Tmp2; + } + pen.dec_x(x); + } + + delete [] SC0; + delete [] SC1; +} + +//! 2D 3x3 pixel gaussian blur +template void +gaussian_blur_3x3(_PEN begin, _PEN end) +{ + typename _PEN::difference_type size(end-begin); + gaussian_blur_3x3(begin,size.x,size.y); +} + +//! 1D 3 pixel gaussian blur +template void +gaussian_blur_3(I begin, I end, bool endpts = true) +{ +// typedef typename I _itertype; +// int i; + typename std::iterator_traits::value_type Tmp1,Tmp2,SR0,SR1; + + SR0=SR1=*begin; + I iter,prev=begin; + for(iter=begin;iter!=end;prev=iter++) + { + Tmp1=*iter; + Tmp2=SR0+Tmp1; + SR0=Tmp1; + Tmp1=SR1+Tmp2; + SR1=Tmp2; + if(iter!=begin && ( endpts || (prev != begin) )) + *prev=(Tmp1)/4; + } + + if(endpts) + { + Tmp1=*prev; + Tmp2=SR0+Tmp1; + SR0=Tmp1; + Tmp1=SR1+Tmp2; + SR1=Tmp2; + *prev=(Tmp1)/4; + } +} + +//! 2D 3x1 pixel gaussian blur +template void +gaussian_blur_3x1(_PEN begin, _PEN end) +{ + typename _PEN::difference_type size=end-begin; + for(;size.y>0;size.y--, begin.inc_y()) + gaussian_blur_3(begin.x(),begin.x()+size.x); +} + +//! 2D 1x3 pixel gaussian blur +template void +gaussian_blur_1x3(_PEN begin, _PEN end) +{ + typename _PEN::difference_type size=end-begin; + for(;size.x>0;size.x--,begin.inc_x()) + gaussian_blur_3(begin.y(),begin.y()+size.y); +} + +template void +gaussian_blur(T pen, int w, int h, int blur_x, int blur_y) +{ + typename T::pointer SC0=new typename T::value_type[w+2]; + typename T::pointer SC1=new typename T::value_type[w+2]; + typename T::pointer SC2=new typename T::value_type[w+2]; + typename T::pointer SC3=new typename T::value_type[w+2]; + + blur_x--; + blur_y--; + + while(blur_x&&blur_y) + { + if(blur_x>=4 && blur_y>=4) + { + gaussian_blur_5x5_(pen,w,h,SC0,SC1,SC2,SC3); + blur_x-=4,blur_y-=4; + } + else if(blur_x>=2 && blur_y>=2) + { + gaussian_blur_3x3(pen,w,h); + blur_x-=2,blur_y-=2; + } + else + blur_x--,blur_y--; + } + while(blur_x) + { + if(blur_x>=2) + { + gaussian_blur_3x1(pen,T(pen).move(w,h)); + blur_x-=2; + } + else + blur_x--; + } + while(blur_y) + { + if(blur_y>=2) + { + gaussian_blur_1x3(pen,T(pen).move(w,h)); + blur_y-=2; + } + else + blur_y--; + } + + delete [] SC0; + delete [] SC1; + delete [] SC2; + delete [] SC3; +} + +template void +gaussian_blur(T begin, T end,int w, int h) +{ + typename T::difference_type size(end-begin); + gaussian_blur(begin,size.x,size.y,w,h); +} + +template void +gaussian_blur(T begin, T end,int w) +{ + typename T::difference_type size(end-begin); + gaussian_blur(begin,size.x,size.y,w,w); +} + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_handle.h b/ETL/tags/0.61.06/ETL/_handle.h new file mode 100644 index 0000000..0137f8f --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_handle.h @@ -0,0 +1,826 @@ +/* === E T L =============================================================== */ +/*! \file _handle.h +** $Id$ +** \brief Template Object Handle Implementation +** \internal +** +** \legal +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** Copyright (c) 2007, 2008 Chris Moore +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** \endlegal +** +** \note +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +*/ +/* ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__HANDLE_H +#define __ETL__HANDLE_H + +/* === H E A D E R S ======================================================= */ + +#include + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +#define ETL_SELF_DELETING_SHARED_OBJECT + +/* === C L A S S E S & S T R U C T S ======================================= */ + +#ifdef NDEBUG +#define assert_cast static_cast +#else +#define assert_cast dynamic_cast +#endif + + +_ETL_BEGIN_NAMESPACE + +// Forward Declarations +template class handle; +template class loose_handle; +template class rhandle; + + +// ======================================================================== +/*! \class shared_object _handle.h ETL/handle +** \brief Shared Object Base Class +** \see handle, loose_handle +** \writeme +*/ +class shared_object +{ +private: + mutable int refcount; +#ifdef ETL_LOCK_REFCOUNTS + mutable etl::mutex mtx; +#endif + +protected: + shared_object():refcount(0) { } + +#ifdef ETL_SELF_DELETING_SHARED_OBJECT + virtual ~shared_object() { } +#else + ~shared_object() { } +#endif + +public: + void ref()const + { +#ifdef ETL_LOCK_REFCOUNTS + etl::mutex::lock lock(mtx); +#endif + assert(refcount>=0); + refcount++; + } + + //! Returns \c false if object needs to be deleted + bool unref()const + { + bool ret = true; + { +#ifdef ETL_LOCK_REFCOUNTS + etl::mutex::lock lock(mtx); +#endif + assert(refcount>0); + + refcount--; + + if(refcount==0) { + ret = false; +#ifdef ETL_SELF_DELETING_SHARED_OBJECT + refcount=-666; +#endif + } + } + +#ifdef ETL_SELF_DELETING_SHARED_OBJECT + if (!ret) + delete this; +#endif + return ret; + } + + int count()const { return refcount; } + +}; // END of class shared_object + +// ======================================================================== +/*! \class virtual_shared_object _handle.h ETL/handle +** \brief Virtual Shared Object Base Class +** \see handle, loose_handle +** \writeme +*/ +class virtual_shared_object +{ +protected: + virtual_shared_object() { } +public: + virtual ~virtual_shared_object()=0; + virtual void ref()const=0; + virtual bool unref()const=0; + virtual int count()const=0; + virtual virtual_shared_object *clone()=0; +}; // END of class virtual_shared_object + +// ======================================================================== +/*! \class handle _handle.h ETL/handle +** \brief Object Handle +** \see shared_object, loose_handle +** \writeme +*/ +template +class handle +{ +public: + + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T* pointer; + typedef const T* const_pointer; + typedef int count_type; + typedef int size_type; + +protected: +#ifdef _DEBUG +public: +#endif + value_type *obj; //!< Pointer to object + +public: + + //! Default constructor - empty handle + handle():obj(NULL) {} + + //! Constructor that constructs from a pointer to new object + handle(pointer x):obj(x) + { + if(obj) + obj->ref(); + } + + //! Default copy constructor + handle(const handle &x):obj(x.get()) + { + if(obj) + obj->ref(); + } + + //! Handle is released on deletion + ~handle() { detach(); } + + //! Template Assignment operator + /*! \note This class may not be necessary, and may be removed + ** at some point in the future. + */ + /* + template handle & + operator=(const handle &x) + { + if(x.get()==obj) + return *this; + + detach(); + + obj=static_cast(x.get()); + if(obj)obj->ref(); + return *this; + } + */ + + //! Assignment operator + handle & + operator=(const handle &x) + { + if(x.get()==obj) + return *this; + + detach(); + + obj=x.get(); + if(obj)obj->ref(); + return *this; + } + + //! Swaps the values of two handles without reference counts + handle & + swap(handle &x) + { + pointer ptr=x.obj; + x.obj=x.get(); + obj=ptr; + return *this; + } + + //! Handle detach procedure + /*! unref()'s the object and sets the internal object pointer to \c NULL */ + void + detach() + { + pointer xobj(obj); + obj=0; +#ifdef ETL_SELF_DELETING_SHARED_OBJECT + if(xobj) + xobj->unref(); +#else + if(xobj && !xobj->unref()) + delete xobj; +#endif + } + + // This will be reintroduced with a new function + //void release() { detach(); } + + void reset() { detach(); } + + bool empty()const { return obj==0; } + + //! Creates a new instance of a T object and puts it in the handle. + /*! Uses the default constructor */ + void spawn() { operator=(handle(new T())); } + + handle clone()const { assert(obj); return static_cast(obj->clone()); } + + //! Returns a constant handle to our object + handle constant()const { assert(obj); return *this; } + + //! Returns number of instances + count_type + count()const + { return obj?obj->count():0; } + + //! Returns true if there is only one instance of the object + bool + unique()const + { assert(obj); return count()==1; } + + reference + operator*()const + { assert(obj); return *obj; } + + pointer + operator->()const + { assert(obj); return obj; } + + //! More explicit bool cast + operator bool()const + { return obj!=NULL; } + + operator handle()const + { return handle(static_cast(obj)); } + + //! static_cast\<\> wrapper + template static handle cast_static (const handle &x) { return handle(static_cast (x.get())); } + //! dynamic_cast\<\> wrapper + template static handle cast_dynamic (const handle &x) { return handle(dynamic_cast (x.get())); } + //! const_cast\<\> wrapper + template static handle cast_const (const handle &x) { return handle(const_cast (x.get())); } + //! reinterpret_cast\<\> wrapper + template static handle cast_reinterpret(const handle &x) { return handle(reinterpret_cast(x.get())); } + + template static handle cast_static (const loose_handle &x); + template static handle cast_dynamic (const loose_handle &x); + template static handle cast_const (const loose_handle &x); + template static handle cast_reinterpret(const loose_handle &x); + + template static handle cast_static (const rhandle &x); + template static handle cast_dynamic (const rhandle &x); + template static handle cast_const (const rhandle &x); + template static handle cast_reinterpret(const rhandle &x); + + template static handle cast_static (U* x); + template static handle cast_dynamic (U* x); + template static handle cast_const (U* x); + template static handle cast_reinterpret(U* x); + + //! Returns pointer to the object that is being wrapped + pointer get()const { return obj; } + + bool + operator!()const + { return !obj; } + + //! static_cast<> overload -- Useful for implicit casts + template + operator handle()const + { return handle(static_cast(obj)); } +}; // END of template class handle + +// ======================================================================== +/*! \class rshared_object _handle.h ETL/handle +** \brief Replaceable Shared Object Base Class +** \see rhandle +** \writeme +*/ +class rshared_object : public shared_object +{ +private: + mutable int rrefcount; + +public: + void *front_; + void *back_; + +protected: + rshared_object():rrefcount(0),front_(0),back_(0) { } + +public: + void rref()const + { rrefcount++; } + + void runref()const + { + assert(rrefcount>0); + rrefcount--; + } + + int rcount()const + { return rrefcount; } +}; // END of class rshared_object + +// ======================================================================== +/*! \class rhandle _handle.h ETL/handle +** \brief Replaceable Object Handle +** \see rshared_object, handle, loose_handle +** \writeme +*/ +template +class rhandle : public handle +{ + friend class rshared_object; +public: + + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T* pointer; + typedef const T* const_pointer; + typedef int count_type; + typedef int size_type; + + + using handle::count; + using handle::unique; + using handle::operator bool; + using handle::get; + using handle::operator*; + using handle::operator->; + + /* + operator const handle&()const + { return *this; } + */ + +private: + using handle::obj; + + rhandle *prev_; + rhandle *next_; + + void add_to_rlist() + { +// value_type*& obj(handle::obj); // Required to keep gcc 3.4.2 from barfing + + assert(obj); + obj->rref(); + + // If this is the first reversible handle + if(!obj->front_) + { + obj->front_=obj->back_=this; + prev_=next_=0; + return; + } + + prev_=reinterpret_cast*>(obj->back_); + next_=0; + prev_->next_=this; + obj->back_=this; + } + + void del_from_rlist() + { +// value_type*& obj(handle::obj); // Required to keep gcc 3.4.2 from barfing + assert(obj); + obj->runref(); + + // If this is the last reversible handle + if(obj->front_==obj->back_) + { + obj->front_=obj->back_=0; + prev_=next_=0; + return; + } + + if(!prev_) + obj->front_=(void*)next_; + else + prev_->next_=next_; + + if(!next_) + obj->back_=(void*)prev_; + else + next_->prev_=prev_; + } + +public: + + //! Default constructor - empty handle + rhandle() {} + + //! Constructor that constructs from a pointer to new object + rhandle(pointer x):handle(x) + { +// value_type*& obj(handle::obj); // Required to keep gcc 3.4.2 from barfing + if(obj)add_to_rlist(); + } + + rhandle(const handle &x):handle(x) + { +// value_type*& obj(handle::obj); // Required to keep gcc 3.4.2 from barfing + if(obj)add_to_rlist(); + } + + //! Default copy constructor + rhandle(const rhandle &x):handle(x) + { +// value_type*& obj(handle::obj); // Required to keep gcc 3.4.2 from barfing + if(obj)add_to_rlist(); + } + + //! Handle is released on deletion + ~rhandle() { detach(); } + + //! Template Assignment operator + /*! \note This class may not be necessary, and may be removed + ** at some point in the future. + */ + /* + template const handle & + operator=(const handle &x) + { + if(x.get()==obj) + return *this; + + detach(); + + obj=static_cast(x.get()); + if(obj) + { + obj->ref(); + add_to_rlist(); + } + return *this; + } + */ + + //! Assignment operator + rhandle & + operator=(const rhandle &x) + { +// value_type*& obj(handle::obj); // Required to keep gcc 3.4.2 from barfing + if(x.get()==obj) + return *this; + + detach(); + + obj=x.get(); + if(obj) + { + obj->ref(); + add_to_rlist(); + } + return *this; + } + + rhandle& + operator=(const handle &x) + { +// value_type*& obj(handle::obj); // Required to keep gcc 3.4.2 from barfing + if(x.get()==obj) + return *this; + + detach(); + + obj=x.get(); + if(obj) + { + obj->ref(); + add_to_rlist(); + } + return *this; + } + + rhandle& + operator=(value_type* x) + { +// value_type*& obj(handle::obj); // Required to keep gcc 3.4.2 from barfing + if(x==obj) + return *this; + + detach(); + + obj=x; + if(obj) + { + obj->ref(); + add_to_rlist(); + } + return *this; + } + + //! Handle release procedure + /*! unref()'s the object and sets the internal object pointer to \c NULL */ + void + detach() + { +// value_type*& obj(handle::obj); // Required to keep gcc 3.4.2 from barfing + if(obj)del_from_rlist(); + handle::detach(); + obj=0; + } + + // This will be reintroduced with a new function + //void release() { detach(); } + + void reset() { detach(); } + + //! Creates a new instance of a T object and puts it in the handle. + /*! Uses the default constructor */ + void spawn() { operator=(handle(new T())); } + + //! Returns number of reversible instances + count_type + rcount()const + { +// value_type*const& obj(handle::obj); // Required to keep gcc 3.4.2 from barfing + return obj?obj->rcount():0; + } + + //! Returns true if there is only one instance of the object + bool + runique()const + { +// value_type*& obj(handle::obj); // Required to keep gcc 3.4.2 from barfing + assert(obj); return obj->front_==obj->back_; + } + + //! \writeme + int replace(const handle &x) + { +// value_type*& obj(handle::obj); // Required to keep gcc 3.4.2 from barfing + assert(obj); + assert(x.get()!=obj); + + if(x.get()==obj) + return 0; + + rhandle *iter; + rhandle *next; + + iter=reinterpret_cast*>(obj->front_); + + assert(iter); + + next=iter->next_; + + int i=0; + #ifndef NDEBUG + pointer obj_=obj; + #endif + + for(;iter;iter=next,next=iter?iter->next_:0,i++) + { + assert(iter->get()==obj_); + (*iter)=x; + } + + assert(obj==x.get()); + + return i; + } + + //! Swaps the values of two handles without reference counts + /*! \warning not yet implemented. \writeme */ + handle & + swap(handle &x); + /* + { + assert(0); + pointer ptr=x.obj; + x.obj=x.get(); + obj=ptr; + return *this; + } + */ +}; // END of template class rhandle + + +// ======================================================================== +/*! \class loose_handle _handle.h ETL/handle +** \brief Loose Object Handle +** \see shared_object, handle +** \writeme +*/ +template +class loose_handle +{ +public: + + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T* pointer; + typedef const T* const_pointer; + typedef int count_type; + typedef int size_type; + +protected: +#ifdef _DEBUG +public: +#endif + value_type *obj; //!< Pointer to object + +public: + + //! Default constructor - empty handle + loose_handle():obj(0) {} + + //! Constructor that constructs from a pointer to new object + loose_handle(pointer x):obj(x) { } + + //! Default copy constructor + loose_handle(const loose_handle &x):obj(x.get()) { } + + loose_handle(const handle &x):obj(x.get()) { } + + template const loose_handle & + operator=(const handle &x) + { + if(x.get()==obj) + return *this; + + obj=static_cast(x.get()); + return *this; + } + + template const loose_handle & + operator=(const loose_handle &x) + { + if(x.get()==obj) + return *this; + + obj=static_cast(x.get()); + return *this; + } + + //! Assignment operator + const loose_handle & + operator=(const loose_handle &x) + { + if(x.get()==obj) + return *this; + + obj=x.get(); + return *this; + } + + //! Swaps the values of two handles without reference counts + loose_handle & + swap(loose_handle &x) + { + pointer ptr=x.obj; + x.obj=x.get(); + obj=ptr; + return *this; + } + + //! Handle release procedure + void detach() { obj=0; } + + // This will be reintroduced with a new function + //void release() { detach(); } + + void reset() { detach(); } + + bool empty()const { return obj==0; } + + handle clone()const { assert(obj); return obj->clone(); } + + //! Returns a constant handle to our object + loose_handle constant()const { return *this; } + + //! Returns number of instances + count_type + count()const + { return obj?obj->count():0; } + + reference + operator*()const + { assert(obj); return *obj; } + + pointer + operator->()const + { assert(obj); return obj; } + + //! static_cast<> overload + //template + //operator loose_handle()const + //{ return loose_handle(static_cast(obj)); } + + //! static_cast<> overload (for consts) + operator loose_handle()const + { return loose_handle(static_cast(obj)); } + + operator handle()const + { return handle(obj); } + + operator rhandle()const + { return rhandle(obj); } + + //! Returns pointer to the object that is being wrapped + pointer get()const { return obj; } + + //! More explicit bool cast + operator bool()const + { return obj!=0; } + + bool + operator!()const + { return !obj; } + + void ref() { if(obj)obj->ref(); } + + bool unref() { if(obj && !obj->unref()){ obj=0; return false; } return true; } +}; // END of template class loose_handle + +// cast loose_handle<> -> handle<> +template template handle handle::cast_static (const loose_handle& x) { return handle(static_cast (x.get())); } +template template handle handle::cast_dynamic (const loose_handle& x) { return handle(dynamic_cast (x.get())); } +template template handle handle::cast_const (const loose_handle& x) { return handle(const_cast (x.get())); } +template template handle handle::cast_reinterpret(const loose_handle& x) { return handle(reinterpret_cast(x.get())); } + +// cast rhandle_handle<> -> handle<> +template template handle handle::cast_static (const rhandle& x) { return handle(static_cast (x.get())); } +template template handle handle::cast_dynamic (const rhandle& x) { return handle(dynamic_cast (x.get())); } +template template handle handle::cast_const (const rhandle& x) { return handle(const_cast (x.get())); } +template template handle handle::cast_reinterpret(const rhandle& x) { return handle(reinterpret_cast(x.get())); } + +// cast U* -> handle<> +template template handle handle::cast_static (U* x) { return handle(static_cast (x)); } +template template handle handle::cast_dynamic (U* x) { return handle(dynamic_cast (x)); } +template template handle handle::cast_const (U* x) { return handle(const_cast (x)); } +template template handle handle::cast_reinterpret(U* x) { return handle(reinterpret_cast(x)); } + +// operator== for handle<>, loose_handle<> and T* +template bool operator==(const handle & lhs,const handle & rhs) { return (lhs.get()==rhs.get()); } +template bool operator==(const loose_handle& lhs,const loose_handle& rhs) { return (lhs.get()==rhs.get()); } +template bool operator==(const handle & lhs,const loose_handle& rhs) { return (lhs.get()==rhs.get()); } +template bool operator==(const loose_handle& lhs,const handle & rhs) { return (lhs.get()==rhs.get()); } +template bool operator==(const handle& lhs,const T* rhs) { return (lhs.get()==rhs); } +template bool operator==(const loose_handle& lhs,const T* rhs) { return (lhs.get()==rhs); } +template bool operator==(const T* lhs,const handle& rhs) { return (lhs ==rhs.get()); } +template bool operator==(const T* lhs,const loose_handle& rhs) { return (lhs ==rhs.get()); } + +// operator!= for handle<>, loose_handle<> and T* +template bool operator!=(const handle & lhs,const handle & rhs) { return (lhs.get()!=rhs.get()); } +template bool operator!=(const loose_handle& lhs,const loose_handle& rhs) { return (lhs.get()!=rhs.get()); } +template bool operator!=(const handle & lhs,const loose_handle& rhs) { return (lhs.get()!=rhs.get()); } +template bool operator!=(const loose_handle& lhs,const handle & rhs) { return (lhs.get()!=rhs.get()); } +template bool operator!=(const handle& lhs,const T* rhs) { return (lhs.get()!=rhs); } +template bool operator!=(const loose_handle& lhs,const T* rhs) { return (lhs.get()!=rhs); } +template bool operator!=(const T* lhs,const handle& rhs) { return (lhs !=rhs.get()); } +template bool operator!=(const T* lhs,const loose_handle& rhs) { return (lhs !=rhs.get()); } + +// operator< for handle<>, loose_handle<> and T* +template bool operator<(const handle& lhs,const handle& rhs) { return (lhs.get() bool operator<(const loose_handle& lhs,const loose_handle& rhs) { return (lhs.get() bool operator<(const handle& lhs,const loose_handle& rhs) { return (lhs.get() bool operator<(const loose_handle& lhs,const handle& rhs) { return (lhs.get() bool operator<(const handle& lhs,const T* rhs) { return (lhs.get() bool operator<(const loose_handle& lhs,const T* rhs) { return (lhs.get() bool operator<(const T* lhs,const handle& rhs) { return (lhs bool operator<(const T* lhs,const loose_handle& rhs) { return (lhs +class hermite_base : std::unary_function +{ +public: + typedef T value_type; + typedef float time_type; +private: + affine_combo affine_func; + value_type a,b,c,d; + time_type r,s; + + value_type _coeff[3]; + time_type drs; // reciprocal of (s-r) +public: + hermite_base():r(0.0),s(1.0) { drs=1.0/(s-r); } + hermite_base( + const value_type &a, const value_type &b, const value_type &c, const value_type &d, + const time_type &r=0.0, const time_type &s=1.0): + a(a),b(b),c(c),d(d),r(r),s(s) { sync(); } + + void sync(void) + { + drs=1.0/(s-r); + _coeff[0]= c; + _coeff[1]=-d*1 - c*2 + b*3 - a*3; + _coeff[2]= d*1 + c*1 - b*2 + a*2; + } + + inline value_type + operator()(time_type t)const + { t-=r; t*=drs; return a + (_coeff[0]+(_coeff[1]+(_coeff[2])*t)*t)*t; } + + void set_rs(time_type new_r, time_type new_s) { r=new_r; s=new_s; drs=1.0/(s-r); } + void set_r(time_type new_r) { r=new_r; drs=1.0/(s-r); } + void set_s(time_type new_s) { s=new_s; drs=1.0/(s-r); } + const time_type &get_r(void)const { return r; } + const time_type &get_s(void)const { return s; } + time_type get_dt(void)const { return s-r; } + + value_type & + operator[](int i) + { return (&a)[i]; } + + const value_type & + operator[](int i) const + { return (&a)[i]; } +}; + + +template +class hermite : public hermite_base +{ +public: + typedef T value_type; + typedef float time_type; + + + +public: + hermite() { } + hermite(const value_type &p1, const value_type &p2, const value_type &t1, const value_type &t2): + P1(p1),P2(p2),T1(t1),T2(t2) { sync(); } + hermite(const value_type &p1, const value_type &p2): + P1(p1),P2(p2),T1(p2-p1),T2(p2-p1) { sync(); } + + value_type P1,P2,T1,T2; + + value_type &p1(void) { return P1; } + value_type &p2(void) { return P2; } + value_type &t1(void) { return T1; } + value_type &t2(void) { return T2; } + + void sync(void) + { +// hermite_base::operator[](0)=P1; +// bezier::operator[](1)=P1+T1/3; +// bezier::operator[](2)=P2-T2/3; +// bezier::operator[](3)=P2; + + hermite_base::operator[](0)=P1; + hermite_base::operator[](1)=P2; + hermite_base::operator[](2)=T1; + hermite_base::operator[](3)=T2; + + hermite_base::sync(); + } + +}; + +*/ + +template +class hermite : public bezier +{ +public: + typedef V value_type; + typedef T time_type; + + + +public: + hermite() { } + hermite(const value_type &p1, const value_type &p2, const value_type &t1, const value_type &t2): + P1(p1),P2(p2),T1(t1),T2(t2) { sync(); } + hermite(const value_type &p1, const value_type &p2): + P1(p1),P2(p2),T1(p2-p1),T2(p2-p1) { sync(); } + + value_type P1,P2,T1,T2; + + value_type &p1() { return P1; } + value_type &p2() { return P2; } + value_type &t1() { return T1; } + value_type &t2() { return T2; } + + void sync() + { + bezier::operator[](0)=P1; + bezier::operator[](1)=P1+T1/3; + bezier::operator[](2)=P2-T2/3; + bezier::operator[](3)=P2; + + bezier::sync(); + } +}; + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_misc.h b/ETL/tags/0.61.06/ETL/_misc.h new file mode 100644 index 0000000..6c84265 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_misc.h @@ -0,0 +1,103 @@ +/*! ======================================================================== +** Extended Template and Library +** Misc +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** Copyright (c) 2007 Chris Moore +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__MISC_H_ +#define __ETL__MISC_H_ + +/* === H E A D E R S ======================================================= */ +#include + +#include + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +template inline I +binary_find(I begin, I end, const T& value) +{ +#if 1 + I iter(begin+(end-begin)/2); + + while(end-begin>1 && !(*iter==value)) + { + ((*iter1 && !(*iter==value)) + { + ((*iter(x+0.5f); // <-- (a) fast, but rounds -1.333 to 0! + // return static_cast(rintf(x)); // <-- (b) slow, but correct + if (x>=0) return static_cast(x + 0.5); // <-- slower than (a), but correct, and faster than (b) + else return static_cast(x - 0.5); +} +inline int round_to_int(const double x) { + // return static_cast(x+0.5); + // return static_cast(rint(x)); + if (x>=0) return static_cast(x + 0.5); + else return static_cast(x - 0.5); +} + +inline int ceil_to_int(const float x) { return static_cast(ceil(x)); } +inline int ceil_to_int(const double x) { return static_cast(ceil(x)); } + +inline int floor_to_int(const float x) { return static_cast(x); } +inline int floor_to_int(const double x) { return static_cast(x); } + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_mutex_null.h b/ETL/tags/0.61.06/ETL/_mutex_null.h new file mode 100644 index 0000000..6c0d21e --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_mutex_null.h @@ -0,0 +1,71 @@ +/*! ======================================================================== +** Extended Template and Library +** NULL Mutex Abstraction Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__MUTEX_NULL_H_ +#define __ETL__MUTEX_NULL_H_ + +/* === H E A D E R S ======================================================= */ +/* === M A C R O S ========================================================= */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +class mutex_null +{ +public: + + mutex_null(){} + ~mutex_null(){} + //! Exception-safe mutex lock class +/* + class lock + { + mutex *_mtx; + public: + lock(mutex &x):_mtx(&x) { _mtx->lock_mutex(); } + ~lock() { _mtx->unlock_mutex(); } + mutex &get() { return *_mtx; } + }; +*/ + class lock + { + public: + lock(mutex_null &/*x*/) { } + }; + + void lock_mutex(){} + bool try_lock_mutex(){return true;} + void unlock_mutex(){} +}; + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_mutex_pthreads.h b/ETL/tags/0.61.06/ETL/_mutex_pthreads.h new file mode 100644 index 0000000..aed6766 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_mutex_pthreads.h @@ -0,0 +1,116 @@ +/*! ======================================================================== +** Extended Template and Library +** Mutex Abstraction Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__MUTEX_PTHREADS_H_ +#define __ETL__MUTEX_PTHREADS_H_ + +/* === H E A D E R S ======================================================= */ + +#define __USE_GNU + +#include + +#ifdef HAVE_SCHED_H +# include +#endif + +/* === M A C R O S ========================================================= */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +class mutex +{ + pthread_mutex_t mtx; + pthread_t locker; + int depth; +public: + + mutex() + { + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + //#ifdef PTHREAD_PRIO_INHERIT + //pthread_mutexattr_setprioceiling(&attr,PTHREAD_PRIO_INHERIT); + //#endif + #ifdef PTHREAD_MUTEX_RECURSIVE + pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE); + #endif + pthread_mutex_init(&mtx,&attr); + pthread_mutexattr_destroy(&attr); + locker=0; + depth=0; + } + + ~mutex() + { pthread_mutex_destroy(&mtx); } + + + //! Exception-safe mutex lock class + class lock + { + mutex *_mtx; + public: + lock(mutex &x):_mtx(&x) { _mtx->lock_mutex(); } + ~lock() { _mtx->unlock_mutex(); } + mutex &get() { return *_mtx; } + }; + + void lock_mutex(void) + { + if(!locker || locker!=pthread_self()) + { + pthread_mutex_lock(&mtx); + locker=pthread_self(); + depth=0; + return; + } + depth++; + } + + bool try_lock_mutex(void) + { return !(bool) pthread_mutex_trylock(&mtx); } + + void unlock_mutex(void) + { + if(depth) + { + depth--; + return; + } + pthread_mutex_unlock(&mtx); + locker=0; + } +}; + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_mutex_pthreads_simple.h b/ETL/tags/0.61.06/ETL/_mutex_pthreads_simple.h new file mode 100644 index 0000000..d95b327 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_mutex_pthreads_simple.h @@ -0,0 +1,64 @@ +/*! ======================================================================== +** Extended Template and Library +** Mutex Abstraction Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** Copyright (c) 2008 Chris Moore +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__MUTEX_PTHREADS_SIMPLE_H_ +#define __ETL__MUTEX_PTHREADS_SIMPLE_H_ + +/* === H E A D E R S ======================================================= */ + +#include + +/* === M A C R O S ========================================================= */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +class mutex +{ + pthread_mutex_t mtx; +public: + mutex() { pthread_mutex_init(&mtx,NULL); } + ~mutex() { pthread_mutex_destroy(&mtx); } + void lock_mutex() { pthread_mutex_lock(&mtx); } + void unlock_mutex() { pthread_mutex_unlock(&mtx); } + + //! Exception-safe mutex lock class + class lock + { + mutex *_mtx; + public: + lock(mutex &x):_mtx(&x) { _mtx->lock_mutex(); } + ~lock() { _mtx->unlock_mutex(); } + }; +}; + +_ETL_END_NAMESPACE + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_mutex_win32.h b/ETL/tags/0.61.06/ETL/_mutex_win32.h new file mode 100644 index 0000000..b7dda75 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_mutex_win32.h @@ -0,0 +1,82 @@ +/*! ======================================================================== +** Extended Template and Library +** Mutex Abstraction Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__MUTEX_WIN32_H_ +#define __ETL__MUTEX_WIN32_H_ + +/* === H E A D E R S ======================================================= */ + +#include +// extern HANDLE CreateMutex(NULL, FALSE, NULL); +// extern CloseHandle(handle); +// extern WaitForSingleObject(handle, INFINITE); +// extern ReleaseMutex(handle); + +/* === M A C R O S ========================================================= */ + + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +class mutex +{ + HANDLE handle; +public: + + mutex() + { handle = CreateMutex(NULL, FALSE, NULL); } + + ~mutex() + { CloseHandle(handle); } + + //! Exception-safe mutex lock class + class lock + { + mutex *_mtx; + public: + lock(mutex &x):_mtx(&x) { _mtx->lock_mutex(); } + ~lock() { _mtx->unlock_mutex(); } + mutex &get() { return *_mtx; } + }; + + void lock_mutex(void) + { WaitForSingleObject(handle, INFINITE); } + + bool try_lock_mutex(void) + { return WaitForSingleObject(handle, INFINITE)==WAIT_FAILED; } + + void unlock_mutex(void) + { ReleaseMutex(handle); } +}; + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_pen.h b/ETL/tags/0.61.06/ETL/_pen.h new file mode 100644 index 0000000..aa6bfab --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_pen.h @@ -0,0 +1,405 @@ +/*! ======================================================================== +** Extended Template Library +** Pen Template Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL_PEN_H +#define __ETL_PEN_H + +/* === H E A D E R S ======================================================= */ + +#include "_curve_func.h" +#include +#include +#include + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +template +class generic_pen_row_iterator +{ +public: + struct iterator_category : public std::random_access_iterator_tag {}; + typedef T value_type; + typedef int difference_type; + typedef value_type* pointer; + typedef value_type& reference; + + typedef generic_pen_row_iterator self_type; + + pointer data_; + int pitch_; + + reference operator[](int i)const { assert(data_); return *(pointer)( (char*)data_+pitch_*i ); } + reference operator*()const { assert(data_); return *data_; } + pointer operator->() const { assert(data_); return &(operator*()); } + + void inc() { assert(data_); data_ = (pointer)((char*)data_ + pitch_); } + void inc(int n) { assert(data_); data_ = (pointer)((char*)data_ + n*pitch_); } + + void dec() { assert(data_); data_ = (pointer)((char*)data_ - pitch_); } + void dec(int n) { assert(data_); data_ = (pointer)((char*)data_ - n*pitch_); } + + const self_type &operator++() { assert(data_); inc(); return *this; } + const self_type &operator--() { assert(data_); dec(); return *this; } + + self_type operator++(int) + { assert(data_); self_type ret(*this); inc(); return ret; } + self_type operator--(int) + { assert(data_); self_type ret(*this); dec(); return ret; } + + bool operator==(const self_type &rhs)const + { return data_==rhs.data_; } + + bool operator!=(const self_type &rhs)const + { return data_!=rhs.data_; } + + difference_type operator-(const self_type &rhs)const + { assert(data_); return ((char*)data_-(char*)rhs.data_-1)/pitch_+1; } + + self_type operator+(const difference_type &rhs)const + { + assert(data_); + self_type ret(*this); + ret.inc(rhs); + return ret; + } + + self_type operator-(const difference_type &rhs)const + { + assert(data_); + self_type ret(*this); + ret.dec(rhs); + return ret; + } + + operator const generic_pen_row_iterator()const + { + return generic_pen_row_iterator(data_,pitch_); + } + + operator bool()const { return (bool)data_; } + bool operator!()const { return !data_; } + + generic_pen_row_iterator(pointer data, int pitch):data_(data),pitch_(pitch) { } + generic_pen_row_iterator():data_(NULL) { } +}; + +template +class generic_pen +{ +public: + typedef T value_type; + typedef AT accumulator_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + + typedef pointer iterator_x; + typedef const_pointer const_iterator_x; + + typedef generic_pen_row_iterator iterator_y; + typedef generic_pen_row_iterator const_iterator_y; + + struct difference_type + { + typedef int value_type; + value_type x,y; + difference_type(value_type x, value_type y):x(x),y(y) { } + value_type &operator[](int i)const { return i?y:x; } + }; + +protected: + int x_,y_; + int w_,h_; +private: + int pitch_; + value_type value_; + value_type *data_; + + typedef generic_pen self_type; + + void addptr(int nbytes) + { + data_ = (pointer)((char*)data_ + nbytes); + } + + void subptr(int nbytes) + { + data_ = (pointer)((char*)data_ - nbytes); + } + +public: + + generic_pen(value_type *data, int w, int h, int pitch): + x_(0), + y_(0), + w_(w), + h_(h), + pitch_(pitch), + data_(data) + { + } + + generic_pen(value_type *data, int w, int h): + x_(0), + y_(0), + w_(w), + h_(h), + pitch_(sizeof(value_type)*w), + data_(data) + { + } + + generic_pen():data_(NULL) { } + + self_type& move(int a, int b) + { + assert(data_); + x_ += a, y_ += b; + addptr(b*pitch_ + a*sizeof(value_type)); + return *this; + } + self_type& move_to(int x, int y) { assert(data_); return move(x - x_,y - y_);} + void set_value(const value_type &v) { value_=v; } + + void inc_x() { assert(data_); x_++; data_++; } + void dec_x() { assert(data_); x_--; data_--; } + void inc_y() { assert(data_); y_++; addptr(pitch_); } + void dec_y() { assert(data_); y_--; subptr(pitch_); } + + void inc_x(int n) { assert(data_); x_+=n; data_+=n; } + void dec_x(int n) { assert(data_); x_-=n; data_-=n; } + void inc_y(int n) { assert(data_); y_+=n; data_ = (pointer)((char*)data_ + pitch_*n); } + void dec_y(int n) { assert(data_); y_-=n; data_ = (pointer)((char*)data_ - pitch_*n); } + + void put_value(const value_type &v)const { assert(data_); *data_=v; } + void put_value()const { assert(data_); put_value(value_); } + + void put_value_clip(const value_type &v)const + { if(!clipped()) put_value(v); } + void put_value_clip()const { put_value_clip(value_); } + + const_reference get_value()const { assert(data_); return *data_; } + + const_reference get_value_at(int x, int y)const { assert(data_); return ((pointer)(((char*)data_)+y*pitch_))[x]; } + + const_reference get_value_clip_at(int x, int y)const { assert(data_); if(clipped(x,y))return value_type(); return ((pointer)(((char*)data_)+y*pitch_))[x]; } + + value_type get_value_clip()const { assert(data_); if(clipped())return value_type(); return *data_; } + + value_type get_pen_value()const { return value_; } + + void put_hline(int l,const value_type &v) + {for(;l>0;l--,inc_x())put_value(v);} + + void put_hline(int l) {put_hline(l,value_);} + + void put_hline_clip(int l, const value_type &v) + {l=std::min(l,w_-x_);for(;l>0;l--,inc_x())put_value_clip(v);} + + void put_hline_clip(int l) {put_hline_clip(l,value_);} + + //the put_block functions do not modify the pen + void put_block(int h, int w, const value_type &v) + { + self_type row(*this); + for(;h>0;h--,row.inc_y()) + { + self_type col(row); + col.put_hline(w,v); + } + } + + void put_block(int h, int w) { put_block(h,w,value_); } + + void put_block_clip(int h, int w, const value_type &v) + { + self_type row(*this); + + //clip start position + if(row.x_ < 0) { w+=row.x_; row.inc_x(-row.x_); } + if(row.y_ < 0) { h+=row.y_; row.inc_y(-row.y_); } + + //clip width and height of copy rect + h = std::min(h,h_-y_); + w = std::min(w,w_-x_); + + //copy rect + for(;h>0;h--,row.inc_y()) + { + self_type col(row); + col.put_hline(w,v); //already clipped + } + } + + void put_block_clip(int h, int w) { put_block(h,w,value_); } + + + iterator_x operator[](int i)const { assert(data_); return (pointer)(((char*)data_)+i*pitch_); } + + iterator_x x() { assert(data_); return data_; } + iterator_x begin_x() { assert(data_); return data_-x_; } + iterator_x end_x() { assert(data_); return data_-x_+w_; } + + iterator_y y() { assert(data_); return iterator_y(data_,pitch_); } + iterator_y begin_y() { assert(data_); return iterator_y((pointer)((char*)data_ - y_*pitch_),pitch_); } + iterator_y end_y() { assert(data_); return iterator_y((pointer)((char*)data_ + (h_-y_)*pitch_),pitch_); } + + operator bool()const { return (bool)data_; } + bool operator!()const { return !data_; } + bool operator==(const self_type &rhs)const { return data_==rhs.data_; } + bool operator!=(const self_type &rhs)const { return data_!=rhs.data_; } + bool clipped(int x, int y)const { return !(x_+x>=0 && y_+y>=0 && x_+x=0 && y_>=0 && x_ +> +class alpha_pen : public PEN_ +{ +public: + typedef A_ alpha_type; + typedef AFFINE_ affine_func_type; + + typedef typename PEN_::value_type value_type; + typedef alpha_pen self_type; + +private: + alpha_type alpha_; + +protected: + affine_func_type affine_func_; + +public: + using PEN_::get_value; + using PEN_::get_pen_value; + using PEN_::inc_x; + using PEN_::dec_x; + using PEN_::inc_y; + using PEN_::dec_y; + using PEN_::clipped; + using PEN_::w_; + using PEN_::h_; + using PEN_::x_; + using PEN_::y_; + + alpha_pen(const alpha_type &a = 1, const affine_func_type &func = affine_func_type()):alpha_(a),affine_func_(func) { } + alpha_pen(const PEN_ &x, const alpha_type &a=1, const affine_func_type &func=affine_func_type()) + :PEN_(x),alpha_(a),affine_func_(func) { } + + const alpha_type& get_alpha()const { return alpha_; } + void get_alpha(alpha_type &a) const { a=alpha_; } + void set_alpha(alpha_type a) { alpha_=a; } + + void put_value(const value_type &v, alpha_type a=1)const + { PEN_::put_value(affine_func_(get_value(),v,alpha_*a)); } + void put_value()const { put_value(get_pen_value()); } + void put_value_alpha(alpha_type a)const { put_value(get_pen_value(),a); } + void put_hline(int l, const alpha_type &a = 1){for(;l>0;l--,inc_x())put_value_alpha(a);} + + void put_value_clip(const value_type &v, alpha_type a=1)const + { if(!clipped())PEN_::put_value(affine_func_(get_value(),v,alpha_*a)); } + void put_value_clip()const { put_value_clip(get_pen_value()); } + void put_value_clip_alpha(alpha_type a)const { put_value_clip(get_pen_value(),a); } + void put_hline_clip(int l, const alpha_type &a = 1){l=std::min(l,w_-x_);for(;l>0;l--,inc_x())put_value_clip_alpha(a);} + + //the put_block functions do not modify the pen + void put_block(int h, int w, const alpha_type &a = 1) + { + self_type row(*this); + for(;h>0;h--,row.inc_y()) + { + self_type col(row); + col.put_hline(w,a); + } + } + + void put_block_clip(int h, int w, const alpha_type &a = 1) + { + self_type row(*this); + + //clip start position + if(row.x_ < 0) { w+=row.x_; row.inc_x(-row.x_); } + if(row.y_ < 0) { h+=row.y_; row.inc_y(-row.y_); } + + //clip width and height of copy rect + h = std::min(h,h_-y_); + w = std::min(w,w_-x_); + + //copy rect + for(;h>0;h--,row.inc_y()) + { + self_type col(row); + col.put_hline(w,a); //already clipped + } + } +}; + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_random.h b/ETL/tags/0.61.06/ETL/_random.h new file mode 100644 index 0000000..c358dfc --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_random.h @@ -0,0 +1,138 @@ +/*! ======================================================================== +** Extended Template and Library +** Random Number Generator Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__RANDOM_H +#define __ETL__RANDOM_H + +/* === H E A D E R S ======================================================= */ + +/* === M A C R O S ========================================================= */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +/* +class rand_source_xor +{ +public: + typedef int seed_type; + typedef short value_type; + +private: + short entropy_pool[256]; + int pool_index; + +public: + random() + { + seed(0); + mod=offset=0; + } + + void seed(const seed_type &x) + { pool_index=0; } + + void add_entropy(value_type entropy) + { + int i; + for(i=0;iPOOL_SIZE) + pool_index=0; + if(mod) + return entropy_pool[pool_index++]%mod+offset; + return entropy_pool[pool_index++]; + } +}; +*/ + +template +class random +{ +public: + typedef T value_type; + typedef int seed_type; + +private: + value_type entropy_pool[POOL_SIZE]; + int pool_index; + + value_type mod,offset; + +public: + random() + { + seed(0); + mod=offset=0; + } + + void seed(const seed_type &x __attribute__ ((unused))) + { pool_index=0; } + + void set_range(const value_type &floor,const value_type &ceil) + { mod=ceil-floor; offset=floor; } + + void set_range(const value_type &ceil) + { mod=ceil; } + + void add_entropy(value_type entropy) + { + int i; + for(i=0;iPOOL_SIZE) + pool_index=0; + if(mod) + return entropy_pool[pool_index++]%mod+offset; + return entropy_pool[pool_index++]; + } +}; + +/* === T Y P E D E F S ===================================================== */ + +_ETL_END_NAMESPACE + +/* === E N D =============================================================== */ + +#endif + diff --git a/ETL/tags/0.61.06/ETL/_rect.h b/ETL/tags/0.61.06/ETL/_rect.h new file mode 100644 index 0000000..d9ffe64 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_rect.h @@ -0,0 +1,171 @@ +/*! ======================================================================== +** Extended Template Library +** Rectangle Basic Class Implementation +** $Id$ +** +** Copyright (c) 2002 Adrian Bentley +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL_RECT_H +#define __ETL_RECT_H + +/* === H E A D E R S ======================================================= */ + +#include +#include + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +template < typename T > +class rect +{ +public: //type niceties + typedef T value_type; + +public: //representation + + value_type minx,maxx,miny,maxy; + +public: //interface + + rect() {} + + rect(const value_type &x1,const value_type &y1) + { + set_point(x1,y1); + } + + rect(const value_type &x1,const value_type &y1, + const value_type &x2,const value_type &y2) + { + set_point(x1,y1); + expand(x2,y2); + } + + rect(const rect &o) + :minx(o.minx),maxx(o.maxx),miny(o.miny),maxy(o.maxy) + {} + + template < typename U > + rect(const rect &o) + :minx(o.minx),maxx(o.maxx),miny(o.miny),maxy(o.maxy) + {} + + void set_point(const value_type &x1,const value_type &y1) + { + minx = maxx = x1; + miny = maxy = y1; + } + + void expand(const value_type &x1,const value_type &y1) + { + minx = std::min(minx,x1); + maxx = std::max(maxx,x1); + miny = std::min(miny,y1); + maxy = std::max(maxy,y1); + } + + void set(const value_type &x1,const value_type &y1, + const value_type &x2,const value_type &y2) + { + minx = x1; maxx = x2; + miny = y1; maxy = y2; + } + + //HACK HACK HACK (stupid compiler doesn't like default arguments of any type) + bool valid() const + { + return valid(std::less()); + } + + template < typename F > + bool valid(const F & func) const + { + return func(minx,maxx) && func(miny,maxy); + } +}; + +template < typename T, typename F > +inline bool intersect(const rect &r1, const rect &r2, const F & func) +{ + /* We wan to do the edge compare test + |-----| + |------| intersecting + + |-----| + |-----| not intersecting + + So we want to compare the mins of the one against the maxs of the other, and + visa versa + + by default (exclude edge sharing) less will not be true if they are equal... + */ + + return func(r1.minx,r2.maxx) && + func(r2.minx,r1.maxx) && + func(r1.miny,r2.maxy) && + func(r2.miny,r1.maxy); +} + +template < typename T > +inline bool intersect(const rect &r1, const rect &r2) +{ + return intersect(r1,r2,std::less()); +} + +template < typename T > +void set_intersect(rect &rout, const rect &r1, const rect &r2) +{ + //takes the intersection of the two rectangles + rout.minx = std::max(r1.minx,r2.minx); + rout.miny = std::max(r1.miny,r2.miny); + rout.maxx = std::min(r1.maxx,r2.maxx); + rout.maxy = std::min(r1.maxy,r2.maxy); +} + +template < typename T > +void set_union(rect &rout, const rect &r1, const rect &r2) +{ + //takes the union of the two rectangles (bounds both... will contain extra info, but that's ok) + rout.set( + std::min(r1.minx,r2.minx), + std::min(r1.miny,r2.miny), + std::max(r1.maxx,r2.maxx), + std::max(r1.maxy,r2.maxy)); + /*rect local = r1; + rout.expand(r2.minx,r2.miny); + rout.expand(r2.maxx,r2.maxy); + rout = local;*/ +} + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_ref_count.h b/ETL/tags/0.61.06/ETL/_ref_count.h new file mode 100644 index 0000000..9f05b46 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_ref_count.h @@ -0,0 +1,158 @@ +/*! ======================================================================== +** Extended Template Library +** +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL_REF_COUNT_H +#define __ETL_REF_COUNT_H + +/* === H E A D E R S ======================================================= */ + +#include "_curve_func.h" +#include + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +class weak_reference_counter; + +// ======================================================================== +/*! \class reference_counter _ref_count.h ETL/ref_count +** \brief Reference counter +** \see weak_reference_counter +** \writeme +*/ +class reference_counter +{ + friend class weak_reference_counter; +private: + int* counter_; +public: + + reference_counter(const bool &x=true):counter_(x?new int(1):0) { } + + reference_counter(const reference_counter &x):counter_(x.counter_) + { if(counter_) (*counter_)++; } + + reference_counter(const weak_reference_counter &x); + + ~reference_counter() { detach(); } + + reference_counter& operator=(const reference_counter &rhs) + { + detach(); + counter_=rhs.counter_; + if(counter_) + { + assert(*counter_>0); + (*counter_)++; + } + return *this; + } + + void detach() + { + if(counter_) + { + assert(*counter_>0); + if(!--(*counter_)) + delete counter_; + counter_=0; + } + } + + void reset() + { + detach(); + counter_=new int(1); + } + + int count()const { return counter_?*counter_:0; } + + bool unique()const { return counter_?*counter_==1:0; } + + operator int()const { return count(); } +}; // END of class reference_counter + +// ======================================================================== +/*! \class weak_reference_counter _ref_count.h ETL/ref_count +** \brief Weak Reference counter +** \see reference_counter +** \writeme +*/ +class weak_reference_counter +{ + friend class reference_counter; +private: + int* counter_; +public: + weak_reference_counter():counter_(0) { } + + weak_reference_counter(const weak_reference_counter &x):counter_(x.counter_) { } + + weak_reference_counter(const reference_counter &x):counter_(x.counter_) { } + + ~weak_reference_counter() { } + + weak_reference_counter& operator=(const reference_counter &rhs) + { + counter_=rhs.counter_; + assert(*counter_>0); + return *this; + } + + weak_reference_counter& operator=(const weak_reference_counter &rhs) + { + counter_=rhs.counter_; + assert(*counter_>0); + return *this; + } + + void detach() { counter_=0; } + + int count()const { return counter_?*counter_:0; } + + bool unique()const { return counter_?*counter_==1:0; } + + operator int()const { return count(); } +}; // END of class weak_reference_counter + +inline reference_counter::reference_counter(const weak_reference_counter &x): + counter_(x.counter_) +{ + if(counter_) (*counter_)++; +} + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_rwlock.h b/ETL/tags/0.61.06/ETL/_rwlock.h new file mode 100644 index 0000000..930db26 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_rwlock.h @@ -0,0 +1,93 @@ +/*! ======================================================================== +** Extended Template and Library +** Mutex Abstraction Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__RWLOCK_H_ +#define __ETL__RWLOCK_H_ + +/* === H E A D E R S ======================================================= */ + +/* === M A C R O S ========================================================= */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +class read_write_lock : private Mutex +{ +public: + + read_write_lock() + { } + + ~read_write_lock() + { } + + //! Exception-safe read-lock class + class read_lock + { + read_write_lock *_mtx; + public: + read_lock(read_write_lock &x):_mtx(&x) { _mtx->lock_read(); } + ~read_lock() { _mtx->unlock_read(); } + read_write_lock &get() { return *_mtx; } + }; + + //! Exception-safe write-lock class + class write_lock + { + read_write_lock *_mtx; + public: + write_lock(read_write_lock &x):_mtx(&x) { _mtx->lock_write(); } + ~read_lock() { _mtx->unlock_write(); } + read_write_lock &get() { return *_mtx; } + }; + + void lock_read(void) + { lock_mutex(); } + + void lock_write(void) + { lock_mutex(); } + + bool try_lock_read(void) + { return try_lock_mutex(); } + + bool try_lock_write(void) + { return try_lock_mutex(); } + + void unlock_write(void) + { unlock_mutex(); } + + void unlock_read(void) + { unlock_mutex(); } +}; + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_smach.h b/ETL/tags/0.61.06/ETL/_smach.h new file mode 100644 index 0000000..99a7320 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_smach.h @@ -0,0 +1,598 @@ +/*! ======================================================================== +** Extended Template and Library +** State Machine Abstraction Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** Copyright (c) 2008 Chris Moore +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__SMACH_H_ +#define __ETL__SMACH_H_ + +/* === H E A D E R S ======================================================= */ + +#include +#include +#include +#include "_mutex_null.h" +#include "_misc.h" + +/* === M A C R O S ========================================================= */ + +#define SMACH_STATE_STACK_SIZE (32) + +#ifdef _MSC_VER +#pragma warning (disable:4786) +#pragma warning (disable:4290) // MSVC6 doesn't like function declarations with exception specs +#endif + +//#define ETL_MUTEX_LOCK() _mutex::lock lock(mutex) +#define ETL_MUTEX_LOCK() + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +/*! ======================================================================== +** \class smach +** \brief Templatized State Machine +** +** A more detailed description needs to be written. +*/ +template +class smach +{ +public: + + typedef K event_key; + typedef M _mutex; + typedef CON context_type; + + + struct egress_exception { }; + struct pop_exception { }; + + + //! Result type for event processing + enum event_result + { + // These values are returned by the event + // handlers cast to state pointers. + RESULT_ERROR, //!< General error or malfunction + RESULT_OK, //!< Event has been processed + RESULT_ACCEPT, //!< The event has been explicitly accepted. + RESULT_REJECT, //!< The event has been explicitly rejected. + + RESULT_END //!< Not a valid result + }; + + //template class state; + + //! Event base class + struct event + { + event_key key; + + event() { } + event(const event_key& key):key(key) { } + + operator event_key()const { return key; } + }; + + //! Event definition class + template + class event_def_internal + { + // List our friends + friend class smach; + //friend class state; + + public: + typedef T state_context_type; + + //! Event function type + typedef event_result (T::*funcptr)(const event&); + + //private: + + event_key id; // + class state : public state_base + { + // Our parent is our friend + friend class smach; + + public: + typedef event_def_internal event_def; + typedef T state_context_type; + + + private: + + std::vector event_list; + + smach *nested; //! Nested machine + event_key low,high; //! Lowest and Highest event values + const char *name; //! Name of the state + typename event_def::funcptr default_handler; //! Default handler for unknown key + + public: + + //! Constructor + state(const char *n, smach* nest=0): + nested(nest),name(n),default_handler(NULL) + { } + + virtual ~state() { } + + //! Setup a nested state machine + /*! A more detailed explanation needs to be written */ + void set_nested_machine(smach *sm) { nested=sm; } + + //! Sets the default handler + void set_default_handler(const typename event_def::funcptr &x) { default_handler=x; } + + //! Returns given the name of the state + virtual const char *get_name() const { return name; } + + state_context_type& get_context(smach& machine) + { + state_context_type *context(dynamic_cast(machine.state_context)); + if(context) + return context; + + } + + //! Adds an event_def onto the list and then make sure it is sorted correctly. + void + insert(const event_def &x) + { + // If this is our first event_def, + // setup the high and low values. + if(!event_list.size()) + low=high=x.id; + + // Sort the event_def onto the list + event_list.push_back(x); + sort(event_list.begin(),event_list.end()); + + // Update the low and high markers + if(x.id::iterator find(const event_key &x) { return binary_find(event_list.begin(),event_list.end(),x); } + typename std::vector::const_iterator find(const event_key &x)const { return binary_find(event_list.begin(),event_list.end(),x); } + + protected: + + virtual void* enter_state(context_type* machine_context)const + { + return new state_context_type(machine_context); + } + + virtual bool leave_state(void* x)const + { + state_context_type* state_context(reinterpret_cast(x)); + delete state_context; + return true; + } + + virtual event_result + process_event(void* x,const event& id)const + { + state_context_type* state_context(reinterpret_cast(x)); + + // Check for nested machine in state + if(nested) + { + const event_result ret(nested->process_event(id)); + if(ret!=RESULT_OK) + return ret; + } + + // Quick test to make sure that the + // given event is in the state + if(id.key::const_iterator iter(find(id.key)); + + // If search results were negative, fail. + if(iter->id!=id.key) + return RESULT_OK; + + // Execute event function + event_result ret((state_context->*(iter->handler))(id)); + + if(ret==RESULT_OK && default_handler) + ret=(state_context->*(default_handler))(id); + + return ret; + } + }; + +private: + + // Machine data + const state_base* curr_state; //!< Current state of the machine + smach* child; //!< Child machine + +public: // this really should be private + void* state_context; //!< State Context +private: + + context_type* machine_context; //!< Machine Context + + const state_base* default_state; + void* default_context; + +#ifdef ETL_MUTEX_LOCK + _mutex mutex; +#endif + + //! State stack data + const state_base* state_stack[SMACH_STATE_STACK_SIZE]; + void* state_context_stack[SMACH_STATE_STACK_SIZE]; + int states_on_stack; + +public: + + //! Gets the name of the currently active state + const char * + get_state_name()const + { +#ifdef ETL_MUTEX_LOCK + ETL_MUTEX_LOCK(); +#endif + if(curr_state) + return curr_state->get_name(); + if(default_state) + return default_state->get_name(); + return 0; + } + + //! Determines if a given event result is an error + /*! This function allows us to quickly see + if an event_result contained an error */ + static bool + event_error(const event_result &rhs) + { return rhs<=RESULT_ERROR; } + + bool + set_default_state(const state_base *nextstate) + { +#ifdef ETL_MUTEX_LOCK + ETL_MUTEX_LOCK(); +#endif + // Keep track of the current state unless + // the state switch fails + const state_base *prev_state=default_state; + + // If we are already in a state, leave it and + // collapse the state stack + if(default_state) + default_state->leave_state(default_context); + + // Set this as our current state + default_state=nextstate; + default_context=0; + + // Attempt to enter the state + if(default_state) + { + default_context=default_state->enter_state(machine_context); + if(default_context) + return true; + } + else + return true; + + // We failed, so attempt to return to previous state + default_state=prev_state; + + // If we had a previous state, enter it + if(default_state) + default_context=default_state->enter_state(machine_context); + + // At this point we are not in the + // requested state, so return failure + return false; + } + + //! Leaves the current state + /*! Effectively makes the state_depth() function return zero. */ + bool + egress() + { +#ifdef ETL_MUTEX_LOCK + ETL_MUTEX_LOCK(); +#endif + + // Pop all states off the state stack + while(states_on_stack) pop_state(); + + // If we are not in a state, then I guess + // we were successful. + if(!curr_state) + return true; + + // Grab the return value from the exit function + bool ret=true; + + const state_base* old_state=curr_state; + void *old_context=state_context; + + // Clear out the current state and its state_context + curr_state=0;state_context=0; + + // Leave the state + return old_state->leave_state(old_context); + + return ret; + } + + //! State entry function + /*! Attempts to enter the given state, + popping off all states on the stack + in the process. */ + bool + enter(const state_base *nextstate) + { +#ifdef ETL_MUTEX_LOCK + ETL_MUTEX_LOCK(); +#endif + + // Keep track of the current state unless + // the state switch fails + const state_base *prev_state=curr_state; + + // If we are already in a state, leave it and + // collapse the state stack + if(curr_state) + egress(); + + // Set this as our current state + curr_state=nextstate; + state_context=0; + + // Attempt to enter the state + state_context=curr_state->enter_state(machine_context); + if(state_context) + return true; + + // We failed, so attempt to return to previous state + curr_state=prev_state; + + // If we had a previous state, enter it + if(curr_state) + state_context=curr_state->enter_state(machine_context); + + // At this point we are not in the + // requested state, so return failure + return false; + } + + //! Pushes state onto state stack + /*! This allows you to enter a state without + leaving your current state. + \param nextstate Pointer to the state to enter + \sa pop_state() + */ + bool + push_state(const state_base *nextstate) + { +#ifdef ETL_MUTEX_LOCK + ETL_MUTEX_LOCK(); +#endif + + // If there are not enough slots, then throw something. + if(states_on_stack==SMACH_STATE_STACK_SIZE) + throw(std::overflow_error("smach<>::push_state(): state stack overflow!")); + + // If there is no current state, nor anything on stack, + // just go ahead and enter the given state. + if(!curr_state && !states_on_stack) + return enter(nextstate); + + // Push the current state onto the stack + state_stack[states_on_stack]=curr_state; + state_context_stack[states_on_stack++]=state_context; + + // Make the next state the current state + curr_state=nextstate; + + // Try to enter the next state + state_context=curr_state->enter_state(machine_context); + if(state_context) + return true; + + // Unable to push state, return to old one + curr_state=state_stack[--states_on_stack]; + state_context=state_context_stack[states_on_stack]; + return false; + } + + //! Pops state off of state stack + /*! Decreases state depth */ + void + pop_state() + { +#ifdef ETL_MUTEX_LOCK + ETL_MUTEX_LOCK(); +#endif + + // If we aren't in a state, then there is nothing + // to do. + if(!curr_state) + throw(std::underflow_error("smach<>::pop_state(): stack is empty!")); + + if(states_on_stack) + { + const state_base* old_state=curr_state; + void *old_context=state_context; + + // Pop previous state off of stack + --states_on_stack; + curr_state=state_stack[states_on_stack]; + state_context=state_context_stack[states_on_stack]; + + old_state->leave_state(old_context); + } + else // If there are no states on stack, just egress + egress(); + } + + //! State Machine Constructor + /*! A more detailed description needs to be written */ + smach(context_type* machine_context=0): + curr_state(0), + child(0), + state_context(0), + machine_context(machine_context), + default_state(0), + default_context(0), + states_on_stack(0) + { } + + //! The destructor + ~smach() + { + egress(); + + if(default_state) + default_state->leave_state(default_context); + } + + //! Sets up a child state machine + /*! A child state machine runs in parallel with + its parent, and gets event priority. This + mechanism is useful in cases where an inherited + object has its own state machine. */ + void set_child(smach *x) + { +#ifdef ETL_MUTEX_LOCK + ETL_MUTEX_LOCK(); +#endif + child=x; + } + + //! Returns the number states currently active + int + state_depth() + { return curr_state?states_on_stack+1:0; } + + event_result + process_event(const event_key& id) { return process_event(event(id)); } + + //! Process an event + event_result + process_event(const event& id) + { +#ifdef ETL_MUTEX_LOCK + ETL_MUTEX_LOCK(); +#endif + + event_result ret(RESULT_OK); + + // Check for child machine + if(child) + { + ret=child->process_event(id); + if(ret!=RESULT_OK) + return ret; + } + + try + { + if(curr_state) + ret=curr_state->process_event(state_context,id); + + if(ret==RESULT_OK) + return default_state->process_event(default_context,id); + + return ret; + } + catch(egress_exception) { return egress()?RESULT_ACCEPT:RESULT_ERROR; } + catch(pop_exception) { pop_state(); return RESULT_ACCEPT; } + catch(const state_base* state) { return enter(state)?RESULT_ACCEPT:RESULT_ERROR; } + } + +}; // END of template class smach + +_ETL_END_NAMESPACE + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_smart_ptr.h b/ETL/tags/0.61.06/ETL/_smart_ptr.h new file mode 100644 index 0000000..a34b8dd --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_smart_ptr.h @@ -0,0 +1,363 @@ +/* ======================================================================== +** Extended Template and Library +** Template Smart Pointer Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__SMART_PTR_H +#define __ETL__SMART_PTR_H + +/* === H E A D E R S ======================================================= */ + +#include +#include "_ref_count.h" + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +template +struct generic_deleter +{ + void operator()(T* x)const { delete x; } +}; + +template +struct array_deleter +{ + void operator()(T* x)const { delete [] x; } +}; + +// ======================================================================== +/*! \class smart_ptr _smart_ptr.h ETL/smart_ptr +** \brief Object Smart Pointer +** \see loose_smart_ptr +** \writeme +*/ +template > +class smart_ptr +{ +public: + + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T* pointer; + typedef const T* const_pointer; + typedef int count_type; + typedef int size_type; + typedef D destructor_type; + +#ifdef DOXYGEN_SHOULD_SKIP_THIS // #ifdef is not a typo +private: +#endif + value_type *obj; //!< \internal Pointer to object + reference_counter refcount; + +public: + // Private constructor for convenience + smart_ptr(value_type* obj,reference_counter refcount):obj(obj),refcount(refcount) { } + + //! Default constructor - empty smart_ptr + smart_ptr():obj(0),refcount(false) {} + + //! Constructor that constructs from a pointer to new object + /*! A new smart_ptr is created with a pointer + to a newly allocated object. We need + to be explicit with this so we don't + accidently have two smart_ptrs for one + object -- that would be bad. */ + explicit smart_ptr(value_type* x):obj(x),refcount(x?true:false) { } + + //! Template copy constructor + /*! This template constructor allows us to cast + smart_ptrs much like we would pointers. */ +#ifdef _WIN32 + template + smart_ptr(const smart_ptr &x):obj((pointer)&*x.obj),refcount(x.refcount()) + { } +#endif + + //! Default copy constructor + /*! The template above is not good enough + for all compilers. We need to explicitly + define the copy constructor for this + class to work on those compilers. */ + smart_ptr(const smart_ptr &x):obj(x.obj),refcount(x.refcount) { } + + explicit smart_ptr(const value_type &x):obj(new value_type(x)) { } + + //! smart_ptr is released on deletion + ~smart_ptr() { if(refcount.unique()) destructor_type()(obj); } + + //! Template Assignment operator + template const smart_ptr & + operator=(const smart_ptr &x) + { + if(x.get()==obj) + return *this; + + reset(); + + if(x.obj) + { + obj=(pointer)x.get(); + refcount=x.refcount; + } + + return *this; + } + + //! Assignment operator + const smart_ptr & + operator=(const smart_ptr &x) + { + if(x.get()==obj) + return *this; + + reset(); + + if(x.obj) + { + + obj=(pointer)x.get(); + refcount=x.refcount; + } + + return *this; + } + + //! smart_ptr reset procedure + void + reset() + { + if(obj) + { + if(refcount.unique()) destructor_type()(obj); + refcount.detach(); + obj=0; + } + } + + void spawn() { operator=(smart_ptr(new T)); } + + //! Returns number of instances + const count_type& count()const { return refcount; } + + //! Returns true if there is only one instance of the object + bool unique()const { return refcount.unique(); } + + //! Returns a constant handle to our object + smart_ptr constant() { return *this; } + + reference operator*()const { assert(obj); return *obj; } + + pointer operator->()const { assert(obj); return obj; } + + + operator smart_ptr()const + { return smart_ptr(static_cast(obj)); } + + //! static_cast<> wrapper + template static + smart_ptr cast_static(const smart_ptr &x) + { if(!x)return NULL; return smart_ptr(static_cast(x.get()),x.refcount); } + + //! dynamic_cast<> wrapper + template static + smart_ptr cast_dynamic(const smart_ptr &x) + { if(!x)return 0; return smart_ptr(dynamic_cast(x.get()),x.refcount); } + + //! const_cast<> wrapper + template static + smart_ptr cast_const(const smart_ptr &x) + { if(!x)return 0; return smart_ptr(const_cast(x.get()),x.refcount); } + + pointer get()const { return obj; } + + //! More explicit bool cast + operator bool()const { return obj!=0; } + + bool operator!()const { return !obj; } + + //! Overloaded cast operator -- useful for implicit casts + template + operator smart_ptr() + { + // This next line should provide a syntax check + // to make sure that this cast makes sense. + // If it doesn't, this should have a compiler error. + // Otherwise, it should get optimized right out + // of the code. + //(U*)obj; + + return *reinterpret_cast*>(this); + } + +}; // END of template class smart_ptr + +// ======================================================================== +/*! \class loose_smart_ptr _smart_ptr.h ETL/smart_ptr +** \brief Loose Object Smart Pointer +** \see smart_ptr +** \writeme +*/ +template +class loose_smart_ptr +{ +public: + + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T* pointer; + typedef const T* const_pointer; + typedef int count_type; + typedef int size_type; + +private: + value_type *obj; //!< \internal Pointer to object + weak_reference_counter refcount; //!< \internal Pointer to object's reference counter + +public: + + //! Default constructor - empty smart_ptr + loose_smart_ptr():obj(0),refcount(0) {} + + //! Default copy constructor + loose_smart_ptr(const loose_smart_ptr &x):obj(x.get()),refcount(x.refcount) { } + + loose_smart_ptr(const smart_ptr &x):obj(x.get()),refcount(x.refcount) { } + + void reset() { obj=0,refcount=0; } + + operator smart_ptr() + { + return smart_ptr(static_cast(obj),refcount); + } + + operator smart_ptr() + { + return smart_ptr(static_cast(obj),refcount); + } + + //! Returns number of instances + const count_type& count()const { return refcount; } + + bool unique()const { return refcount.unique(); } + + reference operator*()const { assert(obj); return *obj; } + + pointer operator->()const { assert(obj); return obj; } + + pointer get()const { return obj; } + + bool operator!()const { return !obj; } +}; + +template bool +operator==(const smart_ptr &lhs,const smart_ptr &rhs) + { return (lhs.get()==rhs.get()); } +template bool +operator==(const loose_smart_ptr &lhs,const loose_smart_ptr &rhs) + { return (lhs.get()==rhs.get()); } +template bool +operator==(const smart_ptr &lhs,const loose_smart_ptr &rhs) + { return (lhs.get()==rhs.get()); } +template bool +operator==(const loose_smart_ptr &lhs,const smart_ptr &rhs) + { return (lhs.get()==rhs.get()); } +template bool +operator==(const smart_ptr &lhs,const T *rhs) + { return (lhs.get()==rhs); } +template bool +operator==(const loose_smart_ptr &lhs,const T *rhs) + { return (lhs.get()==rhs); } +template bool +operator==(const T *lhs,const smart_ptr &rhs) + { return (lhs==rhs.get()); } +template bool +operator==(const T *lhs,const loose_smart_ptr &rhs) + { return (lhs==rhs.get()); } + + +template bool +operator!=(const smart_ptr &lhs,const smart_ptr &rhs) + { return (lhs.get()!=rhs.get()); } +template bool +operator!=(const loose_smart_ptr &lhs,const loose_smart_ptr &rhs) + { return (lhs.get()!=rhs.get()); } +template bool +operator!=(const smart_ptr &lhs,const loose_smart_ptr &rhs) + { return (lhs.get()!=rhs.get()); } +template bool +operator!=(const loose_smart_ptr &lhs,const smart_ptr &rhs) + { return (lhs.get()!=rhs.get()); } +template bool +operator!=(const smart_ptr &lhs,const T *rhs) + { return (lhs.get()!=rhs); } +template bool +operator!=(const loose_smart_ptr &lhs,const T *rhs) + { return (lhs.get()!=rhs); } +template bool +operator!=(const T *lhs,const smart_ptr &rhs) + { return (lhs!=rhs.get()); } +template bool +operator!=(const T *lhs,const loose_smart_ptr &rhs) + { return (lhs!=rhs.get()); } + + +template bool +operator<(const smart_ptr &lhs,const smart_ptr &rhs) + { return (lhs.get() bool +operator<(const loose_smart_ptr &lhs,const loose_smart_ptr &rhs) + { return (lhs.get() bool +operator<(const smart_ptr &lhs,const loose_smart_ptr &rhs) + { return (lhs.get() bool +operator<(const loose_smart_ptr &lhs,const smart_ptr &rhs) + { return (lhs.get() bool +operator<(const smart_ptr &lhs,const T *rhs) + { return (lhs.get() bool +operator<(const loose_smart_ptr &lhs,const T *rhs) + { return (lhs.get() bool +operator<(const T *lhs,const smart_ptr &rhs) + { return (lhs bool +operator<(const T *lhs,const loose_smart_ptr &rhs) + { return (lhs +#include +#include + +/* === M A C R O S ========================================================= */ + +#ifndef ETL_STRPRINTF_MAX_LENGTH +#define ETL_STRPRINTF_MAX_LENGTH (800) +#endif + +#ifdef WIN32 +#define POPEN_BINARY_READ_TYPE "rb" +#define POPEN_BINARY_WRITE_TYPE "wb" +#else +#define POPEN_BINARY_READ_TYPE "r" +#define POPEN_BINARY_WRITE_TYPE "w" +#endif + +/* === T Y P E D E F S ===================================================== */ + +_ETL_BEGIN_CDECLS + +#if defined(__APPLE__) || defined(__CYGWIN__) || defined(_WIN32) +#define ETL_NO_THROW +#else +#define ETL_NO_THROW throw() +#endif + +#ifdef HAVE_VASPRINTF // This is the preferred method + extern int vasprintf(char **,const char *,va_list)ETL_NO_THROW; +#else + +# ifdef HAVE_VSNPRINTF // This is the secondary method + extern int vsnprintf(char *,size_t,const char*,va_list)ETL_NO_THROW; +# endif + +#endif + +#ifdef HAVE_VSSCANF +extern int vsscanf(const char *,const char *,va_list)ETL_NO_THROW; +#else +#define ETL_NO_VSTRSCANF +#ifdef HAVE_SSCANF +extern int sscanf(const char *buf, const char *format, ...)ETL_NO_THROW; +#endif +#endif + +#include + +_ETL_END_CDECLS + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +inline std::string +vstrprintf(const char *format, va_list args) +{ +#ifdef HAVE_VASPRINTF // This is the preferred method (and safest) + char *buffer; + std::string ret; + vasprintf(&buffer,format,args); + ret=buffer; + free(buffer); + return ret; +#else +#ifdef HAVE_VSNPRINTF // This is the secondary method (Safe, but bulky) +#warning etl::vstrprintf() has a maximum size of ETL_STRPRINTF_MAX_LENGTH in this configuration. +#ifdef ETL_THREAD_SAFE + char buffer[ETL_STRPRINTF_MAX_LENGTH]; +#else + static char buffer[ETL_STRPRINTF_MAX_LENGTH]; +#endif + vsnprintf(buffer,sizeof(buffer),format,args); + return buffer; +#else // This is the worst method (UNSAFE, but "works") +#warning Potential for Buffer-overflow bug using vsprintf +#define ETL_UNSAFE_STRPRINTF (true) +// Here, we are doubling the size of the buffer to make this case +// slightly more safe. +#ifdef ETL_THREAD_SAFE + char buffer[ETL_STRPRINTF_MAX_LENGTH*2]; +#else + static char buffer[ETL_STRPRINTF_MAX_LENGTH*2]; +#endif + vsprintf(buffer,format,args); + return buffer; +#endif +#endif +} + +inline std::string +strprintf(const char *format, ...) +{ + va_list args; + va_start(args,format); + return vstrprintf(format,args); +} + +#ifndef ETL_NO_VSTRSCANF +inline int +vstrscanf(const std::string &data, const char*format, va_list args) +{ + return vsscanf(data.c_str(),format,args); +} + +inline int +strscanf(const std::string &data, const char*format, ...) +{ + va_list args; + va_start(args,format); + return vstrscanf(data, format,args); +} +#else + +#if defined (HAVE_SSCANF) && defined (__GNUC__) +#define strscanf(data,format,...) sscanf(data.c_str(),format,__VA_ARGS__) +#endif +#endif + + +#define stratof(X) (atof((X).c_str())) +#define stratoi(X) (atoi((X).c_str())) + +inline std::string +basename(const std::string &str) +{ + std::string::const_iterator iter; + + if(str.size() == 1 && str[0] == ETL_DIRECTORY_SEPARATOR) + return str; + + if(str.end()[-1]==ETL_DIRECTORY_SEPARATOR) + iter=str.end()-2; + else + iter=str.end()-1; + + for(;iter!=str.begin();iter--) + if(*iter==ETL_DIRECTORY_SEPARATOR) + break; + + if (*iter==ETL_DIRECTORY_SEPARATOR) + iter++; + + if(str.end()[-1]==ETL_DIRECTORY_SEPARATOR) + return std::string(iter,str.end()-1); + + return std::string(iter,str.end()); +} + +inline std::string +dirname(const std::string &str) +{ + std::string::const_iterator iter; + + if(str.size() == 1 && str[0] == ETL_DIRECTORY_SEPARATOR) + return str; + + if(str.end()[-1]==ETL_DIRECTORY_SEPARATOR) + iter=str.end()-2; + else + iter=str.end()-1; + + for(;iter!=str.begin();iter--) + if(*iter==ETL_DIRECTORY_SEPARATOR) + break; + + if(iter==str.begin()) + { + if (*iter==ETL_DIRECTORY_SEPARATOR) + return "/"; + else + return "."; + } + + return std::string(str.begin(),iter); +} + +// filename_extension("/f.e/d.c") => ".c" +inline std::string +filename_extension(const std::string &str) +{ + std::string base = basename(str); + std::string::size_type pos = base.find_last_of('.'); + if (pos == std::string::npos) return std::string(); + return base.substr(pos); +} + +// filename_sans_extension("/f.e/d.c") => "/f.e/d" +inline std::string +filename_sans_extension(const std::string &str) +{ + std::string base = basename(str); + std::string::size_type pos = base.find_last_of('.'); + if (pos == std::string::npos) return str; + std::string dir = dirname(str); + if (dir == ".") return base.substr(0,pos); + return dir + ETL_DIRECTORY_SEPARATOR + base.substr(0,pos); +} + +inline bool +is_absolute_path(const std::string &path) +{ +#ifdef WIN32 + if(path.size()>=3 && path[1]==':' && (path[2]=='\\' || path[2]=='/')) + return true; +#endif + if(!path.empty() && path[0]==ETL_DIRECTORY_SEPARATOR) + return true; + return false; +} + +inline std::string +unix_to_local_path(const std::string &path) +{ + std::string ret; + std::string::const_iterator iter; + for(iter=path.begin();iter!=path.end();iter++) + switch(*iter) + { + case '/': + ret+=ETL_DIRECTORY_SEPARATOR; + break; + case '~': + ret+='~'; + break; + default: + ret+=*iter; + break; + } + return ret; +} + +inline std::string +current_working_directory() +{ + char dir[256]; + std::string ret(getcwd(dir,sizeof(dir))); + return ret; +} + +inline std::string +get_root_from_path(std::string path) +{ + std::string ret; + std::string::const_iterator iter; + + for(iter=path.begin();iter!=path.end();++iter) + { + if(*iter==ETL_DIRECTORY_SEPARATOR) + break; + ret+=*iter; + } + //if(iter!=path.end()) + ret+=ETL_DIRECTORY_SEPARATOR; + return ret; +} + +inline std::string +remove_root_from_path(std::string path) +{ + while(!path.empty()) + { + if(path[0]==ETL_DIRECTORY_SEPARATOR) + { + path.erase(path.begin()); + return path; + } + path.erase(path.begin()); + } + return path; +} + +inline std::string +cleanup_path(std::string path) +{ + std::string ret; + + while(basename(path)=="."&&path.size()!=1)path=dirname(path); + + while(!path.empty()) + { + std::string dir(get_root_from_path(path)); + if((dir=="../" || dir=="..\\") && ret.size()) + { + ret=dirname(ret); + if (*(ret.end()-1)!=ETL_DIRECTORY_SEPARATOR) + ret+=ETL_DIRECTORY_SEPARATOR; + } + else if((dir!="./" && dir!=".\\") && dir!=".") + ret+=dir; + path=remove_root_from_path(path); + } + if (ret.size()==0)ret+='.'; + + // Remove any trailing directory separators + if(ret.size() && ret[ret.size()-1]==ETL_DIRECTORY_SEPARATOR) + ret.erase(ret.begin()+ret.size()-1); + return ret; +} + +inline std::string +absolute_path(std::string path) +{ + std::string ret(current_working_directory()); + + if(path.empty()) + return cleanup_path(ret); + if(is_absolute_path(path)) + return cleanup_path(path); + return cleanup_path(ret+ETL_DIRECTORY_SEPARATOR+path); +} + +inline std::string +relative_path(std::string curr_path,std::string dest_path) +{ + // If dest_path is already a relative path, + // then there is no need to do anything. + if(!is_absolute_path(dest_path)) + dest_path=absolute_path(dest_path); + else + dest_path=cleanup_path(dest_path); + + if(!is_absolute_path(curr_path)) + curr_path=absolute_path(curr_path); + else + curr_path=cleanup_path(curr_path); + +#ifdef WIN32 + // If we are on windows and the dest path is on a different drive, + // then there is no way to make a relative path to it. + if(dest_path.size()>=3 && dest_path[1]==':' && dest_path[0]!=curr_path[0]) + return dest_path; +#endif + + if(curr_path==dirname(dest_path)) + return basename(dest_path); + + while(!dest_path.empty() && !curr_path.empty() && get_root_from_path(dest_path)==get_root_from_path(curr_path)) + { + dest_path=remove_root_from_path(dest_path); + curr_path=remove_root_from_path(curr_path); + } + + while(!curr_path.empty()) + { + dest_path=std::string("..")+ETL_DIRECTORY_SEPARATOR+dest_path; + curr_path=remove_root_from_path(curr_path); + } + + return dest_path; +} + +_ETL_END_NAMESPACE + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_surface.h b/ETL/tags/0.61.06/ETL/_surface.h new file mode 100644 index 0000000..d5a32a5 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_surface.h @@ -0,0 +1,649 @@ +/*! ======================================================================== +** Extended Template and Library +** Surface Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** Copyright (c) 2008 Chris Moore +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__SURFACE_H +#define __ETL__SURFACE_H + +/* === H E A D E R S ======================================================= */ + +#include "_pen.h" +#include "_misc.h" +#include +#include + +/* === M A C R O S ========================================================= */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +template +class value_prep +{ +public: + typedef T value_type; + typedef AT accumulator_type; + + accumulator_type cook(const value_type& x)const { return (accumulator_type)x; } + value_type uncook(const accumulator_type& x)const { return (value_type)x; } +}; + +template > +class surface +{ +public: + typedef T value_type; + typedef AT accumulator_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef generic_pen pen; + typedef generic_pen const_pen; + typedef VP value_prep_type; + + typedef alpha_pen const_alpha_pen; + typedef alpha_pen non_const_alpha_pen; + + typedef typename pen::difference_type size_type; + typedef typename pen::difference_type difference_type; + + typedef typename pen::iterator_x iterator_x; + typedef typename pen::iterator_y iterator_y; + typedef typename pen::const_iterator_x const_iterator_x; + typedef typename pen::const_iterator_y const_iterator_y; + +private: + value_type *data_; + value_type *zero_pos_; + typename difference_type::value_type pitch_; + int w_, h_; + bool deletable_; + + value_prep_type cooker_; + + void swap(const surface &x) + { + std::swap(data_,x.data_); + std::swap(zero_pos_,x.zero_pos_); + std::swap(pitch_,x.pitch_); + std::swap(w_,x.w_); + std::swap(h_,x.h_); + std::swap(deletable_,x.deletable_); + } + +public: + surface(): + data_(0), + zero_pos_(data_), + pitch_(0), + w_(0),h_(0), + deletable_(false) { } + + surface(value_type* data, int w, int h, bool deletable=false): + data_(data), + zero_pos_(data), + pitch_(sizeof(value_type)*w), + w_(w),h_(h), + deletable_(deletable) { } + + surface(const typename size_type::value_type &w, const typename size_type::value_type &h): + data_(new value_type[w*h]), + zero_pos_(data_), + pitch_(sizeof(value_type)*w), + w_(w),h_(h), + deletable_(true) { } + + surface(const size_type &s): + data_(new value_type[s.x*s.y]), + zero_pos_(data_), + pitch_(sizeof(value_type)*s.x), + w_(s.x),h_(s.y), + deletable_(true) { } + + template + surface(const _pen &_begin, const _pen &_end) + { + typename _pen::difference_type size=_end-_begin; + + data_=new value_type[size.x*size.y]; + w_=size.x; + h_=size.y; + zero_pos_=data_; + pitch_=sizeof(value_type)*w_; + deletable_=true; + + int x,y; + + for(y=0;y void + fill(value_type v, _pen& PEN, int w, int h) + { + assert(data_); + if(w<=0 || h<=0)return; + int y; + PEN.set_value(v); + for(y=0;y void blit_to(_pen &pen) + { return blit_to(pen,0,0, get_w(),get_h()); } + + template void + blit_to(_pen &DEST_PEN, + int x, int y, int w, int h) //src param + { + if(x>=w_ || y>=h_) + return; + + //clip source origin + if(x<0) + { + w+=x; //decrease + x=0; + } + + if(y<0) + { + h+=y; //decrease + y=0; + } + + //clip width against dest width + w = std::min((long)w,(long)(DEST_PEN.end_x()-DEST_PEN.x())); + h = std::min((long)h,(long)(DEST_PEN.end_y()-DEST_PEN.y())); + + //clip width against src width + w = std::min(w,w_-x); + h = std::min(h,h_-y); + + if(w<=0 || h<=0) + return; + + pen SOURCE_PEN(get_pen(x,y)); + + for(; h>0; h--,DEST_PEN.inc_y(),SOURCE_PEN.inc_y()) + { + int i; + for(i=0; i0 + && h_>0 + && pitch_!=0 + ; + } + + operator bool()const { return is_valid(); } + + pen begin() { assert(data_); return pen(data_,w_,h_,pitch_); } + pen get_pen(int x, int y) { assert(data_); return begin().move(x,y); } + pen end() { assert(data_); return get_pen(w_,h_); } + + const_pen begin()const { assert(data_); return const_pen(data_,w_,h_,pitch_); } + const_pen get_pen(int x, int y)const { assert(data_); return begin().move(x,y); } + const_pen end()const { assert(data_); return get_pen(w_,h_); } + + //! Linear sample + value_type linear_sample(const float x, const float y)const + { + int u(floor_to_int(x)), v(floor_to_int(y)); + float a, b; + static const float epsilon(1.0e-6); + + if(x<0.0f)u=0,a=0.0f; + else if(x>w_-1)u=w_-1,a=0.0f; + else a=x-u; + + if(y<0.0f)v=0,b=0.0f; + else if(y>h_-1)v=h_-1,b=0.0f; + else b=y-v; + + const float + c(1.0f-a), d(1.0f-b), + e(a*d),f(c*b),g(a*b); + + accumulator_type ret(cooker_.cook((*this)[v][u])*(c*d)); + if(e>=epsilon)ret+=cooker_.cook((*this)[v][u+1])*e; + if(f>=epsilon)ret+=cooker_.cook((*this)[v+1][u])*f; + if(g>=epsilon)ret+=cooker_.cook((*this)[v+1][u+1])*g; + return cooker_.uncook(ret); + } + + //! Cosine sample + value_type cosine_sample(const float x, const float y)const + { + int u(floor_to_int(x)), v(floor_to_int(y)); + float a, b; + static const float epsilon(1.0e-6); + + if(x<0.0f)u=0,a=0.0f; + else if(x>w_-1)u=w_-1,a=0.0f; + else a=x-u; + + if(y<0.0f)v=0,b=0.0f; + else if(y>h_-1)v=h_-1,b=0.0f; + else b=y-v; + + a=(1.0f-cos(a*3.1415927f))*0.5f; + b=(1.0f-cos(b*3.1415927f))*0.5f; + + const float + c(1.0f-a), d(1.0f-b), + e(a*d),f(c*b),g(a*b); + + accumulator_type ret(cooker_.cook((*this)[v][u])*(c*d)); + if(e>=epsilon)ret+=cooker_.cook((*this)[v][u+1])*e; + if(f>=epsilon)ret+=cooker_.cook((*this)[v+1][u])*f; + if(g>=epsilon)ret+=cooker_.cook((*this)[v+1][u+1])*g; + + return cooker_.uncook(ret); + } + + //! Cubic sample + value_type cubic_sample(float x, float y)const + { + #if 0 + #define P(x) (((x)>=0)?((x)*(x)*(x)):0.0f) + #define R(x) ( P(x+2) - 4.0f*P(x+1) + 6.0f*P(x) - 4.0f*P(x-1) )*(1.0f/6.0f) + #define F(i,j) (cooker_.cook((*this)[max(min(j+v,h_-1),0)][max(min(i+u,w_-1),0)])*(R((i)-a)*R(b-(j)))) + #define Z(i,j) ret+=F(i,j) + #define X(i,j) // placeholder... To make box more symmetric + + int u(floor_to_int(x)), v(floor_to_int(y)); + float a, b; + + // Clamp X + if(x<0.0f)u=0,a=0.0f; + else if(u>w_-1)u=w_-1,a=0.0f; + else a=x-u; + + // Clamp Y + if(y<0.0f)v=0,b=0.0f; + else if(v>h_-1)v=h_-1,b=0.0f; + else b=y-v; + + // Interpolate + accumulator_type ret(F(0,0)); + Z(-1,-1); Z(-1, 0); Z(-1, 1); Z(-1, 2); + Z( 0,-1); X( 0, 0); Z( 0, 1); Z( 0, 2); + Z( 1,-1); Z( 1, 0); Z( 1, 1); Z( 1, 2); + Z( 2,-1); Z( 2, 0); Z( 2, 1); Z( 2, 2); + + return cooker_.uncook(ret); + + #undef X + #undef Z + #undef F + #undef P + #undef R + #else + + #define f(j,i) (cooker_.cook((*this)[j][i])) + //Using catmull rom interpolation because it doesn't blur at all + //bezier curve with intermediate ctrl pts: 0.5/3(p(i+1) - p(i-1)) and similar + accumulator_type xfa [4]; + + //precalculate indices (all clamped) and offset + const int xi = x > 0 ? (x < w_ ? (int)floor(x) : w_-1) : 0; + const int xa[] = {std::max(0,xi-1),xi,std::min(w_-1,xi+1),std::min(w_-1,xi+2)}; + + const int yi = y > 0 ? (y < h_ ? (int)floor(y) : h_-1) : 0; + const int ya[] = {std::max(0,yi-1),yi,std::min(h_-1,yi+1),std::min(h_-1,yi+2)}; + + const float xf = x-xi; + const float yf = y-yi; + + //figure polynomials for each point + const float txf[] = + { + 0.5*xf*(xf*(xf*(-1) + 2) - 1), //-t + 2t^2 -t^3 + 0.5*(xf*(xf*(3*xf - 5)) + 2), //2 - 5t^2 + 3t^3 + 0.5*xf*(xf*(-3*xf + 4) + 1), //t + 4t^2 - 3t^3 + 0.5*xf*xf*(xf-1) //-t^2 + t^3 + }; + + const float tyf[] = + { + 0.5*yf*(yf*(yf*(-1) + 2) - 1), //-t + 2t^2 -t^3 + 0.5*(yf*(yf*(3*yf - 5)) + 2), //2 - 5t^2 + 3t^3 + 0.5*yf*(yf*(-3*yf + 4) + 1), //t + 4t^2 - 3t^3 + 0.5*yf*yf*(yf-1) //-t^2 + t^3 + }; + + //evaluate polynomial for each row + for(int i = 0; i < 4; ++i) + { + xfa[i] = f(ya[i],xa[0])*txf[0] + f(ya[i],xa[1])*txf[1] + f(ya[i],xa[2])*txf[2] + f(ya[i],xa[3])*txf[3]; + } + + //return the cumulative column evaluation + return cooker_.uncook(xfa[0]*tyf[0] + xfa[1]*tyf[1] + xfa[2]*tyf[2] + xfa[3]*tyf[3]); +#undef f +#endif + } + + value_type sample_rect(float x0,float y0,float x1,float y1) const + { + const surface &s = *this; + + //assumes it's clamped to the boundary of the image + //force min max relationship for x0,x1 and y0,y1 + if(x0 > x1) std::swap(x0,x1); + if(y0 > y1) std::swap(y0,y1); + + //local variable madness + //all things that want to inter-operate should provide a default value constructor for = 0 + accumulator_type acum = 0; + int xi=0,yi=0; + + int xib=(int)floor(x0), + xie=(int)floor(x1); + + int yib=(int)floor(y0), + yie=(int)floor(y1); + + //the weight for the pixel should remain the same... + float weight = (y1-y0)*(x1-x0); + assert(weight != 0); + + float ylast = y0, xlastb = x0; + const_pen pen_ = s.get_pen(xib,yib); + + for(yi = yib; yi < yie; ylast = ++yi, pen_.inc_y()) + { + const float yweight = yi+1 - ylast; + + float xlast = xlastb; + for(xi = xib; xi < xie; xlast = ++xi, pen_.inc_x()) + { + const float w = yweight*(xi+1 - xlast); + acum += cooker_.cook(pen_.get_value())*w; + } + + //post... with next being fractional... + const float w = yweight*(x1 - xlast); + acum += cooker_.cook(pen_.get_value())*w; + + pen_.dec_x(xie-xib); + } + + //post in y direction... must have all x... + { + const float yweight = y1 - ylast; + + float xlast = xlastb; + for(xi = xib; xi < xie; xlast = ++xi) + { + const float w = yweight*(xi+1 - xlast); + + acum += cooker_.cook(pen_.get_value())*w; + } + + //post... with next being fractional... + const float w = yweight*(x1 - xlast); + acum += cooker_.cook(pen_.get_value())*w; + } + + acum *= 1/weight; + return cooker_.uncook(acum); + } + + value_type sample_rect_clip(float x0,float y0,float x1,float y1) const + { + const surface &s = *this; + + //assumes it's clamped to the boundary of the image + //force min max relationship for x0,x1 and y0,y1 + if(x0 > x1) std::swap(x0,x1); + if(y0 > y1) std::swap(y0,y1); + + //local variable madness + //all things that want to inter-operate should provide a default value constructor for = 0 + accumulator_type acum = 0; + int xi=0,yi=0; + + int xib=(int)floor(x0), + xie=(int)floor(x1); + + int yib=(int)floor(y0), + yie=(int)floor(y1); + + //the weight for the pixel should remain the same... + float weight = (y1-y0)*(x1-x0); + + assert(weight != 0); + + //clip to the input region + if(x0 >= s.get_w() || x1 <= 0) return acum; + if(y0 >= s.get_h() || y1 <= 0) return acum; + + if(x0 < 0) { x0 = 0; xib = 0; } + if(x1 >= s.get_w()) + { + x1 = s.get_w(); //want to be just below the last pixel... + xie = s.get_w()-1; + } + + if(y0 < 0) { y0 = 0; yib = 0; } + if(y1 >= s.get_h()) + { + y1 = s.get_h(); //want to be just below the last pixel... + yie = s.get_h()-1; + } + + float ylast = y0, xlastb = x0; + const_pen pen = s.get_pen(xib,yib); + + for(yi = yib; yi < yie; ylast = ++yi, pen.inc_y()) + { + const float yweight = yi+1 - ylast; + + float xlast = xlastb; + for(xi = xib; xi < xie; xlast = ++xi, pen.inc_x()) + { + const float w = yweight*(xi+1 - xlast); + acum += cooker_.cook(pen.get_value())*w; + } + + //post... with next being fractional... + const float w = yweight*(x1 - xlast); + acum += cooker_.cook(pen.get_value())*w; + + pen.dec_x(xie-xib); + } + + //post in y direction... must have all x... + { + const float yweight = y1 - ylast; + + float xlast = xlastb; + for(xi = xib; xi < xie; xlast = ++xi) + { + const float w = yweight*(xi+1 - xlast); + + acum += cooker_.cook(pen.get_value())*w; + } + + //post... with next being fractional... + const float w = yweight*(x1 - xlast); + acum += cooker_.cook(pen.get_value())*w; + } + + acum *= 1/weight; + return cooker_.uncook(acum); + } +}; + +_ETL_END_NAMESPACE + +/* === T Y P E D E F S ===================================================== */ + + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_thread.h b/ETL/tags/0.61.06/ETL/_thread.h new file mode 100644 index 0000000..8f70be8 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_thread.h @@ -0,0 +1,515 @@ +/*! ======================================================================== +** Extended Template and Library +** Thread Abstraction Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL__THREAD_H_ +#define __ETL__THREAD_H_ + +/* === H E A D E R S ======================================================= */ + +#define __USE_GNU + +#ifdef HAVE_PTHREAD_H +# include +#endif + +#ifdef HAVE_SCHED_H +# include +#endif + +#ifdef HAVE_CREATETHREAD +# include +#endif + +/* === M A C R O S ========================================================= */ + +#if ( defined (HAVE_PTHREAD_CREATE) || defined (HAVE_CLONE) || defined (HAVE_CREATETHREAD) ) && !defined (NO_THREADS) +# define CALLISTO_THREADS +#endif + +#define THREAD_ENTRYPOINT + +/* === C L A S S E S & S T R U C T S ======================================= */ + +#if defined(CALLISTO_THREADS) && defined(HAVE_PTHREAD_CREATE) +static inline void Yield(void) +{ + sched_yield(); + pthread_testcancel(); +} +#else +#ifdef Yield + #undef Yield +#endif +inline void Yield(void) { } +#endif + +#ifdef CALLISTO_THREADS + +#ifdef HAVE_PTHREAD_CREATE + +class Thread +{ +public: + typedef void* entrypoint_return; +private: + + pthread_t thread; + int *references; + entrypoint_return (*entrypoint)(void *); + void *context; +public: + Thread(void *(*ep)(void *)=NULL,void *context=NULL): + references(NULL),entrypoint(ep),context(context) { } + Thread(const Thread &t) + { + thread=t.thread; + references=t.references; + entrypoint=t.entrypoint; + context=t.context; + if(references) + (*references)++; + } + const Thread &operator=(const Thread &rhs) + { + if(references) + { + (*references)--; + if(*references==0) + stop(); + } + thread=rhs.thread; + references=rhs.references; + entrypoint=rhs.entrypoint; + context=rhs.context; + if(references) + (*references)++; + return *this; + } + + void start(void) + { + references = new int; + *references = 1; + pthread_create(&thread,NULL,entrypoint,context); +// pthread_detach(thread); + } + + void stop(void) + { + delete references; + references=NULL; + void *exit_status; + pthread_cancel(thread); + pthread_join(thread,&exit_status); + } + + static void TestStop() + { + pthread_testcancel(); + } + + static void SyncStop() + { + int i; + pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,&i); + } + + static void AsyncStop() + { + int i; + pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,&i); + } + + ~Thread() + { + if(references) + { + (*references)--; + if(*references==0) + stop(); + } + } +}; + +class Mutex +{ + pthread_mutex_t mutex; + pthread_t locker; + int depth; +public: + + Mutex() + { + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + //#ifdef PTHREAD_PRIO_INHERIT + //pthread_mutexattr_setprioceiling(&attr,PTHREAD_PRIO_INHERIT); + //#endif + #ifdef PTHREAD_MUTEX_RECURSIVE + pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE); + #endif + pthread_mutex_init(&mutex,&attr); + pthread_mutexattr_destroy(&attr); + locker=0; + depth=0; + } + + ~Mutex() + { pthread_mutex_destroy(&mutex); } + + void Lock(void) + { + if(!locker || locker!=pthread_self()) + { + pthread_mutex_lock(&mutex); + locker=pthread_self(); + depth=0; + return; + } + depth++; + } + + bool TryLock(void) + { return !(bool) pthread_mutex_trylock(&mutex); } + + void UnLock(void) + { + if(depth) + { + depth--; + return; + } + pthread_mutex_unlock(&mutex); + locker=0; + } +}; + +#ifdef HAVE_PTHREAD_RW_LOCK_INIT +class ReadWriteLock +{ + pthread_rwlock_t rwlock; +public: + + ReadWriteLock() + { pthread_rwlock_init(&rwlock,NULL); } + + ~ReadWriteLock() + { pthread_rwlock_destroy(&rwlock); } + + void LockRead(void) + { pthread_rwlock_rdlock(&rwlock); } + + void LockWrite(void) + { pthread_rwlock_wrlock(&rwlock); } + + bool TryLockRead(void) + { return !(bool)pthread_rwlock_tryrdlock(&rwlock); } + + bool TryLockWrite(void) + { return !(bool)pthread_rwlock_trywrlock(&rwlock); } + + void UnLockWrite(void) + { pthread_rwlock_unlock(&rwlock); } + + void UnLockRead(void) + { pthread_rwlock_unlock(&rwlock); } +}; +#else +//* +class ReadWriteLock : public Mutex +{ +public: + + ReadWriteLock() + { } + + ~ReadWriteLock() + { } + + void LockRead(void) + { Lock(); } + + void LockWrite(void) + { Lock(); } + + bool TryLockRead(void) + { return TryLock(); } + + bool TryLockWrite(void) + { return TryLock(); } + + void UnLockWrite(void) + { UnLock(); } + + void UnLockRead(void) + { UnLock(); } +}; +#endif + +/* +class Condition +{ + pthread_cond_t cond; + pthread_mutex_t mutex; +public: + Condition() + { pthread_cond_init(&cond,NULL); pthread_mutex_init(&mutex,NULL); } + ~Condition() + { pthread_cond_destroy(&cond); pthread_mutex_destroy(&mutex);} + void operator()(void) + { pthread_cond_signal(&cond); } + void Wait(void) + { + pthread_mutex_lock(&mutex); + pthread_cond_wait(&cond,&mutex); + pthread_mutex_unlock(&mutex); + } +}; +*/ + +#else // if defined HAVE_PTHREAD +#ifdef HAVE_CREATETHREAD + + +#ifdef THREAD_ENTRYPOINT +#undef THREAD_ENTRYPOINT +#endif +#define THREAD_ENTRYPOINT __stdcall +class Thread +{ +public: + typedef unsigned long entrypoint_return; +private: + + unsigned long thread; + HANDLE handle; + int *references; + + entrypoint_return (THREAD_ENTRYPOINT *entrypoint)(void *); + + void *context; + + HDC hdc; + HGLRC hglrc; + + static entrypoint_return THREAD_ENTRYPOINT thread_prefix(void*data) + { + Thread *thread=(Thread *)data; + + if(thread->hglrc) + wglMakeCurrent(thread->hdc, thread->hglrc); + + return thread->entrypoint(thread->context); + } + +public: + Thread(entrypoint_return (THREAD_ENTRYPOINT *ep)(void *)=NULL,void *context=NULL): + references(NULL),entrypoint(ep),context(context) { } + Thread(const Thread &t) + { + thread=t.thread; + handle=t.handle; + references=t.references; + entrypoint=t.entrypoint; + context=t.context; + handle=NULL; + if(references) + (*references)++; + } + const Thread &operator=(const Thread &rhs) + { + if(references) + { + (*references)--; + if(*references==0) + stop(); + } + thread=rhs.thread; + handle=rhs.handle; + references=rhs.references; + entrypoint=rhs.entrypoint; + context=rhs.context; + if(references) + (*references)++; + return *this; + } + + void start(void) + { + references = new int; + *references = 1; + + hglrc=wglGetCurrentContext(); + hdc=wglGetCurrentDC(); + + handle=CreateThread( + NULL, // Security stuff + 0, // STACK + thread_prefix, // thread function + (void*)this, // thread argument + 0, // creation option + &thread // thread identifier + ); + } + + void stop(void) + { + delete references; + references=NULL; + + TerminateThread(handle, FALSE); + } + + int wait(void) + { + if(handle) + { + WaitForSingleObject(handle, INFINITE); + CloseHandle(handle); + } + return 0; + } + + static void TestStop() + { + } + + static void SyncStop() + { + } + + static void AsyncStop() + { + } + + ~Thread() + { + if(references) + { + (*references)--; + if(*references==0) + stop(); + } + } +}; + +class Mutex +{ + HANDLE handle; +public: + + Mutex() + { + handle = CreateMutex(NULL, FALSE, NULL); + } + + ~Mutex() + { + CloseHandle(handle); + } + + void Lock(void) + { + WaitForSingleObject(handle, INFINITE); + } + + bool TryLock(void) + { + return WaitForSingleObject(handle, INFINITE)==WAIT_FAILED; + } + + void UnLock(void) + { + ReleaseMutex(handle); + } +}; + + +#endif // if defined HAVE_CREATETHREAD +#endif // if defined HAVE_PTHREAD_CREATE +#endif // if defined CALLISTO_THREADS + + +#if !defined(CALLISTO_THREADS) +// Dummy object used when not threading +class ReadWriteLock +{ +public: + + ReadWriteLock() {} + ~ReadWriteLock() {} + void LockRead(void) {} + void LockWrite(void) {} + bool TryLockRead(void) {return true;} + bool TryLockWrite(void) {return true;} + void UnLockRead(void) {} + void UnLockWrite(void) {} +}; + +class Mutex +{ +public: + + Mutex(){} + ~Mutex(){} + void Lock(void){} + bool TryLock(void){return true;} + void UnLock(void){} +}; + +#endif + +class Condition : private Mutex +{ + bool flag; +public: + Condition() + { flag=false; } + ~Condition() + { } + void operator()(void) + { flag=true; } + void Wait(void) + { + Lock(); + while(!flag)Yield(); + flag=false; + UnLock(); + } + void WaitNext(void) + { + Lock(); + flag=false; + while(!flag)Yield(); + UnLock(); + } +}; + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_trivial.h b/ETL/tags/0.61.06/ETL/_trivial.h new file mode 100644 index 0000000..049b268 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_trivial.h @@ -0,0 +1,164 @@ +/*! ======================================================================== +** Extended Template Library +** Trivializing Template Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL_TRIVIAL_H +#define __ETL_TRIVIAL_H + +/* === H E A D E R S ======================================================= */ + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +_ETL_BEGIN_NAMESPACE + +/*! ======================================================================== +** \class Trivial +** \brief Trivializes the constructor of a given class +** +** This class makes the given type 'trivial', +** effectively disabling the constructor and +** destructor. (This is useful for unions) +** Some extra casting may be necessary to get +** it to work properly. +*/ +template +class trivial +{ + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T* pointer; + typedef const T* const_pointer; + + char data[sizeof(T)]; +public: + operator reference() + { return *reinterpret_cast(data); } + + // HACK - Rather dangerous + //operator reference()const + //{ return *reinterpret_cast(const_cast(data)); } + + operator const_reference()const + { return *reinterpret_cast(data); } + + reference get() + { return *reinterpret_cast(data); } + + const_reference get()const + { return *reinterpret_cast(data); } + + void construct() + { new(&get()) value_type(); } + + void destruct() + { get().~value_type(); } + + void destroy() { destruct(); } + + template reference + operator=(const U &rhs) + { return get()=rhs; } + + templatereference + operator=(const trivial &rhs) + { return get()=rhs.get(); } + + template reference + operator+=(const U &rhs) + { return get()+=rhs; } + + template reference + operator-=(const U &rhs) + { return get()-=rhs; } + + template reference + operator*=(const U &rhs) + { return get()*=rhs; } + + template reference + operator/=(const U &rhs) + { return get()/=rhs; } + + template reference + operator%=(const U &rhs) + { return get()%=rhs; } + + template reference + operator^=(const U &rhs) + { return get()^=rhs; } + + template reference + operator&=(const U &rhs) + { return get()&=rhs; } + + template reference + operator>>=(const U &rhs) + { return get()>>=rhs; } + + template reference + operator<<=(const U &rhs) + { return get()<<=rhs; } + + operator bool()const + { return get(); } + + bool operator!()const + { return !get(); } +}; // END of template class trivial + +_ETL_END_NAMESPACE + +//#include + +/* +template std::basic_istream<_CharT, _Traits>& +operator>>(std::basic_istream<_CharT, _Traits>& s, etl::trivial& rhs) +{ return s>>(T)(rhs); } + +template std::basic_ostream<_CharT, _Traits>& +operator<<(std::basic_ostream<_CharT, _Traits>& s, const etl::trivial& rhs) +{ return s<<(T)(rhs); } +*/ + +/* +template std::istream& +operator>>(std::istream& s, etl::trivial& rhs) +{ return s>>(T)(rhs); } + +template std::ostream& +operator<<(std::ostream& s, const etl::trivial& rhs) +{ return s<<(T)(rhs); } +*/ + +/* === E X T E R N S ======================================================= */ + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/_value.h b/ETL/tags/0.61.06/ETL/_value.h new file mode 100644 index 0000000..a52567e --- /dev/null +++ b/ETL/tags/0.61.06/ETL/_value.h @@ -0,0 +1,237 @@ +/* ======================================================================== +** Extended Template and Library +** Abstraction for a Generic Value Type +** $Id$ +** +** Copyright (c) 2002 Adrian Bentley +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** This is an internal header file, included by other ETL headers. +** You should not attempt to use it directly. +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ETL_VALUE_H +#define __ETL_VALUE_H + +/* === H E A D E R S ======================================================= */ +#include +#include +#include + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +/*! \note This class may be specialized to support binary compatibility + for desired objects (e.g. point3,vector3,float[3]). + However it MUST be declared within scope that you are using the + values.... + + \warning If you specialize this class for something that isn't binary + compatible, then your values could easily report belonging to + the wrong types. +*/ +template < typename T > +class value_store_type +{ +public: + typedef T value_type; +}; + +_ETL_BEGIN_NAMESPACE + +/*! \class value _value.h ETL/value + \brief Abstraction of the concept of a generic value + + Modified from ideas for the boost::any type. Added binary compatibility + structure +*/ +class value +{ + struct contentholder + { + virtual ~contentholder() {} + virtual contentholder *clone() const = 0; + virtual const std::type_info &type() const = 0; + }; + + contentholder *content; + +public: //constructor interface + value() + :content(0) + { + } + + value(const value &v) + :content( v.content ? v.content->clone() : 0 ) + { + } + + /* Copies the object passed to it + */ + template < typename T > + value(const T &v) + :content( new holder< typename value_store_type::value_type > + (reinterpret_cast::value_type &>(v)) ) + { + } + +public: //modifier interface + + value & swap(value & rhs) + { + std::swap(content, rhs.content); + return *this; + } + + template + value & operator=(const ValueType & rhs) + { + value(rhs).swap(*this); + return *this; + } + + value & operator=(const value & rhs) + { + value(rhs).swap(*this); + return *this; + } + +public: //query interface + + bool empty() const + { + return content == 0; + } + + const std::type_info & type() const + { + return content ? content->type() : typeid(void); + } + +private: //implementation interface + + template < typename T > + class holder : public contentholder + { + public: //representation + T obj; + + public: //constructor interface + + holder(const T &o) + :obj(o) + { + } + + holder(const holder &h) + :obj(h.obj) + { + } + + public: //accessor interface + virtual contentholder *clone() const + { + return new holder(*this); + } + + virtual const std::type_info &type() const + { + return typeid(T); + } + + public: //allocation interface + void *operator new(unsigned int size) + { + assert(size == sizeof(holder)); + + //use pool allocation at some point + return malloc(size); + } + + void operator delete(void *p) + { + assert(p); + //use pool allocation at some point + return free(p); + } + }; + + template < typename ValueType > + friend ValueType *value_cast(value *v); +}; + +/*! Is thrown for bad value_casts (when using a reference...) +*/ +class bad_value_cast : public std::bad_cast +{ +public: + virtual const char * what() const throw() + { + return "etl::bad_value_cast: " "failed conversion using boost::value_cast"; + } +}; + +/*! Returns a pointer to the desired value type if the value_type and the internal + binary format agree (mediated by using the value_store_type class), otherwise + it returns 0. + + \see value_store_type +*/ +template < typename ValueType > +ValueType *value_cast(value *v) +{ + assert(v); + + return ( typeid(typename value_store_type::value_type) == v->type() ) + ? &static_cast *>(v->content)->obj + : 0; +} + +/*! Same as above except tweaked to allow const cast (possibly for purposes involving + type agreement... if const impacts a typeid call I do not know...) +*/ +template < typename ValueType > +const ValueType * value_cast(const value *v) +{ + return value_cast(const_cast(v)); +} + +/*! Extract a copy of the internal object and will throw a bad_value_cast exception + if the types do not agree. + + \note I'm not sure why boost::any didn't use a reference here... there must be a reason... + + \see bad_value_cast +*/ +template < typename ValueType > +ValueType value_cast(const value &v) +{ + const ValueType * result = value_cast(&v); + if(!result) + throw bad_value_cast(); + return *result; +} + +_ETL_END_NAMESPACE + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/angle b/ETL/tags/0.61.06/ETL/angle new file mode 100644 index 0000000..b58aef8 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/angle @@ -0,0 +1,48 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Angle Abstraction Class Implementation +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __ANGLE__ +#define __ANGLE__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" +#include "_curve_func.h" + +#ifdef ETL_FASTANGLE +#include "_fastangle.h" +_ETL_BEGIN_NAMESPACE +typedef fastangle angle; +_ETL_END_NAMESPACE +#else +# include "_angle.h" +#endif + +#ifdef __BEZIER__ +#include "_bezier_angle.h" +#endif + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/bezier b/ETL/tags/0.61.06/ETL/bezier new file mode 100644 index 0000000..22be24a --- /dev/null +++ b/ETL/tags/0.61.06/ETL/bezier @@ -0,0 +1,40 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Bezier Curve Class +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __BEZIER__ +#define __BEZIER__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_bezier.h" + +#ifdef __ANGLE__ +#include "_bezier_angle.h" +#endif + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/boxblur b/ETL/tags/0.61.06/ETL/boxblur new file mode 100644 index 0000000..e56316b --- /dev/null +++ b/ETL/tags/0.61.06/ETL/boxblur @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Box Blur Template +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __BOXBLUR__ +#define __BOXBLUR__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_boxblur.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/calculus b/ETL/tags/0.61.06/ETL/calculus new file mode 100644 index 0000000..06b8928 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/calculus @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Calculus Functional Classes +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __CALCULUS__ +#define __CALCULUS__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_calculus.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/clock b/ETL/tags/0.61.06/ETL/clock new file mode 100644 index 0000000..76a694e --- /dev/null +++ b/ETL/tags/0.61.06/ETL/clock @@ -0,0 +1,104 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Clock Abstraction +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __CLOCK__ +#define __CLOCK__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#ifdef HAVE_GETTIMEOFDAY +#include "_clock_gettimeofday.h" +#ifndef ETL_CLOCK_DEFAULT_DESC_CLASS +#define ETL_CLOCK_DEFAULT_DESC_CLASS _ETL::clock_desc_gettimeofday +#endif +#ifndef ETL_CLOCK_REALTIME_DESC_CLASS +#define ETL_CLOCK_REALTIME_DESC_CLASS _ETL::clock_desc_gettimeofday +#endif +#endif + +#ifdef _WIN32 +#include "_clock_win32hpcount.h" +#ifndef ETL_CLOCK_DEFAULT_DESC_CLASS +#define ETL_CLOCK_DEFAULT_DESC_CLASS _ETL::clock_desc_win32hpcount +#endif +#ifndef ETL_CLOCK_REALTIME_DESC_CLASS +#define ETL_CLOCK_REALTIME_DESC_CLASS _ETL::clock_desc_win32hpcount +#endif +#endif + +// If we could not find ourselves a better +// clock description, go ahead and use the +// standard clock() implementation. +// (Better than nothing...) +#include "_clock_system.h" +#ifndef ETL_CLOCK_DEFAULT_DESC_CLASS +#define ETL_CLOCK_DEFAULT_DESC_CLASS _ETL::clock_desc_sys_clock +#endif +#ifndef ETL_CLOCK_PROCTIME_DESC_CLASS +#define ETL_CLOCK_PROCTIME_DESC_CLASS _ETL::clock_desc_sys_clock +#endif +#ifndef ETL_CLOCK_REALTIME_DESC_CLASS +#define ETL_CLOCK_REALTIME_DESC_CLASS _ETL::clock_desc_sys_time +#endif + +#include "_clock_base.h" + +_ETL_BEGIN_NAMESPACE + +#if 0 + typedef _ETL::clock_base clock; + #ifdef ETL_CLOCK_PROCTIME_DESC_CLASS + #define ETL_CLOCK_PROCTIME + typedef clock_base clock_proctime; + #endif + #ifdef ETL_CLOCK_REALTIME_DESC_CLASS + #define ETL_CLOCK_REALTIME + typedef clock_base clock_realtime; + #else + #warning No realtime clock description found. + #endif + +#else + class clock : public _ETL::clock_base { }; + #ifdef ETL_CLOCK_PROCTIME_DESC_CLASS + #define ETL_CLOCK_PROCTIME + class clock_proctime : public _ETL::clock_base { }; + #endif + #ifdef ETL_CLOCK_REALTIME_DESC_CLASS + #define ETL_CLOCK_REALTIME + class clock_realtime : public _ETL::clock_base { }; + #else + #warning No realtime clock description found. + #endif +#endif + +_ETL_END_NAMESPACE + +//using etl::clock; + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/etl_config.h b/ETL/tags/0.61.06/ETL/etl_config.h new file mode 100644 index 0000000..9be9f00 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/etl_config.h @@ -0,0 +1,70 @@ + + +#ifndef __ETL_CONFIG_H +#define __ETL_CONFIG_H + +#include "etl_profile.h" +#include + +#ifndef ETL_NAMESPACE +# define ETL_NAMESPACE etl +#endif + +#if defined(WORDS_BIGENDIAN) && !defined(ETL_BIGENDIAN) +#define ETL_BIGENDIAN +#endif + +#ifdef WIN32 +#define ETL_DIRECTORY_SEPARATOR '\\' +#else +#define ETL_DIRECTORY_SEPARATOR '/' +#endif + +#ifndef ETL_FLAG_NONAMESPACE +# define _ETL ETL_NAMESPACE +# define _ETL_BEGIN_NAMESPACE namespace _ETL { +# define _ETL_END_NAMESPACE }; +# define _STD_BEGIN_NAMESPACE namespace std { +# define _STD_END_NAMESPACE }; +#else +# define _ETL +# define _ETL_BEGIN_NAMESPACE +# define _ETL_END_NAMESPACE +# define _STD_BEGIN_NAMESPACE +# define _STD_END_NAMESPACE +#endif + +#define _ETL_BEGIN_CDECLS extern "C" { +#define _ETL_END_CDECLS } + +#ifdef _REENTRANT +#define ETL_REENTRANT 1 +#endif + +/* If __FUNC__ is not defined, +** try to define it. If we cannot, +** then just leave it undefined. +*/ +#ifndef __FUNC__ +/* + * # if defined __cplusplus ? __GNUC_PREREQ (2, 6) : __GNUC_PREREQ (2, 4) +# define __FUNC__ __PRETTY_FUNCTION__ +# else +# if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L +# define __FUNC__ __func__ +# endif +# endif +*/ +#endif + +#ifdef __GNUG__ +#define ETL_DEPRECATED_FUNCTION __attribute__ ((deprecated)) +#else +#define ETL_DEPRECATED_FUNCTION +#endif + +#ifndef NULL +#define NULL 0 +#endif + +#endif diff --git a/ETL/tags/0.61.06/ETL/etl_profile_.h.in b/ETL/tags/0.61.06/ETL/etl_profile_.h.in new file mode 100644 index 0000000..6b21634 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/etl_profile_.h.in @@ -0,0 +1,138 @@ +/* ETL/etl_profile_.h.in. Generated from configure.ac by autoheader. */ + + +// We want to be autoconf/autoheader friendly, so +// if the developer has already included an +// autoheader-generated configuration script, +// we can assume that the user knew what they +// were doing and let them use their own config.h. +//#ifndef PACKAGE_TARNAME + + +/* Define to 1 if you have the `CreateThread' function. */ +#undef HAVE_CREATETHREAD + +/* Define to 1 if you have the `fork' function. */ +#undef HAVE_FORK + +/* Define to 1 if you have the `gettimeofday' function. */ +#undef HAVE_GETTIMEOFDAY + +/* Define to 1 if you have the header file. */ +#undef HAVE_INTTYPES_H + +/* Define to 1 if you have the `kill' function. */ +#undef HAVE_KILL + +/* Define to 1 if you have the `kernel32' library (-lkernel32). */ +#undef HAVE_LIBKERNEL32 + +/* Define to 1 if you have the `pthread' library (-lpthread). */ +#undef HAVE_LIBPTHREAD + +/* Define to 1 if you have the `user32' library (-luser32). */ +#undef HAVE_LIBUSER32 + +/* Define to 1 if you have the header file. */ +#undef HAVE_MEMORY_H + +/* Define to 1 if you have the `pipe' function. */ +#undef HAVE_PIPE + +/* Define to 1 if you have the `pthread_create' function. */ +#undef HAVE_PTHREAD_CREATE + +/* Define to 1 if you have the header file. */ +#undef HAVE_PTHREAD_H + +/* Define to 1 if you have the `pthread_rwlock_init' function. */ +#undef HAVE_PTHREAD_RWLOCK_INIT + +/* Define to 1 if you have the `pthread_yield' function. */ +#undef HAVE_PTHREAD_YIELD + +/* Define to 1 if you have the `QueryPerformanceCounter' function. */ +#undef HAVE_QUERYPERFORMANCECOUNTER + +/* Define to 1 if you have the header file. */ +#undef HAVE_SCHED_H + +/* Define to 1 if you have the `sched_yield' function. */ +#undef HAVE_SCHED_YIELD + +/* Define to 1 if you have the `sscanf' function. */ +#undef HAVE_SSCANF + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDINT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDLIB_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRINGS_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRING_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_STAT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TIMES_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TIME_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TYPES_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_UNISTD_H + +/* Define to 1 if you have the `vasprintf' function. */ +#undef HAVE_VASPRINTF + +/* Define to 1 if you have the `vsnprintf' function. */ +#undef HAVE_VSNPRINTF + +/* Define to 1 if you have the `vsprintf' function. */ +#undef HAVE_VSPRINTF + +/* Define to 1 if you have the `vsscanf' function. */ +#undef HAVE_VSSCANF + +/* Define to 1 if you have the header file. */ +#undef HAVE_WINDOWS_H + +/* Define to 1 if you have the `__clone' function. */ +#undef HAVE___CLONE + +/* Define to the address where bug reports for this package should be sent. */ +#undef PACKAGE_BUGREPORT + +/* Define to the full name of this package. */ +#undef PACKAGE_NAME + +/* Define to the full name and version of this package. */ +#undef PACKAGE_STRING + +/* Define to the one symbol short name of this package. */ +#undef PACKAGE_TARNAME + +/* Define to the version of this package. */ +#undef PACKAGE_VERSION + +/* Define to 1 if you have the ANSI C header files. */ +#undef STDC_HEADERS + +/* Define to 1 if your processor stores words with the most significant byte + first (like Motorola and SPARC, unlike Intel and VAX). */ +#undef WORDS_BIGENDIAN + +/* define if the vsnprintf function is mangled */ +#undef vsnprintf + + +//#endif // ifndef PACKAGE_TARNAME + diff --git a/ETL/tags/0.61.06/ETL/fastangle b/ETL/tags/0.61.06/ETL/fastangle new file mode 100644 index 0000000..5f586a6 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/fastangle @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Fast Angle Abstraction Class +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __FASTANGLE__ +#define __FASTANGLE__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_fastangle.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/fixed b/ETL/tags/0.61.06/ETL/fixed new file mode 100644 index 0000000..3e83c41 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/fixed @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Fixed-Point Math Class +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __FIXED__ +#define __FIXED__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_fixed.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/gaussian b/ETL/tags/0.61.06/ETL/gaussian new file mode 100644 index 0000000..35d2ae8 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/gaussian @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Gaussian Blur Template +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __GAUSSIAN__ +#define __GAUSSIAN__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_gaussian.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/handle b/ETL/tags/0.61.06/ETL/handle new file mode 100644 index 0000000..d957f76 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/handle @@ -0,0 +1,47 @@ +// -*- C++ -*- +/* === E T L =============================================================== */ +/*! \file handle +** $Id$ +** \brief Template Object Handle +** +** \legal +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** Copyright (c) 2008 Chris Moore +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** \endlegal +*/ +/* ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __HANDLE__ +#define __HANDLE__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +// include the next line in an attempt to increase stability +// it seems to make things much *less* stable on MS Windows +#ifndef _WIN32 +#define ETL_LOCK_REFCOUNTS +#endif + +#ifdef ETL_LOCK_REFCOUNTS +# include "mutex" +#endif + +#include "_handle.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/hermite b/ETL/tags/0.61.06/ETL/hermite new file mode 100644 index 0000000..d6b803a --- /dev/null +++ b/ETL/tags/0.61.06/ETL/hermite @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Hermite Curve Class +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __HERMITE__ +#define __HERMITE__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_hermite.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/ipc b/ETL/tags/0.61.06/ETL/ipc new file mode 100644 index 0000000..3a6c168 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/ipc @@ -0,0 +1,41 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Inter-Process Commumnication Classes +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __IPC__ +#define __IPC__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_mutex_null.h" + +#include "_mutex_pthreads.h" + +#include "_condition.h" +#include "_rwlock.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/misc b/ETL/tags/0.61.06/ETL/misc new file mode 100644 index 0000000..239862f --- /dev/null +++ b/ETL/tags/0.61.06/ETL/misc @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Misc +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __MISC__ +#define __MISC__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_misc.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/mutex b/ETL/tags/0.61.06/ETL/mutex new file mode 100644 index 0000000..f7a9939 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/mutex @@ -0,0 +1,42 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Mutex Classes +** $Id$ +** +** Copyright (c) 2008 Chris Moore +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __MUTEX__ +#define __MUTEX__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#ifdef HAVE_LIBPTHREAD +# include "_mutex_pthreads_simple.h" +#else +#ifdef _WIN32 +# include "_mutex_win32.h" +#endif +#endif + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/pen b/ETL/tags/0.61.06/ETL/pen new file mode 100644 index 0000000..78c32c3 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/pen @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Pen Template Class +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __PEN__ +#define __PEN__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_pen.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/random b/ETL/tags/0.61.06/ETL/random new file mode 100644 index 0000000..7bd681a --- /dev/null +++ b/ETL/tags/0.61.06/ETL/random @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Random Number Generator Class +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __RANDOM__ +#define __RANDOM__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_random.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/rect b/ETL/tags/0.61.06/ETL/rect new file mode 100644 index 0000000..2c8b5c5 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/rect @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Rect +** $Id$ +** +** Copyright (c) 2002 Adrian Bentley +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __RECT__ +#define __RECT__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_rect.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/ref_count b/ETL/tags/0.61.06/ETL/ref_count new file mode 100644 index 0000000..1df6fc0 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/ref_count @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __REF_COUNT__ +#define __REF_COUNT__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_ref_count.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/smach b/ETL/tags/0.61.06/ETL/smach new file mode 100644 index 0000000..32bd45c --- /dev/null +++ b/ETL/tags/0.61.06/ETL/smach @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** State Machine Abstraction Class +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __SMACH__ +#define __SMACH__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_smach.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/smart_ptr b/ETL/tags/0.61.06/ETL/smart_ptr new file mode 100644 index 0000000..9209811 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/smart_ptr @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Template Smart Pointer +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __SMART_PTR__ +#define __SMART_PTR__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_smart_ptr.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/spline b/ETL/tags/0.61.06/ETL/spline new file mode 100644 index 0000000..9c8452e --- /dev/null +++ b/ETL/tags/0.61.06/ETL/spline @@ -0,0 +1,37 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Spline Class +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __SPLINE__ +#define __SPLINE__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_bspline.h" +#include "_curve.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/status b/ETL/tags/0.61.06/ETL/status new file mode 100644 index 0000000..f17161d --- /dev/null +++ b/ETL/tags/0.61.06/ETL/status @@ -0,0 +1,38 @@ +#ifdef THIS_CODE_IS_NOT_USED +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Status Callback Class +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __STATUS__ +#define __STATUS__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_status.h" + +/* === E N D =============================================================== */ + +#endif +#endif /* THIS_CODE_IS_NOT_USED */ diff --git a/ETL/tags/0.61.06/ETL/stringf b/ETL/tags/0.61.06/ETL/stringf new file mode 100644 index 0000000..36ae4be --- /dev/null +++ b/ETL/tags/0.61.06/ETL/stringf @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** stringf Procedure +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __STRINGF__ +#define __STRINGF__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_stringf.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/surface b/ETL/tags/0.61.06/ETL/surface new file mode 100644 index 0000000..79f484b --- /dev/null +++ b/ETL/tags/0.61.06/ETL/surface @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Surface Abstraction Class +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __SURFACE__ +#define __SURFACE__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_surface.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/thread b/ETL/tags/0.61.06/ETL/thread new file mode 100644 index 0000000..6aeb221 --- /dev/null +++ b/ETL/tags/0.61.06/ETL/thread @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Thread Abstraction Class +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __THREAD__ +#define __THREAD__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_thread.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/trivial b/ETL/tags/0.61.06/ETL/trivial new file mode 100644 index 0000000..efc7ebc --- /dev/null +++ b/ETL/tags/0.61.06/ETL/trivial @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Trivial Template Class +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __TRIVIAL__ +#define __TRIVIAL__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_trivial.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/ETL/value b/ETL/tags/0.61.06/ETL/value new file mode 100644 index 0000000..b19739c --- /dev/null +++ b/ETL/tags/0.61.06/ETL/value @@ -0,0 +1,36 @@ +// -*- C++ -*- +/*! ======================================================================== +** Extended Template and Library +** Generic Value Template +** $Id$ +** +** Copyright (c) 2002 Adrian Bentley +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __VALUE__ +#define __VALUE__ + +/* === H E A D E R S ======================================================= */ + +#include "etl_config.h" + +#include "_value.h" + +/* === E N D =============================================================== */ + +#endif diff --git a/ETL/tags/0.61.06/Makefile.am b/ETL/tags/0.61.06/Makefile.am new file mode 100644 index 0000000..84d0c4e --- /dev/null +++ b/ETL/tags/0.61.06/Makefile.am @@ -0,0 +1,78 @@ +# $Id$ + +MAINTAINERCLEANFILES=COPYING INSTALL config/config.guess config/config.sub config/ltmain.sh config/install-sh config/mkinstalldirs config/aclocal.m4 config/missing config/texinfo.tex config/depcomp aclocal.m4 config.h.in configure stamp-h.in Makefile.in config.log config.status .doc_stamp .DS_Store include/etl_profile.h.in doxygen.cfg + +SUBDIRS=ETL test + +# Install the pkg-config file: +pkgconfigdir = $(libdir)/pkgconfig +pkgconfig_DATA = ETL.pc + +#Install the -config/m4 alternative to pkg-config: +bin_SCRIPTS=ETL-config +aclocaldir = $(prefix)/share/aclocal + +ACLOCAL_AMFLAGS = -I m4 + +EXTRA_DIST=COPYING m4/subs.m4 config/depcomp m4/cxx_macros.m4 ETL.pbproj/project.pbxproj ETL.pbproj/etl_profile.h ETL.pbproj/frameworkfix.cpp ETL-config.in m4/ETL.m4 doxygen.cfg.in doxygen.cfg ETL.pc.in + +CVS=cvs +SVN=svn +TAG=@PACKAGE_TARNAME@_@VERSION_MAJ@_@VERSION_MIN@_@VERSION_REV@ + +GREP=grep + +PRINTF=printf + +SH=sh + +DOXYGEN=doxygen + +stats: + -@echo + -@echo -- Stats + -@echo + -@$(PRINTF) "Total lines: " + -@wc -l $(shell find $(top_srcdir)/ETL -name '*.[ch]*') | $(GREP) total + -@$(PRINTF) "Total size: " + -@du -hcs $(shell find $(top_srcdir)/ETL -name '*.[ch]*') | $(GREP) total + -@echo + +tagstable: + -$(SVN) delete $(SVN_REPOSITORY)/tags/stable -m "Stable Tag: Removing old tag" + $(SVN) copy $(top_srcdir) $(SVN_REPOSITORY)/tags/stable -m "Stable Tag: Copying everything over" + +tagrelease: + $(SVN) copy $(top_srcdir) $(SVN_REPOSITORY)/tags/$(TAG) -m "Release $(TAG)" + +ChangeLog: + -svn update + svn2cl --include-rev || touch ChangeLog + +listfixmes: + -@echo + -@echo -- List of pending FIXMEs + -@echo + -@$(GREP) FIXME -n $(shell find $(top_srcdir) -name '*.[ch]*') + -@echo + +listhacks: + -@echo + -@echo -- List of pending HACKs + -@echo + -@$(GREP) HACK -n $(shell find $(top_srcdir) -name '*.[ch]*') + -@echo + +run: check + +.doc_stamp: doxygen.cfg + $(DOXYGEN) doxygen.cfg + touch .doc_stamp + +html: .doc_stamp + +rtf: .doc_stamp + +docs: html + +.PHONY: stats tagstable tagrelease listfixmes listhacks check docs pdf html rtf diff --git a/ETL/tags/0.61.06/NEWS b/ETL/tags/0.61.06/NEWS new file mode 100644 index 0000000..6b4ca1a --- /dev/null +++ b/ETL/tags/0.61.06/NEWS @@ -0,0 +1,45 @@ + ETL releases + +More detailed notes are available on the releases page: + +http://synfig.org/Releases + + 0.04.11 (SVN 1837) - March 3, 2008 - Bug fixes + + * Update the website URL to synfig.org instead of synfig.com + * Removed the 'bootstrap' script for building. Use autoreconf instead + * Fixed errors and warnings detected by a pre-release version of GCC 4.3 + * Make ETL-config a wrapper around pkg-config. + * Wrap the refcounting stuff in mutexes + * Don't wrap angles by 360 degrees + * Minor cleanups and typo fixes + + 0.04.10 (SVN 878) - October 10, 2007 - Bug fixes + + * Fix dirname for absolute paths (#1793306) + * Fix minor issues and typos + * Various changes to the 'angle' code. 89+360 < 90; 90 == 90+360, !360 is true, etc. + * Resolve confusion about whether angles are clockwise, and whether they're stored in radians. + * Fix 'make check' for 'fixed' so that it doesn't fail. Tidy the output, too. + + 0.04.09 (SVN 530) - June 20, 2006 - Bug fixes + + * Fix amd64 issue + * Some tests fixes + * Misc bug fixes + * Add better code for finding closest point to a bezier (#1672033) + + 0.04.08 (SVN 139) - February 27, 2006 - Bug fixes + + * Update doxygen configuration + * Misc bug fixes + + 0.04.07 (SVN 52) - November 6, 2005 - Bug fixes + + * Add ./configure options for debug, warnings, optimisation, profiling + * Misc bug fixes + + 0.04.06 - November 3, 2005 - First release! + + * First release! + diff --git a/ETL/tags/0.61.06/README b/ETL/tags/0.61.06/README new file mode 100644 index 0000000..90e4fdd --- /dev/null +++ b/ETL/tags/0.61.06/README @@ -0,0 +1,36 @@ + ETL -- Extended Template Library + +ETL is a multi-platform class and template library designed to add +new datatypes and functions which combine well with the existing +types and functions from the C++ Standard Template Library (STL). + +Web: http://synfig.org/ +SVN: http://svn.voria.com/code/ETL/ +Proj: http://sf.net/projects/synfig/ +IRC: irc://irc.freenode.net/synfig + +Please use the IRC channel and the sf.net tracker to get support and +report bugs, request features and submit patches. + +Copyright + +Copyright 2002 Robert B. Quattlebaum Jr. +Copyright 2002 Adrian Bentley +Copyright 2007 Chris Moore + +Licence + +This package is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License as +published by the Free Software Foundation; either version 2 of +the License, or (at your option) any later version. + +This package is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +or visit http://www.gnu.org/licenses/gpl.html diff --git a/ETL/tags/0.61.06/config/pkg-support/ETL-devel.info b/ETL/tags/0.61.06/config/pkg-support/ETL-devel.info new file mode 100755 index 0000000..4ba67fd --- /dev/null +++ b/ETL/tags/0.61.06/config/pkg-support/ETL-devel.info @@ -0,0 +1,14 @@ +Title @_PACKAGE_@ @_VERSION_@ +Version @_RELEASE_@ +Description @_PACKAGE_NAME_@ +DefaultLocation /Library/Frameworks +DeleteWarning +NeedsAuthorization YES +DisableStop NO +UseUserMask YES +Application NO +Relocatable YES +Required NO +InstallOnly NO +RequiresReboot NO +InstallFat NO diff --git a/ETL/tags/0.61.06/config/pkg-support/devel-resources/License.rtf b/ETL/tags/0.61.06/config/pkg-support/devel-resources/License.rtf new file mode 100755 index 0000000..52701d7 --- /dev/null +++ b/ETL/tags/0.61.06/config/pkg-support/devel-resources/License.rtf @@ -0,0 +1,10 @@ +{\rtf1\mac\ansicpg10000\cocoartf102 +{\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;\f1\fswiss\fcharset77 Helvetica;} +{\colortbl;\red255\green255\blue255;} +\vieww9000\viewh9000\viewkind0 +\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\ql\qnatural + +\f0\b\fs36 \cf0 This will be the license. +\f1\b0\fs24 \ +\ +I intend to licence this software under the LGPL. } \ No newline at end of file diff --git a/ETL/tags/0.61.06/config/pkg-support/devel-resources/ReadMe.rtf b/ETL/tags/0.61.06/config/pkg-support/devel-resources/ReadMe.rtf new file mode 100755 index 0000000..17874b1 --- /dev/null +++ b/ETL/tags/0.61.06/config/pkg-support/devel-resources/ReadMe.rtf @@ -0,0 +1,7 @@ +{\rtf1\mac\ansicpg10000\cocoartf102 +{\fonttbl\f0\fswiss\fcharset77 Helvetica;} +{\colortbl;\red255\green255\blue255;} +\margl1440\margr1440\vieww9000\viewh9000\viewkind0 +\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\ql\qnatural + +\f0\fs24 \cf0 This is the readme.} \ No newline at end of file diff --git a/ETL/tags/0.61.06/config/pkg-support/devel-resources/Welcome.rtf b/ETL/tags/0.61.06/config/pkg-support/devel-resources/Welcome.rtf new file mode 100755 index 0000000..50c42a5 --- /dev/null +++ b/ETL/tags/0.61.06/config/pkg-support/devel-resources/Welcome.rtf @@ -0,0 +1,6 @@ +{\rtf1\mac\ansicpg10000\cocoartf102 +{\fonttbl\f0\fswiss\fcharset77 Helvetica;} +{\colortbl;\red255\green255\blue255;} +\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\ql\qnatural + +\f0\fs24 \cf0 This is the welcome file.} \ No newline at end of file diff --git a/ETL/tags/0.61.06/config/pkg-support/devel-resources/install.sh b/ETL/tags/0.61.06/config/pkg-support/devel-resources/install.sh new file mode 100755 index 0000000..7cb2058 --- /dev/null +++ b/ETL/tags/0.61.06/config/pkg-support/devel-resources/install.sh @@ -0,0 +1,48 @@ +#!/bin/sh +# finish up the installation +# this script should be executed using the sudo command +# this file is copied to ETL-devel.post_install and ETL-devel.post_upgrade +# inside the .pkg bundle +echo "Running post-install script" +umask 022 +sleep 1 + +RESOURCE_DIR=`dirname $0` + +cd RESOURCE_DIR + +echo "Creating ETL-config script" +sleep 1 +[ -d /usr/local ] || mkdir /usr/local +[ -d /usr/local/bin ] || mkdir /usr/local/bin +[ -d /usr/local/include ] || mkdir /usr/local/include +[ -d /usr/local/lib ] || mkdir /usr/local/lib +[ -d /usr/local/sbin ] || mkdir /usr/local/sbin + +# If we already have a directory called ETL in our include directory, nuke it +[ -d /usr/local/include/ETL ] && rm -fr /usr/local/include/ETL + +ln -s /usr/local/include/ETL /Library/Frameworks/ETL.framework/Headers +sed ' +s:@exec_prefix@:/usr/local:g; +s:@prefix@:/usr/local:g; +s:@bindir@:$exec_prefix/bin:g; +s:@libdir@:$exec_prefix/lib:g; +s:@includedir@:$prefix/include:g; +s:@VERSION@:@_VERSION_@:g; +s:@PACKAGE@:@_PACKAGE_@:g; +s:@LIBS@::g; +' < $RESOURCE_DIR/ETL-config.in > /usr/local/bin/ETL-config +chmod 775 /usr/local/bin/ETL-config + +echo "Done with shell script" +sleep 1 + +exit 0 + + +#echo "Precompiling Headers" +#/usr/bin/cc -precomp ~/Library/Frameworks/SDL.framework/Headers/SDL.h -o ~/Library/Frameworks/SDL.framework/Headers/SDL.p + +# open up the README file +#open ~/"Readme SDL Developer.txt" diff --git a/ETL/tags/0.61.06/configure.ac b/ETL/tags/0.61.06/configure.ac new file mode 100644 index 0000000..cb7fdaa --- /dev/null +++ b/ETL/tags/0.61.06/configure.ac @@ -0,0 +1,97 @@ +# $Id$ + +# -- I N I T -------------------------------------------------- + +AC_INIT([Extended Template Library],[0.4.11],[http://synfig.org/Bugs],[ETL]) +AC_REVISION + +AC_CONFIG_AUX_DIR(config) +AM_CONFIG_HEADER(ETL/etl_profile_.h) +AC_CANONICAL_HOST +AC_CANONICAL_TARGET + +AM_INIT_AUTOMAKE([ no-define ]) +AM_MAINTAINER_MODE + +# -- V A R I A B L E S ---------------------------------------- + +debug="no" + +SVN_REPOSITORY=http://svn.voria.com/code/ETL +AC_SUBST(SVN_REPOSITORY) + +# -- A R G U M E N T S ---------------------------------------- + + +# -- P R O G R A M S ------------------------------------------ + +AC_PROG_CC +AC_PROG_CXX +AC_PROG_INSTALL +AC_PROG_RANLIB + +AC_LANG_CPLUSPLUS + +AC_ARG_WARNINGS +AC_ARG_DEBUG +AC_ARG_OPTIMIZATION +AC_ARG_PROFILING + +AC_WIN32_QUIRKS + +# -- L I B R A R I E S ---------------------------------------- + +# -- H E A D E R S -------------------------------------------- + +AH_TOP([ +// We want to be autoconf/autoheader friendly, so +// if the developer has already included an +// autoheader-generated configuration script, +// we can assume that the user knew what they +// were doing and let them use their own config.h. +//#ifndef PACKAGE_TARNAME +]) + +AH_BOTTOM([ +//#endif // ifndef PACKAGE_TARNAME +]) + + +# -- T Y P E S & S T R U C T S -------------------------------- + +# -- F U N C T I O N S ---------------------------------------- + +ETL_DEPS +AC_CHECK_FUNCS([fork]) +AC_CHECK_FUNCS([kill]) +AC_CHECK_FUNCS([pipe]) + +# -- O U T P U T ---------------------------------------------- + +AC_SUBST(CFLAGS) +AC_SUBST(CPPFLAGS) +AC_SUBST(LDFLAGS) + +AC_OUTPUT( +ETL-config +Makefile +ETL/Makefile +test/Makefile +ETL.pc +doxygen.cfg +) + +# -- S U M M A R Y -------------------------------------------- + +echo " +$PACKAGE_NAME v.$VERSION +Configuration Summary +- - - - - - + +Install Prefix -------------------> $prefix +Target Platform ------------------> $host +Debug Mode -----------------------> $debug + +"'$'"CXX ------------------------------> '$CXX' +"'$'"CXXFLAGS -------------------------> '$CXXFLAGS' +" diff --git a/ETL/tags/0.61.06/doxygen.cfg.in b/ETL/tags/0.61.06/doxygen.cfg.in new file mode 100644 index 0000000..3ac5c4e --- /dev/null +++ b/ETL/tags/0.61.06/doxygen.cfg.in @@ -0,0 +1,1220 @@ +# Doxyfile 1.4.6 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = @PACKAGE@ + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = @VERSION@ + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = doc + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create +# 4096 sub-directories (in 2 levels) under the output directory of each output +# format and will distribute the generated files over these directories. +# Enabling this option can be useful when feeding doxygen a huge amount of +# source files, where putting all generated files in the same directory would +# otherwise cause performance problems for the file system. + +CREATE_SUBDIRS = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, +# Dutch, Finnish, French, German, Greek, Hungarian, Italian, Japanese, +# Japanese-en (Japanese with English messages), Korean, Korean-en, Norwegian, +# Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, +# Swedish, and Ukrainian. + +OUTPUT_LANGUAGE = English + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator +# that is used to form the text in various listings. Each string +# in this list, if found as the leading text of the brief description, will be +# stripped from the text and the result after processing the whole list, is +# used as the annotated text. Otherwise, the brief description is used as-is. +# If left blank, the following values are used ("$name" is automatically +# replaced with the name of the entity): "The $name class" "The $name widget" +# "The $name file" "is" "provides" "specifies" "contains" +# "represents" "a" "an" "the" + +ABBREVIATE_BRIEF = + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = NO + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user-defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the +# path to strip. + +STRIP_FROM_PATH = + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of +# the path mentioned in the documentation of a class, which tells +# the reader which header file to include in order to use a class. +# If left blank only the name of the header file containing the class +# definition is used. Otherwise one should specify the include paths that +# are normally passed to the compiler using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like the Qt-style comments (thus requiring an +# explicit @brief command for a brief description. + +JAVADOC_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen +# treat a multi-line C++ special comment block (i.e. a block of //! or /// +# comments) as a brief description. This used to be the default behaviour. +# The new default is to treat a multi-line C++ comment block as a detailed +# description. Set this tag to YES if you prefer the old behaviour instead. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the DETAILS_AT_TOP tag is set to YES then Doxygen +# will output the detailed description near the top, like JavaDoc. +# If set to NO, the detailed description appears after the member +# documentation. + +DETAILS_AT_TOP = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# re-implements. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce +# a new page for each member. If set to NO, the documentation of a member will +# be part of the file/class/namespace that contains it. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 4 + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user-defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = "legal=\if legal" \ + endlegal=\endif \ + "writeme=\todo This needs to be documented" \ + "stub=\todo this is a stub" + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C +# sources only. Doxygen will then generate output that is more tailored for C. +# For instance, some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java +# sources only. Doxygen will then generate output that is more tailored for Java. +# For instance, namespaces will be presented as packages, qualified scopes +# will look different, etc. + +OPTIMIZE_OUTPUT_JAVA = NO + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want to +# include (a tag file for) the STL sources as input, then you should +# set this tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. +# func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. + +BUILTIN_STL_SUPPORT = NO + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# Set the SUBGROUPING tag to YES (the default) to allow class member groups of +# the same type (for instance a group of public functions) to be put as a +# subgroup of that type (e.g. under the Public Functions section). Set it to +# NO to prevent subgrouping. Alternatively, this can be done per class using +# the \nosubgrouping command. + +SUBGROUPING = YES + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = YES + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = YES + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) +# defined locally in source files will be included in the documentation. +# If set to NO only classes defined in header files are included. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. When set to YES local +# methods, which are defined in the implementation section but not in +# the interface are included in the documentation. +# If set to NO (the default) only methods in the interface are included. + +EXTRACT_LOCAL_METHODS = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these classes will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all +# friend (class|struct|union) declarations. +# If set to NO (the default) these declarations will be included in the +# documentation. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any +# documentation blocks found inside the body of a function. +# If set to NO (the default) these blocks will be appended to the +# function's detailed documentation block. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put a list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = NO + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the +# brief documentation of file, namespace and class members alphabetically +# by member name. If set to NO (the default) the members will appear in +# declaration order. + +SORT_BRIEF_DOCS = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be +# sorted by fully-qualified names, including namespaces. If set to +# NO (the default), the class list will be sorted only by class name, +# not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the +# alphabetical list. + +SORT_BY_SCOPE_NAME = NO + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or +# disable (NO) the deprecated list. This list is created by putting +# \deprecated commands in the documentation. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consists of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +# If the sources in your project are distributed over multiple directories +# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy +# in the documentation. The default is NO. + +SHOW_DIRECTORIES = NO + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from the +# version control system). Doxygen will invoke the program by executing (via +# popen()) the command , where is the value of +# the FILE_VERSION_FILTER tag, and is the name of an input file +# provided by doxygen. Whatever the program writes to standard output +# is used as the file version. See the manual for examples. + +FILE_VERSION_FILTER = + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = YES + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some +# parameters in a documented function, or documenting parameters that +# don't exist or using markup commands wrongly. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be abled to get warnings for +# functions that are documented, but have no documentation for their parameters +# or return value. If set to NO (the default) doxygen will only warn about +# wrong or incomplete parameter documentation, but not about the absence of +# documentation. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. Optionally the format may contain +# $version, which will be replaced by the version of the file (if it could +# be obtained via FILE_VERSION_FILTER) + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = ETL + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank the following patterns are tested: +# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx +# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py + +FILE_PATTERNS = *.cpp \ + *.h \ + *.cxx \ + *.hxx \ + *.hpp + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used select whether or not files or +# directories that are symbolic links (a Unix filesystem feature) are excluded +# from the input. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. Note that the wildcards are matched +# against the file with absolute path, so to exclude all test directories +# for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. If FILTER_PATTERNS is specified, this tag will be +# ignored. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: +# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further +# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER +# is applied to all files. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse (i.e. when SOURCE_BROWSER is set to YES). + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. +# Note: To get rid of all source code in the generated output, make sure also +# VERBATIM_HEADERS is set to NO. + +SOURCE_BROWSER = YES + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES (the default) +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = YES + +# If the REFERENCES_RELATION tag is set to YES (the default) +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = YES + +# If the USE_HTAGS tag is set to YES then the references to source code +# will point to the HTML generated by the htags(1) tool instead of doxygen +# built-in source browser. The htags tool is part of GNU's global source +# tagging system (see http://www.gnu.org/software/global/global.html). You +# will need version 4.8.6 or higher. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = YES + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for +# each generated HTML page (for example: .htm,.php,.asp). If it is left blank +# doxygen will generate files with .html extension. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet. Note that doxygen will try to copy +# the style sheet file to the HTML output directory, so don't put your own +# stylesheet in the HTML output directory as well, or it will be erased! + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can +# be used to specify the file name of the resulting .chm file. You +# can add a path in front of the file if the result should not be +# written to the html output directory. + +CHM_FILE = + +# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can +# be used to specify the location (absolute path including file name) of +# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run +# the HTML help compiler on the generated index.hhp. + +HHC_LOCATION = + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the HTML help documentation and to the tree view. + +TOC_EXPAND = NO + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be +# generated containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, +# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are +# probably better off using the HTML help feature. + +GENERATE_TREEVIEW = NO + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = latex + +# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be +# invoked. If left blank `latex' will be used as the default command name. + +LATEX_CMD_NAME = latex + +# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to +# generate index for LaTeX. If left blank `makeindex' will be used as the +# default command name. + +MAKEINDEX_CMD_NAME = makeindex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = YES + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = YES + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +# If LATEX_HIDE_INDICES is set to YES then doxygen will not +# include the index chapters (such as File Index, Compound Index, etc.) +# in the output. + +LATEX_HIDE_INDICES = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimized for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assignments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. + +GENERATE_XML = NO + +# The XML_OUTPUT tag is used to specify where the XML pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `xml' will be used as the default path. + +XML_OUTPUT = xml + +# The XML_SCHEMA tag can be used to specify an XML schema, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_SCHEMA = + +# The XML_DTD tag can be used to specify an XML DTD, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_DTD = + +# If the XML_PROGRAMLISTING tag is set to YES Doxygen will +# dump the program listings (including syntax highlighting +# and cross-referencing information) to the XML output. Note that +# enabling this will significantly increase the size of the XML output. + +XML_PROGRAMLISTING = YES + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will +# generate an AutoGen Definitions (see autogen.sf.net) file +# that captures the structure of the code including all +# documentation. Note that this feature is still experimental +# and incomplete at the moment. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# configuration options related to the Perl module output +#--------------------------------------------------------------------------- + +# If the GENERATE_PERLMOD tag is set to YES Doxygen will +# generate a Perl module file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_PERLMOD = NO + +# If the PERLMOD_LATEX tag is set to YES Doxygen will generate +# the necessary Makefile rules, Perl scripts and LaTeX code to be able +# to generate PDF and DVI output from the Perl module output. + +PERLMOD_LATEX = NO + +# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be +# nicely formatted so it can be parsed by a human reader. This is useful +# if you want to understand what is going on. On the other hand, if this +# tag is set to NO the size of the Perl module output will be much smaller +# and Perl will parse it just the same. + +PERLMOD_PRETTY = YES + +# The names of the make variables in the generated doxyrules.make file +# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. +# This is useful so different doxyrules.make files included by the same +# Makefile don't overwrite each other's variables. + +PERLMOD_MAKEVAR_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_DEFINED tags. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. To prevent a macro definition from being +# undefined via #undef or recursively expanded use the := operator +# instead of the = operator. + +PREDEFINED = ETL_NO_DEPRECATED \ + DOXYGEN_SHOULD_SKIP_THIS \ + DOXYGEN_IS_RUNNING + +# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line, have an all uppercase name, and do not end with a semicolon. Such +# function macros are typically used for boiler-plate code, and will confuse +# the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES option can be used to specify one or more tagfiles. +# Optionally an initial location of the external documentation +# can be added for each tagfile. The format of a tag file without +# this location is as follows: +# TAGFILES = file1 file2 ... +# Adding location for the tag files is done as follows: +# TAGFILES = file1=loc1 "file2 = loc2" ... +# where "loc1" and "loc2" can be relative or absolute paths or +# URLs. If a location is present for each tag, the installdox tool +# does not have to be run to correct the links. +# Note that each tag file must have a unique name +# (where the name does NOT include the path) +# If a tag file is not located in the directory in which doxygen +# is run, you must also specify the path to the tagfile here. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed +# in the modules index. If set to NO, only the current project's groups will +# be listed. + +EXTERNAL_GROUPS = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base +# or super classes. Setting the tag to NO turns the diagrams off. Note that +# this option is superseded by the HAVE_DOT option below. This is only a +# fallback. It is recommended to install and use dot, since it yields more +# powerful graphs. + +CLASS_DIAGRAMS = YES + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = NO + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for groups, showing the direct groups dependencies + +GROUP_GRAPHS = YES + +# If the UML_LOOK tag is set to YES doxygen will generate inheritance and +# collaboration diagrams in a style similar to the OMG's Unified Modeling +# Language. + +UML_LOOK = NO + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = YES + +# If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will +# generate a call dependency graph for every global function or class method. +# Note that enabling this option will significantly increase the time of a run. +# So in most cases it will be better to enable call graphs for selected +# functions only using the \callgraph command. + +CALL_GRAPH = NO + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES +# then doxygen will show the dependencies a directory has on other directories +# in a graphical way. The dependency relations are determined by the #include +# relations between the files in the directories. + +DIRECTORY_GRAPH = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. Possible values are png, jpg, or gif +# If left blank png will be used. + +DOT_IMAGE_FORMAT = gif + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found in the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the +# graphs generated by dot. A depth value of 3 means that only nodes reachable +# from the root by following a path via at most 3 edges will be shown. Nodes +# that lay further from the root node will be omitted. Note that setting this +# option to 1 or 2 may greatly reduce the computation time needed for large +# code bases. Also note that a graph may be further truncated if the graph's +# image dimensions are not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH +# and MAX_DOT_GRAPH_HEIGHT). If 0 is used for the depth value (the default), +# the graph is not depth-constrained. + +MAX_DOT_GRAPH_DEPTH = 0 + +# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent +# background. This is disabled by default, which results in a white background. +# Warning: Depending on the platform used, enabling this option may lead to +# badly anti-aliased labels on the edges of a graph (i.e. they become hard to +# read). + +DOT_TRANSPARENT = NO + +# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output +# files in one run (i.e. multiple -o and -T options on the command line). This +# makes dot run faster, but since only newer versions of dot (>1.8.10) +# support this, this feature is disabled by default. + +DOT_MULTI_TARGETS = NO + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermediate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = NO diff --git a/ETL/tags/0.61.06/m4/ETL.m4 b/ETL/tags/0.61.06/m4/ETL.m4 new file mode 100644 index 0000000..7c807dd --- /dev/null +++ b/ETL/tags/0.61.06/m4/ETL.m4 @@ -0,0 +1,74 @@ +# ETL M4 Macro +# For GNU Autotools +# $Id$ +# +# By Robert B. Quattlebaum Jr. +# + +AC_DEFUN([ETL_DEPS], +[ + AC_C_BIGENDIAN + + AC_CHECK_LIB(user32, main) + AC_CHECK_LIB(kernel32, main) + AC_CHECK_LIB(pthread, main) + + AC_HEADER_STDC + + AC_CHECK_HEADERS(pthread.h) + AC_CHECK_HEADERS(sched.h) + AC_CHECK_HEADERS(sys/times.h) + AC_CHECK_HEADERS(sys/time.h) + AC_CHECK_HEADERS(unistd.h) + AC_CHECK_HEADERS(windows.h) + AC_CHECK_FUNCS([pthread_create]) + AC_CHECK_FUNCS([pthread_rwlock_init]) + AC_CHECK_FUNCS([pthread_yield]) + AC_CHECK_FUNCS([sched_yield]) + AC_CHECK_FUNCS([CreateThread]) + AC_CHECK_FUNCS([__clone]) + AC_CHECK_FUNCS([QueryPerformanceCounter]) + + AC_CHECK_FUNCS([gettimeofday]) + AC_CHECK_FUNCS([sscanf]) + AC_CHECK_FUNCS([vsscanf]) + AC_CHECK_FUNCS([vsprintf]) + AC_CHECK_FUNCS([vasprintf]) + AC_CHECK_FUNCS([vsnprintf],[],[ + AC_CHECK_FUNC([_vsnprintf],[ + AC_DEFINE(vsnprintf,_vsnprintf,[define if the vsnprintf function is mangled]) + AC_DEFINE(HAVE_VSNPRINTF,1) + ]) + ]) +]) + +AC_DEFUN([USING_ETL], +[ + AC_ARG_WITH(ETL-includes, + [ --with-ETL-includes Specify location of ETL headers],[ + CXXFLAGS="$CXXFLAGS -I$withval" + ]) + + AC_PATH_PROG(ETL_CONFIG,ETL-config,no) + + if test "$ETL_CONFIG" = "no"; then + no_ETL_config="yes" + $2 + else + AC_MSG_CHECKING([if $ETL_CONFIG works]) + if $ETL_CONFIG --libs >/dev/null 2>&1; then + ETL_VERSION="`$ETL_CONFIG --version`" + AC_MSG_RESULT([yes, $ETL_VERSION]) + CXXFLAGS="$CXXFLAGS `$ETL_CONFIG --cxxflags`" + $1 + else + AC_MSG_RESULT(no) + no_ETL_config="yes" + $2 + fi + fi + + ETL_DEPS +]) + + diff --git a/ETL/tags/0.61.06/m4/cxx_macros.m4 b/ETL/tags/0.61.06/m4/cxx_macros.m4 new file mode 100644 index 0000000..8fc247a --- /dev/null +++ b/ETL/tags/0.61.06/m4/cxx_macros.m4 @@ -0,0 +1,88 @@ +AC_DEFUN([AC_CXX_FUNCTION_NONTYPE_PARAMETERS], +[AC_CACHE_CHECK(whether the compiler supports function templates with non-type parameters, +ac_cv_cxx_function_nontype_parameters, +[AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([ +template class A {}; +template int f(const A& x) { return 0; } +],[A z; return f(z);], + ac_cv_cxx_function_nontype_parameters=yes, ac_cv_cxx_function_nontype_parameters=no) + AC_LANG_RESTORE +]) +if test "$ac_cv_cxx_function_nontype_parameters" = yes; then + AC_DEFINE(HAVE_FUNCTION_NONTYPE_PARAMETERS,, + [define if the compiler supports function templates with non-type parameters]) +fi +]) + +AC_DEFUN([AC_CXX_NAMESPACES], +[AC_CACHE_CHECK(whether the compiler implements namespaces, +ac_cv_cxx_namespaces, +[AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([namespace Outer { namespace Inner { int i = 0; }}], + [using namespace Outer::Inner; return i;], + ac_cv_cxx_namespaces=yes, ac_cv_cxx_namespaces=no) + AC_LANG_RESTORE +]) +if test "$ac_cv_cxx_namespaces" = yes; then + AC_DEFINE(HAVE_NAMESPACES,,[define if the compiler implements namespaces]) +fi +]) + +AC_DEFUN([AC_CXX_HAVE_COMPLEX], +[AC_CACHE_CHECK(whether the compiler has complex, +ac_cv_cxx_have_complex, +[AC_REQUIRE([AC_CXX_NAMESPACES]) + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([#include +#ifdef HAVE_NAMESPACES +using namespace std; +#endif],[complex a; complex b; return 0;], + ac_cv_cxx_have_complex=yes, ac_cv_cxx_have_complex=no) + AC_LANG_RESTORE +]) +if test "$ac_cv_cxx_have_complex" = yes; then + AC_DEFINE(HAVE_COMPLEX,,[define if the compiler has complex]) +fi +]) + +AC_DEFUN([AC_CXX_HAVE_SSTREAM], +[AC_CACHE_CHECK(whether the compiler has stringstream, +ac_cv_cxx_have_sstream, +[AC_REQUIRE([AC_CXX_NAMESPACES]) + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([#include +#ifdef HAVE_NAMESPACES +using namespace std; +#endif],[stringstream message; message << "Hello"; return 0;], + ac_cv_cxx_have_sstream=yes, ac_cv_cxx_have_sstream=no) + AC_LANG_RESTORE +]) +if test "$ac_cv_cxx_have_sstream" = yes; then + AC_DEFINE(HAVE_SSTREAM,,[define if the compiler has stringstream]) +fi +]) + +AC_DEFUN([AC_CXX_MUTABLE], +[AC_CACHE_CHECK(whether the compiler supports the mutable keyword, +ac_cv_cxx_mutable, +[AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([ +class A { mutable int i; + public: + int f (int n) const { i = n; return i; } + }; +],[A a; return a.f (1);], + ac_cv_cxx_mutable=yes, ac_cv_cxx_mutable=no) + AC_LANG_RESTORE +]) +if test "$ac_cv_cxx_mutable" = yes; then + AC_DEFINE(HAVE_MUTABLE,,[define if the compiler supports the mutable keyword]) +fi +]) + diff --git a/ETL/tags/0.61.06/m4/subs.m4 b/ETL/tags/0.61.06/m4/subs.m4 new file mode 100644 index 0000000..640dd02 --- /dev/null +++ b/ETL/tags/0.61.06/m4/subs.m4 @@ -0,0 +1,244 @@ + +## AC_ARG_WARNINGS() +## +## Provide the --enable-warnings configure argument, set to 'minimum' +## by default. +## +AC_DEFUN([AC_ARG_WARNINGS], +[ + AC_ARG_ENABLE([warnings], + [ --enable-warnings=[[none|minimum|maximum|hardcore]] + Control compiler pickyness. [[default=maximum]]], + [gtkmm_enable_warnings="$enableval"], + gtkmm_enable_warnings="maximum") + + AC_MSG_CHECKING([for compiler warning flags to use]) + + gtkmm_warning_flags='' + + case "$gtkmm_enable_warnings" in + none|no) gtkmm_warning_flags='';; + minimum|yes) gtkmm_warning_flags='-Wall -Wno-unused-parameter';; + maximum) gtkmm_warning_flags='-W -Wall';; + hardcore) gtkmm_warning_flags='-W -Wall -Werror';; + esac + + gtkmm_use_flags='' + + if test "x$gtkmm_warning_flags" != "x" + then + echo 'int foo() { return 0; }' > conftest.cc + + for flag in $gtkmm_warning_flags + do + # Test whether the compiler accepts the flag. GCC doesn't bail + # out when given an unsupported flag but prints a warning, so + # check the compiler output instead. + gtkmm_cxx_out="`$CXX $flag -c conftest.cc 2>&1`" + rm -f conftest.$OBJEXT + test "x${gtkmm_cxx_out}" = "x" && \ + gtkmm_use_flags="${gtkmm_use_flags:+$gtkmm_use_flags }$flag" + done + + rm -f conftest.cc + gtkmm_cxx_out='' + fi + + if test "x$gtkmm_use_flags" != "x" + then + for flag in $gtkmm_use_flags + do + case " $CXXFLAGS " in + *" $flag "*) ;; # don't add flags twice + *) CXXFLAGS="${CXXFLAGS:+$CXXFLAGS }$flag";; + esac + done + else + gtkmm_use_flags='none' + fi + + AC_MSG_RESULT([$gtkmm_use_flags]) +]) + + + + +AC_DEFUN([AC_ARG_DEBUG], +[ + AC_MSG_CHECKING([for debug flags]) + + AC_ARG_ENABLE(debug,[ --enable-debug Build in debugging mode],[ + debug=$enableval + ],[ + debug="no" + ]) + debug_flags='' + + case "$debug" in + yes) + debug_flags="-D_DEBUG -g" + ;; + half) + debug_flags="-DNDEBUG -g" + ;; + no|*) + debug_flags="-DNDEBUG -Wno-deprecated" + ;; + esac + + + CXXFLAGS="`echo $CXXFLAGS | sed s:-g::` $debug_flags" + CFLAGS="`echo $CFLAGS | sed s:-g::` $debug_flags" + + AC_MSG_RESULT([$debug_flags]) +]) + + + + +AC_DEFUN([AC_ARG_OPTIMIZATION], +[ + AC_MSG_CHECKING([for optimization flags]) + + AC_ARG_ENABLE(optimization,[ --enable-optimization=[[0,1,2,3,4]] Select optimization level (default=2)],[ + optimization=$enableval + ],[ + optimization="2" + ]) + optimization_flags='' + case "$optimization" in + 0|no) optimization_flags="-O0";; + 1) optimization_flags="-O1";; + 2|yes) optimization_flags="-O2";; + pass1) optimization_flags="-O2 -fprofile-arcs";; + pass2) optimization_flags="-O2 -fbranch-probabilities";; + 3) optimization_flags="-O3";; + *) optimization_flags="-O4";; + esac + CXXFLAGS="`echo $CXXFLAGS | sed 's:-O.::g'` $optimization_flags" + CFLAGS="`echo $CFLAGS | sed 's:-O.::g'` $optimization_flags" + AC_MSG_RESULT([$optimization_flags]) +]) + +AC_DEFUN([AC_ARG_PROFILE_ARCS], +[ + AC_MSG_CHECKING([for arc profiling]) + + AC_ARG_ENABLE(profile-arcs,[ --enable-profile-arcs Enable arc profiling],[ + profile_arcs=$enableval + ],[ + profile_arcs=no + ]) + + if test $profile_arcs = "yes" ; then { + CXXFLAGS="$CXXFLAGS -fprofile-arcs"; + CFLAGS="$CFLAGS -fprofile-arcs"; + } ; fi + + AC_MSG_RESULT([$profile_arcs]) +]) + +AC_DEFUN([AC_ARG_BRANCH_PROBABILITIES], +[ + AC_MSG_CHECKING([for branch-probabilities]) + + AC_ARG_ENABLE(branch-probabilities,[ --enable-branch-probabilities Enable branch-probabilities],[ + branch_probabilities=$enableval + ],[ + branch_probabilities=no + ]) + + if test $branch_probabilities = "yes" ; then { + CXXFLAGS="$CXXFLAGS -fbranch-probabilities"; + CFLAGS="$CFLAGS -fbranch-probabilities"; + } ; fi + + AC_MSG_RESULT([$branch_probabilities]) +]) + +AC_DEFUN([AC_ARG_PROFILING], +[ + AC_MSG_CHECKING([for profiling]) + + AC_ARG_ENABLE(profiling,[ --enable-profiling Enable profiling using gprof],[ + profiling=$enableval + ],[ + profiling=no + ]) + + if test $profiling = "yes" ; then { + CFLAGS="$CFLAGS -pg"; + CXXFLAGS="$CXXFLAGS -pg"; + LDFLAGS="$LDFLAGS -pg"; + LIBS="$LIBS"; + } ; fi + + AC_MSG_RESULT([$profiling]) +]) + +MINGW_FLAGS="-mno-cygwin" + + +AC_DEFUN([AC_WIN32_QUIRKS], +[ + +case "$host" in + *mingw*) + AC_MSG_CHECKING([the flavor of the compiler]) + if ( $CC --version | grep -q mingw ) ; then { + AC_MSG_RESULT([compiler is mingw special]) + LIBTOOL_PATCH_SED=" + s/dir=\"\$absdir\"/dir=\`cygpath -d -m \"\$absdir\"\`/; + s/absdir=\`cd \"\$dir\" && pwd\`/absdir=\`cygpath -d -m \"\$dir\"\`/; + s/# We need an absolute path/dir=\`cygpath -d -m \"\$dir\"\` # We need an absolute path/; + s- /usr/lib- C:/mingw/lib-g; + s-\"/lib -\"C:/mingw/lib -g; + s- /lib/ - -g; + "; + sys_lib_dlsearch_path_spec="C:/mingw/lib" + ac_default_prefix=`cygpath -d -m "$ac_default_prefix"`; + } else { + AC_MSG_RESULT([compiler is cygwin stock, adding -mno-cygwin]) + CPP="$CPP $MINGW_FLAGS" + CC="$CC $MINGW_FLAGS" + CXX="$CXX $MINGW_FLAGS -L/usr/$host/lib -I/usr/include/c++/3.3.3/$host" + CXXCPP="$CXXCPP $MINGW_FLAGS" + + +} ; fi + + LTCC="gcc" + CXXFLAGS="$CXXFLAGS -LC:/GTK/lib" + CFLAGS="$CFLAGS -LC:/GTK/lib" + LDFLAGS="$LDFLAGS -lole32 -no-undefined -Wl,--export-all-symbols -Wl,--subsystem=console -Wl,--enable-runtime-pseudo-reloc" +dnl LDFLAGS="$LDFLAGS -lole32 -no-undefined -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--subsystem=console -Wl,--enable-runtime-pseudo-reloc" + ;; + *cygwin*) + LDFLAGS="$LDFLAGS -lole32 -no-undefined -Wl,--export-all-symbols" +dnl LDFLAGS="$LDFLAGS -lole32 -no-undefined -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--subsystem=console" + CXXFLAGS="$CXXFLAGS -I/target/include" + CFLAGS="$CFLAGS -I/target/include" + ;; + powerpc-apple*) + echo Adding mac-specific optimization flags. . . + CXXFLAGS="$CXXFLAGS $G5OPTFLAGS" + ;; +esac + + +]) + +AC_DEFUN([AC_LIBTOOL_PATCH], +[ + +if [[ "$LIBTOOL_PATCH_SED""x" != "x" ]] ; then { + printf "Patching libtool... " + cat libtool | sed "$LIBTOOL_PATCH_SED" > libtool2 + rm libtool + mv libtool2 libtool + chmod +x libtool + AC_MSG_RESULT([patched]) +} fi ; + + +]) diff --git a/ETL/tags/0.61.06/test/Makefile.am b/ETL/tags/0.61.06/test/Makefile.am new file mode 100644 index 0000000..b598a8e --- /dev/null +++ b/ETL/tags/0.61.06/test/Makefile.am @@ -0,0 +1,28 @@ +# $Id$ + +MAINTAINERCLEANFILES=Makefile.in +AM_CXXFLAGS=@CXXFLAGS@ -I$(top_srcdir) -I$(top_builddir) +DEFAULT_INCLUDES=-I$(top_srcdir) -I$(top_builddir) +#TESTS=fixed clock handle angle random hermite stringf pen surface smart_ptr benchmark spline value +TESTS=fixed clock handle angle random hermite stringf pen surface smart_ptr benchmark + +#check_PROGRAMS=fixed handle clock angle random hermite stringf pen surface smart_ptr benchmark smach spline value +check_PROGRAMS=fixed handle clock angle random hermite stringf pen surface smart_ptr benchmark smach + +benchmark_SOURCES=benchmark.cpp +smart_ptr_SOURCES=smart_ptr.cpp +surface_SOURCES=surface.cpp +pen_SOURCES=pen.cpp +handle_SOURCES=handle.cpp +angle_SOURCES=angle.cpp +random_SOURCES=random.cpp +fixed_SOURCES=fixed.cpp +smach_SOURCES=smach.cpp +clock_SOURCES=clock.cpp +hermite_SOURCES=hermite.cpp +#spline_SOURCES=spline.cpp +stringf_SOURCES=stringf.cpp +#value_SOURCES=value.cpp + +# FIXME: fix compiler errors for the spline and value tests. +EXTRA_DIST=spline.cpp value.cpp diff --git a/ETL/tags/0.61.06/test/angle.cpp b/ETL/tags/0.61.06/test/angle.cpp new file mode 100644 index 0000000..a0ecac6 --- /dev/null +++ b/ETL/tags/0.61.06/test/angle.cpp @@ -0,0 +1,528 @@ +/*! ======================================================================== +** Extended Template and Library Test Suite +** Angle Class Test +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** Copyright (c) 2008 Chris Moore +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#include +#include +#include +#include +#include +#include + +/* === M A C R O S ========================================================= */ + +ETL_FASTANGLE_INIT(); + +using namespace std; +using namespace etl; + +/* === C L A S S E S ======================================================= */ + +int fastangle_test(void) +{ + int ret=0; + float largest_error; + + { + angle theta; + fastangle theta2; + float error; + largest_error=0.0f; + + for( + theta=angle::degrees(0),theta2=fastangle::degrees(0); + theta<=angle::degrees(360); + theta+=angle::degrees(10),theta2+=fastangle::degrees(10) + ) + { + error=(float)angle::sin(theta).get() -(float)fastangle::sin(theta2).get(); + /* + fprintf(stderr,"angle: sin(%d)=%f ;\tfastangle: sin(%d)=%f ;\t diff: %f\n", + (int)angle::degrees(theta), + (float)angle::sin(theta), + (int)fastangle::degrees(theta2), + (float)fastangle::sin(theta2), + error + ); + */ + if(error > largest_error) + largest_error=error; + if(error < -largest_error) + largest_error=-error; + + } + } + printf("fastangle: Largest SIN error: (+/-)%f\n",largest_error); + if(largest_error>0.075)ret++; + + { + angle theta; + fastangle theta2; + float error; + largest_error=0.0f; + + for( + theta=angle::degrees(0),theta2=fastangle::degrees(0); + theta<=angle::degrees(360); + theta+=angle::degrees(10),theta2+=fastangle::degrees(10) + ) + { + error=(float)angle::cos(theta).get() -(float)fastangle::cos(theta2).get(); + /* + fprintf(stderr,"angle: cos(%d)=%f ;\tfastangle: cos(%d)=%f ;\t diff: %f\n", + (int)angle::degrees(theta), + (float)angle::cos(theta), + (int)fastangle::degrees(theta2), + (float)fastangle::cos(theta2), + error + ); + */ + if(error > largest_error) + largest_error=error; + if(error < -largest_error) + largest_error=-error; + + } + } + printf("fastangle: Largest COS error: (+/-)%f\n",largest_error); + if(largest_error>0.075)ret++; + + { + double val; + float error; + largest_error=0.0f; + + for( + val=-1.0f; + val<1.0f; + val+=0.01 + ) + { + error=angle::radians(angle::sin(val)).get() -fastangle::radians(fastangle::sin(val)).get(); + /* + fprintf(stderr,"angle: asin(%f)=%frad ;\tfastangle: asin(%f)=%frad ;\t diff: %f\n", + val, + (float)(angle::radians)angle::sin(val), + val, + (float)(fastangle::radians)fastangle::sin(val), + error + ); + */ + if(error > largest_error) + largest_error=error; + if(error < -largest_error) + largest_error=-error; + + } + } + printf("fastangle: Largest ASIN error: (+/-)%frad\n",largest_error); + if(largest_error>0.075)ret++; + + + { + double val; + float error; + largest_error=0.0f; + + for( + val=-1.0f; + val<1.0f; + val+=0.01 + ) + { + error=angle::radians(angle::cos(val)).get() -fastangle::radians(fastangle::cos(val)).get(); + /* + fprintf(stderr,"angle: acos(%f)=%frad ;\tfastangle: acos(%f)=%frad ;\t diff: %f\n", + val, + (float)(angle::radians)angle::cos(val), + val, + (float)(fastangle::radians)fastangle::cos(val), + error + ); + */ + if(error > largest_error) + largest_error=error; + if(error < -largest_error) + largest_error=-error; + + } + } + printf("fastangle: Largest ACOS error: (+/-)%frad\n",largest_error); + if(largest_error>0.075)ret++; + + + { + angle theta; + fastangle theta2; + float error; + largest_error=0.0f; + + for( + theta=angle::degrees(0),theta2=fastangle::degrees(0); + theta largest_error) + largest_error=error; + if(error < -largest_error) + largest_error=-error; + + } + } + printf("fastangle: Largest TAN error: (+/-)%f\n",largest_error); + if(largest_error>0.75)ret++; + + { + double val; + float error; + largest_error=0.0f; + + for( + val=-4.0f; + val<4.0f; + val+=0.1 + ) + { + error=angle::radians(angle::tan(val)).get() -fastangle::radians(fastangle::tan(val)).get(); + /* + fprintf(stderr,"angle: atan(%f)=%frad ;\tfastangle: atan(%f)=%frad ;\t diff: %f\n", + val, + (float)(angle::radians)angle::tan(val), + val, + (float)(fastangle::radians)fastangle::tan(val), + error + ); + */ + if(error > largest_error) + largest_error=error; + if(error < -largest_error) + largest_error=-error; + + } + } + printf("fastangle: Largest ATAN error: (+/-)%frad\n",largest_error); + if(largest_error>0.075)ret++; + + + { + angle theta; + float error; + largest_error=0.0f; + + for( + theta=angle::degrees(-179); + theta largest_error) + largest_error=error; + if(error < -largest_error) + largest_error=-error; + + } + } + printf("fastangle: Largest ATAN2 error: (+/-)%frad\n",largest_error); + if(largest_error>0.075)ret++; + + printf("constant tests: %f==%f\n", + (float)angle::degrees(angle::tan(1.01)).get(), + (float)fastangle::degrees(fastangle::tan(1.01)).get()); + printf("constant tests: %f==%f\n", + (float)angle::degrees(angle::tan(-1.0)).get(), + (float)fastangle::degrees(fastangle::tan(-1.0)).get()); + + return ret; +} + +template +void angle_cos_speed_test(void) +{ + Angle a,b,c,d; + float tmp,tmp2; + + for(tmp=-1.0;tmp<1.0;tmp+=0.000002) + { + a=(typename Angle::cos)(tmp); + b=(typename Angle::cos)(tmp); + c=(typename Angle::cos)(tmp); + d=(typename Angle::cos)(tmp); + tmp2=((typename Angle::cos)(a)).get(); + tmp2=((typename Angle::cos)(b)).get(); + tmp2=((typename Angle::cos)(c)).get(); + tmp2=((typename Angle::cos)(d)).get(); + } +} +template +void angle_sin_speed_test(void) +{ + Angle a,b,c,d; + float tmp,tmp2; + + for(tmp=-1.0;tmp<1.0;tmp+=0.000002) + { + a=(typename Angle::sin)(tmp); + b=(typename Angle::sin)(tmp); + c=(typename Angle::sin)(tmp); + d=(typename Angle::sin)(tmp); + tmp2=((typename Angle::sin)(a)).get(); + tmp2=((typename Angle::sin)(b)).get(); + tmp2=((typename Angle::sin)(c)).get(); + tmp2=((typename Angle::sin)(d)).get(); + } +} +template +void angle_tan_speed_test(void) +{ + Angle a,b,c,d; + float tmp,tmp2; + + for(tmp=-1.0;tmp<1.0;tmp+=0.000002) + { + a=(typename Angle::tan)(tmp); + b=(typename Angle::tan)(tmp); + c=(typename Angle::tan)(tmp); + d=(typename Angle::tan)(tmp); + tmp2=((typename Angle::tan)(a)).get(); + tmp2=((typename Angle::tan)(b)).get(); + tmp2=((typename Angle::tan)(c)).get(); + tmp2=((typename Angle::tan)(d)).get(); + } +} +template +void angle_atan2_speed_test(void) +{ + Angle a,b,c; + float x,y; + + for(y=-10.0;y<10.0;y+=0.05) + for(x=-10.0;x<10.0;x+=0.05) + { + a=mytan(y,x); + a=mytan(x,y); + b=mytan(y,x); + b=mytan(x,y); + c=mytan(y,x); + c=mytan(x,y); + a=mytan(y,x); + a=mytan(x,y); + b=mytan(y,x); + b=mytan(x,y); + c=mytan(y,x); + c=mytan(x,y); + } +} + +int fastangle_speed_test(void) +{ + int ret=0; + float + angle_cos_time, + fastangle_cos_time, + angle_tan_time, + fastangle_tan_time, + angle_atan2_time, + fastangle_atan2_time, + angle_sin_time, + fastangle_sin_time ; + + etl::clock MyTimer; + + MyTimer.reset(); + angle_cos_speed_test(); + angle_cos_time=MyTimer(); + printf("angle: Cosine test: %f seconds\n",angle_cos_time); + + MyTimer.reset(); + angle_cos_speed_test(); + fastangle_cos_time=MyTimer(); + printf("fastangle: Cosine test: %f seconds\n",fastangle_cos_time); + printf("fastangle is %.02f%% faster\n",(angle_cos_time/fastangle_cos_time)*100.0-100.0); + + MyTimer.reset(); + angle_sin_speed_test(); + angle_sin_time=MyTimer(); + printf("angle: Sine test: %f seconds\n",angle_sin_time); + + MyTimer.reset(); + angle_sin_speed_test(); + fastangle_sin_time=MyTimer(); + printf("fastangle: Sine test: %f seconds\n",fastangle_sin_time); + printf("fastangle is %.02f%% faster\n",(angle_sin_time/fastangle_sin_time)*100.0-100.0); + + MyTimer.reset(); + angle_tan_speed_test(); + angle_tan_time=MyTimer(); + printf("angle: Tangent test: %f seconds\n",angle_tan_time); + + MyTimer.reset(); + angle_tan_speed_test(); + fastangle_tan_time=MyTimer(); + printf("fastangle: Tangent test: %f seconds\n",fastangle_tan_time); + printf("fastangle is %.02f%% faster\n",(angle_tan_time/fastangle_tan_time)*100.0-100.0); + + MyTimer.reset(); + angle_atan2_speed_test(); + angle_atan2_time=MyTimer(); + printf("angle: arcTangent2 test: %f seconds\n",angle_atan2_time); + + MyTimer.reset(); + angle_atan2_speed_test(); + fastangle_atan2_time=MyTimer(); + printf("fastangle: arcTangent2 test: %f seconds\n",fastangle_atan2_time); + printf("fastangle is %.02f%% faster\n",(angle_atan2_time/fastangle_atan2_time)*100.0-100.0); + + return ret; +} + +int angle_test() +{ + int ret=0; + float dist; + + dist=angle::deg(angle::deg(330).dist(angle::deg(30))).get(); + printf("angle: angular difference between 330deg and 30deg is %0.1fdeg\n",dist); + if(floor(dist+0.5)!=300) + { + printf("angle: error: should be 300deg!\n"); + ret++; + } + + dist=angle::deg(angle::deg(30).dist(angle::deg(330))).get(); + printf("angle: angular difference between 30deg and 330deg is %0.1fdeg\n",dist); + if(floor(dist+0.5)!=-300) + { + printf("angle: error: should be -300deg!\n"); + ret++; + } + + dist=angle::deg(angle::deg(30).dist(angle::deg(-30))).get(); + printf("angle: angular difference between 30deg and -30deg is %0.1fdeg\n",dist); + if(floor(dist+0.5)!=60) + { + printf("angle: error: should be 60deg!\n"); + ret++; + } + + dist=angle::deg(angle::deg(-30).dist(angle::deg(30))).get(); + printf("angle: angular difference between -30deg and 30deg is %0.1fdeg\n",dist); + if(floor(dist+0.5)!=-60) + { + printf("angle: error: should be -60deg!\n"); + ret++; + } + + dist=angle::deg(angle::deg(20).dist(angle::deg(195))).get(); + printf("angle: angular difference between 20deg and 195deg is %0.1fdeg\n",dist); + if(floor(dist+0.5)!=-175) + { + printf("angle: error: should be -175deg!\n"); + ret++; + } + + dist=angle::deg(angle::deg(20).dist(angle::deg(205))).get(); + printf("angle: angular difference between 20deg and 205deg is %0.1fdeg\n",dist); + if(floor(dist+0.5)!=-185) + { + printf("angle: error: should be -185deg!\n"); + ret++; + } + + int i; + + for(i=-1000;i<1000;i++) + { + dist=angle::deg(angle::deg(20+i+360).dist(angle::deg(205+i-360))).get(); + if(floor(dist+0.5)!=535) + { + printf("angle: error: Badness at %d!\n",i); + ret++; + } + + } + + for(i=-1000;i<1000;i++) + { + dist=angle::deg(angle::deg(20+i-360).dist(angle::deg(195+i+360))).get(); + if(floor(dist+0.5)!=-895) + { + printf("angle: error: Badness at %d!\n",i); + ret++; + } + + } + + + + { + float f; + angle a(angle::deg(-2005)); + angle b(angle::deg(200)); + + affine_combo combo; + + hermite hermie(a,b,b.dist(a),b.dist(a)); + + for(f=0;f<1.001;f+=0.1) + { + printf("@%f--affine_combo: %f hermie: %f\n",angle::deg(f).get(),angle::deg(combo(a,b,f)).get(),angle::deg(hermie(f)).get()); + } + + } + + return ret; +} + +/* === E N T R Y P O I N T ================================================= */ + +int main() +{ + int error=0; + + error+=fastangle_test(); + error+=fastangle_speed_test(); + error+=angle_test(); + + return error; +} diff --git a/ETL/tags/0.61.06/test/benchmark.cpp b/ETL/tags/0.61.06/test/benchmark.cpp new file mode 100644 index 0000000..e453186 --- /dev/null +++ b/ETL/tags/0.61.06/test/benchmark.cpp @@ -0,0 +1,475 @@ +/*! ======================================================================== +** Extended Template and Library Test Suite +** Hermite Curve Test +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* === M A C R O S ========================================================= */ + +using namespace etl; +//using namespace std; + +#define HERMITE_TEST_ITERATIONS (100000) + +/* === C L A S S E S ======================================================= */ + +/* === P R O C E D U R E S ================================================= */ + +template +void angle_cos_speed_test(void) +{ + Angle a,b,c,d; + float tmp,tmp2; + + for(tmp=-1;tmp<1;tmp+=0.000002f) + { + a=(typename Angle::cos)(tmp); + b=(typename Angle::cos)(tmp); + c=(typename Angle::cos)(tmp); + d=(typename Angle::cos)(tmp); + tmp2=((typename Angle::cos)(a)).get(); + tmp2=((typename Angle::cos)(b)).get(); + tmp2=((typename Angle::cos)(c)).get(); + tmp2=((typename Angle::cos)(d)).get(); + } +} +template +void angle_sin_speed_test(void) +{ + Angle a,b,c,d; + float tmp,tmp2; + + for(tmp=-1.0;tmp<1.0;tmp+=0.000002f) + { + a=(typename Angle::sin)(tmp); + b=(typename Angle::sin)(tmp); + c=(typename Angle::sin)(tmp); + d=(typename Angle::sin)(tmp); + tmp2=((typename Angle::sin)(a)).get(); + tmp2=((typename Angle::sin)(b)).get(); + tmp2=((typename Angle::sin)(c)).get(); + tmp2=((typename Angle::sin)(d)).get(); + } +} +template +void angle_tan_speed_test(void) +{ + Angle a,b,c,d; + float tmp,tmp2; + + for(tmp=-1;tmp<1;tmp+=0.000002f) + { + a=(typename Angle::tan)(tmp); + b=(typename Angle::tan)(tmp); + c=(typename Angle::tan)(tmp); + d=(typename Angle::tan)(tmp); + tmp2=((typename Angle::tan)(a)).get(); + tmp2=((typename Angle::tan)(b)).get(); + tmp2=((typename Angle::tan)(c)).get(); + tmp2=((typename Angle::tan)(d)).get(); + } +} +template +void angle_atan2_speed_test(void) +{ + Angle a,b,c; + float x,y; + + for(y=-10;y<10;y+=0.05f) + for(x=-10;x<10;x+=0.05f) + { + a=mytan(y,x); + a=mytan(x,y); + b=mytan(y,x); + b=mytan(x,y); + c=mytan(y,x); + c=mytan(x,y); + a=mytan(y,x); + a=mytan(x,y); + b=mytan(y,x); + b=mytan(x,y); + c=mytan(y,x); + c=mytan(x,y); + } +} + +int fastangle_speed_test(void) +{ + int ret=0; + float + angle_cos_time, + fastangle_cos_time, + angle_tan_time, + fastangle_tan_time, + angle_atan2_time, + fastangle_atan2_time, + angle_sin_time, + fastangle_sin_time ; + + etl::clock MyTimer; + + MyTimer.reset(); + angle_cos_speed_test(); + angle_cos_time=MyTimer(); + printf("angle: Cosine test: %f seconds\n",angle_cos_time); + + MyTimer.reset(); + angle_cos_speed_test(); + fastangle_cos_time=MyTimer(); + printf("fastangle: Cosine test: %f seconds\n",fastangle_cos_time); + printf("fastangle is %.02f%% faster\n",(angle_cos_time/fastangle_cos_time)*100.0-100.0); + + MyTimer.reset(); + angle_sin_speed_test(); + angle_sin_time=MyTimer(); + printf("angle: Sine test: %f seconds\n",angle_sin_time); + + MyTimer.reset(); + angle_sin_speed_test(); + fastangle_sin_time=MyTimer(); + printf("fastangle: Sine test: %f seconds\n",fastangle_sin_time); + printf("fastangle is %.02f%% faster\n",(angle_sin_time/fastangle_sin_time)*100.0-100.0); + + MyTimer.reset(); + angle_tan_speed_test(); + angle_tan_time=MyTimer(); + printf("angle: Tangent test: %f seconds\n",angle_tan_time); + + MyTimer.reset(); + angle_tan_speed_test(); + fastangle_tan_time=MyTimer(); + printf("fastangle: Tangent test: %f seconds\n",fastangle_tan_time); + printf("fastangle is %.02f%% faster\n",(angle_tan_time/fastangle_tan_time)*100.0-100.0); + + MyTimer.reset(); + angle_atan2_speed_test(); + angle_atan2_time=MyTimer(); + printf("angle: arcTangent2 test: %f seconds\n",angle_atan2_time); + + MyTimer.reset(); + angle_atan2_speed_test(); + fastangle_atan2_time=MyTimer(); + printf("fastangle: arcTangent2 test: %f seconds\n",fastangle_atan2_time); + printf("fastangle is %.02f%% faster\n",(angle_atan2_time/fastangle_atan2_time)*100.0-100.0); + + return ret; +} + +int surface_and_gaussian_blur_test() +{ + int ret=0; + etl::clock MyTimer; + float endtime; + + { + surface my_surface(1000,1000); + + MyTimer.reset(); + gaussian_blur(my_surface.begin(),my_surface.end(),30,30); + endtime=MyTimer(); + printf("surface_and_gaussian_blur_test: %f seconds\n",endtime); + } + + { + surface my_surface(1000,1000); + + MyTimer.reset(); + gaussian_blur(my_surface.begin(),my_surface.end(),30,30); + endtime=MyTimer(); + printf("surface_and_gaussian_blur_test: %f seconds\n",endtime); + } + + { + surface my_surface(1000,1000); + + MyTimer.reset(); + gaussian_blur(my_surface.begin(),my_surface.end(),30,30); + endtime=MyTimer(); + printf("surface_and_gaussian_blur_test: %f seconds\n",endtime); + } + + return ret; +} + +int hermite_int_test() +{ + int ret=0; + hermite Hermie; + hermite::time_type f; + int i; + + etl::clock timer; + etl::clock::value_type t; + + Hermie.p1()=0; + Hermie.t1()=40000; + Hermie.p2()=0; + Hermie.t2()=40000; + + Hermie.sync(); + + {float t; + for(f=0.0f,i=0,timer.reset();i:time=%f milliseconds\n",t*1000); + return ret; +} + +int hermite_float_test(void) +{ + int ret=0; + float f; int i; + + hermite Hermie; + etl::clock timer; + double t; + + Hermie.p1()=0; + Hermie.t1()=1; + Hermie.p2()=0; + Hermie.t2()=1; + + Hermie.sync(); + + {float t; + for(f=0.0f,i=0,timer.reset();i:time=%f milliseconds\n",t*1000); + return ret; +} + +int hermite_double_test(void) +{ + int ret=0,i; + float f; + + hermite Hermie; + etl::clock timer; + double t; + + Hermie.p1()=0; + Hermie.t1()=1; + Hermie.p2()=0; + Hermie.t2()=1; + + Hermie.sync(); + + for(f=0.0f,i=0,timer.reset();i:time=%f milliseconds\n",t*1000); + return ret; +} + +int hermite_fixed_test(void) +{ + int ret=0; + int i; + hermite Hermie; + hermite::time_type f; + hermite::time_type inc(0.0005f), inc2(1.10); + fixed sum(0); + + etl::clock timer; + double t; + + Hermie.p1()=0; + Hermie.t1()=1; + Hermie.p2()=0; + Hermie.t2()=1; + + Hermie.sync(); + + {fixed t; + for(i=0,f=0,timer.reset();i:time=%f milliseconds\n",t*1000); + return ret; +} + +int hermite_angle_test(void) +{ + int ret=0,i; + float f; + + hermite Hermie; + etl::clock timer; + angle tmp; + double t; + + Hermie.p1()=angle::degrees(0); + Hermie.t1()=angle::degrees(45); + + Hermie.p2()=angle::degrees(-45); + Hermie.t2()=angle::degrees(180); + + Hermie.sync(); + + for(f=0.0f,i=0,timer.reset();i:time=%f milliseconds\n",t*1000); + + return ret; +} + +int hermite_fastangle_test(void) +{ + int ret=0,i; + hermite Hermie; + hermite::time_type f; + + etl::clock timer; + fastangle tmp; + double t; + + Hermie.p1()=fastangle::degrees(0); + Hermie.t1()=fastangle::degrees(45); + + Hermie.p2()=fastangle::degrees(-45); + Hermie.t2()=fastangle::degrees(180); + + Hermie.sync(); + + for(f=0.0f,i=0,timer.reset();i:time=%f milliseconds\n",t*1000); + + return ret; +} + +/* === E N T R Y P O I N T ================================================= */ + +int main() +{ + int error=0; + + error+=fastangle_speed_test(); + error+=surface_and_gaussian_blur_test(); + error+=hermite_float_test(); + error+=hermite_double_test(); + error+=hermite_int_test(); + error+=hermite_fixed_test(); + error+=hermite_angle_test(); + error+=hermite_fastangle_test(); + + return error; +} diff --git a/ETL/tags/0.61.06/test/clock.cpp b/ETL/tags/0.61.06/test/clock.cpp new file mode 100644 index 0000000..652644b --- /dev/null +++ b/ETL/tags/0.61.06/test/clock.cpp @@ -0,0 +1,79 @@ +/*! ======================================================================== +** Extended Template and Library Test Suite +** Clock Test +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#include +#include + +/* === M A C R O S ========================================================= */ + +using namespace etl; + +/* === C L A S S E S ======================================================= */ + + +/* === P R O C E D U R E S ================================================= */ + +int basic_test(void) +{ + int ret=0; + fprintf(stderr,"default etl::clock precision: %0.8f\n",etl::clock::precision()); + fprintf(stderr,"realtime etl::clock precision: %0.8f\n",etl::clock_realtime::precision()); + fprintf(stderr,"proctime etl::clock precision: %0.8f\n",etl::clock_proctime::precision()); + + etl::clock_realtime timer; + etl::clock::value_type amount,total; + + for(amount=3.0;amount>=0.00015;amount/=2.0) + { + if(amount*1000000.0<1000.0f) + fprintf(stderr,"waiting %f microseconds...\n",amount*1000000.0); + else if(amount*1000.0<400.0f) + fprintf(stderr,"waiting %f milliseconds...\n",amount*1000.0); + else + fprintf(stderr,"waiting %f seconds...\n",amount); + + timer.reset(); + etl::clock::sleep(amount); + total=timer(); + if((total-amount)*1000000.0<1000.0f) + fprintf(stderr," ** I waited %f seconds, error of %f microseconds\n",total,(total-amount)*1000000); + else if((total-amount)*1000.0<400.0f) + fprintf(stderr," ** I waited %f seconds, error of %f milliseconds\n",total,(total-amount)*1000); + else + fprintf(stderr," ** I waited %f seconds, error of %f seconds\n",total,total-amount); + + } + return ret; +} + +/* === E N T R Y P O I N T ================================================= */ + +int main() +{ + int error=0; + + error+=basic_test(); + + return error; +} + diff --git a/ETL/tags/0.61.06/test/fixed.cpp b/ETL/tags/0.61.06/test/fixed.cpp new file mode 100644 index 0000000..965a8d3 --- /dev/null +++ b/ETL/tags/0.61.06/test/fixed.cpp @@ -0,0 +1,294 @@ +/*! ======================================================================== +** Extended Template and Library Test Suite +** Fixed-Point Math Test +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** Copyright (c) 2007 Chris Moore +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#define ETL_FIXED_BITS 12 + +#include +#include +#include + +/* === M A C R O S ========================================================= */ + +#ifndef PI +# define PI (3.1415926535897932384626433832795029L) +#endif + +#define ADD_SUB_TEST 20000000 +#define MUL_TEST 10000000 +#define DIV_TEST 1048573 // at 1048573, fixed point numbers wrap around to zero +using namespace etl; + +/* === C L A S S E S ======================================================= */ + +template +struct speed_test +{ + double add_sub_test(void) + { + value_type a=1; + value_type b=2; + value_type c=3; + int i; + etl::clock MyTimer; + MyTimer.reset(); + for(i=0;i(1.5)); + int i; + etl::clock MyTimer; + MyTimer.reset(); + for(i=1;i0.0005) + { + fprintf(stderr,"fixed: Failed test on line %d in "__FILE__".\n",__LINE__); + ret++; + } + + a=1043;d=1043; + a/=27;d/=27; + a+=10.42;d+=10.42; + a/=6;d/=6; + a*=PI;d*=PI; + d-=(double)a; + fprintf(stderr,"fixed: ( 1043 / 27 + 10.42 ) / 6 * PI --- Difference: %f\n",d); + if(d<0.0)d=-d; +#ifdef ROUND_TO_NEAREST_INTEGER + if( d>0.0005) +#else + if( d>0.0025) +#endif + { + fprintf(stderr,"fixed: Failed test on line %d in "__FILE__".\n",__LINE__); + ret++; + } + + return ret; +} + +int char_test(void) +{ + int ret=0; + + fixed_base fix; + double flt; + + if(sizeof(fix)!=sizeof(unsigned char)) + { + ret++; + fprintf(stderr,"fixed: Size of fixed_base is wrong!\n"); + } + + flt=1.0; + fix=1.0; + fprintf(stderr,"fixed: value=%f, data=%d, shouldbe=%f, error=%f\n",(float)fix,fix.data(),flt,(float)fix-flt); + + flt*=0.7; + fix*=0.7; + fprintf(stderr,"fixed: value=%f, data=%d, shouldbe=%f, error=%f\n",(float)fix,fix.data(),flt,(float)fix-flt); + + flt*=0.7; + fix*=0.7; + fprintf(stderr,"fixed: value=%f, data=%d, shouldbe=%f, error=%f\n",(float)fix,fix.data(),flt,(float)fix-flt); + + flt*=0.7; + fix*=0.7; + fprintf(stderr,"fixed: value=%f, data=%d, shouldbe=%f, error=%f\n",(float)fix,fix.data(),flt,(float)fix-flt); + + flt*=0.7; + fix*=0.7; + fprintf(stderr,"fixed: value=%f, data=%d, shouldbe=%f, error=%f\n",(float)fix,fix.data(),flt,(float)fix-flt); + + flt*=0.7; + fix*=0.7; + fprintf(stderr,"fixed: value=%f, data=%d, shouldbe=%f, error=%f\n",(float)fix,fix.data(),flt,(float)fix-flt); + + //flt/=0.7; + //fix/=0.7; + //fprintf(stderr,"fixed: value=%f, data=%d, shouldbe=%f, error=%f\n",(float)fix,fix.data(),flt,(float)fix-flt); + + flt+=0.3; + fix+=0.3; + fprintf(stderr,"fixed: value=%f, data=%d, shouldbe=%f, error=%f\n",(float)fix,fix.data(),flt,(float)fix-flt); + + flt*=2; + fix*=2; + fprintf(stderr,"fixed: value=%f, data=%d, shouldbe=%f, error=%f\n",(float)fix,fix.data(),flt,(float)fix-flt); + + + return ret; +} + +/* === E N T R Y P O I N T ================================================= */ + +int main() +{ + int error=0; + + error+=basic_test(); + error+=char_test(); + + speed_test float_test; + speed_test int_test; + speed_test fixed_test; + + { + double flt,fix,inte; + fprintf(stderr,"\nAddition/subtraction test...\n"); + + fprintf(stderr," calculating float....."); + flt=float_test.add_sub_test(); + fprintf(stderr," float time: %f sec\n",flt); + + fprintf(stderr," calculating fixed....."); + fix=fixed_test.add_sub_test(); + fprintf(stderr," fixed time: %f sec\n",fix); + + fprintf(stderr," calculating integer..."); + inte=int_test.add_sub_test(); + fprintf(stderr," integer time: %f sec\n",inte); + + if(flt>fix) + fprintf(stderr,"Fixed point wins by %f seconds! (%f%% faster)\n",flt-fix,flt/fix*100.0f-100.0f); + else + fprintf(stderr,"Floating point wins by %f seconds! (%f%% faster)\n",fix-flt,fix/flt*100.0f-100.0f); + + } + + { + double flt,fix,inte; + fprintf(stderr,"\nProduct test...\n"); + fprintf(stderr," calculating float....."); + flt=float_test.mul_test(); + fprintf(stderr," float time: %f sec\n",flt); + fprintf(stderr," calculating fixed....."); + fix=fixed_test.mul_test(); + fprintf(stderr," fixed time: %f sec\n",fix); + fprintf(stderr," calculating integer..."); + inte=int_test.mul_test(); + fprintf(stderr," integer time: %f sec\n",inte); + if(flt>fix) + fprintf(stderr,"Fixed point wins by %f seconds! (%f%% faster)\n",flt-fix,flt/fix*100.0f-100.0f); + else + fprintf(stderr,"Floating point wins by %f seconds! (%f%% faster)\n",fix-flt,fix/flt*100.0f-100.0f); + } + + { + double flt,fix,inte; + fprintf(stderr,"\nDivision test...\n"); + fprintf(stderr," calculating float....."); + flt=float_test.div_test(); + fprintf(stderr," float time: %f sec\n",flt); + fprintf(stderr," calculating fixed....."); + fix=fixed_test.div_test(); + fprintf(stderr," fixed time: %f sec\n",fix); + fprintf(stderr," calculating integer..."); + inte=int_test.div_test(); + fprintf(stderr," integer time: %f sec\n",inte); + if(flt>fix) + fprintf(stderr,"Fixed point wins by %f seconds! (%f%% faster)\n",flt-fix,flt/fix*100.0f-100.0f); + else + fprintf(stderr,"Floating point wins by %f seconds! (%f%% faster)\n",fix-flt,fix/flt*100.0f-100.0f); + fprintf(stderr,"\n"); + } + + return error; +} diff --git a/ETL/tags/0.61.06/test/handle.cpp b/ETL/tags/0.61.06/test/handle.cpp new file mode 100644 index 0000000..f66ff92 --- /dev/null +++ b/ETL/tags/0.61.06/test/handle.cpp @@ -0,0 +1,482 @@ +/*! ======================================================================== +** Extended Template and Library Test Suite +** Handle Template Class Test +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#include +#include +#include +#include +#include +#include +#include + +/* === M A C R O S ========================================================= */ + +#define NUMBER_OF_OBJECTS 40000 +using namespace std; + +/* === C L A S S E S ======================================================= */ + +struct my_test_obj : public etl::rshared_object +{ + static int instance_count; + int my_id; + my_test_obj(int my_id=0):my_id(my_id) + { + instance_count++; + } + + virtual ~my_test_obj() + { + if(instance_count==0) + printf("Error, instance count is going past zero!\n"); + instance_count--; + } + + bool operator<(const my_test_obj &rhs)const + { + return my_id obj_handle; +typedef etl::rhandle robj_handle; +typedef etl::handle other_obj_handle; +typedef list< obj_handle > obj_list; +typedef list< other_obj_handle > other_obj_list; +typedef list< robj_handle > robj_list; + +int handle_basic_test() +{ + printf("handle: Size of a handle: %u\n",(unsigned int)sizeof(etl::handle)); + printf("handle: Size of a loose_handle: %u\n",(unsigned int)sizeof(etl::loose_handle)); + printf("handle: Size of a rhandle: %u\n",(unsigned int)sizeof(etl::rhandle)); + printf("handle: Size of a shared_object: %u\n",(unsigned int)sizeof(etl::shared_object)); + printf("handle: Size of a rshared_object: %u\n",(unsigned int)sizeof(etl::rshared_object)); + + printf("handle: Basic test: "); + my_test_obj::instance_count=0; + + { + etl::handle obj_handle(new my_test_obj(rand())); + } + + if(my_test_obj::instance_count!=0) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on create/distroy, instance count=%d, should be zero.\n",__LINE__,my_test_obj::instance_count); + return 1; + } + + { + map > my_map; + etl::handle obj_handle(new my_test_obj(rand())); + my_map["bleh"]=obj_handle; + } + + if(my_test_obj::instance_count!=0) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on create/distroy, instance count=%d, should be zero.\n",__LINE__,my_test_obj::instance_count); + return 1; + } + + etl::handle obj_handle(new my_test_obj(rand())); + + if(obj_handle != obj_handle.constant()) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on call to handle<>::constant().\n",__LINE__); + return 1; + } + + printf("PASSED\n"); + + return 0; +} + +int handle_general_use_test(void) +{ + printf("handle: General-use test: "); + my_test_obj::instance_count=0; + + obj_list my_list, my_other_list; + int i; + + for(i=0;i my_item_list; + for(i=0;i=2); + my_item_list.erase(my_item_list.begin()+src); + assert(tmp.obj.rcount()>=1); + my_item_list.insert(my_item_list.begin()+dest,tmp); + assert(tmp.obj.rcount()>=2); + } + + my_item_list.clear(); + + if(my_test_obj::instance_count) + { + printf("FAILED!\n"); + printf(__FILE__":%d: On clear, instance count=%d, should be zero.\n",__LINE__,my_test_obj::instance_count); + return 1; + } + + printf("PASSED\n"); + + return 0; +} + +int handle_inheritance_test(void) +{ + printf("handle: Inheritance test: "); + my_test_obj::instance_count=0; + my_other_test_obj::instance_count=0; + + other_obj_list my_other_list; + int i; + + for(i=0;i handle) +{ + if(handle) { int i=handle.count(); i++; } +} + +int loose_handle_test(void) +{ + printf("handle: loose_handle test: "); + my_test_obj::instance_count=0; + + etl::loose_handle obj_handle_loose; + etl::handle obj_handle2; + + { + etl::handle obj_handle(new my_test_obj(rand())); + if(my_test_obj::instance_count!=1) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on handle assignment from new object, instance count=%d, should be 1.\n",__LINE__,my_test_obj::instance_count); + return 1; + } + + obj_handle_loose=obj_handle; + if(obj_handle!=obj_handle_loose) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on loose_handle assignment\n",__LINE__); + return 1; + } + + obj_handle2=obj_handle_loose; + if(my_test_obj::instance_count!=1) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on handle assignment from loose_handle, instance count=%d, should be 1.\n",__LINE__,my_test_obj::instance_count); + return 1; + } + + test_func(obj_handle_loose); + if(my_test_obj::instance_count!=1) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on handle assignment from loose_handle, instance count=%d, should be 1.\n",__LINE__,my_test_obj::instance_count); + return 1; + } + } + + if(my_test_obj::instance_count!=1) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on create/destroy, instance count=%d, should be 1.\n",__LINE__,my_test_obj::instance_count); + return 1; + } + + printf("PASSED\n"); + return 0; +} + +int handle_cast_test() +{ + printf("handle: casting test: "); + + etl::handle obj; + etl::handle other_obj; + etl::loose_handle loose_obj; + + other_obj.spawn(); + loose_obj=other_obj; + + obj=etl::handle::cast_dynamic(loose_obj); + + if(obj!=other_obj) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on handle assignment from loose_handle.\n",__LINE__); + return 1; + } + + printf("PASSED\n"); + return 0; +} + +/* === E N T R Y P O I N T ================================================= */ + +int main() +{ + int error=0; + + error+=handle_basic_test(); + error+=handle_cast_test(); + error+=handle_general_use_test(); + error+=handle_inheritance_test(); + error+=loose_handle_test(); + error+=rhandle_general_use_test(); + + return error; +} diff --git a/ETL/tags/0.61.06/test/hermite.cpp b/ETL/tags/0.61.06/test/hermite.cpp new file mode 100644 index 0000000..25a6278 --- /dev/null +++ b/ETL/tags/0.61.06/test/hermite.cpp @@ -0,0 +1,248 @@ +/*! ======================================================================== +** Extended Template and Library Test Suite +** Hermite Curve Test +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** Copyright (c) 2007 Chris Moore +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#include +#include +#include +#include +#include +#include + +/* === M A C R O S ========================================================= */ + +using namespace etl; + +/* === C L A S S E S ======================================================= */ + + +/* === P R O C E D U R E S ================================================= */ + +int basic_test(void) +{ + int ret=0; + float f; + + hermite Hermie; + etl::clock timer; + double t; + + Hermie.p1()=0; + Hermie.t1()=1; + Hermie.p2()=0; + Hermie.t2()=1; + + Hermie.sync(); + + integral > inte(Hermie); + + + fprintf(stderr,"integral of curve() on [0,1] = %f\n",inte(0,1.0)); + fprintf(stderr,"integral of curve() on [-1,3] = %f\n",inte(-1.0,3.0)); + Hermie.set_rs(-1.0,7.0); + inte=integral >(Hermie); + fprintf(stderr,"integral of curve()[%f,%f] on [-1,7] = %f\n",Hermie.get_r(),Hermie.get_s(),inte(-1.0,7.0)); + fprintf(stderr,"integral of curve()[%f,%f] on [0,1] = %f\n",Hermie.get_r(),Hermie.get_s(),inte(0,1.0)); + Hermie.set_rs(0.0,1.0); + + + for(f=0.0f,timer.reset();f<1.001f;f+=0.000005f) + { + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + } + t=timer(); + + fprintf(stderr,"time=%f milliseconds\n",t*1000); + return ret; +} + +int angle_test(void) +{ + int ret=0; + float f; + + hermite Hermie; + etl::clock timer; + angle tmp; + double t; + + Hermie.p1()=angle::degrees(0); + Hermie.t1()=angle::degrees(45); + + Hermie.p2()=angle::degrees(-45); + Hermie.t2()=angle::degrees(180); + + Hermie.sync(); + + + for(f=0.0f,timer.reset();f<1.001f;f+=0.000005f) + { + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + } + t=timer(); + + fprintf(stderr,"angle time=%f milliseconds\n",t*1000); + + return ret; +} + +int fixed_test(void) +{ + int ret=0; + float f; + + hermite Hermie; + etl::clock timer; + double t; + + Hermie.p1()=0; + Hermie.t1()=1; + Hermie.p2()=0; + Hermie.t2()=1; + + Hermie.sync(); + + + + for(f=0.0f,timer.reset();f<1.001f;f+=0.005f) + { + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + t+=Hermie(f)+Hermie(f+0.1f); + } + t=timer(); + + fprintf(stderr,"time=%f milliseconds\n",t*1000); + return ret; +} + + +int anglefixed_test(void) +{ + int ret=0; + float f; + + hermite Hermie; + etl::clock timer; + angle tmp; + double t; + + Hermie.p1()=angle::degrees(0); + Hermie.t1()=angle::degrees(45); + + Hermie.p2()=angle::degrees(-45); + Hermie.t2()=angle::degrees(180); + + Hermie.sync(); + + + for(f=0.0f,timer.reset();f<1.001f;f+=0.0005f) + { + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + tmp+=Hermie(f)+Hermie(f+0.1f); + } + t=timer(); + + fprintf(stderr,"angle fixed time=%f milliseconds\n",t*1000); + + return ret; +} + +int float_intersection_test() +{ + int ret=0; + + hermite curve1(0,1,0,1); + hermite curve2(-1,2,-1,-2); + double t1,t2; + float d; + + t1=curve1.intersect(curve2); + t2=curve2.intersect(curve1); + + d=curve1(t1)-curve2(t2); + + fprintf(stderr,"float:Intersection difference: %f (t1=%f, t2=%f)\n",d,t1,t2); + + if(d>0.01) + { + fprintf(stderr,"float:FAILED INTERSECTION TEST.\n"); + ret++; + } + + return ret; +} + +/* === E N T R Y P O I N T ================================================= */ + +int main() +{ + int error=0; + + error+=basic_test(); + error+=angle_test(); + error+=fixed_test(); + error+=float_intersection_test(); + return error; +} diff --git a/ETL/tags/0.61.06/test/pen.cpp b/ETL/tags/0.61.06/test/pen.cpp new file mode 100644 index 0000000..f29319f --- /dev/null +++ b/ETL/tags/0.61.06/test/pen.cpp @@ -0,0 +1,548 @@ +/*! ======================================================================== +** Extended Template and Library Test Suite +** Handle Template Class Test +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +//#include +#include + +/* === M A C R O S ========================================================= */ + +using namespace std; +using namespace etl; + +/* === C L A S S E S ======================================================= */ + +int generic_pen_test(int w, int h) +{ + printf("generic_pen(w:%d,h:%d): ",w,h); + + auto_ptr data(new float[w*h]); + if(!data.get()) + { + printf("Um..... malloc failure on line %d of "__FILE__"...\n",__LINE__); + abort(); + } + + generic_pen pen(data.get(),w,h); + generic_pen pen2; + + if(!pen) + { + printf("FAILURE! "__FILE__"@%d: On pen bool test\n",__LINE__); + return 1; + } + + if(&pen.x()[2]!=&pen[0][2]) + { + printf("FAILURE! "__FILE__"@%d: On request for horizontal iterator\n",__LINE__); + return 1; + } + + if(&pen.y()[2]!=&pen[2][0]) + { + printf("FAILURE! "__FILE__"@%d: On request for vertical iterator\n",__LINE__); + return 1; + } + + pen.move(1,1); + pen2=pen; + + if(pen!=pen2) + { + printf("FAILURE! "__FILE__"@%d: On pen assignment or pen comparison\n",__LINE__); + return 1; + } + + pen2.move(w,h); + generic_pen::difference_type diff(pen2-pen); + + if(diff.x!=w || diff.y!=h) + { + printf("FAILURE! "__FILE__"@%d: pen difference inconsistency ([%d,%d]!=[%d,%d])\n",__LINE__,diff.x,diff.y,w,h); + return 1; + } + + if(pen.end_x()-pen.x()!=w-1) + { + printf("FAILURE! "__FILE__"@%d: iterator_x inconsistency (%d!=%d)\n",__LINE__,pen.end_x()-pen.x(),w); + return 1; + } + + if(pen.end_y()-pen.y()!=h-1) + { + printf("FAILURE! "__FILE__"@%d: iterator_y inconsistency (%d!=%d)\n",__LINE__,pen.end_y()-pen.y(),h); + return 1; + } + + if(&pen.end_y()[-1]!=&pen.y()[(h-2)]) + { + printf("FAILURE! "__FILE__"@%d: iterator_y inconsistency\n",__LINE__); + return 1; + } + + if(&pen.end_x()[-1]!=&pen.x()[(w-2)]) + { + printf("FAILURE! "__FILE__"@%d: iterator_x inconsistency\n",__LINE__); + return 1; + } + + printf("PASSED\n"); + + return 0; +} + +int alpha_pen_test(void) +{ + printf("alpha_pen: "); + printf("SKIPPED\n"); + + return 0; +} + +int bbox_pen_test(void) +{ + printf("bbox_pen: "); + + + + printf("SKIPPED\n"); + + return 0; +} + +int display_pen(generic_pen pen, int w, int h) +{ + int ret=0; + int x, y; + // print out the after pic + for(y=0;y=2.0f) + printf("#"); + else if(pen.get_value()>=1.0f) + printf("@"); + else if(pen.get_value()>=0.8f) + printf("%%"); + else if(pen.get_value()>=0.6f) + printf("O"); + else if(pen.get_value()>=0.4f) + printf(":"); + else if(pen.get_value()>=0.2f) + printf("."); + else if(pen.get_value()>=-0.0001f) + printf(" "); + else + printf("X"),ret++; + } + pen.dec_x(x); + printf("|\n"); + } + pen.dec_y(y); + return ret; +} + +int display_pen(generic_pen pen, int w, int h) +{ + int ret=0; + int x, y; + // print out the after pic + for(y=0;y=2.0f) + printf("#"); + else if(pen.get_value()>=1.0f) + printf("@"); + else if(pen.get_value()>=0.8f) + printf("%%"); + else if(pen.get_value()>=0.6f) + printf("O"); + else if(pen.get_value()>=0.4f) + printf(":"); + else if(pen.get_value()>=0.2f) + printf("."); + else if(pen.get_value()>=-0.0001f) + printf(" "); + else + printf("X"),ret++; + } + pen.dec_x(x); + printf("|\n"); + } + pen.dec_y(y); + return ret; +} + +void emptyfunction(int v) +{ + static int stupid = 0; + stupid = v; + //printf("Called... %d\n",v); +} + +int box_blur_test(void) +{ + typedef float boxblur_float; + + printf("box_blur: "); + + int w=25,h=25; + + auto_ptr data(new boxblur_float[w*h]); + auto_ptr data2(new boxblur_float[w*h]); + if(!data.get()) + { + printf("Um..... malloc failure on line %d of "__FILE__"...\n",__LINE__); + abort(); + } + + generic_pen pen(data.get(),w,h); + generic_pen pen2; + + generic_pen pen3(data2.get(),w,h); + int x,y; + + for(y=0;y= h) iy = h-1; + + for(int ox=-2; ox <= 2; ++ox) + { + int ix = x+ox; + if(ix < 0) ix = 0; + if(ix >= w) ix = w-1; + + if(ix-iy<=1 && iy-ix<=1 || iy==h/2 || ix==w/2) + f += 2; + } + } + + //print out if the relative error is high + /*f /= 25; + float rf = pen.get_value() - f/25; + if(f && rf > 0.3) + { + printf("pixel (%d,%d) off by %f\n",x,y,rf); + }*/ + boxblur_float diff = fabs(pen.get_value() - f/25); + if(diff > max) max = diff; + pen.put_value(f/25); //if length = 2 then dim = 5.. area = 25 + } + pen.dec_x(x); + } + pen.dec_y(y); + + /*if(max) + { + for(y=0;y data(new float[w*h]); + if(!data.get()) + { + printf("Um..... malloc failure on line %d of "__FILE__"...\n",__LINE__); + abort(); + } + + generic_pen pen(data.get(),w,h); + generic_pen pen2; + int x,y; + + for(y=0;y=2.0f) + printf("#"); + else if(pen.get_value()>=1.0f) + printf("@"); + else if(pen.get_value()>=0.8f) + printf("%%"); + else if(pen.get_value()>=0.6f) + printf("O"); + else if(pen.get_value()>=0.4f) + printf(":"); + else if(pen.get_value()>=0.2f) + printf("."); + else if(pen.get_value()>=0.0f) + printf(" "); + else + printf("X"),bad_values++; + } + pen.dec_x(x); + printf("|\n"); + } + pen.dec_y(y); + + // Pen 2 will be the end + pen2=pen; + pen2.move(w,h); + +#if 0 + gaussian_blur_5x5(pen,pen2); + gaussian_blur_5x5(pen,pen2); + gaussian_blur_5x5(pen,pen2); +#endif + +#if 0 + gaussian_blur_3x3(pen,pen2); + gaussian_blur_3x3(pen,pen2); + gaussian_blur_3x3(pen,pen2); + gaussian_blur_3x3(pen,pen2); + gaussian_blur_3x3(pen,pen2); +#endif + +// gaussian_blur(pen,pen2,15); + gaussian_blur(pen,pen2,10,10); + + printf("\nAFTER GAUSSIAN BLUR:\n"); + + // print out the after pic + for(y=0;y=2.0f) + printf("#"); + else if(pen.get_value()>=1.0f) + printf("@"); + else if(pen.get_value()>=0.8f) + printf("%%"); + else if(pen.get_value()>=0.6f) + printf("O"); + else if(pen.get_value()>=0.4f) + printf(":"); + else if(pen.get_value()>=0.2f) + printf("."); + else if(pen.get_value()>=0.0f) + printf(" "); + else + printf("X"),bad_values++; + } + pen.dec_x(x); + printf("|\n"); + } + pen.dec_y(y); + + if(bad_values) + { + printf("FAILURE! "__FILE__"@%d: blur result contained bad values\n",__LINE__); + return 1; + } +#endif + printf("PASSED\n"); + + return 0; +} + +/* === E N T R Y P O I N T ================================================= */ + +int main() +{ + int error=0; + + error+=generic_pen_test(40,40); + error+=generic_pen_test(10,40); + error+=generic_pen_test(40,10); + if(error)return error; + error+=alpha_pen_test(); + error+=bbox_pen_test(); + error+=box_blur_test(); + if(error)return error; + error+=gaussian_blur_test(); + + return error; +} diff --git a/ETL/tags/0.61.06/test/random.cpp b/ETL/tags/0.61.06/test/random.cpp new file mode 100644 index 0000000..d5bfaea --- /dev/null +++ b/ETL/tags/0.61.06/test/random.cpp @@ -0,0 +1,48 @@ +/*! ======================================================================== +** Extended Template and Library Test Suite +** Angle Class Test +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#include + +/* === M A C R O S ========================================================= */ + +using namespace etl; + +/* === C L A S S E S ======================================================= */ + +int random_basic_test(void) +{ + int ret=0; + random Rand; + + return ret; +} + +/* === E N T R Y P O I N T ================================================= */ + +int main() +{ + int error=0; + + + return error; +} diff --git a/ETL/tags/0.61.06/test/smach.cpp b/ETL/tags/0.61.06/test/smach.cpp new file mode 100644 index 0000000..bb5f48d --- /dev/null +++ b/ETL/tags/0.61.06/test/smach.cpp @@ -0,0 +1,207 @@ +/*! ======================================================================== +** Extended Template and Library Test Suite +** Angle Class Test +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#include +#include + +/* === M A C R O S ========================================================= */ + +using namespace std; +using namespace etl; + +/* === C L A S S E S ======================================================= */ + +enum EventKey +{ + EVENT_1, + EVENT_2, + EVENT_3, + EVENT_4 +}; + + + +struct MachineContext +{ + smach machine; + + MachineContext():machine(this) + { + } +}; + +typedef smach Smach; + +class Event1 : public Smach::event +{ +public: + Event1():Smach::event(EVENT_1) { } +}; + + +class DefaultStateContext +{ + MachineContext *context; +public: + DefaultStateContext(MachineContext *context):context(context) { printf("Entered Default State\n"); } + ~DefaultStateContext() { printf("Left Default State\n"); } + + Smach::event_result event1_handler(const Smach::event& x __attribute__ ((unused))) + { + printf("DEFAULT STATE: Received Event 1\n"); + return Smach::RESULT_ACCEPT; + } +}; + +class DefaultState : public Smach::state +{ +public: + DefaultState():Smach::state("DefaultState") + { + insert(event_def(EVENT_1,&DefaultStateContext::event1_handler)); + } + +} default_state; + + + + + + + +class State1Context +{ + MachineContext *context; +public: + State1Context(MachineContext *context):context(context) { printf("Entered State 1\n"); } + ~State1Context() { printf("Left State 1\n"); } + + Smach::event_result event1_handler(const Smach::event& x __attribute__ ((unused))) + { + printf("STATE1: Received Event 1\n"); + return Smach::RESULT_OK; + } + + Smach::event_result event3_handler(const Smach::event& x); +}; + +class State1 : public Smach::state +{ +public: + State1():Smach::state("State1") + { + insert(event_def(EVENT_1,&State1Context::event1_handler)); + insert(event_def(EVENT_3,&State1Context::event3_handler)); + } + +} state_1; + + +class State2Context +{ + MachineContext *context; +public: + State2Context(MachineContext *context):context(context) { printf("Entered State 2\n"); } + ~State2Context() { printf("Left State 2\n"); } + + Smach::event_result event1_handler(const Smach::event& x __attribute__ ((unused))) + { + printf("STATE2: Received Event 1\n"); + return Smach::RESULT_OK; + } + + Smach::event_result event2_handler(const Smach::event& x __attribute__ ((unused))) + { + printf("STATE2: Received Event 2\n"); + return Smach::RESULT_OK; + } + + Smach::event_result event3_handler(const Smach::event& x __attribute__ ((unused))) + { + printf("STATE2: Received Event 3\n"); + return Smach::RESULT_OK; + } +}; + +class State2 : public Smach::state +{ +public: + State2():Smach::state("State2") + { + insert(event_def(EVENT_1,&State2Context::event1_handler)); + insert(event_def(EVENT_2,&State2Context::event2_handler)); + insert(event_def(EVENT_3,&State2Context::event3_handler)); + } + +} state_2; + +Smach::event_result +State1Context::event3_handler(const Smach::event& x __attribute__ ((unused))) +{ + printf("STATE1: Received Event 3, throwing state to change to...\n"); + + throw &state_2; +// context->machine.enter(&state_2); +// return Smach::RESULT_ACCEPT; +} + +/* === G L O B A L S ======================================================= */ + +/* === E N T R Y P O I N T ================================================= */ + +int main() +{ + int error=0; + + MachineContext context; + try + { + Smach& state_machine(context.machine); + + state_machine.set_default_state(&default_state); + + state_machine.enter(&state_1); + + state_machine.process_event(Event1()); + state_machine.process_event(EVENT_1); + state_machine.process_event(EVENT_2); + state_machine.process_event(EVENT_3); + + state_machine.process_event(Event1()); + state_machine.process_event(EVENT_1); + state_machine.process_event(EVENT_2); + state_machine.process_event(EVENT_3); + + state_machine.process_event(Event1()); + state_machine.process_event(EVENT_1); + state_machine.process_event(EVENT_2); + state_machine.process_event(EVENT_3); + } + catch(...) + { + printf("Uncaught exception\n"); + error++; + } + + return error; +} diff --git a/ETL/tags/0.61.06/test/smart_ptr.cpp b/ETL/tags/0.61.06/test/smart_ptr.cpp new file mode 100644 index 0000000..0d3efc9 --- /dev/null +++ b/ETL/tags/0.61.06/test/smart_ptr.cpp @@ -0,0 +1,319 @@ +/*! ======================================================================== +** Extended Template and Library Test Suite +** Smart Pointer Template Class Test +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +//#define DEBUGPOINT() fprintf(stderr,__FILE__":%d: DEBUGPOINT\n",__LINE__) +#define DEBUGPOINT() + +/* === H E A D E R S ======================================================= */ + +#include +#include +#include +#include +#include +#include + +/* === M A C R O S ========================================================= */ + +#define NUMBER_OF_OBJECTS 40000 +using namespace std; + + +/* === C L A S S E S ======================================================= */ + +struct my_test_obj +{ + static int instance_count; + int my_id; + my_test_obj(int my_id=0):my_id(my_id) + { + instance_count++; + } + + virtual ~my_test_obj() + { + if(instance_count==0) + printf("Error, instance count is going past zero!\n"); + instance_count--; + } + + bool operator<(const my_test_obj &rhs)const + { + return my_id obj_smart_ptr; +typedef etl::smart_ptr other_obj_smart_ptr; +typedef list< obj_smart_ptr > obj_list; +typedef list< other_obj_smart_ptr > other_obj_list; + +int smart_ptr_basic_test(void) +{ + printf("smart_ptr: Size of a smart_ptr: %u\n",(unsigned int)sizeof(obj_smart_ptr)); + printf("smart_ptr: Size of a reference_counter: %u\n",(unsigned int)sizeof(etl::reference_counter)); + + + printf("smart_ptr: Basic test: "); + my_test_obj::instance_count=0; + + { + etl::smart_ptr obj_smart_ptr(new my_test_obj(rand())); + } + + if(my_test_obj::instance_count!=0) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on create/distroy, instance count=%d, should be zero.\n",__LINE__,my_test_obj::instance_count); + return 1; + } + + { + DEBUGPOINT(); + map > my_map; + DEBUGPOINT(); + //etl::smart_ptr obj_smart_ptr(new my_test_obj(rand())); + etl::smart_ptr temp; + temp.spawn(); + DEBUGPOINT(); + temp.reset(); + DEBUGPOINT(); + my_map["bleh"]=temp; + DEBUGPOINT(); + } + + if(my_test_obj::instance_count!=0) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on create/distroy, instance count=%d, should be zero.\n",__LINE__,my_test_obj::instance_count); + return 1; + } + + etl::smart_ptr obj_smart_ptr(new my_test_obj(rand())); + + if(obj_smart_ptr != obj_smart_ptr.constant()) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on call to smart_ptr<>::constant().\n",__LINE__); + return 1; + } + + printf("PASSED\n"); + + return 0; +} + +int smart_ptr_general_use_test(void) +{ + printf("smart_ptr: General-use test: "); + my_test_obj::instance_count=0; + + obj_list my_list, my_other_list; + int i; + + for(i=0;i smart_ptr __attribute__ ((unused))) +{ +} + +int loose_smart_ptr_test(void) +{ + printf("smart_ptr: loose_smart_ptr test: "); + my_test_obj::instance_count=0; + + etl::loose_smart_ptr obj_smart_ptr_loose; + etl::smart_ptr obj_smart_ptr2; + + { + etl::smart_ptr obj_smart_ptr(new my_test_obj(rand())); + if(my_test_obj::instance_count!=1) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on smart_ptr assignment from new object, instance count=%d, should be 1.\n",__LINE__,my_test_obj::instance_count); + return 1; + } + + obj_smart_ptr_loose=obj_smart_ptr; + if(obj_smart_ptr!=obj_smart_ptr_loose) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on loose_smart_ptr assignment\n",__LINE__); + return 1; + } + + obj_smart_ptr2=obj_smart_ptr_loose; + if(my_test_obj::instance_count!=1) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on smart_ptr assignment from loose_smart_ptr, instance count=%d, should be 1.\n",__LINE__,my_test_obj::instance_count); + return 1; + } + + test_func(obj_smart_ptr_loose); + if(my_test_obj::instance_count!=1) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on smart_ptr assignment from loose_smart_ptr, instance count=%d, should be 1.\n",__LINE__,my_test_obj::instance_count); + return 1; + } + } + + if(my_test_obj::instance_count!=1) + { + printf("FAILED!\n"); + printf(__FILE__":%d: on create/destroy, instance count=%d, should be 1.\n",__LINE__,my_test_obj::instance_count); + return 1; + } + + printf("PASSED\n"); + return 0; +} + +/* === E N T R Y P O I N T ================================================= */ + +int main() +{ + int error=0; + + error+=smart_ptr_basic_test(); + error+=smart_ptr_general_use_test(); + error+=smart_ptr_inheritance_test(); + error+=loose_smart_ptr_test(); + + return error; +} diff --git a/ETL/tags/0.61.06/test/spline.cpp b/ETL/tags/0.61.06/test/spline.cpp new file mode 100644 index 0000000..eaae237 --- /dev/null +++ b/ETL/tags/0.61.06/test/spline.cpp @@ -0,0 +1,99 @@ +/*! ======================================================================== +** Extended Template and Library Test Suite +** Spline Curve Test +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#include +#include +#include +#include +#include + +/* === M A C R O S ========================================================= */ + +using namespace etl; + +/* === C L A S S E S ======================================================= */ + + +/* === P R O C E D U R E S ================================================= */ + +int bspline_basic_test(void) +{ + int ret=0; + float f; + + bspline BSpline; + etl::clock timer; + double t; + + *BSpline.cpoints().insert(BSpline.cpoints().end())=0; + *BSpline.cpoints().insert(BSpline.cpoints().end())=-1; + *BSpline.cpoints().insert(BSpline.cpoints().end())=0; + *BSpline.cpoints().insert(BSpline.cpoints().end())=1; + *BSpline.cpoints().insert(BSpline.cpoints().end())=0; + + BSpline.set_m(4); + BSpline.reset_knots(); + + integral > inte(BSpline); + + + /* + for(f=0.0;f<1.001;f+=0.05) + fprintf(stderr,"BSpline(%f)= %f\n",f,BSpline(f)); + */ + + fprintf(stderr,"integral of BSpline() on [0,1] = %f\n",inte(0,1.0)); + + + for(f=0.0f,timer.reset();f<1.001f;f+=0.000005f) + { + t+=BSpline(f)+BSpline(f+0.1f); + t+=BSpline(f)+BSpline(f+0.1f); + t+=BSpline(f)+BSpline(f+0.1f); + t+=BSpline(f)+BSpline(f+0.1f); + t+=BSpline(f)+BSpline(f+0.1f); + t+=BSpline(f)+BSpline(f+0.1f); + t+=BSpline(f)+BSpline(f+0.1f); + t+=BSpline(f)+BSpline(f+0.1f); + t+=BSpline(f)+BSpline(f+0.1f); + t+=BSpline(f)+BSpline(f+0.1f); + t+=BSpline(f)+BSpline(f+0.1f); + t+=BSpline(f)+BSpline(f+0.1f); + } + t=timer(); + + fprintf(stderr,"BSpline time=%f milliseconds\n",t*1000); + return ret; +} + +/* === E N T R Y P O I N T ================================================= */ + +int main() +{ + int error=0; + + error+=bspline_basic_test(); + + return error; +} + diff --git a/ETL/tags/0.61.06/test/stringf.cpp b/ETL/tags/0.61.06/test/stringf.cpp new file mode 100644 index 0000000..7c8346d --- /dev/null +++ b/ETL/tags/0.61.06/test/stringf.cpp @@ -0,0 +1,152 @@ +/*! ======================================================================== +** Extended Template and Library Test Suite +** stringf Procedure Test +** $Id$ +** +** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** +** === N O T E S =========================================================== +** +** ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#include +#include +#include + +/* === M A C R O S ========================================================= */ + +using namespace etl; +using namespace std; + +/* === C L A S S E S ======================================================= */ + + +/* === P R O C E D U R E S ================================================= */ + +int basic_test(void) +{ + int ret=0; + char mystring[80]="My formatted string!"; + string myotherstring="my other string!"; + + cout<>%s<<.",mystring)< "< "< "< "< "< "< "< "< "<=2.0f) + printf("#"); + else if(pen.get_value()>=1.0f) + printf("@"); + else if(pen.get_value()>=0.8f) + printf("%%"); + else if(pen.get_value()>=0.6f) + printf("O"); + else if(pen.get_value()>=0.4f) + printf(":"); + else if(pen.get_value()>=0.2f) + printf("."); + else if(pen.get_value()>=-0.1f) + printf(" "); + else + printf("X"),ret++; + } + pen.dec_x(x); + printf("|\n"); + } + pen.dec_y(y); + return ret; +} + +void make_pattern(generic_pen pen, int w, int h) +{ + int x,y; + for(y=0;y my_surface(100,100); + + gaussian_blur(my_surface.begin(),my_surface.end(),10,10); + + surface my_surface2(my_surface); + + my_surface2.fill(0.5); + my_surface2.clear(); + + my_surface2=my_surface; + + my_surface2.fill(0.5); + my_surface2.clear(); + + my_surface.fill(0.5); + my_surface.clear(); + + surface my_surface3; + my_surface3.mirror(my_surface2); + + my_surface3.fill(0.5); + my_surface3.clear(); + + my_surface3=my_surface; + + my_surface3.mirror(my_surface); + + printf("Surface:basic_test(): %d errors.\n",ret); + + return ret; +} + +int linear_sample_test() +{ + printf("Surface:linear_sample_test(): Running...\n"); + + int ret=0; + + surface my_surface(16,16); + + my_surface.fill(0.0f); + + make_pattern(my_surface.begin(),my_surface.get_w(),my_surface.get_h()); + + int extra(5); + surface dest(18+extra*2,18+extra*2); + + int x,y; + for(x=-extra;x my_surface(16,16); + + my_surface.fill(0.0f); + + make_pattern(my_surface.begin(),my_surface.get_w(),my_surface.get_h()); + + { + surface dest(24,24); + + int x,y; + for(x=0;x dest(16,16); + + int x,y; + for(x=0;x +#include + +/* === M A C R O S ========================================================= */ + +using namespace etl; + +/* === C L A S S E S ======================================================= */ + +/* === P R O C E D U R E S ================================================= */ + +/* === E N T R Y P O I N T ================================================= */ + +struct stupidv +{ + float x,y; + + stupidv(float xin=0, float yin=0) :x(xin),y(yin) {} + void print() const + { + printf("(x=%f,y=%f)\n",x,y); + } +}; + +struct stupidp +{ + float z,w; + + stupidp(float zin=0, float win=0) :z(zin),w(win) {} + + void print() const + { + printf("(z=%f,w=%f)\n",z,w); + } +}; + +template <> +class etl::value_store_type +{ + typedef stupidv value_type; +}; + +int main() +{ + try + { + value v(10.0); //construction + value v2; //default construct... + + //get type... + printf("type of 10.0: %s\n", v.type().name()); + + v2 = 1; //assignment + printf("type of 1: %s\n", v2.type().name()); + + //extract int test + + int *pi = value_cast(&v2); + printf("v2 is an int(%p)\n", pi); + printf(" %d\n", value_cast(v2)); + + printf(" const version: %d\n", value_cast(value(5))); + + v = 'c'; //assignment again... + printf("type of c: %s\n", v.type().name()); + + v2 = v; //value assignment + printf("type of v2 , v: %s , %s\n", v2.type().name(), v.type().name()); + + //random type test + v = stupidv(0,1); + printf("type of vec: %s\n", v.type().name()); + + //type cast with binary change test + value_cast(&v)->print(); + value_cast(stupidp(5,10)).print(); //copy test + + printf("type of v: %s\n", v.type().name()); + printf("type of v2: %s\n", v2.type().name()); + v.swap(v2); + printf("type of v: %s\n", v.type().name()); + printf("type of v2: %s\n", v2.type().name()); + + // test the exception throwing... + value_cast(stupidp(6,66)); + + }catch(const etl::bad_value_cast &e) + { + printf(" Exploded: %s\n",e.what()); + }catch(...) + { + printf(" Exploded\n"); + } + + return 0; +}