Cleaned up generated exd stuff

src/common/Exd/ExdDataGenerated.h

@@ -11,6 +11,7 @@
 #include <ExdCat.h>
 #include <Exd.h>
 #include <set>
+#include <boost/make_shared.hpp>
 
 namespace Core {
 namespace Data {
@@ -244,7 +245,9 @@ struct Omen;
 struct OnlineStatus;
 struct Opening;
 struct Orchestrion;
+struct OrchestrionCategory;
 struct OrchestrionPath;
+struct OrchestrionUiparam;
 struct ParamGrow;
 struct Pet;
 struct PetAction;
@@ -286,6 +289,9 @@ struct SpecialShopItemCategory;
 struct Stain;
 struct Status;
 struct Story;
+struct SubmarineExploration;
+struct SubmarinePart;
+struct SubmarineRank;
 struct SwitchTalk;
 struct TerritoryType;
 struct TextCommand;
@@ -490,7 +496,6 @@ struct Aetheryte
    uint16_t placeName;
    uint16_t aethernetName;
    uint16_t territory;
-   uint32_t destination;
    bool isAetheryte;
    uint8_t aethernetGroup;
    uint16_t map;
@@ -2297,6 +2302,7 @@ struct Leve
    int32_t placeNameStart;
    int32_t placeNameIssued;
    uint8_t classJobCategory;
+   int32_t journalGenre;
    int32_t placeNameStartZone;
    int32_t iconCityState;
    int32_t dataId;
@@ -2640,6 +2646,13 @@ struct Orchestrion
    Orchestrion( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
 };
 
+struct OrchestrionCategory
+{
+   std::string name;
+
+   OrchestrionCategory( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
+};
+
 struct OrchestrionPath
 {
    std::string file;
@@ -2647,6 +2660,14 @@ struct OrchestrionPath
    OrchestrionPath( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
 };
 
+struct OrchestrionUiparam
+{
+   uint8_t orchestrionCategory;
+   uint16_t order;
+
+   OrchestrionUiparam( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
+};
+
 struct ParamGrow
 {
    int32_t expToNext;
@@ -3117,6 +3138,41 @@ struct Story
    Story( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
 };
 
+struct SubmarineExploration
+{
+   std::string destination;
+   std::string location;
+   uint8_t rankReq;
+   uint8_t ceruleumTankReq;
+   uint16_t durationmin;
+   uint8_t distanceForSurvey;
+   uint32_t expReward;
+
+   SubmarineExploration( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
+};
+
+struct SubmarinePart
+{
+   uint8_t slot;
+   uint8_t rank;
+   uint8_t components;
+   int16_t surveillance;
+   int16_t retrieval;
+   int16_t speed;
+   int16_t range;
+   int16_t favor;
+   uint8_t repairMaterials;
+
+   SubmarinePart( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
+};
+
+struct SubmarineRank
+{
+   uint32_t expToNext;
+
+   SubmarineRank( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
+};
+
 struct SwitchTalk
 {
    std::vector< uint32_t > quest;
@@ -3666,7 +3722,9 @@ struct WorldDCGroupType
      xiv::exd::Exd m_OnlineStatusDat;
      xiv::exd::Exd m_OpeningDat;
      xiv::exd::Exd m_OrchestrionDat;
+     xiv::exd::Exd m_OrchestrionCategoryDat;
      xiv::exd::Exd m_OrchestrionPathDat;
+     xiv::exd::Exd m_OrchestrionUiparamDat;
      xiv::exd::Exd m_ParamGrowDat;
      xiv::exd::Exd m_PetDat;
      xiv::exd::Exd m_PetActionDat;
@@ -3708,6 +3766,9 @@ struct WorldDCGroupType
      xiv::exd::Exd m_StainDat;
      xiv::exd::Exd m_StatusDat;
      xiv::exd::Exd m_StoryDat;
+     xiv::exd::Exd m_SubmarineExplorationDat;
+     xiv::exd::Exd m_SubmarinePartDat;
+     xiv::exd::Exd m_SubmarineRankDat;
      xiv::exd::Exd m_SwitchTalkDat;
      xiv::exd::Exd m_TerritoryTypeDat;
      xiv::exd::Exd m_TextCommandDat;
@@ -3743,607 +3804,326 @@ struct WorldDCGroupType
 
 
      using AchievementPtr =  boost::shared_ptr< Achievement >;
-     AchievementPtr getAchievement( uint32_t AchievementId );
      using AchievementCategoryPtr =  boost::shared_ptr< AchievementCategory >;
-     AchievementCategoryPtr getAchievementCategory( uint32_t AchievementCategoryId );
      using AchievementKindPtr =  boost::shared_ptr< AchievementKind >;
-     AchievementKindPtr getAchievementKind( uint32_t AchievementKindId );
      using ActionPtr =  boost::shared_ptr< Action >;
-     ActionPtr getAction( uint32_t ActionId );
      using ActionCategoryPtr =  boost::shared_ptr< ActionCategory >;
-     ActionCategoryPtr getActionCategory( uint32_t ActionCategoryId );
      using ActionComboRoutePtr =  boost::shared_ptr< ActionComboRoute >;
-     ActionComboRoutePtr getActionComboRoute( uint32_t ActionComboRouteId );
      using ActionIndirectionPtr =  boost::shared_ptr< ActionIndirection >;
-     ActionIndirectionPtr getActionIndirection( uint32_t ActionIndirectionId );
      using ActionProcStatusPtr =  boost::shared_ptr< ActionProcStatus >;
-     ActionProcStatusPtr getActionProcStatus( uint32_t ActionProcStatusId );
      using ActionTimelinePtr =  boost::shared_ptr< ActionTimeline >;
-     ActionTimelinePtr getActionTimeline( uint32_t ActionTimelineId );
      using ActionTransientPtr =  boost::shared_ptr< ActionTransient >;
-     ActionTransientPtr getActionTransient( uint32_t ActionTransientId );
      using AddonPtr =  boost::shared_ptr< Addon >;
-     AddonPtr getAddon( uint32_t AddonId );
      using AdventurePtr =  boost::shared_ptr< Adventure >;
-     AdventurePtr getAdventure( uint32_t AdventureId );
      using AdventureExPhasePtr =  boost::shared_ptr< AdventureExPhase >;
-     AdventureExPhasePtr getAdventureExPhase( uint32_t AdventureExPhaseId );
      using AetherCurrentPtr =  boost::shared_ptr< AetherCurrent >;
-     AetherCurrentPtr getAetherCurrent( uint32_t AetherCurrentId );
      using AetherialWheelPtr =  boost::shared_ptr< AetherialWheel >;
-     AetherialWheelPtr getAetherialWheel( uint32_t AetherialWheelId );
      using AetherytePtr =  boost::shared_ptr< Aetheryte >;
-     AetherytePtr getAetheryte( uint32_t AetheryteId );
      using AirshipExplorationLevelPtr =  boost::shared_ptr< AirshipExplorationLevel >;
-     AirshipExplorationLevelPtr getAirshipExplorationLevel( uint32_t AirshipExplorationLevelId );
      using AirshipExplorationLogPtr =  boost::shared_ptr< AirshipExplorationLog >;
-     AirshipExplorationLogPtr getAirshipExplorationLog( uint32_t AirshipExplorationLogId );
      using AirshipExplorationParamTypePtr =  boost::shared_ptr< AirshipExplorationParamType >;
-     AirshipExplorationParamTypePtr getAirshipExplorationParamType( uint32_t AirshipExplorationParamTypeId );
      using AirshipExplorationPartPtr =  boost::shared_ptr< AirshipExplorationPart >;
-     AirshipExplorationPartPtr getAirshipExplorationPart( uint32_t AirshipExplorationPartId );
      using AirshipExplorationPointPtr =  boost::shared_ptr< AirshipExplorationPoint >;
-     AirshipExplorationPointPtr getAirshipExplorationPoint( uint32_t AirshipExplorationPointId );
      using AnimaWeapon5Ptr =  boost::shared_ptr< AnimaWeapon5 >;
-     AnimaWeapon5Ptr getAnimaWeapon5( uint32_t AnimaWeapon5Id );
      using AnimaWeapon5ParamPtr =  boost::shared_ptr< AnimaWeapon5Param >;
-     AnimaWeapon5ParamPtr getAnimaWeapon5Param( uint32_t AnimaWeapon5ParamId );
      using AnimaWeapon5PatternGroupPtr =  boost::shared_ptr< AnimaWeapon5PatternGroup >;
-     AnimaWeapon5PatternGroupPtr getAnimaWeapon5PatternGroup( uint32_t AnimaWeapon5PatternGroupId );
      using AnimaWeapon5SpiritTalkPtr =  boost::shared_ptr< AnimaWeapon5SpiritTalk >;
-     AnimaWeapon5SpiritTalkPtr getAnimaWeapon5SpiritTalk( uint32_t AnimaWeapon5SpiritTalkId );
      using AnimaWeapon5SpiritTalkParamPtr =  boost::shared_ptr< AnimaWeapon5SpiritTalkParam >;
-     AnimaWeapon5SpiritTalkParamPtr getAnimaWeapon5SpiritTalkParam( uint32_t AnimaWeapon5SpiritTalkParamId );
      using AnimaWeapon5TradeItemPtr =  boost::shared_ptr< AnimaWeapon5TradeItem >;
-     AnimaWeapon5TradeItemPtr getAnimaWeapon5TradeItem( uint32_t AnimaWeapon5TradeItemId );
      using AnimaWeaponFUITalkPtr =  boost::shared_ptr< AnimaWeaponFUITalk >;
-     AnimaWeaponFUITalkPtr getAnimaWeaponFUITalk( uint32_t AnimaWeaponFUITalkId );
      using AnimaWeaponFUITalkParamPtr =  boost::shared_ptr< AnimaWeaponFUITalkParam >;
-     AnimaWeaponFUITalkParamPtr getAnimaWeaponFUITalkParam( uint32_t AnimaWeaponFUITalkParamId );
      using AnimaWeaponIconPtr =  boost::shared_ptr< AnimaWeaponIcon >;
-     AnimaWeaponIconPtr getAnimaWeaponIcon( uint32_t AnimaWeaponIconId );
      using AnimaWeaponItemPtr =  boost::shared_ptr< AnimaWeaponItem >;
-     AnimaWeaponItemPtr getAnimaWeaponItem( uint32_t AnimaWeaponItemId );
      using AquariumFishPtr =  boost::shared_ptr< AquariumFish >;
-     AquariumFishPtr getAquariumFish( uint32_t AquariumFishId );
      using AquariumWaterPtr =  boost::shared_ptr< AquariumWater >;
-     AquariumWaterPtr getAquariumWater( uint32_t AquariumWaterId );
      using AttackTypePtr =  boost::shared_ptr< AttackType >;
-     AttackTypePtr getAttackType( uint32_t AttackTypeId );
      using BalloonPtr =  boost::shared_ptr< Balloon >;
-     BalloonPtr getBalloon( uint32_t BalloonId );
      using BaseParamPtr =  boost::shared_ptr< BaseParam >;
-     BaseParamPtr getBaseParam( uint32_t BaseParamId );
      using BattleLevePtr =  boost::shared_ptr< BattleLeve >;
-     BattleLevePtr getBattleLeve( uint32_t BattleLeveId );
      using BeastRankBonusPtr =  boost::shared_ptr< BeastRankBonus >;
-     BeastRankBonusPtr getBeastRankBonus( uint32_t BeastRankBonusId );
      using BeastReputationRankPtr =  boost::shared_ptr< BeastReputationRank >;
-     BeastReputationRankPtr getBeastReputationRank( uint32_t BeastReputationRankId );
      using BeastTribePtr =  boost::shared_ptr< BeastTribe >;
-     BeastTribePtr getBeastTribe( uint32_t BeastTribeId );
      using BehaviorPtr =  boost::shared_ptr< Behavior >;
-     BehaviorPtr getBehavior( uint32_t BehaviorId );
      using BGMPtr =  boost::shared_ptr< BGM >;
-     BGMPtr getBGM( uint32_t BGMId );
      using BNpcAnnounceIconPtr =  boost::shared_ptr< BNpcAnnounceIcon >;
-     BNpcAnnounceIconPtr getBNpcAnnounceIcon( uint32_t BNpcAnnounceIconId );
      using BNpcBasePtr =  boost::shared_ptr< BNpcBase >;
-     BNpcBasePtr getBNpcBase( uint32_t BNpcBaseId );
      using BNpcCustomizePtr =  boost::shared_ptr< BNpcCustomize >;
-     BNpcCustomizePtr getBNpcCustomize( uint32_t BNpcCustomizeId );
      using BNpcNamePtr =  boost::shared_ptr< BNpcName >;
-     BNpcNamePtr getBNpcName( uint32_t BNpcNameId );
      using BuddyActionPtr =  boost::shared_ptr< BuddyAction >;
-     BuddyActionPtr getBuddyAction( uint32_t BuddyActionId );
      using BuddyEquipPtr =  boost::shared_ptr< BuddyEquip >;
-     BuddyEquipPtr getBuddyEquip( uint32_t BuddyEquipId );
      using BuddyItemPtr =  boost::shared_ptr< BuddyItem >;
-     BuddyItemPtr getBuddyItem( uint32_t BuddyItemId );
      using BuddyRankPtr =  boost::shared_ptr< BuddyRank >;
-     BuddyRankPtr getBuddyRank( uint32_t BuddyRankId );
      using BuddySkillPtr =  boost::shared_ptr< BuddySkill >;
-     BuddySkillPtr getBuddySkill( uint32_t BuddySkillId );
      using CabinetPtr =  boost::shared_ptr< Cabinet >;
-     CabinetPtr getCabinet( uint32_t CabinetId );
      using CabinetCategoryPtr =  boost::shared_ptr< CabinetCategory >;
-     CabinetCategoryPtr getCabinetCategory( uint32_t CabinetCategoryId );
      using CalendarPtr =  boost::shared_ptr< Calendar >;
-     CalendarPtr getCalendar( uint32_t CalendarId );
      using CharaMakeCustomizePtr =  boost::shared_ptr< CharaMakeCustomize >;
-     CharaMakeCustomizePtr getCharaMakeCustomize( uint32_t CharaMakeCustomizeId );
      using CharaMakeTypePtr =  boost::shared_ptr< CharaMakeType >;
-     CharaMakeTypePtr getCharaMakeType( uint32_t CharaMakeTypeId );
      using ChocoboRacePtr =  boost::shared_ptr< ChocoboRace >;
-     ChocoboRacePtr getChocoboRace( uint32_t ChocoboRaceId );
      using ChocoboRaceAbilityPtr =  boost::shared_ptr< ChocoboRaceAbility >;
-     ChocoboRaceAbilityPtr getChocoboRaceAbility( uint32_t ChocoboRaceAbilityId );
      using ChocoboRaceAbilityTypePtr =  boost::shared_ptr< ChocoboRaceAbilityType >;
-     ChocoboRaceAbilityTypePtr getChocoboRaceAbilityType( uint32_t ChocoboRaceAbilityTypeId );
      using ChocoboRaceItemPtr =  boost::shared_ptr< ChocoboRaceItem >;
-     ChocoboRaceItemPtr getChocoboRaceItem( uint32_t ChocoboRaceItemId );
      using ChocoboRaceRankPtr =  boost::shared_ptr< ChocoboRaceRank >;
-     ChocoboRaceRankPtr getChocoboRaceRank( uint32_t ChocoboRaceRankId );
      using ChocoboRaceStatusPtr =  boost::shared_ptr< ChocoboRaceStatus >;
-     ChocoboRaceStatusPtr getChocoboRaceStatus( uint32_t ChocoboRaceStatusId );
      using ChocoboRaceTerritoryPtr =  boost::shared_ptr< ChocoboRaceTerritory >;
-     ChocoboRaceTerritoryPtr getChocoboRaceTerritory( uint32_t ChocoboRaceTerritoryId );
      using ChocoboTaxiStandPtr =  boost::shared_ptr< ChocoboTaxiStand >;
-     ChocoboTaxiStandPtr getChocoboTaxiStand( uint32_t ChocoboTaxiStandId );
      using ClassJobPtr =  boost::shared_ptr< ClassJob >;
-     ClassJobPtr getClassJob( uint32_t ClassJobId );
      using ClassJobCategoryPtr =  boost::shared_ptr< ClassJobCategory >;
-     ClassJobCategoryPtr getClassJobCategory( uint32_t ClassJobCategoryId );
      using CompanionPtr =  boost::shared_ptr< Companion >;
-     CompanionPtr getCompanion( uint32_t CompanionId );
      using CompanionMovePtr =  boost::shared_ptr< CompanionMove >;
-     CompanionMovePtr getCompanionMove( uint32_t CompanionMoveId );
      using CompanionTransientPtr =  boost::shared_ptr< CompanionTransient >;
-     CompanionTransientPtr getCompanionTransient( uint32_t CompanionTransientId );
      using CompanyActionPtr =  boost::shared_ptr< CompanyAction >;
-     CompanyActionPtr getCompanyAction( uint32_t CompanyActionId );
      using CompanyCraftDraftPtr =  boost::shared_ptr< CompanyCraftDraft >;
-     CompanyCraftDraftPtr getCompanyCraftDraft( uint32_t CompanyCraftDraftId );
      using CompanyCraftDraftCategoryPtr =  boost::shared_ptr< CompanyCraftDraftCategory >;
-     CompanyCraftDraftCategoryPtr getCompanyCraftDraftCategory( uint32_t CompanyCraftDraftCategoryId );
      using CompanyCraftManufactoryStatePtr =  boost::shared_ptr< CompanyCraftManufactoryState >;
-     CompanyCraftManufactoryStatePtr getCompanyCraftManufactoryState( uint32_t CompanyCraftManufactoryStateId );
      using CompanyCraftPartPtr =  boost::shared_ptr< CompanyCraftPart >;
-     CompanyCraftPartPtr getCompanyCraftPart( uint32_t CompanyCraftPartId );
      using CompanyCraftProcessPtr =  boost::shared_ptr< CompanyCraftProcess >;
-     CompanyCraftProcessPtr getCompanyCraftProcess( uint32_t CompanyCraftProcessId );
      using CompanyCraftSequencePtr =  boost::shared_ptr< CompanyCraftSequence >;
-     CompanyCraftSequencePtr getCompanyCraftSequence( uint32_t CompanyCraftSequenceId );
      using CompanyCraftSupplyItemPtr =  boost::shared_ptr< CompanyCraftSupplyItem >;
-     CompanyCraftSupplyItemPtr getCompanyCraftSupplyItem( uint32_t CompanyCraftSupplyItemId );
      using CompanyCraftTypePtr =  boost::shared_ptr< CompanyCraftType >;
-     CompanyCraftTypePtr getCompanyCraftType( uint32_t CompanyCraftTypeId );
      using CompleteJournalPtr =  boost::shared_ptr< CompleteJournal >;
-     CompleteJournalPtr getCompleteJournal( uint32_t CompleteJournalId );
      using CompleteJournalCategoryPtr =  boost::shared_ptr< CompleteJournalCategory >;
-     CompleteJournalCategoryPtr getCompleteJournalCategory( uint32_t CompleteJournalCategoryId );
      using ContentExActionPtr =  boost::shared_ptr< ContentExAction >;
-     ContentExActionPtr getContentExAction( uint32_t ContentExActionId );
      using ContentFinderConditionPtr =  boost::shared_ptr< ContentFinderCondition >;
-     ContentFinderConditionPtr getContentFinderCondition( uint32_t ContentFinderConditionId );
      using ContentFinderConditionTransientPtr =  boost::shared_ptr< ContentFinderConditionTransient >;
-     ContentFinderConditionTransientPtr getContentFinderConditionTransient( uint32_t ContentFinderConditionTransientId );
      using ContentMemberTypePtr =  boost::shared_ptr< ContentMemberType >;
-     ContentMemberTypePtr getContentMemberType( uint32_t ContentMemberTypeId );
      using ContentRoulettePtr =  boost::shared_ptr< ContentRoulette >;
-     ContentRoulettePtr getContentRoulette( uint32_t ContentRouletteId );
      using ContentTypePtr =  boost::shared_ptr< ContentType >;
-     ContentTypePtr getContentType( uint32_t ContentTypeId );
      using CraftActionPtr =  boost::shared_ptr< CraftAction >;
-     CraftActionPtr getCraftAction( uint32_t CraftActionId );
      using CraftLevePtr =  boost::shared_ptr< CraftLeve >;
-     CraftLevePtr getCraftLeve( uint32_t CraftLeveId );
      using CraftTypePtr =  boost::shared_ptr< CraftType >;
-     CraftTypePtr getCraftType( uint32_t CraftTypeId );
      using CurrencyPtr =  boost::shared_ptr< Currency >;
-     CurrencyPtr getCurrency( uint32_t CurrencyId );
      using CustomTalkPtr =  boost::shared_ptr< CustomTalk >;
-     CustomTalkPtr getCustomTalk( uint32_t CustomTalkId );
      using CutscenePtr =  boost::shared_ptr< Cutscene >;
-     CutscenePtr getCutscene( uint32_t CutsceneId );
      using CutScreenImagePtr =  boost::shared_ptr< CutScreenImage >;
-     CutScreenImagePtr getCutScreenImage( uint32_t CutScreenImageId );
      using DailySupplyItemPtr =  boost::shared_ptr< DailySupplyItem >;
-     DailySupplyItemPtr getDailySupplyItem( uint32_t DailySupplyItemId );
      using DeepDungeonBanPtr =  boost::shared_ptr< DeepDungeonBan >;
-     DeepDungeonBanPtr getDeepDungeonBan( uint32_t DeepDungeonBanId );
      using DeepDungeonDangerPtr =  boost::shared_ptr< DeepDungeonDanger >;
-     DeepDungeonDangerPtr getDeepDungeonDanger( uint32_t DeepDungeonDangerId );
      using DeepDungeonEquipmentPtr =  boost::shared_ptr< DeepDungeonEquipment >;
-     DeepDungeonEquipmentPtr getDeepDungeonEquipment( uint32_t DeepDungeonEquipmentId );
      using DeepDungeonFloorEffectUIPtr =  boost::shared_ptr< DeepDungeonFloorEffectUI >;
-     DeepDungeonFloorEffectUIPtr getDeepDungeonFloorEffectUI( uint32_t DeepDungeonFloorEffectUIId );
      using DeepDungeonItemPtr =  boost::shared_ptr< DeepDungeonItem >;
-     DeepDungeonItemPtr getDeepDungeonItem( uint32_t DeepDungeonItemId );
      using DeepDungeonStatusPtr =  boost::shared_ptr< DeepDungeonStatus >;
-     DeepDungeonStatusPtr getDeepDungeonStatus( uint32_t DeepDungeonStatusId );
      using DefaultTalkPtr =  boost::shared_ptr< DefaultTalk >;
-     DefaultTalkPtr getDefaultTalk( uint32_t DefaultTalkId );
      using DeliveryQuestPtr =  boost::shared_ptr< DeliveryQuest >;
-     DeliveryQuestPtr getDeliveryQuest( uint32_t DeliveryQuestId );
      using DisposalShopPtr =  boost::shared_ptr< DisposalShop >;
-     DisposalShopPtr getDisposalShop( uint32_t DisposalShopId );
      using DisposalShopFilterTypePtr =  boost::shared_ptr< DisposalShopFilterType >;
-     DisposalShopFilterTypePtr getDisposalShopFilterType( uint32_t DisposalShopFilterTypeId );
      using DisposalShopItemPtr =  boost::shared_ptr< DisposalShopItem >;
-     DisposalShopItemPtr getDisposalShopItem( uint32_t DisposalShopItemId );
      using DpsChallengePtr =  boost::shared_ptr< DpsChallenge >;
-     DpsChallengePtr getDpsChallenge( uint32_t DpsChallengeId );
      using DpsChallengeOfficerPtr =  boost::shared_ptr< DpsChallengeOfficer >;
-     DpsChallengeOfficerPtr getDpsChallengeOfficer( uint32_t DpsChallengeOfficerId );
      using DpsChallengeTransientPtr =  boost::shared_ptr< DpsChallengeTransient >;
-     DpsChallengeTransientPtr getDpsChallengeTransient( uint32_t DpsChallengeTransientId );
      using EmotePtr =  boost::shared_ptr< Emote >;
-     EmotePtr getEmote( uint32_t EmoteId );
      using EmoteCategoryPtr =  boost::shared_ptr< EmoteCategory >;
-     EmoteCategoryPtr getEmoteCategory( uint32_t EmoteCategoryId );
      using ENpcBasePtr =  boost::shared_ptr< ENpcBase >;
-     ENpcBasePtr getENpcBase( uint32_t ENpcBaseId );
      using ENpcResidentPtr =  boost::shared_ptr< ENpcResident >;
-     ENpcResidentPtr getENpcResident( uint32_t ENpcResidentId );
      using EObjPtr =  boost::shared_ptr< EObj >;
-     EObjPtr getEObj( uint32_t EObjId );
      using EquipRaceCategoryPtr =  boost::shared_ptr< EquipRaceCategory >;
-     EquipRaceCategoryPtr getEquipRaceCategory( uint32_t EquipRaceCategoryId );
      using EquipSlotCategoryPtr =  boost::shared_ptr< EquipSlotCategory >;
-     EquipSlotCategoryPtr getEquipSlotCategory( uint32_t EquipSlotCategoryId );
      using EventActionPtr =  boost::shared_ptr< EventAction >;
-     EventActionPtr getEventAction( uint32_t EventActionId );
      using EventIconPriorityPtr =  boost::shared_ptr< EventIconPriority >;
-     EventIconPriorityPtr getEventIconPriority( uint32_t EventIconPriorityId );
      using EventIconTypePtr =  boost::shared_ptr< EventIconType >;
-     EventIconTypePtr getEventIconType( uint32_t EventIconTypeId );
      using EventItemPtr =  boost::shared_ptr< EventItem >;
-     EventItemPtr getEventItem( uint32_t EventItemId );
      using EventItemHelpPtr =  boost::shared_ptr< EventItemHelp >;
-     EventItemHelpPtr getEventItemHelp( uint32_t EventItemHelpId );
      using ExVersionPtr =  boost::shared_ptr< ExVersion >;
-     ExVersionPtr getExVersion( uint32_t ExVersionId );
      using FatePtr =  boost::shared_ptr< Fate >;
-     FatePtr getFate( uint32_t FateId );
      using FCActivityPtr =  boost::shared_ptr< FCActivity >;
-     FCActivityPtr getFCActivity( uint32_t FCActivityId );
      using FCActivityCategoryPtr =  boost::shared_ptr< FCActivityCategory >;
-     FCActivityCategoryPtr getFCActivityCategory( uint32_t FCActivityCategoryId );
      using FCAuthorityPtr =  boost::shared_ptr< FCAuthority >;
-     FCAuthorityPtr getFCAuthority( uint32_t FCAuthorityId );
      using FCAuthorityCategoryPtr =  boost::shared_ptr< FCAuthorityCategory >;
-     FCAuthorityCategoryPtr getFCAuthorityCategory( uint32_t FCAuthorityCategoryId );
      using FCChestNamePtr =  boost::shared_ptr< FCChestName >;
-     FCChestNamePtr getFCChestName( uint32_t FCChestNameId );
      using FccShopPtr =  boost::shared_ptr< FccShop >;
-     FccShopPtr getFccShop( uint32_t FccShopId );
      using FCHierarchyPtr =  boost::shared_ptr< FCHierarchy >;
-     FCHierarchyPtr getFCHierarchy( uint32_t FCHierarchyId );
      using FCProfilePtr =  boost::shared_ptr< FCProfile >;
-     FCProfilePtr getFCProfile( uint32_t FCProfileId );
      using FCReputationPtr =  boost::shared_ptr< FCReputation >;
-     FCReputationPtr getFCReputation( uint32_t FCReputationId );
      using FCRightsPtr =  boost::shared_ptr< FCRights >;
-     FCRightsPtr getFCRights( uint32_t FCRightsId );
      using FishingSpotPtr =  boost::shared_ptr< FishingSpot >;
-     FishingSpotPtr getFishingSpot( uint32_t FishingSpotId );
      using FishParameterPtr =  boost::shared_ptr< FishParameter >;
-     FishParameterPtr getFishParameter( uint32_t FishParameterId );
      using GardeningSeedPtr =  boost::shared_ptr< GardeningSeed >;
-     GardeningSeedPtr getGardeningSeed( uint32_t GardeningSeedId );
      using GatheringConditionPtr =  boost::shared_ptr< GatheringCondition >;
-     GatheringConditionPtr getGatheringCondition( uint32_t GatheringConditionId );
      using GatheringExpPtr =  boost::shared_ptr< GatheringExp >;
-     GatheringExpPtr getGatheringExp( uint32_t GatheringExpId );
      using GatheringItemPtr =  boost::shared_ptr< GatheringItem >;
-     GatheringItemPtr getGatheringItem( uint32_t GatheringItemId );
      using GatheringItemLevelConvertTablePtr =  boost::shared_ptr< GatheringItemLevelConvertTable >;
-     GatheringItemLevelConvertTablePtr getGatheringItemLevelConvertTable( uint32_t GatheringItemLevelConvertTableId );
      using GatheringItemPointPtr =  boost::shared_ptr< GatheringItemPoint >;
-     GatheringItemPointPtr getGatheringItemPoint( uint32_t GatheringItemPointId );
      using GatheringNotebookListPtr =  boost::shared_ptr< GatheringNotebookList >;
-     GatheringNotebookListPtr getGatheringNotebookList( uint32_t GatheringNotebookListId );
      using GatheringPointPtr =  boost::shared_ptr< GatheringPoint >;
-     GatheringPointPtr getGatheringPoint( uint32_t GatheringPointId );
      using GatheringPointBasePtr =  boost::shared_ptr< GatheringPointBase >;
-     GatheringPointBasePtr getGatheringPointBase( uint32_t GatheringPointBaseId );
      using GatheringPointBonusPtr =  boost::shared_ptr< GatheringPointBonus >;
-     GatheringPointBonusPtr getGatheringPointBonus( uint32_t GatheringPointBonusId );
      using GatheringPointBonusTypePtr =  boost::shared_ptr< GatheringPointBonusType >;
-     GatheringPointBonusTypePtr getGatheringPointBonusType( uint32_t GatheringPointBonusTypeId );
      using GatheringPointNamePtr =  boost::shared_ptr< GatheringPointName >;
-     GatheringPointNamePtr getGatheringPointName( uint32_t GatheringPointNameId );
      using GatheringSubCategoryPtr =  boost::shared_ptr< GatheringSubCategory >;
-     GatheringSubCategoryPtr getGatheringSubCategory( uint32_t GatheringSubCategoryId );
      using GatheringTypePtr =  boost::shared_ptr< GatheringType >;
-     GatheringTypePtr getGatheringType( uint32_t GatheringTypeId );
      using GcArmyExpeditionPtr =  boost::shared_ptr< GcArmyExpedition >;
-     GcArmyExpeditionPtr getGcArmyExpedition( uint32_t GcArmyExpeditionId );
      using GcArmyExpeditionMemberBonusPtr =  boost::shared_ptr< GcArmyExpeditionMemberBonus >;
-     GcArmyExpeditionMemberBonusPtr getGcArmyExpeditionMemberBonus( uint32_t GcArmyExpeditionMemberBonusId );
      using GcArmyExpeditionTypePtr =  boost::shared_ptr< GcArmyExpeditionType >;
-     GcArmyExpeditionTypePtr getGcArmyExpeditionType( uint32_t GcArmyExpeditionTypeId );
      using GcArmyMemberGrowPtr =  boost::shared_ptr< GcArmyMemberGrow >;
-     GcArmyMemberGrowPtr getGcArmyMemberGrow( uint32_t GcArmyMemberGrowId );
      using GcArmyTrainingPtr =  boost::shared_ptr< GcArmyTraining >;
-     GcArmyTrainingPtr getGcArmyTraining( uint32_t GcArmyTrainingId );
      using GCRankGridaniaFemaleTextPtr =  boost::shared_ptr< GCRankGridaniaFemaleText >;
-     GCRankGridaniaFemaleTextPtr getGCRankGridaniaFemaleText( uint32_t GCRankGridaniaFemaleTextId );
      using GCRankGridaniaMaleTextPtr =  boost::shared_ptr< GCRankGridaniaMaleText >;
-     GCRankGridaniaMaleTextPtr getGCRankGridaniaMaleText( uint32_t GCRankGridaniaMaleTextId );
      using GCRankLimsaFemaleTextPtr =  boost::shared_ptr< GCRankLimsaFemaleText >;
-     GCRankLimsaFemaleTextPtr getGCRankLimsaFemaleText( uint32_t GCRankLimsaFemaleTextId );
      using GCRankLimsaMaleTextPtr =  boost::shared_ptr< GCRankLimsaMaleText >;
-     GCRankLimsaMaleTextPtr getGCRankLimsaMaleText( uint32_t GCRankLimsaMaleTextId );
      using GCRankUldahFemaleTextPtr =  boost::shared_ptr< GCRankUldahFemaleText >;
-     GCRankUldahFemaleTextPtr getGCRankUldahFemaleText( uint32_t GCRankUldahFemaleTextId );
      using GCRankUldahMaleTextPtr =  boost::shared_ptr< GCRankUldahMaleText >;
-     GCRankUldahMaleTextPtr getGCRankUldahMaleText( uint32_t GCRankUldahMaleTextId );
      using GCScripShopCategoryPtr =  boost::shared_ptr< GCScripShopCategory >;
-     GCScripShopCategoryPtr getGCScripShopCategory( uint32_t GCScripShopCategoryId );
      using GCScripShopItemPtr =  boost::shared_ptr< GCScripShopItem >;
-     GCScripShopItemPtr getGCScripShopItem( uint32_t GCScripShopItemId );
      using GCShopPtr =  boost::shared_ptr< GCShop >;
-     GCShopPtr getGCShop( uint32_t GCShopId );
      using GCShopItemCategoryPtr =  boost::shared_ptr< GCShopItemCategory >;
-     GCShopItemCategoryPtr getGCShopItemCategory( uint32_t GCShopItemCategoryId );
      using GCSupplyDutyPtr =  boost::shared_ptr< GCSupplyDuty >;
-     GCSupplyDutyPtr getGCSupplyDuty( uint32_t GCSupplyDutyId );
      using GCSupplyDutyRewardPtr =  boost::shared_ptr< GCSupplyDutyReward >;
-     GCSupplyDutyRewardPtr getGCSupplyDutyReward( uint32_t GCSupplyDutyRewardId );
      using GeneralActionPtr =  boost::shared_ptr< GeneralAction >;
-     GeneralActionPtr getGeneralAction( uint32_t GeneralActionId );
      using GilShopPtr =  boost::shared_ptr< GilShop >;
-     GilShopPtr getGilShop( uint32_t GilShopId );
      using GilShopItemPtr =  boost::shared_ptr< GilShopItem >;
-     GilShopItemPtr getGilShopItem( uint32_t GilShopItemId );
      using GoldSaucerTextDataPtr =  boost::shared_ptr< GoldSaucerTextData >;
-     GoldSaucerTextDataPtr getGoldSaucerTextData( uint32_t GoldSaucerTextDataId );
      using GrandCompanyPtr =  boost::shared_ptr< GrandCompany >;
-     GrandCompanyPtr getGrandCompany( uint32_t GrandCompanyId );
      using GrandCompanyRankPtr =  boost::shared_ptr< GrandCompanyRank >;
-     GrandCompanyRankPtr getGrandCompanyRank( uint32_t GrandCompanyRankId );
      using GuardianDeityPtr =  boost::shared_ptr< GuardianDeity >;
-     GuardianDeityPtr getGuardianDeity( uint32_t GuardianDeityId );
      using GuildleveAssignmentPtr =  boost::shared_ptr< GuildleveAssignment >;
-     GuildleveAssignmentPtr getGuildleveAssignment( uint32_t GuildleveAssignmentId );
      using GuildOrderGuidePtr =  boost::shared_ptr< GuildOrderGuide >;
-     GuildOrderGuidePtr getGuildOrderGuide( uint32_t GuildOrderGuideId );
      using GuildOrderOfficerPtr =  boost::shared_ptr< GuildOrderOfficer >;
-     GuildOrderOfficerPtr getGuildOrderOfficer( uint32_t GuildOrderOfficerId );
      using HouseRetainerPosePtr =  boost::shared_ptr< HouseRetainerPose >;
-     HouseRetainerPosePtr getHouseRetainerPose( uint32_t HouseRetainerPoseId );
      using HousingFurniturePtr =  boost::shared_ptr< HousingFurniture >;
-     HousingFurniturePtr getHousingFurniture( uint32_t HousingFurnitureId );
      using HousingYardObjectPtr =  boost::shared_ptr< HousingYardObject >;
-     HousingYardObjectPtr getHousingYardObject( uint32_t HousingYardObjectId );
      using InstanceContentPtr =  boost::shared_ptr< InstanceContent >;
-     InstanceContentPtr getInstanceContent( uint32_t InstanceContentId );
      using InstanceContentBuffPtr =  boost::shared_ptr< InstanceContentBuff >;
-     InstanceContentBuffPtr getInstanceContentBuff( uint32_t InstanceContentBuffId );
      using InstanceContentTextDataPtr =  boost::shared_ptr< InstanceContentTextData >;
-     InstanceContentTextDataPtr getInstanceContentTextData( uint32_t InstanceContentTextDataId );
      using InstanceContentTypePtr =  boost::shared_ptr< InstanceContentType >;
-     InstanceContentTypePtr getInstanceContentType( uint32_t InstanceContentTypeId );
      using ItemPtr =  boost::shared_ptr< Item >;
-     ItemPtr getItem( uint32_t ItemId );
      using ItemActionPtr =  boost::shared_ptr< ItemAction >;
-     ItemActionPtr getItemAction( uint32_t ItemActionId );
      using ItemFoodPtr =  boost::shared_ptr< ItemFood >;
-     ItemFoodPtr getItemFood( uint32_t ItemFoodId );
      using ItemSearchCategoryPtr =  boost::shared_ptr< ItemSearchCategory >;
-     ItemSearchCategoryPtr getItemSearchCategory( uint32_t ItemSearchCategoryId );
      using ItemSeriesPtr =  boost::shared_ptr< ItemSeries >;
-     ItemSeriesPtr getItemSeries( uint32_t ItemSeriesId );
      using ItemSpecialBonusPtr =  boost::shared_ptr< ItemSpecialBonus >;
-     ItemSpecialBonusPtr getItemSpecialBonus( uint32_t ItemSpecialBonusId );
      using ItemUICategoryPtr =  boost::shared_ptr< ItemUICategory >;
-     ItemUICategoryPtr getItemUICategory( uint32_t ItemUICategoryId );
      using JournalCategoryPtr =  boost::shared_ptr< JournalCategory >;
-     JournalCategoryPtr getJournalCategory( uint32_t JournalCategoryId );
      using JournalGenrePtr =  boost::shared_ptr< JournalGenre >;
-     JournalGenrePtr getJournalGenre( uint32_t JournalGenreId );
      using JournalSectionPtr =  boost::shared_ptr< JournalSection >;
-     JournalSectionPtr getJournalSection( uint32_t JournalSectionId );
      using LevePtr =  boost::shared_ptr< Leve >;
-     LevePtr getLeve( uint32_t LeveId );
      using LeveAssignmentTypePtr =  boost::shared_ptr< LeveAssignmentType >;
-     LeveAssignmentTypePtr getLeveAssignmentType( uint32_t LeveAssignmentTypeId );
      using LeveClientPtr =  boost::shared_ptr< LeveClient >;
-     LeveClientPtr getLeveClient( uint32_t LeveClientId );
      using LevelPtr =  boost::shared_ptr< Level >;
-     LevelPtr getLevel( uint32_t LevelId );
      using LeveRewardItemPtr =  boost::shared_ptr< LeveRewardItem >;
-     LeveRewardItemPtr getLeveRewardItem( uint32_t LeveRewardItemId );
      using LeveRewardItemGroupPtr =  boost::shared_ptr< LeveRewardItemGroup >;
-     LeveRewardItemGroupPtr getLeveRewardItemGroup( uint32_t LeveRewardItemGroupId );
      using LeveVfxPtr =  boost::shared_ptr< LeveVfx >;
-     LeveVfxPtr getLeveVfx( uint32_t LeveVfxId );
      using LogFilterPtr =  boost::shared_ptr< LogFilter >;
-     LogFilterPtr getLogFilter( uint32_t LogFilterId );
      using LogKindPtr =  boost::shared_ptr< LogKind >;
-     LogKindPtr getLogKind( uint32_t LogKindId );
      using LogKindCategoryTextPtr =  boost::shared_ptr< LogKindCategoryText >;
-     LogKindCategoryTextPtr getLogKindCategoryText( uint32_t LogKindCategoryTextId );
      using LogMessagePtr =  boost::shared_ptr< LogMessage >;
-     LogMessagePtr getLogMessage( uint32_t LogMessageId );
      using MacroIconPtr =  boost::shared_ptr< MacroIcon >;
-     MacroIconPtr getMacroIcon( uint32_t MacroIconId );
      using MacroIconRedirectOldPtr =  boost::shared_ptr< MacroIconRedirectOld >;
-     MacroIconRedirectOldPtr getMacroIconRedirectOld( uint32_t MacroIconRedirectOldId );
      using MainCommandPtr =  boost::shared_ptr< MainCommand >;
-     MainCommandPtr getMainCommand( uint32_t MainCommandId );
      using MainCommandCategoryPtr =  boost::shared_ptr< MainCommandCategory >;
-     MainCommandCategoryPtr getMainCommandCategory( uint32_t MainCommandCategoryId );
      using MapPtr =  boost::shared_ptr< Map >;
-     MapPtr getMap( uint32_t MapId );
      using MapMarkerPtr =  boost::shared_ptr< MapMarker >;
-     MapMarkerPtr getMapMarker( uint32_t MapMarkerId );
      using MapSymbolPtr =  boost::shared_ptr< MapSymbol >;
-     MapSymbolPtr getMapSymbol( uint32_t MapSymbolId );
      using MasterpieceSupplyDutyPtr =  boost::shared_ptr< MasterpieceSupplyDuty >;
-     MasterpieceSupplyDutyPtr getMasterpieceSupplyDuty( uint32_t MasterpieceSupplyDutyId );
      using MasterpieceSupplyMultiplierPtr =  boost::shared_ptr< MasterpieceSupplyMultiplier >;
-     MasterpieceSupplyMultiplierPtr getMasterpieceSupplyMultiplier( uint32_t MasterpieceSupplyMultiplierId );
      using MateriaPtr =  boost::shared_ptr< Materia >;
-     MateriaPtr getMateria( uint32_t MateriaId );
      using MinionRacePtr =  boost::shared_ptr< MinionRace >;
-     MinionRacePtr getMinionRace( uint32_t MinionRaceId );
      using MinionRulesPtr =  boost::shared_ptr< MinionRules >;
-     MinionRulesPtr getMinionRules( uint32_t MinionRulesId );
      using MinionSkillTypePtr =  boost::shared_ptr< MinionSkillType >;
-     MinionSkillTypePtr getMinionSkillType( uint32_t MinionSkillTypeId );
      using MobHuntTargetPtr =  boost::shared_ptr< MobHuntTarget >;
-     MobHuntTargetPtr getMobHuntTarget( uint32_t MobHuntTargetId );
      using ModelCharaPtr =  boost::shared_ptr< ModelChara >;
-     ModelCharaPtr getModelChara( uint32_t ModelCharaId );
      using MonsterNotePtr =  boost::shared_ptr< MonsterNote >;
-     MonsterNotePtr getMonsterNote( uint32_t MonsterNoteId );
      using MonsterNoteTargetPtr =  boost::shared_ptr< MonsterNoteTarget >;
-     MonsterNoteTargetPtr getMonsterNoteTarget( uint32_t MonsterNoteTargetId );
      using MountPtr =  boost::shared_ptr< Mount >;
-     MountPtr getMount( uint32_t MountId );
      using MountActionPtr =  boost::shared_ptr< MountAction >;
-     MountActionPtr getMountAction( uint32_t MountActionId );
      using NpcEquipPtr =  boost::shared_ptr< NpcEquip >;
-     NpcEquipPtr getNpcEquip( uint32_t NpcEquipId );
      using OmenPtr =  boost::shared_ptr< Omen >;
-     OmenPtr getOmen( uint32_t OmenId );
      using OnlineStatusPtr =  boost::shared_ptr< OnlineStatus >;
-     OnlineStatusPtr getOnlineStatus( uint32_t OnlineStatusId );
      using OpeningPtr =  boost::shared_ptr< Opening >;
-     OpeningPtr getOpening( uint32_t OpeningId );
      using OrchestrionPtr =  boost::shared_ptr< Orchestrion >;
-     OrchestrionPtr getOrchestrion( uint32_t OrchestrionId );
+     using OrchestrionCategoryPtr =  boost::shared_ptr< OrchestrionCategory >;
      using OrchestrionPathPtr =  boost::shared_ptr< OrchestrionPath >;
-     OrchestrionPathPtr getOrchestrionPath( uint32_t OrchestrionPathId );
+     using OrchestrionUiparamPtr =  boost::shared_ptr< OrchestrionUiparam >;
      using ParamGrowPtr =  boost::shared_ptr< ParamGrow >;
-     ParamGrowPtr getParamGrow( uint32_t ParamGrowId );
      using PetPtr =  boost::shared_ptr< Pet >;
-     PetPtr getPet( uint32_t PetId );
      using PetActionPtr =  boost::shared_ptr< PetAction >;
-     PetActionPtr getPetAction( uint32_t PetActionId );
      using PicturePtr =  boost::shared_ptr< Picture >;
-     PicturePtr getPicture( uint32_t PictureId );
      using PlaceNamePtr =  boost::shared_ptr< PlaceName >;
-     PlaceNamePtr getPlaceName( uint32_t PlaceNameId );
      using QuestPtr =  boost::shared_ptr< Quest >;
-     QuestPtr getQuest( uint32_t QuestId );
      using QuestRewardOtherPtr =  boost::shared_ptr< QuestRewardOther >;
-     QuestRewardOtherPtr getQuestRewardOther( uint32_t QuestRewardOtherId );
      using QuickChatPtr =  boost::shared_ptr< QuickChat >;
-     QuickChatPtr getQuickChat( uint32_t QuickChatId );
      using QuickChatTransientPtr =  boost::shared_ptr< QuickChatTransient >;
-     QuickChatTransientPtr getQuickChatTransient( uint32_t QuickChatTransientId );
      using RacePtr =  boost::shared_ptr< Race >;
-     RacePtr getRace( uint32_t RaceId );
      using RacingChocoboItemPtr =  boost::shared_ptr< RacingChocoboItem >;
-     RacingChocoboItemPtr getRacingChocoboItem( uint32_t RacingChocoboItemId );
      using RacingChocoboNamePtr =  boost::shared_ptr< RacingChocoboName >;
-     RacingChocoboNamePtr getRacingChocoboName( uint32_t RacingChocoboNameId );
      using RacingChocoboNameCategoryPtr =  boost::shared_ptr< RacingChocoboNameCategory >;
-     RacingChocoboNameCategoryPtr getRacingChocoboNameCategory( uint32_t RacingChocoboNameCategoryId );
      using RacingChocoboNameInfoPtr =  boost::shared_ptr< RacingChocoboNameInfo >;
-     RacingChocoboNameInfoPtr getRacingChocoboNameInfo( uint32_t RacingChocoboNameInfoId );
      using RacingChocoboParamPtr =  boost::shared_ptr< RacingChocoboParam >;
-     RacingChocoboParamPtr getRacingChocoboParam( uint32_t RacingChocoboParamId );
      using RecipePtr =  boost::shared_ptr< Recipe >;
-     RecipePtr getRecipe( uint32_t RecipeId );
      using RecipeElementPtr =  boost::shared_ptr< RecipeElement >;
-     RecipeElementPtr getRecipeElement( uint32_t RecipeElementId );
      using RecipeLevelTablePtr =  boost::shared_ptr< RecipeLevelTable >;
-     RecipeLevelTablePtr getRecipeLevelTable( uint32_t RecipeLevelTableId );
      using RecipeNotebookListPtr =  boost::shared_ptr< RecipeNotebookList >;
-     RecipeNotebookListPtr getRecipeNotebookList( uint32_t RecipeNotebookListId );
      using RelicPtr =  boost::shared_ptr< Relic >;
-     RelicPtr getRelic( uint32_t RelicId );
      using Relic3Ptr =  boost::shared_ptr< Relic3 >;
-     Relic3Ptr getRelic3( uint32_t Relic3Id );
      using RelicItemPtr =  boost::shared_ptr< RelicItem >;
-     RelicItemPtr getRelicItem( uint32_t RelicItemId );
      using RelicNotePtr =  boost::shared_ptr< RelicNote >;
-     RelicNotePtr getRelicNote( uint32_t RelicNoteId );
      using RelicNoteCategoryPtr =  boost::shared_ptr< RelicNoteCategory >;
-     RelicNoteCategoryPtr getRelicNoteCategory( uint32_t RelicNoteCategoryId );
      using RetainerTaskPtr =  boost::shared_ptr< RetainerTask >;
-     RetainerTaskPtr getRetainerTask( uint32_t RetainerTaskId );
      using RetainerTaskNormalPtr =  boost::shared_ptr< RetainerTaskNormal >;
-     RetainerTaskNormalPtr getRetainerTaskNormal( uint32_t RetainerTaskNormalId );
      using RetainerTaskParameterPtr =  boost::shared_ptr< RetainerTaskParameter >;
-     RetainerTaskParameterPtr getRetainerTaskParameter( uint32_t RetainerTaskParameterId );
      using RetainerTaskRandomPtr =  boost::shared_ptr< RetainerTaskRandom >;
-     RetainerTaskRandomPtr getRetainerTaskRandom( uint32_t RetainerTaskRandomId );
      using SalvagePtr =  boost::shared_ptr< Salvage >;
-     SalvagePtr getSalvage( uint32_t SalvageId );
      using SatisfactionNpcPtr =  boost::shared_ptr< SatisfactionNpc >;
-     SatisfactionNpcPtr getSatisfactionNpc( uint32_t SatisfactionNpcId );
      using SatisfactionSupplyPtr =  boost::shared_ptr< SatisfactionSupply >;
-     SatisfactionSupplyPtr getSatisfactionSupply( uint32_t SatisfactionSupplyId );
      using SatisfactionSupplyRewardPtr =  boost::shared_ptr< SatisfactionSupplyReward >;
-     SatisfactionSupplyRewardPtr getSatisfactionSupplyReward( uint32_t SatisfactionSupplyRewardId );
      using ScreenImagePtr =  boost::shared_ptr< ScreenImage >;
-     ScreenImagePtr getScreenImage( uint32_t ScreenImageId );
      using SecretRecipeBookPtr =  boost::shared_ptr< SecretRecipeBook >;
-     SecretRecipeBookPtr getSecretRecipeBook( uint32_t SecretRecipeBookId );
      using SpearfishingItemPtr =  boost::shared_ptr< SpearfishingItem >;
-     SpearfishingItemPtr getSpearfishingItem( uint32_t SpearfishingItemId );
      using SpearfishingNotebookPtr =  boost::shared_ptr< SpearfishingNotebook >;
-     SpearfishingNotebookPtr getSpearfishingNotebook( uint32_t SpearfishingNotebookId );
      using SpecialShopPtr =  boost::shared_ptr< SpecialShop >;
-     SpecialShopPtr getSpecialShop( uint32_t SpecialShopId );
      using SpecialShopItemCategoryPtr =  boost::shared_ptr< SpecialShopItemCategory >;
-     SpecialShopItemCategoryPtr getSpecialShopItemCategory( uint32_t SpecialShopItemCategoryId );
      using StainPtr =  boost::shared_ptr< Stain >;
-     StainPtr getStain( uint32_t StainId );
      using StatusPtr =  boost::shared_ptr< Status >;
-     StatusPtr getStatus( uint32_t StatusId );
      using StoryPtr =  boost::shared_ptr< Story >;
-     StoryPtr getStory( uint32_t StoryId );
+     using SubmarineExplorationPtr =  boost::shared_ptr< SubmarineExploration >;
+     using SubmarinePartPtr =  boost::shared_ptr< SubmarinePart >;
+     using SubmarineRankPtr =  boost::shared_ptr< SubmarineRank >;
      using SwitchTalkPtr =  boost::shared_ptr< SwitchTalk >;
-     SwitchTalkPtr getSwitchTalk( uint32_t SwitchTalkId );
      using TerritoryTypePtr =  boost::shared_ptr< TerritoryType >;
-     TerritoryTypePtr getTerritoryType( uint32_t TerritoryTypeId );
      using TextCommandPtr =  boost::shared_ptr< TextCommand >;
-     TextCommandPtr getTextCommand( uint32_t TextCommandId );
      using TitlePtr =  boost::shared_ptr< Title >;
-     TitlePtr getTitle( uint32_t TitleId );
      using TomestonesPtr =  boost::shared_ptr< Tomestones >;
-     TomestonesPtr getTomestones( uint32_t TomestonesId );
      using TomestonesItemPtr =  boost::shared_ptr< TomestonesItem >;
-     TomestonesItemPtr getTomestonesItem( uint32_t TomestonesItemId );
      using TopicSelectPtr =  boost::shared_ptr< TopicSelect >;
-     TopicSelectPtr getTopicSelect( uint32_t TopicSelectId );
      using TownPtr =  boost::shared_ptr< Town >;
-     TownPtr getTown( uint32_t TownId );
      using TraitPtr =  boost::shared_ptr< Trait >;
-     TraitPtr getTrait( uint32_t TraitId );
      using TraitRecastPtr =  boost::shared_ptr< TraitRecast >;
-     TraitRecastPtr getTraitRecast( uint32_t TraitRecastId );
      using TraitTransientPtr =  boost::shared_ptr< TraitTransient >;
-     TraitTransientPtr getTraitTransient( uint32_t TraitTransientId );
      using TreasureHuntRankPtr =  boost::shared_ptr< TreasureHuntRank >;
-     TreasureHuntRankPtr getTreasureHuntRank( uint32_t TreasureHuntRankId );
      using TribePtr =  boost::shared_ptr< Tribe >;
-     TribePtr getTribe( uint32_t TribeId );
      using TripleTriadPtr =  boost::shared_ptr< TripleTriad >;
-     TripleTriadPtr getTripleTriad( uint32_t TripleTriadId );
      using TripleTriadCardPtr =  boost::shared_ptr< TripleTriadCard >;
-     TripleTriadCardPtr getTripleTriadCard( uint32_t TripleTriadCardId );
      using TripleTriadCardRarityPtr =  boost::shared_ptr< TripleTriadCardRarity >;
-     TripleTriadCardRarityPtr getTripleTriadCardRarity( uint32_t TripleTriadCardRarityId );
      using TripleTriadCardResidentPtr =  boost::shared_ptr< TripleTriadCardResident >;
-     TripleTriadCardResidentPtr getTripleTriadCardResident( uint32_t TripleTriadCardResidentId );
      using TripleTriadCardTypePtr =  boost::shared_ptr< TripleTriadCardType >;
-     TripleTriadCardTypePtr getTripleTriadCardType( uint32_t TripleTriadCardTypeId );
      using TripleTriadCompetitionPtr =  boost::shared_ptr< TripleTriadCompetition >;
-     TripleTriadCompetitionPtr getTripleTriadCompetition( uint32_t TripleTriadCompetitionId );
      using TripleTriadRulePtr =  boost::shared_ptr< TripleTriadRule >;
-     TripleTriadRulePtr getTripleTriadRule( uint32_t TripleTriadRuleId );
      using TutorialPtr =  boost::shared_ptr< Tutorial >;
-     TutorialPtr getTutorial( uint32_t TutorialId );
      using TutorialDPSPtr =  boost::shared_ptr< TutorialDPS >;
-     TutorialDPSPtr getTutorialDPS( uint32_t TutorialDPSId );
      using TutorialHealerPtr =  boost::shared_ptr< TutorialHealer >;
-     TutorialHealerPtr getTutorialHealer( uint32_t TutorialHealerId );
      using TutorialTankPtr =  boost::shared_ptr< TutorialTank >;
-     TutorialTankPtr getTutorialTank( uint32_t TutorialTankId );
      using WarpPtr =  boost::shared_ptr< Warp >;
-     WarpPtr getWarp( uint32_t WarpId );
      using WeatherPtr =  boost::shared_ptr< Weather >;
-     WeatherPtr getWeather( uint32_t WeatherId );
      using WeatherGroupPtr =  boost::shared_ptr< WeatherGroup >;
-     WeatherGroupPtr getWeatherGroup( uint32_t WeatherGroupId );
      using WeatherRatePtr =  boost::shared_ptr< WeatherRate >;
-     WeatherRatePtr getWeatherRate( uint32_t WeatherRateId );
      using WeeklyBingoOrderDataPtr =  boost::shared_ptr< WeeklyBingoOrderData >;
-     WeeklyBingoOrderDataPtr getWeeklyBingoOrderData( uint32_t WeeklyBingoOrderDataId );
      using WeeklyBingoRewardDataPtr =  boost::shared_ptr< WeeklyBingoRewardData >;
-     WeeklyBingoRewardDataPtr getWeeklyBingoRewardData( uint32_t WeeklyBingoRewardDataId );
      using WeeklyBingoTextPtr =  boost::shared_ptr< WeeklyBingoText >;
-     WeeklyBingoTextPtr getWeeklyBingoText( uint32_t WeeklyBingoTextId );
      using WorldDCGroupTypePtr =  boost::shared_ptr< WorldDCGroupType >;
-     WorldDCGroupTypePtr getWorldDCGroupType( uint32_t WorldDCGroupTypeId );
+
+     template< class T >
+     boost::shared_ptr< T > get( uint32_t id )
+     {
+        try
+        {
+           auto info = boost::make_shared< T >( id, this );
+           return info;
+        }
+        catch( ... )
+        {
+           return nullptr;
+        }
+        return nullptr;
+     }
 
 
      std::set< uint32_t > m_AchievementIdList;
@@ -4573,7 +4353,9 @@ struct WorldDCGroupType
      std::set< uint32_t > m_OnlineStatusIdList;
      std::set< uint32_t > m_OpeningIdList;
      std::set< uint32_t > m_OrchestrionIdList;
+     std::set< uint32_t > m_OrchestrionCategoryIdList;
      std::set< uint32_t > m_OrchestrionPathIdList;
+     std::set< uint32_t > m_OrchestrionUiparamIdList;
      std::set< uint32_t > m_ParamGrowIdList;
      std::set< uint32_t > m_PetIdList;
      std::set< uint32_t > m_PetActionIdList;
@@ -4615,6 +4397,9 @@ struct WorldDCGroupType
      std::set< uint32_t > m_StainIdList;
      std::set< uint32_t > m_StatusIdList;
      std::set< uint32_t > m_StoryIdList;
+     std::set< uint32_t > m_SubmarineExplorationIdList;
+     std::set< uint32_t > m_SubmarinePartIdList;
+     std::set< uint32_t > m_SubmarineRankIdList;
      std::set< uint32_t > m_SwitchTalkIdList;
      std::set< uint32_t > m_TerritoryTypeIdList;
      std::set< uint32_t > m_TextCommandIdList;
@@ -6011,12 +5796,24 @@ const std::set< uint32_t >& getOrchestrionIdList()
       loadIdList( m_OrchestrionDat, m_OrchestrionIdList );
    return m_OrchestrionIdList;
 }
+const std::set< uint32_t >& getOrchestrionCategoryIdList()
+{
+   if( m_OrchestrionCategoryIdList.size() == 0 )
+      loadIdList( m_OrchestrionCategoryDat, m_OrchestrionCategoryIdList );
+   return m_OrchestrionCategoryIdList;
+}
 const std::set< uint32_t >& getOrchestrionPathIdList()
 {
    if( m_OrchestrionPathIdList.size() == 0 )
       loadIdList( m_OrchestrionPathDat, m_OrchestrionPathIdList );
    return m_OrchestrionPathIdList;
 }
+const std::set< uint32_t >& getOrchestrionUiparamIdList()
+{
+   if( m_OrchestrionUiparamIdList.size() == 0 )
+      loadIdList( m_OrchestrionUiparamDat, m_OrchestrionUiparamIdList );
+   return m_OrchestrionUiparamIdList;
+}
 const std::set< uint32_t >& getParamGrowIdList()
 {
    if( m_ParamGrowIdList.size() == 0 )
@@ -6263,6 +6060,24 @@ const std::set< uint32_t >& getStoryIdList()
       loadIdList( m_StoryDat, m_StoryIdList );
    return m_StoryIdList;
 }
+const std::set< uint32_t >& getSubmarineExplorationIdList()
+{
+   if( m_SubmarineExplorationIdList.size() == 0 )
+      loadIdList( m_SubmarineExplorationDat, m_SubmarineExplorationIdList );
+   return m_SubmarineExplorationIdList;
+}
+const std::set< uint32_t >& getSubmarinePartIdList()
+{
+   if( m_SubmarinePartIdList.size() == 0 )
+      loadIdList( m_SubmarinePartDat, m_SubmarinePartIdList );
+   return m_SubmarinePartIdList;
+}
+const std::set< uint32_t >& getSubmarineRankIdList()
+{
+   if( m_SubmarineRankIdList.size() == 0 )
+      loadIdList( m_SubmarineRankDat, m_SubmarineRankIdList );
+   return m_SubmarineRankIdList;
+}
 const std::set< uint32_t >& getSwitchTalkIdList()
 {
    if( m_SwitchTalkIdList.size() == 0 )

src/servers/sapphire_api/PlayerMinimal.cpp

@@ -220,7 +220,7 @@ namespace Core {
       // CharacterId, ClassIdx, Exp, Lvl
       auto stmtClass = g_charaDb.getPreparedStatement( Db::CharaDbStatements::CHARA_CLASS_INS );
       stmtClass->setInt( 1, m_id );
-      stmtClass->setInt( 2, g_exdDataGen.getClassJob( m_class )->expArrayIndex );
+      stmtClass->setInt( 2, g_exdDataGen.get< Core::Data::ClassJob >( m_class )->expArrayIndex );
       stmtClass->setInt( 3, 0 );
       stmtClass->setInt( 4, 1 );
       g_charaDb.directExecute( stmtClass );
@@ -292,14 +292,14 @@ namespace Core {
 
       ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       /// SETUP EQUIPMENT / STARTING GEAR
-      auto classJobInfo = g_exdDataGen.getClassJob( m_class );
+      auto classJobInfo = g_exdDataGen.get< Core::Data::ClassJob >( m_class );
       uint32_t weaponId = classJobInfo->itemStartingWeapon;
       uint64_t uniqueId = getNextUId64();
 
       uint8_t race = customize[CharaLook::Race];
       uint8_t gender = customize[CharaLook::Gender];
 
-      auto raceInfo = g_exdDataGen.getRace( race );
+      auto raceInfo = g_exdDataGen.get< Core::Data::Race >( race );
 
       uint32_t body;
       uint32_t hands;

src/servers/sapphire_api/main.cpp

@@ -241,7 +241,7 @@ std::string buildHttpResponse( uint16_t rCode, const std::string& content = "",
 void getZoneName( shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request ) 
 {
    string number = request->path_match[1];
-   auto info = g_exdDataGen.getTerritoryType( atoi( number.c_str() ) );
+   auto info = g_exdDataGen.get< Core::Data::TerritoryType >( atoi( number.c_str() ) );
    std::string responseStr = "Not found!";
    if( info )
       responseStr = info->name + ", " + info->bg;

src/servers/sapphire_zone/Action/ActionCast.cpp

@@ -31,7 +31,7 @@ Core::Action::ActionCast::ActionCast( Entity::ActorPtr pActor, Entity::ActorPtr
    m_startTime = 0;
    m_id = actionId;
    m_handleActionType = HandleActionType::Spell;
-   m_castTime = g_exdDataGen.getAction( actionId )->cast100ms * 100; // TODO: Add security checks.
+   m_castTime = g_exdDataGen.get< Core::Data::Action >( actionId )->cast100ms * 100; // TODO: Add security checks.
    m_pSource = pActor;
    m_pTarget = pTarget;
    m_bInterrupt = false;

src/servers/sapphire_zone/Action/ActionTeleport.cpp

@@ -26,7 +26,7 @@ Core::Action::ActionTeleport::ActionTeleport( Entity::ActorPtr pActor, uint16_t
    m_startTime = 0;
    m_id = 5;
    m_handleActionType = HandleActionType::Teleport;
-   m_castTime = g_exdDataGen.getAction( 5 )->cast100ms * 100; // TODO: Add security checks.
+   m_castTime = g_exdDataGen.get< Core::Data::Action >( 5 )->cast100ms * 100; // TODO: Add security checks.
    m_pSource = pActor;
    m_bInterrupt = false;
    m_targetAetheryte = targetZone;

src/servers/sapphire_zone/Action/EventAction.cpp

@@ -28,7 +28,7 @@ Core::Action::EventAction::EventAction( Entity::ActorPtr pActor, uint32_t eventI
    m_handleActionType = HandleActionType::Event;
    m_eventId = eventId;
    m_id = action;
-   m_castTime = g_exdDataGen.getEventAction( action )->castTime * 1000; // TODO: Add security checks.
+   m_castTime = g_exdDataGen.get< Core::Data::EventAction >( action )->castTime * 1000; // TODO: Add security checks.
    m_onActionFinishClb = finishRef;
    m_onActionInterruptClb = interruptRef;
    m_pSource = pActor;

src/servers/sapphire_zone/Actor/Actor.cpp

@@ -671,7 +671,7 @@ void Core::Entity::Actor::handleScriptSkill( uint32_t type, uint16_t actionId, u
       getAsPlayer()->sendDebug( "Handle script skill type: " + std::to_string( type ) );
    }
 
-   auto actionInfoPtr = g_exdDataGen.getAction( actionId );
+   auto actionInfoPtr = g_exdDataGen.get< Core::Data::Action >( actionId );
 
    // Todo: Effect packet generator. 90% of this is basically setting params and it's basically unreadable.
    // Prepare packet. This is seemingly common for all packets in the action handler.

src/servers/sapphire_zone/Actor/BattleNpc.cpp

@@ -418,7 +418,7 @@ void Core::Entity::BattleNpc::onDeath()
             auto levelDiff = static_cast< int32_t >( this->m_level ) - level;
             auto cappedLevelDiff = Math::Util::clamp( levelDiff, 1, 6 );
 
-            auto expNeeded = g_exdDataGen.getParamGrow( m_level + cappedLevelDiff - 1 )->expToNext;
+            auto expNeeded = g_exdDataGen.get< Core::Data::ParamGrow >( m_level + cappedLevelDiff - 1 )->expToNext;
             int32_t exp = 0;
 
             // todo: arbitrary numbers pulled out of my ass

src/servers/sapphire_zone/Actor/Player.cpp

@@ -210,9 +210,9 @@ void Core::Entity::Player::calculateStats()
    uint8_t level = getLevel();
    uint8_t job = static_cast< uint8_t >( getClass() );
 
-   auto classInfo = g_exdDataGen.getClassJob( job );
+   auto classInfo = g_exdDataGen.get< Core::Data::ClassJob >( job );
-   auto tribeInfo = g_exdDataGen.getTribe( tribe );
+   auto tribeInfo = g_exdDataGen.get< Core::Data::Tribe >( tribe );
-   auto paramGrowthInfo = g_exdDataGen.getParamGrow( level );
+   auto paramGrowthInfo = g_exdDataGen.get< Core::Data::ParamGrow >( level );
 
    // TODO: put formula somewhere else...
    float base = Math::CalcStats::calculateBaseStat( getAsPlayer() );
@@ -290,7 +290,7 @@ void Core::Entity::Player::sendStats()
 
 void Core::Entity::Player::teleport( uint16_t aetheryteId, uint8_t type )
 {
-   auto data = g_exdDataGen.getAetheryte( aetheryteId );
+   auto data = g_exdDataGen.get< Core::Data::Aetheryte >( aetheryteId );
 
    if( data == nullptr )
    {
@@ -299,7 +299,7 @@ void Core::Entity::Player::teleport( uint16_t aetheryteId, uint8_t type )
 
    setStateFlag( PlayerStateFlag::BetweenAreas );
 
-   auto z_pos = g_territoryMgr.getTerritoryPosition( data->destination );
+   auto z_pos = g_territoryMgr.getTerritoryPosition( data->territory );
 
    Common::FFXIVARR_POSITION3 pos;
    pos.x = 0;
@@ -313,7 +313,8 @@ void Core::Entity::Player::teleport( uint16_t aetheryteId, uint8_t type )
       rot = z_pos->getTargetRotation();
    }
 
-   sendDebug( "Teleport: " + g_exdDataGen.getPlaceName( data->placeName )->name + " " + g_exdDataGen.getPlaceName( data->aethernetName )->name +
+   sendDebug( "Teleport: " + g_exdDataGen.get< Core::Data::PlaceName >( data->placeName )->name + " " +
+                             g_exdDataGen.get< Core::Data::PlaceName >( data->aethernetName )->name +
                "(" + std::to_string( data->territory ) + ")" );
 
    // TODO: this should be simplified and a type created in server_common/common.h.
@@ -492,7 +493,7 @@ void Core::Entity::Player::discover( int16_t map_id, int16_t sub_id )
 
    int32_t offset = 4;
 
-   auto info = g_exdDataGen.getMap( g_exdDataGen.getTerritoryType( getCurrentZone()->getTerritoryId() )->map );
+   auto info = g_exdDataGen.get< Core::Data::Map >( g_exdDataGen.get< Core::Data::TerritoryType >( getCurrentZone()->getTerritoryId() )->map );
    if( info->discoveryArrayByte )
       offset = 4 + 2 * info->discoveryIndex;
    else
@@ -507,7 +508,7 @@ void Core::Entity::Player::discover( int16_t map_id, int16_t sub_id )
 
    uint16_t level = getLevel();
 
-   uint32_t exp = ( g_exdDataGen.getParamGrow( level )->expToNext * 5 / 100 );
+   uint32_t exp = ( g_exdDataGen.get< Core::Data::ParamGrow >( level )->expToNext * 5 / 100 );
 
    gainExp( exp );
 
@@ -584,9 +585,9 @@ void Core::Entity::Player::gainExp( uint32_t amount )
 
    uint16_t level = getLevel();
 
-   uint32_t neededExpToLevel = g_exdDataGen.getParamGrow( level )->expToNext;
+   uint32_t neededExpToLevel = g_exdDataGen.get< Core::Data::ParamGrow >( level )->expToNext;
 
-   uint32_t neededExpToLevelplus1 = g_exdDataGen.getParamGrow( level + 1 )->expToNext;
+   uint32_t neededExpToLevelplus1 = g_exdDataGen.get< Core::Data::ParamGrow >( level + 1 )->expToNext;
 
    queuePacket( ActorControlPacket143( getId(), GainExpMsg, static_cast< uint8_t >( getClass() ), amount ) );
 
@@ -670,25 +671,25 @@ void Core::Entity::Player::sendStatusUpdate( bool toSelf )
 
 uint8_t Core::Entity::Player::getLevel() const
 {
-   uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
+   uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
    return static_cast< uint8_t >( m_classArray[classJobIndex] );
 }
 
 uint8_t Core::Entity::Player::getLevelForClass( Common::ClassJob pClass ) const
 {
-   uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast< uint8_t >( pClass ) )->expArrayIndex;
+   uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( pClass ) )->expArrayIndex;
    return static_cast< uint8_t >( m_classArray[classJobIndex] );
 }
 
 uint32_t Core::Entity::Player::getExp() const
 {
-   uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
+   uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
    return m_expArray[classJobIndex];
 }
 
 void Core::Entity::Player::setExp( uint32_t amount )
 {
-   uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
+   uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
    m_expArray[classJobIndex] = amount;
 }
 
@@ -728,13 +729,13 @@ void Core::Entity::Player::setClassJob( Common::ClassJob classJob )
 
 void Core::Entity::Player::setLevel( uint8_t level )
 {
-   uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
+   uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
    m_classArray[classJobIndex] = level;
 }
 
 void Core::Entity::Player::setLevelForClass( uint8_t level, Common::ClassJob classjob )
 {
-   uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast< uint8_t >( classjob ) )->expArrayIndex;
+   uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( classjob ) )->expArrayIndex;
 
    if( m_classArray[classJobIndex] == 0 )
       insertDbClass( classJobIndex );
@@ -884,7 +885,7 @@ const uint8_t* Core::Entity::Player::getStateFlags() const
 
 bool Core::Entity::Player::actionHasCastTime( uint32_t actionId ) //TODO: Add logic for special cases
 {
-   auto actionInfoPtr = g_exdDataGen.getAction( actionId );
+   auto actionInfoPtr = g_exdDataGen.get< Core::Data::Action >( actionId );
    if( actionInfoPtr->preservesCombo )
       return false;
 

src/servers/sapphire_zone/Actor/PlayerQuest.cpp

@@ -1015,13 +1015,13 @@ void Core::Entity::Player::removeQuestsCompleted( uint32_t questId )
 bool Core::Entity::Player::giveQuestRewards( uint32_t questId, uint32_t optionalChoice )
 {
    uint32_t playerLevel = getLevel();
-   auto questInfo = g_exdDataGen.getQuest( questId );
+   auto questInfo = g_exdDataGen.get< Core::Data::Quest >( questId );
    
 
    if( !questInfo )
       return false;
 
-   auto paramGrowth = g_exdDataGen.getParamGrow( questInfo->classJobLevel0 );
+   auto paramGrowth = g_exdDataGen.get< Core::Data::ParamGrow >( questInfo->classJobLevel0 );
 
    // TODO: use the correct formula, this one is wrong
    uint32_t exp = ( questInfo->expFactor * paramGrowth->questExpModifier * ( 45 + 5 * questInfo->classJobLevel0 ) ) / 100;

src/servers/sapphire_zone/Actor/PlayerSql.cpp

@@ -456,7 +456,7 @@ void Core::Entity::Player::updateSql()
 
 void Core::Entity::Player::updateDbClass() const
 {
-   uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast<uint8_t>( getClass() ) )->expArrayIndex;
+   uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast<uint8_t>( getClass() ) )->expArrayIndex;
 
    //Exp = ?, Lvl = ? WHERE CharacterId = ? AND ClassIdx = ?
    auto stmtS = g_charaDb.getPreparedStatement( Db::CHARA_CLASS_UP );

src/servers/sapphire_zone/DebugCommand/DebugCommandHandler.cpp

@@ -481,7 +481,7 @@ void Core::DebugCommandHandler::get( char * data, Entity::Player& player, boost:
    if( ( subCommand == "pos" ) )
    {
 
-      int16_t map_id = g_exdDataGen.getTerritoryType( player.getCurrentZone()->getTerritoryId() )->map;
+      int16_t map_id = g_exdDataGen.get< Core::Data::TerritoryType >( player.getCurrentZone()->getTerritoryId() )->map;
 
       player.sendNotice( "Pos:\n" +
                          std::to_string( player.getPos().x ) + "\n" +

src/servers/sapphire_zone/Event/EventHelper.cpp

@@ -17,7 +17,7 @@ std::string Core::Event::getEventName( uint32_t eventId )
    {
    case Event::EventHandler::EventHandlerType::Quest:
    {
-      auto questInfo = g_exdDataGen.getQuest( eventId );
+      auto questInfo = g_exdDataGen.get< Core::Data::Quest >( eventId );
       if( !questInfo )
          return unknown + "Quest";
 
@@ -28,7 +28,7 @@ std::string Core::Event::getEventName( uint32_t eventId )
    }
    case Event::EventHandler::EventHandlerType::CustomTalk:
    {
-      auto customTalkInfo = g_exdDataGen.getCustomTalk( eventId );
+      auto customTalkInfo = g_exdDataGen.get< Core::Data::CustomTalk >( eventId );
       if( !customTalkInfo )
          return unknown + "CustomTalk";
 
@@ -39,14 +39,14 @@ std::string Core::Event::getEventName( uint32_t eventId )
    }
    case Event::EventHandler::EventHandlerType::Opening:
    {
-      auto openingInfo = g_exdDataGen.getOpening( eventId );
+      auto openingInfo = g_exdDataGen.get< Core::Data::Opening >( eventId );
       if( openingInfo )
          return openingInfo->name;
       return unknown + "Opening";
    }
    case Event::EventHandler::EventHandlerType::Aetheryte:
    {
-      auto aetherInfo = g_exdDataGen.getAetheryte( eventId & 0xFFFF );
+      auto aetherInfo = g_exdDataGen.get< Core::Data::Aetheryte >( eventId & 0xFFFF );
       if( aetherInfo->isAetheryte )
          return "Aetheryte";
       return "Aethernet";
@@ -65,7 +65,7 @@ std::string Core::Event::getEventName( uint32_t eventId )
 
 uint32_t Core::Event::mapEventActorToRealActor( uint32_t eventActorId )
 {
-   auto levelInfo = g_exdDataGen.getLevel( eventActorId );
+   auto levelInfo = g_exdDataGen.get< Core::Data::Level >( eventActorId );
    if( levelInfo )
       return levelInfo->objectKey;
 

src/servers/sapphire_zone/Inventory/Inventory.cpp

@@ -135,7 +135,7 @@ Core::ItemPtr Core::Inventory::getItemAt( uint16_t containerId, uint8_t slotId )
 
 Core::ItemPtr Core::Inventory::createItem( uint32_t catalogId, uint8_t quantity )
 {
-   auto itemInfo = g_exdDataGen.getItem( catalogId );
+   auto itemInfo = g_exdDataGen.get< Core::Data::Item >( catalogId );
 
    uint8_t itemAmount = quantity;
 
@@ -473,7 +473,7 @@ bool Core::Inventory::isObtainable( uint32_t catalogId, uint8_t quantity )
 int16_t Core::Inventory::addItem( uint16_t inventoryId, int8_t slotId, uint32_t catalogId, uint8_t quantity )
 {
 
-   auto itemInfo = g_exdDataGen.getItem( catalogId );
+   auto itemInfo = g_exdDataGen.get< Core::Data::Item >( catalogId );
 
    // if item data doesn't exist or it's a blank field
    if( !itemInfo || itemInfo->levelItem == 0 )
@@ -656,7 +656,7 @@ Core::ItemPtr Core::Inventory::loadItem( uint64_t uId )
 
    try
    {
-      auto itemInfo = g_exdDataGen.getItem( itemRes->getUInt( 1 ) );
+      auto itemInfo = g_exdDataGen.get< Core::Data::Item >( itemRes->getUInt( 1 ) );
       bool isHq = itemRes->getUInt( 3 ) == 1 ? true : false;
       ItemPtr pItem( new Item( uId, 
                                itemRes->getUInt( 1 ),

src/servers/sapphire_zone/Inventory/Item.cpp

@@ -24,7 +24,7 @@ Core::Item::Item( uint64_t uId, uint32_t catalogId, uint64_t model1, uint64_t mo
    m_model2( model2 ),
    m_isHq( isHq )
 {
-   auto itemInfo = g_exdDataGen.getItem( catalogId );
+   auto itemInfo = g_exdDataGen.get< Core::Data::Item >( catalogId );
    m_delayMs = itemInfo->delayms;
    m_physicalDmg = itemInfo->damagePhys;
    m_magicalDmg = itemInfo->damageMag;

src/servers/sapphire_zone/Math/CalcBattle.cpp

@@ -30,8 +30,8 @@ extern Core::Data::ExdDataGenerated g_exdDataGen;
 
 uint32_t CalcBattle::calculateHealValue( PlayerPtr pPlayer, uint32_t potency )
 {
-   auto classInfo = g_exdDataGen.getClassJob( static_cast< uint8_t >( pPlayer->getClass() ) );
+   auto classInfo = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( pPlayer->getClass() ) );
-   auto paramGrowthInfo = g_exdDataGen.getParamGrow( pPlayer->getLevel() );
+   auto paramGrowthInfo = g_exdDataGen.get< Core::Data::ParamGrow >( pPlayer->getLevel() );
 
    if ( !classInfo || !paramGrowthInfo )
       return 0;

src/servers/sapphire_zone/Math/CalcStats.cpp

@@ -61,8 +61,8 @@ uint32_t CalcStats::calculateMaxHp( PlayerPtr pPlayer )
    // Is there any way to pull reliable BaseHP without having to manually use a pet for every level, and using the values from a table?
    // More info here: https://docs.google.com/spreadsheets/d/1de06KGT0cNRUvyiXNmjNgcNvzBCCQku7jte5QxEQRbs/edit?usp=sharing
    
-   auto classInfo = g_exdDataGen.getClassJob( static_cast< uint8_t >( pPlayer->getClass() ) );
+   auto classInfo = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( pPlayer->getClass() ) );
-   auto paramGrowthInfo = g_exdDataGen.getParamGrow( pPlayer->getLevel() );
+   auto paramGrowthInfo = g_exdDataGen.get< Core::Data::ParamGrow >( pPlayer->getLevel() );
 
    if ( !classInfo || !paramGrowthInfo )
       return 0;
@@ -94,8 +94,8 @@ uint32_t CalcStats::calculateMaxHp( PlayerPtr pPlayer )
 
 uint32_t CalcStats::calculateMaxMp( PlayerPtr pPlayer )
 {
-   auto classInfo = g_exdDataGen.getClassJob( static_cast< uint8_t >( pPlayer->getClass() ) );
+   auto classInfo = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( pPlayer->getClass() ) );
-   auto paramGrowthInfo = g_exdDataGen.getParamGrow( pPlayer->getLevel() );
+   auto paramGrowthInfo = g_exdDataGen.get< Core::Data::ParamGrow >( pPlayer->getLevel() );
 
    if ( !classInfo || !paramGrowthInfo )
       return 0;

src/servers/sapphire_zone/Network/Handlers/ActionHandler.cpp

@@ -200,11 +200,11 @@ void Core::Network::GameConnection::actionHandler( const Packets::GamePacket& in
         case 0xCA: // Teleport
         {
             // TODO: only register this action if enough gil is in possession
-            auto targetAetheryte = g_exdDataGen.getAetheryte( param11 );
+            auto targetAetheryte = g_exdDataGen.get< Core::Data::Aetheryte >( param11 );
 
             if( targetAetheryte )
             {
-               auto fromAetheryte = g_exdDataGen.getAetheryte( g_exdDataGen.getTerritoryType( player.getZoneId() )->aetheryte );
+               auto fromAetheryte = g_exdDataGen.get< Core::Data::Aetheryte >( g_exdDataGen.get< Core::Data::TerritoryType >( player.getZoneId() )->aetheryte );
 
                 // calculate cost - does not apply for favorite points or homepoints neither checks for aether tickets
                 auto cost = static_cast< uint16_t > ( ( sqrt( pow( fromAetheryte->aetherstreamX - targetAetheryte->aetherstreamX, 2 ) +

src/servers/sapphire_zone/Network/Handlers/CFHandlers.cpp

@@ -70,7 +70,7 @@ void Core::Network::GameConnection::cfRegisterDuty( const Packets::GamePacket& i
    cfCancelPacket.data().state2 = 1; // Your registration is withdrawn.
    queueOutPacket( cfCancelPacket );
 
-   auto cfCondition = g_exdDataGen.getContentFinderCondition( contentId1 );
+   auto cfCondition = g_exdDataGen.get< Core::Data::ContentFinderCondition >( contentId1 );
    if( !cfCondition )
       return;
 

src/servers/sapphire_zone/Network/Handlers/EventHandlers.cpp

@@ -52,7 +52,7 @@ void Core::Network::GameConnection::eventHandlerTalk( const Packets::GamePacket&
    if( !g_scriptMgr.onTalk( player, actorId, eventId ) &&
        eventType == Event::EventHandler::EventHandlerType::Quest )
    {
-      auto questInfo = g_exdDataGen.getQuest( eventId );
+      auto questInfo = g_exdDataGen.get< Core::Data::Quest >( eventId );
       if ( questInfo )
          player.sendUrgent( "Quest not implemented: " + questInfo->name + " (" + questInfo->id + ")" );
    }
@@ -87,7 +87,7 @@ void Core::Network::GameConnection::eventHandlerEmote( const Packets::GamePacket
    if( !g_scriptMgr.onEmote( player, actorId, eventId, static_cast< uint8_t >( emoteId ) )  &&
        eventType == Event::EventHandler::EventHandlerType::Quest )
    {
-      auto questInfo = g_exdDataGen.getQuest( eventId );
+      auto questInfo = g_exdDataGen.get< Core::Data::Quest >( eventId );
       if( questInfo )
          player.sendUrgent( "Quest not implemented: " + questInfo->name );
    }

src/servers/sapphire_zone/Network/Handlers/SkillHandler.cpp

@@ -60,7 +60,7 @@ void Core::Network::GameConnection::skillHandler( const Packets::GamePacket& inP
         std::string actionIdStr = boost::str( boost::format( "%|04X|" ) % action );
         player.sendDebug( "---------------------------------------" );
         player.sendDebug( "ActionHandler ( " + actionIdStr + " | " +
-                          g_exdDataGen.getAction( action )->name +
+                          g_exdDataGen.get< Core::Data::Action >( action )->name +
                           " | " + std::to_string( targetId ) + " )" );
 
         player.queuePacket( ActorControlPacket142( player.getId(), ActorControlType::ActionStart, 0x01, action ) );
@@ -100,7 +100,7 @@ void Core::Network::GameConnection::skillHandler( const Packets::GamePacket& inP
     }
     else if( action < 3000000 ) // item action
     {
-        auto info = g_exdDataGen.getEventItem( action );
+        auto info = g_exdDataGen.get< Core::Data::EventItem >( action );
         if( info )
         {
             g_log.debug( info->name );

src/servers/sapphire_zone/Script/ScriptManager.cpp

@@ -154,7 +154,7 @@ bool Core::Scripting::ScriptManager::onTalk( Entity::Player& player, uint64_t ac
    // aethernet/aetherytes need to be handled separately
    if( eventType == Event::EventHandler::EventHandlerType::Aetheryte )
    {
-      auto aetherInfo = g_exdDataGen.getAetheryte( eventId & 0xFFFF );
+      auto aetherInfo = g_exdDataGen.get< Core::Data::Aetheryte >( eventId & 0xFFFF );
       scriptId = EVENTSCRIPT_AETHERYTE_ID;
       if( !aetherInfo->isAetheryte )
          scriptId = EVENTSCRIPT_AETHERNET_ID;

src/servers/sapphire_zone/StatusEffect/StatusEffect.cpp

@@ -30,7 +30,7 @@ Core::StatusEffect::StatusEffect::StatusEffect( uint32_t id, Entity::ActorPtr so
    , m_tickRate( tickRate )
    , m_lastTick( 0 )
 {
-   auto entry = g_exdDataGen.getStatus( id );
+   auto entry = g_exdDataGen.get< Core::Data::Status >( id );
    m_name = entry->name;
       
    std::replace( m_name.begin(), m_name.end(), ' ', '_' );

src/servers/sapphire_zone/Zone/TerritoryMgr.cpp

@@ -25,7 +25,7 @@ void Core::TerritoryMgr::loadTerritoryTypeDetailCache()
 
    for( auto id : idList )
    {
-      auto teri1 = g_exdDataGen.getTerritoryType( id );
+      auto teri1 = g_exdDataGen.get< Core::Data::TerritoryType >( id );
 
       if( !teri1->name.empty() )
          m_territoryTypeDetailCacheMap[id] = teri1;
@@ -106,7 +106,7 @@ bool Core::TerritoryMgr::createDefaultTerritories()
       if( territoryInfo->name.empty() )
          continue;
 
-      auto pPlaceName = g_exdDataGen.getPlaceName( territoryInfo->placeName );
+      auto pPlaceName = g_exdDataGen.get< Core::Data::PlaceName >( territoryInfo->placeName );
 
       if( !pPlaceName || pPlaceName->name.empty() || !isDefaultTerritory( territoryId ) )
          continue;
@@ -142,7 +142,7 @@ Core::ZonePtr Core::TerritoryMgr::createTerritoryInstance( uint32_t territoryTyp
       return nullptr;
 
    auto pTeri = getTerritoryDetail( territoryTypeId );
-   auto pPlaceName = g_exdDataGen.getPlaceName( pTeri->placeName );
+   auto pPlaceName = g_exdDataGen.get< Core::Data::PlaceName >( pTeri->placeName );
 
    if( !pTeri || !pPlaceName )
       return nullptr;
@@ -160,7 +160,7 @@ Core::ZonePtr Core::TerritoryMgr::createTerritoryInstance( uint32_t territoryTyp
 
 Core::ZonePtr Core::TerritoryMgr::createInstanceContent( uint32_t instanceContentId )
 {
-   auto pInstanceContent = g_exdDataGen.getInstanceContent( instanceContentId );
+   auto pInstanceContent = g_exdDataGen.get< Core::Data::InstanceContent >( instanceContentId );
    if( !pInstanceContent )
       return nullptr;
 

src/servers/sapphire_zone/Zone/Zone.cpp

@@ -62,7 +62,7 @@ Core::Zone::Zone( uint16_t territoryId, uint32_t guId, const std::string& intern
    m_lastMobUpdate = 0;
 
    m_weatherOverride = 0;
-   m_territoryTypeInfo = g_exdDataGen.getTerritoryType( territoryId );
+   m_territoryTypeInfo = g_exdDataGen.get< Core::Data::TerritoryType >( territoryId );
 
    uint8_t weatherRateId = m_territoryTypeInfo->weatherRate > g_exdDataGen.getWeatherRateIdList().size() ?
                            uint8_t{ 0 } : m_territoryTypeInfo->weatherRate;

src/tools/exd_struct_gen/ExdData.h.tmpl

@@ -11,6 +11,7 @@
 #include <ExdCat.h>
 #include <Exd.h>
 #include <set>
+#include <boost/make_shared.hpp>
 
 namespace Core {
 namespace Data {

src/tools/exd_struct_gen/ex.json

@@ -532,10 +532,6 @@
             "target": "TerritoryType"
           }
         },
-        {
-          "index": 11,
-          "name": "Destination"
-        },
         {
           "index": 15,
           "name": "IsAetheryte"
@@ -5888,6 +5884,14 @@
             "target": "ClassJobCategory"
           }
         },
+        {
+          "index": 13,
+          "name": "JournalGenre",
+          "converter": {
+            "type": "link",
+            "target": "JournalGenre"
+          }
+        },
         {
           "index": 15,
           "name": "PlaceName{StartZone}",
@@ -6952,6 +6956,15 @@
         }
       ]
     },
+    {
+      "sheet": "OrchestrionCategory",
+      "defaultColumn": "Name",
+      "definitions": [
+        {
+          "name": "Name"
+        }
+      ]
+    },
     {
       "sheet": "OrchestrionPath",
       "definitions": [
@@ -6960,6 +6973,22 @@
         }
       ]
     },
+    {
+      "sheet": "OrchestrionUiparam",
+      "definitions": [
+        {
+          "name": "OrchestrionCategory",
+          "converter": {
+            "type": "link",
+            "target": "OrchestrionCategory"
+          }
+        },
+        {
+          "index": 1,
+          "name": "Order"
+        }
+      ]
+    },
     {
       "sheet": "ParamGrow",
       "definitions": [
@@ -8789,6 +8818,90 @@
       "isGenericReferenceTarget": true,
       "definitions": []
     },
+    {
+      "sheet": "SubmarineExploration",
+      "defaultColumn": "Destination",
+      "definitions": [
+        {
+          "name": "Destination"
+        },
+        {
+          "index": 1,
+          "name": "Location"
+        },
+        {
+          "index": 5,
+          "name": "RankReq"
+        },
+        {
+          "index": 6,
+          "name": "CeruleumTankReq"
+        },
+        {
+          "index": 7,
+          "name": "Duration<min>"
+        },
+        {
+          "index": 8,
+          "name": "DistanceForSurvey"
+        },
+        {
+          "index": 9,
+          "name": "ExpReward"
+        }
+      ]
+    },
+    {
+      "sheet": "SubmarinePart",
+      "defaultColumn": "Slot",
+      "definitions": [
+        {
+          "name": "Slot"
+        },
+        {
+          "index": 1,
+          "name": "Rank"
+        },
+        {
+          "index": 2,
+          "name": "Components"
+        },
+        {
+          "index": 3,
+          "name": "Surveillance"
+        },
+        {
+          "index": 4,
+          "name": "Retrieval"
+        },
+        {
+          "index": 5,
+          "name": "Speed"
+        },
+        {
+          "index": 6,
+          "name": "Range"
+        },
+        {
+          "index": 7,
+          "name": "Favor"
+        },
+        {
+          "index": 9,
+          "name": "RepairMaterials"
+        }
+      ]
+    },
+    {
+      "sheet": "SubmarineRank",
+      "defaultColumn": "Slot",
+      "definitions": [
+        {
+          "index": 1,
+          "name": "ExpToNext"
+        }
+      ]
+    },
     {
       "sheet": "SwitchTalk",
       "isGenericReferenceTarget": true,

src/tools/exd_struct_gen/main.cpp

@@ -31,8 +31,8 @@ Core::Logger g_log;
 Core::Data::ExdData g_exdData;
 bool skipUnmapped = true;
 
-//const std::string datLocation( "/opt/sapphire_3_15_0/bin/sqpack" );
+std::string datLocation( "/opt/sapphire_3_15_0/bin/sqpack" );
-std::string datLocation( "C:\\SquareEnix\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv" );
+//std::string datLocation( "C:\\SquareEnix\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv" );
 std::map< uint8_t, std::string > g_typeMap;
 
 
@@ -48,9 +48,7 @@ std::string generateIdListDecl( const std::string &exd )
 
 std::string generateDirectGetters( const std::string& exd )
 {
-         
+   return "     using " + exd + "Ptr =  boost::shared_ptr< " + exd + " >;\n";
-   return  "     using " + exd + "Ptr =  boost::shared_ptr< " + exd + " >;\n" +
-           "     " + exd + "Ptr get" + exd + "( uint32_t " + exd + "Id );\n";
 }
 
 std::string generateIdListGetter( const std::string &exd )
@@ -77,25 +75,9 @@ std::string generateSetDatAccessCall( const std::string &exd )
    return "      m_" + exd + "Dat = setupDatAccess( \"" + exd + "\", " + lang + " );\n";
 }
 
-std::string generateDirectGetterDef( const std::string& exd )
+std::string generateDirectGetterDef()
 {
    std::string result = "";
-   result =
-      "Core::Data::ExdDataGenerated::" + exd + "Ptr\n"
-      "   Core::Data::ExdDataGenerated::get" + exd + "( uint32_t " + exd + "Id )\n"
-      "{\n"
-      "   try\n"
-      "   {\n"
-      "      auto row = m_" + exd + "Dat.get_row( " + exd + "Id );\n"
-      "      auto info = boost::make_shared< " + exd + " >( " + exd + "Id, this );\n"
-      "      return info;\n"
-      "   }\n"
-      "   catch( ... )\n"
-      "   {\n"
-      "      return nullptr;\n"
-      "   }\n"
-      "   return nullptr;\n"
-      "}\n";
    return result;
 }
 std::map< uint32_t, std::string > indexToNameMap;
@@ -232,9 +214,9 @@ std::string generateConstructorsDecl( const std::string& exd )
    int count = 0;
 
 
-   result += "\n      Core::Data::" + exd + "::" + exd + "( uint32_t row_id, Core::Data::ExdDataGenerated* exdData )\n";
+   result += "\nCore::Data::" + exd + "::" + exd + "( uint32_t row_id, Core::Data::ExdDataGenerated* exdData )\n";
-   result += "      {\n";
+   result += "{\n";
-   std::string indent = "         ";
+   std::string indent = "   ";
    result += indent + "auto row = exdData->m_" + exd + "Dat.get_row( row_id );\n";
    for( auto member : exhMem )
    {  
@@ -263,7 +245,7 @@ std::string generateConstructorsDecl( const std::string& exd )
       }
       count++;
    }
-   result += "      }\n";
+   result += "}\n";
 
    indexToNameMap.clear();
    indexToTypeMap.clear();
@@ -342,11 +324,28 @@ int main( int argc, char** argv )
       idListsDecl += generateIdListDecl( name );
       getterDecl += generateDirectGetters( name );
       datAccCall += generateSetDatAccessCall( name );
-      getterDef += generateDirectGetterDef( name );
       constructorDecl += generateConstructorsDecl( name );
       idListGetters += generateIdListGetter( name );
    }
 
+   getterDecl +=
+      "\n     template< class T >\n"
+      "     boost::shared_ptr< T > get( uint32_t id )\n"
+      "     {\n"
+      "        try\n"
+      "        {\n"
+      "           auto info = boost::make_shared< T >( id, this );\n"
+      "           return info;\n"
+      "        }\n"
+      "        catch( ... )\n"
+      "        {\n"
+      "           return nullptr;\n"
+      "        }\n"
+      "        return nullptr;\n"
+      "     }\n";
+
+   getterDef += generateDirectGetterDef();
+
    // for all sheets in the json i guess....
 
    std::string result;

src/tools/exd_struct_test/ExdData.h.tmpl

@@ -10,6 +10,7 @@
 #include <ExdData.h>
 #include <ExdCat.h>
 #include <Exd.h>
+#include <boost/make_shared.hpp>
 
 namespace Core {
 namespace Data {

src/tools/exd_struct_test/main.cpp

@@ -9,7 +9,7 @@
 #include <iostream>
 #include <cctype>
 #include <set>
-#include <common/Exd/ExdDataGenerated.h>
+#include "ExdDataGenerated.h"
 #include <common/Logging/Logger.h>
 #include <boost/range/algorithm/remove_if.hpp>
 #include <boost/algorithm/string/classification.hpp>
@@ -25,8 +25,8 @@ Core::Logger g_log;
 Core::Data::ExdDataGenerated g_exdData;
 
 
-//const std::string datLocation( "/opt/sapphire_3_15_0/bin/sqpack" );
+const std::string datLocation( "/opt/sapphire_3_15_0/bin/sqpack" );
-const std::string datLocation( "C:\\SquareEnix\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv" );
+//const std::string datLocation( "C:\\SquareEnix\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv" );
 
 
 int main()
@@ -41,14 +41,16 @@ int main()
       return 0;
    }
 
+   
+   g_log.info( "getting id list " );
    auto idList = g_exdData.getTerritoryTypeIdList();
 
+   g_log.info( "getting id list done" );
    for( auto id : idList )
    {
-      auto teri1 = g_exdData.getTerritoryType( id );
+      auto teri1 = g_exdData.get<Core::Data::TerritoryType>( id );
 
       g_log.info( teri1->name );
-      g_log.info( teri1->bg );
    }
 
    return 0;