/* static */
UsdSchemaExamplesSimple
UsdSchemaExamplesSimple::Get(const UsdStagePtr &stage, const SdfPath &path)
{
    if (not stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdSchemaExamplesSimple();
    }
    return UsdSchemaExamplesSimple(stage->GetPrimAtPath(path));
}

/* static */
UsdHydraPrimvar
UsdHydraPrimvar::Get(const UsdStagePtr &stage, const SdfPath &path)
{
    if (not stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdHydraPrimvar();
    }
    return UsdHydraPrimvar(stage->GetPrimAtPath(path));
}

/* static */
UsdShadeShader
UsdShadeShader::Get(const UsdStagePtr &stage, const SdfPath &path)
{
    if (!stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdShadeShader();
    }
    return UsdShadeShader(stage->GetPrimAtPath(path));
}

/* static */
UsdUISceneGraphPrimAPI
UsdUISceneGraphPrimAPI::Get(const UsdStagePtr &stage, const SdfPath &path)
{
    if (!stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdUISceneGraphPrimAPI();
    }
    return UsdUISceneGraphPrimAPI(stage->GetPrimAtPath(path));
}

/* static */
UsdContrivedEmptyMultipleApplyAPI
UsdContrivedEmptyMultipleApplyAPI::Get(const UsdStagePtr &stage, const SdfPath &path)
{
    if (!stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdContrivedEmptyMultipleApplyAPI();
    }
    return UsdContrivedEmptyMultipleApplyAPI(stage->GetPrimAtPath(path));
}

/* static */
UsdGeomSphere
UsdGeomSphere::Get(const UsdStagePtr &stage, const SdfPath &path)
{
    if (!stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdGeomSphere();
    }
    return UsdGeomSphere(stage->GetPrimAtPath(path));
}

/* static */
UsdRiLightPortalAPI
UsdRiLightPortalAPI::Get(const UsdStagePtr &stage, const SdfPath &path)
{
    if (!stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdRiLightPortalAPI();
    }
    return UsdRiLightPortalAPI(stage->GetPrimAtPath(path));
}

/* static */
UsdContrivedDerived
UsdContrivedDerived::Get(const UsdStagePtr &stage, const SdfPath &path)
{
    if (!stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdContrivedDerived();
    }
    return UsdContrivedDerived(stage->GetPrimAtPath(path));
}

/* static */
UsdGeomNurbsCurves
UsdGeomNurbsCurves::Get(const UsdStagePtr &stage, const SdfPath &path)
{
    if (!stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdGeomNurbsCurves();
    }
    return UsdGeomNurbsCurves(stage->GetPrimAtPath(path));
}

/* static */
UsdSkelRoot
UsdSkelRoot::Get(const UsdStagePtr &stage, const SdfPath &path)
{
    if (!stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdSkelRoot();
    }
    return UsdSkelRoot(stage->GetPrimAtPath(path));
}

/* static */
UsdGeomPointBased
UsdGeomPointBased::Get(const UsdStagePtr &stage, const SdfPath &path)
{
    if (not stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdGeomPointBased();
    }
    return UsdGeomPointBased(stage->GetPrimAtPath(path));
}

/* static */
UsdGeomXformable
UsdGeomXformable::Get(const UsdStagePtr &stage, const SdfPath &path)
{
    if (not stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdGeomXformable();
    }
    return UsdGeomXformable(stage->GetPrimAtPath(path));
}

UsdEditContext::UsdEditContext(const UsdStagePtr &stage,
                               const UsdEditTarget &editTarget)
    : _stage(stage)
    , _originalEditTarget(stage->GetEditTarget())
{
    // Do not check validity of EditTarget: stage will do that and
    // issue an error if invalid.  We DO NOT want people authoring
    // into places they did not expect to be authoring.
    _stage->SetEditTarget(editTarget);
}

void
GusdPrimWrapper::addLeadingBookend( double curFrame, double startFrame )
{
    if( curFrame != startFrame ) {
        double bookendFrame = curFrame - TIME_SAMPLE_DELTA;

        // Ensure the stage start frame <= bookendFrame
        UsdStagePtr stage = getUsdPrimForWrite().GetPrim().GetStage();
        if(stage) {
            double startFrame = stage->GetStartTimeCode();
            if( startFrame > bookendFrame) {
                stage->SetStartTimeCode(bookendFrame);
            }
        }

        getUsdPrimForWrite().GetVisibilityAttr().Set(UsdGeomTokens->invisible,
                                       UsdTimeCode(bookendFrame));
        getUsdPrimForWrite().GetVisibilityAttr().Set(UsdGeomTokens->inherited,
                                       UsdTimeCode(curFrame));   
    }
}

/* static */
UsdGeomCylinder
UsdGeomCylinder::Define(
    const UsdStagePtr &stage, const SdfPath &path)
{
    static TfToken usdPrimTypeName("Cylinder");
    if (not stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdGeomCylinder();
    }
    return UsdGeomCylinder(
        stage->DefinePrim(path, usdPrimTypeName));
}

/* static */
UsdContrivedDerived
UsdContrivedDerived::Define(
    const UsdStagePtr &stage, const SdfPath &path)
{
    static TfToken usdPrimTypeName("Derived");
    if (!stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdContrivedDerived();
    }
    return UsdContrivedDerived(
        stage->DefinePrim(path, usdPrimTypeName));
}

/* static */
UsdGeomNurbsCurves
UsdGeomNurbsCurves::Define(
    const UsdStagePtr &stage, const SdfPath &path)
{
    static TfToken usdPrimTypeName("NurbsCurves");
    if (!stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdGeomNurbsCurves();
    }
    return UsdGeomNurbsCurves(
        stage->DefinePrim(path, usdPrimTypeName));
}

/* static */
UsdGeomSphere
UsdGeomSphere::Define(
    const UsdStagePtr &stage, const SdfPath &path)
{
    static TfToken usdPrimTypeName("Sphere");
    if (!stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdGeomSphere();
    }
    return UsdGeomSphere(
        stage->DefinePrim(path, usdPrimTypeName));
}

/* static */
UsdSkelRoot
UsdSkelRoot::Define(
    const UsdStagePtr &stage, const SdfPath &path)
{
    static TfToken usdPrimTypeName("SkelRoot");
    if (!stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdSkelRoot();
    }
    return UsdSkelRoot(
        stage->DefinePrim(path, usdPrimTypeName));
}

/* static */
UsdGeomXformCommonAPI
UsdGeomXformCommonAPI::Get(const UsdStagePtr &stage, const SdfPath &path)
{
    if (!stage) {
        TF_CODING_ERROR("Invalid stage");
        return UsdGeomXformCommonAPI();
    }

    UsdGeomXformable xformable(stage->GetPrimAtPath(path));

    return UsdGeomXformCommonAPI(xformable);
}