void f1(const tuple<A1, A2, A3>& t);
void f2(const tuple<B1, B2, B3>& t1, const tuple<A1, A2, A3>& t2);
void main() {
  //...
  tuple<A1, A2, A3> t1 = c1.get();
  tuple<B1, B2, B3> t2 = c2.get();
  f1(t1);
  f2(t2, t1);
}

// Не стоит бездумно использовать этот класс, так как он проектировался с учетом локальной специфики
template<typename T0, typename ...T>
class Tuple {
private:
    template<typename Arg>
    struct ChooseTagType{
        using type = typename std::conditional<IsTuple<Arg>(), TupleChoiseTag, typename std::conditional<IsPair<Arg>(), PairChoiseTag, OtherChoiseTag>::type>::type;
    };
    template<typename T1, typename Arg>
    static T1 getImpl(OtherChoiseTag, Arg &&arg) {
        return arg;
    }
    template<typename T1, typename ...Args>
    static T1 getImpl(PairChoiseTag, const std::pair<Args...> &arg) {
        return std::get<T1>(arg);
    }
    template<typename T1, typename ...Args>
    static T1 getImpl(TupleChoiseTag, const std::tuple<Args...> &arg) {
        return std::get<T1>(arg);
    }
    template<typename T1, typename Arg>
    static T1 get(Arg &&arg) {
        const typename ChooseTagType<Arg>::type t;
        return getImpl<T1>(t, std::forward<Arg>(arg));
    }
    template<typename StdTuple, typename M>
    static auto makeLambda(StdTuple stdTuple) {
        return [stdTuple]() -> M& {
            return *get<M*>(stdTuple);
        };
    }
public:
    template<typename StdTuple>
    Tuple(StdTuple stdTuple) {
        getter = std::make_tuple(
            makeLambda<StdTuple, T0>(stdTuple),
            makeLambda<StdTuple, T>(stdTuple)...
        );
    }
    template<bool B = true, typename Dummy = typename std::enable_if<sizeof...(T) == 0 && B>::type>
    T0& get() {
        return std::get<0>(getter)();
    }
    template<typename M>
    M& get() {
        return std::get<std::function<M&()>>(getter)();
    }
private:
    std::tuple<std::function<T0&()>, std::function<T&()>...> getter;
};

void f1(const Tuple<A1, A2, A3>& t);
void f2(const Tuple<B1, B2, B3>& t1, const Tuple<A1, A3>& t2);
void main() {
  //...
  tuple<A1, A2, A3> t1 = c1.get();
  tuple<B1, B2, B3> t2 = c2.get();
  f1(t1);
  f2(t2, t1);
}

class A {
public:
  A(const string& json);
};

class A {
public:
  A(const string& jsonOrXml, bool isJson);
};

class A {
public:
  A(int i, const string& s)
    : i(i)
    , s(s)
  {}
public:
  static optinal<A> fromJson(const string& s) {
    // parse s
    if (!parsed) {
      return nullopt;
    }
    return A(iField, sField);
  }
  static optional<A> fromXml(const string& s) {
    // parse s
    if (!parsed) {
      return nullopt;
    }
    return A(iField, sField);
  }
private:
  int i;
  string s;
};